1 /* Process declarations and variables for C++ compiler.
2 Copyright (C) 1988-2013 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 /* Process declarations and symbol lookup for C++ front end.
23 Also constructs types; the standard scalar types at initialization,
24 and structure, union, array and enum types when they are declared. */
26 /* ??? not all decl nodes are given the most useful possible
27 line numbers. For example, the CONST_DECLs for enum values. */
31 #include "coretypes.h"
36 #include "tree-iterator.h"
37 #include "tree-inline.h"
44 #include "c-family/c-common.h"
45 #include "c-family/c-objc.h"
46 #include "c-family/c-pragma.h"
47 #include "diagnostic.h"
51 #include "pointer-set.h"
52 #include "splay-tree.h"
56 /* Possible cases of bad specifiers type used by bad_specifiers. */
58 BSP_VAR
, /* variable */
59 BSP_PARM
, /* parameter */
64 static tree
grokparms (tree parmlist
, tree
*);
65 static const char *redeclaration_error_message (tree
, tree
);
67 static int decl_jump_unsafe (tree
);
68 static void require_complete_types_for_parms (tree
);
69 static int ambi_op_p (enum tree_code
);
70 static int unary_op_p (enum tree_code
);
71 static void push_local_name (tree
);
72 static tree
grok_reference_init (tree
, tree
, tree
, int);
73 static tree
grokvardecl (tree
, tree
, const cp_decl_specifier_seq
*,
75 static int check_static_variable_definition (tree
, tree
);
76 static void record_unknown_type (tree
, const char *);
77 static tree
builtin_function_1 (tree
, tree
, bool);
78 static tree
build_library_fn_1 (tree
, enum tree_code
, tree
);
79 static int member_function_or_else (tree
, tree
, enum overload_flags
);
80 static void bad_specifiers (tree
, enum bad_spec_place
, int, int, int, int,
82 static void check_for_uninitialized_const_var (tree
);
83 static hashval_t
typename_hash (const void *);
84 static int typename_compare (const void *, const void *);
85 static tree
local_variable_p_walkfn (tree
*, int *, void *);
86 static tree
record_builtin_java_type (const char *, int);
87 static const char *tag_name (enum tag_types
);
88 static tree
lookup_and_check_tag (enum tag_types
, tree
, tag_scope
, bool);
89 static int walk_namespaces_r (tree
, walk_namespaces_fn
, void *);
90 static void maybe_deduce_size_from_array_init (tree
, tree
);
91 static void layout_var_decl (tree
);
92 static tree
check_initializer (tree
, tree
, int, vec
<tree
, va_gc
> **);
93 static void make_rtl_for_nonlocal_decl (tree
, tree
, const char *);
94 static void save_function_data (tree
);
95 static void copy_type_enum (tree
, tree
);
96 static void check_function_type (tree
, tree
);
97 static void finish_constructor_body (void);
98 static void begin_destructor_body (void);
99 static void finish_destructor_body (void);
100 static void record_key_method_defined (tree
);
101 static tree
create_array_type_for_decl (tree
, tree
, tree
);
102 static tree
get_atexit_node (void);
103 static tree
get_dso_handle_node (void);
104 static tree
start_cleanup_fn (void);
105 static void end_cleanup_fn (void);
106 static tree
cp_make_fname_decl (location_t
, tree
, int);
107 static void initialize_predefined_identifiers (void);
108 static tree check_special_function_return_type
109 (special_function_kind
, tree
, tree
);
110 static tree
push_cp_library_fn (enum tree_code
, tree
);
111 static tree
build_cp_library_fn (tree
, enum tree_code
, tree
);
112 static void store_parm_decls (tree
);
113 static void initialize_local_var (tree
, tree
);
114 static void expand_static_init (tree
, tree
);
116 /* The following symbols are subsumed in the cp_global_trees array, and
117 listed here individually for documentation purposes.
120 tree wchar_decl_node;
122 tree vtable_entry_type;
123 tree delta_type_node;
124 tree __t_desc_type_node;
126 tree class_type_node;
127 tree unknown_type_node;
129 Array type `vtable_entry_type[]'
132 tree vtbl_ptr_type_node;
139 A FUNCTION_DECL which can call `abort'. Not necessarily the
140 one that the user will declare, but sufficient to be called
141 by routines that want to abort the program.
145 The FUNCTION_DECL for the default `::operator delete'.
147 tree global_delete_fndecl;
150 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
151 tree tinfo_var_id; */
153 tree cp_global_trees
[CPTI_MAX
];
155 /* Indicates that there is a type value in some namespace, although
156 that is not necessarily in scope at the moment. */
158 tree global_type_node
;
160 /* The node that holds the "name" of the global scope. */
161 tree global_scope_name
;
163 #define local_names cp_function_chain->x_local_names
165 /* A list of objects which have constructors or destructors
166 which reside in the global scope. The decl is stored in
167 the TREE_VALUE slot and the initializer is stored
168 in the TREE_PURPOSE slot. */
169 tree static_aggregates
;
171 /* Like static_aggregates, but for thread_local variables. */
176 /* A node for the integer constant 2. */
178 tree integer_two_node
;
180 /* Used only for jumps to as-yet undefined labels, since jumps to
181 defined labels can have their validity checked immediately. */
183 struct GTY((chain_next ("%h.next"))) named_label_use_entry
{
184 struct named_label_use_entry
*next
;
185 /* The binding level to which this entry is *currently* attached.
186 This is initially the binding level in which the goto appeared,
187 but is modified as scopes are closed. */
188 cp_binding_level
*binding_level
;
189 /* The head of the names list that was current when the goto appeared,
190 or the inner scope popped. These are the decls that will *not* be
191 skipped when jumping to the label. */
193 /* The location of the goto, for error reporting. */
194 location_t o_goto_locus
;
195 /* True if an OpenMP structured block scope has been closed since
196 the goto appeared. This means that the branch from the label will
197 illegally exit an OpenMP scope. */
201 /* A list of all LABEL_DECLs in the function that have names. Here so
202 we can clear out their names' definitions at the end of the
203 function, and so we can check the validity of jumps to these labels. */
205 struct GTY(()) named_label_entry
{
206 /* The decl itself. */
209 /* The binding level to which the label is *currently* attached.
210 This is initially set to the binding level in which the label
211 is defined, but is modified as scopes are closed. */
212 cp_binding_level
*binding_level
;
213 /* The head of the names list that was current when the label was
214 defined, or the inner scope popped. These are the decls that will
215 be skipped when jumping to the label. */
217 /* A vector of all decls from all binding levels that would be
218 crossed by a backward branch to the label. */
219 vec
<tree
, va_gc
> *bad_decls
;
221 /* A list of uses of the label, before the label is defined. */
222 struct named_label_use_entry
*uses
;
224 /* The following bits are set after the label is defined, and are
225 updated as scopes are popped. They indicate that a backward jump
226 to the label will illegally enter a scope of the given flavor. */
232 #define named_labels cp_function_chain->x_named_labels
234 /* The number of function bodies which we are currently processing.
235 (Zero if we are at namespace scope, one inside the body of a
236 function, two inside the body of a function in a local class, etc.) */
239 /* To avoid unwanted recursion, finish_function defers all mark_used calls
240 encountered during its execution until it finishes. */
241 bool defer_mark_used_calls
;
242 vec
<tree
, va_gc
> *deferred_mark_used_calls
;
244 /* States indicating how grokdeclarator() should handle declspecs marked
245 with __attribute__((deprecated)). An object declared as
246 __attribute__((deprecated)) suppresses warnings of uses of other
248 enum deprecated_states deprecated_state
= DEPRECATED_NORMAL
;
251 /* A list of VAR_DECLs whose type was incomplete at the time the
252 variable was declared. */
254 typedef struct GTY(()) incomplete_var_d
{
256 tree incomplete_type
;
260 static GTY(()) vec
<incomplete_var
, va_gc
> *incomplete_vars
;
262 /* Returns the kind of template specialization we are currently
263 processing, given that it's declaration contained N_CLASS_SCOPES
264 explicit scope qualifications. */
267 current_tmpl_spec_kind (int n_class_scopes
)
269 int n_template_parm_scopes
= 0;
270 int seen_specialization_p
= 0;
271 int innermost_specialization_p
= 0;
274 /* Scan through the template parameter scopes. */
275 for (b
= current_binding_level
;
276 b
->kind
== sk_template_parms
;
279 /* If we see a specialization scope inside a parameter scope,
280 then something is wrong. That corresponds to a declaration
283 template <class T> template <> ...
285 which is always invalid since [temp.expl.spec] forbids the
286 specialization of a class member template if the enclosing
287 class templates are not explicitly specialized as well. */
288 if (b
->explicit_spec_p
)
290 if (n_template_parm_scopes
== 0)
291 innermost_specialization_p
= 1;
293 seen_specialization_p
= 1;
295 else if (seen_specialization_p
== 1)
296 return tsk_invalid_member_spec
;
298 ++n_template_parm_scopes
;
301 /* Handle explicit instantiations. */
302 if (processing_explicit_instantiation
)
304 if (n_template_parm_scopes
!= 0)
305 /* We've seen a template parameter list during an explicit
306 instantiation. For example:
308 template <class T> template void f(int);
310 This is erroneous. */
311 return tsk_invalid_expl_inst
;
313 return tsk_expl_inst
;
316 if (n_template_parm_scopes
< n_class_scopes
)
317 /* We've not seen enough template headers to match all the
318 specialized classes present. For example:
320 template <class T> void R<T>::S<T>::f(int);
322 This is invalid; there needs to be one set of template
323 parameters for each class. */
324 return tsk_insufficient_parms
;
325 else if (n_template_parm_scopes
== n_class_scopes
)
326 /* We're processing a non-template declaration (even though it may
327 be a member of a template class.) For example:
329 template <class T> void S<T>::f(int);
331 The `class T' matches the `S<T>', leaving no template headers
332 corresponding to the `f'. */
334 else if (n_template_parm_scopes
> n_class_scopes
+ 1)
335 /* We've got too many template headers. For example:
337 template <> template <class T> void f (T);
339 There need to be more enclosing classes. */
340 return tsk_excessive_parms
;
342 /* This must be a template. It's of the form:
344 template <class T> template <class U> void S<T>::f(U);
346 This is a specialization if the innermost level was a
347 specialization; otherwise it's just a definition of the
349 return innermost_specialization_p
? tsk_expl_spec
: tsk_template
;
352 /* Exit the current scope. */
360 /* When a label goes out of scope, check to see if that label was used
361 in a valid manner, and issue any appropriate warnings or errors. */
364 pop_label (tree label
, tree old_value
)
366 if (!processing_template_decl
)
368 if (DECL_INITIAL (label
) == NULL_TREE
)
372 error ("label %q+D used but not defined", label
);
373 location
= input_location
; /* FIXME want (input_filename, (line)0) */
374 /* Avoid crashing later. */
375 define_label (location
, DECL_NAME (label
));
378 warn_for_unused_label (label
);
381 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label
), old_value
);
384 /* At the end of a function, all labels declared within the function
385 go out of scope. BLOCK is the top-level block for the
389 pop_labels_1 (void **slot
, void *data
)
391 struct named_label_entry
*ent
= (struct named_label_entry
*) *slot
;
392 tree block
= (tree
) data
;
394 pop_label (ent
->label_decl
, NULL_TREE
);
396 /* Put the labels into the "variables" of the top-level block,
397 so debugger can see them. */
398 DECL_CHAIN (ent
->label_decl
) = BLOCK_VARS (block
);
399 BLOCK_VARS (block
) = ent
->label_decl
;
401 htab_clear_slot (named_labels
, slot
);
407 pop_labels (tree block
)
411 htab_traverse (named_labels
, pop_labels_1
, block
);
416 /* At the end of a block with local labels, restore the outer definition. */
419 pop_local_label (tree label
, tree old_value
)
421 struct named_label_entry dummy
;
424 pop_label (label
, old_value
);
426 dummy
.label_decl
= label
;
427 slot
= htab_find_slot (named_labels
, &dummy
, NO_INSERT
);
428 htab_clear_slot (named_labels
, slot
);
431 /* The following two routines are used to interface to Objective-C++.
432 The binding level is purposely treated as an opaque type. */
435 objc_get_current_scope (void)
437 return current_binding_level
;
440 /* The following routine is used by the NeXT-style SJLJ exceptions;
441 variables get marked 'volatile' so as to not be clobbered by
442 _setjmp()/_longjmp() calls. All variables in the current scope,
443 as well as parent scopes up to (but not including) ENCLOSING_BLK
444 shall be thusly marked. */
447 objc_mark_locals_volatile (void *enclosing_blk
)
449 cp_binding_level
*scope
;
451 for (scope
= current_binding_level
;
452 scope
&& scope
!= enclosing_blk
;
453 scope
= scope
->level_chain
)
457 for (decl
= scope
->names
; decl
; decl
= TREE_CHAIN (decl
))
458 objc_volatilize_decl (decl
);
460 /* Do not climb up past the current function. */
461 if (scope
->kind
== sk_function_parms
)
466 /* Update data for defined and undefined labels when leaving a scope. */
469 poplevel_named_label_1 (void **slot
, void *data
)
471 struct named_label_entry
*ent
= (struct named_label_entry
*) *slot
;
472 cp_binding_level
*bl
= (cp_binding_level
*) data
;
473 cp_binding_level
*obl
= bl
->level_chain
;
475 if (ent
->binding_level
== bl
)
479 /* ENT->NAMES_IN_SCOPE may contain a mixture of DECLs and
480 TREE_LISTs representing OVERLOADs, so be careful. */
481 for (decl
= ent
->names_in_scope
; decl
; decl
= (DECL_P (decl
)
483 : TREE_CHAIN (decl
)))
484 if (decl_jump_unsafe (decl
))
485 vec_safe_push (ent
->bad_decls
, decl
);
487 ent
->binding_level
= obl
;
488 ent
->names_in_scope
= obl
->names
;
492 ent
->in_try_scope
= true;
495 ent
->in_catch_scope
= true;
498 ent
->in_omp_scope
= true;
506 struct named_label_use_entry
*use
;
508 for (use
= ent
->uses
; use
; use
= use
->next
)
509 if (use
->binding_level
== bl
)
511 use
->binding_level
= obl
;
512 use
->names_in_scope
= obl
->names
;
513 if (bl
->kind
== sk_omp
)
514 use
->in_omp_scope
= true;
521 /* Saved errorcount to avoid -Wunused-but-set-{parameter,variable} warnings
522 when errors were reported, except for -Werror-unused-but-set-*. */
523 static int unused_but_set_errorcount
;
525 /* Exit a binding level.
526 Pop the level off, and restore the state of the identifier-decl mappings
527 that were in effect when this level was entered.
529 If KEEP == 1, this level had explicit declarations, so
530 and create a "block" (a BLOCK node) for the level
531 to record its declarations and subblocks for symbol table output.
533 If FUNCTIONBODY is nonzero, this level is the body of a function,
534 so create a block as if KEEP were set and also clear out all
537 If REVERSE is nonzero, reverse the order of decls before putting
538 them into the BLOCK. */
541 poplevel (int keep
, int reverse
, int functionbody
)
544 /* The chain of decls was accumulated in reverse order.
545 Put it into forward order, just for cleanliness. */
550 int leaving_for_scope
;
553 cp_label_binding
*label_bind
;
555 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
560 gcc_assert (current_binding_level
->kind
!= sk_class
);
562 if (current_binding_level
->kind
== sk_cleanup
)
564 subblocks
= functionbody
>= 0 ? current_binding_level
->blocks
: 0;
566 gcc_assert (!vec_safe_length (current_binding_level
->class_shadowed
));
568 /* We used to use KEEP == 2 to indicate that the new block should go
569 at the beginning of the list of blocks at this binding level,
570 rather than the end. This hack is no longer used. */
571 gcc_assert (keep
== 0 || keep
== 1);
573 if (current_binding_level
->keep
)
576 /* Any uses of undefined labels, and any defined labels, now operate
577 under constraints of next binding contour. */
578 if (cfun
&& !functionbody
&& named_labels
)
579 htab_traverse (named_labels
, poplevel_named_label_1
,
580 current_binding_level
);
582 /* Get the decls in the order they were written.
583 Usually current_binding_level->names is in reverse order.
584 But parameter decls were previously put in forward order. */
587 current_binding_level
->names
588 = decls
= nreverse (current_binding_level
->names
);
590 decls
= current_binding_level
->names
;
592 /* If there were any declarations or structure tags in that level,
593 or if this level is a function body,
594 create a BLOCK to record them for the life of this function. */
596 if (keep
== 1 || functionbody
)
597 block
= make_node (BLOCK
);
598 if (block
!= NULL_TREE
)
600 BLOCK_VARS (block
) = decls
;
601 BLOCK_SUBBLOCKS (block
) = subblocks
;
604 /* In each subblock, record that this is its superior. */
606 for (link
= subblocks
; link
; link
= BLOCK_CHAIN (link
))
607 BLOCK_SUPERCONTEXT (link
) = block
;
609 /* We still support the old for-scope rules, whereby the variables
610 in a for-init statement were in scope after the for-statement
611 ended. We only use the new rules if flag_new_for_scope is
614 = current_binding_level
->kind
== sk_for
&& flag_new_for_scope
== 1;
616 /* Before we remove the declarations first check for unused variables. */
617 if ((warn_unused_variable
|| warn_unused_but_set_variable
)
618 && !processing_template_decl
)
619 for (tree d
= getdecls (); d
; d
= TREE_CHAIN (d
))
621 /* There are cases where D itself is a TREE_LIST. See in
622 push_local_binding where the list of decls returned by
623 getdecls is built. */
624 decl
= TREE_CODE (d
) == TREE_LIST
? TREE_VALUE (d
) : d
;
626 && (! TREE_USED (decl
) || !DECL_READ_P (decl
))
627 && ! DECL_IN_SYSTEM_HEADER (decl
)
628 && DECL_NAME (decl
) && ! DECL_ARTIFICIAL (decl
)
629 && TREE_TYPE (decl
) != error_mark_node
630 && (!CLASS_TYPE_P (TREE_TYPE (decl
))
631 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
))))
633 if (! TREE_USED (decl
))
634 warning (OPT_Wunused_variable
, "unused variable %q+D", decl
);
635 else if (DECL_CONTEXT (decl
) == current_function_decl
636 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
637 && errorcount
== unused_but_set_errorcount
)
639 warning (OPT_Wunused_but_set_variable
,
640 "variable %q+D set but not used", decl
);
641 unused_but_set_errorcount
= errorcount
;
646 /* Remove declarations for all the DECLs in this level. */
647 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
649 if (leaving_for_scope
&& VAR_P (link
)
650 /* It's hard to make this ARM compatibility hack play nicely with
651 lambdas, and it really isn't necessary in C++11 mode. */
652 && cxx_dialect
< cxx0x
655 tree name
= DECL_NAME (link
);
659 ob
= outer_binding (name
,
660 IDENTIFIER_BINDING (name
),
663 ns_binding
= IDENTIFIER_NAMESPACE_VALUE (name
);
665 ns_binding
= NULL_TREE
;
667 if (ob
&& ob
->scope
== current_binding_level
->level_chain
)
668 /* We have something like:
673 and we are leaving the `for' scope. There's no reason to
674 keep the binding of the inner `i' in this case. */
675 pop_binding (name
, link
);
676 else if ((ob
&& (TREE_CODE (ob
->value
) == TYPE_DECL
))
677 || (ns_binding
&& TREE_CODE (ns_binding
) == TYPE_DECL
))
678 /* Here, we have something like:
686 We must pop the for-scope binding so we know what's a
687 type and what isn't. */
688 pop_binding (name
, link
);
691 /* Mark this VAR_DECL as dead so that we can tell we left it
692 there only for backward compatibility. */
693 DECL_DEAD_FOR_LOCAL (link
) = 1;
695 /* Keep track of what should have happened when we
696 popped the binding. */
699 SET_DECL_SHADOWED_FOR_VAR (link
, ob
->value
);
700 DECL_HAS_SHADOWED_FOR_VAR_P (link
) = 1;
703 /* Add it to the list of dead variables in the next
704 outermost binding to that we can remove these when we
705 leave that binding. */
707 current_binding_level
->level_chain
->dead_vars_from_for
,
710 /* Although we don't pop the cxx_binding, we do clear
711 its SCOPE since the scope is going away now. */
712 IDENTIFIER_BINDING (name
)->scope
713 = current_binding_level
->level_chain
;
720 /* Remove the binding. */
723 if (TREE_CODE (decl
) == TREE_LIST
)
724 decl
= TREE_VALUE (decl
);
727 if (TREE_CODE (name
) == OVERLOAD
)
728 name
= OVL_FUNCTION (name
);
730 gcc_assert (DECL_P (name
));
731 pop_binding (DECL_NAME (name
), decl
);
735 /* Remove declarations for any `for' variables from inner scopes
736 that we kept around. */
737 FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level
->dead_vars_from_for
,
739 pop_binding (DECL_NAME (decl
), decl
);
741 /* Restore the IDENTIFIER_TYPE_VALUEs. */
742 for (link
= current_binding_level
->type_shadowed
;
743 link
; link
= TREE_CHAIN (link
))
744 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
746 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
747 FOR_EACH_VEC_SAFE_ELT_REVERSE (current_binding_level
->shadowed_labels
,
749 pop_local_label (label_bind
->label
, label_bind
->prev_value
);
751 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
752 list if a `using' declaration put them there. The debugging
753 back ends won't understand OVERLOAD, so we remove them here.
754 Because the BLOCK_VARS are (temporarily) shared with
755 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
756 popped all the bindings. */
761 for (d
= &BLOCK_VARS (block
); *d
; )
763 if (TREE_CODE (*d
) == TREE_LIST
)
764 *d
= TREE_CHAIN (*d
);
766 d
= &DECL_CHAIN (*d
);
770 /* If the level being exited is the top level of a function,
771 check over all the labels. */
774 /* Since this is the top level block of a function, the vars are
775 the function's parameters. Don't leave them in the BLOCK
776 because they are found in the FUNCTION_DECL instead. */
777 BLOCK_VARS (block
) = 0;
781 kind
= current_binding_level
->kind
;
782 if (kind
== sk_cleanup
)
786 /* If this is a temporary binding created for a cleanup, then we'll
787 have pushed a statement list level. Pop that, create a new
788 BIND_EXPR for the block, and insert it into the stream. */
789 stmt
= pop_stmt_list (current_binding_level
->statement_list
);
790 stmt
= c_build_bind_expr (input_location
, block
, stmt
);
797 /* The current function is being defined, so its DECL_INITIAL
798 should be error_mark_node. */
799 gcc_assert (DECL_INITIAL (current_function_decl
) == error_mark_node
);
800 DECL_INITIAL (current_function_decl
) = block
;
803 current_binding_level
->blocks
804 = block_chainon (current_binding_level
->blocks
, block
);
806 /* If we did not make a block for the level just exited,
807 any blocks made for inner levels
808 (since they cannot be recorded as subblocks in that level)
809 must be carried forward so they will later become subblocks
810 of something else. */
812 current_binding_level
->blocks
813 = block_chainon (current_binding_level
->blocks
, subblocks
);
815 /* Each and every BLOCK node created here in `poplevel' is important
816 (e.g. for proper debugging information) so if we created one
817 earlier, mark it as "used". */
819 TREE_USED (block
) = 1;
821 /* All temporary bindings created for cleanups are popped silently. */
822 if (kind
== sk_cleanup
)
825 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
829 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
830 itself, calling F for each. The DATA is passed to F as well. */
833 walk_namespaces_r (tree name_space
, walk_namespaces_fn f
, void* data
)
836 tree current
= NAMESPACE_LEVEL (name_space
)->namespaces
;
838 result
|= (*f
) (name_space
, data
);
840 for (; current
; current
= DECL_CHAIN (current
))
841 result
|= walk_namespaces_r (current
, f
, data
);
846 /* Walk all the namespaces, calling F for each. The DATA is passed to
850 walk_namespaces (walk_namespaces_fn f
, void* data
)
852 return walk_namespaces_r (global_namespace
, f
, data
);
855 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
856 DATA is non-NULL, this is the last time we will call
857 wrapup_global_declarations for this NAMESPACE. */
860 wrapup_globals_for_namespace (tree name_space
, void* data
)
862 cp_binding_level
*level
= NAMESPACE_LEVEL (name_space
);
863 vec
<tree
, va_gc
> *statics
= level
->static_decls
;
864 tree
*vec
= statics
->address ();
865 int len
= statics
->length ();
866 int last_time
= (data
!= 0);
870 check_global_declarations (vec
, len
);
871 emit_debug_global_declarations (vec
, len
);
875 /* Write out any globals that need to be output. */
876 return wrapup_global_declarations (vec
, len
);
880 /* In C++, you don't have to write `struct S' to refer to `S'; you
881 can just use `S'. We accomplish this by creating a TYPE_DECL as
882 if the user had written `typedef struct S S'. Create and return
883 the TYPE_DECL for TYPE. */
886 create_implicit_typedef (tree name
, tree type
)
890 decl
= build_decl (input_location
, TYPE_DECL
, name
, type
);
891 DECL_ARTIFICIAL (decl
) = 1;
892 /* There are other implicit type declarations, like the one *within*
893 a class that allows you to write `S::S'. We must distinguish
895 SET_DECL_IMPLICIT_TYPEDEF_P (decl
);
896 TYPE_NAME (type
) = decl
;
897 TYPE_STUB_DECL (type
) = decl
;
902 /* Remember a local name for name-mangling purposes. */
905 push_local_name (tree decl
)
910 timevar_start (TV_NAME_LOOKUP
);
912 name
= DECL_NAME (decl
);
914 nelts
= vec_safe_length (local_names
);
915 for (i
= 0; i
< nelts
; i
++)
917 t
= (*local_names
)[i
];
918 if (DECL_NAME (t
) == name
)
920 if (!DECL_LANG_SPECIFIC (decl
))
921 retrofit_lang_decl (decl
);
922 DECL_LANG_SPECIFIC (decl
)->u
.base
.u2sel
= 1;
923 if (DECL_DISCRIMINATOR_SET_P (t
))
924 DECL_DISCRIMINATOR (decl
) = DECL_DISCRIMINATOR (t
) + 1;
926 DECL_DISCRIMINATOR (decl
) = 1;
928 (*local_names
)[i
] = decl
;
929 timevar_stop (TV_NAME_LOOKUP
);
934 vec_safe_push (local_names
, decl
);
935 timevar_stop (TV_NAME_LOOKUP
);
938 /* Subroutine of duplicate_decls: return truthvalue of whether
939 or not types of these decls match.
941 For C++, we must compare the parameter list so that `int' can match
942 `int&' in a parameter position, but `int&' is not confused with
946 decls_match (tree newdecl
, tree olddecl
)
950 if (newdecl
== olddecl
)
953 if (TREE_CODE (newdecl
) != TREE_CODE (olddecl
))
954 /* If the two DECLs are not even the same kind of thing, we're not
955 interested in their types. */
958 gcc_assert (DECL_P (newdecl
));
960 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
962 tree f1
= TREE_TYPE (newdecl
);
963 tree f2
= TREE_TYPE (olddecl
);
964 tree p1
= TYPE_ARG_TYPES (f1
);
965 tree p2
= TYPE_ARG_TYPES (f2
);
968 /* Specializations of different templates are different functions
969 even if they have the same type. */
970 tree t1
= (DECL_USE_TEMPLATE (newdecl
)
971 ? DECL_TI_TEMPLATE (newdecl
)
973 tree t2
= (DECL_USE_TEMPLATE (olddecl
)
974 ? DECL_TI_TEMPLATE (olddecl
)
979 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
980 && ! (DECL_EXTERN_C_P (newdecl
)
981 && DECL_EXTERN_C_P (olddecl
)))
984 /* A new declaration doesn't match a built-in one unless it
985 is also extern "C". */
986 if (DECL_IS_BUILTIN (olddecl
)
987 && DECL_EXTERN_C_P (olddecl
) && !DECL_EXTERN_C_P (newdecl
))
990 if (TREE_CODE (f1
) != TREE_CODE (f2
))
993 /* A declaration with deduced return type should use its pre-deduction
994 type for declaration matching. */
995 if (FNDECL_USED_AUTO (olddecl
))
996 r2
= DECL_STRUCT_FUNCTION (olddecl
)->language
->x_auto_return_pattern
;
1000 if (same_type_p (TREE_TYPE (f1
), r2
))
1002 if (!prototype_p (f2
) && DECL_EXTERN_C_P (olddecl
)
1003 && (DECL_BUILT_IN (olddecl
)
1004 #ifndef NO_IMPLICIT_EXTERN_C
1005 || (DECL_IN_SYSTEM_HEADER (newdecl
) && !DECL_CLASS_SCOPE_P (newdecl
))
1006 || (DECL_IN_SYSTEM_HEADER (olddecl
) && !DECL_CLASS_SCOPE_P (olddecl
))
1010 types_match
= self_promoting_args_p (p1
);
1011 if (p1
== void_list_node
)
1012 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
1014 #ifndef NO_IMPLICIT_EXTERN_C
1015 else if (!prototype_p (f1
)
1016 && (DECL_EXTERN_C_P (olddecl
)
1017 && DECL_IN_SYSTEM_HEADER (olddecl
)
1018 && !DECL_CLASS_SCOPE_P (olddecl
))
1019 && (DECL_EXTERN_C_P (newdecl
)
1020 && DECL_IN_SYSTEM_HEADER (newdecl
)
1021 && !DECL_CLASS_SCOPE_P (newdecl
)))
1023 types_match
= self_promoting_args_p (p2
);
1024 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
1030 && (TYPE_ATTRIBUTES (TREE_TYPE (newdecl
)) == NULL_TREE
1031 || comp_type_attributes (TREE_TYPE (newdecl
),
1032 TREE_TYPE (olddecl
)) != 0);
1037 /* The decls dont match if they correspond to two different versions
1038 of the same function. Disallow extern "C" functions to be
1039 versions for now. */
1041 && !DECL_EXTERN_C_P (newdecl
)
1042 && !DECL_EXTERN_C_P (olddecl
)
1043 && targetm
.target_option
.function_versions (newdecl
, olddecl
))
1045 /* Mark functions as versions if necessary. Modify the mangled decl
1046 name if necessary. */
1047 if (DECL_FUNCTION_VERSIONED (newdecl
)
1048 && DECL_FUNCTION_VERSIONED (olddecl
))
1050 if (!DECL_FUNCTION_VERSIONED (newdecl
))
1052 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
1053 if (DECL_ASSEMBLER_NAME_SET_P (newdecl
))
1054 mangle_decl (newdecl
);
1056 if (!DECL_FUNCTION_VERSIONED (olddecl
))
1058 DECL_FUNCTION_VERSIONED (olddecl
) = 1;
1059 if (DECL_ASSEMBLER_NAME_SET_P (olddecl
))
1060 mangle_decl (olddecl
);
1062 record_function_versions (olddecl
, newdecl
);
1066 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1068 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
))
1069 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)))
1072 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1073 DECL_TEMPLATE_PARMS (olddecl
)))
1076 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1077 types_match
= same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
)),
1078 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
)));
1080 types_match
= decls_match (DECL_TEMPLATE_RESULT (olddecl
),
1081 DECL_TEMPLATE_RESULT (newdecl
));
1085 /* Need to check scope for variable declaration (VAR_DECL).
1086 For typedef (TYPE_DECL), scope is ignored. */
1088 && CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
1090 Two declarations for an object with C language linkage
1091 with the same name (ignoring the namespace that qualify
1092 it) that appear in different namespace scopes refer to
1094 && !(DECL_EXTERN_C_P (olddecl
) && DECL_EXTERN_C_P (newdecl
)))
1097 if (TREE_TYPE (newdecl
) == error_mark_node
)
1098 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
1099 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
1100 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
1101 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
1104 types_match
= comptypes (TREE_TYPE (newdecl
),
1105 TREE_TYPE (olddecl
),
1106 COMPARE_REDECLARATION
);
1112 /* If NEWDECL is `static' and an `extern' was seen previously,
1113 warn about it. OLDDECL is the previous declaration.
1115 Note that this does not apply to the C++ case of declaring
1116 a variable `extern const' and then later `const'.
1118 Don't complain about built-in functions, since they are beyond
1119 the user's control. */
1122 warn_extern_redeclared_static (tree newdecl
, tree olddecl
)
1124 if (TREE_CODE (newdecl
) == TYPE_DECL
1125 || TREE_CODE (newdecl
) == TEMPLATE_DECL
1126 || TREE_CODE (newdecl
) == CONST_DECL
1127 || TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1130 /* Don't get confused by static member functions; that's a different
1132 if (TREE_CODE (newdecl
) == FUNCTION_DECL
1133 && DECL_STATIC_FUNCTION_P (newdecl
))
1136 /* If the old declaration was `static', or the new one isn't, then
1137 everything is OK. */
1138 if (DECL_THIS_STATIC (olddecl
) || !DECL_THIS_STATIC (newdecl
))
1141 /* It's OK to declare a builtin function as `static'. */
1142 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1143 && DECL_ARTIFICIAL (olddecl
))
1146 permerror (input_location
, "%qD was declared %<extern%> and later %<static%>", newdecl
);
1147 permerror (input_location
, "previous declaration of %q+D", olddecl
);
1150 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1151 function templates. If their exception specifications do not
1152 match, issue a diagnostic. */
1155 check_redeclaration_exception_specification (tree new_decl
,
1160 tree new_exceptions
;
1161 tree old_exceptions
;
1163 new_type
= TREE_TYPE (new_decl
);
1164 new_exceptions
= TYPE_RAISES_EXCEPTIONS (new_type
);
1165 old_type
= TREE_TYPE (old_decl
);
1166 old_exceptions
= TYPE_RAISES_EXCEPTIONS (old_type
);
1170 If any declaration of a function has an exception-specification,
1171 all declarations, including the definition and an explicit
1172 specialization, of that function shall have an
1173 exception-specification with the same set of type-ids. */
1174 if ((pedantic
|| ! DECL_IN_SYSTEM_HEADER (old_decl
))
1175 && ! DECL_IS_BUILTIN (old_decl
)
1177 && !comp_except_specs (new_exceptions
, old_exceptions
, ce_normal
))
1179 error ("declaration of %qF has a different exception specifier",
1181 error ("from previous declaration %q+F", old_decl
);
1185 /* Return true if OLD_DECL and NEW_DECL agree on constexprness.
1186 Otherwise issue diagnostics. */
1189 validate_constexpr_redeclaration (tree old_decl
, tree new_decl
)
1191 old_decl
= STRIP_TEMPLATE (old_decl
);
1192 new_decl
= STRIP_TEMPLATE (new_decl
);
1193 if (!VAR_OR_FUNCTION_DECL_P (old_decl
)
1194 || !VAR_OR_FUNCTION_DECL_P (new_decl
))
1196 if (DECL_DECLARED_CONSTEXPR_P (old_decl
)
1197 == DECL_DECLARED_CONSTEXPR_P (new_decl
))
1199 if (TREE_CODE (old_decl
) == FUNCTION_DECL
&& DECL_BUILT_IN (old_decl
))
1201 /* Hide a built-in declaration. */
1202 DECL_DECLARED_CONSTEXPR_P (old_decl
)
1203 = DECL_DECLARED_CONSTEXPR_P (new_decl
);
1206 error ("redeclaration %qD differs in %<constexpr%>", new_decl
);
1207 error ("from previous declaration %q+D", old_decl
);
1211 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1212 && lookup_attribute ("gnu_inline", \
1213 DECL_ATTRIBUTES (fn)))
1215 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1216 If the redeclaration is invalid, a diagnostic is issued, and the
1217 error_mark_node is returned. Otherwise, OLDDECL is returned.
1219 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1222 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1225 duplicate_decls (tree newdecl
, tree olddecl
, bool newdecl_is_friend
)
1227 unsigned olddecl_uid
= DECL_UID (olddecl
);
1228 int olddecl_friend
= 0, types_match
= 0, hidden_friend
= 0;
1229 int new_defines_function
= 0;
1230 tree new_template_info
;
1232 if (newdecl
== olddecl
)
1235 types_match
= decls_match (newdecl
, olddecl
);
1237 /* If either the type of the new decl or the type of the old decl is an
1238 error_mark_node, then that implies that we have already issued an
1239 error (earlier) for some bogus type specification, and in that case,
1240 it is rather pointless to harass the user with yet more error message
1241 about the same declaration, so just pretend the types match here. */
1242 if (TREE_TYPE (newdecl
) == error_mark_node
1243 || TREE_TYPE (olddecl
) == error_mark_node
)
1244 return error_mark_node
;
1246 if (UDLIT_OPER_P (DECL_NAME (newdecl
))
1247 && UDLIT_OPER_P (DECL_NAME (olddecl
)))
1249 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
1250 && TREE_CODE (olddecl
) != TEMPLATE_DECL
1251 && check_raw_literal_operator (olddecl
))
1252 error ("literal operator template %q+D conflicts with"
1253 " raw literal operator %qD", newdecl
, olddecl
);
1254 else if (TREE_CODE (newdecl
) != TEMPLATE_DECL
1255 && TREE_CODE (olddecl
) == TEMPLATE_DECL
1256 && check_raw_literal_operator (newdecl
))
1257 error ("raw literal operator %q+D conflicts with"
1258 " literal operator template %qD", newdecl
, olddecl
);
1261 if (DECL_P (olddecl
)
1262 && TREE_CODE (newdecl
) == FUNCTION_DECL
1263 && TREE_CODE (olddecl
) == FUNCTION_DECL
1264 && (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
)))
1266 if (DECL_DECLARED_INLINE_P (newdecl
)
1267 && DECL_UNINLINABLE (newdecl
)
1268 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
1269 /* Already warned elsewhere. */;
1270 else if (DECL_DECLARED_INLINE_P (olddecl
)
1271 && DECL_UNINLINABLE (olddecl
)
1272 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
1273 /* Already warned. */;
1274 else if (DECL_DECLARED_INLINE_P (newdecl
)
1275 && DECL_UNINLINABLE (olddecl
)
1276 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
1278 warning (OPT_Wattributes
, "function %q+D redeclared as inline",
1280 warning (OPT_Wattributes
, "previous declaration of %q+D "
1281 "with attribute noinline", olddecl
);
1283 else if (DECL_DECLARED_INLINE_P (olddecl
)
1284 && DECL_UNINLINABLE (newdecl
)
1285 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
1287 warning (OPT_Wattributes
, "function %q+D redeclared with "
1288 "attribute noinline", newdecl
);
1289 warning (OPT_Wattributes
, "previous declaration of %q+D was inline",
1294 /* Check for redeclaration and other discrepancies. */
1295 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1296 && DECL_ARTIFICIAL (olddecl
))
1298 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl
));
1299 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
1301 /* Avoid warnings redeclaring built-ins which have not been
1302 explicitly declared. */
1303 if (DECL_ANTICIPATED (olddecl
))
1306 /* If you declare a built-in or predefined function name as static,
1307 the old definition is overridden, but optionally warn this was a
1308 bad choice of name. */
1309 if (! TREE_PUBLIC (newdecl
))
1311 warning (OPT_Wshadow
,
1312 DECL_BUILT_IN (olddecl
)
1313 ? G_("shadowing built-in function %q#D")
1314 : G_("shadowing library function %q#D"), olddecl
);
1315 /* Discard the old built-in function. */
1318 /* If the built-in is not ansi, then programs can override
1319 it even globally without an error. */
1320 else if (! DECL_BUILT_IN (olddecl
))
1321 warning (0, "library function %q#D redeclared as non-function %q#D",
1325 error ("declaration of %q#D", newdecl
);
1326 error ("conflicts with built-in declaration %q#D",
1331 else if (!types_match
)
1333 /* Avoid warnings redeclaring built-ins which have not been
1334 explicitly declared. */
1335 if (DECL_ANTICIPATED (olddecl
))
1337 /* Deal with fileptr_type_node. FILE type is not known
1338 at the time we create the builtins. */
1341 for (t1
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1342 t2
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1344 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1347 else if (TREE_VALUE (t2
) == fileptr_type_node
)
1349 tree t
= TREE_VALUE (t1
);
1352 && TYPE_NAME (TREE_TYPE (t
))
1353 && DECL_NAME (TYPE_NAME (TREE_TYPE (t
)))
1354 == get_identifier ("FILE")
1355 && compparms (TREE_CHAIN (t1
), TREE_CHAIN (t2
)))
1357 tree oldargs
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1359 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))
1360 = TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
1361 types_match
= decls_match (newdecl
, olddecl
);
1363 return duplicate_decls (newdecl
, olddecl
,
1365 TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) = oldargs
;
1368 else if (! same_type_p (TREE_VALUE (t1
), TREE_VALUE (t2
)))
1371 else if ((DECL_EXTERN_C_P (newdecl
)
1372 && DECL_EXTERN_C_P (olddecl
))
1373 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1374 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
1376 /* A near match; override the builtin. */
1378 if (TREE_PUBLIC (newdecl
))
1380 warning (0, "new declaration %q#D", newdecl
);
1381 warning (0, "ambiguates built-in declaration %q#D",
1385 warning (OPT_Wshadow
,
1386 DECL_BUILT_IN (olddecl
)
1387 ? G_("shadowing built-in function %q#D")
1388 : G_("shadowing library function %q#D"), olddecl
);
1391 /* Discard the old built-in function. */
1394 /* Replace the old RTL to avoid problems with inlining. */
1395 COPY_DECL_RTL (newdecl
, olddecl
);
1397 /* Even if the types match, prefer the new declarations type for
1398 built-ins which have not been explicitly declared, for
1399 exception lists, etc... */
1400 else if (DECL_IS_BUILTIN (olddecl
))
1402 tree type
= TREE_TYPE (newdecl
);
1403 tree attribs
= (*targetm
.merge_type_attributes
)
1404 (TREE_TYPE (olddecl
), type
);
1406 type
= cp_build_type_attribute_variant (type
, attribs
);
1407 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = type
;
1410 /* If a function is explicitly declared "throw ()", propagate that to
1411 the corresponding builtin. */
1412 if (DECL_BUILT_IN_CLASS (olddecl
) == BUILT_IN_NORMAL
1413 && DECL_ANTICIPATED (olddecl
)
1414 && TREE_NOTHROW (newdecl
)
1415 && !TREE_NOTHROW (olddecl
))
1417 enum built_in_function fncode
= DECL_FUNCTION_CODE (olddecl
);
1418 tree tmpdecl
= builtin_decl_explicit (fncode
);
1419 if (tmpdecl
&& tmpdecl
!= olddecl
&& types_match
)
1420 TREE_NOTHROW (tmpdecl
) = 1;
1423 /* Whether or not the builtin can throw exceptions has no
1424 bearing on this declarator. */
1425 TREE_NOTHROW (olddecl
) = 0;
1427 if (DECL_THIS_STATIC (newdecl
) && !DECL_THIS_STATIC (olddecl
))
1429 /* If a builtin function is redeclared as `static', merge
1430 the declarations, but make the original one static. */
1431 DECL_THIS_STATIC (olddecl
) = 1;
1432 TREE_PUBLIC (olddecl
) = 0;
1434 /* Make the old declaration consistent with the new one so
1435 that all remnants of the builtin-ness of this function
1436 will be banished. */
1437 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
1438 COPY_DECL_RTL (newdecl
, olddecl
);
1441 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
1443 /* C++ Standard, 3.3, clause 4:
1444 "[Note: a namespace name or a class template name must be unique
1445 in its declarative region (7.3.2, clause 14). ]" */
1446 if (TREE_CODE (olddecl
) != NAMESPACE_DECL
1447 && TREE_CODE (newdecl
) != NAMESPACE_DECL
1448 && (TREE_CODE (olddecl
) != TEMPLATE_DECL
1449 || TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) != TYPE_DECL
)
1450 && (TREE_CODE (newdecl
) != TEMPLATE_DECL
1451 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != TYPE_DECL
))
1453 if ((TREE_CODE (olddecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (olddecl
)
1454 && TREE_CODE (newdecl
) != TYPE_DECL
)
1455 || (TREE_CODE (newdecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (newdecl
)
1456 && TREE_CODE (olddecl
) != TYPE_DECL
))
1458 /* We do nothing special here, because C++ does such nasty
1459 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1460 get shadowed, and know that if we need to find a TYPE_DECL
1461 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1462 slot of the identifier. */
1466 if ((TREE_CODE (newdecl
) == FUNCTION_DECL
1467 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
1468 || (TREE_CODE (olddecl
) == FUNCTION_DECL
1469 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
1473 error ("%q#D redeclared as different kind of symbol", newdecl
);
1474 if (TREE_CODE (olddecl
) == TREE_LIST
)
1475 olddecl
= TREE_VALUE (olddecl
);
1476 error ("previous declaration of %q+#D", olddecl
);
1478 return error_mark_node
;
1480 else if (!types_match
)
1482 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
))
1483 /* These are certainly not duplicate declarations; they're
1484 from different scopes. */
1487 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1489 /* The name of a class template may not be declared to refer to
1490 any other template, class, function, object, namespace, value,
1491 or type in the same scope. */
1492 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
1493 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1495 error ("declaration of template %q#D", newdecl
);
1496 error ("conflicts with previous declaration %q+#D", olddecl
);
1497 return error_mark_node
;
1499 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
1500 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
1501 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
1502 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))))
1503 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1504 DECL_TEMPLATE_PARMS (olddecl
))
1505 /* Template functions can be disambiguated by
1507 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl
)),
1508 TREE_TYPE (TREE_TYPE (olddecl
))))
1510 error ("new declaration %q#D", newdecl
);
1511 error ("ambiguates old declaration %q+#D", olddecl
);
1515 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1517 if (DECL_EXTERN_C_P (newdecl
) && DECL_EXTERN_C_P (olddecl
))
1519 error ("declaration of C function %q#D conflicts with",
1521 error ("previous declaration %q+#D here", olddecl
);
1524 /* For function versions, params and types match, but they
1525 are not ambiguous. */
1526 else if ((!DECL_FUNCTION_VERSIONED (newdecl
)
1527 && !DECL_FUNCTION_VERSIONED (olddecl
))
1528 && compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1529 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
1531 error ("new declaration %q#D", newdecl
);
1532 if (FNDECL_USED_AUTO (olddecl
))
1533 error_at (DECL_SOURCE_LOCATION (olddecl
), "ambiguates old "
1534 "declaration with deduced return type");
1536 error ("ambiguates old declaration %q+#D", olddecl
);
1537 return error_mark_node
;
1544 error ("conflicting declaration %q#D", newdecl
);
1545 error ("%q+D has a previous declaration as %q#D", olddecl
, olddecl
);
1546 return error_mark_node
;
1549 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1550 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
1551 && (!DECL_TEMPLATE_INFO (newdecl
)
1552 || (DECL_TI_TEMPLATE (newdecl
)
1553 != DECL_TI_TEMPLATE (olddecl
))))
1554 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1555 && (!DECL_TEMPLATE_INFO (olddecl
)
1556 || (DECL_TI_TEMPLATE (olddecl
)
1557 != DECL_TI_TEMPLATE (newdecl
))))))
1558 /* It's OK to have a template specialization and a non-template
1559 with the same type, or to have specializations of two
1560 different templates with the same type. Note that if one is a
1561 specialization, and the other is an instantiation of the same
1562 template, that we do not exit at this point. That situation
1563 can occur if we instantiate a template class, and then
1564 specialize one of its methods. This situation is valid, but
1565 the declarations must be merged in the usual way. */
1567 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1568 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
1569 && !DECL_USE_TEMPLATE (newdecl
))
1570 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
1571 && !DECL_USE_TEMPLATE (olddecl
))))
1572 /* One of the declarations is a template instantiation, and the
1573 other is not a template at all. That's OK. */
1575 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1577 /* In [namespace.alias] we have:
1579 In a declarative region, a namespace-alias-definition can be
1580 used to redefine a namespace-alias declared in that declarative
1581 region to refer only to the namespace to which it already
1584 Therefore, if we encounter a second alias directive for the same
1585 alias, we can just ignore the second directive. */
1586 if (DECL_NAMESPACE_ALIAS (newdecl
)
1587 && (DECL_NAMESPACE_ALIAS (newdecl
)
1588 == DECL_NAMESPACE_ALIAS (olddecl
)))
1590 /* [namespace.alias]
1592 A namespace-name or namespace-alias shall not be declared as
1593 the name of any other entity in the same declarative region.
1594 A namespace-name defined at global scope shall not be
1595 declared as the name of any other entity in any global scope
1597 error ("declaration of namespace %qD conflicts with", newdecl
);
1598 error ("previous declaration of namespace %q+D here", olddecl
);
1599 return error_mark_node
;
1603 const char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
1606 error_at (DECL_SOURCE_LOCATION (newdecl
), errmsg
, newdecl
);
1607 if (DECL_NAME (olddecl
) != NULL_TREE
)
1608 error ((DECL_INITIAL (olddecl
) && namespace_bindings_p ())
1609 ? G_("%q+#D previously defined here")
1610 : G_("%q+#D previously declared here"), olddecl
);
1611 return error_mark_node
;
1613 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1614 && DECL_INITIAL (olddecl
) != NULL_TREE
1615 && !prototype_p (TREE_TYPE (olddecl
))
1616 && prototype_p (TREE_TYPE (newdecl
)))
1618 /* Prototype decl follows defn w/o prototype. */
1619 warning_at (input_location
, 0, "prototype for %q+#D", newdecl
);
1620 warning_at (DECL_SOURCE_LOCATION (olddecl
), 0,
1621 "follows non-prototype definition here");
1623 else if (VAR_OR_FUNCTION_DECL_P (olddecl
)
1624 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
1627 If two declarations of the same function or object
1628 specify different linkage-specifications ..., the program
1629 is ill-formed.... Except for functions with C++ linkage,
1630 a function declaration without a linkage specification
1631 shall not precede the first linkage specification for
1632 that function. A function can be declared without a
1633 linkage specification after an explicit linkage
1634 specification has been seen; the linkage explicitly
1635 specified in the earlier declaration is not affected by
1636 such a function declaration.
1638 DR 563 raises the question why the restrictions on
1639 functions should not also apply to objects. Older
1640 versions of G++ silently ignore the linkage-specification
1648 which is clearly wrong. Therefore, we now treat objects
1650 if (current_lang_depth () == 0)
1652 /* There is no explicit linkage-specification, so we use
1653 the linkage from the previous declaration. */
1654 if (!DECL_LANG_SPECIFIC (newdecl
))
1655 retrofit_lang_decl (newdecl
);
1656 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
1660 error ("previous declaration of %q+#D with %qL linkage",
1661 olddecl
, DECL_LANGUAGE (olddecl
));
1662 error ("conflicts with new declaration with %qL linkage",
1663 DECL_LANGUAGE (newdecl
));
1667 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
1669 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
1671 tree t1
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1672 tree t2
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
1675 if (TREE_CODE (TREE_TYPE (newdecl
)) == METHOD_TYPE
)
1676 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
);
1678 for (; t1
&& t1
!= void_list_node
;
1679 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
1680 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
1682 if (1 == simple_cst_equal (TREE_PURPOSE (t1
),
1685 permerror (input_location
, "default argument given for parameter %d of %q#D",
1687 permerror (input_location
, "after previous specification in %q+#D", olddecl
);
1691 error ("default argument given for parameter %d of %q#D",
1693 error ("after previous specification in %q+#D",
1700 /* Do not merge an implicit typedef with an explicit one. In:
1704 typedef class A A __attribute__ ((foo));
1706 the attribute should apply only to the typedef. */
1707 if (TREE_CODE (olddecl
) == TYPE_DECL
1708 && (DECL_IMPLICIT_TYPEDEF_P (olddecl
)
1709 || DECL_IMPLICIT_TYPEDEF_P (newdecl
)))
1712 /* If new decl is `static' and an `extern' was seen previously,
1714 warn_extern_redeclared_static (newdecl
, olddecl
);
1716 if (!validate_constexpr_redeclaration (olddecl
, newdecl
))
1717 return error_mark_node
;
1719 /* We have committed to returning 1 at this point. */
1720 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1722 /* Now that functions must hold information normally held
1723 by field decls, there is extra work to do so that
1724 declaration information does not get destroyed during
1726 if (DECL_VINDEX (olddecl
))
1727 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
1728 if (DECL_CONTEXT (olddecl
))
1729 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
1730 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
1731 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
1732 DECL_PURE_VIRTUAL_P (newdecl
) |= DECL_PURE_VIRTUAL_P (olddecl
);
1733 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
1734 DECL_INVALID_OVERRIDER_P (newdecl
) |= DECL_INVALID_OVERRIDER_P (olddecl
);
1735 DECL_THIS_STATIC (newdecl
) |= DECL_THIS_STATIC (olddecl
);
1736 if (DECL_OVERLOADED_OPERATOR_P (olddecl
) != ERROR_MARK
)
1737 SET_OVERLOADED_OPERATOR_CODE
1738 (newdecl
, DECL_OVERLOADED_OPERATOR_P (olddecl
));
1739 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
1741 /* Optionally warn about more than one declaration for the same
1742 name, but don't warn about a function declaration followed by a
1744 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
1745 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
1746 /* Don't warn about extern decl followed by definition. */
1747 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
1748 /* Don't warn about friends, let add_friend take care of it. */
1749 && ! (newdecl_is_friend
|| DECL_FRIEND_P (olddecl
))
1750 /* Don't warn about declaration followed by specialization. */
1751 && (! DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1752 || DECL_TEMPLATE_SPECIALIZATION (olddecl
)))
1754 warning (OPT_Wredundant_decls
, "redundant redeclaration of %qD in same scope", newdecl
);
1755 warning (OPT_Wredundant_decls
, "previous declaration of %q+D", olddecl
);
1758 if (DECL_DELETED_FN (newdecl
))
1760 error ("deleted definition of %qD", newdecl
);
1761 error ("after previous declaration %q+D", olddecl
);
1763 DECL_DELETED_FN (newdecl
) |= DECL_DELETED_FN (olddecl
);
1766 /* Deal with C++: must preserve virtual function table size. */
1767 if (TREE_CODE (olddecl
) == TYPE_DECL
)
1769 tree newtype
= TREE_TYPE (newdecl
);
1770 tree oldtype
= TREE_TYPE (olddecl
);
1772 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
1773 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
1774 CLASSTYPE_FRIEND_CLASSES (newtype
)
1775 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
1777 DECL_ORIGINAL_TYPE (newdecl
) = DECL_ORIGINAL_TYPE (olddecl
);
1780 /* Copy all the DECL_... slots specified in the new decl
1781 except for any that we copy here from the old type. */
1782 DECL_ATTRIBUTES (newdecl
)
1783 = (*targetm
.merge_decl_attributes
) (olddecl
, newdecl
);
1785 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1789 old_result
= DECL_TEMPLATE_RESULT (olddecl
);
1790 new_result
= DECL_TEMPLATE_RESULT (newdecl
);
1791 TREE_TYPE (olddecl
) = TREE_TYPE (old_result
);
1792 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
1793 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
1794 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
1796 DECL_ATTRIBUTES (old_result
)
1797 = (*targetm
.merge_decl_attributes
) (old_result
, new_result
);
1799 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
1801 if (GNU_INLINE_P (old_result
) != GNU_INLINE_P (new_result
)
1802 && DECL_INITIAL (new_result
))
1804 if (DECL_INITIAL (old_result
))
1805 DECL_UNINLINABLE (old_result
) = 1;
1807 DECL_UNINLINABLE (old_result
) = DECL_UNINLINABLE (new_result
);
1808 DECL_EXTERNAL (old_result
) = DECL_EXTERNAL (new_result
);
1809 DECL_NOT_REALLY_EXTERN (old_result
)
1810 = DECL_NOT_REALLY_EXTERN (new_result
);
1811 DECL_INTERFACE_KNOWN (old_result
)
1812 = DECL_INTERFACE_KNOWN (new_result
);
1813 DECL_DECLARED_INLINE_P (old_result
)
1814 = DECL_DECLARED_INLINE_P (new_result
);
1815 DECL_DISREGARD_INLINE_LIMITS (old_result
)
1816 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
1821 DECL_DECLARED_INLINE_P (old_result
)
1822 |= DECL_DECLARED_INLINE_P (new_result
);
1823 DECL_DISREGARD_INLINE_LIMITS (old_result
)
1824 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
1825 check_redeclaration_exception_specification (newdecl
, olddecl
);
1829 /* If the new declaration is a definition, update the file and
1830 line information on the declaration, and also make
1831 the old declaration the same definition. */
1832 if (DECL_INITIAL (new_result
) != NULL_TREE
)
1834 DECL_SOURCE_LOCATION (olddecl
)
1835 = DECL_SOURCE_LOCATION (old_result
)
1836 = DECL_SOURCE_LOCATION (newdecl
);
1837 DECL_INITIAL (old_result
) = DECL_INITIAL (new_result
);
1838 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
1841 DECL_ARGUMENTS (old_result
)
1842 = DECL_ARGUMENTS (new_result
);
1843 for (parm
= DECL_ARGUMENTS (old_result
); parm
;
1844 parm
= DECL_CHAIN (parm
))
1845 DECL_CONTEXT (parm
) = old_result
;
1854 /* Automatically handles default parameters. */
1855 tree oldtype
= TREE_TYPE (olddecl
);
1858 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1859 maybe_instantiate_noexcept (olddecl
);
1861 /* Merge the data types specified in the two decls. */
1862 newtype
= merge_types (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
1864 /* If merge_types produces a non-typedef type, just use the old type. */
1865 if (TREE_CODE (newdecl
) == TYPE_DECL
1866 && newtype
== DECL_ORIGINAL_TYPE (newdecl
))
1869 if (VAR_P (newdecl
))
1871 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
1872 DECL_INITIALIZED_P (newdecl
) |= DECL_INITIALIZED_P (olddecl
);
1873 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl
)
1874 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl
);
1875 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl
)
1876 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl
);
1878 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
1879 if (DECL_LANG_SPECIFIC (olddecl
)
1880 && CP_DECL_THREADPRIVATE_P (olddecl
))
1882 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
1883 if (!DECL_LANG_SPECIFIC (newdecl
))
1884 retrofit_lang_decl (newdecl
);
1886 DECL_TLS_MODEL (newdecl
) = DECL_TLS_MODEL (olddecl
);
1887 CP_DECL_THREADPRIVATE_P (newdecl
) = 1;
1891 /* Do this after calling `merge_types' so that default
1892 parameters don't confuse us. */
1893 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1894 check_redeclaration_exception_specification (newdecl
, olddecl
);
1895 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
1897 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1898 check_default_args (newdecl
);
1900 /* Lay the type out, unless already done. */
1901 if (! same_type_p (newtype
, oldtype
)
1902 && TREE_TYPE (newdecl
) != error_mark_node
1903 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
1904 layout_type (TREE_TYPE (newdecl
));
1906 if ((VAR_P (newdecl
)
1907 || TREE_CODE (newdecl
) == PARM_DECL
1908 || TREE_CODE (newdecl
) == RESULT_DECL
1909 || TREE_CODE (newdecl
) == FIELD_DECL
1910 || TREE_CODE (newdecl
) == TYPE_DECL
)
1911 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
1912 layout_decl (newdecl
, 0);
1914 /* Merge the type qualifiers. */
1915 if (TREE_READONLY (newdecl
))
1916 TREE_READONLY (olddecl
) = 1;
1917 if (TREE_THIS_VOLATILE (newdecl
))
1918 TREE_THIS_VOLATILE (olddecl
) = 1;
1919 if (TREE_NOTHROW (newdecl
))
1920 TREE_NOTHROW (olddecl
) = 1;
1922 /* Merge deprecatedness. */
1923 if (TREE_DEPRECATED (newdecl
))
1924 TREE_DEPRECATED (olddecl
) = 1;
1926 /* Preserve function specific target and optimization options */
1927 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1929 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl
)
1930 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl
))
1931 DECL_FUNCTION_SPECIFIC_TARGET (newdecl
)
1932 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl
);
1934 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
)
1935 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
))
1936 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
)
1937 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
);
1940 /* Merge the initialization information. */
1941 if (DECL_INITIAL (newdecl
) == NULL_TREE
1942 && DECL_INITIAL (olddecl
) != NULL_TREE
)
1944 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
1945 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
1946 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1948 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
1949 DECL_STRUCT_FUNCTION (newdecl
) = DECL_STRUCT_FUNCTION (olddecl
);
1953 /* Merge the section attribute.
1954 We want to issue an error if the sections conflict but that must be
1955 done later in decl_attributes since we are called before attributes
1957 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
1958 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
1960 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1962 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
1963 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
1964 DECL_NO_LIMIT_STACK (newdecl
) |= DECL_NO_LIMIT_STACK (olddecl
);
1965 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
1966 TREE_NOTHROW (newdecl
) |= TREE_NOTHROW (olddecl
);
1967 DECL_IS_MALLOC (newdecl
) |= DECL_IS_MALLOC (olddecl
);
1968 DECL_IS_OPERATOR_NEW (newdecl
) |= DECL_IS_OPERATOR_NEW (olddecl
);
1969 DECL_PURE_P (newdecl
) |= DECL_PURE_P (olddecl
);
1970 TREE_READONLY (newdecl
) |= TREE_READONLY (olddecl
);
1971 DECL_LOOPING_CONST_OR_PURE_P (newdecl
)
1972 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl
);
1973 /* Keep the old RTL. */
1974 COPY_DECL_RTL (olddecl
, newdecl
);
1976 else if (VAR_P (newdecl
)
1977 && (DECL_SIZE (olddecl
) || !DECL_SIZE (newdecl
)))
1979 /* Keep the old RTL. We cannot keep the old RTL if the old
1980 declaration was for an incomplete object and the new
1981 declaration is not since many attributes of the RTL will
1983 COPY_DECL_RTL (olddecl
, newdecl
);
1986 /* If cannot merge, then use the new type and qualifiers,
1987 and don't preserve the old rtl. */
1990 /* Clean out any memory we had of the old declaration. */
1991 tree oldstatic
= value_member (olddecl
, static_aggregates
);
1993 TREE_VALUE (oldstatic
) = error_mark_node
;
1995 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
1996 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
1997 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
1998 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
2001 /* Merge the storage class information. */
2002 merge_weak (newdecl
, olddecl
);
2004 if (DECL_ONE_ONLY (olddecl
))
2005 DECL_COMDAT_GROUP (newdecl
) = DECL_COMDAT_GROUP (olddecl
);
2007 DECL_DEFER_OUTPUT (newdecl
) |= DECL_DEFER_OUTPUT (olddecl
);
2008 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
2009 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
2010 if (! DECL_EXTERNAL (olddecl
))
2011 DECL_EXTERNAL (newdecl
) = 0;
2013 new_template_info
= NULL_TREE
;
2014 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
2016 bool new_redefines_gnu_inline
= false;
2018 if (new_defines_function
2019 && ((DECL_INTERFACE_KNOWN (olddecl
)
2020 && TREE_CODE (olddecl
) == FUNCTION_DECL
)
2021 || (TREE_CODE (olddecl
) == TEMPLATE_DECL
2022 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
2023 == FUNCTION_DECL
))))
2027 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
2028 fn
= DECL_TEMPLATE_RESULT (olddecl
);
2030 new_redefines_gnu_inline
= GNU_INLINE_P (fn
) && DECL_INITIAL (fn
);
2033 if (!new_redefines_gnu_inline
)
2035 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
2036 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
2037 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
2039 DECL_TEMPLATE_INSTANTIATED (newdecl
)
2040 |= DECL_TEMPLATE_INSTANTIATED (olddecl
);
2041 DECL_ODR_USED (newdecl
) |= DECL_ODR_USED (olddecl
);
2043 /* If the OLDDECL is an instantiation and/or specialization,
2044 then the NEWDECL must be too. But, it may not yet be marked
2045 as such if the caller has created NEWDECL, but has not yet
2046 figured out that it is a redeclaration. */
2047 if (!DECL_USE_TEMPLATE (newdecl
))
2048 DECL_USE_TEMPLATE (newdecl
) = DECL_USE_TEMPLATE (olddecl
);
2050 /* Don't really know how much of the language-specific
2051 values we should copy from old to new. */
2052 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
2053 DECL_REPO_AVAILABLE_P (newdecl
) = DECL_REPO_AVAILABLE_P (olddecl
);
2054 DECL_INITIALIZED_IN_CLASS_P (newdecl
)
2055 |= DECL_INITIALIZED_IN_CLASS_P (olddecl
);
2057 if (LANG_DECL_HAS_MIN (newdecl
))
2059 DECL_LANG_SPECIFIC (newdecl
)->u
.min
.u2
=
2060 DECL_LANG_SPECIFIC (olddecl
)->u
.min
.u2
;
2061 if (DECL_TEMPLATE_INFO (newdecl
))
2062 new_template_info
= DECL_TEMPLATE_INFO (newdecl
);
2063 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
2065 /* Only functions have these fields. */
2066 if (DECL_DECLARES_FUNCTION_P (newdecl
))
2068 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
2069 olddecl_friend
= DECL_FRIEND_P (olddecl
);
2070 hidden_friend
= (DECL_ANTICIPATED (olddecl
)
2071 && DECL_HIDDEN_FRIEND_P (olddecl
)
2072 && newdecl_is_friend
);
2073 DECL_BEFRIENDING_CLASSES (newdecl
)
2074 = chainon (DECL_BEFRIENDING_CLASSES (newdecl
),
2075 DECL_BEFRIENDING_CLASSES (olddecl
));
2076 /* DECL_THUNKS is only valid for virtual functions,
2077 otherwise it is a DECL_FRIEND_CONTEXT. */
2078 if (DECL_VIRTUAL_P (newdecl
))
2079 SET_DECL_THUNKS (newdecl
, DECL_THUNKS (olddecl
));
2081 /* Only variables have this field. */
2082 else if (VAR_P (newdecl
)
2083 && VAR_HAD_UNKNOWN_BOUND (olddecl
))
2084 SET_VAR_HAD_UNKNOWN_BOUND (newdecl
);
2087 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2091 /* Merge parameter attributes. */
2092 tree oldarg
, newarg
;
2093 for (oldarg
= DECL_ARGUMENTS(olddecl
),
2094 newarg
= DECL_ARGUMENTS(newdecl
);
2096 oldarg
= DECL_CHAIN(oldarg
), newarg
= DECL_CHAIN(newarg
)) {
2097 DECL_ATTRIBUTES (newarg
)
2098 = (*targetm
.merge_decl_attributes
) (oldarg
, newarg
);
2099 DECL_ATTRIBUTES (oldarg
) = DECL_ATTRIBUTES (newarg
);
2102 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
2103 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
2105 /* If newdecl is not a specialization, then it is not a
2106 template-related function at all. And that means that we
2107 should have exited above, returning 0. */
2108 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
));
2110 if (DECL_ODR_USED (olddecl
))
2111 /* From [temp.expl.spec]:
2113 If a template, a member template or the member of a class
2114 template is explicitly specialized then that
2115 specialization shall be declared before the first use of
2116 that specialization that would cause an implicit
2117 instantiation to take place, in every translation unit in
2118 which such a use occurs. */
2119 error ("explicit specialization of %qD after first use",
2122 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
2124 /* Don't propagate visibility from the template to the
2125 specialization here. We'll do that in determine_visibility if
2127 DECL_VISIBILITY_SPECIFIED (olddecl
) = 0;
2129 /* [temp.expl.spec/14] We don't inline explicit specialization
2130 just because the primary template says so. */
2132 /* But still keep DECL_DISREGARD_INLINE_LIMITS in sync with
2133 the always_inline attribute. */
2134 if (DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2135 && !DECL_DISREGARD_INLINE_LIMITS (newdecl
))
2137 if (DECL_DECLARED_INLINE_P (newdecl
))
2138 DECL_DISREGARD_INLINE_LIMITS (newdecl
) = true;
2140 DECL_ATTRIBUTES (newdecl
)
2141 = remove_attribute ("always_inline",
2142 DECL_ATTRIBUTES (newdecl
));
2145 else if (new_defines_function
&& DECL_INITIAL (olddecl
))
2147 /* Never inline re-defined extern inline functions.
2148 FIXME: this could be better handled by keeping both
2149 function as separate declarations. */
2150 DECL_UNINLINABLE (newdecl
) = 1;
2154 if (DECL_PENDING_INLINE_INFO (newdecl
) == 0)
2155 DECL_PENDING_INLINE_INFO (newdecl
) = DECL_PENDING_INLINE_INFO (olddecl
);
2157 DECL_DECLARED_INLINE_P (newdecl
) |= DECL_DECLARED_INLINE_P (olddecl
);
2159 DECL_UNINLINABLE (newdecl
) = DECL_UNINLINABLE (olddecl
)
2160 = (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
));
2162 DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2163 = DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2164 = (DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2165 || DECL_DISREGARD_INLINE_LIMITS (olddecl
));
2168 /* Preserve abstractness on cloned [cd]tors. */
2169 DECL_ABSTRACT (newdecl
) = DECL_ABSTRACT (olddecl
);
2171 /* Update newdecl's parms to point at olddecl. */
2172 for (parm
= DECL_ARGUMENTS (newdecl
); parm
;
2173 parm
= DECL_CHAIN (parm
))
2174 DECL_CONTEXT (parm
) = olddecl
;
2178 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
2179 COPY_DECL_ASSEMBLER_NAME (newdecl
, olddecl
);
2180 COPY_DECL_RTL (newdecl
, olddecl
);
2182 if (! types_match
|| new_defines_function
)
2184 /* These need to be copied so that the names are available.
2185 Note that if the types do match, we'll preserve inline
2186 info and other bits, but if not, we won't. */
2187 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
2188 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
2190 /* If redeclaring a builtin function, it stays built in
2191 if newdecl is a gnu_inline definition, or if newdecl is just
2193 if (DECL_BUILT_IN (olddecl
)
2194 && (new_defines_function
? GNU_INLINE_P (newdecl
) : types_match
))
2196 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
2197 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
2198 /* If we're keeping the built-in definition, keep the rtl,
2199 regardless of declaration matches. */
2200 COPY_DECL_RTL (olddecl
, newdecl
);
2201 if (DECL_BUILT_IN_CLASS (newdecl
) == BUILT_IN_NORMAL
)
2203 enum built_in_function fncode
= DECL_FUNCTION_CODE (newdecl
);
2206 /* If a compatible prototype of these builtin functions
2207 is seen, assume the runtime implements it with the
2208 expected semantics. */
2209 case BUILT_IN_STPCPY
:
2210 if (builtin_decl_explicit_p (fncode
))
2211 set_builtin_decl_implicit_p (fncode
, true);
2218 if (new_defines_function
)
2219 /* If defining a function declared with other language
2220 linkage, use the previously declared language linkage. */
2221 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
2222 else if (types_match
)
2224 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
2225 /* Don't clear out the arguments if we're just redeclaring a
2227 if (DECL_ARGUMENTS (olddecl
))
2228 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
2231 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
2232 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
2234 /* Now preserve various other info from the definition. */
2235 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
2236 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
2237 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
2238 COPY_DECL_ASSEMBLER_NAME (olddecl
, newdecl
);
2240 /* Warn about conflicting visibility specifications. */
2241 if (DECL_VISIBILITY_SPECIFIED (olddecl
)
2242 && DECL_VISIBILITY_SPECIFIED (newdecl
)
2243 && DECL_VISIBILITY (newdecl
) != DECL_VISIBILITY (olddecl
))
2245 warning_at (input_location
, OPT_Wattributes
,
2246 "%q+D: visibility attribute ignored because it", newdecl
);
2247 warning_at (DECL_SOURCE_LOCATION (olddecl
), OPT_Wattributes
,
2248 "conflicts with previous declaration here");
2250 /* Choose the declaration which specified visibility. */
2251 if (DECL_VISIBILITY_SPECIFIED (olddecl
))
2253 DECL_VISIBILITY (newdecl
) = DECL_VISIBILITY (olddecl
);
2254 DECL_VISIBILITY_SPECIFIED (newdecl
) = 1;
2256 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2257 so keep this behavior. */
2258 if (VAR_P (newdecl
) && DECL_HAS_INIT_PRIORITY_P (newdecl
))
2260 SET_DECL_INIT_PRIORITY (olddecl
, DECL_INIT_PRIORITY (newdecl
));
2261 DECL_HAS_INIT_PRIORITY_P (olddecl
) = 1;
2263 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
2264 if (DECL_ALIGN (olddecl
) > DECL_ALIGN (newdecl
))
2266 DECL_ALIGN (newdecl
) = DECL_ALIGN (olddecl
);
2267 DECL_USER_ALIGN (newdecl
) |= DECL_USER_ALIGN (olddecl
);
2269 DECL_USER_ALIGN (olddecl
) = DECL_USER_ALIGN (newdecl
);
2270 if (TREE_CODE (newdecl
) == FIELD_DECL
)
2271 DECL_PACKED (olddecl
) = DECL_PACKED (newdecl
);
2273 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2274 with that from NEWDECL below. */
2275 if (DECL_LANG_SPECIFIC (olddecl
))
2277 gcc_assert (DECL_LANG_SPECIFIC (olddecl
)
2278 != DECL_LANG_SPECIFIC (newdecl
));
2279 ggc_free (DECL_LANG_SPECIFIC (olddecl
));
2282 /* Merge the USED information. */
2283 if (TREE_USED (olddecl
))
2284 TREE_USED (newdecl
) = 1;
2285 else if (TREE_USED (newdecl
))
2286 TREE_USED (olddecl
) = 1;
2287 if (VAR_P (newdecl
))
2289 if (DECL_READ_P (olddecl
))
2290 DECL_READ_P (newdecl
) = 1;
2291 else if (DECL_READ_P (newdecl
))
2292 DECL_READ_P (olddecl
) = 1;
2294 if (DECL_PRESERVE_P (olddecl
))
2295 DECL_PRESERVE_P (newdecl
) = 1;
2296 else if (DECL_PRESERVE_P (newdecl
))
2297 DECL_PRESERVE_P (olddecl
) = 1;
2299 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
2300 to olddecl and deleted. */
2301 if (TREE_CODE (newdecl
) == FUNCTION_DECL
2302 && DECL_FUNCTION_VERSIONED (olddecl
))
2304 /* Set the flag for newdecl so that it gets copied to olddecl. */
2305 DECL_FUNCTION_VERSIONED (newdecl
) = 1;
2306 /* newdecl will be purged after copying to olddecl and is no longer
2308 delete_function_version (newdecl
);
2311 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2315 function_size
= sizeof (struct tree_decl_common
);
2317 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2318 (char *) newdecl
+ sizeof (struct tree_common
),
2319 function_size
- sizeof (struct tree_common
));
2321 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2322 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2323 sizeof (struct tree_function_decl
) - sizeof (struct tree_decl_common
));
2324 if (new_template_info
)
2325 /* If newdecl is a template instantiation, it is possible that
2326 the following sequence of events has occurred:
2328 o A friend function was declared in a class template. The
2329 class template was instantiated.
2331 o The instantiation of the friend declaration was
2332 recorded on the instantiation list, and is newdecl.
2334 o Later, however, instantiate_class_template called pushdecl
2335 on the newdecl to perform name injection. But, pushdecl in
2336 turn called duplicate_decls when it discovered that another
2337 declaration of a global function with the same name already
2340 o Here, in duplicate_decls, we decided to clobber newdecl.
2342 If we're going to do that, we'd better make sure that
2343 olddecl, and not newdecl, is on the list of
2344 instantiations so that if we try to do the instantiation
2345 again we won't get the clobbered declaration. */
2346 reregister_specialization (newdecl
,
2352 size_t size
= tree_code_size (TREE_CODE (olddecl
));
2353 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2354 (char *) newdecl
+ sizeof (struct tree_common
),
2355 sizeof (struct tree_decl_common
) - sizeof (struct tree_common
));
2356 switch (TREE_CODE (olddecl
))
2366 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2367 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2368 size
- sizeof (struct tree_decl_common
)
2369 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2373 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2374 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2375 sizeof (struct tree_decl_non_common
) - sizeof (struct tree_decl_common
)
2376 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2380 DECL_UID (olddecl
) = olddecl_uid
;
2382 DECL_FRIEND_P (olddecl
) = 1;
2385 DECL_ANTICIPATED (olddecl
) = 1;
2386 DECL_HIDDEN_FRIEND_P (olddecl
) = 1;
2389 /* NEWDECL contains the merged attribute lists.
2390 Update OLDDECL to be the same. */
2391 DECL_ATTRIBUTES (olddecl
) = DECL_ATTRIBUTES (newdecl
);
2393 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2394 so that encode_section_info has a chance to look at the new decl
2395 flags and attributes. */
2396 if (DECL_RTL_SET_P (olddecl
)
2397 && (TREE_CODE (olddecl
) == FUNCTION_DECL
2399 && TREE_STATIC (olddecl
))))
2400 make_decl_rtl (olddecl
);
2402 /* The NEWDECL will no longer be needed. Because every out-of-class
2403 declaration of a member results in a call to duplicate_decls,
2404 freeing these nodes represents in a significant savings. */
2410 /* Return zero if the declaration NEWDECL is valid
2411 when the declaration OLDDECL (assumed to be for the same name)
2412 has already been seen.
2413 Otherwise return an error message format string with a %s
2414 where the identifier should go. */
2417 redeclaration_error_message (tree newdecl
, tree olddecl
)
2419 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2421 /* Because C++ can put things into name space for free,
2422 constructs like "typedef struct foo { ... } foo"
2423 would look like an erroneous redeclaration. */
2424 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
2427 return G_("redefinition of %q#D");
2429 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2431 /* If this is a pure function, its olddecl will actually be
2432 the original initialization to `0' (which we force to call
2433 abort()). Don't complain about redefinition in this case. */
2434 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_PURE_VIRTUAL_P (olddecl
)
2435 && DECL_INITIAL (olddecl
) == NULL_TREE
)
2438 /* If both functions come from different namespaces, this is not
2439 a redeclaration - this is a conflict with a used function. */
2440 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
2441 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
)
2442 && ! decls_match (olddecl
, newdecl
))
2443 return G_("%qD conflicts with used function");
2445 /* We'll complain about linkage mismatches in
2446 warn_extern_redeclared_static. */
2448 /* Defining the same name twice is no good. */
2449 if (DECL_INITIAL (olddecl
) != NULL_TREE
2450 && DECL_INITIAL (newdecl
) != NULL_TREE
)
2452 if (DECL_NAME (olddecl
) == NULL_TREE
)
2453 return G_("%q#D not declared in class");
2454 else if (!GNU_INLINE_P (olddecl
)
2455 || GNU_INLINE_P (newdecl
))
2456 return G_("redefinition of %q#D");
2459 if (DECL_DECLARED_INLINE_P (olddecl
) && DECL_DECLARED_INLINE_P (newdecl
))
2461 bool olda
= GNU_INLINE_P (olddecl
);
2462 bool newa
= GNU_INLINE_P (newdecl
);
2467 return G_("%q+D redeclared inline with "
2468 "%<gnu_inline%> attribute");
2470 return G_("%q+D redeclared inline without "
2471 "%<gnu_inline%> attribute");
2475 check_abi_tag_redeclaration
2476 (olddecl
, lookup_attribute ("abi_tag", DECL_ATTRIBUTES (olddecl
)),
2477 lookup_attribute ("abi_tag", DECL_ATTRIBUTES (newdecl
)));
2481 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2485 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2487 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl
))
2488 && COMPLETE_TYPE_P (TREE_TYPE (olddecl
)))
2489 return G_("redefinition of %q#D");
2493 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != FUNCTION_DECL
2494 || (DECL_TEMPLATE_RESULT (newdecl
)
2495 == DECL_TEMPLATE_RESULT (olddecl
)))
2498 nt
= DECL_TEMPLATE_RESULT (newdecl
);
2499 if (DECL_TEMPLATE_INFO (nt
))
2500 nt
= DECL_TEMPLATE_RESULT (template_for_substitution (nt
));
2501 ot
= DECL_TEMPLATE_RESULT (olddecl
);
2502 if (DECL_TEMPLATE_INFO (ot
))
2503 ot
= DECL_TEMPLATE_RESULT (template_for_substitution (ot
));
2504 if (DECL_INITIAL (nt
) && DECL_INITIAL (ot
)
2505 && (!GNU_INLINE_P (ot
) || GNU_INLINE_P (nt
)))
2506 return G_("redefinition of %q#D");
2508 if (DECL_DECLARED_INLINE_P (ot
) && DECL_DECLARED_INLINE_P (nt
))
2510 bool olda
= GNU_INLINE_P (ot
);
2511 bool newa
= GNU_INLINE_P (nt
);
2516 return G_("%q+D redeclared inline with "
2517 "%<gnu_inline%> attribute");
2519 return G_("%q+D redeclared inline without "
2520 "%<gnu_inline%> attribute");
2524 /* Core issue #226 (C++0x):
2526 If a friend function template declaration specifies a
2527 default template-argument, that declaration shall be a
2528 definition and shall be the only declaration of the
2529 function template in the translation unit. */
2530 if ((cxx_dialect
!= cxx98
)
2531 && TREE_CODE (ot
) == FUNCTION_DECL
&& DECL_FRIEND_P (ot
)
2532 && !check_default_tmpl_args (nt
, DECL_TEMPLATE_PARMS (newdecl
),
2533 /*is_primary=*/true,
2534 /*is_partial=*/false,
2535 /*is_friend_decl=*/2))
2536 return G_("redeclaration of friend %q#D "
2537 "may not have default template arguments");
2541 else if (VAR_P (newdecl
)
2542 && DECL_THREAD_LOCAL_P (newdecl
) != DECL_THREAD_LOCAL_P (olddecl
)
2543 && (! DECL_LANG_SPECIFIC (olddecl
)
2544 || ! CP_DECL_THREADPRIVATE_P (olddecl
)
2545 || DECL_THREAD_LOCAL_P (newdecl
)))
2547 /* Only variables can be thread-local, and all declarations must
2548 agree on this property. */
2549 if (DECL_THREAD_LOCAL_P (newdecl
))
2550 return G_("thread-local declaration of %q#D follows "
2551 "non-thread-local declaration");
2553 return G_("non-thread-local declaration of %q#D follows "
2554 "thread-local declaration");
2556 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl
))
2558 /* The objects have been declared at namespace scope. If either
2559 is a member of an anonymous union, then this is an invalid
2560 redeclaration. For example:
2566 if ((VAR_P (newdecl
) && DECL_ANON_UNION_VAR_P (newdecl
))
2567 || (VAR_P (olddecl
) && DECL_ANON_UNION_VAR_P (olddecl
)))
2568 return G_("redeclaration of %q#D");
2569 /* If at least one declaration is a reference, there is no
2570 conflict. For example:
2576 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
2578 /* Reject two definitions. */
2579 return G_("redefinition of %q#D");
2583 /* Objects declared with block scope: */
2584 /* Reject two definitions, and reject a definition
2585 together with an external reference. */
2586 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
2587 return G_("redeclaration of %q#D");
2592 /* Hash and equality functions for the named_label table. */
2595 named_label_entry_hash (const void *data
)
2597 const struct named_label_entry
*ent
= (const struct named_label_entry
*) data
;
2598 return DECL_UID (ent
->label_decl
);
2602 named_label_entry_eq (const void *a
, const void *b
)
2604 const struct named_label_entry
*ent_a
= (const struct named_label_entry
*) a
;
2605 const struct named_label_entry
*ent_b
= (const struct named_label_entry
*) b
;
2606 return ent_a
->label_decl
== ent_b
->label_decl
;
2609 /* Create a new label, named ID. */
2612 make_label_decl (tree id
, int local_p
)
2614 struct named_label_entry
*ent
;
2618 decl
= build_decl (input_location
, LABEL_DECL
, id
, void_type_node
);
2620 DECL_CONTEXT (decl
) = current_function_decl
;
2621 DECL_MODE (decl
) = VOIDmode
;
2622 C_DECLARED_LABEL_FLAG (decl
) = local_p
;
2624 /* Say where one reference is to the label, for the sake of the
2625 error if it is not defined. */
2626 DECL_SOURCE_LOCATION (decl
) = input_location
;
2628 /* Record the fact that this identifier is bound to this label. */
2629 SET_IDENTIFIER_LABEL_VALUE (id
, decl
);
2631 /* Create the label htab for the function on demand. */
2633 named_labels
= htab_create_ggc (13, named_label_entry_hash
,
2634 named_label_entry_eq
, NULL
);
2636 /* Record this label on the list of labels used in this function.
2637 We do this before calling make_label_decl so that we get the
2638 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2639 ent
= ggc_alloc_cleared_named_label_entry ();
2640 ent
->label_decl
= decl
;
2642 slot
= htab_find_slot (named_labels
, ent
, INSERT
);
2643 gcc_assert (*slot
== NULL
);
2649 /* Look for a label named ID in the current function. If one cannot
2650 be found, create one. (We keep track of used, but undefined,
2651 labels, and complain about them at the end of a function.) */
2654 lookup_label_1 (tree id
)
2658 /* You can't use labels at global scope. */
2659 if (current_function_decl
== NULL_TREE
)
2661 error ("label %qE referenced outside of any function", id
);
2665 /* See if we've already got this label. */
2666 decl
= IDENTIFIER_LABEL_VALUE (id
);
2667 if (decl
!= NULL_TREE
&& DECL_CONTEXT (decl
) == current_function_decl
)
2670 decl
= make_label_decl (id
, /*local_p=*/0);
2674 /* Wrapper for lookup_label_1. */
2677 lookup_label (tree id
)
2680 bool subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
2681 ret
= lookup_label_1 (id
);
2682 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
2686 /* Declare a local label named ID. */
2689 declare_local_label (tree id
)
2692 cp_label_binding bind
;
2694 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2695 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2696 bind
.prev_value
= IDENTIFIER_LABEL_VALUE (id
);
2698 decl
= make_label_decl (id
, /*local_p=*/1);
2700 vec_safe_push (current_binding_level
->shadowed_labels
, bind
);
2705 /* Returns nonzero if it is ill-formed to jump past the declaration of
2706 DECL. Returns 2 if it's also a real problem. */
2709 decl_jump_unsafe (tree decl
)
2711 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
2712 with automatic storage duration is not in scope to a point where it is
2713 in scope is ill-formed unless the variable has scalar type, class type
2714 with a trivial default constructor and a trivial destructor, a
2715 cv-qualified version of one of these types, or an array of one of the
2716 preceding types and is declared without an initializer (8.5). */
2717 tree type
= TREE_TYPE (decl
);
2719 if (!VAR_P (decl
) || TREE_STATIC (decl
)
2720 || type
== error_mark_node
)
2723 type
= strip_array_types (type
);
2725 if (DECL_NONTRIVIALLY_INITIALIZED_P (decl
))
2728 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
2734 /* A subroutine of check_previous_goto_1 to identify a branch to the user. */
2737 identify_goto (tree decl
, const location_t
*locus
)
2740 permerror (input_location
, "jump to label %qD", decl
);
2742 permerror (input_location
, "jump to case label");
2744 permerror (*locus
, " from here");
2747 /* Check that a single previously seen jump to a newly defined label
2748 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2749 the jump context; NAMES are the names in scope in LEVEL at the jump
2750 context; LOCUS is the source position of the jump or 0. Returns
2751 true if all is well. */
2754 check_previous_goto_1 (tree decl
, cp_binding_level
* level
, tree names
,
2755 bool exited_omp
, const location_t
*locus
)
2757 cp_binding_level
*b
;
2758 bool identified
= false, saw_eh
= false, saw_omp
= false;
2762 identify_goto (decl
, locus
);
2763 error (" exits OpenMP structured block");
2764 identified
= saw_omp
= true;
2767 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
2769 tree new_decls
, old_decls
= (b
== level
? names
: NULL_TREE
);
2771 for (new_decls
= b
->names
; new_decls
!= old_decls
;
2772 new_decls
= (DECL_P (new_decls
) ? DECL_CHAIN (new_decls
)
2773 : TREE_CHAIN (new_decls
)))
2775 int problem
= decl_jump_unsafe (new_decls
);
2781 identify_goto (decl
, locus
);
2785 error (" crosses initialization of %q+#D", new_decls
);
2787 permerror (input_location
, " enters scope of %q+#D which has "
2788 "non-trivial destructor", new_decls
);
2793 if ((b
->kind
== sk_try
|| b
->kind
== sk_catch
) && !saw_eh
)
2797 identify_goto (decl
, locus
);
2800 if (b
->kind
== sk_try
)
2801 error (" enters try block");
2803 error (" enters catch block");
2806 if (b
->kind
== sk_omp
&& !saw_omp
)
2810 identify_goto (decl
, locus
);
2813 error (" enters OpenMP structured block");
2822 check_previous_goto (tree decl
, struct named_label_use_entry
*use
)
2824 check_previous_goto_1 (decl
, use
->binding_level
,
2825 use
->names_in_scope
, use
->in_omp_scope
,
2826 &use
->o_goto_locus
);
2830 check_switch_goto (cp_binding_level
* level
)
2832 return check_previous_goto_1 (NULL_TREE
, level
, level
->names
, false, NULL
);
2835 /* Check that a new jump to a label DECL is OK. Called by
2836 finish_goto_stmt. */
2839 check_goto (tree decl
)
2841 struct named_label_entry
*ent
, dummy
;
2842 bool saw_catch
= false, identified
= false;
2846 /* We can't know where a computed goto is jumping.
2847 So we assume that it's OK. */
2848 if (TREE_CODE (decl
) != LABEL_DECL
)
2851 /* We didn't record any information about this label when we created it,
2852 and there's not much point since it's trivial to analyze as a return. */
2853 if (decl
== cdtor_label
)
2856 dummy
.label_decl
= decl
;
2857 ent
= (struct named_label_entry
*) htab_find (named_labels
, &dummy
);
2858 gcc_assert (ent
!= NULL
);
2860 /* If the label hasn't been defined yet, defer checking. */
2861 if (! DECL_INITIAL (decl
))
2863 struct named_label_use_entry
*new_use
;
2865 /* Don't bother creating another use if the last goto had the
2866 same data, and will therefore create the same set of errors. */
2868 && ent
->uses
->names_in_scope
== current_binding_level
->names
)
2871 new_use
= ggc_alloc_named_label_use_entry ();
2872 new_use
->binding_level
= current_binding_level
;
2873 new_use
->names_in_scope
= current_binding_level
->names
;
2874 new_use
->o_goto_locus
= input_location
;
2875 new_use
->in_omp_scope
= false;
2877 new_use
->next
= ent
->uses
;
2878 ent
->uses
= new_use
;
2882 if (ent
->in_try_scope
|| ent
->in_catch_scope
2883 || ent
->in_omp_scope
|| !vec_safe_is_empty (ent
->bad_decls
))
2885 permerror (input_location
, "jump to label %q+D", decl
);
2886 permerror (input_location
, " from here");
2890 FOR_EACH_VEC_SAFE_ELT (ent
->bad_decls
, ix
, bad
)
2892 int u
= decl_jump_unsafe (bad
);
2894 if (u
> 1 && DECL_ARTIFICIAL (bad
))
2896 /* Can't skip init of __exception_info. */
2897 error_at (DECL_SOURCE_LOCATION (bad
), " enters catch block");
2901 error (" skips initialization of %q+#D", bad
);
2903 permerror (input_location
, " enters scope of %q+#D which has "
2904 "non-trivial destructor", bad
);
2907 if (ent
->in_try_scope
)
2908 error (" enters try block");
2909 else if (ent
->in_catch_scope
&& !saw_catch
)
2910 error (" enters catch block");
2912 if (ent
->in_omp_scope
)
2913 error (" enters OpenMP structured block");
2914 else if (flag_openmp
)
2916 cp_binding_level
*b
;
2917 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
2919 if (b
== ent
->binding_level
)
2921 if (b
->kind
== sk_omp
)
2925 permerror (input_location
, "jump to label %q+D", decl
);
2926 permerror (input_location
, " from here");
2929 error (" exits OpenMP structured block");
2936 /* Check that a return is ok wrt OpenMP structured blocks.
2937 Called by finish_return_stmt. Returns true if all is well. */
2940 check_omp_return (void)
2942 cp_binding_level
*b
;
2943 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
2944 if (b
->kind
== sk_omp
)
2946 error ("invalid exit from OpenMP structured block");
2949 else if (b
->kind
== sk_function_parms
)
2954 /* Define a label, specifying the location in the source file.
2955 Return the LABEL_DECL node for the label. */
2958 define_label_1 (location_t location
, tree name
)
2960 struct named_label_entry
*ent
, dummy
;
2961 cp_binding_level
*p
;
2964 decl
= lookup_label (name
);
2966 dummy
.label_decl
= decl
;
2967 ent
= (struct named_label_entry
*) htab_find (named_labels
, &dummy
);
2968 gcc_assert (ent
!= NULL
);
2970 /* After labels, make any new cleanups in the function go into their
2971 own new (temporary) binding contour. */
2972 for (p
= current_binding_level
;
2973 p
->kind
!= sk_function_parms
;
2975 p
->more_cleanups_ok
= 0;
2977 if (name
== get_identifier ("wchar_t"))
2978 permerror (input_location
, "label named wchar_t");
2980 if (DECL_INITIAL (decl
) != NULL_TREE
)
2982 error ("duplicate label %qD", decl
);
2983 return error_mark_node
;
2987 struct named_label_use_entry
*use
;
2989 /* Mark label as having been defined. */
2990 DECL_INITIAL (decl
) = error_mark_node
;
2991 /* Say where in the source. */
2992 DECL_SOURCE_LOCATION (decl
) = location
;
2994 ent
->binding_level
= current_binding_level
;
2995 ent
->names_in_scope
= current_binding_level
->names
;
2997 for (use
= ent
->uses
; use
; use
= use
->next
)
2998 check_previous_goto (decl
, use
);
3005 /* Wrapper for define_label_1. */
3008 define_label (location_t location
, tree name
)
3011 bool running
= timevar_cond_start (TV_NAME_LOOKUP
);
3012 ret
= define_label_1 (location
, name
);
3013 timevar_cond_stop (TV_NAME_LOOKUP
, running
);
3020 cp_binding_level
*level
;
3021 struct cp_switch
*next
;
3022 /* The SWITCH_STMT being built. */
3024 /* A splay-tree mapping the low element of a case range to the high
3025 element, or NULL_TREE if there is no high element. Used to
3026 determine whether or not a new case label duplicates an old case
3027 label. We need a tree, rather than simply a hash table, because
3028 of the GNU case range extension. */
3032 /* A stack of the currently active switch statements. The innermost
3033 switch statement is on the top of the stack. There is no need to
3034 mark the stack for garbage collection because it is only active
3035 during the processing of the body of a function, and we never
3036 collect at that point. */
3038 static struct cp_switch
*switch_stack
;
3040 /* Called right after a switch-statement condition is parsed.
3041 SWITCH_STMT is the switch statement being parsed. */
3044 push_switch (tree switch_stmt
)
3046 struct cp_switch
*p
= XNEW (struct cp_switch
);
3047 p
->level
= current_binding_level
;
3048 p
->next
= switch_stack
;
3049 p
->switch_stmt
= switch_stmt
;
3050 p
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
3057 struct cp_switch
*cs
= switch_stack
;
3058 location_t switch_location
;
3060 /* Emit warnings as needed. */
3061 switch_location
= EXPR_LOC_OR_HERE (cs
->switch_stmt
);
3062 if (!processing_template_decl
)
3063 c_do_switch_warnings (cs
->cases
, switch_location
,
3064 SWITCH_STMT_TYPE (cs
->switch_stmt
),
3065 SWITCH_STMT_COND (cs
->switch_stmt
));
3067 splay_tree_delete (cs
->cases
);
3068 switch_stack
= switch_stack
->next
;
3072 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
3073 condition. Note that if TYPE and VALUE are already integral we don't
3074 really do the conversion because the language-independent
3075 warning/optimization code will work better that way. */
3078 case_conversion (tree type
, tree value
)
3080 if (value
== NULL_TREE
)
3083 if (cxx_dialect
>= cxx0x
3084 && (SCOPED_ENUM_P (type
)
3085 || !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value
))))
3087 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
3088 type
= type_promotes_to (type
);
3089 value
= perform_implicit_conversion (type
, value
, tf_warning_or_error
);
3091 return cxx_constant_value (value
);
3094 /* Note that we've seen a definition of a case label, and complain if this
3095 is a bad place for one. */
3098 finish_case_label (location_t loc
, tree low_value
, tree high_value
)
3101 cp_binding_level
*p
;
3104 if (processing_template_decl
)
3108 /* For templates, just add the case label; we'll do semantic
3109 analysis at instantiation-time. */
3110 label
= build_decl (loc
, LABEL_DECL
, NULL_TREE
, NULL_TREE
);
3111 return add_stmt (build_case_label (low_value
, high_value
, label
));
3114 /* Find the condition on which this switch statement depends. */
3115 cond
= SWITCH_STMT_COND (switch_stack
->switch_stmt
);
3116 if (cond
&& TREE_CODE (cond
) == TREE_LIST
)
3117 cond
= TREE_VALUE (cond
);
3119 if (!check_switch_goto (switch_stack
->level
))
3120 return error_mark_node
;
3122 type
= SWITCH_STMT_TYPE (switch_stack
->switch_stmt
);
3124 low_value
= case_conversion (type
, low_value
);
3125 high_value
= case_conversion (type
, high_value
);
3127 r
= c_add_case_label (loc
, switch_stack
->cases
, cond
, type
,
3128 low_value
, high_value
);
3130 /* After labels, make any new cleanups in the function go into their
3131 own new (temporary) binding contour. */
3132 for (p
= current_binding_level
;
3133 p
->kind
!= sk_function_parms
;
3135 p
->more_cleanups_ok
= 0;
3140 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
3143 typename_hash (const void* k
)
3146 const_tree
const t
= (const_tree
) k
;
3148 hash
= (htab_hash_pointer (TYPE_CONTEXT (t
))
3149 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t
))));
3154 typedef struct typename_info
{
3162 /* Compare two TYPENAME_TYPEs. K1 is really of type `tree', K2 is
3163 really of type `typename_info*' */
3166 typename_compare (const void * k1
, const void * k2
)
3168 const_tree
const t1
= (const_tree
) k1
;
3169 const typename_info
*const t2
= (const typename_info
*) k2
;
3171 return (DECL_NAME (TYPE_NAME (t1
)) == t2
->name
3172 && TYPE_CONTEXT (t1
) == t2
->scope
3173 && TYPENAME_TYPE_FULLNAME (t1
) == t2
->template_id
3174 && TYPENAME_IS_ENUM_P (t1
) == t2
->enum_p
3175 && TYPENAME_IS_CLASS_P (t1
) == t2
->class_p
);
3178 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
3179 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
3181 Returns the new TYPENAME_TYPE. */
3183 static GTY ((param_is (union tree_node
))) htab_t typename_htab
;
3186 build_typename_type (tree context
, tree name
, tree fullname
,
3187 enum tag_types tag_type
)
3195 if (typename_htab
== NULL
)
3196 typename_htab
= htab_create_ggc (61, &typename_hash
,
3197 &typename_compare
, NULL
);
3199 ti
.scope
= FROB_CONTEXT (context
);
3201 ti
.template_id
= fullname
;
3202 ti
.enum_p
= tag_type
== enum_type
;
3203 ti
.class_p
= (tag_type
== class_type
3204 || tag_type
== record_type
3205 || tag_type
== union_type
);
3206 hash
= (htab_hash_pointer (ti
.scope
)
3207 ^ htab_hash_pointer (ti
.name
));
3209 /* See if we already have this type. */
3210 e
= htab_find_slot_with_hash (typename_htab
, &ti
, hash
, INSERT
);
3215 /* Build the TYPENAME_TYPE. */
3216 t
= cxx_make_type (TYPENAME_TYPE
);
3217 TYPE_CONTEXT (t
) = ti
.scope
;
3218 TYPENAME_TYPE_FULLNAME (t
) = ti
.template_id
;
3219 TYPENAME_IS_ENUM_P (t
) = ti
.enum_p
;
3220 TYPENAME_IS_CLASS_P (t
) = ti
.class_p
;
3222 /* Build the corresponding TYPE_DECL. */
3223 d
= build_decl (input_location
, TYPE_DECL
, name
, t
);
3224 TYPE_NAME (TREE_TYPE (d
)) = d
;
3225 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3226 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3227 DECL_ARTIFICIAL (d
) = 1;
3229 /* Store it in the hash table. */
3232 /* TYPENAME_TYPEs must always be compared structurally, because
3233 they may or may not resolve down to another type depending on
3234 the currently open classes. */
3235 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3241 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
3242 provided to name the type. Returns an appropriate type, unless an
3243 error occurs, in which case error_mark_node is returned. If we
3244 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
3245 return that, rather than the _TYPE it corresponds to, in other
3246 cases we look through the type decl. If TF_ERROR is set, complain
3247 about errors, otherwise be quiet. */
3250 make_typename_type (tree context
, tree name
, enum tag_types tag_type
,
3251 tsubst_flags_t complain
)
3257 if (name
== error_mark_node
3258 || context
== NULL_TREE
3259 || context
== error_mark_node
)
3260 return error_mark_node
;
3264 if (!(TYPE_LANG_SPECIFIC (name
)
3265 && (CLASSTYPE_IS_TEMPLATE (name
)
3266 || CLASSTYPE_USE_TEMPLATE (name
))))
3267 name
= TYPE_IDENTIFIER (name
);
3269 /* Create a TEMPLATE_ID_EXPR for the type. */
3270 name
= build_nt (TEMPLATE_ID_EXPR
,
3271 CLASSTYPE_TI_TEMPLATE (name
),
3272 CLASSTYPE_TI_ARGS (name
));
3274 else if (TREE_CODE (name
) == TYPE_DECL
)
3275 name
= DECL_NAME (name
);
3279 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3281 name
= TREE_OPERAND (name
, 0);
3282 if (TREE_CODE (name
) == TEMPLATE_DECL
)
3283 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
3284 else if (TREE_CODE (name
) == OVERLOAD
)
3286 if (complain
& tf_error
)
3287 error ("%qD is not a type", name
);
3288 return error_mark_node
;
3291 if (TREE_CODE (name
) == TEMPLATE_DECL
)
3293 if (complain
& tf_error
)
3294 error ("%qD used without template parameters", name
);
3295 return error_mark_node
;
3297 gcc_assert (identifier_p (name
));
3298 gcc_assert (TYPE_P (context
));
3300 if (!MAYBE_CLASS_TYPE_P (context
))
3302 if (complain
& tf_error
)
3303 error ("%q#T is not a class", context
);
3304 return error_mark_node
;
3307 /* When the CONTEXT is a dependent type, NAME could refer to a
3308 dependent base class of CONTEXT. But look inside it anyway
3309 if CONTEXT is a currently open scope, in case it refers to a
3310 member of the current instantiation or a non-dependent base;
3311 lookup will stop when we hit a dependent base. */
3312 if (!dependent_scope_p (context
))
3313 /* We should only set WANT_TYPE when we're a nested typename type.
3314 Then we can give better diagnostics if we find a non-type. */
3315 t
= lookup_field (context
, name
, 2, /*want_type=*/true);
3319 if ((!t
|| TREE_CODE (t
) == TREE_LIST
) && dependent_type_p (context
))
3320 return build_typename_type (context
, name
, fullname
, tag_type
);
3322 want_template
= TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
;
3326 if (complain
& tf_error
)
3327 error (want_template
? G_("no class template named %q#T in %q#T")
3328 : G_("no type named %q#T in %q#T"), name
, context
);
3329 return error_mark_node
;
3332 /* Pull out the template from an injected-class-name (or multiple). */
3334 t
= maybe_get_template_decl_from_type_decl (t
);
3336 if (TREE_CODE (t
) == TREE_LIST
)
3338 if (complain
& tf_error
)
3340 error ("lookup of %qT in %qT is ambiguous", name
, context
);
3341 print_candidates (t
);
3343 return error_mark_node
;
3346 if (want_template
&& !DECL_TYPE_TEMPLATE_P (t
))
3348 if (complain
& tf_error
)
3349 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3351 return error_mark_node
;
3353 if (!want_template
&& TREE_CODE (t
) != TYPE_DECL
)
3355 if (complain
& tf_error
)
3356 error ("%<typename %T::%D%> names %q#T, which is not a type",
3358 return error_mark_node
;
3361 if (!perform_or_defer_access_check (TYPE_BINFO (context
), t
, t
, complain
))
3362 return error_mark_node
;
3364 /* If we are currently parsing a template and if T is a typedef accessed
3365 through CONTEXT then we need to remember and check access of T at
3366 template instantiation time. */
3367 add_typedef_to_current_template_for_access_check (t
, context
, input_location
);
3370 return lookup_template_class (t
, TREE_OPERAND (fullname
, 1),
3372 /*entering_scope=*/0,
3373 tf_warning_or_error
| tf_user
);
3375 if (DECL_ARTIFICIAL (t
) || !(complain
& tf_keep_type_decl
))
3378 maybe_record_typedef_use (t
);
3383 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3384 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3385 in which case error_mark_node is returned.
3387 If PARM_LIST is non-NULL, also make sure that the template parameter
3388 list of TEMPLATE_DECL matches.
3390 If COMPLAIN zero, don't complain about any errors that occur. */
3393 make_unbound_class_template (tree context
, tree name
, tree parm_list
,
3394 tsubst_flags_t complain
)
3400 name
= TYPE_IDENTIFIER (name
);
3401 else if (DECL_P (name
))
3402 name
= DECL_NAME (name
);
3403 gcc_assert (identifier_p (name
));
3405 if (!dependent_type_p (context
)
3406 || currently_open_class (context
))
3408 tree tmpl
= NULL_TREE
;
3410 if (MAYBE_CLASS_TYPE_P (context
))
3411 tmpl
= lookup_field (context
, name
, 0, false);
3413 if (tmpl
&& TREE_CODE (tmpl
) == TYPE_DECL
)
3414 tmpl
= maybe_get_template_decl_from_type_decl (tmpl
);
3416 if (!tmpl
|| !DECL_TYPE_TEMPLATE_P (tmpl
))
3418 if (complain
& tf_error
)
3419 error ("no class template named %q#T in %q#T", name
, context
);
3420 return error_mark_node
;
3424 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl
), parm_list
))
3426 if (complain
& tf_error
)
3428 error ("template parameters do not match template");
3429 error ("%q+D declared here", tmpl
);
3431 return error_mark_node
;
3434 if (!perform_or_defer_access_check (TYPE_BINFO (context
), tmpl
, tmpl
,
3436 return error_mark_node
;
3441 /* Build the UNBOUND_CLASS_TEMPLATE. */
3442 t
= cxx_make_type (UNBOUND_CLASS_TEMPLATE
);
3443 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
3444 TREE_TYPE (t
) = NULL_TREE
;
3445 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3447 /* Build the corresponding TEMPLATE_DECL. */
3448 d
= build_decl (input_location
, TEMPLATE_DECL
, name
, t
);
3449 TYPE_NAME (TREE_TYPE (d
)) = d
;
3450 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3451 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3452 DECL_ARTIFICIAL (d
) = 1;
3453 DECL_TEMPLATE_PARMS (d
) = parm_list
;
3460 /* Push the declarations of builtin types into the namespace.
3461 RID_INDEX is the index of the builtin type in the array
3462 RID_POINTERS. NAME is the name used when looking up the builtin
3463 type. TYPE is the _TYPE node for the builtin type. */
3466 record_builtin_type (enum rid rid_index
,
3470 tree rname
= NULL_TREE
, tname
= NULL_TREE
;
3471 tree tdecl
= NULL_TREE
;
3473 if ((int) rid_index
< (int) RID_MAX
)
3474 rname
= ridpointers
[(int) rid_index
];
3476 tname
= get_identifier (name
);
3478 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
3479 eliminated. Built-in types should not be looked up name; their
3480 names are keywords that the parser can recognize. However, there
3481 is code in c-common.c that uses identifier_global_value to look
3482 up built-in types by name. */
3485 tdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, tname
, type
);
3486 DECL_ARTIFICIAL (tdecl
) = 1;
3487 SET_IDENTIFIER_GLOBAL_VALUE (tname
, tdecl
);
3493 tdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, rname
, type
);
3494 DECL_ARTIFICIAL (tdecl
) = 1;
3496 SET_IDENTIFIER_GLOBAL_VALUE (rname
, tdecl
);
3499 if (!TYPE_NAME (type
))
3500 TYPE_NAME (type
) = tdecl
;
3503 debug_hooks
->type_decl (tdecl
, 0);
3506 /* Record one of the standard Java types.
3507 * Declare it as having the given NAME.
3508 * If SIZE > 0, it is the size of one of the integral types;
3509 * otherwise it is the negative of the size of one of the other types. */
3512 record_builtin_java_type (const char* name
, int size
)
3517 type
= build_nonstandard_integer_type (size
, 0);
3518 type
= build_distinct_type_copy (type
);
3520 else if (size
> -32)
3523 /* "__java_char" or ""__java_boolean". */
3524 type
= build_nonstandard_integer_type (-size
, 1);
3525 type
= build_distinct_type_copy (type
);
3526 /* Get the signed type cached and attached to the unsigned type,
3527 so it doesn't get garbage-collected at "random" times,
3528 causing potential codegen differences out of different UIDs
3529 and different alias set numbers. */
3530 stype
= build_nonstandard_integer_type (-size
, 0);
3531 stype
= build_distinct_type_copy (stype
);
3532 TREE_CHAIN (type
) = stype
;
3533 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
3536 { /* "__java_float" or ""__java_double". */
3537 type
= make_node (REAL_TYPE
);
3538 TYPE_PRECISION (type
) = - size
;
3541 record_builtin_type (RID_MAX
, name
, type
);
3542 decl
= TYPE_NAME (type
);
3544 /* Suppress generate debug symbol entries for these types,
3545 since for normal C++ they are just clutter.
3546 However, push_lang_context undoes this if extern "Java" is seen. */
3547 DECL_IGNORED_P (decl
) = 1;
3549 TYPE_FOR_JAVA (type
) = 1;
3553 /* Push a type into the namespace so that the back ends ignore it. */
3556 record_unknown_type (tree type
, const char* name
)
3558 tree decl
= pushdecl (build_decl (UNKNOWN_LOCATION
,
3559 TYPE_DECL
, get_identifier (name
), type
));
3560 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3561 DECL_IGNORED_P (decl
) = 1;
3562 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
3563 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
3564 TYPE_ALIGN (type
) = 1;
3565 TYPE_USER_ALIGN (type
) = 0;
3566 SET_TYPE_MODE (type
, TYPE_MODE (void_type_node
));
3569 /* A string for which we should create an IDENTIFIER_NODE at
3572 typedef struct predefined_identifier
3574 /* The name of the identifier. */
3575 const char *const name
;
3576 /* The place where the IDENTIFIER_NODE should be stored. */
3578 /* Nonzero if this is the name of a constructor or destructor. */
3579 const int ctor_or_dtor_p
;
3580 } predefined_identifier
;
3582 /* Create all the predefined identifiers. */
3585 initialize_predefined_identifiers (void)
3587 const predefined_identifier
*pid
;
3589 /* A table of identifiers to create at startup. */
3590 static const predefined_identifier predefined_identifiers
[] = {
3591 { "C++", &lang_name_cplusplus
, 0 },
3592 { "C", &lang_name_c
, 0 },
3593 { "Java", &lang_name_java
, 0 },
3594 /* Some of these names have a trailing space so that it is
3595 impossible for them to conflict with names written by users. */
3596 { "__ct ", &ctor_identifier
, 1 },
3597 { "__base_ctor ", &base_ctor_identifier
, 1 },
3598 { "__comp_ctor ", &complete_ctor_identifier
, 1 },
3599 { "__dt ", &dtor_identifier
, 1 },
3600 { "__comp_dtor ", &complete_dtor_identifier
, 1 },
3601 { "__base_dtor ", &base_dtor_identifier
, 1 },
3602 { "__deleting_dtor ", &deleting_dtor_identifier
, 1 },
3603 { IN_CHARGE_NAME
, &in_charge_identifier
, 0 },
3604 { "nelts", &nelts_identifier
, 0 },
3605 { THIS_NAME
, &this_identifier
, 0 },
3606 { VTABLE_DELTA_NAME
, &delta_identifier
, 0 },
3607 { VTABLE_PFN_NAME
, &pfn_identifier
, 0 },
3608 { "_vptr", &vptr_identifier
, 0 },
3609 { "__vtt_parm", &vtt_parm_identifier
, 0 },
3610 { "::", &global_scope_name
, 0 },
3611 { "std", &std_identifier
, 0 },
3615 for (pid
= predefined_identifiers
; pid
->name
; ++pid
)
3617 *pid
->node
= get_identifier (pid
->name
);
3618 if (pid
->ctor_or_dtor_p
)
3619 IDENTIFIER_CTOR_OR_DTOR_P (*pid
->node
) = 1;
3623 /* Create the predefined scalar types of C,
3624 and some nodes representing standard constants (0, 1, (void *)0).
3625 Initialize the global binding level.
3626 Make definitions for built-in primitive functions. */
3629 cxx_init_decl_processing (void)
3632 tree void_ftype_ptr
;
3634 /* Create all the identifiers we need. */
3635 initialize_predefined_identifiers ();
3637 /* Create the global variables. */
3638 push_to_top_level ();
3640 current_function_decl
= NULL_TREE
;
3641 current_binding_level
= NULL
;
3642 /* Enter the global namespace. */
3643 gcc_assert (global_namespace
== NULL_TREE
);
3644 global_namespace
= build_lang_decl (NAMESPACE_DECL
, global_scope_name
,
3646 DECL_CONTEXT (global_namespace
) = build_translation_unit_decl (NULL_TREE
);
3647 TREE_PUBLIC (global_namespace
) = 1;
3648 begin_scope (sk_namespace
, global_namespace
);
3650 if (flag_visibility_ms_compat
)
3651 default_visibility
= VISIBILITY_HIDDEN
;
3654 current_lang_name
= lang_name_c
;
3656 /* Create the `std' namespace. */
3657 push_namespace (std_identifier
);
3658 std_node
= current_namespace
;
3661 c_common_nodes_and_builtins ();
3663 java_byte_type_node
= record_builtin_java_type ("__java_byte", 8);
3664 java_short_type_node
= record_builtin_java_type ("__java_short", 16);
3665 java_int_type_node
= record_builtin_java_type ("__java_int", 32);
3666 java_long_type_node
= record_builtin_java_type ("__java_long", 64);
3667 java_float_type_node
= record_builtin_java_type ("__java_float", -32);
3668 java_double_type_node
= record_builtin_java_type ("__java_double", -64);
3669 java_char_type_node
= record_builtin_java_type ("__java_char", -16);
3670 java_boolean_type_node
= record_builtin_java_type ("__java_boolean", -1);
3672 integer_two_node
= build_int_cst (NULL_TREE
, 2);
3674 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
3675 truthvalue_type_node
= boolean_type_node
;
3676 truthvalue_false_node
= boolean_false_node
;
3677 truthvalue_true_node
= boolean_true_node
;
3679 empty_except_spec
= build_tree_list (NULL_TREE
, NULL_TREE
);
3680 noexcept_true_spec
= build_tree_list (boolean_true_node
, NULL_TREE
);
3681 noexcept_false_spec
= build_tree_list (boolean_false_node
, NULL_TREE
);
3684 record_builtin_type (RID_MAX
, NULL
, string_type_node
);
3687 delta_type_node
= ptrdiff_type_node
;
3688 vtable_index_type
= ptrdiff_type_node
;
3690 vtt_parm_type
= build_pointer_type (const_ptr_type_node
);
3691 void_ftype
= build_function_type_list (void_type_node
, NULL_TREE
);
3692 void_ftype_ptr
= build_function_type_list (void_type_node
,
3693 ptr_type_node
, NULL_TREE
);
3695 = build_exception_variant (void_ftype_ptr
, empty_except_spec
);
3697 /* C++ extensions */
3699 unknown_type_node
= make_node (LANG_TYPE
);
3700 record_unknown_type (unknown_type_node
, "unknown type");
3702 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3703 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
3705 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3707 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
3708 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
3710 init_list_type_node
= make_node (LANG_TYPE
);
3711 record_unknown_type (init_list_type_node
, "init list");
3714 /* Make sure we get a unique function type, so we can give
3715 its pointer type a name. (This wins for gdb.) */
3716 tree vfunc_type
= make_node (FUNCTION_TYPE
);
3717 TREE_TYPE (vfunc_type
) = integer_type_node
;
3718 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
3719 layout_type (vfunc_type
);
3721 vtable_entry_type
= build_pointer_type (vfunc_type
);
3723 record_builtin_type (RID_MAX
, VTBL_PTR_TYPE
, vtable_entry_type
);
3726 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
3727 layout_type (vtbl_type_node
);
3728 vtbl_type_node
= cp_build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
3729 record_builtin_type (RID_MAX
, NULL
, vtbl_type_node
);
3730 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
3731 layout_type (vtbl_ptr_type_node
);
3732 record_builtin_type (RID_MAX
, NULL
, vtbl_ptr_type_node
);
3734 push_namespace (get_identifier ("__cxxabiv1"));
3735 abi_node
= current_namespace
;
3738 global_type_node
= make_node (LANG_TYPE
);
3739 record_unknown_type (global_type_node
, "global type");
3742 current_lang_name
= lang_name_cplusplus
;
3745 tree newattrs
, extvisattr
;
3746 tree newtype
, deltype
;
3747 tree ptr_ftype_sizetype
;
3751 = build_function_type_list (ptr_type_node
, size_type_node
, NULL_TREE
);
3752 if (cxx_dialect
== cxx98
)
3755 tree bad_alloc_type_node
;
3756 tree bad_alloc_decl
;
3758 push_namespace (std_identifier
);
3759 bad_alloc_id
= get_identifier ("bad_alloc");
3760 bad_alloc_type_node
= make_class_type (RECORD_TYPE
);
3761 TYPE_CONTEXT (bad_alloc_type_node
) = current_namespace
;
3763 = create_implicit_typedef (bad_alloc_id
, bad_alloc_type_node
);
3764 DECL_CONTEXT (bad_alloc_decl
) = current_namespace
;
3768 = add_exception_specifier (NULL_TREE
, bad_alloc_type_node
, -1);
3771 new_eh_spec
= noexcept_false_spec
;
3773 /* Ensure attribs.c is initialized. */
3775 extvisattr
= build_tree_list (get_identifier ("externally_visible"),
3777 newattrs
= tree_cons (get_identifier ("alloc_size"),
3778 build_tree_list (NULL_TREE
, integer_one_node
),
3780 newtype
= cp_build_type_attribute_variant (ptr_ftype_sizetype
, newattrs
);
3781 newtype
= build_exception_variant (newtype
, new_eh_spec
);
3782 deltype
= cp_build_type_attribute_variant (void_ftype_ptr
, extvisattr
);
3783 deltype
= build_exception_variant (deltype
, empty_except_spec
);
3784 push_cp_library_fn (NEW_EXPR
, newtype
);
3785 push_cp_library_fn (VEC_NEW_EXPR
, newtype
);
3786 global_delete_fndecl
= push_cp_library_fn (DELETE_EXPR
, deltype
);
3787 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
);
3789 nullptr_type_node
= make_node (NULLPTR_TYPE
);
3790 TYPE_SIZE (nullptr_type_node
) = bitsize_int (GET_MODE_BITSIZE (ptr_mode
));
3791 TYPE_SIZE_UNIT (nullptr_type_node
) = size_int (GET_MODE_SIZE (ptr_mode
));
3792 TYPE_UNSIGNED (nullptr_type_node
) = 1;
3793 TYPE_PRECISION (nullptr_type_node
) = GET_MODE_BITSIZE (ptr_mode
);
3794 SET_TYPE_MODE (nullptr_type_node
, ptr_mode
);
3795 record_builtin_type (RID_MAX
, "decltype(nullptr)", nullptr_type_node
);
3796 nullptr_node
= build_int_cst (nullptr_type_node
, 0);
3800 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype
);
3802 /* Perform other language dependent initializations. */
3803 init_class_processing ();
3804 init_rtti_processing ();
3805 init_template_processing ();
3807 if (flag_exceptions
)
3808 init_exception_processing ();
3810 if (! supports_one_only ())
3813 make_fname_decl
= cp_make_fname_decl
;
3814 start_fname_decls ();
3816 /* Show we use EH for cleanups. */
3817 if (flag_exceptions
)
3818 using_eh_for_cleanups ();
3821 /* Generate an initializer for a function naming variable from
3822 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3823 filled in with the type of the init. */
3826 cp_fname_init (const char* name
, tree
*type_p
)
3828 tree domain
= NULL_TREE
;
3830 tree init
= NULL_TREE
;
3835 length
= strlen (name
);
3836 domain
= build_index_type (size_int (length
));
3837 init
= build_string (length
+ 1, name
);
3840 type
= cp_build_qualified_type (char_type_node
, TYPE_QUAL_CONST
);
3841 type
= build_cplus_array_type (type
, domain
);
3846 TREE_TYPE (init
) = type
;
3848 init
= error_mark_node
;
3853 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
3854 the decl, LOC is the location to give the decl, NAME is the
3855 initialization string and TYPE_DEP indicates whether NAME depended
3856 on the type of the function. We make use of that to detect
3857 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
3858 at the point of first use, so we mustn't push the decl now. */
3861 cp_make_fname_decl (location_t loc
, tree id
, int type_dep
)
3863 const char *const name
= (type_dep
&& processing_template_decl
3864 ? NULL
: fname_as_string (type_dep
));
3866 tree init
= cp_fname_init (name
, &type
);
3867 tree decl
= build_decl (loc
, VAR_DECL
, id
, type
);
3870 free (CONST_CAST (char *, name
));
3872 /* As we're using pushdecl_with_scope, we must set the context. */
3873 DECL_CONTEXT (decl
) = current_function_decl
;
3875 TREE_STATIC (decl
) = 1;
3876 TREE_READONLY (decl
) = 1;
3877 DECL_ARTIFICIAL (decl
) = 1;
3879 TREE_USED (decl
) = 1;
3881 if (current_function_decl
)
3883 cp_binding_level
*b
= current_binding_level
;
3884 if (b
->kind
== sk_function_parms
)
3885 return error_mark_node
;
3886 while (b
->level_chain
->kind
!= sk_function_parms
)
3888 pushdecl_with_scope (decl
, b
, /*is_friend=*/false);
3889 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, NULL_TREE
,
3890 LOOKUP_ONLYCONVERTING
);
3894 DECL_THIS_STATIC (decl
) = true;
3895 pushdecl_top_level_and_finish (decl
, init
);
3902 builtin_function_1 (tree decl
, tree context
, bool is_global
)
3904 tree id
= DECL_NAME (decl
);
3905 const char *name
= IDENTIFIER_POINTER (id
);
3907 retrofit_lang_decl (decl
);
3909 DECL_ARTIFICIAL (decl
) = 1;
3910 SET_OVERLOADED_OPERATOR_CODE (decl
, ERROR_MARK
);
3911 SET_DECL_LANGUAGE (decl
, lang_c
);
3912 /* Runtime library routines are, by definition, available in an
3913 external shared object. */
3914 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
3915 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
3917 DECL_CONTEXT (decl
) = context
;
3920 pushdecl_top_level (decl
);
3924 /* A function in the user's namespace should have an explicit
3925 declaration before it is used. Mark the built-in function as
3926 anticipated but not actually declared. */
3927 if (name
[0] != '_' || name
[1] != '_')
3928 DECL_ANTICIPATED (decl
) = 1;
3929 else if (strncmp (name
+ 2, "builtin_", strlen ("builtin_")) != 0)
3931 size_t len
= strlen (name
);
3933 /* Treat __*_chk fortification functions as anticipated as well,
3934 unless they are __builtin_*. */
3935 if (len
> strlen ("___chk")
3936 && memcmp (name
+ len
- strlen ("_chk"),
3937 "_chk", strlen ("_chk") + 1) == 0)
3938 DECL_ANTICIPATED (decl
) = 1;
3945 cxx_builtin_function (tree decl
)
3947 tree id
= DECL_NAME (decl
);
3948 const char *name
= IDENTIFIER_POINTER (id
);
3949 /* All builtins that don't begin with an '_' should additionally
3950 go in the 'std' namespace. */
3953 tree decl2
= copy_node(decl
);
3954 push_namespace (std_identifier
);
3955 builtin_function_1 (decl2
, std_node
, false);
3959 return builtin_function_1 (decl
, NULL_TREE
, false);
3962 /* Like cxx_builtin_function, but guarantee the function is added to the global
3963 scope. This is to allow function specific options to add new machine
3964 dependent builtins when the target ISA changes via attribute((target(...)))
3965 which saves space on program startup if the program does not use non-generic
3969 cxx_builtin_function_ext_scope (tree decl
)
3972 tree id
= DECL_NAME (decl
);
3973 const char *name
= IDENTIFIER_POINTER (id
);
3974 /* All builtins that don't begin with an '_' should additionally
3975 go in the 'std' namespace. */
3978 tree decl2
= copy_node(decl
);
3979 push_namespace (std_identifier
);
3980 builtin_function_1 (decl2
, std_node
, true);
3984 return builtin_function_1 (decl
, NULL_TREE
, true);
3987 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
3988 function. Not called directly. */
3991 build_library_fn_1 (tree name
, enum tree_code operator_code
, tree type
)
3993 tree fn
= build_lang_decl (FUNCTION_DECL
, name
, type
);
3994 DECL_EXTERNAL (fn
) = 1;
3995 TREE_PUBLIC (fn
) = 1;
3996 DECL_ARTIFICIAL (fn
) = 1;
3997 SET_OVERLOADED_OPERATOR_CODE (fn
, operator_code
);
3998 SET_DECL_LANGUAGE (fn
, lang_c
);
3999 /* Runtime library routines are, by definition, available in an
4000 external shared object. */
4001 DECL_VISIBILITY (fn
) = VISIBILITY_DEFAULT
;
4002 DECL_VISIBILITY_SPECIFIED (fn
) = 1;
4006 /* Returns the _DECL for a library function with C linkage.
4007 We assume that such functions never throw; if this is incorrect,
4008 callers should unset TREE_NOTHROW. */
4011 build_library_fn (tree name
, tree type
)
4013 tree fn
= build_library_fn_1 (name
, ERROR_MARK
, type
);
4014 TREE_NOTHROW (fn
) = 1;
4018 /* Returns the _DECL for a library function with C++ linkage. */
4021 build_cp_library_fn (tree name
, enum tree_code operator_code
, tree type
)
4023 tree fn
= build_library_fn_1 (name
, operator_code
, type
);
4024 TREE_NOTHROW (fn
) = TYPE_NOTHROW_P (type
);
4025 DECL_CONTEXT (fn
) = FROB_CONTEXT (current_namespace
);
4026 SET_DECL_LANGUAGE (fn
, lang_cplusplus
);
4030 /* Like build_library_fn, but takes a C string instead of an
4034 build_library_fn_ptr (const char* name
, tree type
)
4036 return build_library_fn (get_identifier (name
), type
);
4039 /* Like build_cp_library_fn, but takes a C string instead of an
4043 build_cp_library_fn_ptr (const char* name
, tree type
)
4045 return build_cp_library_fn (get_identifier (name
), ERROR_MARK
, type
);
4048 /* Like build_library_fn, but also pushes the function so that we will
4049 be able to find it via IDENTIFIER_GLOBAL_VALUE. Also, the function
4050 may throw exceptions listed in RAISES. */
4053 push_library_fn (tree name
, tree type
, tree raises
)
4058 type
= build_exception_variant (type
, raises
);
4060 fn
= build_library_fn (name
, type
);
4061 pushdecl_top_level (fn
);
4065 /* Like build_cp_library_fn, but also pushes the function so that it
4066 will be found by normal lookup. */
4069 push_cp_library_fn (enum tree_code operator_code
, tree type
)
4071 tree fn
= build_cp_library_fn (ansi_opname (operator_code
),
4076 apply_tm_attr (fn
, get_identifier ("transaction_safe"));
4080 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
4084 push_void_library_fn (tree name
, tree parmtypes
)
4086 tree type
= build_function_type (void_type_node
, parmtypes
);
4087 return push_library_fn (name
, type
, NULL_TREE
);
4090 /* Like push_library_fn, but also note that this function throws
4091 and does not return. Used for __throw_foo and the like. */
4094 push_throw_library_fn (tree name
, tree type
)
4096 tree fn
= push_library_fn (name
, type
, NULL_TREE
);
4097 TREE_THIS_VOLATILE (fn
) = 1;
4098 TREE_NOTHROW (fn
) = 0;
4102 /* When we call finish_struct for an anonymous union, we create
4103 default copy constructors and such. But, an anonymous union
4104 shouldn't have such things; this function undoes the damage to the
4105 anonymous union type T.
4107 (The reason that we create the synthesized methods is that we don't
4108 distinguish `union { int i; }' from `typedef union { int i; } U'.
4109 The first is an anonymous union; the second is just an ordinary
4113 fixup_anonymous_aggr (tree t
)
4117 /* Wipe out memory of synthesized methods. */
4118 TYPE_HAS_USER_CONSTRUCTOR (t
) = 0;
4119 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
4120 TYPE_HAS_COPY_CTOR (t
) = 0;
4121 TYPE_HAS_CONST_COPY_CTOR (t
) = 0;
4122 TYPE_HAS_COPY_ASSIGN (t
) = 0;
4123 TYPE_HAS_CONST_COPY_ASSIGN (t
) = 0;
4125 /* Splice the implicitly generated functions out of the TYPE_METHODS
4127 q
= &TYPE_METHODS (t
);
4130 if (DECL_ARTIFICIAL (*q
))
4131 *q
= TREE_CHAIN (*q
);
4133 q
= &DECL_CHAIN (*q
);
4136 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
4137 if (TYPE_METHODS (t
))
4139 tree decl
= TYPE_MAIN_DECL (t
);
4141 if (TREE_CODE (t
) != UNION_TYPE
)
4142 error_at (DECL_SOURCE_LOCATION (decl
),
4143 "an anonymous struct cannot have function members");
4145 error_at (DECL_SOURCE_LOCATION (decl
),
4146 "an anonymous union cannot have function members");
4149 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
4150 assignment operators (because they cannot have these methods themselves).
4151 For anonymous unions this is already checked because they are not allowed
4152 in any union, otherwise we have to check it. */
4153 if (TREE_CODE (t
) != UNION_TYPE
)
4157 for (field
= TYPE_FIELDS (t
); field
; field
= DECL_CHAIN (field
))
4158 if (TREE_CODE (field
) == FIELD_DECL
)
4160 type
= TREE_TYPE (field
);
4161 if (CLASS_TYPE_P (type
))
4163 if (TYPE_NEEDS_CONSTRUCTING (type
))
4164 error ("member %q+#D with constructor not allowed "
4165 "in anonymous aggregate", field
);
4166 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
4167 error ("member %q+#D with destructor not allowed "
4168 "in anonymous aggregate", field
);
4169 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type
))
4170 error ("member %q+#D with copy assignment operator "
4171 "not allowed in anonymous aggregate", field
);
4177 /* Warn for an attribute located at LOCATION that appertains to the
4178 class type CLASS_TYPE that has not been properly placed after its
4179 class-key, in it class-specifier. */
4182 warn_misplaced_attr_for_class_type (source_location location
,
4185 gcc_assert (TAGGED_TYPE_P (class_type
));
4187 warning_at (location
, OPT_Wattributes
,
4188 "attribute ignored in declaration "
4189 "of %q#T", class_type
);
4191 "attribute for %q#T must follow the %qs keyword",
4192 class_type
, class_key_or_enum_as_string (class_type
));
4195 /* Make sure that a declaration with no declarator is well-formed, i.e.
4196 just declares a tagged type or anonymous union.
4198 Returns the type declared; or NULL_TREE if none. */
4201 check_tag_decl (cp_decl_specifier_seq
*declspecs
,
4202 bool explicit_type_instantiation_p
)
4204 int saw_friend
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
4205 int saw_typedef
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
4206 /* If a class, struct, or enum type is declared by the DECLSPECS
4207 (i.e, if a class-specifier, enum-specifier, or non-typename
4208 elaborated-type-specifier appears in the DECLSPECS),
4209 DECLARED_TYPE is set to the corresponding type. */
4210 tree declared_type
= NULL_TREE
;
4211 bool error_p
= false;
4213 if (declspecs
->multiple_types_p
)
4214 error ("multiple types in one declaration");
4215 else if (declspecs
->redefined_builtin_type
)
4217 if (!in_system_header
)
4218 permerror (declspecs
->locations
[ds_redefined_builtin_type_spec
],
4219 "redeclaration of C++ built-in type %qT",
4220 declspecs
->redefined_builtin_type
);
4225 && TYPE_P (declspecs
->type
)
4226 && ((TREE_CODE (declspecs
->type
) != TYPENAME_TYPE
4227 && MAYBE_CLASS_TYPE_P (declspecs
->type
))
4228 || TREE_CODE (declspecs
->type
) == ENUMERAL_TYPE
))
4229 declared_type
= declspecs
->type
;
4230 else if (declspecs
->type
== error_mark_node
)
4232 if (declared_type
== NULL_TREE
&& ! saw_friend
&& !error_p
)
4233 permerror (input_location
, "declaration does not declare anything");
4234 else if (declared_type
!= NULL_TREE
&& type_uses_auto (declared_type
))
4236 error ("%<auto%> can only be specified for variables "
4237 "or function declarations");
4238 return error_mark_node
;
4240 /* Check for an anonymous union. */
4241 else if (declared_type
&& RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type
))
4242 && TYPE_ANONYMOUS_P (declared_type
))
4244 /* 7/3 In a simple-declaration, the optional init-declarator-list
4245 can be omitted only when declaring a class (clause 9) or
4246 enumeration (7.2), that is, when the decl-specifier-seq contains
4247 either a class-specifier, an elaborated-type-specifier with
4248 a class-key (9.1), or an enum-specifier. In these cases and
4249 whenever a class-specifier or enum-specifier is present in the
4250 decl-specifier-seq, the identifiers in these specifiers are among
4251 the names being declared by the declaration (as class-name,
4252 enum-names, or enumerators, depending on the syntax). In such
4253 cases, and except for the declaration of an unnamed bit-field (9.6),
4254 the decl-specifier-seq shall introduce one or more names into the
4255 program, or shall redeclare a name introduced by a previous
4256 declaration. [Example:
4257 enum { }; // ill-formed
4258 typedef class { }; // ill-formed
4262 error ("missing type-name in typedef-declaration");
4265 /* Anonymous unions are objects, so they can have specifiers. */;
4266 SET_ANON_AGGR_TYPE_P (declared_type
);
4268 if (TREE_CODE (declared_type
) != UNION_TYPE
&& !in_system_header
)
4269 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ prohibits anonymous structs");
4274 if (decl_spec_seq_has_spec_p (declspecs
, ds_inline
)
4275 || decl_spec_seq_has_spec_p (declspecs
, ds_virtual
))
4276 error ("%qs can only be specified for functions",
4277 decl_spec_seq_has_spec_p (declspecs
, ds_inline
)
4278 ? "inline" : "virtual");
4280 && (!current_class_type
4281 || current_scope () != current_class_type
))
4282 error ("%<friend%> can only be specified inside a class");
4283 else if (decl_spec_seq_has_spec_p (declspecs
, ds_explicit
))
4284 error ("%<explicit%> can only be specified for constructors");
4285 else if (declspecs
->storage_class
)
4286 error ("a storage class can only be specified for objects "
4288 else if (decl_spec_seq_has_spec_p (declspecs
, ds_const
)
4289 || decl_spec_seq_has_spec_p (declspecs
, ds_volatile
)
4290 || decl_spec_seq_has_spec_p (declspecs
, ds_restrict
)
4291 || decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
4292 error ("qualifiers can only be specified for objects "
4294 else if (saw_typedef
)
4295 warning (0, "%<typedef%> was ignored in this declaration");
4296 else if (decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
))
4297 error ("%<constexpr%> cannot be used for type declarations");
4300 if (declspecs
->attributes
&& warn_attributes
&& declared_type
)
4303 if (!CLASS_TYPE_P (declared_type
)
4304 || !CLASSTYPE_TEMPLATE_INSTANTIATION (declared_type
))
4305 /* For a non-template class, use the name location. */
4306 loc
= location_of (declared_type
);
4308 /* For a template class (an explicit instantiation), use the
4309 current location. */
4310 loc
= input_location
;
4312 if (explicit_type_instantiation_p
)
4313 /* [dcl.attr.grammar]/4:
4315 No attribute-specifier-seq shall appertain to an explicit
4318 warning_at (loc
, OPT_Wattributes
,
4319 "attribute ignored in explicit instantiation %q#T",
4322 "no attribute can be applied to "
4323 "an explicit instantiation");
4326 warn_misplaced_attr_for_class_type (loc
, declared_type
);
4329 return declared_type
;
4332 /* Called when a declaration is seen that contains no names to declare.
4333 If its type is a reference to a structure, union or enum inherited
4334 from a containing scope, shadow that tag name for the current scope
4335 with a forward reference.
4336 If its type defines a new named structure or union
4337 or defines an enum, it is valid but we need not do anything here.
4338 Otherwise, it is an error.
4340 C++: may have to grok the declspecs to learn about static,
4341 complain for anonymous unions.
4343 Returns the TYPE declared -- or NULL_TREE if none. */
4346 shadow_tag (cp_decl_specifier_seq
*declspecs
)
4348 tree t
= check_tag_decl (declspecs
,
4349 /*explicit_type_instantiation_p=*/false);
4354 if (maybe_process_partial_specialization (t
) == error_mark_node
)
4357 /* This is where the variables in an anonymous union are
4358 declared. An anonymous union declaration looks like:
4360 because there is no declarator after the union, the parser
4361 sends that declaration here. */
4362 if (ANON_AGGR_TYPE_P (t
))
4364 fixup_anonymous_aggr (t
);
4366 if (TYPE_FIELDS (t
))
4368 tree decl
= grokdeclarator (/*declarator=*/NULL
,
4369 declspecs
, NORMAL
, 0, NULL
);
4370 finish_anon_union (decl
);
4377 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
4380 groktypename (cp_decl_specifier_seq
*type_specifiers
,
4381 const cp_declarator
*declarator
,
4382 bool is_template_arg
)
4386 enum decl_context context
4387 = is_template_arg
? TEMPLATE_TYPE_ARG
: TYPENAME
;
4388 attrs
= type_specifiers
->attributes
;
4389 type_specifiers
->attributes
= NULL_TREE
;
4390 type
= grokdeclarator (declarator
, type_specifiers
, context
, 0, &attrs
);
4391 if (attrs
&& type
!= error_mark_node
)
4393 if (CLASS_TYPE_P (type
))
4394 warning (OPT_Wattributes
, "ignoring attributes applied to class type %qT "
4395 "outside of definition", type
);
4396 else if (MAYBE_CLASS_TYPE_P (type
))
4397 /* A template type parameter or other dependent type. */
4398 warning (OPT_Wattributes
, "ignoring attributes applied to dependent "
4399 "type %qT without an associated declaration", type
);
4401 cplus_decl_attributes (&type
, attrs
, 0);
4406 /* Process a DECLARATOR for a function-scope variable declaration,
4407 namespace-scope variable declaration, or function declaration.
4408 (Function definitions go through start_function; class member
4409 declarations appearing in the body of the class go through
4410 grokfield.) The DECL corresponding to the DECLARATOR is returned.
4411 If an error occurs, the error_mark_node is returned instead.
4413 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
4414 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
4415 for an explicitly defaulted function, or SD_DELETED for an explicitly
4416 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
4417 implicitly initialized via a default constructor. ATTRIBUTES and
4418 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
4420 The scope represented by the context of the returned DECL is pushed
4421 (if it is not the global namespace) and is assigned to
4422 *PUSHED_SCOPE_P. The caller is then responsible for calling
4423 pop_scope on *PUSHED_SCOPE_P if it is set. */
4426 start_decl (const cp_declarator
*declarator
,
4427 cp_decl_specifier_seq
*declspecs
,
4430 tree prefix_attributes
,
4431 tree
*pushed_scope_p
)
4439 *pushed_scope_p
= NULL_TREE
;
4441 /* An object declared as __attribute__((deprecated)) suppresses
4442 warnings of uses of other deprecated items. */
4443 if (lookup_attribute ("deprecated", attributes
))
4444 deprecated_state
= DEPRECATED_SUPPRESS
;
4446 attributes
= chainon (attributes
, prefix_attributes
);
4448 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
4451 deprecated_state
= DEPRECATED_NORMAL
;
4453 if (decl
== NULL_TREE
|| VOID_TYPE_P (decl
)
4454 || decl
== error_mark_node
)
4455 return error_mark_node
;
4457 context
= CP_DECL_CONTEXT (decl
);
4458 if (context
!= global_namespace
)
4459 *pushed_scope_p
= push_scope (context
);
4462 /* Is it valid for this decl to have an initializer at all?
4463 If not, set INITIALIZED to zero, which will indirectly
4464 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
4465 switch (TREE_CODE (decl
))
4468 error ("typedef %qD is initialized (use decltype instead)", decl
);
4469 return error_mark_node
;
4472 if (initialized
== SD_DELETED
)
4473 /* We'll handle the rest of the semantics later, but we need to
4474 set this now so it's visible to duplicate_decls. */
4475 DECL_DELETED_FN (decl
) = 1;
4484 if (! toplevel_bindings_p ()
4485 && DECL_EXTERNAL (decl
))
4486 warning (0, "declaration of %q#D has %<extern%> and is initialized",
4488 DECL_EXTERNAL (decl
) = 0;
4489 if (toplevel_bindings_p ())
4490 TREE_STATIC (decl
) = 1;
4492 alias
= lookup_attribute ("alias", DECL_ATTRIBUTES (decl
)) != 0;
4494 if (alias
&& TREE_CODE (decl
) == FUNCTION_DECL
)
4495 record_key_method_defined (decl
);
4497 /* If this is a typedef that names the class for linkage purposes
4498 (7.1.3p8), apply any attributes directly to the type. */
4499 if (TREE_CODE (decl
) == TYPE_DECL
4500 && TAGGED_TYPE_P (TREE_TYPE (decl
))
4501 && decl
== TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl
))))
4502 flags
= ATTR_FLAG_TYPE_IN_PLACE
;
4506 /* Set attributes here so if duplicate decl, will have proper attributes. */
4507 cplus_decl_attributes (&decl
, attributes
, flags
);
4509 /* Dllimported symbols cannot be defined. Static data members (which
4510 can be initialized in-class and dllimported) go through grokfield,
4511 not here, so we don't need to exclude those decls when checking for
4513 if (initialized
&& DECL_DLLIMPORT_P (decl
))
4515 error ("definition of %q#D is marked %<dllimport%>", decl
);
4516 DECL_DLLIMPORT_P (decl
) = 0;
4519 /* If #pragma weak was used, mark the decl weak now. */
4520 if (!processing_template_decl
)
4521 maybe_apply_pragma_weak (decl
);
4523 if (TREE_CODE (decl
) == FUNCTION_DECL
4524 && DECL_DECLARED_INLINE_P (decl
)
4525 && DECL_UNINLINABLE (decl
)
4526 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
4527 warning (0, "inline function %q+D given attribute noinline", decl
);
4529 if (TYPE_P (context
) && COMPLETE_TYPE_P (complete_type (context
)))
4533 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, false);
4534 if (field
== NULL_TREE
|| !VAR_P (field
))
4535 error ("%q#D is not a static member of %q#T", decl
, context
);
4538 if (DECL_CONTEXT (field
) != context
)
4540 if (!same_type_p (DECL_CONTEXT (field
), context
))
4541 permerror (input_location
, "ISO C++ does not permit %<%T::%D%> "
4542 "to be defined as %<%T::%D%>",
4543 DECL_CONTEXT (field
), DECL_NAME (decl
),
4544 context
, DECL_NAME (decl
));
4545 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
4547 /* Static data member are tricky; an in-class initialization
4548 still doesn't provide a definition, so the in-class
4549 declaration will have DECL_EXTERNAL set, but will have an
4550 initialization. Thus, duplicate_decls won't warn
4551 about this situation, and so we check here. */
4552 if (initialized
&& DECL_INITIALIZED_IN_CLASS_P (field
))
4553 error ("duplicate initialization of %qD", decl
);
4554 if (duplicate_decls (decl
, field
, /*newdecl_is_friend=*/false))
4556 if (decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
)
4557 && !DECL_DECLARED_CONSTEXPR_P (field
))
4558 error ("%qD declared %<constexpr%> outside its class", field
);
4563 tree field
= check_classfn (context
, decl
,
4564 (processing_template_decl
4565 > template_class_depth (context
))
4566 ? current_template_parms
4568 if (field
&& field
!= error_mark_node
4569 && duplicate_decls (decl
, field
,
4570 /*newdecl_is_friend=*/false))
4574 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
4575 DECL_IN_AGGR_P (decl
) = 0;
4576 /* Do not mark DECL as an explicit specialization if it was not
4577 already marked as an instantiation; a declaration should
4578 never be marked as a specialization unless we know what
4579 template is being specialized. */
4580 if (DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
4582 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
4584 /* [temp.expl.spec] An explicit specialization of a static data
4585 member of a template is a definition if the declaration
4586 includes an initializer; otherwise, it is a declaration.
4588 We check for processing_specialization so this only applies
4589 to the new specialization syntax. */
4590 if (!initialized
&& processing_specialization
)
4591 DECL_EXTERNAL (decl
) = 1;
4594 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
)
4595 /* Aliases are definitions. */
4597 permerror (input_location
, "declaration of %q#D outside of class is not definition",
4601 was_public
= TREE_PUBLIC (decl
);
4603 /* Enter this declaration into the symbol table. */
4604 decl
= maybe_push_decl (decl
);
4606 if (processing_template_decl
)
4607 decl
= push_template_decl (decl
);
4608 if (decl
== error_mark_node
)
4609 return error_mark_node
;
4612 && DECL_NAMESPACE_SCOPE_P (decl
) && !TREE_PUBLIC (decl
) && !was_public
4613 && !DECL_THIS_STATIC (decl
) && !DECL_ARTIFICIAL (decl
))
4615 /* This is a const variable with implicit 'static'. Set
4616 DECL_THIS_STATIC so we can tell it from variables that are
4617 !TREE_PUBLIC because of the anonymous namespace. */
4618 gcc_assert (CP_TYPE_CONST_P (TREE_TYPE (decl
)) || errorcount
);
4619 DECL_THIS_STATIC (decl
) = 1;
4622 if (!processing_template_decl
&& VAR_P (decl
))
4623 start_decl_1 (decl
, initialized
);
4628 /* Process the declaration of a variable DECL. INITIALIZED is true
4629 iff DECL is explicitly initialized. (INITIALIZED is false if the
4630 variable is initialized via an implicitly-called constructor.)
4631 This function must be called for ordinary variables (including, for
4632 example, implicit instantiations of templates), but must not be
4633 called for template declarations. */
4636 start_decl_1 (tree decl
, bool initialized
)
4640 bool aggregate_definition_p
;
4642 gcc_assert (!processing_template_decl
);
4644 if (error_operand_p (decl
))
4647 gcc_assert (VAR_P (decl
));
4649 type
= TREE_TYPE (decl
);
4650 complete_p
= COMPLETE_TYPE_P (type
);
4651 aggregate_definition_p
= MAYBE_CLASS_TYPE_P (type
) && !DECL_EXTERNAL (decl
);
4653 /* If an explicit initializer is present, or if this is a definition
4654 of an aggregate, then we need a complete type at this point.
4655 (Scalars are always complete types, so there is nothing to
4656 check.) This code just sets COMPLETE_P; errors (if necessary)
4657 are issued below. */
4658 if ((initialized
|| aggregate_definition_p
)
4660 && COMPLETE_TYPE_P (complete_type (type
)))
4663 /* We will not yet have set TREE_READONLY on DECL if the type
4664 was "const", but incomplete, before this point. But, now, we
4665 have a complete type, so we can try again. */
4666 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
4670 /* Is it valid for this decl to have an initializer at all? */
4672 /* Don't allow initializations for incomplete types except for
4673 arrays which might be completed by the initialization. */
4675 ; /* A complete type is ok. */
4676 else if (type_uses_auto (type
))
4677 ; /* An auto type is ok. */
4678 else if (TREE_CODE (type
) != ARRAY_TYPE
)
4680 error ("variable %q#D has initializer but incomplete type", decl
);
4681 type
= TREE_TYPE (decl
) = error_mark_node
;
4683 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
4685 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
4686 error ("elements of array %q#D have incomplete type", decl
);
4687 /* else we already gave an error in start_decl. */
4690 else if (aggregate_definition_p
&& !complete_p
)
4692 if (type_uses_auto (type
))
4693 error ("declaration of %q#D has no initializer", decl
);
4695 error ("aggregate %q#D has incomplete type and cannot be defined",
4697 /* Change the type so that assemble_variable will give
4698 DECL an rtl we can live with: (mem (const_int 0)). */
4699 type
= TREE_TYPE (decl
) = error_mark_node
;
4702 /* Create a new scope to hold this declaration if necessary.
4703 Whether or not a new scope is necessary cannot be determined
4704 until after the type has been completed; if the type is a
4705 specialization of a class template it is not until after
4706 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4707 will be set correctly. */
4708 maybe_push_cleanup_level (type
);
4711 /* Handle initialization of references. DECL, TYPE, and INIT have the
4712 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
4713 but will be set to a new CLEANUP_STMT if a temporary is created
4714 that must be destroyed subsequently.
4716 Returns an initializer expression to use to initialize DECL, or
4717 NULL if the initialization can be performed statically.
4719 Quotes on semantics can be found in ARM 8.4.3. */
4722 grok_reference_init (tree decl
, tree type
, tree init
, int flags
)
4724 if (init
== NULL_TREE
)
4726 if ((DECL_LANG_SPECIFIC (decl
) == 0
4727 || DECL_IN_AGGR_P (decl
) == 0)
4728 && ! DECL_THIS_EXTERN (decl
))
4729 error ("%qD declared as reference but not initialized", decl
);
4733 if (TREE_CODE (init
) == TREE_LIST
)
4734 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
4735 tf_warning_or_error
);
4737 if (TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
4738 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
4739 /* Note: default conversion is only called in very special cases. */
4740 init
= decay_conversion (init
, tf_warning_or_error
);
4742 /* Convert INIT to the reference type TYPE. This may involve the
4743 creation of a temporary, whose lifetime must be the same as that
4744 of the reference. If so, a DECL_EXPR for the temporary will be
4745 added just after the DECL_EXPR for DECL. That's why we don't set
4746 DECL_INITIAL for local references (instead assigning to them
4747 explicitly); we need to allow the temporary to be initialized
4749 return initialize_reference (type
, init
, flags
,
4750 tf_warning_or_error
);
4753 /* Designated initializers in arrays are not supported in GNU C++.
4754 The parser cannot detect this error since it does not know whether
4755 a given brace-enclosed initializer is for a class type or for an
4756 array. This function checks that CE does not use a designated
4757 initializer. If it does, an error is issued. Returns true if CE
4758 is valid, i.e., does not have a designated initializer. */
4761 check_array_designated_initializer (constructor_elt
*ce
,
4762 unsigned HOST_WIDE_INT index
)
4764 /* Designated initializers for array elements are not supported. */
4767 /* The parser only allows identifiers as designated
4769 if (ce
->index
== error_mark_node
)
4771 error ("name used in a GNU-style designated "
4772 "initializer for an array");
4775 else if (identifier_p (ce
->index
))
4777 error ("name %qD used in a GNU-style designated "
4778 "initializer for an array", ce
->index
);
4782 ce
->index
= cxx_constant_value (ce
->index
);
4784 if (TREE_CODE (ce
->index
) == INTEGER_CST
)
4786 /* A C99 designator is OK if it matches the current index. */
4787 if (TREE_INT_CST_LOW (ce
->index
) == index
)
4790 sorry ("non-trivial designated initializers not supported");
4801 /* When parsing `int a[] = {1, 2};' we don't know the size of the
4802 array until we finish parsing the initializer. If that's the
4803 situation we're in, update DECL accordingly. */
4806 maybe_deduce_size_from_array_init (tree decl
, tree init
)
4808 tree type
= TREE_TYPE (decl
);
4810 if (TREE_CODE (type
) == ARRAY_TYPE
4811 && TYPE_DOMAIN (type
) == NULL_TREE
4812 && TREE_CODE (decl
) != TYPE_DECL
)
4814 /* do_default is really a C-ism to deal with tentative definitions.
4815 But let's leave it here to ease the eventual merge. */
4816 int do_default
= !DECL_EXTERNAL (decl
);
4817 tree initializer
= init
? init
: DECL_INITIAL (decl
);
4820 /* Check that there are no designated initializers in INIT, as
4821 those are not supported in GNU C++, and as the middle-end
4822 will crash if presented with a non-numeric designated
4824 if (initializer
&& TREE_CODE (initializer
) == CONSTRUCTOR
)
4826 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initializer
);
4827 constructor_elt
*ce
;
4829 FOR_EACH_VEC_SAFE_ELT (v
, i
, ce
)
4830 if (!check_array_designated_initializer (ce
, i
))
4836 failure
= cp_complete_array_type (&TREE_TYPE (decl
), initializer
,
4840 error ("initializer fails to determine size of %qD", decl
);
4842 else if (failure
== 2)
4846 error ("array size missing in %qD", decl
);
4848 /* If a `static' var's size isn't known, make it extern as
4849 well as static, so it does not get allocated. If it's not
4850 `static', then don't mark it extern; finish_incomplete_decl
4851 will give it a default size and it will get allocated. */
4852 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
4853 DECL_EXTERNAL (decl
) = 1;
4855 else if (failure
== 3)
4857 error ("zero-size array %qD", decl
);
4861 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl
)), decl
);
4863 relayout_decl (decl
);
4867 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
4868 any appropriate error messages regarding the layout. */
4871 layout_var_decl (tree decl
)
4875 type
= TREE_TYPE (decl
);
4876 if (type
== error_mark_node
)
4879 /* If we haven't already layed out this declaration, do so now.
4880 Note that we must not call complete type for an external object
4881 because it's type might involve templates that we are not
4882 supposed to instantiate yet. (And it's perfectly valid to say
4883 `extern X x' for some incomplete type `X'.) */
4884 if (!DECL_EXTERNAL (decl
))
4885 complete_type (type
);
4886 if (!DECL_SIZE (decl
)
4887 && TREE_TYPE (decl
) != error_mark_node
4888 && (COMPLETE_TYPE_P (type
)
4889 || (TREE_CODE (type
) == ARRAY_TYPE
4890 && !TYPE_DOMAIN (type
)
4891 && COMPLETE_TYPE_P (TREE_TYPE (type
)))))
4892 layout_decl (decl
, 0);
4894 if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
4896 /* An automatic variable with an incomplete type: that is an error.
4897 Don't talk about array types here, since we took care of that
4898 message in grokdeclarator. */
4899 error ("storage size of %qD isn%'t known", decl
);
4900 TREE_TYPE (decl
) = error_mark_node
;
4903 /* Keep this code around in case we later want to control debug info
4904 based on whether a type is "used". (jason 1999-11-11) */
4906 else if (!DECL_EXTERNAL (decl
) && MAYBE_CLASS_TYPE_P (ttype
))
4907 /* Let debugger know it should output info for this type. */
4908 note_debug_info_needed (ttype
);
4910 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
4911 note_debug_info_needed (DECL_CONTEXT (decl
));
4914 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
4915 && DECL_SIZE (decl
) != NULL_TREE
4916 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
4918 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
4919 constant_expression_warning (DECL_SIZE (decl
));
4922 error ("storage size of %qD isn%'t constant", decl
);
4923 TREE_TYPE (decl
) = error_mark_node
;
4928 /* If a local static variable is declared in an inline function, or if
4929 we have a weak definition, we must endeavor to create only one
4930 instance of the variable at link-time. */
4933 maybe_commonize_var (tree decl
)
4935 /* Static data in a function with comdat linkage also has comdat
4937 if (TREE_STATIC (decl
)
4938 /* Don't mess with __FUNCTION__. */
4939 && ! DECL_ARTIFICIAL (decl
)
4940 && DECL_FUNCTION_SCOPE_P (decl
)
4941 && vague_linkage_p (DECL_CONTEXT (decl
)))
4945 /* With weak symbols, we simply make the variable COMDAT;
4946 that will cause copies in multiple translations units to
4948 comdat_linkage (decl
);
4952 if (DECL_INITIAL (decl
) == NULL_TREE
4953 || DECL_INITIAL (decl
) == error_mark_node
)
4955 /* Without weak symbols, we can use COMMON to merge
4956 uninitialized variables. */
4957 TREE_PUBLIC (decl
) = 1;
4958 DECL_COMMON (decl
) = 1;
4962 /* While for initialized variables, we must use internal
4963 linkage -- which means that multiple copies will not
4965 TREE_PUBLIC (decl
) = 0;
4966 DECL_COMMON (decl
) = 0;
4967 warning_at (input_location
, 0,
4968 "sorry: semantics of inline function static "
4969 "data %q+#D are wrong (you%'ll wind up "
4970 "with multiple copies)", decl
);
4971 warning_at (DECL_SOURCE_LOCATION (decl
), 0,
4972 " you can work around this by removing "
4977 else if (DECL_LANG_SPECIFIC (decl
) && DECL_COMDAT (decl
))
4978 /* Set it up again; we might have set DECL_INITIAL since the last
4980 comdat_linkage (decl
);
4983 /* Issue an error message if DECL is an uninitialized const variable. */
4986 check_for_uninitialized_const_var (tree decl
)
4988 tree type
= strip_array_types (TREE_TYPE (decl
));
4990 /* ``Unless explicitly declared extern, a const object does not have
4991 external linkage and must be initialized. ($8.4; $12.1)'' ARM
4994 && TREE_CODE (type
) != REFERENCE_TYPE
4995 && CP_TYPE_CONST_P (type
)
4996 && !DECL_INITIAL (decl
))
4998 tree field
= default_init_uninitialized_part (type
);
5002 permerror (DECL_SOURCE_LOCATION (decl
),
5003 "uninitialized const %qD", decl
);
5005 if (CLASS_TYPE_P (type
))
5007 tree defaulted_ctor
;
5009 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type
)),
5010 "%q#T has no user-provided default constructor", type
);
5011 defaulted_ctor
= in_class_defaulted_default_constructor (type
);
5013 inform (DECL_SOURCE_LOCATION (defaulted_ctor
),
5014 "constructor is not user-provided because it is "
5015 "explicitly defaulted in the class body");
5016 inform (0, "and the implicitly-defined constructor does not "
5017 "initialize %q+#D", field
);
5022 /* Structure holding the current initializer being processed by reshape_init.
5023 CUR is a pointer to the current element being processed, END is a pointer
5024 after the last element present in the initializer. */
5025 typedef struct reshape_iterator_t
5027 constructor_elt
*cur
;
5028 constructor_elt
*end
;
5031 static tree
reshape_init_r (tree
, reshape_iter
*, bool, tsubst_flags_t
);
5033 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
5034 returned is the next FIELD_DECL (possibly FIELD itself) that can be
5035 initialized. If there are no more such fields, the return value
5039 next_initializable_field (tree field
)
5042 && (TREE_CODE (field
) != FIELD_DECL
5043 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
5044 || DECL_ARTIFICIAL (field
)))
5045 field
= DECL_CHAIN (field
);
5050 /* Subroutine of reshape_init_array and reshape_init_vector, which does
5051 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
5052 INTEGER_CST representing the size of the array minus one (the maximum index),
5053 or NULL_TREE if the array was declared without specifying the size. D is
5054 the iterator within the constructor. */
5057 reshape_init_array_1 (tree elt_type
, tree max_index
, reshape_iter
*d
,
5058 tsubst_flags_t complain
)
5061 bool sized_array_p
= (max_index
!= NULL_TREE
);
5062 unsigned HOST_WIDE_INT max_index_cst
= 0;
5063 unsigned HOST_WIDE_INT index
;
5065 /* The initializer for an array is always a CONSTRUCTOR. */
5066 new_init
= build_constructor (init_list_type_node
, NULL
);
5070 /* Minus 1 is used for zero sized arrays. */
5071 if (integer_all_onesp (max_index
))
5074 if (host_integerp (max_index
, 1))
5075 max_index_cst
= tree_low_cst (max_index
, 1);
5076 /* sizetype is sign extended, not zero extended. */
5078 max_index_cst
= tree_low_cst (fold_convert (size_type_node
, max_index
),
5082 /* Loop until there are no more initializers. */
5084 d
->cur
!= d
->end
&& (!sized_array_p
|| index
<= max_index_cst
);
5088 constructor_elt
*old_cur
= d
->cur
;
5090 check_array_designated_initializer (d
->cur
, index
);
5091 elt_init
= reshape_init_r (elt_type
, d
, /*first_initializer_p=*/false,
5093 if (elt_init
== error_mark_node
)
5094 return error_mark_node
;
5095 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
),
5096 size_int (index
), elt_init
);
5097 if (!TREE_CONSTANT (elt_init
))
5098 TREE_CONSTANT (new_init
) = false;
5100 /* This can happen with an invalid initializer (c++/54501). */
5101 if (d
->cur
== old_cur
&& !sized_array_p
)
5108 /* Subroutine of reshape_init_r, processes the initializers for arrays.
5109 Parameters are the same of reshape_init_r. */
5112 reshape_init_array (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5114 tree max_index
= NULL_TREE
;
5116 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
5118 if (TYPE_DOMAIN (type
))
5119 max_index
= array_type_nelts (type
);
5121 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5124 /* Subroutine of reshape_init_r, processes the initializers for vectors.
5125 Parameters are the same of reshape_init_r. */
5128 reshape_init_vector (tree type
, reshape_iter
*d
, tsubst_flags_t complain
)
5130 tree max_index
= NULL_TREE
;
5132 gcc_assert (TREE_CODE (type
) == VECTOR_TYPE
);
5134 if (COMPOUND_LITERAL_P (d
->cur
->value
))
5136 tree value
= d
->cur
->value
;
5137 if (!same_type_p (TREE_TYPE (value
), type
))
5139 if (complain
& tf_error
)
5140 error ("invalid type %qT as initializer for a vector of type %qT",
5141 TREE_TYPE (d
->cur
->value
), type
);
5142 value
= error_mark_node
;
5148 /* For a vector, we initialize it as an array of the appropriate size. */
5149 if (TREE_CODE (type
) == VECTOR_TYPE
)
5150 max_index
= size_int (TYPE_VECTOR_SUBPARTS (type
) - 1);
5152 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
, complain
);
5155 /* Subroutine of reshape_init_r, processes the initializers for classes
5156 or union. Parameters are the same of reshape_init_r. */
5159 reshape_init_class (tree type
, reshape_iter
*d
, bool first_initializer_p
,
5160 tsubst_flags_t complain
)
5165 gcc_assert (CLASS_TYPE_P (type
));
5167 /* The initializer for a class is always a CONSTRUCTOR. */
5168 new_init
= build_constructor (init_list_type_node
, NULL
);
5169 field
= next_initializable_field (TYPE_FIELDS (type
));
5175 An initializer for an aggregate member that is an
5176 empty class shall have the form of an empty
5177 initializer-list {}. */
5178 if (!first_initializer_p
)
5180 if (complain
& tf_error
)
5181 error ("initializer for %qT must be brace-enclosed", type
);
5182 return error_mark_node
;
5187 /* Loop through the initializable fields, gathering initializers. */
5188 while (d
->cur
!= d
->end
)
5191 constructor_elt
*old_cur
= d
->cur
;
5193 /* Handle designated initializers, as an extension. */
5196 if (TREE_CODE (d
->cur
->index
) == INTEGER_CST
)
5198 if (complain
& tf_error
)
5199 error ("%<[%E] =%> used in a GNU-style designated initializer"
5200 " for class %qT", d
->cur
->index
, type
);
5201 return error_mark_node
;
5204 if (TREE_CODE (d
->cur
->index
) == FIELD_DECL
)
5205 /* We already reshaped this. */
5206 gcc_assert (d
->cur
->index
== field
);
5208 field
= lookup_field_1 (type
, d
->cur
->index
, /*want_type=*/false);
5210 if (!field
|| TREE_CODE (field
) != FIELD_DECL
)
5212 if (complain
& tf_error
)
5213 error ("%qT has no non-static data member named %qD", type
,
5215 return error_mark_node
;
5219 /* If we processed all the member of the class, we are done. */
5223 field_init
= reshape_init_r (TREE_TYPE (field
), d
,
5224 /*first_initializer_p=*/false, complain
);
5225 if (field_init
== error_mark_node
)
5226 return error_mark_node
;
5228 if (d
->cur
== old_cur
&& d
->cur
->index
)
5230 /* This can happen with an invalid initializer for a flexible
5231 array member (c++/54441). */
5232 if (complain
& tf_error
)
5233 error ("invalid initializer for %q#D", field
);
5234 return error_mark_node
;
5237 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
), field
, field_init
);
5241 When a union is initialized with a brace-enclosed
5242 initializer, the braces shall only contain an
5243 initializer for the first member of the union. */
5244 if (TREE_CODE (type
) == UNION_TYPE
)
5247 field
= next_initializable_field (DECL_CHAIN (field
));
5253 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
5254 designators are not valid; either complain or return true to indicate
5255 that reshape_init_r should return error_mark_node. */
5258 has_designator_problem (reshape_iter
*d
, tsubst_flags_t complain
)
5262 if (complain
& tf_error
)
5263 error ("C99 designator %qE outside aggregate initializer",
5271 /* Subroutine of reshape_init, which processes a single initializer (part of
5272 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
5273 iterator within the CONSTRUCTOR which points to the initializer to process.
5274 FIRST_INITIALIZER_P is true if this is the first initializer of the
5275 outermost CONSTRUCTOR node. */
5278 reshape_init_r (tree type
, reshape_iter
*d
, bool first_initializer_p
,
5279 tsubst_flags_t complain
)
5281 tree init
= d
->cur
->value
;
5283 if (error_operand_p (init
))
5284 return error_mark_node
;
5286 if (first_initializer_p
&& !CP_AGGREGATE_TYPE_P (type
)
5287 && has_designator_problem (d
, complain
))
5288 return error_mark_node
;
5290 if (TREE_CODE (type
) == COMPLEX_TYPE
)
5292 /* A complex type can be initialized from one or two initializers,
5293 but braces are not elided. */
5295 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
5297 if (CONSTRUCTOR_NELTS (init
) > 2)
5299 if (complain
& tf_error
)
5300 error ("too many initializers for %qT", type
);
5302 return error_mark_node
;
5305 else if (first_initializer_p
&& d
->cur
!= d
->end
)
5307 vec
<constructor_elt
, va_gc
> *v
= 0;
5308 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, init
);
5309 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, d
->cur
->value
);
5310 if (has_designator_problem (d
, complain
))
5311 return error_mark_node
;
5313 init
= build_constructor (init_list_type_node
, v
);
5318 /* A non-aggregate type is always initialized with a single
5320 if (!CP_AGGREGATE_TYPE_P (type
))
5322 /* It is invalid to initialize a non-aggregate type with a
5323 brace-enclosed initializer before C++0x.
5324 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
5325 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
5326 a CONSTRUCTOR (with a record type). */
5327 if (TREE_CODE (init
) == CONSTRUCTOR
5328 && BRACE_ENCLOSED_INITIALIZER_P (init
)) /* p7626.C */
5330 if (SCALAR_TYPE_P (type
))
5332 if (complain
& tf_error
)
5333 error ("braces around scalar initializer for type %qT", type
);
5334 init
= error_mark_node
;
5337 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
5346 All implicit type conversions (clause _conv_) are considered when
5347 initializing the aggregate member with an initializer from an
5348 initializer-list. If the initializer can initialize a member,
5349 the member is initialized. Otherwise, if the member is itself a
5350 non-empty subaggregate, brace elision is assumed and the
5351 initializer is considered for the initialization of the first
5352 member of the subaggregate. */
5353 if (TREE_CODE (init
) != CONSTRUCTOR
5354 /* But don't try this for the first initializer, since that would be
5355 looking through the outermost braces; A a2 = { a1 }; is not a
5356 valid aggregate initialization. */
5357 && !first_initializer_p
5358 && (same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (init
))
5359 || can_convert_arg (type
, TREE_TYPE (init
), init
, LOOKUP_NORMAL
,
5366 /* [dcl.init.string]
5368 A char array (whether plain char, signed char, or unsigned char)
5369 can be initialized by a string-literal (optionally enclosed in
5370 braces); a wchar_t array can be initialized by a wide
5371 string-literal (optionally enclosed in braces). */
5372 if (TREE_CODE (type
) == ARRAY_TYPE
5373 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type
))))
5375 tree str_init
= init
;
5377 /* Strip one level of braces if and only if they enclose a single
5378 element (as allowed by [dcl.init.string]). */
5379 if (!first_initializer_p
5380 && TREE_CODE (str_init
) == CONSTRUCTOR
5381 && vec_safe_length (CONSTRUCTOR_ELTS (str_init
)) == 1)
5383 str_init
= (*CONSTRUCTOR_ELTS (str_init
))[0].value
;
5386 /* If it's a string literal, then it's the initializer for the array
5387 as a whole. Otherwise, continue with normal initialization for
5388 array types (one value per array element). */
5389 if (TREE_CODE (str_init
) == STRING_CST
)
5391 if (has_designator_problem (d
, complain
))
5392 return error_mark_node
;
5398 /* The following cases are about aggregates. If we are not within a full
5399 initializer already, and there is not a CONSTRUCTOR, it means that there
5400 is a missing set of braces (that is, we are processing the case for
5401 which reshape_init exists). */
5402 if (!first_initializer_p
)
5404 if (TREE_CODE (init
) == CONSTRUCTOR
)
5406 if (TREE_TYPE (init
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init
)))
5407 /* There is no need to reshape pointer-to-member function
5408 initializers, as they are always constructed correctly
5409 by the front end. */
5411 else if (COMPOUND_LITERAL_P (init
))
5412 /* For a nested compound literal, there is no need to reshape since
5413 brace elision is not allowed. Even if we decided to allow it,
5414 we should add a call to reshape_init in finish_compound_literal,
5415 before calling digest_init, so changing this code would still
5416 not be necessary. */
5417 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init
));
5421 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
5422 return reshape_init (type
, init
, complain
);
5426 warning (OPT_Wmissing_braces
, "missing braces around initializer for %qT",
5430 /* Dispatch to specialized routines. */
5431 if (CLASS_TYPE_P (type
))
5432 return reshape_init_class (type
, d
, first_initializer_p
, complain
);
5433 else if (TREE_CODE (type
) == ARRAY_TYPE
)
5434 return reshape_init_array (type
, d
, complain
);
5435 else if (TREE_CODE (type
) == VECTOR_TYPE
)
5436 return reshape_init_vector (type
, d
, complain
);
5441 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
5442 brace-enclosed aggregate initializer.
5444 INIT is the CONSTRUCTOR containing the list of initializers describing
5445 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
5446 It may not presently match the shape of the TYPE; for example:
5448 struct S { int a; int b; };
5449 struct S a[] = { 1, 2, 3, 4 };
5451 Here INIT will hold a vector of four elements, rather than a
5452 vector of two elements, each itself a vector of two elements. This
5453 routine transforms INIT from the former form into the latter. The
5454 revised CONSTRUCTOR node is returned. */
5457 reshape_init (tree type
, tree init
, tsubst_flags_t complain
)
5459 vec
<constructor_elt
, va_gc
> *v
;
5463 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
5465 v
= CONSTRUCTOR_ELTS (init
);
5467 /* An empty constructor does not need reshaping, and it is always a valid
5469 if (vec_safe_is_empty (v
))
5472 /* Recurse on this CONSTRUCTOR. */
5474 d
.end
= d
.cur
+ v
->length ();
5476 new_init
= reshape_init_r (type
, &d
, true, complain
);
5477 if (new_init
== error_mark_node
)
5478 return error_mark_node
;
5480 /* Make sure all the element of the constructor were used. Otherwise,
5481 issue an error about exceeding initializers. */
5484 if (complain
& tf_error
)
5485 error ("too many initializers for %qT", type
);
5487 return error_mark_node
;
5493 /* Verify array initializer. Returns true if errors have been reported. */
5496 check_array_initializer (tree decl
, tree type
, tree init
)
5498 tree element_type
= TREE_TYPE (type
);
5500 /* The array type itself need not be complete, because the
5501 initializer may tell us how many elements are in the array.
5502 But, the elements of the array must be complete. */
5503 if (!COMPLETE_TYPE_P (complete_type (element_type
)))
5506 error ("elements of array %q#D have incomplete type", decl
);
5508 error ("elements of array %q#T have incomplete type", type
);
5511 /* It is not valid to initialize a VLA. */
5513 && ((COMPLETE_TYPE_P (type
) && !TREE_CONSTANT (TYPE_SIZE (type
)))
5514 || !TREE_CONSTANT (TYPE_SIZE (element_type
))))
5517 error ("variable-sized object %qD may not be initialized", decl
);
5519 error ("variable-sized compound literal");
5525 /* Subroutine of check_initializer; args are passed down from that function.
5526 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
5529 build_aggr_init_full_exprs (tree decl
, tree init
, int flags
)
5532 gcc_assert (stmts_are_full_exprs_p ());
5533 return build_aggr_init (decl
, init
, flags
, tf_warning_or_error
);
5536 /* Verify INIT (the initializer for DECL), and record the
5537 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
5538 grok_reference_init.
5540 If the return value is non-NULL, it is an expression that must be
5541 evaluated dynamically to initialize DECL. */
5544 check_initializer (tree decl
, tree init
, int flags
, vec
<tree
, va_gc
> **cleanups
)
5546 tree type
= TREE_TYPE (decl
);
5547 tree init_code
= NULL
;
5548 tree extra_init
= NULL_TREE
;
5551 /* Things that are going to be initialized need to have complete
5553 TREE_TYPE (decl
) = type
= complete_type (TREE_TYPE (decl
));
5555 if (DECL_HAS_VALUE_EXPR_P (decl
))
5557 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
5558 it doesn't have storage to be initialized. */
5559 gcc_assert (init
== NULL_TREE
);
5563 if (type
== error_mark_node
)
5564 /* We will have already complained. */
5567 if (TREE_CODE (type
) == ARRAY_TYPE
)
5569 if (check_array_initializer (decl
, type
, init
))
5572 else if (!COMPLETE_TYPE_P (type
))
5574 error ("%q#D has incomplete type", decl
);
5575 TREE_TYPE (decl
) = error_mark_node
;
5579 /* There is no way to make a variable-sized class type in GNU C++. */
5580 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type
)));
5582 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
))
5584 int init_len
= vec_safe_length (CONSTRUCTOR_ELTS (init
));
5585 if (SCALAR_TYPE_P (type
))
5589 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
5590 init
= build_zero_init (type
, NULL_TREE
, false);
5592 else if (init_len
!= 1 && TREE_CODE (type
) != COMPLEX_TYPE
)
5594 error ("scalar object %qD requires one element in initializer",
5596 TREE_TYPE (decl
) = error_mark_node
;
5602 if (TREE_CODE (decl
) == CONST_DECL
)
5604 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
5606 DECL_INITIAL (decl
) = init
;
5608 gcc_assert (init
!= NULL_TREE
);
5611 else if (!init
&& DECL_REALLY_EXTERN (decl
))
5613 else if (init
|| type_build_ctor_call (type
)
5614 || TREE_CODE (type
) == REFERENCE_TYPE
)
5616 if (TREE_CODE (type
) == REFERENCE_TYPE
)
5618 init
= grok_reference_init (decl
, type
, init
, flags
);
5619 flags
|= LOOKUP_ALREADY_DIGESTED
;
5622 check_for_uninitialized_const_var (decl
);
5623 /* Do not reshape constructors of vectors (they don't need to be
5625 else if (BRACE_ENCLOSED_INITIALIZER_P (init
))
5627 if (is_std_init_list (type
))
5629 init
= perform_implicit_conversion (type
, init
,
5630 tf_warning_or_error
);
5631 flags
|= LOOKUP_ALREADY_DIGESTED
;
5633 else if (TYPE_NON_AGGREGATE_CLASS (type
))
5635 /* Don't reshape if the class has constructors. */
5636 if (cxx_dialect
== cxx98
)
5637 error ("in C++98 %qD must be initialized by constructor, "
5641 else if (TREE_CODE (type
) == VECTOR_TYPE
&& TYPE_VECTOR_OPAQUE (type
))
5643 error ("opaque vector types cannot be initialized");
5644 init
= error_mark_node
;
5648 init
= reshape_init (type
, init
, tf_warning_or_error
);
5649 if (SCALAR_TYPE_P (type
))
5650 check_narrowing (type
, init
);
5654 /* If DECL has an array type without a specific bound, deduce the
5655 array size from the initializer. */
5656 maybe_deduce_size_from_array_init (decl
, init
);
5657 type
= TREE_TYPE (decl
);
5658 if (type
== error_mark_node
)
5661 if ((type_build_ctor_call (type
) || CLASS_TYPE_P (type
))
5662 && !(flags
& LOOKUP_ALREADY_DIGESTED
)
5663 && !(init
&& BRACE_ENCLOSED_INITIALIZER_P (init
)
5664 && CP_AGGREGATE_TYPE_P (type
)
5665 && (CLASS_TYPE_P (type
)
5666 || type_has_extended_temps (type
))))
5668 init_code
= build_aggr_init_full_exprs (decl
, init
, flags
);
5670 /* A constructor call is a non-trivial initializer even if
5671 it isn't explicitly written. */
5672 if (TREE_SIDE_EFFECTS (init_code
))
5673 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = true;
5675 /* If this is a constexpr initializer, expand_default_init will
5676 have returned an INIT_EXPR rather than a CALL_EXPR. In that
5677 case, pull the initializer back out and pass it down into
5678 store_init_value. */
5679 while (TREE_CODE (init_code
) == EXPR_STMT
5680 || TREE_CODE (init_code
) == CONVERT_EXPR
)
5681 init_code
= TREE_OPERAND (init_code
, 0);
5682 if (TREE_CODE (init_code
) == INIT_EXPR
)
5684 init
= TREE_OPERAND (init_code
, 1);
5685 init_code
= NULL_TREE
;
5686 /* Don't call digest_init; it's unnecessary and will complain
5687 about aggregate initialization of non-aggregate classes. */
5688 flags
|= LOOKUP_ALREADY_DIGESTED
;
5690 else if (DECL_DECLARED_CONSTEXPR_P (decl
))
5692 /* Declared constexpr, but no suitable initializer; massage
5693 init appropriately so we can pass it into store_init_value
5695 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
))
5696 init
= finish_compound_literal (type
, init
,
5697 tf_warning_or_error
);
5698 else if (CLASS_TYPE_P (type
)
5699 && (!init
|| TREE_CODE (init
) == TREE_LIST
))
5701 init
= build_functional_cast (type
, init
, tf_none
);
5702 if (TREE_CODE (init
) == TARGET_EXPR
)
5703 TARGET_EXPR_DIRECT_INIT_P (init
) = true;
5705 init_code
= NULL_TREE
;
5711 if (init
&& TREE_CODE (init
) != TREE_VEC
)
5713 /* In aggregate initialization of a variable, each element
5714 initialization is a full-expression because there is no
5715 enclosing expression. */
5716 gcc_assert (stmts_are_full_exprs_p ());
5718 init_code
= store_init_value (decl
, init
, cleanups
, flags
);
5720 if (pedantic
&& TREE_CODE (type
) == ARRAY_TYPE
5721 && DECL_INITIAL (decl
)
5722 && TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
5723 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl
)))
5724 warning (0, "array %qD initialized by parenthesized string literal %qE",
5725 decl
, DECL_INITIAL (decl
));
5731 if (CLASS_TYPE_P (core_type
= strip_array_types (type
))
5732 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
)
5733 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
)))
5734 diagnose_uninitialized_cst_or_ref_member (core_type
, /*using_new=*/false,
5737 check_for_uninitialized_const_var (decl
);
5740 if (init
&& init
!= error_mark_node
)
5741 init_code
= build2 (INIT_EXPR
, type
, decl
, init
);
5744 init_code
= add_stmt_to_compound (extra_init
, init_code
);
5746 if (init_code
&& DECL_IN_AGGR_P (decl
))
5748 static int explained
= 0;
5750 if (cxx_dialect
< cxx0x
)
5751 error ("initializer invalid for static member with constructor");
5753 error ("non-constant in-class initialization invalid for static "
5754 "member %qD", decl
);
5757 error ("(an out of class initialization is required)");
5765 /* If DECL is not a local variable, give it RTL. */
5768 make_rtl_for_nonlocal_decl (tree decl
, tree init
, const char* asmspec
)
5770 int toplev
= toplevel_bindings_p ();
5772 const char *filename
;
5774 /* Set the DECL_ASSEMBLER_NAME for the object. */
5777 /* The `register' keyword, when used together with an
5778 asm-specification, indicates that the variable should be
5779 placed in a particular register. */
5780 if (VAR_P (decl
) && DECL_REGISTER (decl
))
5782 set_user_assembler_name (decl
, asmspec
);
5783 DECL_HARD_REGISTER (decl
) = 1;
5787 if (TREE_CODE (decl
) == FUNCTION_DECL
5788 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
5789 set_builtin_user_assembler_name (decl
, asmspec
);
5790 set_user_assembler_name (decl
, asmspec
);
5794 /* Handle non-variables up front. */
5797 rest_of_decl_compilation (decl
, toplev
, at_eof
);
5801 /* If we see a class member here, it should be a static data
5803 if (DECL_LANG_SPECIFIC (decl
) && DECL_IN_AGGR_P (decl
))
5805 gcc_assert (TREE_STATIC (decl
));
5806 /* An in-class declaration of a static data member should be
5807 external; it is only a declaration, and not a definition. */
5808 if (init
== NULL_TREE
)
5809 gcc_assert (DECL_EXTERNAL (decl
) || !TREE_PUBLIC (decl
));
5812 /* We don't create any RTL for local variables. */
5813 if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
5816 /* We defer emission of local statics until the corresponding
5817 DECL_EXPR is expanded. */
5818 defer_p
= DECL_FUNCTION_SCOPE_P (decl
) || DECL_VIRTUAL_P (decl
);
5820 /* We try to defer namespace-scope static constants so that they are
5821 not emitted into the object file unnecessarily. */
5822 filename
= input_filename
;
5823 if (!DECL_VIRTUAL_P (decl
)
5824 && TREE_READONLY (decl
)
5825 && DECL_INITIAL (decl
) != NULL_TREE
5826 && DECL_INITIAL (decl
) != error_mark_node
5828 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
))
5830 && !TREE_PUBLIC (decl
))
5832 /* Fool with the linkage of static consts according to #pragma
5834 struct c_fileinfo
*finfo
= get_fileinfo (filename
);
5835 if (!finfo
->interface_unknown
&& !TREE_PUBLIC (decl
))
5837 TREE_PUBLIC (decl
) = 1;
5838 DECL_EXTERNAL (decl
) = finfo
->interface_only
;
5843 /* Likewise for template instantiations. */
5844 else if (DECL_LANG_SPECIFIC (decl
)
5845 && DECL_IMPLICIT_INSTANTIATION (decl
))
5848 /* If we're not deferring, go ahead and assemble the variable. */
5850 rest_of_decl_compilation (decl
, toplev
, at_eof
);
5853 /* walk_tree helper for wrap_temporary_cleanups, below. */
5856 wrap_cleanups_r (tree
*stmt_p
, int *walk_subtrees
, void *data
)
5858 /* Stop at types or full-expression boundaries. */
5859 if (TYPE_P (*stmt_p
)
5860 || TREE_CODE (*stmt_p
) == CLEANUP_POINT_EXPR
)
5866 if (TREE_CODE (*stmt_p
) == TARGET_EXPR
)
5868 tree guard
= (tree
)data
;
5869 tree tcleanup
= TARGET_EXPR_CLEANUP (*stmt_p
);
5871 tcleanup
= build2 (TRY_CATCH_EXPR
, void_type_node
, tcleanup
, guard
);
5872 /* Tell honor_protect_cleanup_actions to handle this as a separate
5874 TRY_CATCH_IS_CLEANUP (tcleanup
) = 1;
5876 TARGET_EXPR_CLEANUP (*stmt_p
) = tcleanup
;
5882 /* We're initializing a local variable which has a cleanup GUARD. If there
5883 are any temporaries used in the initializer INIT of this variable, we
5884 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
5885 variable will be cleaned up properly if one of them throws.
5887 Unfortunately, there's no way to express this properly in terms of
5888 nesting, as the regions for the temporaries overlap the region for the
5889 variable itself; if there are two temporaries, the variable needs to be
5890 the first thing destroyed if either of them throws. However, we only
5891 want to run the variable's cleanup if it actually got constructed. So
5892 we need to guard the temporary cleanups with the variable's cleanup if
5893 they are run on the normal path, but not if they are run on the
5894 exceptional path. We implement this by telling
5895 honor_protect_cleanup_actions to strip the variable cleanup from the
5896 exceptional path. */
5899 wrap_temporary_cleanups (tree init
, tree guard
)
5901 cp_walk_tree_without_duplicates (&init
, wrap_cleanups_r
, (void *)guard
);
5904 /* Generate code to initialize DECL (a local variable). */
5907 initialize_local_var (tree decl
, tree init
)
5909 tree type
= TREE_TYPE (decl
);
5913 gcc_assert (VAR_P (decl
)
5914 || TREE_CODE (decl
) == RESULT_DECL
);
5915 gcc_assert (!TREE_STATIC (decl
));
5917 if (DECL_SIZE (decl
) == NULL_TREE
)
5919 /* If we used it already as memory, it must stay in memory. */
5920 DECL_INITIAL (decl
) = NULL_TREE
;
5921 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
5925 if (type
== error_mark_node
)
5928 /* Compute and store the initial value. */
5929 already_used
= TREE_USED (decl
) || TREE_USED (type
);
5930 if (TREE_USED (type
))
5931 DECL_READ_P (decl
) = 1;
5933 /* Generate a cleanup, if necessary. */
5934 cleanup
= cxx_maybe_build_cleanup (decl
, tf_warning_or_error
);
5936 /* Perform the initialization. */
5939 if (TREE_CODE (init
) == INIT_EXPR
5940 && !TREE_SIDE_EFFECTS (TREE_OPERAND (init
, 1)))
5942 /* Stick simple initializers in DECL_INITIAL so that
5943 -Wno-init-self works (c++/34772). */
5944 gcc_assert (TREE_OPERAND (init
, 0) == decl
);
5945 DECL_INITIAL (decl
) = TREE_OPERAND (init
, 1);
5949 int saved_stmts_are_full_exprs_p
;
5951 /* If we're only initializing a single object, guard the
5952 destructors of any temporaries used in its initializer with
5953 its destructor. This isn't right for arrays because each
5954 element initialization is a full-expression. */
5955 if (cleanup
&& TREE_CODE (type
) != ARRAY_TYPE
)
5956 wrap_temporary_cleanups (init
, cleanup
);
5958 gcc_assert (building_stmt_list_p ());
5959 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
5960 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
5961 finish_expr_stmt (init
);
5962 current_stmt_tree ()->stmts_are_full_exprs_p
=
5963 saved_stmts_are_full_exprs_p
;
5967 /* Set this to 0 so we can tell whether an aggregate which was
5968 initialized was ever used. Don't do this if it has a
5969 destructor, so we don't complain about the 'resource
5970 allocation is initialization' idiom. Now set
5971 attribute((unused)) on types so decls of that type will be
5972 marked used. (see TREE_USED, above.) */
5973 if (TYPE_NEEDS_CONSTRUCTING (type
)
5975 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type
)
5976 && DECL_NAME (decl
))
5977 TREE_USED (decl
) = 0;
5978 else if (already_used
)
5979 TREE_USED (decl
) = 1;
5982 finish_decl_cleanup (decl
, cleanup
);
5985 /* DECL is a VAR_DECL for a compiler-generated variable with static
5986 storage duration (like a virtual table) whose initializer is a
5987 compile-time constant. Initialize the variable and provide it to the
5991 initialize_artificial_var (tree decl
, vec
<constructor_elt
, va_gc
> *v
)
5994 gcc_assert (DECL_ARTIFICIAL (decl
));
5995 init
= build_constructor (TREE_TYPE (decl
), v
);
5996 gcc_assert (TREE_CODE (init
) == CONSTRUCTOR
);
5997 DECL_INITIAL (decl
) = init
;
5998 DECL_INITIALIZED_P (decl
) = 1;
5999 determine_visibility (decl
);
6000 layout_var_decl (decl
);
6001 maybe_commonize_var (decl
);
6002 make_rtl_for_nonlocal_decl (decl
, init
, /*asmspec=*/NULL
);
6005 /* INIT is the initializer for a variable, as represented by the
6006 parser. Returns true iff INIT is type-dependent. */
6009 type_dependent_init_p (tree init
)
6011 if (TREE_CODE (init
) == TREE_LIST
)
6012 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6013 return any_type_dependent_elements_p (init
);
6014 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6015 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6017 vec
<constructor_elt
, va_gc
> *elts
;
6021 elts
= CONSTRUCTOR_ELTS (init
);
6022 nelts
= vec_safe_length (elts
);
6023 for (i
= 0; i
< nelts
; ++i
)
6024 if (type_dependent_init_p ((*elts
)[i
].value
))
6028 /* It must be a simple expression, e.g., int i = 3; */
6029 return type_dependent_expression_p (init
);
6034 /* INIT is the initializer for a variable, as represented by the
6035 parser. Returns true iff INIT is value-dependent. */
6038 value_dependent_init_p (tree init
)
6040 if (TREE_CODE (init
) == TREE_LIST
)
6041 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6042 return any_value_dependent_elements_p (init
);
6043 else if (TREE_CODE (init
) == CONSTRUCTOR
)
6044 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6046 vec
<constructor_elt
, va_gc
> *elts
;
6050 elts
= CONSTRUCTOR_ELTS (init
);
6051 nelts
= vec_safe_length (elts
);
6052 for (i
= 0; i
< nelts
; ++i
)
6053 if (value_dependent_init_p ((*elts
)[i
].value
))
6057 /* It must be a simple expression, e.g., int i = 3; */
6058 return value_dependent_expression_p (init
);
6063 /* Finish processing of a declaration;
6064 install its line number and initial value.
6065 If the length of an array type is not known before,
6066 it must be determined now, from the initial value, or it is an error.
6068 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
6069 true, then INIT is an integral constant expression.
6071 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
6072 if the (init) syntax was used. */
6075 cp_finish_decl (tree decl
, tree init
, bool init_const_expr_p
,
6076 tree asmspec_tree
, int flags
)
6079 vec
<tree
, va_gc
> *cleanups
= NULL
;
6080 const char *asmspec
= NULL
;
6081 int was_readonly
= 0;
6082 bool var_definition_p
= false;
6085 if (decl
== error_mark_node
)
6090 error ("assignment (not initialization) in declaration");
6094 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
6095 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
6096 gcc_assert (TREE_CODE (decl
) != PARM_DECL
);
6098 type
= TREE_TYPE (decl
);
6099 if (type
== error_mark_node
)
6102 /* If a name was specified, get the string. */
6103 if (at_namespace_scope_p ())
6104 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
6105 if (asmspec_tree
&& asmspec_tree
!= error_mark_node
)
6106 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
6108 if (current_class_type
6109 && CP_DECL_CONTEXT (decl
) == current_class_type
6110 && TYPE_BEING_DEFINED (current_class_type
)
6111 && !CLASSTYPE_TEMPLATE_INSTANTIATION (current_class_type
)
6112 && (DECL_INITIAL (decl
) || init
))
6113 DECL_INITIALIZED_IN_CLASS_P (decl
) = 1;
6115 if (TREE_CODE (decl
) != FUNCTION_DECL
6116 && (auto_node
= type_uses_auto (type
)))
6119 if (init
== NULL_TREE
)
6121 if (DECL_LANG_SPECIFIC (decl
)
6122 && DECL_TEMPLATE_INSTANTIATION (decl
)
6123 && !DECL_TEMPLATE_INSTANTIATED (decl
))
6125 /* init is null because we're deferring instantiating the
6126 initializer until we need it. Well, we need it now. */
6127 instantiate_decl (decl
, /*defer_ok*/true, /*expl*/false);
6131 error ("declaration of %q#D has no initializer", decl
);
6132 TREE_TYPE (decl
) = error_mark_node
;
6136 if (TREE_CODE (d_init
) == TREE_LIST
)
6137 d_init
= build_x_compound_expr_from_list (d_init
, ELK_INIT
,
6138 tf_warning_or_error
);
6139 d_init
= resolve_nondeduced_context (d_init
);
6140 type
= TREE_TYPE (decl
) = do_auto_deduction (type
, d_init
,
6142 if (type
== error_mark_node
)
6146 if (!ensure_literal_type_for_constexpr_object (decl
))
6147 DECL_DECLARED_CONSTEXPR_P (decl
) = 0;
6150 && DECL_CLASS_SCOPE_P (decl
)
6151 && DECL_INITIALIZED_IN_CLASS_P (decl
))
6152 check_static_variable_definition (decl
, type
);
6154 if (init
&& TREE_CODE (decl
) == FUNCTION_DECL
)
6157 if (init
== ridpointers
[(int)RID_DELETE
])
6159 /* FIXME check this is 1st decl. */
6160 DECL_DELETED_FN (decl
) = 1;
6161 DECL_DECLARED_INLINE_P (decl
) = 1;
6162 DECL_INITIAL (decl
) = error_mark_node
;
6163 FOR_EACH_CLONE (clone
, decl
)
6165 DECL_DELETED_FN (clone
) = 1;
6166 DECL_DECLARED_INLINE_P (clone
) = 1;
6167 DECL_INITIAL (clone
) = error_mark_node
;
6171 else if (init
== ridpointers
[(int)RID_DEFAULT
])
6173 if (defaultable_fn_check (decl
))
6174 DECL_DEFAULTED_FN (decl
) = 1;
6176 DECL_INITIAL (decl
) = NULL_TREE
;
6180 if (init
&& VAR_P (decl
))
6182 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = 1;
6183 /* If DECL is a reference, then we want to know whether init is a
6184 reference constant; init_const_expr_p as passed tells us whether
6185 it's an rvalue constant. */
6186 if (TREE_CODE (type
) == REFERENCE_TYPE
)
6187 init_const_expr_p
= potential_constant_expression (init
);
6188 if (init_const_expr_p
)
6190 /* Set these flags now for templates. We'll update the flags in
6191 store_init_value for instantiations. */
6192 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = 1;
6193 if (decl_maybe_constant_var_p (decl
))
6194 TREE_CONSTANT (decl
) = 1;
6198 if (processing_template_decl
)
6200 bool type_dependent_p
;
6202 /* Add this declaration to the statement-tree. */
6203 if (at_function_scope_p ())
6204 add_decl_expr (decl
);
6206 type_dependent_p
= dependent_type_p (type
);
6208 if (check_for_bare_parameter_packs (init
))
6211 DECL_INITIAL (decl
) = NULL_TREE
;
6214 /* Generally, initializers in templates are expanded when the
6215 template is instantiated. But, if DECL is a variable constant
6216 then it can be used in future constant expressions, so its value
6217 must be available. */
6219 if (!VAR_P (decl
) || dependent_type_p (type
))
6220 /* We can't do anything if the decl has dependent type. */;
6222 && init_const_expr_p
6223 && !type_dependent_p
6224 && decl_maybe_constant_var_p (decl
)
6225 && !type_dependent_init_p (init
)
6226 && !value_dependent_init_p (init
))
6228 /* This variable seems to be a non-dependent constant, so process
6229 its initializer. If check_initializer returns non-null the
6230 initialization wasn't constant after all. */
6232 cleanups
= make_tree_vector ();
6233 init_code
= check_initializer (decl
, init
, flags
, &cleanups
);
6234 if (init_code
== NULL_TREE
)
6236 release_tree_vector (cleanups
);
6238 else if (!DECL_PRETTY_FUNCTION_P (decl
))
6240 /* Deduce array size even if the initializer is dependent. */
6241 maybe_deduce_size_from_array_init (decl
, init
);
6242 /* And complain about multiple initializers. */
6243 if (init
&& TREE_CODE (init
) == TREE_LIST
&& TREE_CHAIN (init
)
6244 && !MAYBE_CLASS_TYPE_P (type
))
6245 init
= build_x_compound_expr_from_list (init
, ELK_INIT
,
6246 tf_warning_or_error
);
6250 DECL_INITIAL (decl
) = init
;
6254 /* Just store non-static data member initializers for later. */
6255 if (init
&& TREE_CODE (decl
) == FIELD_DECL
)
6256 DECL_INITIAL (decl
) = init
;
6258 /* Take care of TYPE_DECLs up front. */
6259 if (TREE_CODE (decl
) == TYPE_DECL
)
6261 if (type
!= error_mark_node
6262 && MAYBE_CLASS_TYPE_P (type
) && DECL_NAME (decl
))
6264 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
6265 warning (0, "shadowing previous type declaration of %q#D", decl
);
6266 set_identifier_type_value (DECL_NAME (decl
), decl
);
6269 /* If we have installed this as the canonical typedef for this
6270 type, and that type has not been defined yet, delay emitting
6271 the debug information for it, as we will emit it later. */
6272 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
6273 && !COMPLETE_TYPE_P (TREE_TYPE (decl
)))
6274 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
6276 rest_of_decl_compilation (decl
, DECL_FILE_SCOPE_P (decl
),
6281 /* A reference will be modified here, as it is initialized. */
6282 if (! DECL_EXTERNAL (decl
)
6283 && TREE_READONLY (decl
)
6284 && TREE_CODE (type
) == REFERENCE_TYPE
)
6287 TREE_READONLY (decl
) = 0;
6292 /* If this is a local variable that will need a mangled name,
6293 register it now. We must do this before processing the
6294 initializer for the variable, since the initialization might
6295 require a guard variable, and since the mangled name of the
6296 guard variable will depend on the mangled name of this
6298 if (DECL_FUNCTION_SCOPE_P (decl
)
6299 && TREE_STATIC (decl
)
6300 && !DECL_ARTIFICIAL (decl
))
6302 push_local_name (decl
);
6303 if (DECL_CONSTRUCTOR_P (current_function_decl
)
6304 || DECL_DESTRUCTOR_P (current_function_decl
))
6305 /* Normally local_decls is populated during GIMPLE lowering,
6306 but [cd]tors are never actually compiled directly. We need
6307 to put statics on the list so we can deal with the label
6308 address extension. FIXME. */
6309 add_local_decl (cfun
, decl
);
6312 /* Convert the initializer to the type of DECL, if we have not
6313 already initialized DECL. */
6314 if (!DECL_INITIALIZED_P (decl
)
6315 /* If !DECL_EXTERNAL then DECL is being defined. In the
6316 case of a static data member initialized inside the
6317 class-specifier, there can be an initializer even if DECL
6318 is *not* defined. */
6319 && (!DECL_EXTERNAL (decl
) || init
))
6321 if (TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
6324 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
6325 /* Allow libjava/prims.cc define primitive classes. */
6326 if (init
!= NULL_TREE
6327 || jclass
== NULL_TREE
6328 || TREE_CODE (jclass
) != TYPE_DECL
6329 || !POINTER_TYPE_P (TREE_TYPE (jclass
))
6330 || !same_type_ignoring_top_level_qualifiers_p
6331 (type
, TREE_TYPE (TREE_TYPE (jclass
))))
6332 error ("Java object %qD not allocated with %<new%>", decl
);
6335 cleanups
= make_tree_vector ();
6336 init
= check_initializer (decl
, init
, flags
, &cleanups
);
6338 /* Check that the initializer for a static data member was a
6339 constant. Although we check in the parser that the
6340 initializer is an integral constant expression, we do not
6341 simplify division-by-zero at the point at which it
6342 occurs. Therefore, in:
6344 struct S { static const int i = 7 / 0; };
6346 we issue an error at this point. It would
6347 probably be better to forbid division by zero in
6348 integral constant expressions. */
6349 if (DECL_EXTERNAL (decl
) && init
)
6351 error ("%qD cannot be initialized by a non-constant expression"
6352 " when being declared", decl
);
6353 DECL_INITIALIZED_IN_CLASS_P (decl
) = 0;
6361 The memory occupied by any object of static storage
6362 duration is zero-initialized at program startup before
6363 any other initialization takes place.
6365 We cannot create an appropriate initializer until after
6366 the type of DECL is finalized. If DECL_INITIAL is set,
6367 then the DECL is statically initialized, and any
6368 necessary zero-initialization has already been performed. */
6369 if (TREE_STATIC (decl
) && !DECL_INITIAL (decl
))
6370 DECL_INITIAL (decl
) = build_zero_init (TREE_TYPE (decl
),
6371 /*nelts=*/NULL_TREE
,
6372 /*static_storage_p=*/true);
6373 /* Remember that the initialization for this variable has
6375 DECL_INITIALIZED_P (decl
) = 1;
6376 /* This declaration is the definition of this variable,
6377 unless we are initializing a static data member within
6378 the class specifier. */
6379 if (!DECL_EXTERNAL (decl
))
6380 var_definition_p
= true;
6382 /* If the variable has an array type, lay out the type, even if
6383 there is no initializer. It is valid to index through the
6384 array, and we must get TYPE_ALIGN set correctly on the array
6386 else if (TREE_CODE (type
) == ARRAY_TYPE
)
6389 if (TREE_STATIC (decl
)
6390 && !at_function_scope_p ()
6391 && current_function_decl
== NULL
)
6392 /* So decl is a global variable or a static member of a
6393 non local class. Record the types it uses
6394 so that we can decide later to emit debug info for them. */
6395 record_types_used_by_current_var_decl (decl
);
6397 else if (TREE_CODE (decl
) == FIELD_DECL
6398 && TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
6399 error ("non-static data member %qD has Java class type", decl
);
6401 /* Add this declaration to the statement-tree. This needs to happen
6402 after the call to check_initializer so that the DECL_EXPR for a
6403 reference temp is added before the DECL_EXPR for the reference itself. */
6404 if (DECL_FUNCTION_SCOPE_P (decl
))
6405 add_decl_expr (decl
);
6407 /* Let the middle end know about variables and functions -- but not
6408 static data members in uninstantiated class templates. */
6409 if (VAR_OR_FUNCTION_DECL_P (decl
))
6413 layout_var_decl (decl
);
6414 maybe_commonize_var (decl
);
6417 /* This needs to happen after the linkage is set. */
6418 determine_visibility (decl
);
6420 if (var_definition_p
&& TREE_STATIC (decl
))
6422 /* If a TREE_READONLY variable needs initialization
6423 at runtime, it is no longer readonly and we need to
6424 avoid MEM_READONLY_P being set on RTL created for it. */
6427 if (TREE_READONLY (decl
))
6428 TREE_READONLY (decl
) = 0;
6431 else if (was_readonly
)
6432 TREE_READONLY (decl
) = 1;
6434 /* Likewise if it needs destruction. */
6435 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
6436 TREE_READONLY (decl
) = 0;
6439 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
);
6441 /* Check for abstractness of the type. Notice that there is no
6442 need to strip array types here since the check for those types
6443 is already done within create_array_type_for_decl. */
6444 abstract_virtuals_error (decl
, type
);
6446 if (TREE_TYPE (decl
) == error_mark_node
)
6447 /* No initialization required. */
6449 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
6453 if (init
== ridpointers
[(int)RID_DEFAULT
])
6455 /* An out-of-class default definition is defined at
6456 the point where it is explicitly defaulted. */
6457 if (DECL_DELETED_FN (decl
))
6458 maybe_explain_implicit_delete (decl
);
6459 else if (DECL_INITIAL (decl
) == error_mark_node
)
6460 synthesize_method (decl
);
6463 error ("function %q#D is initialized like a variable", decl
);
6465 /* else no initialization required. */
6467 else if (DECL_EXTERNAL (decl
)
6468 && ! (DECL_LANG_SPECIFIC (decl
)
6469 && DECL_NOT_REALLY_EXTERN (decl
)))
6472 DECL_INITIAL (decl
) = init
;
6474 /* A variable definition. */
6475 else if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
6476 /* Initialize the local variable. */
6477 initialize_local_var (decl
, init
);
6479 /* If a variable is defined, and then a subsequent
6480 definition with external linkage is encountered, we will
6481 get here twice for the same variable. We want to avoid
6482 calling expand_static_init more than once. For variables
6483 that are not static data members, we can call
6484 expand_static_init only when we actually process the
6485 initializer. It is not legal to redeclare a static data
6486 member, so this issue does not arise in that case. */
6487 else if (var_definition_p
&& TREE_STATIC (decl
))
6488 expand_static_init (decl
, init
);
6491 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
6492 reference, insert it in the statement-tree now. */
6496 FOR_EACH_VEC_ELT (*cleanups
, i
, t
)
6497 push_cleanup (decl
, t
, false);
6498 release_tree_vector (cleanups
);
6502 TREE_READONLY (decl
) = 1;
6504 invoke_plugin_callbacks (PLUGIN_FINISH_DECL
, decl
);
6507 /* Returns a declaration for a VAR_DECL as if:
6509 extern "C" TYPE NAME;
6511 had been seen. Used to create compiler-generated global
6515 declare_global_var (tree name
, tree type
)
6519 push_to_top_level ();
6520 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
6521 TREE_PUBLIC (decl
) = 1;
6522 DECL_EXTERNAL (decl
) = 1;
6523 DECL_ARTIFICIAL (decl
) = 1;
6524 /* If the user has explicitly declared this variable (perhaps
6525 because the code we are compiling is part of a low-level runtime
6526 library), then it is possible that our declaration will be merged
6527 with theirs by pushdecl. */
6528 decl
= pushdecl (decl
);
6529 cp_finish_decl (decl
, NULL_TREE
, false, NULL_TREE
, 0);
6530 pop_from_top_level ();
6535 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
6536 if "__cxa_atexit" is not being used) corresponding to the function
6537 to be called when the program exits. */
6540 get_atexit_fn_ptr_type (void)
6544 if (!atexit_fn_ptr_type_node
)
6547 if (flag_use_cxa_atexit
6548 && !targetm
.cxx
.use_atexit_for_cxa_atexit ())
6549 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
6550 arg_type
= ptr_type_node
;
6552 /* The parameter to "atexit" is "void (*)(void)". */
6553 arg_type
= NULL_TREE
;
6555 fn_type
= build_function_type_list (void_type_node
,
6556 arg_type
, NULL_TREE
);
6557 atexit_fn_ptr_type_node
= build_pointer_type (fn_type
);
6560 return atexit_fn_ptr_type_node
;
6563 /* Returns a pointer to the `atexit' function. Note that if
6564 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
6565 `__cxa_atexit' function specified in the IA64 C++ ABI. */
6568 get_atexit_node (void)
6574 bool use_aeabi_atexit
;
6579 if (flag_use_cxa_atexit
&& !targetm
.cxx
.use_atexit_for_cxa_atexit ())
6581 /* The declaration for `__cxa_atexit' is:
6583 int __cxa_atexit (void (*)(void *), void *, void *)
6585 We build up the argument types and then the function type
6587 tree argtype0
, argtype1
, argtype2
;
6589 use_aeabi_atexit
= targetm
.cxx
.use_aeabi_atexit ();
6590 /* First, build the pointer-to-function type for the first
6592 fn_ptr_type
= get_atexit_fn_ptr_type ();
6593 /* Then, build the rest of the argument types. */
6594 argtype2
= ptr_type_node
;
6595 if (use_aeabi_atexit
)
6597 argtype1
= fn_ptr_type
;
6598 argtype0
= ptr_type_node
;
6602 argtype1
= ptr_type_node
;
6603 argtype0
= fn_ptr_type
;
6605 /* And the final __cxa_atexit type. */
6606 fn_type
= build_function_type_list (integer_type_node
,
6607 argtype0
, argtype1
, argtype2
,
6609 if (use_aeabi_atexit
)
6610 name
= "__aeabi_atexit";
6612 name
= "__cxa_atexit";
6616 /* The declaration for `atexit' is:
6618 int atexit (void (*)());
6620 We build up the argument types and then the function type
6622 fn_ptr_type
= get_atexit_fn_ptr_type ();
6623 /* Build the final atexit type. */
6624 fn_type
= build_function_type_list (integer_type_node
,
6625 fn_ptr_type
, NULL_TREE
);
6629 /* Now, build the function declaration. */
6630 push_lang_context (lang_name_c
);
6631 atexit_fndecl
= build_library_fn_ptr (name
, fn_type
);
6632 mark_used (atexit_fndecl
);
6633 pop_lang_context ();
6634 atexit_node
= decay_conversion (atexit_fndecl
, tf_warning_or_error
);
6639 /* Like get_atexit_node, but for thread-local cleanups. */
6642 get_thread_atexit_node (void)
6644 /* The declaration for `__cxa_thread_atexit' is:
6646 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
6647 tree fn_type
= build_function_type_list (integer_type_node
,
6648 get_atexit_fn_ptr_type (),
6649 ptr_type_node
, ptr_type_node
,
6652 /* Now, build the function declaration. */
6653 tree atexit_fndecl
= build_library_fn_ptr ("__cxa_thread_atexit", fn_type
);
6654 return decay_conversion (atexit_fndecl
, tf_warning_or_error
);
6657 /* Returns the __dso_handle VAR_DECL. */
6660 get_dso_handle_node (void)
6662 if (dso_handle_node
)
6663 return dso_handle_node
;
6665 /* Declare the variable. */
6666 dso_handle_node
= declare_global_var (get_identifier ("__dso_handle"),
6669 #ifdef HAVE_GAS_HIDDEN
6670 DECL_VISIBILITY (dso_handle_node
) = VISIBILITY_HIDDEN
;
6671 DECL_VISIBILITY_SPECIFIED (dso_handle_node
) = 1;
6674 return dso_handle_node
;
6677 /* Begin a new function with internal linkage whose job will be simply
6678 to destroy some particular variable. */
6680 static GTY(()) int start_cleanup_cnt
;
6683 start_cleanup_fn (void)
6688 bool use_cxa_atexit
= flag_use_cxa_atexit
6689 && !targetm
.cxx
.use_atexit_for_cxa_atexit ();
6691 push_to_top_level ();
6693 /* No need to mangle this. */
6694 push_lang_context (lang_name_c
);
6696 /* Build the name of the function. */
6697 sprintf (name
, "__tcf_%d", start_cleanup_cnt
++);
6698 /* Build the function declaration. */
6699 fntype
= TREE_TYPE (get_atexit_fn_ptr_type ());
6700 fndecl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), fntype
);
6701 /* It's a function with internal linkage, generated by the
6703 TREE_PUBLIC (fndecl
) = 0;
6704 DECL_ARTIFICIAL (fndecl
) = 1;
6705 /* Make the function `inline' so that it is only emitted if it is
6706 actually needed. It is unlikely that it will be inlined, since
6707 it is only called via a function pointer, but we avoid unnecessary
6708 emissions this way. */
6709 DECL_DECLARED_INLINE_P (fndecl
) = 1;
6710 DECL_INTERFACE_KNOWN (fndecl
) = 1;
6711 /* Build the parameter. */
6716 parmdecl
= cp_build_parm_decl (NULL_TREE
, ptr_type_node
);
6717 DECL_CONTEXT (parmdecl
) = fndecl
;
6718 TREE_USED (parmdecl
) = 1;
6719 DECL_READ_P (parmdecl
) = 1;
6720 DECL_ARGUMENTS (fndecl
) = parmdecl
;
6724 start_preparsed_function (fndecl
, NULL_TREE
, SF_PRE_PARSED
);
6726 pop_lang_context ();
6728 return current_function_decl
;
6731 /* Finish the cleanup function begun by start_cleanup_fn. */
6734 end_cleanup_fn (void)
6736 expand_or_defer_fn (finish_function (0));
6738 pop_from_top_level ();
6741 /* Generate code to handle the destruction of DECL, an object with
6742 static storage duration. */
6745 register_dtor_fn (tree decl
)
6752 bool ob_parm
, dso_parm
, use_dtor
;
6753 tree arg0
, arg1
, arg2
;
6756 type
= TREE_TYPE (decl
);
6757 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
6758 return void_zero_node
;
6760 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
6761 "__aeabi_atexit"), and DECL is a class object, we can just pass the
6762 destructor to "__cxa_atexit"; we don't have to build a temporary
6763 function to do the cleanup. */
6764 dso_parm
= (flag_use_cxa_atexit
6765 && !targetm
.cxx
.use_atexit_for_cxa_atexit ());
6766 ob_parm
= (DECL_THREAD_LOCAL_P (decl
) || dso_parm
);
6767 use_dtor
= ob_parm
&& CLASS_TYPE_P (type
);
6772 /* Find the destructor. */
6773 idx
= lookup_fnfields_1 (type
, complete_dtor_identifier
);
6774 gcc_assert (idx
>= 0);
6775 cleanup
= (*CLASSTYPE_METHOD_VEC (type
))[idx
];
6776 /* Make sure it is accessible. */
6777 perform_or_defer_access_check (TYPE_BINFO (type
), cleanup
, cleanup
,
6778 tf_warning_or_error
);
6782 /* Call build_cleanup before we enter the anonymous function so
6783 that any access checks will be done relative to the current
6784 scope, rather than the scope of the anonymous function. */
6785 build_cleanup (decl
);
6787 /* Now start the function. */
6788 cleanup
= start_cleanup_fn ();
6790 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
6791 to the original function, rather than the anonymous one. That
6792 will make the back end think that nested functions are in use,
6793 which causes confusion. */
6794 push_deferring_access_checks (dk_no_check
);
6795 fcall
= build_cleanup (decl
);
6796 pop_deferring_access_checks ();
6798 /* Create the body of the anonymous function. */
6799 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
6800 finish_expr_stmt (fcall
);
6801 finish_compound_stmt (compound_stmt
);
6805 /* Call atexit with the cleanup function. */
6806 mark_used (cleanup
);
6807 cleanup
= build_address (cleanup
);
6809 if (DECL_THREAD_LOCAL_P (decl
))
6810 atex_node
= get_thread_atexit_node ();
6812 atex_node
= get_atexit_node ();
6816 /* We must convert CLEANUP to the type that "__cxa_atexit"
6818 cleanup
= build_nop (get_atexit_fn_ptr_type (), cleanup
);
6819 /* "__cxa_atexit" will pass the address of DECL to the
6820 cleanup function. */
6822 addr
= build_address (decl
);
6823 /* The declared type of the parameter to "__cxa_atexit" is
6824 "void *". For plain "T*", we could just let the
6825 machinery in cp_build_function_call convert it -- but if the
6826 type is "cv-qualified T *", then we need to convert it
6827 before passing it in, to avoid spurious errors. */
6828 addr
= build_nop (ptr_type_node
, addr
);
6831 /* Since the cleanup functions we build ignore the address
6832 they're given, there's no reason to pass the actual address
6833 in, and, in general, it's cheaper to pass NULL than any
6835 addr
= null_pointer_node
;
6838 arg2
= cp_build_addr_expr (get_dso_handle_node (),
6839 tf_warning_or_error
);
6841 /* Just pass NULL to the dso handle parm if we don't actually
6842 have a DSO handle on this target. */
6843 arg2
= null_pointer_node
;
6849 if (!DECL_THREAD_LOCAL_P (decl
)
6850 && targetm
.cxx
.use_aeabi_atexit ())
6866 return cp_build_function_call_nary (atex_node
, tf_warning_or_error
,
6867 arg0
, arg1
, arg2
, NULL_TREE
);
6870 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
6871 is its initializer. Generate code to handle the construction
6872 and destruction of DECL. */
6875 expand_static_init (tree decl
, tree init
)
6877 gcc_assert (VAR_P (decl
));
6878 gcc_assert (TREE_STATIC (decl
));
6880 /* Some variables require no dynamic initialization. */
6882 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
6885 if (DECL_THREAD_LOCAL_P (decl
) && DECL_GNU_TLS_P (decl
)
6886 && !DECL_FUNCTION_SCOPE_P (decl
))
6889 error ("non-local variable %qD declared %<__thread%> "
6890 "needs dynamic initialization", decl
);
6892 error ("non-local variable %qD declared %<__thread%> "
6893 "has a non-trivial destructor", decl
);
6894 static bool informed
;
6897 inform (DECL_SOURCE_LOCATION (decl
),
6898 "C++11 %<thread_local%> allows dynamic initialization "
6905 if (DECL_FUNCTION_SCOPE_P (decl
))
6907 /* Emit code to perform this initialization but once. */
6908 tree if_stmt
= NULL_TREE
, inner_if_stmt
= NULL_TREE
;
6909 tree then_clause
= NULL_TREE
, inner_then_clause
= NULL_TREE
;
6910 tree guard
, guard_addr
;
6912 /* We don't need thread-safety code for thread-local vars. */
6913 bool thread_guard
= (flag_threadsafe_statics
6914 && !DECL_THREAD_LOCAL_P (decl
));
6916 /* Emit code to perform this initialization but once. This code
6919 static <type> guard;
6920 if (!guard.first_byte) {
6921 if (__cxa_guard_acquire (&guard)) {
6924 // Do initialization.
6925 flag = true; __cxa_guard_release (&guard);
6926 // Register variable for destruction at end of program.
6928 if (!flag) __cxa_guard_abort (&guard);
6932 Note that the `flag' variable is only set to 1 *after* the
6933 initialization is complete. This ensures that an exception,
6934 thrown during the construction, will cause the variable to
6935 reinitialized when we pass through this code again, as per:
6939 If the initialization exits by throwing an exception, the
6940 initialization is not complete, so it will be tried again
6941 the next time control enters the declaration.
6943 This process should be thread-safe, too; multiple threads
6944 should not be able to initialize the variable more than
6947 /* Create the guard variable. */
6948 guard
= get_guard (decl
);
6950 /* This optimization isn't safe on targets with relaxed memory
6951 consistency. On such targets we force synchronization in
6952 __cxa_guard_acquire. */
6953 if (!targetm
.relaxed_ordering
|| !thread_guard
)
6955 /* Begin the conditional initialization. */
6956 if_stmt
= begin_if_stmt ();
6957 finish_if_stmt_cond (get_guard_cond (guard
), if_stmt
);
6958 then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
6963 tree vfntype
= NULL_TREE
;
6964 tree acquire_name
, release_name
, abort_name
;
6965 tree acquire_fn
, release_fn
, abort_fn
;
6966 guard_addr
= build_address (guard
);
6968 acquire_name
= get_identifier ("__cxa_guard_acquire");
6969 release_name
= get_identifier ("__cxa_guard_release");
6970 abort_name
= get_identifier ("__cxa_guard_abort");
6971 acquire_fn
= identifier_global_value (acquire_name
);
6972 release_fn
= identifier_global_value (release_name
);
6973 abort_fn
= identifier_global_value (abort_name
);
6975 acquire_fn
= push_library_fn
6976 (acquire_name
, build_function_type_list (integer_type_node
,
6977 TREE_TYPE (guard_addr
),
6980 if (!release_fn
|| !abort_fn
)
6981 vfntype
= build_function_type_list (void_type_node
,
6982 TREE_TYPE (guard_addr
),
6985 release_fn
= push_library_fn (release_name
, vfntype
, NULL_TREE
);
6987 abort_fn
= push_library_fn (abort_name
, vfntype
, NULL_TREE
);
6989 inner_if_stmt
= begin_if_stmt ();
6990 finish_if_stmt_cond (build_call_n (acquire_fn
, 1, guard_addr
),
6993 inner_then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
6994 begin
= get_target_expr (boolean_false_node
);
6995 flag
= TARGET_EXPR_SLOT (begin
);
6997 TARGET_EXPR_CLEANUP (begin
)
6998 = build3 (COND_EXPR
, void_type_node
, flag
,
7000 build_call_n (abort_fn
, 1, guard_addr
));
7001 CLEANUP_EH_ONLY (begin
) = 1;
7003 /* Do the initialization itself. */
7004 init
= add_stmt_to_compound (begin
, init
);
7005 init
= add_stmt_to_compound
7006 (init
, build2 (MODIFY_EXPR
, void_type_node
, flag
, boolean_true_node
));
7007 init
= add_stmt_to_compound
7008 (init
, build_call_n (release_fn
, 1, guard_addr
));
7011 init
= add_stmt_to_compound (init
, set_guard (guard
));
7013 /* Use atexit to register a function for destroying this static
7015 init
= add_stmt_to_compound (init
, register_dtor_fn (decl
));
7017 finish_expr_stmt (init
);
7021 finish_compound_stmt (inner_then_clause
);
7022 finish_then_clause (inner_if_stmt
);
7023 finish_if_stmt (inner_if_stmt
);
7026 if (!targetm
.relaxed_ordering
|| !thread_guard
)
7028 finish_compound_stmt (then_clause
);
7029 finish_then_clause (if_stmt
);
7030 finish_if_stmt (if_stmt
);
7033 else if (DECL_THREAD_LOCAL_P (decl
))
7034 tls_aggregates
= tree_cons (init
, decl
, tls_aggregates
);
7036 static_aggregates
= tree_cons (init
, decl
, static_aggregates
);
7040 /* Make TYPE a complete type based on INITIAL_VALUE.
7041 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
7042 2 if there was no information (in which case assume 0 if DO_DEFAULT),
7043 3 if the initializer list is empty (in pedantic mode). */
7046 cp_complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
7049 tree type
, elt_type
;
7053 unsigned HOST_WIDE_INT i
;
7056 /* An array of character type can be initialized from a
7057 brace-enclosed string constant.
7059 FIXME: this code is duplicated from reshape_init. Probably
7060 we should just call reshape_init here? */
7061 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype
)))
7062 && TREE_CODE (initial_value
) == CONSTRUCTOR
7063 && !vec_safe_is_empty (CONSTRUCTOR_ELTS (initial_value
)))
7065 vec
<constructor_elt
, va_gc
> *v
= CONSTRUCTOR_ELTS (initial_value
);
7066 tree value
= (*v
)[0].value
;
7068 if (TREE_CODE (value
) == STRING_CST
7069 && v
->length () == 1)
7070 initial_value
= value
;
7073 /* If any of the elements are parameter packs, we can't actually
7074 complete this type now because the array size is dependent. */
7075 if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
7077 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value
),
7080 if (PACK_EXPANSION_P (value
))
7086 failure
= complete_array_type (ptype
, initial_value
, do_default
);
7088 /* We can create the array before the element type is complete, which
7089 means that we didn't have these two bits set in the original type
7090 either. In completing the type, we are expected to propagate these
7091 bits. See also complete_type which does the same thing for arrays
7094 if (TYPE_DOMAIN (type
))
7096 elt_type
= TREE_TYPE (type
);
7097 TYPE_NEEDS_CONSTRUCTING (type
) = TYPE_NEEDS_CONSTRUCTING (elt_type
);
7098 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
7099 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
);
7105 /* As above, but either give an error or reject zero-size arrays, depending
7109 cp_complete_array_type_or_error (tree
*ptype
, tree initial_value
,
7110 bool do_default
, tsubst_flags_t complain
)
7113 bool sfinae
= !(complain
& tf_error
);
7114 /* In SFINAE context we can't be lenient about zero-size arrays. */
7117 failure
= cp_complete_array_type (ptype
, initial_value
, do_default
);
7123 /* Not an error. */;
7124 else if (failure
== 1)
7125 error ("initializer fails to determine size of %qT", *ptype
);
7126 else if (failure
== 2)
7129 error ("array size missing in %qT", *ptype
);
7131 else if (failure
== 3)
7132 error ("zero-size array %qT", *ptype
);
7133 *ptype
= error_mark_node
;
7138 /* Return zero if something is declared to be a member of type
7139 CTYPE when in the context of CUR_TYPE. STRING is the error
7140 message to print in that case. Otherwise, quietly return 1. */
7143 member_function_or_else (tree ctype
, tree cur_type
, enum overload_flags flags
)
7145 if (ctype
&& ctype
!= cur_type
)
7147 if (flags
== DTOR_FLAG
)
7148 error ("destructor for alien class %qT cannot be a member", ctype
);
7150 error ("constructor for alien class %qT cannot be a member", ctype
);
7156 /* Subroutine of `grokdeclarator'. */
7158 /* Generate errors possibly applicable for a given set of specifiers.
7159 This is for ARM $7.1.2. */
7162 bad_specifiers (tree object
,
7163 enum bad_spec_place type
,
7174 error ("%qD declared as a %<virtual%> variable", object
);
7176 error ("%qD declared as an %<inline%> variable", object
);
7178 error ("%<const%> and %<volatile%> function specifiers on "
7179 "%qD invalid in variable declaration", object
);
7183 error ("%qD declared as a %<virtual%> parameter", object
);
7185 error ("%qD declared as an %<inline%> parameter", object
);
7187 error ("%<const%> and %<volatile%> function specifiers on "
7188 "%qD invalid in parameter declaration", object
);
7192 error ("%qD declared as a %<virtual%> type", object
);
7194 error ("%qD declared as an %<inline%> type", object
);
7196 error ("%<const%> and %<volatile%> function specifiers on "
7197 "%qD invalid in type declaration", object
);
7201 error ("%qD declared as a %<virtual%> field", object
);
7203 error ("%qD declared as an %<inline%> field", object
);
7205 error ("%<const%> and %<volatile%> function specifiers on "
7206 "%qD invalid in field declaration", object
);
7212 error ("%q+D declared as a friend", object
);
7214 && (TREE_CODE (object
) == TYPE_DECL
7215 || (!TYPE_PTRFN_P (TREE_TYPE (object
))
7216 && !TYPE_REFFN_P (TREE_TYPE (object
))
7217 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object
)))))
7218 error ("%q+D declared with an exception specification", object
);
7221 /* DECL is a member function or static data member and is presently
7222 being defined. Check that the definition is taking place in a
7226 check_class_member_definition_namespace (tree decl
)
7228 /* These checks only apply to member functions and static data
7230 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl
));
7231 /* We check for problems with specializations in pt.c in
7232 check_specialization_namespace, where we can issue better
7234 if (processing_specialization
)
7236 /* There are no restrictions on the placement of
7237 explicit instantiations. */
7238 if (processing_explicit_instantiation
)
7242 A member function definition that appears outside of the
7243 class definition shall appear in a namespace scope enclosing
7244 the class definition.
7248 The definition for a static data member shall appear in a
7249 namespace scope enclosing the member's class definition. */
7250 if (!is_ancestor (current_namespace
, DECL_CONTEXT (decl
)))
7251 permerror (input_location
, "definition of %qD is not in namespace enclosing %qT",
7252 decl
, DECL_CONTEXT (decl
));
7255 /* Build a PARM_DECL for the "this" parameter. TYPE is the
7256 METHOD_TYPE for a non-static member function; QUALS are the
7257 cv-qualifiers that apply to the function. */
7260 build_this_parm (tree type
, cp_cv_quals quals
)
7265 cp_cv_quals this_quals
;
7267 if (CLASS_TYPE_P (type
))
7270 = cp_build_qualified_type (type
, quals
& ~TYPE_QUAL_RESTRICT
);
7271 this_type
= build_pointer_type (this_type
);
7274 this_type
= type_of_this_parm (type
);
7275 /* The `this' parameter is implicitly `const'; it cannot be
7277 this_quals
= (quals
& TYPE_QUAL_RESTRICT
) | TYPE_QUAL_CONST
;
7278 qual_type
= cp_build_qualified_type (this_type
, this_quals
);
7279 parm
= build_artificial_parm (this_identifier
, qual_type
);
7280 cp_apply_type_quals_to_decl (this_quals
, parm
);
7284 /* DECL is a static member function. Complain if it was declared
7285 with function-cv-quals. */
7288 check_static_quals (tree decl
, cp_cv_quals quals
)
7290 if (quals
!= TYPE_UNQUALIFIED
)
7291 error ("static member function %q#D declared with type qualifiers",
7295 /* CTYPE is class type, or null if non-class.
7296 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
7298 DECLARATOR is the function's name.
7299 PARMS is a chain of PARM_DECLs for the function.
7300 VIRTUALP is truthvalue of whether the function is virtual or not.
7301 FLAGS are to be passed through to `grokclassfn'.
7302 QUALS are qualifiers indicating whether the function is `const'
7304 RAISES is a list of exceptions that this function can raise.
7305 CHECK is 1 if we must find this method in CTYPE, 0 if we should
7306 not look, and -1 if we should not call `grokclassfn' at all.
7308 SFK is the kind of special function (if any) for the new function.
7310 Returns `NULL_TREE' if something goes wrong, after issuing
7311 applicable error messages. */
7314 grokfndecl (tree ctype
,
7318 tree orig_declarator
,
7320 enum overload_flags flags
,
7322 cp_ref_qualifier rqual
,
7328 special_function_kind sfk
,
7333 location_t location
)
7336 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
7340 type
= build_ref_qualified_type (type
, rqual
);
7342 type
= build_exception_variant (type
, raises
);
7344 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
7346 /* If we have an explicit location, use it, otherwise use whatever
7347 build_lang_decl used (probably input_location). */
7348 if (location
!= UNKNOWN_LOCATION
)
7349 DECL_SOURCE_LOCATION (decl
) = location
;
7351 if (TREE_CODE (type
) == METHOD_TYPE
)
7354 parm
= build_this_parm (type
, quals
);
7355 DECL_CHAIN (parm
) = parms
;
7358 DECL_ARGUMENTS (decl
) = parms
;
7359 for (t
= parms
; t
; t
= DECL_CHAIN (t
))
7360 DECL_CONTEXT (t
) = decl
;
7361 /* Propagate volatile out from type to decl. */
7362 if (TYPE_VOLATILE (type
))
7363 TREE_THIS_VOLATILE (decl
) = 1;
7365 /* Setup decl according to sfk. */
7368 case sfk_constructor
:
7369 case sfk_copy_constructor
:
7370 case sfk_move_constructor
:
7371 DECL_CONSTRUCTOR_P (decl
) = 1;
7373 case sfk_destructor
:
7374 DECL_DESTRUCTOR_P (decl
) = 1;
7380 /* If pointers to member functions use the least significant bit to
7381 indicate whether a function is virtual, ensure a pointer
7382 to this function will have that bit clear. */
7383 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
7384 && TREE_CODE (type
) == METHOD_TYPE
7385 && DECL_ALIGN (decl
) < 2 * BITS_PER_UNIT
)
7386 DECL_ALIGN (decl
) = 2 * BITS_PER_UNIT
;
7389 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
7393 ("defining explicit specialization %qD in friend declaration",
7397 tree fns
= TREE_OPERAND (orig_declarator
, 0);
7398 tree args
= TREE_OPERAND (orig_declarator
, 1);
7400 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
7402 /* Something like `template <class T> friend void f<T>()'. */
7403 error ("invalid use of template-id %qD in declaration "
7404 "of primary template",
7410 /* A friend declaration of the form friend void f<>(). Record
7411 the information in the TEMPLATE_ID_EXPR. */
7412 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
7414 if (TREE_CODE (fns
) == COMPONENT_REF
)
7416 /* Due to bison parser ickiness, we will have already looked
7417 up an operator_name or PFUNCNAME within the current class
7418 (see template_id in parse.y). If the current class contains
7419 such a name, we'll get a COMPONENT_REF here. Undo that. */
7421 gcc_assert (TREE_TYPE (TREE_OPERAND (fns
, 0))
7422 == current_class_type
);
7423 fns
= TREE_OPERAND (fns
, 1);
7425 gcc_assert (identifier_p (fns
) || TREE_CODE (fns
) == OVERLOAD
);
7426 DECL_TEMPLATE_INFO (decl
) = build_template_info (fns
, args
);
7428 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
7429 if (TREE_PURPOSE (t
)
7430 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
7432 error ("default arguments are not allowed in declaration "
7433 "of friend template specialization %qD",
7439 error ("%<inline%> is not allowed in declaration of friend "
7440 "template specialization %qD",
7443 error ("%<constexpr%> is not allowed in declaration of friend "
7444 "template specialization %qD",
7451 /* If this decl has namespace scope, set that up. */
7453 set_decl_namespace (decl
, in_namespace
, friendp
);
7455 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_decl_namespace ());
7457 /* `main' and builtins have implicit 'C' linkage. */
7458 if ((MAIN_NAME_P (declarator
)
7459 || (IDENTIFIER_LENGTH (declarator
) > 10
7460 && IDENTIFIER_POINTER (declarator
)[0] == '_'
7461 && IDENTIFIER_POINTER (declarator
)[1] == '_'
7462 && strncmp (IDENTIFIER_POINTER (declarator
)+2, "builtin_", 8) == 0))
7463 && current_lang_name
== lang_name_cplusplus
7464 && ctype
== NULL_TREE
7465 && DECL_FILE_SCOPE_P (decl
))
7466 SET_DECL_LANGUAGE (decl
, lang_c
);
7468 /* Should probably propagate const out from type to decl I bet (mrs). */
7471 DECL_STATIC_FUNCTION_P (decl
) = 1;
7472 DECL_CONTEXT (decl
) = ctype
;
7477 DECL_CONTEXT (decl
) = ctype
;
7479 check_class_member_definition_namespace (decl
);
7482 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
7484 if (PROCESSING_REAL_TEMPLATE_DECL_P())
7485 error ("cannot declare %<::main%> to be a template");
7487 error ("cannot declare %<::main%> to be inline");
7489 error ("cannot declare %<::main%> to be constexpr");
7491 error ("cannot declare %<::main%> to be static");
7496 /* Members of anonymous types and local classes have no linkage; make
7497 them internal. If a typedef is made later, this will be changed. */
7498 if (ctype
&& (TYPE_ANONYMOUS_P (ctype
)
7499 || decl_function_context (TYPE_MAIN_DECL (ctype
))))
7502 if (publicp
&& cxx_dialect
== cxx98
)
7504 /* [basic.link]: A name with no linkage (notably, the name of a class
7505 or enumeration declared in a local scope) shall not be used to
7506 declare an entity with linkage.
7508 DR 757 relaxes this restriction for C++0x. */
7509 t
= no_linkage_check (TREE_TYPE (decl
),
7510 /*relaxed_p=*/false);
7513 if (TYPE_ANONYMOUS_P (t
))
7515 if (DECL_EXTERN_C_P (decl
))
7516 /* Allow this; it's pretty common in C. */;
7519 permerror (input_location
, "anonymous type with no linkage "
7520 "used to declare function %q#D with linkage",
7522 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
7523 permerror (input_location
, "%q+#D does not refer to the unqualified "
7524 "type, so it is not used for linkage",
7529 permerror (input_location
, "type %qT with no linkage used to "
7530 "declare function %q#D with linkage", t
, decl
);
7534 TREE_PUBLIC (decl
) = publicp
;
7537 DECL_INTERFACE_KNOWN (decl
) = 1;
7538 DECL_NOT_REALLY_EXTERN (decl
) = 1;
7541 /* If the declaration was declared inline, mark it as such. */
7543 DECL_DECLARED_INLINE_P (decl
) = 1;
7545 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
7547 DECL_EXTERNAL (decl
) = 1;
7548 if (TREE_CODE (type
) == FUNCTION_TYPE
)
7553 ? G_("static member function %qD cannot have cv-qualifier")
7554 : G_("non-member function %qD cannot have cv-qualifier"),
7556 quals
= TYPE_UNQUALIFIED
;
7562 ? G_("static member function %qD cannot have ref-qualifier")
7563 : G_("non-member function %qD cannot have ref-qualifier"),
7565 rqual
= REF_QUAL_NONE
;
7569 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
))
7570 && !grok_op_properties (decl
, /*complain=*/true))
7572 else if (UDLIT_OPER_P (DECL_NAME (decl
)))
7574 bool long_long_unsigned_p
;
7576 const char *suffix
= NULL
;
7577 /* [over.literal]/6: Literal operators shall not have C linkage. */
7578 if (DECL_LANGUAGE (decl
) == lang_c
)
7580 error ("literal operator with C linkage");
7584 if (DECL_NAMESPACE_SCOPE_P (decl
))
7586 if (!check_literal_operator_args (decl
, &long_long_unsigned_p
,
7589 error ("%qD has invalid argument list", decl
);
7593 suffix
= UDLIT_OP_SUFFIX (DECL_NAME (decl
));
7594 if (long_long_unsigned_p
)
7596 if (cpp_interpret_int_suffix (parse_in
, suffix
, strlen (suffix
)))
7597 warning (0, "integer suffix %<%s%>"
7598 " shadowed by implementation", suffix
);
7600 else if (long_double_p
)
7602 if (cpp_interpret_float_suffix (parse_in
, suffix
, strlen (suffix
)))
7603 warning (0, "floating point suffix %<%s%>"
7604 " shadowed by implementation", suffix
);
7609 error ("%qD must be a non-member function", decl
);
7615 /* Make the init_value nonzero so pushdecl knows this is not
7616 tentative. error_mark_node is replaced later with the BLOCK. */
7617 DECL_INITIAL (decl
) = error_mark_node
;
7619 if (TYPE_NOTHROW_P (type
) || nothrow_libfn_p (decl
))
7620 TREE_NOTHROW (decl
) = 1;
7622 /* Caller will do the rest of this. */
7626 if (ctype
!= NULL_TREE
)
7627 grokclassfn (ctype
, decl
, flags
);
7630 if (cxx_dialect
>= cxx0x
7631 && DECL_DESTRUCTOR_P (decl
)
7632 && !TYPE_BEING_DEFINED (DECL_CONTEXT (decl
))
7633 && !processing_template_decl
)
7634 deduce_noexcept_on_destructor (decl
);
7636 decl
= check_explicit_specialization (orig_declarator
, decl
,
7639 4 * (friendp
!= 0));
7640 if (decl
== error_mark_node
)
7643 if (DECL_STATIC_FUNCTION_P (decl
))
7644 check_static_quals (decl
, quals
);
7648 cplus_decl_attributes (&decl
, *attrlist
, 0);
7649 *attrlist
= NULL_TREE
;
7652 /* Check main's type after attributes have been applied. */
7653 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
7655 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
7658 tree oldtypeargs
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
7660 error ("%<::main%> must return %<int%>");
7661 newtype
= build_function_type (integer_type_node
, oldtypeargs
);
7662 TREE_TYPE (decl
) = newtype
;
7665 check_main_parameter_types (decl
);
7668 if (ctype
!= NULL_TREE
7669 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
7672 tree old_decl
= check_classfn (ctype
, decl
,
7673 (processing_template_decl
7674 > template_class_depth (ctype
))
7675 ? current_template_parms
7678 if (old_decl
== error_mark_node
)
7686 if (TREE_CODE (old_decl
) == TEMPLATE_DECL
)
7687 /* Because grokfndecl is always supposed to return a
7688 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
7689 here. We depend on our callers to figure out that its
7690 really a template that's being returned. */
7691 old_decl
= DECL_TEMPLATE_RESULT (old_decl
);
7693 if (DECL_STATIC_FUNCTION_P (old_decl
)
7694 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
7696 /* Remove the `this' parm added by grokclassfn. */
7697 revert_static_member_fn (decl
);
7698 check_static_quals (decl
, quals
);
7700 if (DECL_ARTIFICIAL (old_decl
))
7702 error ("definition of implicitly-declared %qD", old_decl
);
7705 else if (DECL_DEFAULTED_FN (old_decl
))
7707 error ("definition of explicitly-defaulted %q+D", decl
);
7708 error ("%q+#D explicitly defaulted here", old_decl
);
7712 /* Since we've smashed OLD_DECL to its
7713 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
7714 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
7715 decl
= DECL_TEMPLATE_RESULT (decl
);
7717 /* Attempt to merge the declarations. This can fail, in
7718 the case of some invalid specialization declarations. */
7719 pushed_scope
= push_scope (ctype
);
7720 ok
= duplicate_decls (decl
, old_decl
, friendp
);
7722 pop_scope (pushed_scope
);
7725 error ("no %q#D member function declared in class %qT",
7733 if (DECL_CONSTRUCTOR_P (decl
) && !grok_ctor_properties (ctype
, decl
))
7736 if (ctype
== NULL_TREE
|| check
)
7740 DECL_VIRTUAL_P (decl
) = 1;
7745 /* decl is a FUNCTION_DECL.
7746 specifiers are the parsed virt-specifiers.
7748 Set flags to reflect the virt-specifiers.
7753 set_virt_specifiers (tree decl
, cp_virt_specifiers specifiers
)
7755 if (decl
== NULL_TREE
)
7757 if (specifiers
& VIRT_SPEC_OVERRIDE
)
7758 DECL_OVERRIDE_P (decl
) = 1;
7759 if (specifiers
& VIRT_SPEC_FINAL
)
7760 DECL_FINAL_P (decl
) = 1;
7764 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
7765 the linkage that DECL will receive in the object file. */
7768 set_linkage_for_static_data_member (tree decl
)
7770 /* A static data member always has static storage duration and
7771 external linkage. Note that static data members are forbidden in
7772 local classes -- the only situation in which a class has
7773 non-external linkage. */
7774 TREE_PUBLIC (decl
) = 1;
7775 TREE_STATIC (decl
) = 1;
7776 /* For non-template classes, static data members are always put
7777 out in exactly those files where they are defined, just as
7778 with ordinary namespace-scope variables. */
7779 if (!processing_template_decl
)
7780 DECL_INTERFACE_KNOWN (decl
) = 1;
7783 /* Create a VAR_DECL named NAME with the indicated TYPE.
7785 If SCOPE is non-NULL, it is the class type or namespace containing
7786 the variable. If SCOPE is NULL, the variable should is created in
7787 the innermost enclosings scope. */
7790 grokvardecl (tree type
,
7792 const cp_decl_specifier_seq
*declspecs
,
7798 tree explicit_scope
;
7800 gcc_assert (!name
|| identifier_p (name
));
7802 /* Compute the scope in which to place the variable, but remember
7803 whether or not that scope was explicitly specified by the user. */
7804 explicit_scope
= scope
;
7807 /* An explicit "extern" specifier indicates a namespace-scope
7809 if (declspecs
->storage_class
== sc_extern
)
7810 scope
= current_decl_namespace ();
7811 else if (!at_function_scope_p ())
7812 scope
= current_scope ();
7816 && (/* If the variable is a namespace-scope variable declared in a
7817 template, we need DECL_LANG_SPECIFIC. */
7818 (TREE_CODE (scope
) == NAMESPACE_DECL
&& processing_template_decl
)
7819 /* Similarly for namespace-scope variables with language linkage
7821 || (TREE_CODE (scope
) == NAMESPACE_DECL
7822 && current_lang_name
!= lang_name_cplusplus
)
7823 /* Similarly for static data members. */
7825 decl
= build_lang_decl (VAR_DECL
, name
, type
);
7827 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
7829 if (explicit_scope
&& TREE_CODE (explicit_scope
) == NAMESPACE_DECL
)
7830 set_decl_namespace (decl
, explicit_scope
, 0);
7832 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
7834 if (declspecs
->storage_class
== sc_extern
)
7836 DECL_THIS_EXTERN (decl
) = 1;
7837 DECL_EXTERNAL (decl
) = !initialized
;
7840 if (DECL_CLASS_SCOPE_P (decl
))
7842 set_linkage_for_static_data_member (decl
);
7843 /* This function is only called with out-of-class definitions. */
7844 DECL_EXTERNAL (decl
) = 0;
7845 check_class_member_definition_namespace (decl
);
7847 /* At top level, either `static' or no s.c. makes a definition
7848 (perhaps tentative), and absence of `static' makes it public. */
7849 else if (toplevel_bindings_p ())
7851 TREE_PUBLIC (decl
) = (declspecs
->storage_class
!= sc_static
7852 && (DECL_THIS_EXTERN (decl
) || ! constp
));
7853 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
7855 /* Not at top level, only `static' makes a static definition. */
7858 TREE_STATIC (decl
) = declspecs
->storage_class
== sc_static
;
7859 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
7862 if (decl_spec_seq_has_spec_p (declspecs
, ds_thread
))
7864 DECL_TLS_MODEL (decl
) = decl_default_tls_model (decl
);
7865 if (declspecs
->gnu_thread_keyword_p
)
7866 DECL_GNU_TLS_P (decl
) = true;
7869 /* If the type of the decl has no linkage, make sure that we'll
7870 notice that in mark_used. */
7871 if (cxx_dialect
> cxx98
7872 && decl_linkage (decl
) != lk_none
7873 && DECL_LANG_SPECIFIC (decl
) == NULL
7874 && !DECL_EXTERN_C_P (decl
)
7875 && no_linkage_check (TREE_TYPE (decl
), /*relaxed_p=*/false))
7876 retrofit_lang_decl (decl
);
7878 if (TREE_PUBLIC (decl
))
7880 /* [basic.link]: A name with no linkage (notably, the name of a class
7881 or enumeration declared in a local scope) shall not be used to
7882 declare an entity with linkage.
7884 DR 757 relaxes this restriction for C++0x. */
7885 tree t
= (cxx_dialect
> cxx98
? NULL_TREE
7886 : no_linkage_check (TREE_TYPE (decl
), /*relaxed_p=*/false));
7889 if (TYPE_ANONYMOUS_P (t
))
7891 if (DECL_EXTERN_C_P (decl
))
7892 /* Allow this; it's pretty common in C. */
7896 /* DRs 132, 319 and 389 seem to indicate types with
7897 no linkage can only be used to declare extern "C"
7898 entities. Since it's not always an error in the
7899 ISO C++ 90 Standard, we only issue a warning. */
7900 warning (0, "anonymous type with no linkage used to declare "
7901 "variable %q#D with linkage", decl
);
7902 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
7903 warning (0, "%q+#D does not refer to the unqualified "
7904 "type, so it is not used for linkage",
7909 warning (0, "type %qT with no linkage used to declare variable "
7910 "%q#D with linkage", t
, decl
);
7914 DECL_INTERFACE_KNOWN (decl
) = 1;
7919 /* Create and return a canonical pointer to member function type, for
7920 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
7923 build_ptrmemfunc_type (tree type
)
7927 tree unqualified_variant
= NULL_TREE
;
7929 if (type
== error_mark_node
)
7932 /* If a canonical type already exists for this type, use it. We use
7933 this method instead of type_hash_canon, because it only does a
7934 simple equality check on the list of field members. */
7936 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
7939 /* Make sure that we always have the unqualified pointer-to-member
7941 if (cp_type_quals (type
) != TYPE_UNQUALIFIED
)
7943 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type
));
7945 t
= make_class_type (RECORD_TYPE
);
7946 xref_basetypes (t
, NULL_TREE
);
7948 /* Let the front end know this is a pointer to member function... */
7949 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
7950 /* ... and not really a class type. */
7951 SET_CLASS_TYPE_P (t
, 0);
7953 field
= build_decl (input_location
, FIELD_DECL
, pfn_identifier
, type
);
7956 field
= build_decl (input_location
, FIELD_DECL
, delta_identifier
,
7958 DECL_CHAIN (field
) = fields
;
7961 finish_builtin_struct (t
, "__ptrmemfunc_type", fields
, ptr_type_node
);
7963 /* Zap out the name so that the back end will give us the debugging
7964 information for this anonymous RECORD_TYPE. */
7965 TYPE_NAME (t
) = NULL_TREE
;
7967 /* If this is not the unqualified form of this pointer-to-member
7968 type, set the TYPE_MAIN_VARIANT for this type to be the
7969 unqualified type. Since they are actually RECORD_TYPEs that are
7970 not variants of each other, we must do this manually.
7971 As we just built a new type there is no need to do yet another copy. */
7972 if (cp_type_quals (type
) != TYPE_UNQUALIFIED
)
7974 int type_quals
= cp_type_quals (type
);
7975 TYPE_READONLY (t
) = (type_quals
& TYPE_QUAL_CONST
) != 0;
7976 TYPE_VOLATILE (t
) = (type_quals
& TYPE_QUAL_VOLATILE
) != 0;
7977 TYPE_RESTRICT (t
) = (type_quals
& TYPE_QUAL_RESTRICT
) != 0;
7978 TYPE_MAIN_VARIANT (t
) = unqualified_variant
;
7979 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (unqualified_variant
);
7980 TYPE_NEXT_VARIANT (unqualified_variant
) = t
;
7981 TREE_TYPE (TYPE_BINFO (t
)) = t
;
7984 /* Cache this pointer-to-member type so that we can find it again
7986 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
7988 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
7989 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7990 else if (TYPE_CANONICAL (type
) != type
)
7991 TYPE_CANONICAL (t
) = build_ptrmemfunc_type (TYPE_CANONICAL (type
));
7996 /* Create and return a pointer to data member type. */
7999 build_ptrmem_type (tree class_type
, tree member_type
)
8001 if (TREE_CODE (member_type
) == METHOD_TYPE
)
8003 cp_cv_quals quals
= type_memfn_quals (member_type
);
8004 cp_ref_qualifier rqual
= type_memfn_rqual (member_type
);
8005 member_type
= build_memfn_type (member_type
, class_type
, quals
, rqual
);
8006 return build_ptrmemfunc_type (build_pointer_type (member_type
));
8010 gcc_assert (TREE_CODE (member_type
) != FUNCTION_TYPE
);
8011 return build_offset_type (class_type
, member_type
);
8015 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
8016 Check to see that the definition is valid. Issue appropriate error
8017 messages. Return 1 if the definition is particularly bad, or 0
8021 check_static_variable_definition (tree decl
, tree type
)
8023 /* Can't check yet if we don't know the type. */
8024 if (dependent_type_p (type
))
8026 /* If DECL is declared constexpr, we'll do the appropriate checks
8027 in check_initializer. */
8028 if (DECL_P (decl
) && DECL_DECLARED_CONSTEXPR_P (decl
))
8030 else if (cxx_dialect
>= cxx0x
&& !INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
8032 if (!COMPLETE_TYPE_P (type
))
8033 error ("in-class initialization of static data member %q#D of "
8034 "incomplete type", decl
);
8035 else if (literal_type_p (type
))
8036 permerror (input_location
,
8037 "%<constexpr%> needed for in-class initialization of "
8038 "static data member %q#D of non-integral type", decl
);
8040 error ("in-class initialization of static data member %q#D of "
8041 "non-literal type", decl
);
8045 /* Motion 10 at San Diego: If a static const integral data member is
8046 initialized with an integral constant expression, the initializer
8047 may appear either in the declaration (within the class), or in
8048 the definition, but not both. If it appears in the class, the
8049 member is a member constant. The file-scope definition is always
8051 if (!ARITHMETIC_TYPE_P (type
) && TREE_CODE (type
) != ENUMERAL_TYPE
)
8053 error ("invalid in-class initialization of static data member "
8054 "of non-integral type %qT",
8058 else if (!CP_TYPE_CONST_P (type
))
8059 error ("ISO C++ forbids in-class initialization of non-const "
8060 "static member %qD",
8062 else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
8063 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids initialization of member constant "
8064 "%qD of non-integral type %qT", decl
, type
);
8069 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
8070 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
8071 expressions out into temporary variables so that walk_tree doesn't
8072 step into them (c++/15764). */
8075 stabilize_save_expr_r (tree
*expr_p
, int *walk_subtrees
, void *data
)
8077 struct pointer_set_t
*pset
= (struct pointer_set_t
*)data
;
8078 tree expr
= *expr_p
;
8079 if (TREE_CODE (expr
) == SAVE_EXPR
)
8081 tree op
= TREE_OPERAND (expr
, 0);
8082 cp_walk_tree (&op
, stabilize_save_expr_r
, data
, pset
);
8083 if (TREE_SIDE_EFFECTS (op
))
8084 TREE_OPERAND (expr
, 0) = get_temp_regvar (TREE_TYPE (op
), op
);
8087 else if (!EXPR_P (expr
) || !TREE_SIDE_EFFECTS (expr
))
8092 /* Entry point for the above. */
8095 stabilize_vla_size (tree size
)
8097 struct pointer_set_t
*pset
= pointer_set_create ();
8098 /* Break out any function calls into temporary variables. */
8099 cp_walk_tree (&size
, stabilize_save_expr_r
, pset
, pset
);
8100 pointer_set_destroy (pset
);
8103 /* Helper function for compute_array_index_type. Look for SIZEOF_EXPR
8104 not inside of SAVE_EXPR and fold them. */
8107 fold_sizeof_expr_r (tree
*expr_p
, int *walk_subtrees
, void *data
)
8109 tree expr
= *expr_p
;
8110 if (TREE_CODE (expr
) == SAVE_EXPR
|| TYPE_P (expr
))
8112 else if (TREE_CODE (expr
) == SIZEOF_EXPR
)
8114 *(bool *)data
= true;
8115 if (SIZEOF_EXPR_TYPE_P (expr
))
8116 expr
= cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (expr
, 0)),
8117 SIZEOF_EXPR
, false);
8118 else if (TYPE_P (TREE_OPERAND (expr
, 0)))
8119 expr
= cxx_sizeof_or_alignof_type (TREE_OPERAND (expr
, 0), SIZEOF_EXPR
,
8122 expr
= cxx_sizeof_or_alignof_expr (TREE_OPERAND (expr
, 0), SIZEOF_EXPR
,
8124 if (expr
== error_mark_node
)
8125 expr
= size_one_node
;
8132 /* Given the SIZE (i.e., number of elements) in an array, compute an
8133 appropriate index type for the array. If non-NULL, NAME is the
8134 name of the thing being declared. */
8137 compute_array_index_type (tree name
, tree size
, tsubst_flags_t complain
)
8141 tree abi_1_itype
= NULL_TREE
;
8143 if (error_operand_p (size
))
8144 return error_mark_node
;
8146 if (!type_dependent_expression_p (size
))
8148 tree type
= TREE_TYPE (size
);
8150 mark_rvalue_use (size
);
8152 if (cxx_dialect
< cxx0x
&& TREE_CODE (size
) == NOP_EXPR
8153 && TREE_SIDE_EFFECTS (size
))
8154 /* In C++98, we mark a non-constant array bound with a magic
8155 NOP_EXPR with TREE_SIDE_EFFECTS; don't fold in that case. */;
8158 size
= fold_non_dependent_expr_sfinae (size
, complain
);
8160 if (CLASS_TYPE_P (type
)
8161 && CLASSTYPE_LITERAL_P (type
))
8163 size
= build_expr_type_conversion (WANT_INT
, size
, true);
8166 if (!(complain
& tf_error
))
8167 return error_mark_node
;
8169 error ("size of array %qD has non-integral type %qT",
8172 error ("size of array has non-integral type %qT", type
);
8173 size
= integer_one_node
;
8175 if (size
== error_mark_node
)
8176 return error_mark_node
;
8177 type
= TREE_TYPE (size
);
8178 /* We didn't support this case in GCC 3.2, so don't bother
8179 trying to model it now in ABI v1. */
8180 abi_1_itype
= error_mark_node
;
8183 size
= maybe_constant_value (size
);
8184 if (!TREE_CONSTANT (size
))
8188 if (error_operand_p (size
))
8189 return error_mark_node
;
8191 /* The array bound must be an integer type. */
8192 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
8194 if (!(complain
& tf_error
))
8195 return error_mark_node
;
8197 error ("size of array %qD has non-integral type %qT", name
, type
);
8199 error ("size of array has non-integral type %qT", type
);
8200 size
= integer_one_node
;
8201 type
= TREE_TYPE (size
);
8205 /* A type is dependent if it is...an array type constructed from any
8206 dependent type or whose size is specified by a constant expression
8207 that is value-dependent. */
8208 /* We can only call value_dependent_expression_p on integral constant
8209 expressions; treat non-constant expressions as dependent, too. */
8210 if (processing_template_decl
8211 && (type_dependent_expression_p (size
)
8212 || !TREE_CONSTANT (size
) || value_dependent_expression_p (size
)))
8214 /* We cannot do any checking for a SIZE that isn't known to be
8215 constant. Just build the index type and mark that it requires
8216 structural equality checks. */
8217 itype
= build_index_type (build_min (MINUS_EXPR
, sizetype
,
8218 size
, integer_one_node
));
8219 TYPE_DEPENDENT_P (itype
) = 1;
8220 TYPE_DEPENDENT_P_VALID (itype
) = 1;
8221 SET_TYPE_STRUCTURAL_EQUALITY (itype
);
8225 if (!abi_version_at_least (2) && processing_template_decl
8226 && abi_1_itype
== NULL_TREE
)
8227 /* For abi-1, we handled all instances in templates the same way,
8228 even when they were non-dependent. This affects the manglings
8229 produced. So, we do the normal checking for non-dependent
8230 sizes, but at the end we'll return the same type that abi-1
8231 would have, but with TYPE_CANONICAL set to the "right"
8232 value that the current ABI would provide. */
8233 abi_1_itype
= build_index_type (build_min (MINUS_EXPR
, sizetype
,
8234 osize
, integer_one_node
));
8236 /* Normally, the array-bound will be a constant. */
8237 if (TREE_CODE (size
) == INTEGER_CST
)
8239 /* Check to see if the array bound overflowed. Make that an
8240 error, no matter how generous we're being. */
8241 constant_expression_error (size
);
8243 /* An array must have a positive number of elements. */
8244 if (INT_CST_LT (size
, integer_zero_node
))
8246 if (!(complain
& tf_error
))
8247 return error_mark_node
;
8249 error ("size of array %qD is negative", name
);
8251 error ("size of array is negative");
8252 size
= integer_one_node
;
8254 /* As an extension we allow zero-sized arrays. */
8255 else if (integer_zerop (size
))
8257 if (!(complain
& tf_error
))
8258 /* We must fail if performing argument deduction (as
8259 indicated by the state of complain), so that
8260 another substitution can be found. */
8261 return error_mark_node
;
8262 else if (in_system_header
)
8263 /* Allow them in system headers because glibc uses them. */;
8265 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids zero-size array %qD", name
);
8267 pedwarn (input_location
, OPT_Wpedantic
, "ISO C++ forbids zero-size array");
8270 else if (TREE_CONSTANT (size
)
8271 /* We don't allow VLAs at non-function scopes, or during
8272 tentative template substitution. */
8273 || !at_function_scope_p () || !(complain
& tf_error
))
8275 if (!(complain
& tf_error
))
8276 return error_mark_node
;
8277 /* `(int) &fn' is not a valid array bound. */
8279 error ("size of array %qD is not an integral constant-expression",
8282 error ("size of array is not an integral constant-expression");
8283 size
= integer_one_node
;
8285 else if (pedantic
&& warn_vla
!= 0)
8288 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array %qD", name
);
8290 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array");
8292 else if (warn_vla
> 0)
8296 "variable length array %qD is used", name
);
8299 "variable length array is used");
8302 if (processing_template_decl
&& !TREE_CONSTANT (size
))
8303 /* A variable sized array. */
8304 itype
= build_min (MINUS_EXPR
, sizetype
, size
, integer_one_node
);
8307 HOST_WIDE_INT saved_processing_template_decl
;
8309 /* Compute the index of the largest element in the array. It is
8310 one less than the number of elements in the array. We save
8311 and restore PROCESSING_TEMPLATE_DECL so that computations in
8312 cp_build_binary_op will be appropriately folded. */
8313 saved_processing_template_decl
= processing_template_decl
;
8314 processing_template_decl
= 0;
8315 itype
= cp_build_binary_op (input_location
,
8317 cp_convert (ssizetype
, size
, complain
),
8318 cp_convert (ssizetype
, integer_one_node
,
8321 itype
= fold (itype
);
8322 processing_template_decl
= saved_processing_template_decl
;
8324 if (!TREE_CONSTANT (itype
))
8326 /* A variable sized array. */
8327 itype
= variable_size (itype
);
8328 if (TREE_CODE (itype
) != SAVE_EXPR
)
8330 /* Look for SIZEOF_EXPRs in itype and fold them, otherwise
8331 they might survive till gimplification. */
8332 tree newitype
= itype
;
8334 cp_walk_tree_without_duplicates (&newitype
,
8335 fold_sizeof_expr_r
, &found
);
8337 itype
= variable_size (fold (newitype
));
8340 /* Make sure that there was no overflow when creating to a signed
8341 index type. (For example, on a 32-bit machine, an array with
8342 size 2^32 - 1 is too big.) */
8343 else if (TREE_CODE (itype
) == INTEGER_CST
8344 && TREE_OVERFLOW (itype
))
8346 if (!(complain
& tf_error
))
8347 return error_mark_node
;
8348 error ("overflow in array dimension");
8349 TREE_OVERFLOW (itype
) = 0;
8353 /* Create and return the appropriate index type. */
8354 if (abi_1_itype
&& abi_1_itype
!= error_mark_node
)
8356 tree t
= build_index_type (itype
);
8357 TYPE_CANONICAL (abi_1_itype
) = TYPE_CANONICAL (t
);
8358 itype
= abi_1_itype
;
8361 itype
= build_index_type (itype
);
8363 /* If the index type were dependent, we would have returned early, so
8364 remember that it isn't. */
8365 TYPE_DEPENDENT_P (itype
) = 0;
8366 TYPE_DEPENDENT_P_VALID (itype
) = 1;
8370 /* Returns the scope (if any) in which the entity declared by
8371 DECLARATOR will be located. If the entity was declared with an
8372 unqualified name, NULL_TREE is returned. */
8375 get_scope_of_declarator (const cp_declarator
*declarator
)
8377 while (declarator
&& declarator
->kind
!= cdk_id
)
8378 declarator
= declarator
->declarator
;
8380 /* If the declarator-id is a SCOPE_REF, the scope in which the
8381 declaration occurs is the first operand. */
8383 && declarator
->u
.id
.qualifying_scope
)
8384 return declarator
->u
.id
.qualifying_scope
;
8386 /* Otherwise, the declarator is not a qualified name; the entity will
8387 be declared in the current scope. */
8391 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
8392 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
8396 create_array_type_for_decl (tree name
, tree type
, tree size
)
8398 tree itype
= NULL_TREE
;
8400 /* If things have already gone awry, bail now. */
8401 if (type
== error_mark_node
|| size
== error_mark_node
)
8402 return error_mark_node
;
8404 /* 8.3.4/1: If the type of the identifier of D contains the auto
8405 type-specifier, the program is ill-formed. */
8406 if (pedantic
&& type_uses_auto (type
))
8407 pedwarn (input_location
, OPT_Wpedantic
,
8408 "declaration of %qD as array of %<auto%>", name
);
8410 /* If there are some types which cannot be array elements,
8411 issue an error-message and return. */
8412 switch (TREE_CODE (type
))
8416 error ("declaration of %qD as array of void", name
);
8418 error ("creating array of void");
8419 return error_mark_node
;
8423 error ("declaration of %qD as array of functions", name
);
8425 error ("creating array of functions");
8426 return error_mark_node
;
8428 case REFERENCE_TYPE
:
8430 error ("declaration of %qD as array of references", name
);
8432 error ("creating array of references");
8433 return error_mark_node
;
8437 error ("declaration of %qD as array of function members", name
);
8439 error ("creating array of function members");
8440 return error_mark_node
;
8448 The constant expressions that specify the bounds of the arrays
8449 can be omitted only for the first member of the sequence. */
8450 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
8453 error ("declaration of %qD as multidimensional array must "
8454 "have bounds for all dimensions except the first",
8457 error ("multidimensional array must have bounds for all "
8458 "dimensions except the first");
8460 return error_mark_node
;
8463 /* Figure out the index type for the array. */
8465 itype
= compute_array_index_type (name
, size
, tf_warning_or_error
);
8468 T is called the array element type; this type shall not be [...] an
8469 abstract class type. */
8470 abstract_virtuals_error (name
, type
);
8472 return build_cplus_array_type (type
, itype
);
8475 /* Check that it's OK to declare a function with the indicated TYPE.
8476 SFK indicates the kind of special function (if any) that this
8477 function is. OPTYPE is the type given in a conversion operator
8478 declaration, or the class type for a constructor/destructor.
8479 Returns the actual return type of the function; that
8480 may be different than TYPE if an error occurs, or for certain
8481 special functions. */
8484 check_special_function_return_type (special_function_kind sfk
,
8490 case sfk_constructor
:
8492 error ("return type specification for constructor invalid");
8494 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
8495 type
= build_pointer_type (optype
);
8497 type
= void_type_node
;
8500 case sfk_destructor
:
8502 error ("return type specification for destructor invalid");
8503 /* We can't use the proper return type here because we run into
8504 problems with ambiguous bases and covariant returns.
8505 Java classes are left unchanged because (void *) isn't a valid
8506 Java type, and we don't want to change the Java ABI. */
8507 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
8508 type
= build_pointer_type (void_type_node
);
8510 type
= void_type_node
;
8513 case sfk_conversion
:
8515 error ("return type specified for %<operator %T%>", optype
);
8526 /* A variable or data member (whose unqualified name is IDENTIFIER)
8527 has been declared with the indicated TYPE. If the TYPE is not
8528 acceptable, issue an error message and return a type to use for
8529 error-recovery purposes. */
8532 check_var_type (tree identifier
, tree type
)
8534 if (VOID_TYPE_P (type
))
8537 error ("unnamed variable or field declared void");
8538 else if (identifier_p (identifier
))
8540 gcc_assert (!IDENTIFIER_OPNAME_P (identifier
));
8541 error ("variable or field %qE declared void", identifier
);
8544 error ("variable or field declared void");
8545 type
= error_mark_node
;
8551 /* Functions for adjusting the visibility of a tagged type and its nested
8552 types when it gets a name for linkage purposes from a typedef. */
8554 static void bt_reset_linkage (binding_entry
, void *);
8556 reset_type_linkage (tree type
)
8558 set_linkage_according_to_type (type
, TYPE_MAIN_DECL (type
));
8559 if (CLASS_TYPE_P (type
))
8560 binding_table_foreach (CLASSTYPE_NESTED_UTDS (type
), bt_reset_linkage
, NULL
);
8563 bt_reset_linkage (binding_entry b
, void */
*data*/
)
8565 reset_type_linkage (b
->type
);
8568 /* Given declspecs and a declarator (abstract or otherwise), determine
8569 the name and type of the object declared and construct a DECL node
8572 DECLSPECS points to the representation of declaration-specifier
8573 sequence that precedes declarator.
8575 DECL_CONTEXT says which syntactic context this declaration is in:
8576 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
8577 FUNCDEF for a function definition. Like NORMAL but a few different
8578 error messages in each case. Return value may be zero meaning
8579 this definition is too screwy to try to parse.
8580 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
8581 handle member functions (which have FIELD context).
8582 Return value may be zero meaning this definition is too screwy to
8584 PARM for a parameter declaration (either within a function prototype
8585 or before a function body). Make a PARM_DECL, or return void_type_node.
8586 TPARM for a template parameter declaration.
8587 CATCHPARM for a parameter declaration before a catch clause.
8588 TYPENAME if for a typename (in a cast or sizeof).
8589 Don't make a DECL node; just return the ..._TYPE node.
8590 FIELD for a struct or union field; make a FIELD_DECL.
8591 BITFIELD for a field with specified width.
8593 INITIALIZED is as for start_decl.
8595 ATTRLIST is a pointer to the list of attributes, which may be NULL
8596 if there are none; *ATTRLIST may be modified if attributes from inside
8597 the declarator should be applied to the declaration.
8599 When this function is called, scoping variables (such as
8600 CURRENT_CLASS_TYPE) should reflect the scope in which the
8601 declaration occurs, not the scope in which the new declaration will
8602 be placed. For example, on:
8606 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
8609 Returns a DECL (if a declarator is present), a TYPE (if there is no
8610 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
8614 grokdeclarator (const cp_declarator
*declarator
,
8615 cp_decl_specifier_seq
*declspecs
,
8616 enum decl_context decl_context
,
8620 tree type
= NULL_TREE
;
8622 int explicit_int128
= 0;
8623 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
8624 int explicit_int
= 0;
8625 int explicit_char
= 0;
8626 int defaulted_int
= 0;
8628 tree typedef_decl
= NULL_TREE
;
8629 const char *name
= NULL
;
8630 tree typedef_type
= NULL_TREE
;
8631 /* True if this declarator is a function definition. */
8632 bool funcdef_flag
= false;
8633 cp_declarator_kind innermost_code
= cdk_error
;
8636 /* See the code below that used this. */
8637 tree decl_attr
= NULL_TREE
;
8640 /* Keep track of what sort of function is being processed
8641 so that we can warn about default return values, or explicit
8642 return values which do not match prescribed defaults. */
8643 special_function_kind sfk
= sfk_none
;
8645 tree dname
= NULL_TREE
;
8646 tree ctor_return_type
= NULL_TREE
;
8647 enum overload_flags flags
= NO_SPECIAL
;
8648 /* cv-qualifiers that apply to the declarator, for a declaration of
8649 a member function. */
8650 cp_cv_quals memfn_quals
= TYPE_UNQUALIFIED
;
8651 /* virt-specifiers that apply to the declarator, for a declaration of
8652 a member function. */
8653 cp_virt_specifiers virt_specifiers
= VIRT_SPEC_UNSPECIFIED
;
8654 /* ref-qualifier that applies to the declarator, for a declaration of
8655 a member function. */
8656 cp_ref_qualifier rqual
= REF_QUAL_NONE
;
8657 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
8659 tree raises
= NULL_TREE
;
8660 int template_count
= 0;
8661 tree returned_attrs
= NULL_TREE
;
8662 tree parms
= NULL_TREE
;
8663 const cp_declarator
*id_declarator
;
8664 /* The unqualified name of the declarator; either an
8665 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
8666 tree unqualified_id
;
8667 /* The class type, if any, in which this entity is located,
8668 or NULL_TREE if none. Note that this value may be different from
8669 the current class type; for example if an attempt is made to declare
8670 "A::f" inside "B", this value will be "A". */
8671 tree ctype
= current_class_type
;
8672 /* The NAMESPACE_DECL for the namespace in which this entity is
8673 located. If an unqualified name is used to declare the entity,
8674 this value will be NULL_TREE, even if the entity is located at
8676 tree in_namespace
= NULL_TREE
;
8677 cp_storage_class storage_class
;
8678 bool unsigned_p
, signed_p
, short_p
, long_p
, thread_p
;
8679 bool type_was_error_mark_node
= false;
8680 bool parameter_pack_p
= declarator
? declarator
->parameter_pack_p
: false;
8681 bool template_type_arg
= false;
8682 bool template_parm_flag
= false;
8683 bool typedef_p
= decl_spec_seq_has_spec_p (declspecs
, ds_typedef
);
8684 bool constexpr_p
= decl_spec_seq_has_spec_p (declspecs
, ds_constexpr
);
8685 source_location saved_loc
= input_location
;
8688 signed_p
= decl_spec_seq_has_spec_p (declspecs
, ds_signed
);
8689 unsigned_p
= decl_spec_seq_has_spec_p (declspecs
, ds_unsigned
);
8690 short_p
= decl_spec_seq_has_spec_p (declspecs
, ds_short
);
8691 long_p
= decl_spec_seq_has_spec_p (declspecs
, ds_long
);
8692 longlong
= decl_spec_seq_has_spec_p (declspecs
, ds_long_long
);
8693 explicit_int128
= declspecs
->explicit_int128_p
;
8694 thread_p
= decl_spec_seq_has_spec_p (declspecs
, ds_thread
);
8696 if (decl_context
== FUNCDEF
)
8697 funcdef_flag
= true, decl_context
= NORMAL
;
8698 else if (decl_context
== MEMFUNCDEF
)
8699 funcdef_flag
= true, decl_context
= FIELD
;
8700 else if (decl_context
== BITFIELD
)
8701 bitfield
= 1, decl_context
= FIELD
;
8702 else if (decl_context
== TEMPLATE_TYPE_ARG
)
8703 template_type_arg
= true, decl_context
= TYPENAME
;
8704 else if (decl_context
== TPARM
)
8705 template_parm_flag
= true, decl_context
= PARM
;
8707 if (initialized
> 1)
8708 funcdef_flag
= true;
8710 /* Look inside a declarator for the name being declared
8711 and get it as a string, for an error message. */
8712 for (id_declarator
= declarator
;
8714 id_declarator
= id_declarator
->declarator
)
8716 if (id_declarator
->kind
!= cdk_id
)
8717 innermost_code
= id_declarator
->kind
;
8719 switch (id_declarator
->kind
)
8722 if (id_declarator
->declarator
8723 && id_declarator
->declarator
->kind
== cdk_id
)
8725 sfk
= id_declarator
->declarator
->u
.id
.sfk
;
8726 if (sfk
== sfk_destructor
)
8733 tree qualifying_scope
= id_declarator
->u
.id
.qualifying_scope
;
8734 tree decl
= id_declarator
->u
.id
.unqualified_name
;
8737 if (qualifying_scope
)
8739 if (at_function_scope_p ())
8743 A declarator-id shall not be qualified except
8746 None of the cases are permitted in block
8748 if (qualifying_scope
== global_namespace
)
8749 error ("invalid use of qualified-name %<::%D%>",
8751 else if (TYPE_P (qualifying_scope
))
8752 error ("invalid use of qualified-name %<%T::%D%>",
8753 qualifying_scope
, decl
);
8755 error ("invalid use of qualified-name %<%D::%D%>",
8756 qualifying_scope
, decl
);
8757 return error_mark_node
;
8759 else if (TYPE_P (qualifying_scope
))
8761 ctype
= qualifying_scope
;
8762 if (!MAYBE_CLASS_TYPE_P (ctype
))
8764 error ("%q#T is not a class or a namespace", ctype
);
8767 else if (innermost_code
!= cdk_function
8768 && current_class_type
8769 && !uniquely_derived_from_p (ctype
,
8770 current_class_type
))
8772 error ("type %qT is not derived from type %qT",
8773 ctype
, current_class_type
);
8774 return error_mark_node
;
8777 else if (TREE_CODE (qualifying_scope
) == NAMESPACE_DECL
)
8778 in_namespace
= qualifying_scope
;
8780 switch (TREE_CODE (decl
))
8786 if (innermost_code
!= cdk_function
)
8788 error ("declaration of %qD as non-function", decl
);
8789 return error_mark_node
;
8791 else if (!qualifying_scope
8792 && !(current_class_type
&& at_class_scope_p ()))
8794 error ("declaration of %qD as non-member", decl
);
8795 return error_mark_node
;
8798 type
= TREE_OPERAND (decl
, 0);
8800 type
= constructor_name (type
);
8801 name
= identifier_to_locale (IDENTIFIER_POINTER (type
));
8806 case TEMPLATE_ID_EXPR
:
8808 tree fns
= TREE_OPERAND (decl
, 0);
8811 if (!identifier_p (dname
))
8813 gcc_assert (is_overloaded_fn (dname
));
8814 dname
= DECL_NAME (get_first_fn (dname
));
8819 case IDENTIFIER_NODE
:
8820 if (identifier_p (decl
))
8823 if (C_IS_RESERVED_WORD (dname
))
8825 error ("declarator-id missing; using reserved word %qD",
8827 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
8829 else if (!IDENTIFIER_TYPENAME_P (dname
))
8830 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
8833 gcc_assert (flags
== NO_SPECIAL
);
8834 flags
= TYPENAME_FLAG
;
8835 ctor_return_type
= TREE_TYPE (dname
);
8836 sfk
= sfk_conversion
;
8837 if (is_typename_at_global_scope (dname
))
8838 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
8840 name
= "<invalid operator>";
8857 return error_mark_node
;
8862 if (id_declarator
->kind
== cdk_id
)
8868 The declarator in a function-definition shall have the form
8869 D1 ( parameter-declaration-clause) ... */
8870 if (funcdef_flag
&& innermost_code
!= cdk_function
)
8872 error ("function definition does not declare parameters");
8873 return error_mark_node
;
8876 if (((dname
&& IDENTIFIER_OPNAME_P (dname
)) || flags
== TYPENAME_FLAG
)
8877 && innermost_code
!= cdk_function
8878 && ! (ctype
&& !declspecs
->any_specifiers_p
))
8880 error ("declaration of %qD as non-function", dname
);
8881 return error_mark_node
;
8885 && identifier_p (dname
)
8886 && UDLIT_OPER_P (dname
)
8887 && innermost_code
!= cdk_function
)
8889 error ("declaration of %qD as non-function", dname
);
8890 return error_mark_node
;
8893 if (dname
&& IDENTIFIER_OPNAME_P (dname
))
8897 error ("declaration of %qD as %<typedef%>", dname
);
8898 return error_mark_node
;
8900 else if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
8902 error ("declaration of %qD as parameter", dname
);
8903 return error_mark_node
;
8907 /* Anything declared one level down from the top level
8908 must be one of the parameters of a function
8909 (because the body is at least two levels down). */
8911 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
8912 by not allowing C++ class definitions to specify their parameters
8913 with xdecls (must be spec.d in the parmlist).
8915 Since we now wait to push a class scope until we are sure that
8916 we are in a legitimate method context, we must set oldcname
8917 explicitly (since current_class_name is not yet alive).
8919 We also want to avoid calling this a PARM if it is in a namespace. */
8921 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
8923 cp_binding_level
*b
= current_binding_level
;
8924 current_binding_level
= b
->level_chain
;
8925 if (current_binding_level
!= 0 && toplevel_bindings_p ())
8926 decl_context
= PARM
;
8927 current_binding_level
= b
;
8931 name
= decl_context
== PARM
? "parameter" : "type name";
8933 if (constexpr_p
&& typedef_p
)
8935 error ("%<constexpr%> cannot appear in a typedef declaration");
8936 return error_mark_node
;
8939 /* If there were multiple types specified in the decl-specifier-seq,
8940 issue an error message. */
8941 if (declspecs
->multiple_types_p
)
8943 error ("two or more data types in declaration of %qs", name
);
8944 return error_mark_node
;
8947 if (declspecs
->conflicting_specifiers_p
)
8949 error ("conflicting specifiers in declaration of %qs", name
);
8950 return error_mark_node
;
8953 /* Extract the basic type from the decl-specifier-seq. */
8954 type
= declspecs
->type
;
8955 if (type
== error_mark_node
)
8958 type_was_error_mark_node
= true;
8960 /* If the entire declaration is itself tagged as deprecated then
8961 suppress reports of deprecated items. */
8962 if (type
&& TREE_DEPRECATED (type
)
8963 && deprecated_state
!= DEPRECATED_SUPPRESS
)
8964 warn_deprecated_use (type
, NULL_TREE
);
8965 if (type
&& TREE_CODE (type
) == TYPE_DECL
)
8967 typedef_decl
= type
;
8968 type
= TREE_TYPE (typedef_decl
);
8969 if (TREE_DEPRECATED (type
)
8970 && DECL_ARTIFICIAL (typedef_decl
)
8971 && deprecated_state
!= DEPRECATED_SUPPRESS
)
8972 warn_deprecated_use (type
, NULL_TREE
);
8974 /* No type at all: default to `int', and set DEFAULTED_INT
8975 because it was not a user-defined typedef. */
8976 if (type
== NULL_TREE
&& (signed_p
|| unsigned_p
|| long_p
|| short_p
))
8978 /* These imply 'int'. */
8979 type
= integer_type_node
;
8983 explicit_int
= declspecs
->explicit_int_p
;
8984 explicit_char
= declspecs
->explicit_char_p
;
8987 /* See the code below that used this. */
8989 decl_attr
= DECL_ATTRIBUTES (typedef_decl
);
8991 typedef_type
= type
;
8994 if (sfk
!= sfk_conversion
)
8995 ctor_return_type
= ctype
;
8997 if (sfk
!= sfk_none
)
8998 type
= check_special_function_return_type (sfk
, type
,
9000 else if (type
== NULL_TREE
)
9006 /* We handle `main' specially here, because 'main () { }' is so
9007 common. With no options, it is allowed. With -Wreturn-type,
9008 it is a warning. It is only an error with -pedantic-errors. */
9009 is_main
= (funcdef_flag
9010 && dname
&& identifier_p (dname
)
9011 && MAIN_NAME_P (dname
)
9012 && ctype
== NULL_TREE
9013 && in_namespace
== NULL_TREE
9014 && current_namespace
== global_namespace
);
9016 if (type_was_error_mark_node
)
9017 /* We've already issued an error, don't complain more. */;
9018 else if (in_system_header
|| flag_ms_extensions
)
9019 /* Allow it, sigh. */;
9021 permerror (input_location
, "ISO C++ forbids declaration of %qs with no type", name
);
9023 pedwarn (input_location
, OPT_Wpedantic
,
9024 "ISO C++ forbids declaration of %qs with no type", name
);
9026 warning (OPT_Wreturn_type
,
9027 "ISO C++ forbids declaration of %qs with no type", name
);
9029 type
= integer_type_node
;
9034 if (explicit_int128
)
9036 if (int128_integer_type_node
== NULL_TREE
)
9038 error ("%<__int128%> is not supported by this target");
9039 explicit_int128
= false;
9041 else if (pedantic
&& ! in_system_header
)
9042 pedwarn (input_location
, OPT_Wpedantic
,
9043 "ISO C++ does not support %<__int128%> for %qs", name
);
9046 /* Now process the modifiers that were specified
9047 and check for invalid combinations. */
9049 /* Long double is a special combination. */
9050 if (long_p
&& !longlong
&& TYPE_MAIN_VARIANT (type
) == double_type_node
)
9053 type
= cp_build_qualified_type (long_double_type_node
,
9054 cp_type_quals (type
));
9057 /* Check all other uses of type modifiers. */
9059 if (unsigned_p
|| signed_p
|| long_p
|| short_p
)
9063 if ((signed_p
|| unsigned_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
9064 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
9065 else if (signed_p
&& unsigned_p
)
9066 error ("%<signed%> and %<unsigned%> specified together for %qs", name
);
9067 else if (longlong
&& TREE_CODE (type
) != INTEGER_TYPE
)
9068 error ("%<long long%> invalid for %qs", name
);
9069 else if (long_p
&& TREE_CODE (type
) == REAL_TYPE
)
9070 error ("%<long%> invalid for %qs", name
);
9071 else if (short_p
&& TREE_CODE (type
) == REAL_TYPE
)
9072 error ("%<short%> invalid for %qs", name
);
9073 else if ((long_p
|| short_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
9074 error ("%<long%> or %<short%> invalid for %qs", name
);
9075 else if ((long_p
|| short_p
|| explicit_char
|| explicit_int
) && explicit_int128
)
9076 error ("%<long%>, %<int%>, %<short%>, or %<char%> invalid for %qs", name
);
9077 else if ((long_p
|| short_p
) && explicit_char
)
9078 error ("%<long%> or %<short%> specified with char for %qs", name
);
9079 else if (long_p
&& short_p
)
9080 error ("%<long%> and %<short%> specified together for %qs", name
);
9081 else if (type
== char16_type_node
|| type
== char32_type_node
)
9083 if (signed_p
|| unsigned_p
)
9084 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
9085 else if (short_p
|| long_p
)
9086 error ("%<short%> or %<long%> invalid for %qs", name
);
9091 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& !explicit_int128
&& pedantic
)
9093 pedwarn (input_location
, OPT_Wpedantic
,
9094 "long, short, signed or unsigned used invalidly for %qs",
9096 if (flag_pedantic_errors
)
9101 /* Discard the type modifiers if they are invalid. */
9112 /* Decide whether an integer type is signed or not.
9113 Optionally treat bitfields as signed by default. */
9117 It is implementation-defined whether a plain (neither
9118 explicitly signed or unsigned) char, short, int, or long
9119 bit-field is signed or unsigned.
9121 Naturally, we extend this to long long as well. Note that
9122 this does not include wchar_t. */
9123 || (bitfield
&& !flag_signed_bitfields
9125 /* A typedef for plain `int' without `signed' can be
9126 controlled just like plain `int', but a typedef for
9127 `signed int' cannot be so controlled. */
9129 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
9130 && TREE_CODE (type
) == INTEGER_TYPE
9131 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
9133 if (explicit_int128
)
9134 type
= int128_unsigned_type_node
;
9136 type
= long_long_unsigned_type_node
;
9138 type
= long_unsigned_type_node
;
9140 type
= short_unsigned_type_node
;
9141 else if (type
== char_type_node
)
9142 type
= unsigned_char_type_node
;
9143 else if (typedef_decl
)
9144 type
= unsigned_type_for (type
);
9146 type
= unsigned_type_node
;
9148 else if (signed_p
&& type
== char_type_node
)
9149 type
= signed_char_type_node
;
9150 else if (explicit_int128
)
9151 type
= int128_integer_type_node
;
9153 type
= long_long_integer_type_node
;
9155 type
= long_integer_type_node
;
9157 type
= short_integer_type_node
;
9159 if (decl_spec_seq_has_spec_p (declspecs
, ds_complex
))
9161 if (TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
9162 error ("complex invalid for %qs", name
);
9163 /* If we just have "complex", it is equivalent to
9164 "complex double", but if any modifiers at all are specified it is
9165 the complex form of TYPE. E.g, "complex short" is
9166 "complex short int". */
9167 else if (defaulted_int
&& ! longlong
&& ! explicit_int128
9168 && ! (long_p
|| short_p
|| signed_p
|| unsigned_p
))
9169 type
= complex_double_type_node
;
9170 else if (type
== integer_type_node
)
9171 type
= complex_integer_type_node
;
9172 else if (type
== float_type_node
)
9173 type
= complex_float_type_node
;
9174 else if (type
== double_type_node
)
9175 type
= complex_double_type_node
;
9176 else if (type
== long_double_type_node
)
9177 type
= complex_long_double_type_node
;
9179 type
= build_complex_type (type
);
9182 type_quals
= TYPE_UNQUALIFIED
;
9183 if (decl_spec_seq_has_spec_p (declspecs
, ds_const
))
9184 type_quals
|= TYPE_QUAL_CONST
;
9185 if (decl_spec_seq_has_spec_p (declspecs
, ds_volatile
))
9186 type_quals
|= TYPE_QUAL_VOLATILE
;
9187 if (decl_spec_seq_has_spec_p (declspecs
, ds_restrict
))
9188 type_quals
|= TYPE_QUAL_RESTRICT
;
9189 if (sfk
== sfk_conversion
&& type_quals
!= TYPE_UNQUALIFIED
)
9190 error ("qualifiers are not allowed on declaration of %<operator %T%>",
9193 /* If we're using the injected-class-name to form a compound type or a
9194 declaration, replace it with the underlying class so we don't get
9195 redundant typedefs in the debug output. But if we are returning the
9196 type unchanged, leave it alone so that it's available to
9197 maybe_get_template_decl_from_type_decl. */
9198 if (CLASS_TYPE_P (type
)
9199 && DECL_SELF_REFERENCE_P (TYPE_NAME (type
))
9200 && type
== TREE_TYPE (TYPE_NAME (type
))
9201 && (declarator
|| type_quals
))
9202 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
9204 type_quals
|= cp_type_quals (type
);
9205 type
= cp_build_qualified_type_real
9206 (type
, type_quals
, ((typedef_decl
&& !DECL_ARTIFICIAL (typedef_decl
)
9207 ? tf_ignore_bad_quals
: 0) | tf_warning_or_error
));
9208 /* We might have ignored or rejected some of the qualifiers. */
9209 type_quals
= cp_type_quals (type
);
9212 inlinep
= decl_spec_seq_has_spec_p (declspecs
, ds_inline
);
9213 virtualp
= decl_spec_seq_has_spec_p (declspecs
, ds_virtual
);
9214 explicitp
= decl_spec_seq_has_spec_p (declspecs
, ds_explicit
);
9216 storage_class
= declspecs
->storage_class
;
9217 if (storage_class
== sc_static
)
9218 staticp
= 1 + (decl_context
== FIELD
);
9220 if (virtualp
&& staticp
== 2)
9222 error ("member %qD cannot be declared both virtual and static", dname
);
9223 storage_class
= sc_none
;
9226 friendp
= decl_spec_seq_has_spec_p (declspecs
, ds_friend
);
9228 /* Issue errors about use of storage classes for parameters. */
9229 if (decl_context
== PARM
)
9233 error ("typedef declaration invalid in parameter declaration");
9234 return error_mark_node
;
9236 else if (template_parm_flag
&& storage_class
!= sc_none
)
9238 error ("storage class specified for template parameter %qs", name
);
9239 return error_mark_node
;
9241 else if (storage_class
== sc_static
9242 || storage_class
== sc_extern
9244 error ("storage class specifiers invalid in parameter declarations");
9246 /* Function parameters cannot be constexpr. If we saw one, moan
9247 and pretend it wasn't there. */
9250 error ("a parameter cannot be declared %<constexpr%>");
9255 /* Give error if `virtual' is used outside of class declaration. */
9257 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
9259 error ("%<virtual%> outside class declaration");
9263 /* Static anonymous unions are dealt with here. */
9264 if (staticp
&& decl_context
== TYPENAME
9266 && ANON_AGGR_TYPE_P (declspecs
->type
))
9267 decl_context
= FIELD
;
9269 /* Warn about storage classes that are invalid for certain
9270 kinds of declarations (parameters, typenames, etc.). */
9273 && storage_class
!= sc_extern
9274 && storage_class
!= sc_static
)
9277 error ("multiple storage classes in declaration of %qs", name
);
9280 if (decl_context
!= NORMAL
9281 && ((storage_class
!= sc_none
9282 && storage_class
!= sc_mutable
)
9285 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
9286 && (storage_class
== sc_register
9287 || storage_class
== sc_auto
))
9291 else if (decl_context
== FIELD
9292 /* C++ allows static class elements. */
9293 && storage_class
== sc_static
)
9294 /* C++ also allows inlines and signed and unsigned elements,
9295 but in those cases we don't come in here. */
9299 if (decl_context
== FIELD
)
9300 error ("storage class specified for %qs", name
);
9303 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
9304 error ("storage class specified for parameter %qs", name
);
9306 error ("storage class specified for typename");
9308 if (storage_class
== sc_register
9309 || storage_class
== sc_auto
9310 || storage_class
== sc_extern
9312 storage_class
= sc_none
;
9315 else if (storage_class
== sc_extern
&& funcdef_flag
9316 && ! toplevel_bindings_p ())
9317 error ("nested function %qs declared %<extern%>", name
);
9318 else if (toplevel_bindings_p ())
9320 if (storage_class
== sc_auto
)
9321 error ("top-level declaration of %qs specifies %<auto%>", name
);
9324 && storage_class
!= sc_extern
9325 && storage_class
!= sc_static
)
9327 if (declspecs
->gnu_thread_keyword_p
)
9328 pedwarn (input_location
, 0, "function-scope %qs implicitly auto and "
9329 "declared %<__thread%>", name
);
9331 /* When thread_local is applied to a variable of block scope the
9332 storage-class-specifier static is implied if it does not appear
9334 storage_class
= declspecs
->storage_class
= sc_static
;
9338 if (storage_class
&& friendp
)
9340 error ("storage class specifiers invalid in friend function declarations");
9341 storage_class
= sc_none
;
9346 unqualified_id
= NULL_TREE
;
9349 unqualified_id
= id_declarator
->u
.id
.unqualified_name
;
9350 switch (TREE_CODE (unqualified_id
))
9353 unqualified_id
= TREE_OPERAND (unqualified_id
, 0);
9354 if (TYPE_P (unqualified_id
))
9355 unqualified_id
= constructor_name (unqualified_id
);
9358 case IDENTIFIER_NODE
:
9359 case TEMPLATE_ID_EXPR
:
9367 if (declspecs
->std_attributes
)
9369 /* Apply the c++11 attributes to the type preceding them. */
9370 input_location
= declspecs
->locations
[ds_std_attribute
];
9371 decl_attributes (&type
, declspecs
->std_attributes
, 0);
9372 input_location
= saved_loc
;
9375 /* Determine the type of the entity declared by recurring on the
9377 for (; declarator
; declarator
= declarator
->declarator
)
9379 const cp_declarator
*inner_declarator
;
9382 if (type
== error_mark_node
)
9383 return error_mark_node
;
9385 attrs
= declarator
->attributes
;
9391 if (declarator
== NULL
|| declarator
->kind
== cdk_id
)
9392 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
9393 if (declarator
->kind
== cdk_function
)
9394 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
9395 if (declarator
->kind
== cdk_array
)
9396 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
9397 returned_attrs
= decl_attributes (&type
,
9398 chainon (returned_attrs
, attrs
),
9402 if (declarator
->kind
== cdk_id
)
9405 inner_declarator
= declarator
->declarator
;
9407 switch (declarator
->kind
)
9410 type
= create_array_type_for_decl (dname
, type
,
9411 declarator
->u
.array
.bounds
);
9412 if (declarator
->std_attributes
)
9415 The optional attribute-specifier-seq appertains to the
9417 returned_attrs
= chainon (returned_attrs
,
9418 declarator
->std_attributes
);
9426 /* Declaring a function type.
9427 Make sure we have a valid type for the function to return. */
9429 if (type_quals
!= TYPE_UNQUALIFIED
)
9431 if (SCALAR_TYPE_P (type
) || VOID_TYPE_P (type
))
9432 warning (OPT_Wignored_qualifiers
,
9433 "type qualifiers ignored on function return type");
9434 /* We now know that the TYPE_QUALS don't apply to the
9435 decl, but to its return type. */
9436 type_quals
= TYPE_UNQUALIFIED
;
9438 errmsg
= targetm
.invalid_return_type (type
);
9442 type
= integer_type_node
;
9445 /* Error about some types functions can't return. */
9447 if (TREE_CODE (type
) == FUNCTION_TYPE
)
9449 error ("%qs declared as function returning a function", name
);
9450 return error_mark_node
;
9452 if (TREE_CODE (type
) == ARRAY_TYPE
)
9454 error ("%qs declared as function returning an array", name
);
9455 return error_mark_node
;
9458 input_location
= declspecs
->locations
[ds_type_spec
];
9459 abstract_virtuals_error (ACU_RETURN
, type
);
9460 input_location
= saved_loc
;
9462 /* Pick up type qualifiers which should be applied to `this'. */
9463 memfn_quals
= declarator
->u
.function
.qualifiers
;
9464 /* Pick up virt-specifiers. */
9465 virt_specifiers
= declarator
->u
.function
.virt_specifiers
;
9466 /* And ref-qualifier, too */
9467 rqual
= declarator
->u
.function
.ref_qualifier
;
9468 /* Pick up the exception specifications. */
9469 raises
= declarator
->u
.function
.exception_specification
;
9470 /* If the exception-specification is ill-formed, let's pretend
9471 there wasn't one. */
9472 if (raises
== error_mark_node
)
9475 /* Say it's a definition only for the CALL_EXPR
9476 closest to the identifier. */
9477 funcdecl_p
= inner_declarator
&& inner_declarator
->kind
== cdk_id
;
9479 /* Handle a late-specified return type. */
9482 if (type_uses_auto (type
))
9484 if (!declarator
->u
.function
.late_return_type
)
9486 if (current_class_type
9487 && LAMBDA_TYPE_P (current_class_type
))
9488 /* OK for C++11 lambdas. */;
9489 else if (cxx_dialect
< cxx1y
)
9490 pedwarn (input_location
, 0, "%qs function uses "
9491 "%<auto%> type specifier without trailing "
9492 "return type", name
);
9494 else if (!is_auto (type
))
9496 error ("%qs function with trailing return type has"
9497 " %qT as its type rather than plain %<auto%>",
9499 return error_mark_node
;
9502 else if (declarator
->u
.function
.late_return_type
)
9504 if (cxx_dialect
< cxx0x
)
9505 /* Not using maybe_warn_cpp0x because this should
9506 always be an error. */
9507 error ("trailing return type only available with "
9508 "-std=c++11 or -std=gnu++11");
9510 error ("%qs function with trailing return type not "
9511 "declared with %<auto%> type specifier", name
);
9512 return error_mark_node
;
9515 type
= splice_late_return_type
9516 (type
, declarator
->u
.function
.late_return_type
);
9517 if (type
== error_mark_node
)
9518 return error_mark_node
;
9520 if (ctype
== NULL_TREE
9521 && decl_context
== FIELD
9523 && (friendp
== 0 || dname
== current_class_name
))
9524 ctype
= current_class_type
;
9526 if (ctype
&& (sfk
== sfk_constructor
9527 || sfk
== sfk_destructor
))
9529 /* We are within a class's scope. If our declarator name
9530 is the same as the class name, and we are defining
9531 a function, then it is a constructor/destructor, and
9532 therefore returns a void type. */
9534 /* ISO C++ 12.4/2. A destructor may not be declared
9535 const or volatile. A destructor may not be static.
9536 A destructor may not be declared with ref-qualifier.
9538 ISO C++ 12.1. A constructor may not be declared
9539 const or volatile. A constructor may not be
9540 virtual. A constructor may not be static.
9541 A constructor may not be declared with ref-qualifier. */
9543 error ((flags
== DTOR_FLAG
)
9544 ? G_("destructor cannot be static member function")
9545 : G_("constructor cannot be static member function"));
9548 error ((flags
== DTOR_FLAG
)
9549 ? G_("destructors may not be cv-qualified")
9550 : G_("constructors may not be cv-qualified"));
9551 memfn_quals
= TYPE_UNQUALIFIED
;
9556 error ((flags
== DTOR_FLAG
)
9557 ? "destructors may not be ref-qualified"
9558 : "constructors may not be ref-qualified");
9559 rqual
= REF_QUAL_NONE
;
9562 if (decl_context
== FIELD
9563 && !member_function_or_else (ctype
,
9566 return error_mark_node
;
9568 if (flags
!= DTOR_FLAG
)
9570 /* It's a constructor. */
9575 permerror (input_location
, "constructors cannot be declared virtual");
9578 if (decl_context
== FIELD
9579 && sfk
!= sfk_constructor
)
9580 return error_mark_node
;
9582 if (decl_context
== FIELD
)
9588 error ("can%'t initialize friend function %qs", name
);
9591 /* Cannot be both friend and virtual. */
9592 error ("virtual functions cannot be friends");
9595 if (decl_context
== NORMAL
)
9596 error ("friend declaration not in class definition");
9597 if (current_function_decl
&& funcdef_flag
)
9598 error ("can%'t define friend function %qs in a local "
9602 else if (ctype
&& sfk
== sfk_conversion
)
9606 maybe_warn_cpp0x (CPP0X_EXPLICIT_CONVERSION
);
9611 arg_types
= grokparms (declarator
->u
.function
.parameters
,
9614 if (inner_declarator
9615 && inner_declarator
->kind
== cdk_id
9616 && inner_declarator
->u
.id
.sfk
== sfk_destructor
9617 && arg_types
!= void_list_node
)
9619 error ("destructors may not have parameters");
9620 arg_types
= void_list_node
;
9624 type
= build_function_type (type
, arg_types
);
9625 if (declarator
->std_attributes
)
9628 The optional attribute-specifier-seq appertains to
9629 the function type. */
9630 decl_attributes (&type
, declarator
->std_attributes
,
9638 /* Filter out pointers-to-references and references-to-references.
9639 We can get these if a TYPE_DECL is used. */
9641 if (TREE_CODE (type
) == REFERENCE_TYPE
)
9643 if (declarator
->kind
!= cdk_reference
)
9645 error ("cannot declare pointer to %q#T", type
);
9646 type
= TREE_TYPE (type
);
9649 /* In C++0x, we allow reference to reference declarations
9650 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
9651 and template type arguments [14.3.1/4 temp.arg.type]. The
9652 check for direct reference to reference declarations, which
9653 are still forbidden, occurs below. Reasoning behind the change
9654 can be found in DR106, DR540, and the rvalue reference
9656 else if (cxx_dialect
== cxx98
)
9658 error ("cannot declare reference to %q#T", type
);
9659 type
= TREE_TYPE (type
);
9662 else if (VOID_TYPE_P (type
))
9664 if (declarator
->kind
== cdk_reference
)
9665 error ("cannot declare reference to %q#T", type
);
9666 else if (declarator
->kind
== cdk_ptrmem
)
9667 error ("cannot declare pointer to %q#T member", type
);
9670 /* We now know that the TYPE_QUALS don't apply to the decl,
9671 but to the target of the pointer. */
9672 type_quals
= TYPE_UNQUALIFIED
;
9674 /* This code used to handle METHOD_TYPE, but I don't think it's
9675 possible to get it here anymore. */
9676 gcc_assert (TREE_CODE (type
) != METHOD_TYPE
);
9677 if (declarator
->kind
== cdk_ptrmem
9678 && TREE_CODE (type
) == FUNCTION_TYPE
)
9680 memfn_quals
|= type_memfn_quals (type
);
9681 type
= build_memfn_type (type
,
9682 declarator
->u
.pointer
.class_type
,
9685 if (type
== error_mark_node
)
9686 return error_mark_node
;
9688 rqual
= REF_QUAL_NONE
;
9689 memfn_quals
= TYPE_UNQUALIFIED
;
9692 if (TREE_CODE (type
) == FUNCTION_TYPE
9693 && (type_memfn_quals (type
) != TYPE_UNQUALIFIED
9694 || type_memfn_rqual (type
) != REF_QUAL_NONE
))
9695 error (declarator
->kind
== cdk_reference
9696 ? G_("cannot declare reference to qualified function type %qT")
9697 : G_("cannot declare pointer to qualified function type %qT"),
9700 /* When the pointed-to type involves components of variable size,
9701 care must be taken to ensure that the size evaluation code is
9702 emitted early enough to dominate all the possible later uses
9703 and late enough for the variables on which it depends to have
9706 This is expected to happen automatically when the pointed-to
9707 type has a name/declaration of it's own, but special attention
9708 is required if the type is anonymous.
9710 We handle the NORMAL and FIELD contexts here by inserting a
9711 dummy statement that just evaluates the size at a safe point
9712 and ensures it is not deferred until e.g. within a deeper
9713 conditional context (c++/43555).
9715 We expect nothing to be needed here for PARM or TYPENAME.
9716 Evaluating the size at this point for TYPENAME would
9717 actually be incorrect, as we might be in the middle of an
9718 expression with side effects on the pointed-to type size
9719 "arguments" prior to the pointer declaration point and the
9720 size evaluation could end up prior to the side effects. */
9722 if (!TYPE_NAME (type
)
9723 && (decl_context
== NORMAL
|| decl_context
== FIELD
)
9724 && at_function_scope_p ()
9725 && variably_modified_type_p (type
, NULL_TREE
))
9727 /* First break out any side-effects. */
9728 stabilize_vla_size (TYPE_SIZE (type
));
9729 /* And then force evaluation of the SAVE_EXPR. */
9730 finish_expr_stmt (TYPE_SIZE (type
));
9733 if (declarator
->kind
== cdk_reference
)
9735 /* In C++0x, the type we are creating a reference to might be
9736 a typedef which is itself a reference type. In that case,
9737 we follow the reference collapsing rules in
9738 [7.1.3/8 dcl.typedef] to create the final reference type:
9740 "If a typedef TD names a type that is a reference to a type
9741 T, an attempt to create the type 'lvalue reference to cv TD'
9742 creates the type 'lvalue reference to T,' while an attempt
9743 to create the type "rvalue reference to cv TD' creates the
9746 if (VOID_TYPE_P (type
))
9747 /* We already gave an error. */;
9748 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
9750 if (declarator
->u
.reference
.rvalue_ref
)
9751 /* Leave type alone. */;
9753 type
= cp_build_reference_type (TREE_TYPE (type
), false);
9756 type
= cp_build_reference_type
9757 (type
, declarator
->u
.reference
.rvalue_ref
);
9759 /* In C++0x, we need this check for direct reference to
9760 reference declarations, which are forbidden by
9761 [8.3.2/5 dcl.ref]. Reference to reference declarations
9762 are only allowed indirectly through typedefs and template
9763 type arguments. Example:
9765 void foo(int & &); // invalid ref-to-ref decl
9767 typedef int & int_ref;
9768 void foo(int_ref &); // valid ref-to-ref decl
9770 if (inner_declarator
&& inner_declarator
->kind
== cdk_reference
)
9771 error ("cannot declare reference to %q#T, which is not "
9772 "a typedef or a template type argument", type
);
9774 else if (TREE_CODE (type
) == METHOD_TYPE
)
9775 type
= build_ptrmemfunc_type (build_pointer_type (type
));
9776 else if (declarator
->kind
== cdk_ptrmem
)
9778 gcc_assert (TREE_CODE (declarator
->u
.pointer
.class_type
)
9780 if (declarator
->u
.pointer
.class_type
== error_mark_node
)
9781 /* We will already have complained. */
9782 type
= error_mark_node
;
9784 type
= build_ptrmem_type (declarator
->u
.pointer
.class_type
,
9788 type
= build_pointer_type (type
);
9790 /* Process a list of type modifier keywords (such as
9791 const or volatile) that were given inside the `*' or `&'. */
9793 if (declarator
->u
.pointer
.qualifiers
)
9796 = cp_build_qualified_type (type
,
9797 declarator
->u
.pointer
.qualifiers
);
9798 type_quals
= cp_type_quals (type
);
9801 /* Apply C++11 attributes to the pointer, and not to the
9802 type pointed to. This is unlike what is done for GNU
9803 attributes above. It is to comply with [dcl.ptr]/1:
9805 [the optional attribute-specifier-seq (7.6.1) appertains
9806 to the pointer and not to the object pointed to]. */
9807 if (declarator
->std_attributes
)
9808 decl_attributes (&type
, declarator
->std_attributes
,
9822 /* We need to stabilize side-effects in VLA sizes for regular array
9823 declarations too, not just pointers to arrays. */
9824 if (type
!= error_mark_node
&& !TYPE_NAME (type
)
9825 && (decl_context
== NORMAL
|| decl_context
== FIELD
)
9826 && at_function_scope_p ()
9827 && variably_modified_type_p (type
, NULL_TREE
))
9828 stabilize_vla_size (TYPE_SIZE (type
));
9830 /* A `constexpr' specifier used in an object declaration declares
9831 the object as `const'. */
9832 if (constexpr_p
&& innermost_code
!= cdk_function
)
9834 if (type_quals
& TYPE_QUAL_VOLATILE
)
9835 error ("both %<volatile%> and %<constexpr%> cannot be used here");
9836 if (TREE_CODE (type
) != REFERENCE_TYPE
)
9838 type_quals
|= TYPE_QUAL_CONST
;
9839 type
= cp_build_qualified_type (type
, type_quals
);
9843 if (unqualified_id
&& TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
9844 && TREE_CODE (type
) != FUNCTION_TYPE
9845 && TREE_CODE (type
) != METHOD_TYPE
)
9847 error ("template-id %qD used as a declarator",
9849 unqualified_id
= dname
;
9852 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
9853 qualified with a class-name, turn it into a METHOD_TYPE, unless
9854 we know that the function is static. We take advantage of this
9855 opportunity to do other processing that pertains to entities
9856 explicitly declared to be class members. Note that if DECLARATOR
9857 is non-NULL, we know it is a cdk_id declarator; otherwise, we
9858 would not have exited the loop above. */
9860 && declarator
->u
.id
.qualifying_scope
9861 && MAYBE_CLASS_TYPE_P (declarator
->u
.id
.qualifying_scope
))
9863 ctype
= declarator
->u
.id
.qualifying_scope
;
9864 ctype
= TYPE_MAIN_VARIANT (ctype
);
9865 template_count
= num_template_headers_for_class (ctype
);
9867 if (ctype
== current_class_type
)
9871 permerror (input_location
, "member functions are implicitly friends of their class");
9875 permerror (declarator
->id_loc
,
9876 "extra qualification %<%T::%> on member %qs",
9879 else if (/* If the qualifying type is already complete, then we
9880 can skip the following checks. */
9881 !COMPLETE_TYPE_P (ctype
)
9882 && (/* If the function is being defined, then
9883 qualifying type must certainly be complete. */
9885 /* A friend declaration of "T::f" is OK, even if
9886 "T" is a template parameter. But, if this
9887 function is not a friend, the qualifying type
9889 || (!friendp
&& !CLASS_TYPE_P (ctype
))
9890 /* For a declaration, the type need not be
9891 complete, if either it is dependent (since there
9892 is no meaningful definition of complete in that
9893 case) or the qualifying class is currently being
9895 || !(dependent_type_p (ctype
)
9896 || currently_open_class (ctype
)))
9897 /* Check that the qualifying type is complete. */
9898 && !complete_type_or_else (ctype
, NULL_TREE
))
9899 return error_mark_node
;
9900 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
9902 if (current_class_type
9903 && (!friendp
|| funcdef_flag
))
9906 ? G_("cannot define member function %<%T::%s%> "
9908 : G_("cannot declare member function %<%T::%s%> "
9910 ctype
, name
, current_class_type
);
9911 return error_mark_node
;
9914 else if (typedef_p
&& current_class_type
)
9916 error ("cannot declare member %<%T::%s%> within %qT",
9917 ctype
, name
, current_class_type
);
9918 return error_mark_node
;
9922 if (ctype
== NULL_TREE
&& decl_context
== FIELD
&& friendp
== 0)
9923 ctype
= current_class_type
;
9925 /* Now TYPE has the actual type. */
9930 *attrlist
= chainon (returned_attrs
, *attrlist
);
9932 attrlist
= &returned_attrs
;
9936 && declarator
->kind
== cdk_id
9937 && declarator
->std_attributes
)
9938 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
9939 a declarator-id appertains to the entity that is declared. */
9940 *attrlist
= chainon (*attrlist
, declarator
->std_attributes
);
9942 /* Handle parameter packs. */
9943 if (parameter_pack_p
)
9945 if (decl_context
== PARM
)
9946 /* Turn the type into a pack expansion.*/
9947 type
= make_pack_expansion (type
);
9949 error ("non-parameter %qs cannot be a parameter pack", name
);
9952 /* Did array size calculations overflow or does the array cover more
9953 than half of the address-space? */
9954 if (TREE_CODE (type
) == ARRAY_TYPE
9955 && COMPLETE_TYPE_P (type
)
9956 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
9957 && ! valid_constant_size_p (TYPE_SIZE_UNIT (type
)))
9959 error ("size of array %qs is too large", name
);
9960 /* If we proceed with the array type as it is, we'll eventually
9961 crash in tree_low_cst(). */
9962 type
= error_mark_node
;
9965 if ((decl_context
== FIELD
|| decl_context
== PARM
)
9966 && !processing_template_decl
9967 && variably_modified_type_p (type
, NULL_TREE
))
9969 if (decl_context
== FIELD
)
9970 error ("data member may not have variably modified type %qT", type
);
9972 error ("parameter may not have variably modified type %qT", type
);
9973 type
= error_mark_node
;
9976 if (explicitp
== 1 || (explicitp
&& friendp
))
9978 /* [dcl.fct.spec] The explicit specifier shall only be used in
9979 declarations of constructors within a class definition. */
9980 error ("only declarations of constructors can be %<explicit%>");
9984 if (storage_class
== sc_mutable
)
9986 if (decl_context
!= FIELD
|| friendp
)
9988 error ("non-member %qs cannot be declared %<mutable%>", name
);
9989 storage_class
= sc_none
;
9991 else if (decl_context
== TYPENAME
|| typedef_p
)
9993 error ("non-object member %qs cannot be declared %<mutable%>", name
);
9994 storage_class
= sc_none
;
9996 else if (TREE_CODE (type
) == FUNCTION_TYPE
9997 || TREE_CODE (type
) == METHOD_TYPE
)
9999 error ("function %qs cannot be declared %<mutable%>", name
);
10000 storage_class
= sc_none
;
10004 error ("static %qs cannot be declared %<mutable%>", name
);
10005 storage_class
= sc_none
;
10007 else if (type_quals
& TYPE_QUAL_CONST
)
10009 error ("const %qs cannot be declared %<mutable%>", name
);
10010 storage_class
= sc_none
;
10012 else if (TREE_CODE (type
) == REFERENCE_TYPE
)
10014 permerror (input_location
, "reference %qs cannot be declared "
10015 "%<mutable%>", name
);
10016 storage_class
= sc_none
;
10020 /* If this is declaring a typedef name, return a TYPE_DECL. */
10021 if (typedef_p
&& decl_context
!= TYPENAME
)
10025 /* Note that the grammar rejects storage classes
10026 in typenames, fields or parameters. */
10027 if (current_lang_name
== lang_name_java
)
10028 TYPE_FOR_JAVA (type
) = 1;
10030 /* This declaration:
10032 typedef void f(int) const;
10034 declares a function type which is not a member of any
10035 particular class, but which is cv-qualified; for
10036 example "f S::*" declares a pointer to a const-qualified
10037 member function of S. We record the cv-qualification in the
10039 if ((rqual
|| memfn_quals
) && TREE_CODE (type
) == FUNCTION_TYPE
)
10041 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
10043 /* We have now dealt with these qualifiers. */
10044 memfn_quals
= TYPE_UNQUALIFIED
;
10045 rqual
= REF_QUAL_NONE
;
10048 if (type_uses_auto (type
))
10050 error ("typedef declared %<auto%>");
10051 type
= error_mark_node
;
10054 if (decl_context
== FIELD
)
10055 decl
= build_lang_decl (TYPE_DECL
, unqualified_id
, type
);
10057 decl
= build_decl (input_location
, TYPE_DECL
, unqualified_id
, type
);
10058 if (id_declarator
&& declarator
->u
.id
.qualifying_scope
) {
10059 error_at (DECL_SOURCE_LOCATION (decl
),
10060 "typedef name may not be a nested-name-specifier");
10061 TREE_TYPE (decl
) = error_mark_node
;
10064 if (decl_context
!= FIELD
)
10066 if (!current_function_decl
)
10067 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
10068 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl
)
10069 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
10070 (current_function_decl
)))
10071 /* The TYPE_DECL is "abstract" because there will be
10072 clones of this constructor/destructor, and there will
10073 be copies of this TYPE_DECL generated in those
10075 DECL_ABSTRACT (decl
) = 1;
10077 else if (current_class_type
10078 && constructor_name_p (unqualified_id
, current_class_type
))
10079 permerror (input_location
, "ISO C++ forbids nested type %qD with same name "
10080 "as enclosing class",
10083 /* If the user declares "typedef struct {...} foo" then the
10084 struct will have an anonymous name. Fill that name in now.
10085 Nothing can refer to it, so nothing needs know about the name
10087 if (type
!= error_mark_node
10089 && TYPE_NAME (type
)
10090 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10091 && TYPE_ANONYMOUS_P (type
)
10092 && declspecs
->type_definition_p
10093 && cp_type_quals (type
) == TYPE_UNQUALIFIED
)
10097 /* Replace the anonymous name with the real name everywhere. */
10098 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
10100 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
10101 /* We do not rename the debug info representing the
10102 anonymous tagged type because the standard says in
10103 [dcl.typedef] that the naming applies only for
10104 linkage purposes. */
10105 /*debug_hooks->set_name (t, decl);*/
10106 TYPE_NAME (t
) = decl
;
10109 if (TYPE_LANG_SPECIFIC (type
))
10110 TYPE_WAS_ANONYMOUS (type
) = 1;
10112 /* If this is a typedef within a template class, the nested
10113 type is a (non-primary) template. The name for the
10114 template needs updating as well. */
10115 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
10116 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
10117 = TYPE_IDENTIFIER (type
);
10119 /* Adjust linkage now that we aren't anonymous anymore. */
10120 reset_type_linkage (type
);
10122 /* FIXME remangle member functions; member functions of a
10123 type with external linkage have external linkage. */
10127 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
10128 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
10130 bad_specifiers (decl
, BSP_TYPE
, virtualp
,
10131 memfn_quals
!= TYPE_UNQUALIFIED
,
10132 inlinep
, friendp
, raises
!= NULL_TREE
);
10134 if (decl_spec_seq_has_spec_p (declspecs
, ds_alias
))
10135 /* Acknowledge that this was written:
10136 `using analias = atype;'. */
10137 TYPE_DECL_ALIAS_P (decl
) = 1;
10142 /* Detect the case of an array type of unspecified size
10143 which came, as such, direct from a typedef name.
10144 We must copy the type, so that the array's domain can be
10145 individually set by the object's initializer. */
10147 if (type
&& typedef_type
10148 && TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
10149 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (typedef_type
))
10150 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
10152 /* Detect where we're using a typedef of function type to declare a
10153 function. PARMS will not be set, so we must create it now. */
10155 if (type
== typedef_type
&& TREE_CODE (type
) == FUNCTION_TYPE
)
10157 tree decls
= NULL_TREE
;
10160 for (args
= TYPE_ARG_TYPES (type
);
10161 args
&& args
!= void_list_node
;
10162 args
= TREE_CHAIN (args
))
10164 tree decl
= cp_build_parm_decl (NULL_TREE
, TREE_VALUE (args
));
10166 DECL_CHAIN (decl
) = decls
;
10170 parms
= nreverse (decls
);
10172 if (decl_context
!= TYPENAME
)
10174 /* A cv-qualifier-seq shall only be part of the function type
10175 for a non-static member function. A ref-qualifier shall only
10176 .... /same as above/ [dcl.fct] */
10177 if ((type_memfn_quals (type
) != TYPE_UNQUALIFIED
10178 || type_memfn_rqual (type
) != REF_QUAL_NONE
)
10179 && (current_class_type
== NULL_TREE
|| staticp
) )
10182 ? G_("qualified function types cannot be used to "
10183 "declare static member functions")
10184 : G_("qualified function types cannot be used to "
10185 "declare free functions"));
10186 type
= TYPE_MAIN_VARIANT (type
);
10189 /* The qualifiers on the function type become the qualifiers on
10190 the non-static member function. */
10191 memfn_quals
|= type_memfn_quals (type
);
10192 rqual
= type_memfn_rqual (type
);
10193 type_quals
= TYPE_UNQUALIFIED
;
10197 /* If this is a type name (such as, in a cast or sizeof),
10198 compute the type and return it now. */
10200 if (decl_context
== TYPENAME
)
10202 /* Note that the grammar rejects storage classes
10203 in typenames, fields or parameters. */
10204 if (type_quals
!= TYPE_UNQUALIFIED
)
10205 type_quals
= TYPE_UNQUALIFIED
;
10207 /* Special case: "friend class foo" looks like a TYPENAME context. */
10210 if (type_quals
!= TYPE_UNQUALIFIED
)
10212 error ("type qualifiers specified for friend class declaration");
10213 type_quals
= TYPE_UNQUALIFIED
;
10217 error ("%<inline%> specified for friend class declaration");
10223 /* Don't allow friend declaration without a class-key. */
10224 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
10225 permerror (input_location
, "template parameters cannot be friends");
10226 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
10227 permerror (input_location
, "friend declaration requires class-key, "
10228 "i.e. %<friend class %T::%D%>",
10229 TYPE_CONTEXT (type
), TYPENAME_TYPE_FULLNAME (type
));
10231 permerror (input_location
, "friend declaration requires class-key, "
10232 "i.e. %<friend %#T%>",
10236 /* Only try to do this stuff if we didn't already give up. */
10237 if (type
!= integer_type_node
)
10239 /* A friendly class? */
10240 if (current_class_type
)
10241 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
),
10242 /*complain=*/true);
10244 error ("trying to make class %qT a friend of global scope",
10247 type
= void_type_node
;
10250 else if (memfn_quals
)
10252 if (ctype
== NULL_TREE
10253 && TREE_CODE (type
) == METHOD_TYPE
)
10254 ctype
= TYPE_METHOD_BASETYPE (type
);
10257 type
= build_memfn_type (type
, ctype
, memfn_quals
, rqual
);
10258 /* Core issue #547: need to allow this in template type args. */
10259 else if (template_type_arg
&& TREE_CODE (type
) == FUNCTION_TYPE
)
10260 type
= apply_memfn_quals (type
, memfn_quals
, rqual
);
10262 error ("invalid qualifiers on non-member function type");
10267 else if (unqualified_id
== NULL_TREE
&& decl_context
!= PARM
10268 && decl_context
!= CATCHPARM
10269 && TREE_CODE (type
) != UNION_TYPE
10272 error ("abstract declarator %qT used as declaration", type
);
10273 return error_mark_node
;
10276 /* Only functions may be declared using an operator-function-id. */
10278 && IDENTIFIER_OPNAME_P (unqualified_id
)
10279 && TREE_CODE (type
) != FUNCTION_TYPE
10280 && TREE_CODE (type
) != METHOD_TYPE
)
10282 error ("declaration of %qD as non-function", unqualified_id
);
10283 return error_mark_node
;
10286 /* We don't check parameter types here because we can emit a better
10287 error message later. */
10288 if (decl_context
!= PARM
)
10290 type
= check_var_type (unqualified_id
, type
);
10291 if (type
== error_mark_node
)
10292 return error_mark_node
;
10295 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
10296 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
10298 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
10300 if (ctype
|| in_namespace
)
10301 error ("cannot use %<::%> in parameter declaration");
10303 if (type_uses_auto (type
))
10305 error ("parameter declared %<auto%>");
10306 type
= error_mark_node
;
10309 /* A parameter declared as an array of T is really a pointer to T.
10310 One declared as a function is really a pointer to a function.
10311 One declared as a member is really a pointer to member. */
10313 if (TREE_CODE (type
) == ARRAY_TYPE
)
10315 /* Transfer const-ness of array into that of type pointed to. */
10316 type
= build_pointer_type (TREE_TYPE (type
));
10317 type_quals
= TYPE_UNQUALIFIED
;
10319 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
10320 type
= build_pointer_type (type
);
10323 if (ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2
10324 && !NEW_DELETE_OPNAME_P (unqualified_id
))
10326 cp_cv_quals real_quals
= memfn_quals
;
10327 if (constexpr_p
&& sfk
!= sfk_constructor
&& sfk
!= sfk_destructor
)
10328 real_quals
|= TYPE_QUAL_CONST
;
10329 type
= build_memfn_type (type
, ctype
, real_quals
, rqual
);
10335 if (decl_context
== PARM
)
10337 decl
= cp_build_parm_decl (unqualified_id
, type
);
10339 bad_specifiers (decl
, BSP_PARM
, virtualp
,
10340 memfn_quals
!= TYPE_UNQUALIFIED
,
10341 inlinep
, friendp
, raises
!= NULL_TREE
);
10343 else if (decl_context
== FIELD
)
10345 if (!staticp
&& TREE_CODE (type
) != METHOD_TYPE
10346 && type_uses_auto (type
))
10348 error ("non-static data member declared %<auto%>");
10349 type
= error_mark_node
;
10352 /* The C99 flexible array extension. */
10353 if (!staticp
&& TREE_CODE (type
) == ARRAY_TYPE
10354 && TYPE_DOMAIN (type
) == NULL_TREE
)
10356 tree itype
= compute_array_index_type (dname
, integer_zero_node
,
10357 tf_warning_or_error
);
10358 type
= build_cplus_array_type (TREE_TYPE (type
), itype
);
10361 if (type
== error_mark_node
)
10363 /* Happens when declaring arrays of sizes which
10364 are error_mark_node, for example. */
10367 else if (in_namespace
&& !friendp
)
10369 /* Something like struct S { int N::j; }; */
10370 error ("invalid use of %<::%>");
10371 return error_mark_node
;
10373 else if (TREE_CODE (type
) == FUNCTION_TYPE
10374 || TREE_CODE (type
) == METHOD_TYPE
)
10377 tree function_context
;
10381 /* This should never happen in pure C++ (the check
10382 could be an assert). It could happen in
10383 Objective-C++ if someone writes invalid code that
10384 uses a function declaration for an instance
10385 variable or property (instance variables and
10386 properties are parsed as FIELD_DECLs, but they are
10387 part of an Objective-C class, not a C++ class).
10388 That code is invalid and is caught by this
10392 error ("declaration of function %qD in invalid context",
10394 return error_mark_node
;
10397 /* ``A union may [ ... ] not [ have ] virtual functions.''
10399 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
10401 error ("function %qD declared virtual inside a union",
10403 return error_mark_node
;
10406 if (NEW_DELETE_OPNAME_P (unqualified_id
))
10410 error ("%qD cannot be declared virtual, since it "
10411 "is always static",
10418 /* Check that the name used for a destructor makes sense. */
10419 if (sfk
== sfk_destructor
)
10421 tree uqname
= id_declarator
->u
.id
.unqualified_name
;
10425 gcc_assert (friendp
);
10426 error ("expected qualified name in friend declaration "
10427 "for destructor %qD", uqname
);
10428 return error_mark_node
;
10431 if (!check_dtor_name (ctype
, TREE_OPERAND (uqname
, 0)))
10433 error ("declaration of %qD as member of %qT",
10435 return error_mark_node
;
10439 error ("a destructor cannot be %<constexpr%>");
10440 return error_mark_node
;
10443 else if (sfk
== sfk_constructor
&& friendp
&& !ctype
)
10445 error ("expected qualified name in friend declaration "
10446 "for constructor %qD",
10447 id_declarator
->u
.id
.unqualified_name
);
10448 return error_mark_node
;
10451 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
10452 function_context
= (ctype
!= NULL_TREE
) ?
10453 decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
10454 publicp
= (! friendp
|| ! staticp
)
10455 && function_context
== NULL_TREE
;
10456 decl
= grokfndecl (ctype
, type
,
10457 TREE_CODE (unqualified_id
) != TEMPLATE_ID_EXPR
10458 ? unqualified_id
: dname
,
10461 virtualp
, flags
, memfn_quals
, rqual
, raises
,
10462 friendp
? -1 : 0, friendp
, publicp
,
10463 inlinep
| (2 * constexpr_p
),
10465 funcdef_flag
, template_count
, in_namespace
,
10466 attrlist
, declarator
->id_loc
);
10467 decl
= set_virt_specifiers (decl
, virt_specifiers
);
10468 if (decl
== NULL_TREE
)
10469 return error_mark_node
;
10471 /* This clobbers the attrs stored in `decl' from `attrlist'. */
10472 /* The decl and setting of decl_attr is also turned off. */
10473 decl
= build_decl_attribute_variant (decl
, decl_attr
);
10476 /* [class.conv.ctor]
10478 A constructor declared without the function-specifier
10479 explicit that can be called with a single parameter
10480 specifies a conversion from the type of its first
10481 parameter to the type of its class. Such a constructor
10482 is called a converting constructor. */
10483 if (explicitp
== 2)
10484 DECL_NONCONVERTING_P (decl
) = 1;
10486 else if (!staticp
&& !dependent_type_p (type
)
10487 && !COMPLETE_TYPE_P (complete_type (type
))
10488 && (TREE_CODE (type
) != ARRAY_TYPE
|| initialized
== 0))
10490 if (unqualified_id
)
10491 error ("field %qD has incomplete type", unqualified_id
);
10493 error ("name %qT has incomplete type", type
);
10495 /* If we're instantiating a template, tell them which
10496 instantiation made the field's type be incomplete. */
10497 if (current_class_type
10498 && TYPE_NAME (current_class_type
)
10499 && IDENTIFIER_TEMPLATE (current_class_name
)
10501 && declspecs
->type
== type
)
10502 error (" in instantiation of template %qT",
10503 current_class_type
);
10505 return error_mark_node
;
10511 error ("%qE is neither function nor member function; "
10512 "cannot be declared friend", unqualified_id
);
10520 /* Friends are treated specially. */
10521 if (ctype
== current_class_type
)
10522 ; /* We already issued a permerror. */
10523 else if (decl
&& DECL_NAME (decl
))
10525 if (template_class_depth (current_class_type
) == 0)
10527 decl
= check_explicit_specialization
10528 (unqualified_id
, decl
, template_count
,
10529 2 * funcdef_flag
+ 4);
10530 if (decl
== error_mark_node
)
10531 return error_mark_node
;
10534 decl
= do_friend (ctype
, unqualified_id
, decl
,
10540 return error_mark_node
;
10543 /* Structure field. It may not be a function, except for C++. */
10545 if (decl
== NULL_TREE
)
10549 /* C++ allows static class members. All other work
10550 for this is done by grokfield. */
10551 decl
= build_lang_decl_loc (declarator
->id_loc
,
10552 VAR_DECL
, unqualified_id
, type
);
10553 set_linkage_for_static_data_member (decl
);
10554 /* Even if there is an in-class initialization, DECL
10555 is considered undefined until an out-of-class
10556 definition is provided. */
10557 DECL_EXTERNAL (decl
) = 1;
10561 DECL_TLS_MODEL (decl
) = decl_default_tls_model (decl
);
10562 if (declspecs
->gnu_thread_keyword_p
)
10563 DECL_GNU_TLS_P (decl
) = true;
10566 if (constexpr_p
&& !initialized
)
10568 error ("constexpr static data member %qD must have an "
10569 "initializer", decl
);
10570 constexpr_p
= false;
10577 error ("non-static data member %qE declared %<constexpr%>",
10579 constexpr_p
= false;
10581 decl
= build_decl (input_location
,
10582 FIELD_DECL
, unqualified_id
, type
);
10583 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
10584 if (bitfield
&& !unqualified_id
)
10585 TREE_NO_WARNING (decl
) = 1;
10587 if (storage_class
== sc_mutable
)
10589 DECL_MUTABLE_P (decl
) = 1;
10590 storage_class
= sc_none
;
10595 /* An attempt is being made to initialize a non-static
10596 member. This is new in C++11. */
10597 maybe_warn_cpp0x (CPP0X_NSDMI
);
10599 /* If this has been parsed with static storage class, but
10600 errors forced staticp to be cleared, ensure NSDMI is
10602 if (declspecs
->storage_class
== sc_static
)
10603 DECL_INITIAL (decl
) = error_mark_node
;
10607 bad_specifiers (decl
, BSP_FIELD
, virtualp
,
10608 memfn_quals
!= TYPE_UNQUALIFIED
,
10609 inlinep
, friendp
, raises
!= NULL_TREE
);
10612 else if (TREE_CODE (type
) == FUNCTION_TYPE
10613 || TREE_CODE (type
) == METHOD_TYPE
)
10615 tree original_name
;
10618 if (!unqualified_id
)
10619 return error_mark_node
;
10621 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
10622 original_name
= dname
;
10624 original_name
= unqualified_id
;
10626 if (storage_class
== sc_auto
)
10627 error ("storage class %<auto%> invalid for function %qs", name
);
10628 else if (storage_class
== sc_register
)
10629 error ("storage class %<register%> invalid for function %qs", name
);
10632 if (declspecs
->gnu_thread_keyword_p
)
10633 error ("storage class %<__thread%> invalid for function %qs",
10636 error ("storage class %<thread_local%> invalid for function %qs",
10640 if (virt_specifiers
)
10641 error ("virt-specifiers in %qs not allowed outside a class definition", name
);
10642 /* Function declaration not at top level.
10643 Storage classes other than `extern' are not allowed
10644 and `extern' makes no difference. */
10645 if (! toplevel_bindings_p ()
10646 && (storage_class
== sc_static
10647 || decl_spec_seq_has_spec_p (declspecs
, ds_inline
))
10650 if (storage_class
== sc_static
)
10651 pedwarn (input_location
, OPT_Wpedantic
,
10652 "%<static%> specified invalid for function %qs "
10653 "declared out of global scope", name
);
10655 pedwarn (input_location
, OPT_Wpedantic
,
10656 "%<inline%> specifier invalid for function %qs "
10657 "declared out of global scope", name
);
10660 if (ctype
== NULL_TREE
)
10664 error ("virtual non-class function %qs", name
);
10667 else if (sfk
== sfk_constructor
10668 || sfk
== sfk_destructor
)
10670 error (funcdef_flag
10671 ? G_("%qs defined in a non-class scope")
10672 : G_("%qs declared in a non-class scope"), name
);
10677 /* Record whether the function is public. */
10678 publicp
= (ctype
!= NULL_TREE
10679 || storage_class
!= sc_static
);
10681 decl
= grokfndecl (ctype
, type
, original_name
, parms
, unqualified_id
,
10682 virtualp
, flags
, memfn_quals
, rqual
, raises
,
10684 publicp
, inlinep
| (2 * constexpr_p
), sfk
,
10686 template_count
, in_namespace
, attrlist
,
10687 declarator
->id_loc
);
10688 if (decl
== NULL_TREE
)
10689 return error_mark_node
;
10693 int invalid_static
= 0;
10695 /* Don't allow a static member function in a class, and forbid
10696 declaring main to be static. */
10697 if (TREE_CODE (type
) == METHOD_TYPE
)
10699 permerror (input_location
, "cannot declare member function %qD to have "
10700 "static linkage", decl
);
10701 invalid_static
= 1;
10703 else if (current_function_decl
)
10705 /* FIXME need arm citation */
10706 error ("cannot declare static function inside another function");
10707 invalid_static
= 1;
10710 if (invalid_static
)
10713 storage_class
= sc_none
;
10719 /* It's a variable. */
10721 /* An uninitialized decl with `extern' is a reference. */
10722 decl
= grokvardecl (type
, unqualified_id
,
10725 (type_quals
& TYPE_QUAL_CONST
) != 0,
10726 ctype
? ctype
: in_namespace
);
10727 bad_specifiers (decl
, BSP_VAR
, virtualp
,
10728 memfn_quals
!= TYPE_UNQUALIFIED
,
10729 inlinep
, friendp
, raises
!= NULL_TREE
);
10733 DECL_CONTEXT (decl
) = ctype
;
10736 permerror (input_location
, "%<static%> may not be used when defining "
10737 "(as opposed to declaring) a static data member");
10739 storage_class
= sc_none
;
10741 if (storage_class
== sc_register
&& TREE_STATIC (decl
))
10743 error ("static member %qD declared %<register%>", decl
);
10744 storage_class
= sc_none
;
10746 if (storage_class
== sc_extern
&& pedantic
)
10748 pedwarn (input_location
, OPT_Wpedantic
,
10749 "cannot explicitly declare member %q#D to have "
10750 "extern linkage", decl
);
10751 storage_class
= sc_none
;
10754 else if (constexpr_p
&& DECL_EXTERNAL (decl
))
10756 error ("declaration of constexpr variable %qD is not a definition",
10758 constexpr_p
= false;
10762 if (storage_class
== sc_extern
&& initialized
&& !funcdef_flag
)
10764 if (toplevel_bindings_p ())
10766 /* It's common practice (and completely valid) to have a const
10767 be initialized and declared extern. */
10768 if (!(type_quals
& TYPE_QUAL_CONST
))
10769 warning (0, "%qs initialized and declared %<extern%>", name
);
10773 error ("%qs has both %<extern%> and initializer", name
);
10774 return error_mark_node
;
10778 /* Record `register' declaration for warnings on &
10779 and in case doing stupid register allocation. */
10781 if (storage_class
== sc_register
)
10782 DECL_REGISTER (decl
) = 1;
10783 else if (storage_class
== sc_extern
)
10784 DECL_THIS_EXTERN (decl
) = 1;
10785 else if (storage_class
== sc_static
)
10786 DECL_THIS_STATIC (decl
) = 1;
10788 /* Set constexpr flag on vars (functions got it in grokfndecl). */
10789 if (constexpr_p
&& VAR_P (decl
))
10790 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
10792 /* Record constancy and volatility on the DECL itself . There's
10793 no need to do this when processing a template; we'll do this
10794 for the instantiated declaration based on the type of DECL. */
10795 if (!processing_template_decl
)
10796 cp_apply_type_quals_to_decl (type_quals
, decl
);
10802 /* Subroutine of start_function. Ensure that each of the parameter
10803 types (as listed in PARMS) is complete, as is required for a
10804 function definition. */
10807 require_complete_types_for_parms (tree parms
)
10809 for (; parms
; parms
= DECL_CHAIN (parms
))
10811 if (dependent_type_p (TREE_TYPE (parms
)))
10813 if (!VOID_TYPE_P (TREE_TYPE (parms
))
10814 && complete_type_or_else (TREE_TYPE (parms
), parms
))
10816 relayout_decl (parms
);
10817 DECL_ARG_TYPE (parms
) = type_passed_as (TREE_TYPE (parms
));
10820 /* grokparms or complete_type_or_else will have already issued
10822 TREE_TYPE (parms
) = error_mark_node
;
10826 /* Returns nonzero if T is a local variable. */
10829 local_variable_p (const_tree t
)
10832 /* A VAR_DECL with a context that is a _TYPE is a static data
10834 && !TYPE_P (CP_DECL_CONTEXT (t
))
10835 /* Any other non-local variable must be at namespace scope. */
10836 && !DECL_NAMESPACE_SCOPE_P (t
))
10837 || (TREE_CODE (t
) == PARM_DECL
))
10843 /* Like local_variable_p, but suitable for use as a tree-walking
10847 local_variable_p_walkfn (tree
*tp
, int *walk_subtrees
,
10850 if (local_variable_p (*tp
)
10851 && (!DECL_ARTIFICIAL (*tp
) || DECL_NAME (*tp
) == this_identifier
))
10853 else if (TYPE_P (*tp
))
10854 *walk_subtrees
= 0;
10859 /* Check that ARG, which is a default-argument expression for a
10860 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
10861 something goes wrong. DECL may also be a _TYPE node, rather than a
10862 DECL, if there is no DECL available. */
10865 check_default_argument (tree decl
, tree arg
)
10870 if (TREE_CODE (arg
) == DEFAULT_ARG
)
10871 /* We get a DEFAULT_ARG when looking at an in-class declaration
10872 with a default argument. Ignore the argument for now; we'll
10873 deal with it after the class is complete. */
10882 decl_type
= TREE_TYPE (decl
);
10884 if (arg
== error_mark_node
10885 || decl
== error_mark_node
10886 || TREE_TYPE (arg
) == error_mark_node
10887 || decl_type
== error_mark_node
)
10888 /* Something already went wrong. There's no need to check
10890 return error_mark_node
;
10892 /* [dcl.fct.default]
10894 A default argument expression is implicitly converted to the
10896 ++cp_unevaluated_operand
;
10897 perform_implicit_conversion_flags (decl_type
, arg
, tf_warning_or_error
,
10899 --cp_unevaluated_operand
;
10901 if (warn_zero_as_null_pointer_constant
10902 && TYPE_PTR_OR_PTRMEM_P (decl_type
)
10903 && null_ptr_cst_p (arg
)
10904 && maybe_warn_zero_as_null_pointer_constant (arg
, input_location
))
10905 return nullptr_node
;
10907 /* [dcl.fct.default]
10909 Local variables shall not be used in default argument
10912 The keyword `this' shall not be used in a default argument of a
10913 member function. */
10914 var
= cp_walk_tree_without_duplicates (&arg
, local_variable_p_walkfn
, NULL
);
10917 if (DECL_NAME (var
) == this_identifier
)
10918 permerror (input_location
, "default argument %qE uses %qD", arg
, var
);
10920 error ("default argument %qE uses local variable %qD", arg
, var
);
10921 return error_mark_node
;
10928 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
10931 type_is_deprecated (tree type
)
10933 enum tree_code code
;
10934 if (TREE_DEPRECATED (type
))
10936 if (TYPE_NAME (type
)
10937 && TREE_DEPRECATED (TYPE_NAME (type
)))
10940 /* Do warn about using typedefs to a deprecated class. */
10941 if (TAGGED_TYPE_P (type
) && type
!= TYPE_MAIN_VARIANT (type
))
10942 return type_is_deprecated (TYPE_MAIN_VARIANT (type
));
10944 code
= TREE_CODE (type
);
10946 if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
10947 || code
== OFFSET_TYPE
|| code
== FUNCTION_TYPE
10948 || code
== METHOD_TYPE
|| code
== ARRAY_TYPE
)
10949 return type_is_deprecated (TREE_TYPE (type
));
10951 if (TYPE_PTRMEMFUNC_P (type
))
10952 return type_is_deprecated
10953 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type
))));
10958 /* Decode the list of parameter types for a function type.
10959 Given the list of things declared inside the parens,
10960 return a list of types.
10962 If this parameter does not end with an ellipsis, we append
10965 *PARMS is set to the chain of PARM_DECLs created. */
10968 grokparms (tree parmlist
, tree
*parms
)
10970 tree result
= NULL_TREE
;
10971 tree decls
= NULL_TREE
;
10975 for (parm
= parmlist
; parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
10977 tree type
= NULL_TREE
;
10978 tree init
= TREE_PURPOSE (parm
);
10979 tree decl
= TREE_VALUE (parm
);
10980 const char *errmsg
;
10982 if (parm
== void_list_node
)
10985 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
10988 type
= TREE_TYPE (decl
);
10989 if (VOID_TYPE_P (type
))
10991 if (same_type_p (type
, void_type_node
)
10992 && DECL_SELF_REFERENCE_P (type
)
10993 && !DECL_NAME (decl
) && !result
&& TREE_CHAIN (parm
) == void_list_node
)
10994 /* this is a parmlist of `(void)', which is ok. */
10996 cxx_incomplete_type_error (decl
, type
);
10997 /* It's not a good idea to actually create parameters of
10998 type `void'; other parts of the compiler assume that a
10999 void type terminates the parameter list. */
11000 type
= error_mark_node
;
11001 TREE_TYPE (decl
) = error_mark_node
;
11004 if (type
!= error_mark_node
11005 && TYPE_FOR_JAVA (type
)
11006 && MAYBE_CLASS_TYPE_P (type
))
11008 error ("parameter %qD has Java class type", decl
);
11009 type
= error_mark_node
;
11010 TREE_TYPE (decl
) = error_mark_node
;
11014 if (type
!= error_mark_node
11015 && (errmsg
= targetm
.invalid_parameter_type (type
)))
11018 type
= error_mark_node
;
11019 TREE_TYPE (decl
) = error_mark_node
;
11022 if (type
!= error_mark_node
)
11024 if (deprecated_state
!= DEPRECATED_SUPPRESS
)
11026 tree deptype
= type_is_deprecated (type
);
11028 warn_deprecated_use (deptype
, NULL_TREE
);
11031 /* Top-level qualifiers on the parameters are
11032 ignored for function types. */
11033 type
= cp_build_qualified_type (type
, 0);
11034 if (TREE_CODE (type
) == METHOD_TYPE
)
11036 error ("parameter %qD invalidly declared method type", decl
);
11037 type
= build_pointer_type (type
);
11038 TREE_TYPE (decl
) = type
;
11040 else if (abstract_virtuals_error (decl
, type
))
11041 any_error
= 1; /* Seems like a good idea. */
11042 else if (POINTER_TYPE_P (type
))
11044 /* [dcl.fct]/6, parameter types cannot contain pointers
11045 (references) to arrays of unknown bound. */
11046 tree t
= TREE_TYPE (type
);
11047 int ptr
= TYPE_PTR_P (type
);
11051 if (TYPE_PTR_P (t
))
11053 else if (TREE_CODE (t
) != ARRAY_TYPE
)
11055 else if (!TYPE_DOMAIN (t
))
11059 if (TREE_CODE (t
) == ARRAY_TYPE
)
11061 ? G_("parameter %qD includes pointer to array of "
11062 "unknown bound %qT")
11063 : G_("parameter %qD includes reference to array of "
11064 "unknown bound %qT"),
11070 else if (init
&& !processing_template_decl
)
11071 init
= check_default_argument (decl
, init
);
11074 DECL_CHAIN (decl
) = decls
;
11076 result
= tree_cons (init
, type
, result
);
11078 decls
= nreverse (decls
);
11079 result
= nreverse (result
);
11081 result
= chainon (result
, void_list_node
);
11088 /* D is a constructor or overloaded `operator='.
11090 Let T be the class in which D is declared. Then, this function
11093 -1 if D's is an ill-formed constructor or copy assignment operator
11094 whose first parameter is of type `T'.
11095 0 if D is not a copy constructor or copy assignment
11097 1 if D is a copy constructor or copy assignment operator whose
11098 first parameter is a reference to non-const qualified T.
11099 2 if D is a copy constructor or copy assignment operator whose
11100 first parameter is a reference to const qualified T.
11102 This function can be used as a predicate. Positive values indicate
11103 a copy constructor and nonzero values indicate a copy assignment
11107 copy_fn_p (const_tree d
)
11113 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
11115 if (TREE_CODE (d
) == TEMPLATE_DECL
11116 || (DECL_TEMPLATE_INFO (d
)
11117 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
11118 /* Instantiations of template member functions are never copy
11119 functions. Note that member functions of templated classes are
11120 represented as template functions internally, and we must
11121 accept those as copy functions. */
11124 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
11128 arg_type
= TREE_VALUE (args
);
11129 if (arg_type
== error_mark_node
)
11132 if (TYPE_MAIN_VARIANT (arg_type
) == DECL_CONTEXT (d
))
11134 /* Pass by value copy assignment operator. */
11137 else if (TREE_CODE (arg_type
) == REFERENCE_TYPE
11138 && !TYPE_REF_IS_RVALUE (arg_type
)
11139 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)) == DECL_CONTEXT (d
))
11141 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type
)))
11147 args
= TREE_CHAIN (args
);
11149 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
11150 /* There are more non-optional args. */
11156 /* D is a constructor or overloaded `operator='.
11158 Let T be the class in which D is declared. Then, this function
11159 returns true when D is a move constructor or move assignment
11160 operator, false otherwise. */
11163 move_fn_p (const_tree d
)
11165 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
11167 if (cxx_dialect
== cxx98
)
11168 /* There are no move constructors if we are in C++98 mode. */
11171 if (TREE_CODE (d
) == TEMPLATE_DECL
11172 || (DECL_TEMPLATE_INFO (d
)
11173 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
11174 /* Instantiations of template member functions are never move
11175 functions. Note that member functions of templated classes are
11176 represented as template functions internally, and we must
11177 accept those as move functions. */
11180 return move_signature_fn_p (d
);
11183 /* D is a constructor or overloaded `operator='.
11185 Then, this function returns true when D has the same signature as a move
11186 constructor or move assignment operator (because either it is such a
11187 ctor/op= or it is a template specialization with the same signature),
11188 false otherwise. */
11191 move_signature_fn_p (const_tree d
)
11195 bool result
= false;
11197 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
11201 arg_type
= TREE_VALUE (args
);
11202 if (arg_type
== error_mark_node
)
11205 if (TREE_CODE (arg_type
) == REFERENCE_TYPE
11206 && TYPE_REF_IS_RVALUE (arg_type
)
11207 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)),
11211 args
= TREE_CHAIN (args
);
11213 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
11214 /* There are more non-optional args. */
11220 /* Remember any special properties of member function DECL. */
11223 grok_special_member_properties (tree decl
)
11227 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
11230 class_type
= DECL_CONTEXT (decl
);
11231 if (DECL_CONSTRUCTOR_P (decl
))
11233 int ctor
= copy_fn_p (decl
);
11235 if (!DECL_ARTIFICIAL (decl
))
11236 TYPE_HAS_USER_CONSTRUCTOR (class_type
) = 1;
11242 A non-template constructor for class X is a copy
11243 constructor if its first parameter is of type X&, const
11244 X&, volatile X& or const volatile X&, and either there
11245 are no other parameters or else all other parameters have
11246 default arguments. */
11247 TYPE_HAS_COPY_CTOR (class_type
) = 1;
11248 if (user_provided_p (decl
))
11249 TYPE_HAS_COMPLEX_COPY_CTOR (class_type
) = 1;
11251 TYPE_HAS_CONST_COPY_CTOR (class_type
) = 1;
11253 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl
)))
11255 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type
) = 1;
11256 if (user_provided_p (decl
))
11257 TYPE_HAS_COMPLEX_DFLT (class_type
) = 1;
11259 else if (move_fn_p (decl
) && user_provided_p (decl
))
11260 TYPE_HAS_COMPLEX_MOVE_CTOR (class_type
) = 1;
11261 else if (is_list_ctor (decl
))
11262 TYPE_HAS_LIST_CTOR (class_type
) = 1;
11264 if (DECL_DECLARED_CONSTEXPR_P (decl
)
11265 && !copy_fn_p (decl
) && !move_fn_p (decl
))
11266 TYPE_HAS_CONSTEXPR_CTOR (class_type
) = 1;
11268 else if (DECL_OVERLOADED_OPERATOR_P (decl
) == NOP_EXPR
)
11272 A non-template assignment operator for class X is a copy
11273 assignment operator if its parameter is of type X, X&, const
11274 X&, volatile X& or const volatile X&. */
11276 int assop
= copy_fn_p (decl
);
11280 TYPE_HAS_COPY_ASSIGN (class_type
) = 1;
11281 if (user_provided_p (decl
))
11282 TYPE_HAS_COMPLEX_COPY_ASSIGN (class_type
) = 1;
11284 TYPE_HAS_CONST_COPY_ASSIGN (class_type
) = 1;
11286 else if (move_fn_p (decl
) && user_provided_p (decl
))
11287 TYPE_HAS_COMPLEX_MOVE_ASSIGN (class_type
) = 1;
11289 /* Destructors are handled in check_methods. */
11292 /* Check a constructor DECL has the correct form. Complains
11293 if the class has a constructor of the form X(X). */
11296 grok_ctor_properties (const_tree ctype
, const_tree decl
)
11298 int ctor_parm
= copy_fn_p (decl
);
11304 A declaration of a constructor for a class X is ill-formed if
11305 its first parameter is of type (optionally cv-qualified) X
11306 and either there are no other parameters or else all other
11307 parameters have default arguments.
11309 We *don't* complain about member template instantiations that
11310 have this form, though; they can occur as we try to decide
11311 what constructor to use during overload resolution. Since
11312 overload resolution will never prefer such a constructor to
11313 the non-template copy constructor (which is either explicitly
11314 or implicitly defined), there's no need to worry about their
11315 existence. Theoretically, they should never even be
11316 instantiated, but that's hard to forestall. */
11317 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
11325 /* An operator with this code is unary, but can also be binary. */
11328 ambi_op_p (enum tree_code code
)
11330 return (code
== INDIRECT_REF
11331 || code
== ADDR_EXPR
11332 || code
== UNARY_PLUS_EXPR
11333 || code
== NEGATE_EXPR
11334 || code
== PREINCREMENT_EXPR
11335 || code
== PREDECREMENT_EXPR
);
11338 /* An operator with this name can only be unary. */
11341 unary_op_p (enum tree_code code
)
11343 return (code
== TRUTH_NOT_EXPR
11344 || code
== BIT_NOT_EXPR
11345 || code
== COMPONENT_REF
11346 || code
== TYPE_EXPR
);
11349 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
11350 errors are issued for invalid declarations. */
11353 grok_op_properties (tree decl
, bool complain
)
11355 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
11357 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
11358 tree name
= DECL_NAME (decl
);
11359 enum tree_code operator_code
;
11364 /* Count the number of arguments and check for ellipsis. */
11365 for (argtype
= argtypes
, arity
= 0;
11366 argtype
&& argtype
!= void_list_node
;
11367 argtype
= TREE_CHAIN (argtype
))
11369 ellipsis_p
= !argtype
;
11371 class_type
= DECL_CONTEXT (decl
);
11372 if (class_type
&& !CLASS_TYPE_P (class_type
))
11373 class_type
= NULL_TREE
;
11375 if (DECL_CONV_FN_P (decl
))
11376 operator_code
= TYPE_EXPR
;
11380 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
11381 if (ansi_opname (CODE) == name) \
11383 operator_code = (CODE); \
11386 else if (ansi_assopname (CODE) == name) \
11388 operator_code = (CODE); \
11389 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
11393 #include "operators.def"
11394 #undef DEF_OPERATOR
11396 gcc_unreachable ();
11399 gcc_assert (operator_code
!= MAX_TREE_CODES
);
11400 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
11403 switch (operator_code
)
11406 TYPE_HAS_NEW_OPERATOR (class_type
) = 1;
11410 TYPE_GETS_DELETE (class_type
) |= 1;
11414 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type
) = 1;
11417 case VEC_DELETE_EXPR
:
11418 TYPE_GETS_DELETE (class_type
) |= 2;
11425 /* [basic.std.dynamic.allocation]/1:
11427 A program is ill-formed if an allocation function is declared
11428 in a namespace scope other than global scope or declared static
11431 The same also holds true for deallocation functions. */
11432 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
11433 || operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
11435 if (DECL_NAMESPACE_SCOPE_P (decl
))
11437 if (CP_DECL_CONTEXT (decl
) != global_namespace
)
11439 error ("%qD may not be declared within a namespace", decl
);
11442 else if (!TREE_PUBLIC (decl
))
11444 error ("%qD may not be declared as static", decl
);
11450 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
)
11452 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
11453 DECL_IS_OPERATOR_NEW (decl
) = 1;
11455 else if (operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
11456 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
11459 /* An operator function must either be a non-static member function
11460 or have at least one parameter of a class, a reference to a class,
11461 an enumeration, or a reference to an enumeration. 13.4.0.6 */
11462 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
11464 if (operator_code
== TYPE_EXPR
11465 || operator_code
== CALL_EXPR
11466 || operator_code
== COMPONENT_REF
11467 || operator_code
== ARRAY_REF
11468 || operator_code
== NOP_EXPR
)
11470 error ("%qD must be a nonstatic member function", decl
);
11477 if (DECL_STATIC_FUNCTION_P (decl
))
11479 error ("%qD must be either a non-static member "
11480 "function or a non-member function", decl
);
11484 for (p
= argtypes
; p
&& p
!= void_list_node
; p
= TREE_CHAIN (p
))
11486 tree arg
= non_reference (TREE_VALUE (p
));
11487 if (arg
== error_mark_node
)
11490 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
11491 because these checks are performed even on
11492 template functions. */
11493 if (MAYBE_CLASS_TYPE_P (arg
)
11494 || TREE_CODE (arg
) == ENUMERAL_TYPE
)
11498 if (!p
|| p
== void_list_node
)
11501 error ("%qD must have an argument of class or "
11502 "enumerated type", decl
);
11508 /* There are no restrictions on the arguments to an overloaded
11510 if (operator_code
== CALL_EXPR
)
11513 /* Warn about conversion operators that will never be used. */
11514 if (IDENTIFIER_TYPENAME_P (name
)
11515 && ! DECL_TEMPLATE_INFO (decl
)
11517 /* Warn only declaring the function; there is no need to
11518 warn again about out-of-class definitions. */
11519 && class_type
== current_class_type
)
11521 tree t
= TREE_TYPE (name
);
11522 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
11525 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
11527 if (VOID_TYPE_P (t
))
11528 warning (OPT_Wconversion
,
11530 ? G_("conversion to a reference to void "
11531 "will never use a type conversion operator")
11532 : G_("conversion to void "
11533 "will never use a type conversion operator"));
11534 else if (class_type
)
11536 if (t
== class_type
)
11537 warning (OPT_Wconversion
,
11539 ? G_("conversion to a reference to the same type "
11540 "will never use a type conversion operator")
11541 : G_("conversion to the same type "
11542 "will never use a type conversion operator"));
11543 /* Don't force t to be complete here. */
11544 else if (MAYBE_CLASS_TYPE_P (t
)
11545 && COMPLETE_TYPE_P (t
)
11546 && DERIVED_FROM_P (t
, class_type
))
11547 warning (OPT_Wconversion
,
11549 ? G_("conversion to a reference to a base class "
11550 "will never use a type conversion operator")
11551 : G_("conversion to a base class "
11552 "will never use a type conversion operator"));
11557 if (operator_code
== COND_EXPR
)
11560 error ("ISO C++ prohibits overloading operator ?:");
11563 else if (ellipsis_p
)
11565 error ("%qD must not have variable number of arguments", decl
);
11568 else if (ambi_op_p (operator_code
))
11571 /* We pick the one-argument operator codes by default, so
11572 we don't have to change anything. */
11574 else if (arity
== 2)
11576 /* If we thought this was a unary operator, we now know
11577 it to be a binary operator. */
11578 switch (operator_code
)
11581 operator_code
= MULT_EXPR
;
11585 operator_code
= BIT_AND_EXPR
;
11588 case UNARY_PLUS_EXPR
:
11589 operator_code
= PLUS_EXPR
;
11593 operator_code
= MINUS_EXPR
;
11596 case PREINCREMENT_EXPR
:
11597 operator_code
= POSTINCREMENT_EXPR
;
11600 case PREDECREMENT_EXPR
:
11601 operator_code
= POSTDECREMENT_EXPR
;
11605 gcc_unreachable ();
11608 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
11610 if ((operator_code
== POSTINCREMENT_EXPR
11611 || operator_code
== POSTDECREMENT_EXPR
)
11612 && ! processing_template_decl
11613 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)), integer_type_node
))
11616 error ("postfix %qD must take %<int%> as its argument",
11619 error ("postfix %qD must take %<int%> as its second "
11627 error ("%qD must take either zero or one argument", decl
);
11629 error ("%qD must take either one or two arguments", decl
);
11633 /* More Effective C++ rule 6. */
11635 && (operator_code
== POSTINCREMENT_EXPR
11636 || operator_code
== POSTDECREMENT_EXPR
11637 || operator_code
== PREINCREMENT_EXPR
11638 || operator_code
== PREDECREMENT_EXPR
))
11640 tree arg
= TREE_VALUE (argtypes
);
11641 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
11642 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
11643 arg
= TREE_TYPE (arg
);
11644 arg
= TYPE_MAIN_VARIANT (arg
);
11645 if (operator_code
== PREINCREMENT_EXPR
11646 || operator_code
== PREDECREMENT_EXPR
)
11648 if (TREE_CODE (ret
) != REFERENCE_TYPE
11649 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
11651 warning (OPT_Weffc__
, "prefix %qD should return %qT", decl
,
11652 build_reference_type (arg
));
11656 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
11657 warning (OPT_Weffc__
, "postfix %qD should return %qT", decl
, arg
);
11661 else if (unary_op_p (operator_code
))
11666 error ("%qD must take %<void%>", decl
);
11668 error ("%qD must take exactly one argument", decl
);
11672 else /* if (binary_op_p (operator_code)) */
11677 error ("%qD must take exactly one argument", decl
);
11679 error ("%qD must take exactly two arguments", decl
);
11683 /* More Effective C++ rule 7. */
11685 && (operator_code
== TRUTH_ANDIF_EXPR
11686 || operator_code
== TRUTH_ORIF_EXPR
11687 || operator_code
== COMPOUND_EXPR
))
11688 warning (OPT_Weffc__
, "user-defined %qD always evaluates both arguments",
11692 /* Effective C++ rule 23. */
11695 && !DECL_ASSIGNMENT_OPERATOR_P (decl
)
11696 && (operator_code
== PLUS_EXPR
11697 || operator_code
== MINUS_EXPR
11698 || operator_code
== TRUNC_DIV_EXPR
11699 || operator_code
== MULT_EXPR
11700 || operator_code
== TRUNC_MOD_EXPR
)
11701 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
11702 warning (OPT_Weffc__
, "%qD should return by value", decl
);
11704 /* [over.oper]/8 */
11705 for (; argtypes
&& argtypes
!= void_list_node
;
11706 argtypes
= TREE_CHAIN (argtypes
))
11707 if (TREE_PURPOSE (argtypes
))
11709 TREE_PURPOSE (argtypes
) = NULL_TREE
;
11710 if (operator_code
== POSTINCREMENT_EXPR
11711 || operator_code
== POSTDECREMENT_EXPR
)
11713 pedwarn (input_location
, OPT_Wpedantic
, "%qD cannot have default arguments",
11718 error ("%qD cannot have default arguments", decl
);
11726 /* Return a string giving the keyword associate with CODE. */
11728 static const char *
11729 tag_name (enum tag_types code
)
11741 case typename_type
:
11744 gcc_unreachable ();
11748 /* Name lookup in an elaborated-type-specifier (after the keyword
11749 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
11750 elaborated-type-specifier is invalid, issue a diagnostic and return
11751 error_mark_node; otherwise, return the *_TYPE to which it referred.
11752 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
11755 check_elaborated_type_specifier (enum tag_types tag_code
,
11757 bool allow_template_p
)
11763 struct S { struct S *p; };
11765 name lookup will find the TYPE_DECL for the implicit "S::S"
11766 typedef. Adjust for that here. */
11767 if (DECL_SELF_REFERENCE_P (decl
))
11768 decl
= TYPE_NAME (TREE_TYPE (decl
));
11770 type
= TREE_TYPE (decl
);
11772 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
11773 is false for this case as well. */
11774 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
11776 error ("using template type parameter %qT after %qs",
11777 type
, tag_name (tag_code
));
11778 return error_mark_node
;
11780 /* Accept template template parameters. */
11781 else if (allow_template_p
11782 && (TREE_CODE (type
) == BOUND_TEMPLATE_TEMPLATE_PARM
11783 || TREE_CODE (type
) == TEMPLATE_TEMPLATE_PARM
))
11787 If the identifier resolves to a typedef-name or the
11788 simple-template-id resolves to an alias template
11789 specialization, the elaborated-type-specifier is ill-formed.
11791 In other words, the only legitimate declaration to use in the
11792 elaborated type specifier is the implicit typedef created when
11793 the type is declared. */
11794 else if (!DECL_IMPLICIT_TYPEDEF_P (decl
)
11795 && !DECL_SELF_REFERENCE_P (decl
)
11796 && tag_code
!= typename_type
)
11798 if (alias_template_specialization_p (type
))
11799 error ("using alias template specialization %qT after %qs",
11800 type
, tag_name (tag_code
));
11802 error ("using typedef-name %qD after %qs", decl
, tag_name (tag_code
));
11803 inform (DECL_SOURCE_LOCATION (decl
),
11804 "%qD has a previous declaration here", decl
);
11805 return error_mark_node
;
11807 else if (TREE_CODE (type
) != RECORD_TYPE
11808 && TREE_CODE (type
) != UNION_TYPE
11809 && tag_code
!= enum_type
11810 && tag_code
!= typename_type
)
11812 error ("%qT referred to as %qs", type
, tag_name (tag_code
));
11813 error ("%q+T has a previous declaration here", type
);
11814 return error_mark_node
;
11816 else if (TREE_CODE (type
) != ENUMERAL_TYPE
11817 && tag_code
== enum_type
)
11819 error ("%qT referred to as enum", type
);
11820 error ("%q+T has a previous declaration here", type
);
11821 return error_mark_node
;
11823 else if (!allow_template_p
11824 && TREE_CODE (type
) == RECORD_TYPE
11825 && CLASSTYPE_IS_TEMPLATE (type
))
11827 /* If a class template appears as elaborated type specifier
11828 without a template header such as:
11830 template <class T> class C {};
11831 void f(class C); // No template header here
11833 then the required template argument is missing. */
11834 error ("template argument required for %<%s %T%>",
11835 tag_name (tag_code
),
11836 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
)));
11837 return error_mark_node
;
11843 /* Lookup NAME in elaborate type specifier in scope according to
11844 SCOPE and issue diagnostics if necessary.
11845 Return *_TYPE node upon success, NULL_TREE when the NAME is not
11846 found, and ERROR_MARK_NODE for type error. */
11849 lookup_and_check_tag (enum tag_types tag_code
, tree name
,
11850 tag_scope scope
, bool template_header_p
)
11854 if (scope
== ts_global
)
11856 /* First try ordinary name lookup, ignoring hidden class name
11857 injected via friend declaration. */
11858 decl
= lookup_name_prefer_type (name
, 2);
11859 /* If that fails, the name will be placed in the smallest
11860 non-class, non-function-prototype scope according to 3.3.1/5.
11861 We may already have a hidden name declared as friend in this
11862 scope. So lookup again but not ignoring hidden names.
11863 If we find one, that name will be made visible rather than
11864 creating a new tag. */
11866 decl
= lookup_type_scope (name
, ts_within_enclosing_non_class
);
11869 decl
= lookup_type_scope (name
, scope
);
11872 && (DECL_CLASS_TEMPLATE_P (decl
)
11873 || DECL_TEMPLATE_TEMPLATE_PARM_P (decl
)))
11874 decl
= DECL_TEMPLATE_RESULT (decl
);
11876 if (decl
&& TREE_CODE (decl
) == TYPE_DECL
)
11878 /* Look for invalid nested type:
11882 if (scope
== ts_current
&& DECL_SELF_REFERENCE_P (decl
))
11884 error ("%qD has the same name as the class in which it is "
11887 return error_mark_node
;
11890 /* Two cases we need to consider when deciding if a class
11891 template is allowed as an elaborated type specifier:
11892 1. It is a self reference to its own class.
11893 2. It comes with a template header.
11897 template <class T> class C {
11898 class C *c1; // DECL_SELF_REFERENCE_P is true
11901 template <class U> class C; // template_header_p is true
11902 template <class T> class C<T>::D {
11903 class C *c2; // DECL_SELF_REFERENCE_P is true
11906 t
= check_elaborated_type_specifier (tag_code
,
11909 | DECL_SELF_REFERENCE_P (decl
));
11912 else if (decl
&& TREE_CODE (decl
) == TREE_LIST
)
11914 error ("reference to %qD is ambiguous", name
);
11915 print_candidates (decl
);
11916 return error_mark_node
;
11922 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
11923 Define the tag as a forward-reference if it is not defined.
11925 If a declaration is given, process it here, and report an error if
11926 multiple declarations are not identical.
11928 SCOPE is TS_CURRENT when this is also a definition. Only look in
11929 the current frame for the name (since C++ allows new names in any
11930 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
11931 declaration. Only look beginning from the current scope outward up
11932 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
11934 TEMPLATE_HEADER_P is true when this declaration is preceded by
11935 a set of template parameters. */
11938 xref_tag_1 (enum tag_types tag_code
, tree name
,
11939 tag_scope orig_scope
, bool template_header_p
)
11941 enum tree_code code
;
11943 tree context
= NULL_TREE
;
11946 gcc_assert (identifier_p (name
));
11952 code
= RECORD_TYPE
;
11958 code
= ENUMERAL_TYPE
;
11961 gcc_unreachable ();
11964 if (orig_scope
== ts_lambda
)
11965 scope
= ts_current
;
11967 scope
= orig_scope
;
11969 /* In case of anonymous name, xref_tag is only called to
11970 make type node and push name. Name lookup is not required. */
11971 if (ANON_AGGRNAME_P (name
))
11974 t
= lookup_and_check_tag (tag_code
, name
,
11975 scope
, template_header_p
);
11977 if (t
== error_mark_node
)
11978 return error_mark_node
;
11980 if (scope
!= ts_current
&& t
&& current_class_type
11981 && template_class_depth (current_class_type
)
11982 && template_header_p
)
11984 if (TREE_CODE (t
) == TEMPLATE_TEMPLATE_PARM
)
11987 /* Since SCOPE is not TS_CURRENT, we are not looking at a
11988 definition of this tag. Since, in addition, we are currently
11989 processing a (member) template declaration of a template
11990 class, we must be very careful; consider:
11997 { template <class V>
11998 friend struct S1; };
12000 Here, the S2::S1 declaration should not be confused with the
12001 outer declaration. In particular, the inner version should
12002 have a template parameter of level 2, not level 1. This
12003 would be particularly important if the member declaration
12006 template <class V = U> friend struct S1;
12008 say, when we should tsubst into `U' when instantiating
12009 S2. On the other hand, when presented with:
12019 we must find the inner binding eventually. We
12020 accomplish this by making sure that the new type we
12021 create to represent this declaration has the right
12023 context
= TYPE_CONTEXT (t
);
12029 /* If no such tag is yet defined, create a forward-reference node
12030 and record it as the "definition".
12031 When a real declaration of this type is found,
12032 the forward-reference will be altered into a real type. */
12033 if (code
== ENUMERAL_TYPE
)
12035 error ("use of enum %q#D without previous declaration", name
);
12036 return error_mark_node
;
12040 t
= make_class_type (code
);
12041 TYPE_CONTEXT (t
) = context
;
12042 if (orig_scope
== ts_lambda
)
12043 /* Remember that we're declaring a lambda to avoid bogus errors
12044 in push_template_decl. */
12045 CLASSTYPE_LAMBDA_EXPR (t
) = error_mark_node
;
12046 t
= pushtag (name
, t
, scope
);
12051 if (template_header_p
&& MAYBE_CLASS_TYPE_P (t
))
12053 if (!redeclare_class_template (t
, current_template_parms
))
12054 return error_mark_node
;
12056 else if (!processing_template_decl
12057 && CLASS_TYPE_P (t
)
12058 && CLASSTYPE_IS_TEMPLATE (t
))
12060 error ("redeclaration of %qT as a non-template", t
);
12061 error ("previous declaration %q+D", t
);
12062 return error_mark_node
;
12065 /* Make injected friend class visible. */
12066 if (scope
!= ts_within_enclosing_non_class
12067 && hidden_name_p (TYPE_NAME (t
)))
12069 DECL_ANTICIPATED (TYPE_NAME (t
)) = 0;
12070 DECL_FRIEND_P (TYPE_NAME (t
)) = 0;
12072 if (TYPE_TEMPLATE_INFO (t
))
12074 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t
)) = 0;
12075 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t
)) = 0;
12083 /* Wrapper for xref_tag_1. */
12086 xref_tag (enum tag_types tag_code
, tree name
,
12087 tag_scope scope
, bool template_header_p
)
12091 subtime
= timevar_cond_start (TV_NAME_LOOKUP
);
12092 ret
= xref_tag_1 (tag_code
, name
, scope
, template_header_p
);
12093 timevar_cond_stop (TV_NAME_LOOKUP
, subtime
);
12099 xref_tag_from_type (tree old
, tree id
, tag_scope scope
)
12101 enum tag_types tag_kind
;
12103 if (TREE_CODE (old
) == RECORD_TYPE
)
12104 tag_kind
= (CLASSTYPE_DECLARED_CLASS (old
) ? class_type
: record_type
);
12106 tag_kind
= union_type
;
12108 if (id
== NULL_TREE
)
12109 id
= TYPE_IDENTIFIER (old
);
12111 return xref_tag (tag_kind
, id
, scope
, false);
12114 /* Create the binfo hierarchy for REF with (possibly NULL) base list
12115 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
12116 access_* node, and the TREE_VALUE is the type of the base-class.
12117 Non-NULL TREE_TYPE indicates virtual inheritance.
12119 Returns true if the binfo hierarchy was successfully created,
12120 false if an error was detected. */
12123 xref_basetypes (tree ref
, tree base_list
)
12126 tree binfo
, base_binfo
;
12127 unsigned max_vbases
= 0; /* Maximum direct & indirect virtual bases. */
12128 unsigned max_bases
= 0; /* Maximum direct bases. */
12130 tree default_access
;
12131 tree igo_prev
; /* Track Inheritance Graph Order. */
12133 if (ref
== error_mark_node
)
12136 /* The base of a derived class is private by default, all others are
12138 default_access
= (TREE_CODE (ref
) == RECORD_TYPE
12139 && CLASSTYPE_DECLARED_CLASS (ref
)
12140 ? access_private_node
: access_public_node
);
12142 /* First, make sure that any templates in base-classes are
12143 instantiated. This ensures that if we call ourselves recursively
12144 we do not get confused about which classes are marked and which
12146 basep
= &base_list
;
12149 tree basetype
= TREE_VALUE (*basep
);
12151 /* The dependent_type_p call below should really be dependent_scope_p
12152 so that we give a hard error about using an incomplete type as a
12153 base, but we allow it with a pedwarn for backward
12155 if (processing_template_decl
12156 && CLASS_TYPE_P (basetype
) && TYPE_BEING_DEFINED (basetype
))
12157 cxx_incomplete_type_diagnostic (NULL_TREE
, basetype
, DK_PEDWARN
);
12158 if (!dependent_type_p (basetype
)
12159 && !complete_type_or_else (basetype
, NULL
))
12160 /* An incomplete type. Remove it from the list. */
12161 *basep
= TREE_CHAIN (*basep
);
12165 if (TREE_TYPE (*basep
))
12167 if (CLASS_TYPE_P (basetype
))
12168 max_vbases
+= vec_safe_length (CLASSTYPE_VBASECLASSES (basetype
));
12169 basep
= &TREE_CHAIN (*basep
);
12173 TYPE_MARKED_P (ref
) = 1;
12175 /* The binfo slot should be empty, unless this is an (ill-formed)
12177 if (TYPE_BINFO (ref
) && !TYPE_SIZE (ref
))
12179 error ("redefinition of %q#T", ref
);
12183 gcc_assert (TYPE_MAIN_VARIANT (ref
) == ref
);
12185 binfo
= make_tree_binfo (max_bases
);
12187 TYPE_BINFO (ref
) = binfo
;
12188 BINFO_OFFSET (binfo
) = size_zero_node
;
12189 BINFO_TYPE (binfo
) = ref
;
12191 /* Apply base-class info set up to the variants of this type. */
12192 fixup_type_variants (ref
);
12196 vec_alloc (BINFO_BASE_ACCESSES (binfo
), max_bases
);
12197 /* An aggregate cannot have baseclasses. */
12198 CLASSTYPE_NON_AGGREGATE (ref
) = 1;
12200 if (TREE_CODE (ref
) == UNION_TYPE
)
12202 error ("derived union %qT invalid", ref
);
12209 if (TYPE_FOR_JAVA (ref
))
12211 error ("Java class %qT cannot have multiple bases", ref
);
12218 vec_alloc (CLASSTYPE_VBASECLASSES (ref
), max_vbases
);
12220 if (TYPE_FOR_JAVA (ref
))
12222 error ("Java class %qT cannot have virtual bases", ref
);
12227 for (igo_prev
= binfo
; base_list
; base_list
= TREE_CHAIN (base_list
))
12229 tree access
= TREE_PURPOSE (base_list
);
12230 int via_virtual
= TREE_TYPE (base_list
) != NULL_TREE
;
12231 tree basetype
= TREE_VALUE (base_list
);
12233 if (access
== access_default_node
)
12234 access
= default_access
;
12236 if (PACK_EXPANSION_P (basetype
))
12237 basetype
= PACK_EXPANSION_PATTERN (basetype
);
12238 if (TREE_CODE (basetype
) == TYPE_DECL
)
12239 basetype
= TREE_TYPE (basetype
);
12240 if (!MAYBE_CLASS_TYPE_P (basetype
) || TREE_CODE (basetype
) == UNION_TYPE
)
12242 error ("base type %qT fails to be a struct or class type",
12247 if (TYPE_FOR_JAVA (basetype
) && (current_lang_depth () == 0))
12248 TYPE_FOR_JAVA (ref
) = 1;
12250 base_binfo
= NULL_TREE
;
12251 if (CLASS_TYPE_P (basetype
) && !dependent_scope_p (basetype
))
12253 base_binfo
= TYPE_BINFO (basetype
);
12254 /* The original basetype could have been a typedef'd type. */
12255 basetype
= BINFO_TYPE (base_binfo
);
12257 /* Inherit flags from the base. */
12258 TYPE_HAS_NEW_OPERATOR (ref
)
12259 |= TYPE_HAS_NEW_OPERATOR (basetype
);
12260 TYPE_HAS_ARRAY_NEW_OPERATOR (ref
)
12261 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype
);
12262 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
12263 TYPE_HAS_CONVERSION (ref
) |= TYPE_HAS_CONVERSION (basetype
);
12264 CLASSTYPE_DIAMOND_SHAPED_P (ref
)
12265 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype
);
12266 CLASSTYPE_REPEATED_BASE_P (ref
)
12267 |= CLASSTYPE_REPEATED_BASE_P (basetype
);
12270 /* We must do this test after we've seen through a typedef
12272 if (TYPE_MARKED_P (basetype
))
12274 if (basetype
== ref
)
12275 error ("recursive type %qT undefined", basetype
);
12277 error ("duplicate base type %qT invalid", basetype
);
12281 if (PACK_EXPANSION_P (TREE_VALUE (base_list
)))
12282 /* Regenerate the pack expansion for the bases. */
12283 basetype
= make_pack_expansion (basetype
);
12285 TYPE_MARKED_P (basetype
) = 1;
12287 base_binfo
= copy_binfo (base_binfo
, basetype
, ref
,
12288 &igo_prev
, via_virtual
);
12289 if (!BINFO_INHERITANCE_CHAIN (base_binfo
))
12290 BINFO_INHERITANCE_CHAIN (base_binfo
) = binfo
;
12292 BINFO_BASE_APPEND (binfo
, base_binfo
);
12293 BINFO_BASE_ACCESS_APPEND (binfo
, access
);
12296 if (vec_safe_length (CLASSTYPE_VBASECLASSES (ref
)) < max_vbases
)
12297 /* If we didn't get max_vbases vbases, we must have shared at
12298 least one of them, and are therefore diamond shaped. */
12299 CLASSTYPE_DIAMOND_SHAPED_P (ref
) = 1;
12301 /* Unmark all the types. */
12302 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
12303 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
12304 TYPE_MARKED_P (ref
) = 0;
12306 /* Now see if we have a repeated base type. */
12307 if (!CLASSTYPE_REPEATED_BASE_P (ref
))
12309 for (base_binfo
= binfo
; base_binfo
;
12310 base_binfo
= TREE_CHAIN (base_binfo
))
12312 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
12314 CLASSTYPE_REPEATED_BASE_P (ref
) = 1;
12317 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 1;
12319 for (base_binfo
= binfo
; base_binfo
;
12320 base_binfo
= TREE_CHAIN (base_binfo
))
12321 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
12322 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
12331 /* Copies the enum-related properties from type SRC to type DST.
12332 Used with the underlying type of an enum and the enum itself. */
12334 copy_type_enum (tree dst
, tree src
)
12337 for (t
= dst
; t
; t
= TYPE_NEXT_VARIANT (t
))
12339 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (src
);
12340 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (src
);
12341 TYPE_SIZE (t
) = TYPE_SIZE (src
);
12342 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (src
);
12343 SET_TYPE_MODE (dst
, TYPE_MODE (src
));
12344 TYPE_PRECISION (t
) = TYPE_PRECISION (src
);
12345 TYPE_ALIGN (t
) = TYPE_ALIGN (src
);
12346 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (src
);
12347 TYPE_UNSIGNED (t
) = TYPE_UNSIGNED (src
);
12351 /* Begin compiling the definition of an enumeration type.
12354 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
12356 UNDERLYING_TYPE is the type that will be used as the storage for
12357 the enumeration type. This should be NULL_TREE if no storage type
12360 SCOPED_ENUM_P is true if this is a scoped enumeration type.
12362 if IS_NEW is not NULL, gets TRUE iff a new type is created.
12364 Returns the type object, as yet incomplete.
12365 Also records info about it so that build_enumerator
12366 may be used to declare the individual values as they are read. */
12369 start_enum (tree name
, tree enumtype
, tree underlying_type
,
12370 bool scoped_enum_p
, bool *is_new
)
12372 tree prevtype
= NULL_TREE
;
12373 gcc_assert (identifier_p (name
));
12377 /* [C++0x dcl.enum]p5:
12379 If not explicitly specified, the underlying type of a scoped
12380 enumeration type is int. */
12381 if (!underlying_type
&& scoped_enum_p
)
12382 underlying_type
= integer_type_node
;
12384 if (underlying_type
)
12385 underlying_type
= cv_unqualified (underlying_type
);
12387 /* If this is the real definition for a previous forward reference,
12388 fill in the contents in the same object that used to be the
12389 forward reference. */
12391 enumtype
= lookup_and_check_tag (enum_type
, name
,
12392 /*tag_scope=*/ts_current
,
12393 /*template_header_p=*/false);
12395 /* In case of a template_decl, the only check that should be deferred
12396 to instantiation time is the comparison of underlying types. */
12397 if (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
12399 if (scoped_enum_p
!= SCOPED_ENUM_P (enumtype
))
12401 error_at (input_location
, "scoped/unscoped mismatch "
12402 "in enum %q#T", enumtype
);
12403 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12404 "previous definition here");
12405 enumtype
= error_mark_node
;
12407 else if (ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) != !! underlying_type
)
12409 error_at (input_location
, "underlying type mismatch "
12410 "in enum %q#T", enumtype
);
12411 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12412 "previous definition here");
12413 enumtype
= error_mark_node
;
12415 else if (underlying_type
&& ENUM_UNDERLYING_TYPE (enumtype
)
12416 && !dependent_type_p (underlying_type
)
12417 && !dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))
12418 && !same_type_p (underlying_type
,
12419 ENUM_UNDERLYING_TYPE (enumtype
)))
12421 error_at (input_location
, "different underlying type "
12422 "in enum %q#T", enumtype
);
12423 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
12424 "previous definition here");
12425 underlying_type
= NULL_TREE
;
12429 if (!enumtype
|| TREE_CODE (enumtype
) != ENUMERAL_TYPE
12430 || processing_template_decl
)
12432 /* In case of error, make a dummy enum to allow parsing to
12434 if (enumtype
== error_mark_node
)
12436 name
= make_anon_name ();
12437 enumtype
= NULL_TREE
;
12440 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
12441 of an opaque enum, or an opaque enum of an already defined
12442 enumeration (C++0x only).
12443 In any other case, it'll be NULL_TREE. */
12449 prevtype
= enumtype
;
12451 /* Do not push the decl more than once, unless we need to
12452 compare underlying types at instantiation time */
12454 || TREE_CODE (enumtype
) != ENUMERAL_TYPE
12455 || (underlying_type
12456 && dependent_type_p (underlying_type
))
12457 || (ENUM_UNDERLYING_TYPE (enumtype
)
12458 && dependent_type_p (ENUM_UNDERLYING_TYPE (enumtype
))))
12460 enumtype
= cxx_make_type (ENUMERAL_TYPE
);
12461 enumtype
= pushtag (name
, enumtype
, /*tag_scope=*/ts_current
);
12464 enumtype
= xref_tag (enum_type
, name
, /*tag_scope=*/ts_current
,
12467 if (enumtype
== error_mark_node
)
12468 return error_mark_node
;
12470 /* The enum is considered opaque until the opening '{' of the
12471 enumerator list. */
12472 SET_OPAQUE_ENUM_P (enumtype
, true);
12473 ENUM_FIXED_UNDERLYING_TYPE_P (enumtype
) = !! underlying_type
;
12476 SET_SCOPED_ENUM_P (enumtype
, scoped_enum_p
);
12478 if (underlying_type
)
12480 if (CP_INTEGRAL_TYPE_P (underlying_type
))
12482 copy_type_enum (enumtype
, underlying_type
);
12483 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
12485 else if (dependent_type_p (underlying_type
))
12486 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
12488 error ("underlying type %<%T%> of %<%T%> must be an integral type",
12489 underlying_type
, enumtype
);
12492 /* If into a template class, the returned enum is always the first
12493 declaration (opaque or not) seen. This way all the references to
12494 this type will be to the same declaration. The following ones are used
12495 only to check for definition errors. */
12496 if (prevtype
&& processing_template_decl
)
12502 /* After processing and defining all the values of an enumeration type,
12503 install their decls in the enumeration type.
12504 ENUMTYPE is the type object. */
12507 finish_enum_value_list (tree enumtype
)
12510 tree underlying_type
;
12513 tree minnode
, maxnode
;
12516 bool fixed_underlying_type_p
12517 = ENUM_UNDERLYING_TYPE (enumtype
) != NULL_TREE
;
12519 /* We built up the VALUES in reverse order. */
12520 TYPE_VALUES (enumtype
) = nreverse (TYPE_VALUES (enumtype
));
12522 /* For an enum defined in a template, just set the type of the values;
12523 all further processing is postponed until the template is
12524 instantiated. We need to set the type so that tsubst of a CONST_DECL
12526 if (processing_template_decl
)
12528 for (values
= TYPE_VALUES (enumtype
);
12530 values
= TREE_CHAIN (values
))
12531 TREE_TYPE (TREE_VALUE (values
)) = enumtype
;
12535 /* Determine the minimum and maximum values of the enumerators. */
12536 if (TYPE_VALUES (enumtype
))
12538 minnode
= maxnode
= NULL_TREE
;
12540 for (values
= TYPE_VALUES (enumtype
);
12542 values
= TREE_CHAIN (values
))
12544 decl
= TREE_VALUE (values
);
12546 /* [dcl.enum]: Following the closing brace of an enum-specifier,
12547 each enumerator has the type of its enumeration. Prior to the
12548 closing brace, the type of each enumerator is the type of its
12549 initializing value. */
12550 TREE_TYPE (decl
) = enumtype
;
12552 /* Update the minimum and maximum values, if appropriate. */
12553 value
= DECL_INITIAL (decl
);
12554 if (value
== error_mark_node
)
12555 value
= integer_zero_node
;
12556 /* Figure out what the minimum and maximum values of the
12557 enumerators are. */
12559 minnode
= maxnode
= value
;
12560 else if (tree_int_cst_lt (maxnode
, value
))
12562 else if (tree_int_cst_lt (value
, minnode
))
12569 If the enumerator-list is empty, the underlying type is as if
12570 the enumeration had a single enumerator with value 0. */
12571 minnode
= maxnode
= integer_zero_node
;
12573 if (!fixed_underlying_type_p
)
12575 /* Compute the number of bits require to represent all values of the
12576 enumeration. We must do this before the type of MINNODE and
12577 MAXNODE are transformed, since tree_int_cst_min_precision relies
12578 on the TREE_TYPE of the value it is passed. */
12579 bool unsignedp
= tree_int_cst_sgn (minnode
) >= 0;
12580 int lowprec
= tree_int_cst_min_precision (minnode
, unsignedp
);
12581 int highprec
= tree_int_cst_min_precision (maxnode
, unsignedp
);
12582 int precision
= MAX (lowprec
, highprec
);
12584 bool use_short_enum
;
12586 /* Determine the underlying type of the enumeration.
12590 The underlying type of an enumeration is an integral type that
12591 can represent all the enumerator values defined in the
12592 enumeration. It is implementation-defined which integral type is
12593 used as the underlying type for an enumeration except that the
12594 underlying type shall not be larger than int unless the value of
12595 an enumerator cannot fit in an int or unsigned int.
12597 We use "int" or an "unsigned int" as the underlying type, even if
12598 a smaller integral type would work, unless the user has
12599 explicitly requested that we use the smallest possible type. The
12600 user can request that for all enumerations with a command line
12601 flag, or for just one enumeration with an attribute. */
12603 use_short_enum
= flag_short_enums
12604 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype
));
12606 for (itk
= (use_short_enum
? itk_char
: itk_int
);
12610 underlying_type
= integer_types
[itk
];
12611 if (underlying_type
!= NULL_TREE
12612 && TYPE_PRECISION (underlying_type
) >= precision
12613 && TYPE_UNSIGNED (underlying_type
) == unsignedp
)
12616 if (itk
== itk_none
)
12620 IF no integral type can represent all the enumerator values, the
12621 enumeration is ill-formed. */
12622 error ("no integral type can represent all of the enumerator values "
12623 "for %qT", enumtype
);
12624 precision
= TYPE_PRECISION (long_long_integer_type_node
);
12625 underlying_type
= integer_types
[itk_unsigned_long_long
];
12630 The value of sizeof() applied to an enumeration type, an object
12631 of an enumeration type, or an enumerator, is the value of sizeof()
12632 applied to the underlying type. */
12633 copy_type_enum (enumtype
, underlying_type
);
12635 /* Compute the minimum and maximum values for the type.
12639 For an enumeration where emin is the smallest enumerator and emax
12640 is the largest, the values of the enumeration are the values of the
12641 underlying type in the range bmin to bmax, where bmin and bmax are,
12642 respectively, the smallest and largest values of the smallest bit-
12643 field that can store emin and emax. */
12645 /* The middle-end currently assumes that types with TYPE_PRECISION
12646 narrower than their underlying type are suitably zero or sign
12647 extended to fill their mode. Similarly, it assumes that the front
12648 end assures that a value of a particular type must be within
12649 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
12651 We used to set these fields based on bmin and bmax, but that led
12652 to invalid assumptions like optimizing away bounds checking. So
12653 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
12654 TYPE_MAX_VALUE to the values for the mode above and only restrict
12655 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
12656 ENUM_UNDERLYING_TYPE (enumtype
)
12657 = build_distinct_type_copy (underlying_type
);
12658 TYPE_PRECISION (ENUM_UNDERLYING_TYPE (enumtype
)) = precision
;
12659 set_min_and_max_values_for_integral_type
12660 (ENUM_UNDERLYING_TYPE (enumtype
), precision
, unsignedp
);
12662 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
12663 if (flag_strict_enums
)
12664 set_min_and_max_values_for_integral_type (enumtype
, precision
,
12668 underlying_type
= ENUM_UNDERLYING_TYPE (enumtype
);
12670 /* Convert each of the enumerators to the type of the underlying
12671 type of the enumeration. */
12672 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
12674 location_t saved_location
;
12676 decl
= TREE_VALUE (values
);
12677 saved_location
= input_location
;
12678 input_location
= DECL_SOURCE_LOCATION (decl
);
12679 if (fixed_underlying_type_p
)
12680 /* If the enumeration type has a fixed underlying type, we
12681 already checked all of the enumerator values. */
12682 value
= DECL_INITIAL (decl
);
12684 value
= perform_implicit_conversion (underlying_type
,
12685 DECL_INITIAL (decl
),
12686 tf_warning_or_error
);
12687 input_location
= saved_location
;
12689 /* Do not clobber shared ints. */
12690 value
= copy_node (value
);
12692 TREE_TYPE (value
) = enumtype
;
12693 DECL_INITIAL (decl
) = value
;
12696 /* Fix up all variant types of this enum type. */
12697 for (t
= TYPE_MAIN_VARIANT (enumtype
); t
; t
= TYPE_NEXT_VARIANT (t
))
12698 TYPE_VALUES (t
) = TYPE_VALUES (enumtype
);
12700 if (at_class_scope_p ()
12701 && COMPLETE_TYPE_P (current_class_type
)
12702 && UNSCOPED_ENUM_P (enumtype
))
12703 insert_late_enum_def_into_classtype_sorted_fields (enumtype
,
12704 current_class_type
);
12706 /* Finish debugging output for this type. */
12707 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
12710 /* Finishes the enum type. This is called only the first time an
12711 enumeration is seen, be it opaque or odinary.
12712 ENUMTYPE is the type object. */
12715 finish_enum (tree enumtype
)
12717 if (processing_template_decl
)
12719 if (at_function_scope_p ())
12720 add_stmt (build_min (TAG_DEFN
, enumtype
));
12724 /* If this is a forward declaration, there should not be any variants,
12725 though we can get a variant in the middle of an enum-specifier with
12726 wacky code like 'enum E { e = sizeof(const E*) };' */
12727 gcc_assert (enumtype
== TYPE_MAIN_VARIANT (enumtype
)
12728 && (TYPE_VALUES (enumtype
)
12729 || !TYPE_NEXT_VARIANT (enumtype
)));
12732 /* Build and install a CONST_DECL for an enumeration constant of the
12733 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
12734 LOC is the location of NAME.
12735 Assignment of sequential values by default is handled here. */
12738 build_enumerator (tree name
, tree value
, tree enumtype
, location_t loc
)
12744 /* If the VALUE was erroneous, pretend it wasn't there; that will
12745 result in the enum being assigned the next value in sequence. */
12746 if (value
== error_mark_node
)
12749 /* Remove no-op casts from the value. */
12751 STRIP_TYPE_NOPS (value
);
12753 if (! processing_template_decl
)
12755 /* Validate and default VALUE. */
12756 if (value
!= NULL_TREE
)
12758 value
= cxx_constant_value (value
);
12760 if (TREE_CODE (value
) != INTEGER_CST
12761 || ! INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (value
)))
12763 error ("enumerator value for %qD is not an integer constant",
12769 /* Default based on previous value. */
12770 if (value
== NULL_TREE
)
12772 if (TYPE_VALUES (enumtype
))
12777 /* C++03 7.2/4: If no initializer is specified for the first
12778 enumerator, the type is an unspecified integral
12779 type. Otherwise the type is the same as the type of the
12780 initializing value of the preceding enumerator unless the
12781 incremented value is not representable in that type, in
12782 which case the type is an unspecified integral type
12783 sufficient to contain the incremented value. */
12784 prev_value
= DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype
)));
12785 if (error_operand_p (prev_value
))
12786 value
= error_mark_node
;
12789 double_int di
= TREE_INT_CST (prev_value
)
12790 .add_with_sign (double_int_one
,
12791 false, &overflowed
);
12794 tree type
= TREE_TYPE (prev_value
);
12795 bool pos
= TYPE_UNSIGNED (type
) || !di
.is_negative ();
12796 if (!double_int_fits_to_tree_p (type
, di
))
12799 for (itk
= itk_int
; itk
!= itk_none
; itk
++)
12801 type
= integer_types
[itk
];
12802 if (type
!= NULL_TREE
12803 && (pos
|| !TYPE_UNSIGNED (type
))
12804 && double_int_fits_to_tree_p (type
, di
))
12807 if (type
&& cxx_dialect
< cxx0x
12808 && itk
> itk_unsigned_long
)
12809 pedwarn (input_location
, OPT_Wlong_long
, pos
? "\
12810 incremented enumerator value is too large for %<unsigned long%>" : "\
12811 incremented enumerator value is too large for %<long%>");
12813 if (type
== NULL_TREE
)
12816 value
= double_int_to_tree (type
, di
);
12821 error ("overflow in enumeration values at %qD", name
);
12822 value
= error_mark_node
;
12827 value
= integer_zero_node
;
12830 /* Remove no-op casts from the value. */
12831 STRIP_TYPE_NOPS (value
);
12833 /* If the underlying type of the enum is fixed, check whether
12834 the enumerator values fits in the underlying type. If it
12835 does not fit, the program is ill-formed [C++0x dcl.enum]. */
12836 if (ENUM_UNDERLYING_TYPE (enumtype
)
12838 && TREE_CODE (value
) == INTEGER_CST
)
12840 if (!int_fits_type_p (value
, ENUM_UNDERLYING_TYPE (enumtype
)))
12841 error ("enumerator value %E is too large for underlying type %<%T%>",
12842 value
, ENUM_UNDERLYING_TYPE (enumtype
));
12844 /* Convert the value to the appropriate type. */
12845 value
= convert (ENUM_UNDERLYING_TYPE (enumtype
), value
);
12849 /* C++ associates enums with global, function, or class declarations. */
12850 context
= current_scope ();
12852 /* Build the actual enumeration constant. Note that the enumeration
12853 constants have the underlying type of the enum (if it is fixed)
12854 or the type of their initializer (if the underlying type of the
12855 enum is not fixed):
12859 If the underlying type is fixed, the type of each enumerator
12860 prior to the closing brace is the underlying type; if the
12861 initializing value of an enumerator cannot be represented by
12862 the underlying type, the program is ill-formed. If the
12863 underlying type is not fixed, the type of each enumerator is
12864 the type of its initializing value.
12866 If the underlying type is not fixed, it will be computed by
12867 finish_enum and we will reset the type of this enumerator. Of
12868 course, if we're processing a template, there may be no value. */
12869 type
= value
? TREE_TYPE (value
) : NULL_TREE
;
12871 decl
= build_decl (loc
, CONST_DECL
, name
, type
);
12873 DECL_CONTEXT (decl
) = enumtype
;
12874 TREE_CONSTANT (decl
) = 1;
12875 TREE_READONLY (decl
) = 1;
12876 DECL_INITIAL (decl
) = value
;
12878 if (context
&& context
== current_class_type
&& !SCOPED_ENUM_P (enumtype
))
12879 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
12880 on the TYPE_FIELDS list for `S'. (That's so that you can say
12881 things like `S::i' later.) */
12882 finish_member_declaration (decl
);
12886 /* Add this enumeration constant to the list for this type. */
12887 TYPE_VALUES (enumtype
) = tree_cons (name
, decl
, TYPE_VALUES (enumtype
));
12890 /* Look for an enumerator with the given NAME within the enumeration
12891 type ENUMTYPE. This routine is used primarily for qualified name
12892 lookup into an enumerator in C++0x, e.g.,
12894 enum class Color { Red, Green, Blue };
12896 Color color = Color::Red;
12898 Returns the value corresponding to the enumerator, or
12899 NULL_TREE if no such enumerator was found. */
12901 lookup_enumerator (tree enumtype
, tree name
)
12904 gcc_assert (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
);
12906 e
= purpose_member (name
, TYPE_VALUES (enumtype
));
12907 return e
? TREE_VALUE (e
) : NULL_TREE
;
12911 /* We're defining DECL. Make sure that its type is OK. */
12914 check_function_type (tree decl
, tree current_function_parms
)
12916 tree fntype
= TREE_TYPE (decl
);
12917 tree return_type
= complete_type (TREE_TYPE (fntype
));
12919 /* In a function definition, arg types must be complete. */
12920 require_complete_types_for_parms (current_function_parms
);
12922 if (dependent_type_p (return_type
)
12923 || type_uses_auto (return_type
))
12925 if (!COMPLETE_OR_VOID_TYPE_P (return_type
)
12926 || (TYPE_FOR_JAVA (return_type
) && MAYBE_CLASS_TYPE_P (return_type
)))
12928 tree args
= TYPE_ARG_TYPES (fntype
);
12930 if (!COMPLETE_OR_VOID_TYPE_P (return_type
))
12931 error ("return type %q#T is incomplete", return_type
);
12933 error ("return type has Java class type %q#T", return_type
);
12935 /* Make it return void instead. */
12936 if (TREE_CODE (fntype
) == METHOD_TYPE
)
12937 fntype
= build_method_type_directly (TREE_TYPE (TREE_VALUE (args
)),
12939 TREE_CHAIN (args
));
12941 fntype
= build_function_type (void_type_node
, args
);
12943 = build_exception_variant (fntype
,
12944 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl
)));
12945 fntype
= (cp_build_type_attribute_variant
12946 (fntype
, TYPE_ATTRIBUTES (TREE_TYPE (decl
))));
12947 TREE_TYPE (decl
) = fntype
;
12950 abstract_virtuals_error (decl
, TREE_TYPE (fntype
));
12953 /* Create the FUNCTION_DECL for a function definition.
12954 DECLSPECS and DECLARATOR are the parts of the declaration;
12955 they describe the function's name and the type it returns,
12956 but twisted together in a fashion that parallels the syntax of C.
12958 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
12959 DECLARATOR is really the DECL for the function we are about to
12960 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
12961 indicating that the function is an inline defined in-class.
12963 This function creates a binding context for the function body
12964 as well as setting up the FUNCTION_DECL in current_function_decl.
12966 For C++, we must first check whether that datum makes any sense.
12967 For example, "class A local_a(1,2);" means that variable local_a
12968 is an aggregate of type A, which should have a constructor
12969 applied to it with the argument list [1, 2].
12971 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
12972 or may be a BLOCK if the function has been defined previously
12973 in this translation unit. On exit, DECL_INITIAL (decl1) will be
12974 error_mark_node if the function has never been defined, or
12975 a BLOCK if the function has been defined somewhere. */
12978 start_preparsed_function (tree decl1
, tree attrs
, int flags
)
12980 tree ctype
= NULL_TREE
;
12983 int doing_friend
= 0;
12984 cp_binding_level
*bl
;
12985 tree current_function_parms
;
12986 struct c_fileinfo
*finfo
12987 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1
)));
12988 bool honor_interface
;
12990 /* Sanity check. */
12991 gcc_assert (VOID_TYPE_P (TREE_VALUE (void_list_node
)));
12992 gcc_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
);
12994 fntype
= TREE_TYPE (decl1
);
12995 if (TREE_CODE (fntype
) == METHOD_TYPE
)
12996 ctype
= TYPE_METHOD_BASETYPE (fntype
);
12998 /* ISO C++ 11.4/5. A friend function defined in a class is in
12999 the (lexical) scope of the class in which it is defined. */
13000 if (!ctype
&& DECL_FRIEND_P (decl1
))
13002 ctype
= DECL_FRIEND_CONTEXT (decl1
);
13004 /* CTYPE could be null here if we're dealing with a template;
13005 for example, `inline friend float foo()' inside a template
13006 will have no CTYPE set. */
13007 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
13013 if (DECL_DECLARED_INLINE_P (decl1
)
13014 && lookup_attribute ("noinline", attrs
))
13015 warning (0, "inline function %q+D given attribute noinline", decl1
);
13017 /* Handle gnu_inline attribute. */
13018 if (GNU_INLINE_P (decl1
))
13020 DECL_EXTERNAL (decl1
) = 1;
13021 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
13022 DECL_INTERFACE_KNOWN (decl1
) = 1;
13023 DECL_DISREGARD_INLINE_LIMITS (decl1
) = 1;
13026 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1
))
13027 /* This is a constructor, we must ensure that any default args
13028 introduced by this definition are propagated to the clones
13029 now. The clones are used directly in overload resolution. */
13030 adjust_clone_args (decl1
);
13032 /* Sometimes we don't notice that a function is a static member, and
13033 build a METHOD_TYPE for it. Fix that up now. */
13034 gcc_assert (!(ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
)
13035 && TREE_CODE (TREE_TYPE (decl1
)) == METHOD_TYPE
));
13037 /* Set up current_class_type, and enter the scope of the class, if
13040 push_nested_class (ctype
);
13041 else if (DECL_STATIC_FUNCTION_P (decl1
))
13042 push_nested_class (DECL_CONTEXT (decl1
));
13044 /* Now that we have entered the scope of the class, we must restore
13045 the bindings for any template parameters surrounding DECL1, if it
13046 is an inline member template. (Order is important; consider the
13047 case where a template parameter has the same name as a field of
13048 the class.) It is not until after this point that
13049 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
13050 if (flags
& SF_INCLASS_INLINE
)
13051 maybe_begin_member_template_processing (decl1
);
13053 /* Effective C++ rule 15. */
13055 && DECL_OVERLOADED_OPERATOR_P (decl1
) == NOP_EXPR
13056 && VOID_TYPE_P (TREE_TYPE (fntype
)))
13057 warning (OPT_Weffc__
, "%<operator=%> should return a reference to %<*this%>");
13059 /* Make the init_value nonzero so pushdecl knows this is not tentative.
13060 error_mark_node is replaced below (in poplevel) with the BLOCK. */
13061 if (!DECL_INITIAL (decl1
))
13062 DECL_INITIAL (decl1
) = error_mark_node
;
13064 /* This function exists in static storage.
13065 (This does not mean `static' in the C sense!) */
13066 TREE_STATIC (decl1
) = 1;
13068 /* We must call push_template_decl after current_class_type is set
13069 up. (If we are processing inline definitions after exiting a
13070 class scope, current_class_type will be NULL_TREE until set above
13071 by push_nested_class.) */
13072 if (processing_template_decl
)
13074 /* FIXME: Handle error_mark_node more gracefully. */
13075 tree newdecl1
= push_template_decl (decl1
);
13076 if (newdecl1
!= error_mark_node
)
13080 /* We are now in the scope of the function being defined. */
13081 current_function_decl
= decl1
;
13083 /* Save the parm names or decls from this function's declarator
13084 where store_parm_decls will find them. */
13085 current_function_parms
= DECL_ARGUMENTS (decl1
);
13087 /* Make sure the parameter and return types are reasonable. When
13088 you declare a function, these types can be incomplete, but they
13089 must be complete when you define the function. */
13090 check_function_type (decl1
, current_function_parms
);
13092 /* Build the return declaration for the function. */
13093 restype
= TREE_TYPE (fntype
);
13095 if (DECL_RESULT (decl1
) == NULL_TREE
)
13099 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
13100 DECL_ARTIFICIAL (resdecl
) = 1;
13101 DECL_IGNORED_P (resdecl
) = 1;
13102 DECL_RESULT (decl1
) = resdecl
;
13104 cp_apply_type_quals_to_decl (cp_type_quals (restype
), resdecl
);
13107 /* Let the user know we're compiling this function. */
13108 announce_function (decl1
);
13110 /* Record the decl so that the function name is defined.
13111 If we already have a decl for this name, and it is a FUNCTION_DECL,
13112 use the old decl. */
13113 if (!processing_template_decl
&& !(flags
& SF_PRE_PARSED
))
13115 /* A specialization is not used to guide overload resolution. */
13116 if (!DECL_FUNCTION_MEMBER_P (decl1
)
13117 && !(DECL_USE_TEMPLATE (decl1
) &&
13118 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1
))))
13120 tree olddecl
= pushdecl (decl1
);
13122 if (olddecl
== error_mark_node
)
13123 /* If something went wrong when registering the declaration,
13124 use DECL1; we have to have a FUNCTION_DECL to use when
13125 parsing the body of the function. */
13129 /* Otherwise, OLDDECL is either a previous declaration
13130 of the same function or DECL1 itself. */
13132 if (warn_missing_declarations
13133 && olddecl
== decl1
13134 && !DECL_MAIN_P (decl1
)
13135 && TREE_PUBLIC (decl1
)
13136 && !DECL_DECLARED_INLINE_P (decl1
))
13140 /* Check whether DECL1 is in an anonymous
13142 for (context
= DECL_CONTEXT (decl1
);
13144 context
= DECL_CONTEXT (context
))
13146 if (TREE_CODE (context
) == NAMESPACE_DECL
13147 && DECL_NAME (context
) == NULL_TREE
)
13151 if (context
== NULL
)
13152 warning (OPT_Wmissing_declarations
,
13153 "no previous declaration for %q+D", decl1
);
13161 /* We need to set the DECL_CONTEXT. */
13162 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
13163 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
13165 fntype
= TREE_TYPE (decl1
);
13166 restype
= TREE_TYPE (fntype
);
13168 /* If #pragma weak applies, mark the decl appropriately now.
13169 The pragma only applies to global functions. Because
13170 determining whether or not the #pragma applies involves
13171 computing the mangled name for the declaration, we cannot
13172 apply the pragma until after we have merged this declaration
13173 with any previous declarations; if the original declaration
13174 has a linkage specification, that specification applies to
13175 the definition as well, and may affect the mangled name. */
13176 if (DECL_FILE_SCOPE_P (decl1
))
13177 maybe_apply_pragma_weak (decl1
);
13180 /* Reset this in case the call to pushdecl changed it. */
13181 current_function_decl
= decl1
;
13183 gcc_assert (DECL_INITIAL (decl1
));
13185 /* This function may already have been parsed, in which case just
13186 return; our caller will skip over the body without parsing. */
13187 if (DECL_INITIAL (decl1
) != error_mark_node
)
13190 /* Initialize RTL machinery. We cannot do this until
13191 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
13192 even when processing a template; this is how we get
13193 CFUN set up, and our per-function variables initialized.
13194 FIXME factor out the non-RTL stuff. */
13195 bl
= current_binding_level
;
13196 allocate_struct_function (decl1
, processing_template_decl
);
13198 /* Initialize the language data structures. Whenever we start
13199 a new function, we destroy temporaries in the usual way. */
13200 cfun
->language
= ggc_alloc_cleared_language_function ();
13201 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
13202 current_binding_level
= bl
;
13204 if (!processing_template_decl
&& type_uses_auto (restype
))
13206 FNDECL_USED_AUTO (decl1
) = true;
13207 current_function_auto_return_pattern
= restype
;
13210 /* Start the statement-tree, start the tree now. */
13211 DECL_SAVED_TREE (decl1
) = push_stmt_list ();
13213 /* If we are (erroneously) defining a function that we have already
13214 defined before, wipe out what we knew before. */
13215 if (!DECL_PENDING_INLINE_P (decl1
))
13216 DECL_SAVED_FUNCTION_DATA (decl1
) = NULL
;
13218 if (ctype
&& !doing_friend
&& !DECL_STATIC_FUNCTION_P (decl1
))
13220 /* We know that this was set up by `grokclassfn'. We do not
13221 wait until `store_parm_decls', since evil parse errors may
13222 never get us to that point. Here we keep the consistency
13223 between `current_class_type' and `current_class_ptr'. */
13224 tree t
= DECL_ARGUMENTS (decl1
);
13226 gcc_assert (t
!= NULL_TREE
&& TREE_CODE (t
) == PARM_DECL
);
13227 gcc_assert (TYPE_PTR_P (TREE_TYPE (t
)));
13229 cp_function_chain
->x_current_class_ref
13230 = cp_build_indirect_ref (t
, RO_NULL
, tf_warning_or_error
);
13231 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
13232 cp_function_chain
->x_current_class_ptr
= t
;
13234 /* Constructors and destructors need to know whether they're "in
13235 charge" of initializing virtual base classes. */
13236 t
= DECL_CHAIN (t
);
13237 if (DECL_HAS_IN_CHARGE_PARM_P (decl1
))
13239 current_in_charge_parm
= t
;
13240 t
= DECL_CHAIN (t
);
13242 if (DECL_HAS_VTT_PARM_P (decl1
))
13244 gcc_assert (DECL_NAME (t
) == vtt_parm_identifier
);
13245 current_vtt_parm
= t
;
13249 honor_interface
= (!DECL_TEMPLATE_INSTANTIATION (decl1
)
13250 /* Implicitly-defined methods (like the
13251 destructor for a class in which no destructor
13252 is explicitly declared) must not be defined
13253 until their definition is needed. So, we
13254 ignore interface specifications for
13255 compiler-generated functions. */
13256 && !DECL_ARTIFICIAL (decl1
));
13258 if (processing_template_decl
)
13259 /* Don't mess with interface flags. */;
13260 else if (DECL_INTERFACE_KNOWN (decl1
))
13262 tree ctx
= decl_function_context (decl1
);
13264 if (DECL_NOT_REALLY_EXTERN (decl1
))
13265 DECL_EXTERNAL (decl1
) = 0;
13267 if (ctx
!= NULL_TREE
&& vague_linkage_p (ctx
))
13268 /* This is a function in a local class in an extern inline
13269 or template function. */
13270 comdat_linkage (decl1
);
13272 /* If this function belongs to an interface, it is public.
13273 If it belongs to someone else's interface, it is also external.
13274 This only affects inlines and template instantiations. */
13275 else if (!finfo
->interface_unknown
&& honor_interface
)
13277 if (DECL_DECLARED_INLINE_P (decl1
)
13278 || DECL_TEMPLATE_INSTANTIATION (decl1
))
13280 DECL_EXTERNAL (decl1
)
13281 = (finfo
->interface_only
13282 || (DECL_DECLARED_INLINE_P (decl1
)
13283 && ! flag_implement_inlines
13284 && !DECL_VINDEX (decl1
)));
13286 /* For WIN32 we also want to put these in linkonce sections. */
13287 maybe_make_one_only (decl1
);
13290 DECL_EXTERNAL (decl1
) = 0;
13291 DECL_INTERFACE_KNOWN (decl1
) = 1;
13292 /* If this function is in an interface implemented in this file,
13293 make sure that the back end knows to emit this function
13295 if (!DECL_EXTERNAL (decl1
))
13296 mark_needed (decl1
);
13298 else if (finfo
->interface_unknown
&& finfo
->interface_only
13299 && honor_interface
)
13301 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
13302 interface, we will have both finfo->interface_unknown and
13303 finfo->interface_only set. In that case, we don't want to
13304 use the normal heuristics because someone will supply a
13305 #pragma implementation elsewhere, and deducing it here would
13306 produce a conflict. */
13307 comdat_linkage (decl1
);
13308 DECL_EXTERNAL (decl1
) = 0;
13309 DECL_INTERFACE_KNOWN (decl1
) = 1;
13310 DECL_DEFER_OUTPUT (decl1
) = 1;
13314 /* This is a definition, not a reference.
13315 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
13316 if (!GNU_INLINE_P (decl1
))
13317 DECL_EXTERNAL (decl1
) = 0;
13319 if ((DECL_DECLARED_INLINE_P (decl1
)
13320 || DECL_TEMPLATE_INSTANTIATION (decl1
))
13321 && ! DECL_INTERFACE_KNOWN (decl1
))
13322 DECL_DEFER_OUTPUT (decl1
) = 1;
13324 DECL_INTERFACE_KNOWN (decl1
) = 1;
13327 /* Determine the ELF visibility attribute for the function. We must not
13328 do this before calling "pushdecl", as we must allow "duplicate_decls"
13329 to merge any attributes appropriately. We also need to wait until
13331 if (!DECL_CLONED_FUNCTION_P (decl1
))
13332 determine_visibility (decl1
);
13334 begin_scope (sk_function_parms
, decl1
);
13338 if (DECL_DESTRUCTOR_P (decl1
)
13339 || (DECL_CONSTRUCTOR_P (decl1
)
13340 && targetm
.cxx
.cdtor_returns_this ()))
13342 cdtor_label
= build_decl (input_location
,
13343 LABEL_DECL
, NULL_TREE
, NULL_TREE
);
13344 DECL_CONTEXT (cdtor_label
) = current_function_decl
;
13347 start_fname_decls ();
13349 store_parm_decls (current_function_parms
);
13353 /* Like start_preparsed_function, except that instead of a
13354 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
13356 Returns 1 on success. If the DECLARATOR is not suitable for a function
13357 (it defines a datum instead), we return 0, which tells
13358 yyparse to report a parse error. */
13361 start_function (cp_decl_specifier_seq
*declspecs
,
13362 const cp_declarator
*declarator
,
13367 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, &attrs
);
13368 if (decl1
== error_mark_node
)
13370 /* If the declarator is not suitable for a function definition,
13371 cause a syntax error. */
13372 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
)
13374 error ("invalid function declaration");
13378 if (DECL_MAIN_P (decl1
))
13379 /* main must return int. grokfndecl should have corrected it
13380 (and issued a diagnostic) if the user got it wrong. */
13381 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1
)),
13382 integer_type_node
));
13384 start_preparsed_function (decl1
, attrs
, /*flags=*/SF_DEFAULT
);
13389 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
13393 use_eh_spec_block (tree fn
)
13395 return (flag_exceptions
&& flag_enforce_eh_specs
13396 && !processing_template_decl
13397 && !type_throw_all_p (TREE_TYPE (fn
))
13398 /* We insert the EH_SPEC_BLOCK only in the original
13399 function; then, it is copied automatically to the
13401 && !DECL_CLONED_FUNCTION_P (fn
)
13402 /* Implicitly-generated constructors and destructors have
13403 exception specifications. However, those specifications
13404 are the union of the possible exceptions specified by the
13405 constructors/destructors for bases and members, so no
13406 unallowed exception will ever reach this function. By
13407 not creating the EH_SPEC_BLOCK we save a little memory,
13408 and we avoid spurious warnings about unreachable
13410 && !DECL_DEFAULTED_FN (fn
));
13413 /* Store the parameter declarations into the current function declaration.
13414 This is called after parsing the parameter declarations, before
13415 digesting the body of the function.
13417 Also install to binding contour return value identifier, if any. */
13420 store_parm_decls (tree current_function_parms
)
13422 tree fndecl
= current_function_decl
;
13425 /* This is a chain of any other decls that came in among the parm
13426 declarations. If a parm is declared with enum {foo, bar} x;
13427 then CONST_DECLs for foo and bar are put here. */
13428 tree nonparms
= NULL_TREE
;
13430 if (current_function_parms
)
13432 /* This case is when the function was defined with an ANSI prototype.
13433 The parms already have decls, so we need not do anything here
13434 except record them as in effect
13435 and complain if any redundant old-style parm decls were written. */
13437 tree specparms
= current_function_parms
;
13440 /* Must clear this because it might contain TYPE_DECLs declared
13442 current_binding_level
->names
= NULL
;
13444 /* If we're doing semantic analysis, then we'll call pushdecl
13445 for each of these. We must do them in reverse order so that
13446 they end in the correct forward order. */
13447 specparms
= nreverse (specparms
);
13449 for (parm
= specparms
; parm
; parm
= next
)
13451 next
= DECL_CHAIN (parm
);
13452 if (TREE_CODE (parm
) == PARM_DECL
)
13454 if (DECL_NAME (parm
) == NULL_TREE
13455 || !VOID_TYPE_P (parm
))
13458 error ("parameter %qD declared void", parm
);
13462 /* If we find an enum constant or a type tag,
13463 put it aside for the moment. */
13464 TREE_CHAIN (parm
) = NULL_TREE
;
13465 nonparms
= chainon (nonparms
, parm
);
13469 /* Get the decls in their original chain order and record in the
13470 function. This is all and only the PARM_DECLs that were
13471 pushed into scope by the loop above. */
13472 DECL_ARGUMENTS (fndecl
) = getdecls ();
13475 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
13477 /* Now store the final chain of decls for the arguments
13478 as the decl-chain of the current lexical scope.
13479 Put the enumerators in as well, at the front so that
13480 DECL_ARGUMENTS is not modified. */
13481 current_binding_level
->names
= chainon (nonparms
, DECL_ARGUMENTS (fndecl
));
13483 if (use_eh_spec_block (current_function_decl
))
13484 current_eh_spec_block
= begin_eh_spec_block ();
13488 /* We have finished doing semantic analysis on DECL, but have not yet
13489 generated RTL for its body. Save away our current state, so that
13490 when we want to generate RTL later we know what to do. */
13493 save_function_data (tree decl
)
13495 struct language_function
*f
;
13497 /* Save the language-specific per-function data so that we can
13498 get it back when we really expand this function. */
13499 gcc_assert (!DECL_PENDING_INLINE_P (decl
));
13502 f
= ggc_alloc_language_function ();
13503 memcpy (f
, cp_function_chain
, sizeof (struct language_function
));
13504 DECL_SAVED_FUNCTION_DATA (decl
) = f
;
13506 /* Clear out the bits we don't need. */
13507 f
->base
.x_stmt_tree
.x_cur_stmt_list
= NULL
;
13508 f
->bindings
= NULL
;
13509 f
->x_local_names
= NULL
;
13510 f
->base
.local_typedefs
= NULL
;
13514 /* Set the return value of the constructor (if present). */
13517 finish_constructor_body (void)
13522 if (targetm
.cxx
.cdtor_returns_this ()
13523 && (! TYPE_FOR_JAVA (current_class_type
)))
13525 /* Any return from a constructor will end up here. */
13526 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
13528 val
= DECL_ARGUMENTS (current_function_decl
);
13529 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
13530 DECL_RESULT (current_function_decl
), val
);
13531 /* Return the address of the object. */
13532 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
13533 add_stmt (exprstmt
);
13537 /* Do all the processing for the beginning of a destructor; set up the
13538 vtable pointers and cleanups for bases and members. */
13541 begin_destructor_body (void)
13543 tree compound_stmt
;
13545 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
13546 issued an error message. We still want to try to process the
13547 body of the function, but initialize_vtbl_ptrs will crash if
13548 TYPE_BINFO is NULL. */
13549 if (COMPLETE_TYPE_P (current_class_type
))
13551 compound_stmt
= begin_compound_stmt (0);
13552 /* Make all virtual function table pointers in non-virtual base
13553 classes point to CURRENT_CLASS_TYPE's virtual function
13555 initialize_vtbl_ptrs (current_class_ptr
);
13556 finish_compound_stmt (compound_stmt
);
13558 /* And insert cleanups for our bases and members so that they
13559 will be properly destroyed if we throw. */
13560 push_base_cleanups ();
13564 /* At the end of every destructor we generate code to delete the object if
13565 necessary. Do that now. */
13568 finish_destructor_body (void)
13572 /* Any return from a destructor will end up here; that way all base
13573 and member cleanups will be run when the function returns. */
13574 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
13576 /* In a virtual destructor, we must call delete. */
13577 if (DECL_VIRTUAL_P (current_function_decl
))
13580 tree virtual_size
= cxx_sizeof (current_class_type
);
13584 At the point of definition of a virtual destructor (including
13585 an implicit definition), non-placement operator delete shall
13586 be looked up in the scope of the destructor's class and if
13587 found shall be accessible and unambiguous. */
13588 exprstmt
= build_op_delete_call (DELETE_EXPR
, current_class_ptr
,
13590 /*global_p=*/false,
13591 /*placement=*/NULL_TREE
,
13592 /*alloc_fn=*/NULL_TREE
,
13593 tf_warning_or_error
);
13595 if_stmt
= begin_if_stmt ();
13596 finish_if_stmt_cond (build2 (BIT_AND_EXPR
, integer_type_node
,
13597 current_in_charge_parm
,
13600 finish_expr_stmt (exprstmt
);
13601 finish_then_clause (if_stmt
);
13602 finish_if_stmt (if_stmt
);
13605 if (targetm
.cxx
.cdtor_returns_this ())
13609 val
= DECL_ARGUMENTS (current_function_decl
);
13610 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
13611 DECL_RESULT (current_function_decl
), val
);
13612 /* Return the address of the object. */
13613 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
13614 add_stmt (exprstmt
);
13618 /* Do the necessary processing for the beginning of a function body, which
13619 in this case includes member-initializers, but not the catch clauses of
13620 a function-try-block. Currently, this means opening a binding level
13621 for the member-initializers (in a ctor), member cleanups (in a dtor),
13622 and capture proxies (in a lambda operator()). */
13625 begin_function_body (void)
13629 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
13632 if (processing_template_decl
)
13633 /* Do nothing now. */;
13635 /* Always keep the BLOCK node associated with the outermost pair of
13636 curly braces of a function. These are needed for correct
13637 operation of dwarfout.c. */
13638 keep_next_level (true);
13640 stmt
= begin_compound_stmt (BCS_FN_BODY
);
13642 if (processing_template_decl
)
13643 /* Do nothing now. */;
13644 else if (DECL_DESTRUCTOR_P (current_function_decl
))
13645 begin_destructor_body ();
13650 /* Do the processing for the end of a function body. Currently, this means
13651 closing out the cleanups for fully-constructed bases and members, and in
13652 the case of the destructor, deleting the object if desired. Again, this
13653 is only meaningful for [cd]tors, since they are the only functions where
13654 there is a significant distinction between the main body and any
13655 function catch clauses. Handling, say, main() return semantics here
13656 would be wrong, as flowing off the end of a function catch clause for
13657 main() would also need to return 0. */
13660 finish_function_body (tree compstmt
)
13662 if (compstmt
== NULL_TREE
)
13665 /* Close the block. */
13666 finish_compound_stmt (compstmt
);
13668 if (processing_template_decl
)
13669 /* Do nothing now. */;
13670 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
13671 finish_constructor_body ();
13672 else if (DECL_DESTRUCTOR_P (current_function_decl
))
13673 finish_destructor_body ();
13676 /* Given a function, returns the BLOCK corresponding to the outermost level
13677 of curly braces, skipping the artificial block created for constructor
13681 outer_curly_brace_block (tree fndecl
)
13683 tree block
= BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl
));
13684 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
13685 /* Skip the artificial function body block. */
13686 block
= BLOCK_SUBBLOCKS (block
);
13690 /* If FNDECL is a class's key method, add the class to the list of
13691 keyed classes that should be emitted. */
13694 record_key_method_defined (tree fndecl
)
13696 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl
)
13697 && DECL_VIRTUAL_P (fndecl
)
13698 && !processing_template_decl
)
13700 tree fnclass
= DECL_CONTEXT (fndecl
);
13701 if (fndecl
== CLASSTYPE_KEY_METHOD (fnclass
))
13702 keyed_classes
= tree_cons (NULL_TREE
, fnclass
, keyed_classes
);
13706 /* Subroutine of finish_function.
13707 Save the body of constexpr functions for possible
13708 future compile time evaluation. */
13711 maybe_save_function_definition (tree fun
)
13713 if (!processing_template_decl
13714 && DECL_DECLARED_CONSTEXPR_P (fun
)
13715 && !DECL_CLONED_FUNCTION_P (fun
))
13716 register_constexpr_fundef (fun
, DECL_SAVED_TREE (fun
));
13719 /* Finish up a function declaration and compile that function
13720 all the way to assembler language output. The free the storage
13721 for the function definition.
13723 FLAGS is a bitwise or of the following values:
13725 We just finished processing the body of an in-class inline
13726 function definition. (This processing will have taken place
13727 after the class definition is complete.) */
13730 finish_function (int flags
)
13732 tree fndecl
= current_function_decl
;
13733 tree fntype
, ctype
= NULL_TREE
;
13734 int inclass_inline
= (flags
& 2) != 0;
13736 /* When we get some parse errors, we can end up without a
13737 current_function_decl, so cope. */
13738 if (fndecl
== NULL_TREE
)
13739 return error_mark_node
;
13741 if (c_dialect_objc ())
13742 objc_finish_function ();
13744 gcc_assert (!defer_mark_used_calls
);
13745 defer_mark_used_calls
= true;
13747 record_key_method_defined (fndecl
);
13749 fntype
= TREE_TYPE (fndecl
);
13751 /* TREE_READONLY (fndecl) = 1;
13752 This caused &foo to be of type ptr-to-const-function
13753 which then got a warning when stored in a ptr-to-function variable. */
13755 gcc_assert (building_stmt_list_p ());
13756 /* The current function is being defined, so its DECL_INITIAL should
13757 be set, and unless there's a multiple definition, it should be
13758 error_mark_node. */
13759 gcc_assert (DECL_INITIAL (fndecl
) == error_mark_node
);
13761 /* For a cloned function, we've already got all the code we need;
13762 there's no need to add any extra bits. */
13763 if (!DECL_CLONED_FUNCTION_P (fndecl
))
13765 /* Make it so that `main' always returns 0 by default. */
13766 if (DECL_MAIN_P (current_function_decl
))
13767 finish_return_stmt (integer_zero_node
);
13769 if (use_eh_spec_block (current_function_decl
))
13770 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
13771 (TREE_TYPE (current_function_decl
)),
13772 current_eh_spec_block
);
13775 /* If we're saving up tree structure, tie off the function now. */
13776 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
13778 finish_fname_decls ();
13780 /* If this function can't throw any exceptions, remember that. */
13781 if (!processing_template_decl
13782 && !cp_function_chain
->can_throw
13783 && !flag_non_call_exceptions
13784 && !decl_replaceable_p (fndecl
))
13785 TREE_NOTHROW (fndecl
) = 1;
13787 /* This must come after expand_function_end because cleanups might
13788 have declarations (from inline functions) that need to go into
13789 this function's blocks. */
13791 /* If the current binding level isn't the outermost binding level
13792 for this function, either there is a bug, or we have experienced
13793 syntax errors and the statement tree is malformed. */
13794 if (current_binding_level
->kind
!= sk_function_parms
)
13796 /* Make sure we have already experienced errors. */
13797 gcc_assert (errorcount
);
13799 /* Throw away the broken statement tree and extra binding
13801 DECL_SAVED_TREE (fndecl
) = alloc_stmt_list ();
13803 while (current_binding_level
->kind
!= sk_function_parms
)
13805 if (current_binding_level
->kind
== sk_class
)
13806 pop_nested_class ();
13808 poplevel (0, 0, 0);
13811 poplevel (1, 0, 1);
13813 /* Statements should always be full-expressions at the outermost set
13814 of curly braces for a function. */
13815 gcc_assert (stmts_are_full_exprs_p ());
13817 /* If there are no return statements in a function with auto return type,
13818 the return type is void. But if the declared type is something like
13819 auto*, this is an error. */
13820 if (!processing_template_decl
&& FNDECL_USED_AUTO (fndecl
)
13821 && TREE_TYPE (fntype
) == current_function_auto_return_pattern
)
13823 if (!is_auto (current_function_auto_return_pattern
)
13824 && !current_function_returns_value
&& !current_function_returns_null
)
13826 error ("no return statements in function returning %qT",
13827 current_function_auto_return_pattern
);
13828 inform (input_location
, "only plain %<auto%> return type can be "
13829 "deduced to %<void%>");
13831 apply_deduced_return_type (fndecl
, void_type_node
);
13832 fntype
= TREE_TYPE (fndecl
);
13835 /* Save constexpr function body before it gets munged by
13836 the NRV transformation. */
13837 maybe_save_function_definition (fndecl
);
13839 /* Set up the named return value optimization, if we can. Candidate
13840 variables are selected in check_return_expr. */
13841 if (current_function_return_value
)
13843 tree r
= current_function_return_value
;
13846 if (r
!= error_mark_node
13847 /* This is only worth doing for fns that return in memory--and
13848 simpler, since we don't have to worry about promoted modes. */
13849 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl
)), fndecl
)
13850 /* Only allow this for variables declared in the outer scope of
13851 the function so we know that their lifetime always ends with a
13852 return; see g++.dg/opt/nrv6.C. We could be more flexible if
13853 we were to do this optimization in tree-ssa. */
13854 && (outer
= outer_curly_brace_block (fndecl
))
13855 && chain_member (r
, BLOCK_VARS (outer
)))
13856 finalize_nrv (&DECL_SAVED_TREE (fndecl
), r
, DECL_RESULT (fndecl
));
13858 current_function_return_value
= NULL_TREE
;
13861 /* Remember that we were in class scope. */
13862 if (current_class_name
)
13863 ctype
= current_class_type
;
13865 /* Must mark the RESULT_DECL as being in this function. */
13866 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
13868 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
13869 to the FUNCTION_DECL node itself. */
13870 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
13872 /* Save away current state, if appropriate. */
13873 if (!processing_template_decl
)
13874 save_function_data (fndecl
);
13876 /* Complain if there's just no return statement. */
13877 if (warn_return_type
13878 && !VOID_TYPE_P (TREE_TYPE (fntype
))
13879 && !dependent_type_p (TREE_TYPE (fntype
))
13880 && !current_function_returns_value
&& !current_function_returns_null
13881 /* Don't complain if we abort or throw. */
13882 && !current_function_returns_abnormally
13883 /* Don't complain if we are declared noreturn. */
13884 && !TREE_THIS_VOLATILE (fndecl
)
13885 && !DECL_NAME (DECL_RESULT (fndecl
))
13886 && !TREE_NO_WARNING (fndecl
)
13887 /* Structor return values (if any) are set by the compiler. */
13888 && !DECL_CONSTRUCTOR_P (fndecl
)
13889 && !DECL_DESTRUCTOR_P (fndecl
)
13890 && targetm
.warn_func_return (fndecl
))
13892 warning (OPT_Wreturn_type
,
13893 "no return statement in function returning non-void");
13894 TREE_NO_WARNING (fndecl
) = 1;
13897 /* Store the end of the function, so that we get good line number
13898 info for the epilogue. */
13899 cfun
->function_end_locus
= input_location
;
13901 /* Complain about parameters that are only set, but never otherwise used. */
13902 if (warn_unused_but_set_parameter
13903 && !processing_template_decl
13904 && errorcount
== unused_but_set_errorcount
13905 && !DECL_CLONED_FUNCTION_P (fndecl
))
13909 for (decl
= DECL_ARGUMENTS (fndecl
);
13911 decl
= DECL_CHAIN (decl
))
13912 if (TREE_USED (decl
)
13913 && TREE_CODE (decl
) == PARM_DECL
13914 && !DECL_READ_P (decl
)
13915 && DECL_NAME (decl
)
13916 && !DECL_ARTIFICIAL (decl
)
13917 && !TREE_NO_WARNING (decl
)
13918 && !DECL_IN_SYSTEM_HEADER (decl
)
13919 && TREE_TYPE (decl
) != error_mark_node
13920 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
13921 && (!CLASS_TYPE_P (TREE_TYPE (decl
))
13922 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
))))
13923 warning (OPT_Wunused_but_set_parameter
,
13924 "parameter %q+D set but not used", decl
);
13925 unused_but_set_errorcount
= errorcount
;
13928 /* Complain about locally defined typedefs that are not used in this
13930 maybe_warn_unused_local_typedefs ();
13932 /* Genericize before inlining. */
13933 if (!processing_template_decl
)
13935 struct language_function
*f
= DECL_SAVED_FUNCTION_DATA (fndecl
);
13936 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE
, fndecl
);
13937 cp_genericize (fndecl
);
13938 /* Clear out the bits we don't need. */
13939 f
->x_current_class_ptr
= NULL
;
13940 f
->x_current_class_ref
= NULL
;
13941 f
->x_eh_spec_block
= NULL
;
13942 f
->x_in_charge_parm
= NULL
;
13943 f
->x_vtt_parm
= NULL
;
13944 f
->x_return_value
= NULL
;
13945 f
->bindings
= NULL
;
13946 f
->extern_decl_map
= NULL
;
13948 /* Clear out the bits we don't need. */
13949 local_names
= NULL
;
13951 /* We're leaving the context of this function, so zap cfun. It's still in
13952 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
13954 current_function_decl
= NULL
;
13956 /* If this is an in-class inline definition, we may have to pop the
13957 bindings for the template parameters that we added in
13958 maybe_begin_member_template_processing when start_function was
13960 if (inclass_inline
)
13961 maybe_end_member_template_processing ();
13963 /* Leave the scope of the class. */
13965 pop_nested_class ();
13970 current_function_decl
= NULL_TREE
;
13972 defer_mark_used_calls
= false;
13973 if (deferred_mark_used_calls
)
13978 FOR_EACH_VEC_SAFE_ELT (deferred_mark_used_calls
, i
, decl
)
13980 vec_free (deferred_mark_used_calls
);
13986 /* Create the FUNCTION_DECL for a function definition.
13987 DECLSPECS and DECLARATOR are the parts of the declaration;
13988 they describe the return type and the name of the function,
13989 but twisted together in a fashion that parallels the syntax of C.
13991 This function creates a binding context for the function body
13992 as well as setting up the FUNCTION_DECL in current_function_decl.
13994 Returns a FUNCTION_DECL on success.
13996 If the DECLARATOR is not suitable for a function (it defines a datum
13997 instead), we return 0, which tells yyparse to report a parse error.
13999 May return void_type_node indicating that this method is actually
14000 a friend. See grokfield for more details.
14002 Came here with a `.pushlevel' .
14004 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
14005 CHANGES TO CODE IN `grokfield'. */
14008 grokmethod (cp_decl_specifier_seq
*declspecs
,
14009 const cp_declarator
*declarator
, tree attrlist
)
14011 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
14014 if (fndecl
== error_mark_node
)
14015 return error_mark_node
;
14017 if (fndecl
== NULL
|| TREE_CODE (fndecl
) != FUNCTION_DECL
)
14019 error ("invalid member function declaration");
14020 return error_mark_node
;
14024 cplus_decl_attributes (&fndecl
, attrlist
, 0);
14026 /* Pass friends other than inline friend functions back. */
14027 if (fndecl
== void_type_node
)
14030 if (DECL_IN_AGGR_P (fndecl
))
14032 if (DECL_CLASS_SCOPE_P (fndecl
))
14033 error ("%qD is already defined in class %qT", fndecl
,
14034 DECL_CONTEXT (fndecl
));
14035 return error_mark_node
;
14038 check_template_shadow (fndecl
);
14040 DECL_DECLARED_INLINE_P (fndecl
) = 1;
14041 DECL_NO_INLINE_WARNING_P (fndecl
) = 1;
14043 /* We process method specializations in finish_struct_1. */
14044 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
14046 fndecl
= push_template_decl (fndecl
);
14047 if (fndecl
== error_mark_node
)
14051 if (! DECL_FRIEND_P (fndecl
))
14053 if (DECL_CHAIN (fndecl
))
14055 fndecl
= copy_node (fndecl
);
14056 TREE_CHAIN (fndecl
) = NULL_TREE
;
14060 cp_finish_decl (fndecl
, NULL_TREE
, false, NULL_TREE
, 0);
14062 DECL_IN_AGGR_P (fndecl
) = 1;
14067 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
14068 we can lay it out later, when and if its type becomes complete.
14070 Also handle constexpr pointer to member variables where the initializer
14071 is an unlowered PTRMEM_CST because the class isn't complete yet. */
14074 maybe_register_incomplete_var (tree var
)
14076 gcc_assert (VAR_P (var
));
14078 /* Keep track of variables with incomplete types. */
14079 if (!processing_template_decl
&& TREE_TYPE (var
) != error_mark_node
14080 && DECL_EXTERNAL (var
))
14082 tree inner_type
= TREE_TYPE (var
);
14084 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
14085 inner_type
= TREE_TYPE (inner_type
);
14086 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
14088 if ((!COMPLETE_TYPE_P (inner_type
) && CLASS_TYPE_P (inner_type
))
14089 /* RTTI TD entries are created while defining the type_info. */
14090 || (TYPE_LANG_SPECIFIC (inner_type
)
14091 && TYPE_BEING_DEFINED (inner_type
)))
14093 incomplete_var iv
= {var
, inner_type
};
14094 vec_safe_push (incomplete_vars
, iv
);
14096 else if (TYPE_PTRMEM_P (inner_type
)
14097 && DECL_INITIAL (var
)
14098 && TREE_CODE (DECL_INITIAL (var
)) == PTRMEM_CST
)
14100 tree context
= TYPE_PTRMEM_CLASS_TYPE (inner_type
);
14101 gcc_assert (TYPE_BEING_DEFINED (context
));
14102 incomplete_var iv
= {var
, context
};
14103 vec_safe_push (incomplete_vars
, iv
);
14108 /* Called when a class type (given by TYPE) is defined. If there are
14109 any existing VAR_DECLs whose type has been completed by this
14110 declaration, update them now. */
14113 complete_vars (tree type
)
14116 incomplete_var
*iv
;
14118 for (ix
= 0; vec_safe_iterate (incomplete_vars
, ix
, &iv
); )
14120 if (same_type_p (type
, iv
->incomplete_type
))
14122 tree var
= iv
->decl
;
14123 tree type
= TREE_TYPE (var
);
14125 if (TYPE_PTRMEM_P (type
))
14126 DECL_INITIAL (var
) = cplus_expand_constant (DECL_INITIAL (var
));
14129 /* Complete the type of the variable. The VAR_DECL itself
14130 will be laid out in expand_expr. */
14131 complete_type (type
);
14132 cp_apply_type_quals_to_decl (cp_type_quals (type
), var
);
14135 /* Remove this entry from the list. */
14136 incomplete_vars
->unordered_remove (ix
);
14142 /* Check for pending declarations which may have abstract type. */
14143 complete_type_check_abstract (type
);
14146 /* If DECL is of a type which needs a cleanup, build and return an
14147 expression to perform that cleanup here. Return NULL_TREE if no
14148 cleanup need be done. */
14151 cxx_maybe_build_cleanup (tree decl
, tsubst_flags_t complain
)
14157 /* Assume no cleanup is required. */
14158 cleanup
= NULL_TREE
;
14160 if (error_operand_p (decl
))
14163 /* Handle "__attribute__((cleanup))". We run the cleanup function
14164 before the destructor since the destructor is what actually
14165 terminates the lifetime of the object. */
14166 attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
14173 /* Get the name specified by the user for the cleanup function. */
14174 id
= TREE_VALUE (TREE_VALUE (attr
));
14175 /* Look up the name to find the cleanup function to call. It is
14176 important to use lookup_name here because that is what is
14177 used in c-common.c:handle_cleanup_attribute when performing
14178 initial checks on the attribute. Note that those checks
14179 include ensuring that the function found is not an overloaded
14180 function, or an object with an overloaded call operator,
14181 etc.; we can rely on the fact that the function found is an
14182 ordinary FUNCTION_DECL. */
14183 fn
= lookup_name (id
);
14184 arg
= build_address (decl
);
14186 cleanup
= cp_build_function_call_nary (fn
, complain
, arg
, NULL_TREE
);
14187 if (cleanup
== error_mark_node
)
14188 return error_mark_node
;
14190 /* Handle ordinary C++ destructors. */
14191 type
= TREE_TYPE (decl
);
14192 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
14194 int flags
= LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
;
14195 bool has_vbases
= (TREE_CODE (type
) == RECORD_TYPE
14196 && CLASSTYPE_VBASECLASSES (type
));
14200 if (TREE_CODE (type
) == ARRAY_TYPE
)
14203 addr
= build_address (decl
);
14205 /* Optimize for space over speed here. */
14206 if (!has_vbases
|| flag_expensive_optimizations
)
14207 flags
|= LOOKUP_NONVIRTUAL
;
14209 call
= build_delete (TREE_TYPE (addr
), addr
,
14210 sfk_complete_destructor
, flags
, 0, complain
);
14211 if (call
== error_mark_node
)
14212 cleanup
= error_mark_node
;
14214 cleanup
= cp_build_compound_expr (cleanup
, call
, complain
);
14219 /* build_delete sets the location of the destructor call to the
14220 current location, even though the destructor is going to be
14221 called later, at the end of the current scope. This can lead to
14222 a "jumpy" behaviour for users of debuggers when they step around
14223 the end of the block. So let's unset the location of the
14224 destructor call instead. */
14225 if (cleanup
!= NULL
&& EXPR_P (cleanup
))
14226 SET_EXPR_LOCATION (cleanup
, UNKNOWN_LOCATION
);
14231 /* When a stmt has been parsed, this function is called. */
14238 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
14239 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
14240 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
14243 static_fn_type (tree memfntype
)
14248 if (TYPE_PTRMEMFUNC_P (memfntype
))
14249 memfntype
= TYPE_PTRMEMFUNC_FN_TYPE (memfntype
);
14250 if (POINTER_TYPE_P (memfntype
)
14251 || TREE_CODE (memfntype
) == FUNCTION_DECL
)
14252 memfntype
= TREE_TYPE (memfntype
);
14253 if (TREE_CODE (memfntype
) == FUNCTION_TYPE
)
14255 gcc_assert (TREE_CODE (memfntype
) == METHOD_TYPE
);
14256 args
= TYPE_ARG_TYPES (memfntype
);
14257 cp_ref_qualifier rqual
= type_memfn_rqual (memfntype
);
14258 fntype
= build_function_type (TREE_TYPE (memfntype
), TREE_CHAIN (args
));
14259 fntype
= apply_memfn_quals (fntype
, type_memfn_quals (memfntype
), rqual
);
14260 fntype
= (cp_build_type_attribute_variant
14261 (fntype
, TYPE_ATTRIBUTES (memfntype
)));
14262 fntype
= (build_exception_variant
14263 (fntype
, TYPE_RAISES_EXCEPTIONS (memfntype
)));
14267 /* DECL was originally constructed as a non-static member function,
14268 but turned out to be static. Update it accordingly. */
14271 revert_static_member_fn (tree decl
)
14273 tree stype
= static_fn_type (decl
);
14274 cp_cv_quals quals
= type_memfn_quals (stype
);
14275 cp_ref_qualifier rqual
= type_memfn_rqual (stype
);
14277 if (quals
!= TYPE_UNQUALIFIED
|| rqual
!= REF_QUAL_NONE
)
14278 stype
= apply_memfn_quals (stype
, TYPE_UNQUALIFIED
, REF_QUAL_NONE
);
14280 TREE_TYPE (decl
) = stype
;
14282 if (DECL_ARGUMENTS (decl
))
14283 DECL_ARGUMENTS (decl
) = DECL_CHAIN (DECL_ARGUMENTS (decl
));
14284 DECL_STATIC_FUNCTION_P (decl
) = 1;
14287 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
14288 one of the language-independent trees. */
14290 enum cp_tree_node_structure_enum
14291 cp_tree_node_structure (union lang_tree_node
* t
)
14293 switch (TREE_CODE (&t
->generic
))
14295 case DEFAULT_ARG
: return TS_CP_DEFAULT_ARG
;
14296 case DEFERRED_NOEXCEPT
: return TS_CP_DEFERRED_NOEXCEPT
;
14297 case IDENTIFIER_NODE
: return TS_CP_IDENTIFIER
;
14298 case OVERLOAD
: return TS_CP_OVERLOAD
;
14299 case TEMPLATE_PARM_INDEX
: return TS_CP_TPI
;
14300 case PTRMEM_CST
: return TS_CP_PTRMEM
;
14301 case BASELINK
: return TS_CP_BASELINK
;
14302 case STATIC_ASSERT
: return TS_CP_STATIC_ASSERT
;
14303 case ARGUMENT_PACK_SELECT
: return TS_CP_ARGUMENT_PACK_SELECT
;
14304 case TRAIT_EXPR
: return TS_CP_TRAIT_EXPR
;
14305 case LAMBDA_EXPR
: return TS_CP_LAMBDA_EXPR
;
14306 case TEMPLATE_INFO
: return TS_CP_TEMPLATE_INFO
;
14307 case USERDEF_LITERAL
: return TS_CP_USERDEF_LITERAL
;
14308 default: return TS_CP_GENERIC
;
14312 /* Build the void_list_node (void_type_node having been created). */
14314 build_void_list_node (void)
14316 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
14321 cp_missing_noreturn_ok_p (tree decl
)
14323 /* A missing noreturn is ok for the `main' function. */
14324 return DECL_MAIN_P (decl
);
14327 /* Return the COMDAT group into which DECL should be placed. */
14330 cxx_comdat_group (tree decl
)
14334 /* Virtual tables, construction virtual tables, and virtual table
14335 tables all go in a single COMDAT group, named after the primary
14337 if (VAR_P (decl
) && DECL_VTABLE_OR_VTT_P (decl
))
14338 name
= DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl
)));
14339 /* For all other DECLs, the COMDAT group is the mangled name of the
14340 declaration itself. */
14343 while (DECL_THUNK_P (decl
))
14345 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
14346 into the same section as the target function. In that case
14347 we must return target's name. */
14348 tree target
= THUNK_TARGET (decl
);
14349 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target
)
14350 && DECL_SECTION_NAME (target
) != NULL
14351 && DECL_ONE_ONLY (target
))
14356 name
= DECL_ASSEMBLER_NAME (decl
);
14362 #include "gt-cp-decl.h"