1 /* Process declarations and variables for C++ compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
5 Contributed by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
24 /* Process declarations and symbol lookup for C++ front end.
25 Also constructs types; the standard scalar types at initialization,
26 and structure, union, array and enum types when they are declared. */
28 /* ??? not all decl nodes are given the most useful possible
29 line numbers. For example, the CONST_DECLs for enum values. */
33 #include "coretypes.h"
40 #include "tree-inline.h"
51 #include "diagnostic.h"
55 #include "tree-flow.h"
56 #include "pointer-set.h"
59 static tree
grokparms (tree parmlist
, tree
*);
60 static const char *redeclaration_error_message (tree
, tree
);
62 static int decl_jump_unsafe (tree
);
63 static void require_complete_types_for_parms (tree
);
64 static int ambi_op_p (enum tree_code
);
65 static int unary_op_p (enum tree_code
);
66 static void push_local_name (tree
);
67 static tree
grok_reference_init (tree
, tree
, tree
, tree
*);
68 static tree
grokvardecl (tree
, tree
, const cp_decl_specifier_seq
*,
70 static void record_unknown_type (tree
, const char *);
71 static tree
builtin_function_1 (tree
, tree
, bool);
72 static tree
build_library_fn_1 (tree
, enum tree_code
, tree
);
73 static int member_function_or_else (tree
, tree
, enum overload_flags
);
74 static void bad_specifiers (tree
, const char *, int, int, int, int,
76 static void check_for_uninitialized_const_var (tree
);
77 static hashval_t
typename_hash (const void *);
78 static int typename_compare (const void *, const void *);
79 static tree
local_variable_p_walkfn (tree
*, int *, void *);
80 static tree
record_builtin_java_type (const char *, int);
81 static const char *tag_name (enum tag_types
);
82 static tree
lookup_and_check_tag (enum tag_types
, tree
, tag_scope
, bool);
83 static int walk_namespaces_r (tree
, walk_namespaces_fn
, void *);
84 static void maybe_deduce_size_from_array_init (tree
, tree
);
85 static void layout_var_decl (tree
);
86 static tree
check_initializer (tree
, tree
, int, tree
*);
87 static void make_rtl_for_nonlocal_decl (tree
, tree
, const char *);
88 static void save_function_data (tree
);
89 static bool check_function_type (tree
, tree
);
90 static void finish_constructor_body (void);
91 static void begin_destructor_body (void);
92 static void finish_destructor_body (void);
93 static tree
create_array_type_for_decl (tree
, tree
, tree
);
94 static tree
get_atexit_node (void);
95 static tree
get_dso_handle_node (void);
96 static tree
start_cleanup_fn (void);
97 static void end_cleanup_fn (void);
98 static tree
cp_make_fname_decl (location_t
, tree
, int);
99 static void initialize_predefined_identifiers (void);
100 static tree check_special_function_return_type
101 (special_function_kind
, tree
, tree
);
102 static tree
push_cp_library_fn (enum tree_code
, tree
);
103 static tree
build_cp_library_fn (tree
, enum tree_code
, tree
);
104 static void store_parm_decls (tree
);
105 static void initialize_local_var (tree
, tree
);
106 static void expand_static_init (tree
, tree
);
108 /* The following symbols are subsumed in the cp_global_trees array, and
109 listed here individually for documentation purposes.
112 tree wchar_decl_node;
114 tree vtable_entry_type;
115 tree delta_type_node;
116 tree __t_desc_type_node;
118 tree class_type_node;
119 tree unknown_type_node;
121 Array type `vtable_entry_type[]'
124 tree vtbl_ptr_type_node;
131 A FUNCTION_DECL which can call `abort'. Not necessarily the
132 one that the user will declare, but sufficient to be called
133 by routines that want to abort the program.
137 The FUNCTION_DECL for the default `::operator delete'.
139 tree global_delete_fndecl;
142 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
143 tree tinfo_var_id; */
145 tree cp_global_trees
[CPTI_MAX
];
147 /* Indicates that there is a type value in some namespace, although
148 that is not necessarily in scope at the moment. */
150 tree global_type_node
;
152 /* The node that holds the "name" of the global scope. */
153 tree global_scope_name
;
155 #define local_names cp_function_chain->x_local_names
157 /* A list of objects which have constructors or destructors
158 which reside in the global scope. The decl is stored in
159 the TREE_VALUE slot and the initializer is stored
160 in the TREE_PURPOSE slot. */
161 tree static_aggregates
;
165 /* A node for the integer constants 2, and 3. */
167 tree integer_two_node
, integer_three_node
;
169 /* Used only for jumps to as-yet undefined labels, since jumps to
170 defined labels can have their validity checked immediately. */
172 struct GTY(()) named_label_use_entry
{
173 struct named_label_use_entry
*next
;
174 /* The binding level to which this entry is *currently* attached.
175 This is initially the binding level in which the goto appeared,
176 but is modified as scopes are closed. */
177 struct cp_binding_level
*binding_level
;
178 /* The head of the names list that was current when the goto appeared,
179 or the inner scope popped. These are the decls that will *not* be
180 skipped when jumping to the label. */
182 /* The location of the goto, for error reporting. */
183 location_t o_goto_locus
;
184 /* True if an OpenMP structured block scope has been closed since
185 the goto appeared. This means that the branch from the label will
186 illegally exit an OpenMP scope. */
190 /* A list of all LABEL_DECLs in the function that have names. Here so
191 we can clear out their names' definitions at the end of the
192 function, and so we can check the validity of jumps to these labels. */
194 struct GTY(()) named_label_entry
{
195 /* The decl itself. */
198 /* The binding level to which the label is *currently* attached.
199 This is initially set to the binding level in which the label
200 is defined, but is modified as scopes are closed. */
201 struct cp_binding_level
*binding_level
;
202 /* The head of the names list that was current when the label was
203 defined, or the inner scope popped. These are the decls that will
204 be skipped when jumping to the label. */
206 /* A tree list of all decls from all binding levels that would be
207 crossed by a backward branch to the label. */
210 /* A list of uses of the label, before the label is defined. */
211 struct named_label_use_entry
*uses
;
213 /* The following bits are set after the label is defined, and are
214 updated as scopes are popped. They indicate that a backward jump
215 to the label will illegally enter a scope of the given flavor. */
221 #define named_labels cp_function_chain->x_named_labels
223 /* The number of function bodies which we are currently processing.
224 (Zero if we are at namespace scope, one inside the body of a
225 function, two inside the body of a function in a local class, etc.) */
228 /* To avoid unwanted recursion, finish_function defers all mark_used calls
229 encountered during its execution until it finishes. */
230 bool defer_mark_used_calls
;
231 VEC(tree
, gc
) *deferred_mark_used_calls
;
233 /* States indicating how grokdeclarator() should handle declspecs marked
234 with __attribute__((deprecated)). An object declared as
235 __attribute__((deprecated)) suppresses warnings of uses of other
237 enum deprecated_states deprecated_state
= DEPRECATED_NORMAL
;
240 /* A TREE_LIST of VAR_DECLs. The TREE_PURPOSE is a RECORD_TYPE or
241 UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type. At the
242 time the VAR_DECL was declared, the type was incomplete. */
244 static GTY(()) tree incomplete_vars
;
246 /* Returns the kind of template specialization we are currently
247 processing, given that it's declaration contained N_CLASS_SCOPES
248 explicit scope qualifications. */
251 current_tmpl_spec_kind (int n_class_scopes
)
253 int n_template_parm_scopes
= 0;
254 int seen_specialization_p
= 0;
255 int innermost_specialization_p
= 0;
256 struct cp_binding_level
*b
;
258 /* Scan through the template parameter scopes. */
259 for (b
= current_binding_level
;
260 b
->kind
== sk_template_parms
;
263 /* If we see a specialization scope inside a parameter scope,
264 then something is wrong. That corresponds to a declaration
267 template <class T> template <> ...
269 which is always invalid since [temp.expl.spec] forbids the
270 specialization of a class member template if the enclosing
271 class templates are not explicitly specialized as well. */
272 if (b
->explicit_spec_p
)
274 if (n_template_parm_scopes
== 0)
275 innermost_specialization_p
= 1;
277 seen_specialization_p
= 1;
279 else if (seen_specialization_p
== 1)
280 return tsk_invalid_member_spec
;
282 ++n_template_parm_scopes
;
285 /* Handle explicit instantiations. */
286 if (processing_explicit_instantiation
)
288 if (n_template_parm_scopes
!= 0)
289 /* We've seen a template parameter list during an explicit
290 instantiation. For example:
292 template <class T> template void f(int);
294 This is erroneous. */
295 return tsk_invalid_expl_inst
;
297 return tsk_expl_inst
;
300 if (n_template_parm_scopes
< n_class_scopes
)
301 /* We've not seen enough template headers to match all the
302 specialized classes present. For example:
304 template <class T> void R<T>::S<T>::f(int);
306 This is invalid; there needs to be one set of template
307 parameters for each class. */
308 return tsk_insufficient_parms
;
309 else if (n_template_parm_scopes
== n_class_scopes
)
310 /* We're processing a non-template declaration (even though it may
311 be a member of a template class.) For example:
313 template <class T> void S<T>::f(int);
315 The `class T' matches the `S<T>', leaving no template headers
316 corresponding to the `f'. */
318 else if (n_template_parm_scopes
> n_class_scopes
+ 1)
319 /* We've got too many template headers. For example:
321 template <> template <class T> void f (T);
323 There need to be more enclosing classes. */
324 return tsk_excessive_parms
;
326 /* This must be a template. It's of the form:
328 template <class T> template <class U> void S<T>::f(U);
330 This is a specialization if the innermost level was a
331 specialization; otherwise it's just a definition of the
333 return innermost_specialization_p
? tsk_expl_spec
: tsk_template
;
336 /* Exit the current scope. */
344 /* When a label goes out of scope, check to see if that label was used
345 in a valid manner, and issue any appropriate warnings or errors. */
348 pop_label (tree label
, tree old_value
)
350 if (!processing_template_decl
)
352 if (DECL_INITIAL (label
) == NULL_TREE
)
356 error ("label %q+D used but not defined", label
);
357 location
= input_location
; /* FIXME want (input_filename, (line)0) */
358 /* Avoid crashing later. */
359 define_label (location
, DECL_NAME (label
));
362 warn_for_unused_label (label
);
365 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label
), old_value
);
368 /* At the end of a function, all labels declared within the function
369 go out of scope. BLOCK is the top-level block for the
373 pop_labels_1 (void **slot
, void *data
)
375 struct named_label_entry
*ent
= (struct named_label_entry
*) *slot
;
376 tree block
= (tree
) data
;
378 pop_label (ent
->label_decl
, NULL_TREE
);
380 /* Put the labels into the "variables" of the top-level block,
381 so debugger can see them. */
382 TREE_CHAIN (ent
->label_decl
) = BLOCK_VARS (block
);
383 BLOCK_VARS (block
) = ent
->label_decl
;
385 htab_clear_slot (named_labels
, slot
);
391 pop_labels (tree block
)
395 htab_traverse (named_labels
, pop_labels_1
, block
);
400 /* At the end of a block with local labels, restore the outer definition. */
403 pop_local_label (tree label
, tree old_value
)
405 struct named_label_entry dummy
;
408 pop_label (label
, old_value
);
410 dummy
.label_decl
= label
;
411 slot
= htab_find_slot (named_labels
, &dummy
, NO_INSERT
);
412 htab_clear_slot (named_labels
, slot
);
415 /* The following two routines are used to interface to Objective-C++.
416 The binding level is purposely treated as an opaque type. */
419 objc_get_current_scope (void)
421 return current_binding_level
;
424 /* The following routine is used by the NeXT-style SJLJ exceptions;
425 variables get marked 'volatile' so as to not be clobbered by
426 _setjmp()/_longjmp() calls. All variables in the current scope,
427 as well as parent scopes up to (but not including) ENCLOSING_BLK
428 shall be thusly marked. */
431 objc_mark_locals_volatile (void *enclosing_blk
)
433 struct cp_binding_level
*scope
;
435 for (scope
= current_binding_level
;
436 scope
&& scope
!= enclosing_blk
;
437 scope
= scope
->level_chain
)
441 for (decl
= scope
->names
; decl
; decl
= TREE_CHAIN (decl
))
442 objc_volatilize_decl (decl
);
444 /* Do not climb up past the current function. */
445 if (scope
->kind
== sk_function_parms
)
450 /* Update data for defined and undefined labels when leaving a scope. */
453 poplevel_named_label_1 (void **slot
, void *data
)
455 struct named_label_entry
*ent
= (struct named_label_entry
*) *slot
;
456 struct cp_binding_level
*bl
= (struct cp_binding_level
*) data
;
457 struct cp_binding_level
*obl
= bl
->level_chain
;
459 if (ent
->binding_level
== bl
)
463 for (decl
= ent
->names_in_scope
; decl
; decl
= TREE_CHAIN (decl
))
464 if (decl_jump_unsafe (decl
))
465 ent
->bad_decls
= tree_cons (NULL
, decl
, ent
->bad_decls
);
467 ent
->binding_level
= obl
;
468 ent
->names_in_scope
= obl
->names
;
472 ent
->in_try_scope
= true;
475 ent
->in_catch_scope
= true;
478 ent
->in_omp_scope
= true;
486 struct named_label_use_entry
*use
;
488 for (use
= ent
->uses
; use
; use
= use
->next
)
489 if (use
->binding_level
== bl
)
491 use
->binding_level
= obl
;
492 use
->names_in_scope
= obl
->names
;
493 if (bl
->kind
== sk_omp
)
494 use
->in_omp_scope
= true;
501 /* Exit a binding level.
502 Pop the level off, and restore the state of the identifier-decl mappings
503 that were in effect when this level was entered.
505 If KEEP == 1, this level had explicit declarations, so
506 and create a "block" (a BLOCK node) for the level
507 to record its declarations and subblocks for symbol table output.
509 If FUNCTIONBODY is nonzero, this level is the body of a function,
510 so create a block as if KEEP were set and also clear out all
513 If REVERSE is nonzero, reverse the order of decls before putting
514 them into the BLOCK. */
517 poplevel (int keep
, int reverse
, int functionbody
)
520 /* The chain of decls was accumulated in reverse order.
521 Put it into forward order, just for cleanliness. */
526 int leaving_for_scope
;
529 timevar_push (TV_NAME_LOOKUP
);
534 gcc_assert (current_binding_level
->kind
!= sk_class
);
536 if (current_binding_level
->kind
== sk_cleanup
)
538 subblocks
= functionbody
>= 0 ? current_binding_level
->blocks
: 0;
540 gcc_assert (!VEC_length(cp_class_binding
,
541 current_binding_level
->class_shadowed
));
543 /* We used to use KEEP == 2 to indicate that the new block should go
544 at the beginning of the list of blocks at this binding level,
545 rather than the end. This hack is no longer used. */
546 gcc_assert (keep
== 0 || keep
== 1);
548 if (current_binding_level
->keep
)
551 /* Any uses of undefined labels, and any defined labels, now operate
552 under constraints of next binding contour. */
553 if (cfun
&& !functionbody
&& named_labels
)
554 htab_traverse (named_labels
, poplevel_named_label_1
,
555 current_binding_level
);
557 /* Get the decls in the order they were written.
558 Usually current_binding_level->names is in reverse order.
559 But parameter decls were previously put in forward order. */
562 current_binding_level
->names
563 = decls
= nreverse (current_binding_level
->names
);
565 decls
= current_binding_level
->names
;
567 /* If there were any declarations or structure tags in that level,
568 or if this level is a function body,
569 create a BLOCK to record them for the life of this function. */
571 if (keep
== 1 || functionbody
)
572 block
= make_node (BLOCK
);
573 if (block
!= NULL_TREE
)
575 BLOCK_VARS (block
) = decls
;
576 BLOCK_SUBBLOCKS (block
) = subblocks
;
579 /* In each subblock, record that this is its superior. */
581 for (link
= subblocks
; link
; link
= BLOCK_CHAIN (link
))
582 BLOCK_SUPERCONTEXT (link
) = block
;
584 /* We still support the old for-scope rules, whereby the variables
585 in a for-init statement were in scope after the for-statement
586 ended. We only use the new rules if flag_new_for_scope is
589 = current_binding_level
->kind
== sk_for
&& flag_new_for_scope
== 1;
591 /* Before we remove the declarations first check for unused variables. */
592 if (warn_unused_variable
593 && !processing_template_decl
)
594 for (decl
= getdecls (); decl
; decl
= TREE_CHAIN (decl
))
595 if (TREE_CODE (decl
) == VAR_DECL
596 && ! TREE_USED (decl
)
597 && ! DECL_IN_SYSTEM_HEADER (decl
)
598 && DECL_NAME (decl
) && ! DECL_ARTIFICIAL (decl
))
599 warning (OPT_Wunused_variable
, "unused variable %q+D", decl
);
601 /* Remove declarations for all the DECLs in this level. */
602 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
604 if (leaving_for_scope
&& TREE_CODE (link
) == VAR_DECL
607 tree name
= DECL_NAME (link
);
611 ob
= outer_binding (name
,
612 IDENTIFIER_BINDING (name
),
615 ns_binding
= IDENTIFIER_NAMESPACE_VALUE (name
);
617 ns_binding
= NULL_TREE
;
619 if (ob
&& ob
->scope
== current_binding_level
->level_chain
)
620 /* We have something like:
625 and we are leaving the `for' scope. There's no reason to
626 keep the binding of the inner `i' in this case. */
627 pop_binding (name
, link
);
628 else if ((ob
&& (TREE_CODE (ob
->value
) == TYPE_DECL
))
629 || (ns_binding
&& TREE_CODE (ns_binding
) == TYPE_DECL
))
630 /* Here, we have something like:
638 We must pop the for-scope binding so we know what's a
639 type and what isn't. */
640 pop_binding (name
, link
);
643 /* Mark this VAR_DECL as dead so that we can tell we left it
644 there only for backward compatibility. */
645 DECL_DEAD_FOR_LOCAL (link
) = 1;
647 /* Keep track of what should have happened when we
648 popped the binding. */
651 SET_DECL_SHADOWED_FOR_VAR (link
, ob
->value
);
652 DECL_HAS_SHADOWED_FOR_VAR_P (link
) = 1;
655 /* Add it to the list of dead variables in the next
656 outermost binding to that we can remove these when we
657 leave that binding. */
658 current_binding_level
->level_chain
->dead_vars_from_for
659 = tree_cons (NULL_TREE
, link
,
660 current_binding_level
->level_chain
->
663 /* Although we don't pop the cxx_binding, we do clear
664 its SCOPE since the scope is going away now. */
665 IDENTIFIER_BINDING (name
)->scope
666 = current_binding_level
->level_chain
;
673 /* Remove the binding. */
676 if (TREE_CODE (decl
) == TREE_LIST
)
677 decl
= TREE_VALUE (decl
);
680 if (TREE_CODE (name
) == OVERLOAD
)
681 name
= OVL_FUNCTION (name
);
683 gcc_assert (DECL_P (name
));
684 pop_binding (DECL_NAME (name
), decl
);
688 /* Remove declarations for any `for' variables from inner scopes
689 that we kept around. */
690 for (link
= current_binding_level
->dead_vars_from_for
;
691 link
; link
= TREE_CHAIN (link
))
692 pop_binding (DECL_NAME (TREE_VALUE (link
)), TREE_VALUE (link
));
694 /* Restore the IDENTIFIER_TYPE_VALUEs. */
695 for (link
= current_binding_level
->type_shadowed
;
696 link
; link
= TREE_CHAIN (link
))
697 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
699 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
700 for (link
= current_binding_level
->shadowed_labels
;
702 link
= TREE_CHAIN (link
))
703 pop_local_label (TREE_VALUE (link
), TREE_PURPOSE (link
));
705 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
706 list if a `using' declaration put them there. The debugging
707 back ends won't understand OVERLOAD, so we remove them here.
708 Because the BLOCK_VARS are (temporarily) shared with
709 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
710 popped all the bindings. */
715 for (d
= &BLOCK_VARS (block
); *d
; )
717 if (TREE_CODE (*d
) == TREE_LIST
)
718 *d
= TREE_CHAIN (*d
);
720 d
= &TREE_CHAIN (*d
);
724 /* If the level being exited is the top level of a function,
725 check over all the labels. */
728 /* Since this is the top level block of a function, the vars are
729 the function's parameters. Don't leave them in the BLOCK
730 because they are found in the FUNCTION_DECL instead. */
731 BLOCK_VARS (block
) = 0;
735 kind
= current_binding_level
->kind
;
736 if (kind
== sk_cleanup
)
740 /* If this is a temporary binding created for a cleanup, then we'll
741 have pushed a statement list level. Pop that, create a new
742 BIND_EXPR for the block, and insert it into the stream. */
743 stmt
= pop_stmt_list (current_binding_level
->statement_list
);
744 stmt
= c_build_bind_expr (input_location
, block
, stmt
);
751 /* The current function is being defined, so its DECL_INITIAL
752 should be error_mark_node. */
753 gcc_assert (DECL_INITIAL (current_function_decl
) == error_mark_node
);
754 DECL_INITIAL (current_function_decl
) = block
;
757 current_binding_level
->blocks
758 = chainon (current_binding_level
->blocks
, block
);
760 /* If we did not make a block for the level just exited,
761 any blocks made for inner levels
762 (since they cannot be recorded as subblocks in that level)
763 must be carried forward so they will later become subblocks
764 of something else. */
766 current_binding_level
->blocks
767 = chainon (current_binding_level
->blocks
, subblocks
);
769 /* Each and every BLOCK node created here in `poplevel' is important
770 (e.g. for proper debugging information) so if we created one
771 earlier, mark it as "used". */
773 TREE_USED (block
) = 1;
775 /* All temporary bindings created for cleanups are popped silently. */
776 if (kind
== sk_cleanup
)
779 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, block
);
782 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
783 itself, calling F for each. The DATA is passed to F as well. */
786 walk_namespaces_r (tree name_space
, walk_namespaces_fn f
, void* data
)
789 tree current
= NAMESPACE_LEVEL (name_space
)->namespaces
;
791 result
|= (*f
) (name_space
, data
);
793 for (; current
; current
= TREE_CHAIN (current
))
794 result
|= walk_namespaces_r (current
, f
, data
);
799 /* Walk all the namespaces, calling F for each. The DATA is passed to
803 walk_namespaces (walk_namespaces_fn f
, void* data
)
805 return walk_namespaces_r (global_namespace
, f
, data
);
808 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
809 DATA is non-NULL, this is the last time we will call
810 wrapup_global_declarations for this NAMESPACE. */
813 wrapup_globals_for_namespace (tree name_space
, void* data
)
815 struct cp_binding_level
*level
= NAMESPACE_LEVEL (name_space
);
816 VEC(tree
,gc
) *statics
= level
->static_decls
;
817 tree
*vec
= VEC_address (tree
, statics
);
819 int len
= VEC_length (tree
, statics
);
820 int last_time
= (data
!= 0);
822 /* Check undefined IFUNC symbols. */
823 for (decl
= level
->names
; decl
; decl
= TREE_CHAIN (decl
))
824 if (TREE_CODE (decl
) == FUNCTION_DECL
825 && DECL_INITIAL (decl
) == 0
826 && DECL_EXTERNAL (decl
)
827 && ! TREE_NO_WARNING (decl
)
828 && DECL_IS_IFUNC (decl
))
830 error_at (input_location
,
831 "indirect function %q+F never defined", decl
);
832 TREE_NO_WARNING (decl
) = 1;
837 check_global_declarations (vec
, len
);
838 emit_debug_global_declarations (vec
, len
);
842 /* Write out any globals that need to be output. */
843 return wrapup_global_declarations (vec
, len
);
847 /* In C++, you don't have to write `struct S' to refer to `S'; you
848 can just use `S'. We accomplish this by creating a TYPE_DECL as
849 if the user had written `typedef struct S S'. Create and return
850 the TYPE_DECL for TYPE. */
853 create_implicit_typedef (tree name
, tree type
)
857 decl
= build_decl (input_location
, TYPE_DECL
, name
, type
);
858 DECL_ARTIFICIAL (decl
) = 1;
859 /* There are other implicit type declarations, like the one *within*
860 a class that allows you to write `S::S'. We must distinguish
862 SET_DECL_IMPLICIT_TYPEDEF_P (decl
);
863 TYPE_NAME (type
) = decl
;
864 TYPE_STUB_DECL (type
) = decl
;
869 /* Remember a local name for name-mangling purposes. */
872 push_local_name (tree decl
)
877 timevar_push (TV_NAME_LOOKUP
);
879 name
= DECL_NAME (decl
);
881 nelts
= VEC_length (tree
, local_names
);
882 for (i
= 0; i
< nelts
; i
++)
884 t
= VEC_index (tree
, local_names
, i
);
885 if (DECL_NAME (t
) == name
)
887 if (!DECL_LANG_SPECIFIC (decl
))
888 retrofit_lang_decl (decl
);
889 DECL_LANG_SPECIFIC (decl
)->u
.base
.u2sel
= 1;
890 if (DECL_LANG_SPECIFIC (t
))
891 DECL_DISCRIMINATOR (decl
) = DECL_DISCRIMINATOR (t
) + 1;
893 DECL_DISCRIMINATOR (decl
) = 1;
895 VEC_replace (tree
, local_names
, i
, decl
);
896 timevar_pop (TV_NAME_LOOKUP
);
901 VEC_safe_push (tree
, gc
, local_names
, decl
);
902 timevar_pop (TV_NAME_LOOKUP
);
905 /* Subroutine of duplicate_decls: return truthvalue of whether
906 or not types of these decls match.
908 For C++, we must compare the parameter list so that `int' can match
909 `int&' in a parameter position, but `int&' is not confused with
913 decls_match (tree newdecl
, tree olddecl
)
917 if (newdecl
== olddecl
)
920 if (TREE_CODE (newdecl
) != TREE_CODE (olddecl
))
921 /* If the two DECLs are not even the same kind of thing, we're not
922 interested in their types. */
925 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
927 tree f1
= TREE_TYPE (newdecl
);
928 tree f2
= TREE_TYPE (olddecl
);
929 tree p1
= TYPE_ARG_TYPES (f1
);
930 tree p2
= TYPE_ARG_TYPES (f2
);
932 /* Specializations of different templates are different functions
933 even if they have the same type. */
934 tree t1
= (DECL_USE_TEMPLATE (newdecl
)
935 ? DECL_TI_TEMPLATE (newdecl
)
937 tree t2
= (DECL_USE_TEMPLATE (olddecl
)
938 ? DECL_TI_TEMPLATE (olddecl
)
943 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
944 && ! (DECL_EXTERN_C_P (newdecl
)
945 && DECL_EXTERN_C_P (olddecl
)))
948 #ifdef NO_IMPLICIT_EXTERN_C
949 /* A new declaration doesn't match a built-in one unless it
950 is also extern "C". */
951 if (DECL_IS_BUILTIN (olddecl
)
952 && DECL_EXTERN_C_P (olddecl
) && !DECL_EXTERN_C_P (newdecl
))
956 if (TREE_CODE (f1
) != TREE_CODE (f2
))
959 if (same_type_p (TREE_TYPE (f1
), TREE_TYPE (f2
)))
961 if (p2
== NULL_TREE
&& DECL_EXTERN_C_P (olddecl
)
962 && (DECL_BUILT_IN (olddecl
)
963 #ifndef NO_IMPLICIT_EXTERN_C
964 || (DECL_IN_SYSTEM_HEADER (newdecl
) && !DECL_CLASS_SCOPE_P (newdecl
))
965 || (DECL_IN_SYSTEM_HEADER (olddecl
) && !DECL_CLASS_SCOPE_P (olddecl
))
969 types_match
= self_promoting_args_p (p1
);
970 if (p1
== void_list_node
)
971 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
973 #ifndef NO_IMPLICIT_EXTERN_C
974 else if (p1
== NULL_TREE
975 && (DECL_EXTERN_C_P (olddecl
)
976 && DECL_IN_SYSTEM_HEADER (olddecl
)
977 && !DECL_CLASS_SCOPE_P (olddecl
))
978 && (DECL_EXTERN_C_P (newdecl
)
979 && DECL_IN_SYSTEM_HEADER (newdecl
)
980 && !DECL_CLASS_SCOPE_P (newdecl
)))
982 types_match
= self_promoting_args_p (p2
);
983 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
987 types_match
= compparms (p1
, p2
);
992 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
994 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
))
995 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)))
998 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
999 DECL_TEMPLATE_PARMS (olddecl
)))
1002 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1003 types_match
= same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
)),
1004 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
)));
1006 types_match
= decls_match (DECL_TEMPLATE_RESULT (olddecl
),
1007 DECL_TEMPLATE_RESULT (newdecl
));
1011 /* Need to check scope for variable declaration (VAR_DECL).
1012 For typedef (TYPE_DECL), scope is ignored. */
1013 if (TREE_CODE (newdecl
) == VAR_DECL
1014 && CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
1016 Two declarations for an object with C language linkage
1017 with the same name (ignoring the namespace that qualify
1018 it) that appear in different namespace scopes refer to
1020 && !(DECL_EXTERN_C_P (olddecl
) && DECL_EXTERN_C_P (newdecl
)))
1023 if (TREE_TYPE (newdecl
) == error_mark_node
)
1024 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
1025 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
1026 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
1027 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
1030 types_match
= comptypes (TREE_TYPE (newdecl
),
1031 TREE_TYPE (olddecl
),
1032 COMPARE_REDECLARATION
);
1038 /* If NEWDECL is `static' and an `extern' was seen previously,
1039 warn about it. OLDDECL is the previous declaration.
1041 Note that this does not apply to the C++ case of declaring
1042 a variable `extern const' and then later `const'.
1044 Don't complain about built-in functions, since they are beyond
1045 the user's control. */
1048 warn_extern_redeclared_static (tree newdecl
, tree olddecl
)
1050 if (TREE_CODE (newdecl
) == TYPE_DECL
1051 || TREE_CODE (newdecl
) == TEMPLATE_DECL
1052 || TREE_CODE (newdecl
) == CONST_DECL
1053 || TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1056 /* Don't get confused by static member functions; that's a different
1058 if (TREE_CODE (newdecl
) == FUNCTION_DECL
1059 && DECL_STATIC_FUNCTION_P (newdecl
))
1062 /* If the old declaration was `static', or the new one isn't, then
1063 then everything is OK. */
1064 if (DECL_THIS_STATIC (olddecl
) || !DECL_THIS_STATIC (newdecl
))
1067 /* It's OK to declare a builtin function as `static'. */
1068 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1069 && DECL_ARTIFICIAL (olddecl
))
1072 permerror (input_location
, "%qD was declared %<extern%> and later %<static%>", newdecl
);
1073 permerror (input_location
, "previous declaration of %q+D", olddecl
);
1076 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1077 function templates. If their exception specifications do not
1078 match, issue a diagnostic. */
1081 check_redeclaration_exception_specification (tree new_decl
,
1086 tree new_exceptions
;
1087 tree old_exceptions
;
1089 new_type
= TREE_TYPE (new_decl
);
1090 new_exceptions
= TYPE_RAISES_EXCEPTIONS (new_type
);
1091 old_type
= TREE_TYPE (old_decl
);
1092 old_exceptions
= TYPE_RAISES_EXCEPTIONS (old_type
);
1096 If any declaration of a function has an exception-specification,
1097 all declarations, including the definition and an explicit
1098 specialization, of that function shall have an
1099 exception-specification with the same set of type-ids. */
1100 if ((pedantic
|| ! DECL_IN_SYSTEM_HEADER (old_decl
))
1101 && ! DECL_IS_BUILTIN (old_decl
)
1103 && !comp_except_specs (new_exceptions
, old_exceptions
,
1106 error ("declaration of %qF throws different exceptions", new_decl
);
1107 error ("from previous declaration %q+F", old_decl
);
1111 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1112 && lookup_attribute ("gnu_inline", \
1113 DECL_ATTRIBUTES (fn)))
1115 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1116 If the redeclaration is invalid, a diagnostic is issued, and the
1117 error_mark_node is returned. Otherwise, OLDDECL is returned.
1119 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1122 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1125 duplicate_decls (tree newdecl
, tree olddecl
, bool newdecl_is_friend
)
1127 unsigned olddecl_uid
= DECL_UID (olddecl
);
1128 int olddecl_friend
= 0, types_match
= 0, hidden_friend
= 0;
1129 int new_defines_function
= 0;
1130 tree new_template_info
;
1132 if (newdecl
== olddecl
)
1135 types_match
= decls_match (newdecl
, olddecl
);
1137 /* If either the type of the new decl or the type of the old decl is an
1138 error_mark_node, then that implies that we have already issued an
1139 error (earlier) for some bogus type specification, and in that case,
1140 it is rather pointless to harass the user with yet more error message
1141 about the same declaration, so just pretend the types match here. */
1142 if (TREE_TYPE (newdecl
) == error_mark_node
1143 || TREE_TYPE (olddecl
) == error_mark_node
)
1144 return error_mark_node
;
1146 if (DECL_P (olddecl
)
1147 && TREE_CODE (newdecl
) == FUNCTION_DECL
1148 && TREE_CODE (olddecl
) == FUNCTION_DECL
1149 && (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
)))
1151 if (DECL_DECLARED_INLINE_P (newdecl
)
1152 && DECL_UNINLINABLE (newdecl
)
1153 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
1154 /* Already warned elsewhere. */;
1155 else if (DECL_DECLARED_INLINE_P (olddecl
)
1156 && DECL_UNINLINABLE (olddecl
)
1157 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
1158 /* Already warned. */;
1159 else if (DECL_DECLARED_INLINE_P (newdecl
)
1160 && DECL_UNINLINABLE (olddecl
)
1161 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
1163 warning (OPT_Wattributes
, "function %q+D redeclared as inline",
1165 warning (OPT_Wattributes
, "previous declaration of %q+D "
1166 "with attribute noinline", olddecl
);
1168 else if (DECL_DECLARED_INLINE_P (olddecl
)
1169 && DECL_UNINLINABLE (newdecl
)
1170 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
1172 warning (OPT_Wattributes
, "function %q+D redeclared with "
1173 "attribute noinline", newdecl
);
1174 warning (OPT_Wattributes
, "previous declaration of %q+D was inline",
1179 /* Check for redeclaration and other discrepancies. */
1180 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1181 && DECL_ARTIFICIAL (olddecl
))
1183 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl
));
1184 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
1186 /* Avoid warnings redeclaring built-ins which have not been
1187 explicitly declared. */
1188 if (DECL_ANTICIPATED (olddecl
))
1191 /* If you declare a built-in or predefined function name as static,
1192 the old definition is overridden, but optionally warn this was a
1193 bad choice of name. */
1194 if (! TREE_PUBLIC (newdecl
))
1196 warning (OPT_Wshadow
,
1197 DECL_BUILT_IN (olddecl
)
1198 ? G_("shadowing built-in function %q#D")
1199 : G_("shadowing library function %q#D"), olddecl
);
1200 /* Discard the old built-in function. */
1203 /* If the built-in is not ansi, then programs can override
1204 it even globally without an error. */
1205 else if (! DECL_BUILT_IN (olddecl
))
1206 warning (0, "library function %q#D redeclared as non-function %q#D",
1210 error ("declaration of %q#D", newdecl
);
1211 error ("conflicts with built-in declaration %q#D",
1216 else if (!types_match
)
1218 /* Avoid warnings redeclaring built-ins which have not been
1219 explicitly declared. */
1220 if (DECL_ANTICIPATED (olddecl
))
1222 /* Deal with fileptr_type_node. FILE type is not known
1223 at the time we create the builtins. */
1226 for (t1
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1227 t2
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1229 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1232 else if (TREE_VALUE (t2
) == fileptr_type_node
)
1234 tree t
= TREE_VALUE (t1
);
1236 if (TREE_CODE (t
) == POINTER_TYPE
1237 && TYPE_NAME (TREE_TYPE (t
))
1238 && DECL_NAME (TYPE_NAME (TREE_TYPE (t
)))
1239 == get_identifier ("FILE")
1240 && compparms (TREE_CHAIN (t1
), TREE_CHAIN (t2
)))
1242 tree oldargs
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1244 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))
1245 = TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
1246 types_match
= decls_match (newdecl
, olddecl
);
1248 return duplicate_decls (newdecl
, olddecl
,
1250 TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) = oldargs
;
1253 else if (! same_type_p (TREE_VALUE (t1
), TREE_VALUE (t2
)))
1256 else if ((DECL_EXTERN_C_P (newdecl
)
1257 && DECL_EXTERN_C_P (olddecl
))
1258 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1259 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
1261 /* A near match; override the builtin. */
1263 if (TREE_PUBLIC (newdecl
))
1265 warning (0, "new declaration %q#D", newdecl
);
1266 warning (0, "ambiguates built-in declaration %q#D",
1270 warning (OPT_Wshadow
,
1271 DECL_BUILT_IN (olddecl
)
1272 ? G_("shadowing built-in function %q#D")
1273 : G_("shadowing library function %q#D"), olddecl
);
1276 /* Discard the old built-in function. */
1279 /* Replace the old RTL to avoid problems with inlining. */
1280 COPY_DECL_RTL (newdecl
, olddecl
);
1282 /* Even if the types match, prefer the new declarations type for
1283 built-ins which have not been explicitly declared, for
1284 exception lists, etc... */
1285 else if (DECL_ANTICIPATED (olddecl
))
1287 tree type
= TREE_TYPE (newdecl
);
1288 tree attribs
= (*targetm
.merge_type_attributes
)
1289 (TREE_TYPE (olddecl
), type
);
1291 type
= cp_build_type_attribute_variant (type
, attribs
);
1292 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = type
;
1295 /* If a function is explicitly declared "throw ()", propagate that to
1296 the corresponding builtin. */
1297 if (DECL_BUILT_IN_CLASS (olddecl
) == BUILT_IN_NORMAL
1298 && DECL_ANTICIPATED (olddecl
)
1299 && TREE_NOTHROW (newdecl
)
1300 && !TREE_NOTHROW (olddecl
)
1301 && built_in_decls
[DECL_FUNCTION_CODE (olddecl
)] != NULL_TREE
1302 && built_in_decls
[DECL_FUNCTION_CODE (olddecl
)] != olddecl
1304 TREE_NOTHROW (built_in_decls
[DECL_FUNCTION_CODE (olddecl
)]) = 1;
1306 /* Whether or not the builtin can throw exceptions has no
1307 bearing on this declarator. */
1308 TREE_NOTHROW (olddecl
) = 0;
1310 if (DECL_THIS_STATIC (newdecl
) && !DECL_THIS_STATIC (olddecl
))
1312 /* If a builtin function is redeclared as `static', merge
1313 the declarations, but make the original one static. */
1314 DECL_THIS_STATIC (olddecl
) = 1;
1315 TREE_PUBLIC (olddecl
) = 0;
1317 /* Make the old declaration consistent with the new one so
1318 that all remnants of the builtin-ness of this function
1319 will be banished. */
1320 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
1321 COPY_DECL_RTL (newdecl
, olddecl
);
1324 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
1326 /* C++ Standard, 3.3, clause 4:
1327 "[Note: a namespace name or a class template name must be unique
1328 in its declarative region (7.3.2, clause 14). ]" */
1329 if (TREE_CODE (olddecl
) != NAMESPACE_DECL
1330 && TREE_CODE (newdecl
) != NAMESPACE_DECL
1331 && (TREE_CODE (olddecl
) != TEMPLATE_DECL
1332 || TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) != TYPE_DECL
)
1333 && (TREE_CODE (newdecl
) != TEMPLATE_DECL
1334 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != TYPE_DECL
))
1336 if ((TREE_CODE (olddecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (olddecl
)
1337 && TREE_CODE (newdecl
) != TYPE_DECL
)
1338 || (TREE_CODE (newdecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (newdecl
)
1339 && TREE_CODE (olddecl
) != TYPE_DECL
))
1341 /* We do nothing special here, because C++ does such nasty
1342 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1343 get shadowed, and know that if we need to find a TYPE_DECL
1344 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1345 slot of the identifier. */
1349 if ((TREE_CODE (newdecl
) == FUNCTION_DECL
1350 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
1351 || (TREE_CODE (olddecl
) == FUNCTION_DECL
1352 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
1356 error ("%q#D redeclared as different kind of symbol", newdecl
);
1357 if (TREE_CODE (olddecl
) == TREE_LIST
)
1358 olddecl
= TREE_VALUE (olddecl
);
1359 error ("previous declaration of %q+#D", olddecl
);
1361 return error_mark_node
;
1363 else if (!types_match
)
1365 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
))
1366 /* These are certainly not duplicate declarations; they're
1367 from different scopes. */
1370 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1372 /* The name of a class template may not be declared to refer to
1373 any other template, class, function, object, namespace, value,
1374 or type in the same scope. */
1375 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
1376 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1378 error ("declaration of template %q#D", newdecl
);
1379 error ("conflicts with previous declaration %q+#D", olddecl
);
1381 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
1382 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
1383 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
1384 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))))
1385 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1386 DECL_TEMPLATE_PARMS (olddecl
))
1387 /* Template functions can be disambiguated by
1389 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl
)),
1390 TREE_TYPE (TREE_TYPE (olddecl
))))
1392 error ("new declaration %q#D", newdecl
);
1393 error ("ambiguates old declaration %q+#D", olddecl
);
1397 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1399 if (DECL_EXTERN_C_P (newdecl
) && DECL_EXTERN_C_P (olddecl
))
1401 error ("declaration of C function %q#D conflicts with",
1403 error ("previous declaration %q+#D here", olddecl
);
1405 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1406 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
1408 error ("new declaration %q#D", newdecl
);
1409 error ("ambiguates old declaration %q+#D", olddecl
);
1410 return error_mark_node
;
1417 error ("conflicting declaration %q#D", newdecl
);
1418 error ("%q+D has a previous declaration as %q#D", olddecl
, olddecl
);
1419 return error_mark_node
;
1422 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1423 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
1424 && (!DECL_TEMPLATE_INFO (newdecl
)
1425 || (DECL_TI_TEMPLATE (newdecl
)
1426 != DECL_TI_TEMPLATE (olddecl
))))
1427 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1428 && (!DECL_TEMPLATE_INFO (olddecl
)
1429 || (DECL_TI_TEMPLATE (olddecl
)
1430 != DECL_TI_TEMPLATE (newdecl
))))))
1431 /* It's OK to have a template specialization and a non-template
1432 with the same type, or to have specializations of two
1433 different templates with the same type. Note that if one is a
1434 specialization, and the other is an instantiation of the same
1435 template, that we do not exit at this point. That situation
1436 can occur if we instantiate a template class, and then
1437 specialize one of its methods. This situation is valid, but
1438 the declarations must be merged in the usual way. */
1440 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1441 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
1442 && !DECL_USE_TEMPLATE (newdecl
))
1443 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
1444 && !DECL_USE_TEMPLATE (olddecl
))))
1445 /* One of the declarations is a template instantiation, and the
1446 other is not a template at all. That's OK. */
1448 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1450 /* In [namespace.alias] we have:
1452 In a declarative region, a namespace-alias-definition can be
1453 used to redefine a namespace-alias declared in that declarative
1454 region to refer only to the namespace to which it already
1457 Therefore, if we encounter a second alias directive for the same
1458 alias, we can just ignore the second directive. */
1459 if (DECL_NAMESPACE_ALIAS (newdecl
)
1460 && (DECL_NAMESPACE_ALIAS (newdecl
)
1461 == DECL_NAMESPACE_ALIAS (olddecl
)))
1463 /* [namespace.alias]
1465 A namespace-name or namespace-alias shall not be declared as
1466 the name of any other entity in the same declarative region.
1467 A namespace-name defined at global scope shall not be
1468 declared as the name of any other entity in any global scope
1470 error ("declaration of namespace %qD conflicts with", newdecl
);
1471 error ("previous declaration of namespace %q+D here", olddecl
);
1472 return error_mark_node
;
1476 const char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
1479 error_at (DECL_SOURCE_LOCATION (newdecl
), errmsg
, newdecl
);
1480 if (DECL_NAME (olddecl
) != NULL_TREE
)
1481 error ((DECL_INITIAL (olddecl
) && namespace_bindings_p ())
1482 ? "%q+#D previously defined here"
1483 : "%q+#D previously declared here", olddecl
);
1484 return error_mark_node
;
1486 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1487 && DECL_INITIAL (olddecl
) != NULL_TREE
1488 && TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) == NULL_TREE
1489 && TYPE_ARG_TYPES (TREE_TYPE (newdecl
)) != NULL_TREE
)
1491 /* Prototype decl follows defn w/o prototype. */
1492 warning_at (input_location
, 0, "prototype for %q+#D", newdecl
);
1493 warning_at (DECL_SOURCE_LOCATION (olddecl
), 0,
1494 "follows non-prototype definition here");
1496 else if ((TREE_CODE (olddecl
) == FUNCTION_DECL
1497 || TREE_CODE (olddecl
) == VAR_DECL
)
1498 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
1501 If two declarations of the same function or object
1502 specify different linkage-specifications ..., the program
1503 is ill-formed.... Except for functions with C++ linkage,
1504 a function declaration without a linkage specification
1505 shall not precede the first linkage specification for
1506 that function. A function can be declared without a
1507 linkage specification after an explicit linkage
1508 specification has been seen; the linkage explicitly
1509 specified in the earlier declaration is not affected by
1510 such a function declaration.
1512 DR 563 raises the question why the restrictions on
1513 functions should not also apply to objects. Older
1514 versions of G++ silently ignore the linkage-specification
1522 which is clearly wrong. Therefore, we now treat objects
1524 if (current_lang_depth () == 0)
1526 /* There is no explicit linkage-specification, so we use
1527 the linkage from the previous declaration. */
1528 if (!DECL_LANG_SPECIFIC (newdecl
))
1529 retrofit_lang_decl (newdecl
);
1530 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
1534 error ("previous declaration of %q+#D with %qL linkage",
1535 olddecl
, DECL_LANGUAGE (olddecl
));
1536 error ("conflicts with new declaration with %qL linkage",
1537 DECL_LANGUAGE (newdecl
));
1541 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
1543 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
1545 tree t1
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1546 tree t2
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
1549 if (TREE_CODE (TREE_TYPE (newdecl
)) == METHOD_TYPE
)
1550 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
);
1552 for (; t1
&& t1
!= void_list_node
;
1553 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
1554 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
1556 if (1 == simple_cst_equal (TREE_PURPOSE (t1
),
1559 permerror (input_location
, "default argument given for parameter %d of %q#D",
1561 permerror (input_location
, "after previous specification in %q+#D", olddecl
);
1565 error ("default argument given for parameter %d of %q#D",
1567 error ("after previous specification in %q+#D",
1574 /* Do not merge an implicit typedef with an explicit one. In:
1578 typedef class A A __attribute__ ((foo));
1580 the attribute should apply only to the typedef. */
1581 if (TREE_CODE (olddecl
) == TYPE_DECL
1582 && (DECL_IMPLICIT_TYPEDEF_P (olddecl
)
1583 || DECL_IMPLICIT_TYPEDEF_P (newdecl
)))
1586 /* If new decl is `static' and an `extern' was seen previously,
1588 warn_extern_redeclared_static (newdecl
, olddecl
);
1590 /* We have committed to returning 1 at this point. */
1591 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1593 /* Now that functions must hold information normally held
1594 by field decls, there is extra work to do so that
1595 declaration information does not get destroyed during
1597 if (DECL_VINDEX (olddecl
))
1598 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
1599 if (DECL_CONTEXT (olddecl
))
1600 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
1601 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
1602 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
1603 DECL_PURE_VIRTUAL_P (newdecl
) |= DECL_PURE_VIRTUAL_P (olddecl
);
1604 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
1605 DECL_INVALID_OVERRIDER_P (newdecl
) |= DECL_INVALID_OVERRIDER_P (olddecl
);
1606 DECL_THIS_STATIC (newdecl
) |= DECL_THIS_STATIC (olddecl
);
1607 if (DECL_OVERLOADED_OPERATOR_P (olddecl
) != ERROR_MARK
)
1608 SET_OVERLOADED_OPERATOR_CODE
1609 (newdecl
, DECL_OVERLOADED_OPERATOR_P (olddecl
));
1610 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
1612 /* Optionally warn about more than one declaration for the same
1613 name, but don't warn about a function declaration followed by a
1615 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
1616 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
1617 /* Don't warn about extern decl followed by definition. */
1618 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
1619 /* Don't warn about friends, let add_friend take care of it. */
1620 && ! (newdecl_is_friend
|| DECL_FRIEND_P (olddecl
)))
1622 warning (OPT_Wredundant_decls
, "redundant redeclaration of %qD in same scope", newdecl
);
1623 warning (OPT_Wredundant_decls
, "previous declaration of %q+D", olddecl
);
1626 if (DECL_DELETED_FN (newdecl
))
1628 error ("deleted definition of %qD", newdecl
);
1629 error ("after previous declaration %q+D", olddecl
);
1632 /* The IFUNC information must be on definition since it may
1633 change the function return type inside the function body. */
1634 if (new_defines_function
1635 && DECL_IS_IFUNC (olddecl
)
1636 && !DECL_IS_IFUNC (newdecl
))
1638 error ("definition of function %q+D conflicts with",
1640 error ("previous declaration of indirect function %q+D here",
1642 return error_mark_node
;
1645 /* Merge the IFUNC information. */
1646 if (DECL_IS_IFUNC (olddecl
))
1647 DECL_IS_IFUNC (newdecl
) = 1;
1648 else if (DECL_IS_IFUNC (newdecl
))
1649 DECL_IS_IFUNC (olddecl
) = 1;
1652 /* Deal with C++: must preserve virtual function table size. */
1653 if (TREE_CODE (olddecl
) == TYPE_DECL
)
1655 tree newtype
= TREE_TYPE (newdecl
);
1656 tree oldtype
= TREE_TYPE (olddecl
);
1658 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
1659 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
1660 CLASSTYPE_FRIEND_CLASSES (newtype
)
1661 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
1663 DECL_ORIGINAL_TYPE (newdecl
) = DECL_ORIGINAL_TYPE (olddecl
);
1666 /* Copy all the DECL_... slots specified in the new decl
1667 except for any that we copy here from the old type. */
1668 DECL_ATTRIBUTES (newdecl
)
1669 = (*targetm
.merge_decl_attributes
) (olddecl
, newdecl
);
1671 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1675 old_result
= DECL_TEMPLATE_RESULT (olddecl
);
1676 new_result
= DECL_TEMPLATE_RESULT (newdecl
);
1677 TREE_TYPE (olddecl
) = TREE_TYPE (old_result
);
1678 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
1679 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
1680 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
1682 DECL_ATTRIBUTES (old_result
)
1683 = (*targetm
.merge_decl_attributes
) (old_result
, new_result
);
1685 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
1687 if (GNU_INLINE_P (old_result
) != GNU_INLINE_P (new_result
)
1688 && DECL_INITIAL (new_result
))
1690 if (DECL_INITIAL (old_result
))
1691 DECL_UNINLINABLE (old_result
) = 1;
1693 DECL_UNINLINABLE (old_result
) = DECL_UNINLINABLE (new_result
);
1694 DECL_EXTERNAL (old_result
) = DECL_EXTERNAL (new_result
);
1695 DECL_NOT_REALLY_EXTERN (old_result
)
1696 = DECL_NOT_REALLY_EXTERN (new_result
);
1697 DECL_INTERFACE_KNOWN (old_result
)
1698 = DECL_INTERFACE_KNOWN (new_result
);
1699 DECL_DECLARED_INLINE_P (old_result
)
1700 = DECL_DECLARED_INLINE_P (new_result
);
1701 DECL_DISREGARD_INLINE_LIMITS (old_result
)
1702 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
1707 DECL_DECLARED_INLINE_P (old_result
)
1708 |= DECL_DECLARED_INLINE_P (new_result
);
1709 DECL_DISREGARD_INLINE_LIMITS (old_result
)
1710 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
1711 check_redeclaration_exception_specification (newdecl
, olddecl
);
1715 /* If the new declaration is a definition, update the file and
1716 line information on the declaration, and also make
1717 the old declaration the same definition. */
1718 if (DECL_INITIAL (new_result
) != NULL_TREE
)
1720 DECL_SOURCE_LOCATION (olddecl
)
1721 = DECL_SOURCE_LOCATION (old_result
)
1722 = DECL_SOURCE_LOCATION (newdecl
);
1723 DECL_INITIAL (old_result
) = DECL_INITIAL (new_result
);
1724 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
1727 DECL_ARGUMENTS (old_result
)
1728 = DECL_ARGUMENTS (new_result
);
1729 for (parm
= DECL_ARGUMENTS (old_result
); parm
;
1730 parm
= TREE_CHAIN (parm
))
1731 DECL_CONTEXT (parm
) = old_result
;
1740 /* Automatically handles default parameters. */
1741 tree oldtype
= TREE_TYPE (olddecl
);
1744 /* Merge the data types specified in the two decls. */
1745 newtype
= merge_types (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
1747 /* If merge_types produces a non-typedef type, just use the old type. */
1748 if (TREE_CODE (newdecl
) == TYPE_DECL
1749 && newtype
== DECL_ORIGINAL_TYPE (newdecl
))
1752 if (TREE_CODE (newdecl
) == VAR_DECL
)
1754 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
1755 DECL_INITIALIZED_P (newdecl
) |= DECL_INITIALIZED_P (olddecl
);
1756 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl
)
1757 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl
);
1758 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl
)
1759 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl
);
1761 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
1762 if (DECL_LANG_SPECIFIC (olddecl
)
1763 && CP_DECL_THREADPRIVATE_P (olddecl
))
1765 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
1766 if (!DECL_LANG_SPECIFIC (newdecl
))
1767 retrofit_lang_decl (newdecl
);
1769 DECL_TLS_MODEL (newdecl
) = DECL_TLS_MODEL (olddecl
);
1770 CP_DECL_THREADPRIVATE_P (newdecl
) = 1;
1774 /* Do this after calling `merge_types' so that default
1775 parameters don't confuse us. */
1776 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1777 check_redeclaration_exception_specification (newdecl
, olddecl
);
1778 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
1780 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1781 check_default_args (newdecl
);
1783 /* Lay the type out, unless already done. */
1784 if (! same_type_p (newtype
, oldtype
)
1785 && TREE_TYPE (newdecl
) != error_mark_node
1786 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
1787 layout_type (TREE_TYPE (newdecl
));
1789 if ((TREE_CODE (newdecl
) == VAR_DECL
1790 || TREE_CODE (newdecl
) == PARM_DECL
1791 || TREE_CODE (newdecl
) == RESULT_DECL
1792 || TREE_CODE (newdecl
) == FIELD_DECL
1793 || TREE_CODE (newdecl
) == TYPE_DECL
)
1794 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
1795 layout_decl (newdecl
, 0);
1797 /* Merge the type qualifiers. */
1798 if (TREE_READONLY (newdecl
))
1799 TREE_READONLY (olddecl
) = 1;
1800 if (TREE_THIS_VOLATILE (newdecl
))
1801 TREE_THIS_VOLATILE (olddecl
) = 1;
1802 if (TREE_NOTHROW (newdecl
))
1803 TREE_NOTHROW (olddecl
) = 1;
1805 /* Merge deprecatedness. */
1806 if (TREE_DEPRECATED (newdecl
))
1807 TREE_DEPRECATED (olddecl
) = 1;
1809 /* Preserve function specific target and optimization options */
1810 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1812 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl
)
1813 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl
))
1814 DECL_FUNCTION_SPECIFIC_TARGET (newdecl
)
1815 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl
);
1817 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
)
1818 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
))
1819 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
)
1820 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
);
1823 /* Merge the initialization information. */
1824 if (DECL_INITIAL (newdecl
) == NULL_TREE
1825 && DECL_INITIAL (olddecl
) != NULL_TREE
)
1827 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
1828 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
1829 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1831 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
1832 DECL_STRUCT_FUNCTION (newdecl
) = DECL_STRUCT_FUNCTION (olddecl
);
1836 /* Merge the section attribute.
1837 We want to issue an error if the sections conflict but that must be
1838 done later in decl_attributes since we are called before attributes
1840 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
1841 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
1843 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1845 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
1846 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
1847 DECL_NO_LIMIT_STACK (newdecl
) |= DECL_NO_LIMIT_STACK (olddecl
);
1848 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
1849 TREE_NOTHROW (newdecl
) |= TREE_NOTHROW (olddecl
);
1850 DECL_IS_MALLOC (newdecl
) |= DECL_IS_MALLOC (olddecl
);
1851 DECL_IS_OPERATOR_NEW (newdecl
) |= DECL_IS_OPERATOR_NEW (olddecl
);
1852 DECL_PURE_P (newdecl
) |= DECL_PURE_P (olddecl
);
1853 TREE_READONLY (newdecl
) |= TREE_READONLY (olddecl
);
1854 DECL_LOOPING_CONST_OR_PURE_P (newdecl
)
1855 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl
);
1856 /* Keep the old RTL. */
1857 COPY_DECL_RTL (olddecl
, newdecl
);
1859 else if (TREE_CODE (newdecl
) == VAR_DECL
1860 && (DECL_SIZE (olddecl
) || !DECL_SIZE (newdecl
)))
1862 /* Keep the old RTL. We cannot keep the old RTL if the old
1863 declaration was for an incomplete object and the new
1864 declaration is not since many attributes of the RTL will
1866 COPY_DECL_RTL (olddecl
, newdecl
);
1869 /* If cannot merge, then use the new type and qualifiers,
1870 and don't preserve the old rtl. */
1873 /* Clean out any memory we had of the old declaration. */
1874 tree oldstatic
= value_member (olddecl
, static_aggregates
);
1876 TREE_VALUE (oldstatic
) = error_mark_node
;
1878 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
1879 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
1880 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
1881 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
1884 /* Merge the storage class information. */
1885 merge_weak (newdecl
, olddecl
);
1887 if (DECL_ONE_ONLY (olddecl
))
1888 DECL_COMDAT_GROUP (newdecl
) = DECL_COMDAT_GROUP (olddecl
);
1890 DECL_DEFER_OUTPUT (newdecl
) |= DECL_DEFER_OUTPUT (olddecl
);
1891 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
1892 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
1893 if (! DECL_EXTERNAL (olddecl
))
1894 DECL_EXTERNAL (newdecl
) = 0;
1896 new_template_info
= NULL_TREE
;
1897 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
1899 bool new_redefines_gnu_inline
= false;
1901 if (new_defines_function
1902 && ((DECL_INTERFACE_KNOWN (olddecl
)
1903 && TREE_CODE (olddecl
) == FUNCTION_DECL
)
1904 || (TREE_CODE (olddecl
) == TEMPLATE_DECL
1905 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
1906 == FUNCTION_DECL
))))
1910 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
1911 fn
= DECL_TEMPLATE_RESULT (olddecl
);
1913 new_redefines_gnu_inline
= GNU_INLINE_P (fn
) && DECL_INITIAL (fn
);
1916 if (!new_redefines_gnu_inline
)
1918 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
1919 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
1920 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
1922 DECL_TEMPLATE_INSTANTIATED (newdecl
)
1923 |= DECL_TEMPLATE_INSTANTIATED (olddecl
);
1924 DECL_ODR_USED (newdecl
) |= DECL_ODR_USED (olddecl
);
1926 /* If the OLDDECL is an instantiation and/or specialization,
1927 then the NEWDECL must be too. But, it may not yet be marked
1928 as such if the caller has created NEWDECL, but has not yet
1929 figured out that it is a redeclaration. */
1930 if (!DECL_USE_TEMPLATE (newdecl
))
1931 DECL_USE_TEMPLATE (newdecl
) = DECL_USE_TEMPLATE (olddecl
);
1933 /* Don't really know how much of the language-specific
1934 values we should copy from old to new. */
1935 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
1936 DECL_REPO_AVAILABLE_P (newdecl
) = DECL_REPO_AVAILABLE_P (olddecl
);
1937 DECL_INITIALIZED_IN_CLASS_P (newdecl
)
1938 |= DECL_INITIALIZED_IN_CLASS_P (olddecl
);
1940 if (LANG_DECL_HAS_MIN (newdecl
))
1942 DECL_LANG_SPECIFIC (newdecl
)->u
.min
.u2
=
1943 DECL_LANG_SPECIFIC (olddecl
)->u
.min
.u2
;
1944 if (DECL_TEMPLATE_INFO (newdecl
))
1945 new_template_info
= DECL_TEMPLATE_INFO (newdecl
);
1946 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
1948 /* Only functions have these fields. */
1949 if (TREE_CODE (newdecl
) == FUNCTION_DECL
1950 || DECL_FUNCTION_TEMPLATE_P (newdecl
))
1952 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
1953 olddecl_friend
= DECL_FRIEND_P (olddecl
);
1954 hidden_friend
= (DECL_ANTICIPATED (olddecl
)
1955 && DECL_HIDDEN_FRIEND_P (olddecl
)
1956 && newdecl_is_friend
);
1957 DECL_BEFRIENDING_CLASSES (newdecl
)
1958 = chainon (DECL_BEFRIENDING_CLASSES (newdecl
),
1959 DECL_BEFRIENDING_CLASSES (olddecl
));
1960 /* DECL_THUNKS is only valid for virtual functions,
1961 otherwise it is a DECL_FRIEND_CONTEXT. */
1962 if (DECL_VIRTUAL_P (newdecl
))
1963 DECL_THUNKS (newdecl
) = DECL_THUNKS (olddecl
);
1965 /* Only variables have this field. */
1966 else if (TREE_CODE (newdecl
) == VAR_DECL
1967 && VAR_HAD_UNKNOWN_BOUND (olddecl
))
1968 SET_VAR_HAD_UNKNOWN_BOUND (newdecl
);
1971 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1975 /* Merge parameter attributes. */
1976 tree oldarg
, newarg
;
1977 for (oldarg
= DECL_ARGUMENTS(olddecl
),
1978 newarg
= DECL_ARGUMENTS(newdecl
);
1980 oldarg
= TREE_CHAIN(oldarg
), newarg
= TREE_CHAIN(newarg
)) {
1981 DECL_ATTRIBUTES (newarg
)
1982 = (*targetm
.merge_decl_attributes
) (oldarg
, newarg
);
1983 DECL_ATTRIBUTES (oldarg
) = DECL_ATTRIBUTES (newarg
);
1986 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
1987 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
1989 /* If newdecl is not a specialization, then it is not a
1990 template-related function at all. And that means that we
1991 should have exited above, returning 0. */
1992 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
));
1994 if (DECL_ODR_USED (olddecl
))
1995 /* From [temp.expl.spec]:
1997 If a template, a member template or the member of a class
1998 template is explicitly specialized then that
1999 specialization shall be declared before the first use of
2000 that specialization that would cause an implicit
2001 instantiation to take place, in every translation unit in
2002 which such a use occurs. */
2003 error ("explicit specialization of %qD after first use",
2006 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
2008 /* Don't propagate visibility from the template to the
2009 specialization here. We'll do that in determine_visibility if
2011 DECL_VISIBILITY_SPECIFIED (olddecl
) = 0;
2013 /* [temp.expl.spec/14] We don't inline explicit specialization
2014 just because the primary template says so. */
2016 else if (new_defines_function
&& DECL_INITIAL (olddecl
))
2018 /* Never inline re-defined extern inline functions.
2019 FIXME: this could be better handled by keeping both
2020 function as separate declarations. */
2021 DECL_UNINLINABLE (newdecl
) = 1;
2025 if (DECL_PENDING_INLINE_INFO (newdecl
) == 0)
2026 DECL_PENDING_INLINE_INFO (newdecl
) = DECL_PENDING_INLINE_INFO (olddecl
);
2028 DECL_DECLARED_INLINE_P (newdecl
) |= DECL_DECLARED_INLINE_P (olddecl
);
2030 DECL_UNINLINABLE (newdecl
) = DECL_UNINLINABLE (olddecl
)
2031 = (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
));
2033 DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2034 = DECL_DISREGARD_INLINE_LIMITS (olddecl
)
2035 = (DECL_DISREGARD_INLINE_LIMITS (newdecl
)
2036 || DECL_DISREGARD_INLINE_LIMITS (olddecl
));
2039 /* Preserve abstractness on cloned [cd]tors. */
2040 DECL_ABSTRACT (newdecl
) = DECL_ABSTRACT (olddecl
);
2042 /* Update newdecl's parms to point at olddecl. */
2043 for (parm
= DECL_ARGUMENTS (newdecl
); parm
;
2044 parm
= TREE_CHAIN (parm
))
2045 DECL_CONTEXT (parm
) = olddecl
;
2049 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
2050 COPY_DECL_ASSEMBLER_NAME (newdecl
, olddecl
);
2051 COPY_DECL_RTL (newdecl
, olddecl
);
2053 if (! types_match
|| new_defines_function
)
2055 /* These need to be copied so that the names are available.
2056 Note that if the types do match, we'll preserve inline
2057 info and other bits, but if not, we won't. */
2058 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
2059 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
2061 if (new_defines_function
)
2062 /* If defining a function declared with other language
2063 linkage, use the previously declared language linkage. */
2064 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
2065 else if (types_match
)
2067 /* If redeclaring a builtin function, and not a definition,
2068 it stays built in. */
2069 if (DECL_BUILT_IN (olddecl
))
2071 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
2072 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
2073 /* If we're keeping the built-in definition, keep the rtl,
2074 regardless of declaration matches. */
2075 COPY_DECL_RTL (olddecl
, newdecl
);
2078 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
2079 /* Don't clear out the arguments if we're just redeclaring a
2081 if (DECL_ARGUMENTS (olddecl
))
2082 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
2085 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
2086 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
2088 /* Now preserve various other info from the definition. */
2089 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
2090 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
2091 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
2092 COPY_DECL_ASSEMBLER_NAME (olddecl
, newdecl
);
2094 /* Warn about conflicting visibility specifications. */
2095 if (DECL_VISIBILITY_SPECIFIED (olddecl
)
2096 && DECL_VISIBILITY_SPECIFIED (newdecl
)
2097 && DECL_VISIBILITY (newdecl
) != DECL_VISIBILITY (olddecl
))
2099 warning_at (input_location
, OPT_Wattributes
,
2100 "%q+D: visibility attribute ignored because it", newdecl
);
2101 warning_at (DECL_SOURCE_LOCATION (olddecl
), OPT_Wattributes
,
2102 "conflicts with previous declaration here");
2104 /* Choose the declaration which specified visibility. */
2105 if (DECL_VISIBILITY_SPECIFIED (olddecl
))
2107 DECL_VISIBILITY (newdecl
) = DECL_VISIBILITY (olddecl
);
2108 DECL_VISIBILITY_SPECIFIED (newdecl
) = 1;
2110 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2111 so keep this behavior. */
2112 if (TREE_CODE (newdecl
) == VAR_DECL
&& DECL_HAS_INIT_PRIORITY_P (newdecl
))
2114 SET_DECL_INIT_PRIORITY (olddecl
, DECL_INIT_PRIORITY (newdecl
));
2115 DECL_HAS_INIT_PRIORITY_P (olddecl
) = 1;
2118 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2119 with that from NEWDECL below. */
2120 if (DECL_LANG_SPECIFIC (olddecl
))
2122 gcc_assert (DECL_LANG_SPECIFIC (olddecl
)
2123 != DECL_LANG_SPECIFIC (newdecl
));
2124 ggc_free (DECL_LANG_SPECIFIC (olddecl
));
2127 /* Merge the USED information. */
2128 if (TREE_USED (olddecl
))
2129 TREE_USED (newdecl
) = 1;
2130 else if (TREE_USED (newdecl
))
2131 TREE_USED (olddecl
) = 1;
2132 if (DECL_PRESERVE_P (olddecl
))
2133 DECL_PRESERVE_P (newdecl
) = 1;
2134 else if (DECL_PRESERVE_P (newdecl
))
2135 DECL_PRESERVE_P (olddecl
) = 1;
2137 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2141 function_size
= sizeof (struct tree_decl_common
);
2143 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2144 (char *) newdecl
+ sizeof (struct tree_common
),
2145 function_size
- sizeof (struct tree_common
));
2147 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2148 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2149 sizeof (struct tree_function_decl
) - sizeof (struct tree_decl_common
));
2150 if (new_template_info
)
2151 /* If newdecl is a template instantiation, it is possible that
2152 the following sequence of events has occurred:
2154 o A friend function was declared in a class template. The
2155 class template was instantiated.
2157 o The instantiation of the friend declaration was
2158 recorded on the instantiation list, and is newdecl.
2160 o Later, however, instantiate_class_template called pushdecl
2161 on the newdecl to perform name injection. But, pushdecl in
2162 turn called duplicate_decls when it discovered that another
2163 declaration of a global function with the same name already
2166 o Here, in duplicate_decls, we decided to clobber newdecl.
2168 If we're going to do that, we'd better make sure that
2169 olddecl, and not newdecl, is on the list of
2170 instantiations so that if we try to do the instantiation
2171 again we won't get the clobbered declaration. */
2172 reregister_specialization (newdecl
,
2178 size_t size
= tree_code_size (TREE_CODE (olddecl
));
2179 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2180 (char *) newdecl
+ sizeof (struct tree_common
),
2181 sizeof (struct tree_decl_common
) - sizeof (struct tree_common
));
2182 switch (TREE_CODE (olddecl
))
2192 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2193 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2194 size
- sizeof (struct tree_decl_common
)
2195 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2199 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2200 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2201 sizeof (struct tree_decl_non_common
) - sizeof (struct tree_decl_common
)
2202 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2206 DECL_UID (olddecl
) = olddecl_uid
;
2208 DECL_FRIEND_P (olddecl
) = 1;
2211 DECL_ANTICIPATED (olddecl
) = 1;
2212 DECL_HIDDEN_FRIEND_P (olddecl
) = 1;
2215 /* NEWDECL contains the merged attribute lists.
2216 Update OLDDECL to be the same. */
2217 DECL_ATTRIBUTES (olddecl
) = DECL_ATTRIBUTES (newdecl
);
2219 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2220 so that encode_section_info has a chance to look at the new decl
2221 flags and attributes. */
2222 if (DECL_RTL_SET_P (olddecl
)
2223 && (TREE_CODE (olddecl
) == FUNCTION_DECL
2224 || (TREE_CODE (olddecl
) == VAR_DECL
2225 && TREE_STATIC (olddecl
))))
2226 make_decl_rtl (olddecl
);
2228 /* The NEWDECL will no longer be needed. Because every out-of-class
2229 declaration of a member results in a call to duplicate_decls,
2230 freeing these nodes represents in a significant savings. */
2236 /* Return zero if the declaration NEWDECL is valid
2237 when the declaration OLDDECL (assumed to be for the same name)
2238 has already been seen.
2239 Otherwise return an error message format string with a %s
2240 where the identifier should go. */
2243 redeclaration_error_message (tree newdecl
, tree olddecl
)
2245 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2247 /* Because C++ can put things into name space for free,
2248 constructs like "typedef struct foo { ... } foo"
2249 would look like an erroneous redeclaration. */
2250 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
2253 return G_("redefinition of %q#D");
2255 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2257 /* If this is a pure function, its olddecl will actually be
2258 the original initialization to `0' (which we force to call
2259 abort()). Don't complain about redefinition in this case. */
2260 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_PURE_VIRTUAL_P (olddecl
)
2261 && DECL_INITIAL (olddecl
) == NULL_TREE
)
2264 /* If both functions come from different namespaces, this is not
2265 a redeclaration - this is a conflict with a used function. */
2266 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
2267 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
)
2268 && ! decls_match (olddecl
, newdecl
))
2269 return G_("%qD conflicts with used function");
2271 /* We'll complain about linkage mismatches in
2272 warn_extern_redeclared_static. */
2274 /* Defining the same name twice is no good. */
2275 if (DECL_INITIAL (olddecl
) != NULL_TREE
2276 && DECL_INITIAL (newdecl
) != NULL_TREE
)
2278 if (DECL_NAME (olddecl
) == NULL_TREE
)
2279 return G_("%q#D not declared in class");
2280 else if (!GNU_INLINE_P (olddecl
)
2281 || GNU_INLINE_P (newdecl
))
2282 return G_("redefinition of %q#D");
2285 if (DECL_DECLARED_INLINE_P (olddecl
) && DECL_DECLARED_INLINE_P (newdecl
))
2287 bool olda
= GNU_INLINE_P (olddecl
);
2288 bool newa
= GNU_INLINE_P (newdecl
);
2293 return G_("%q+D redeclared inline with "
2294 "%<gnu_inline%> attribute");
2296 return G_("%q+D redeclared inline without "
2297 "%<gnu_inline%> attribute");
2303 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2307 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2309 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl
))
2310 && COMPLETE_TYPE_P (TREE_TYPE (olddecl
)))
2311 return G_("redefinition of %q#D");
2315 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != FUNCTION_DECL
2316 || (DECL_TEMPLATE_RESULT (newdecl
)
2317 == DECL_TEMPLATE_RESULT (olddecl
)))
2320 nt
= DECL_TEMPLATE_RESULT (newdecl
);
2321 if (DECL_TEMPLATE_INFO (nt
))
2322 nt
= DECL_TEMPLATE_RESULT (template_for_substitution (nt
));
2323 ot
= DECL_TEMPLATE_RESULT (olddecl
);
2324 if (DECL_TEMPLATE_INFO (ot
))
2325 ot
= DECL_TEMPLATE_RESULT (template_for_substitution (ot
));
2326 if (DECL_INITIAL (nt
) && DECL_INITIAL (ot
)
2327 && (!GNU_INLINE_P (ot
) || GNU_INLINE_P (nt
)))
2328 return G_("redefinition of %q#D");
2330 if (DECL_DECLARED_INLINE_P (ot
) && DECL_DECLARED_INLINE_P (nt
))
2332 bool olda
= GNU_INLINE_P (ot
);
2333 bool newa
= GNU_INLINE_P (nt
);
2338 return G_("%q+D redeclared inline with "
2339 "%<gnu_inline%> attribute");
2341 return G_("%q+D redeclared inline without "
2342 "%<gnu_inline%> attribute");
2346 /* Core issue #226 (C++0x):
2348 If a friend function template declaration specifies a
2349 default template-argument, that declaration shall be a
2350 definition and shall be the only declaration of the
2351 function template in the translation unit. */
2352 if ((cxx_dialect
!= cxx98
)
2353 && TREE_CODE (ot
) == FUNCTION_DECL
&& DECL_FRIEND_P (ot
)
2354 && !check_default_tmpl_args (nt
, DECL_TEMPLATE_PARMS (newdecl
),
2355 /*is_primary=*/1, /*is_partial=*/0,
2356 /*is_friend_decl=*/2))
2357 return G_("redeclaration of friend %q#D "
2358 "may not have default template arguments");
2362 else if (TREE_CODE (newdecl
) == VAR_DECL
2363 && DECL_THREAD_LOCAL_P (newdecl
) != DECL_THREAD_LOCAL_P (olddecl
)
2364 && (! DECL_LANG_SPECIFIC (olddecl
)
2365 || ! CP_DECL_THREADPRIVATE_P (olddecl
)
2366 || DECL_THREAD_LOCAL_P (newdecl
)))
2368 /* Only variables can be thread-local, and all declarations must
2369 agree on this property. */
2370 if (DECL_THREAD_LOCAL_P (newdecl
))
2371 return G_("thread-local declaration of %q#D follows "
2372 "non-thread-local declaration");
2374 return G_("non-thread-local declaration of %q#D follows "
2375 "thread-local declaration");
2377 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl
))
2379 /* The objects have been declared at namespace scope. If either
2380 is a member of an anonymous union, then this is an invalid
2381 redeclaration. For example:
2387 if ((TREE_CODE (newdecl
) == VAR_DECL
&& DECL_ANON_UNION_VAR_P (newdecl
))
2388 || (TREE_CODE (olddecl
) == VAR_DECL
&& DECL_ANON_UNION_VAR_P (olddecl
)))
2389 return G_("redeclaration of %q#D");
2390 /* If at least one declaration is a reference, there is no
2391 conflict. For example:
2397 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
2399 /* Reject two definitions. */
2400 return G_("redefinition of %q#D");
2404 /* Objects declared with block scope: */
2405 /* Reject two definitions, and reject a definition
2406 together with an external reference. */
2407 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
2408 return G_("redeclaration of %q#D");
2413 /* Hash and equality functions for the named_label table. */
2416 named_label_entry_hash (const void *data
)
2418 const struct named_label_entry
*ent
= (const struct named_label_entry
*) data
;
2419 return DECL_UID (ent
->label_decl
);
2423 named_label_entry_eq (const void *a
, const void *b
)
2425 const struct named_label_entry
*ent_a
= (const struct named_label_entry
*) a
;
2426 const struct named_label_entry
*ent_b
= (const struct named_label_entry
*) b
;
2427 return ent_a
->label_decl
== ent_b
->label_decl
;
2430 /* Create a new label, named ID. */
2433 make_label_decl (tree id
, int local_p
)
2435 struct named_label_entry
*ent
;
2439 decl
= build_decl (input_location
, LABEL_DECL
, id
, void_type_node
);
2441 DECL_CONTEXT (decl
) = current_function_decl
;
2442 DECL_MODE (decl
) = VOIDmode
;
2443 C_DECLARED_LABEL_FLAG (decl
) = local_p
;
2445 /* Say where one reference is to the label, for the sake of the
2446 error if it is not defined. */
2447 DECL_SOURCE_LOCATION (decl
) = input_location
;
2449 /* Record the fact that this identifier is bound to this label. */
2450 SET_IDENTIFIER_LABEL_VALUE (id
, decl
);
2452 /* Create the label htab for the function on demand. */
2454 named_labels
= htab_create_ggc (13, named_label_entry_hash
,
2455 named_label_entry_eq
, NULL
);
2457 /* Record this label on the list of labels used in this function.
2458 We do this before calling make_label_decl so that we get the
2459 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2460 ent
= GGC_CNEW (struct named_label_entry
);
2461 ent
->label_decl
= decl
;
2463 slot
= htab_find_slot (named_labels
, ent
, INSERT
);
2464 gcc_assert (*slot
== NULL
);
2470 /* Look for a label named ID in the current function. If one cannot
2471 be found, create one. (We keep track of used, but undefined,
2472 labels, and complain about them at the end of a function.) */
2475 lookup_label (tree id
)
2479 timevar_push (TV_NAME_LOOKUP
);
2480 /* You can't use labels at global scope. */
2481 if (current_function_decl
== NULL_TREE
)
2483 error ("label %qE referenced outside of any function", id
);
2484 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
2487 /* See if we've already got this label. */
2488 decl
= IDENTIFIER_LABEL_VALUE (id
);
2489 if (decl
!= NULL_TREE
&& DECL_CONTEXT (decl
) == current_function_decl
)
2490 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2492 decl
= make_label_decl (id
, /*local_p=*/0);
2493 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2496 /* Declare a local label named ID. */
2499 declare_local_label (tree id
)
2503 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2504 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2505 shadow
= tree_cons (IDENTIFIER_LABEL_VALUE (id
), NULL_TREE
,
2506 current_binding_level
->shadowed_labels
);
2507 current_binding_level
->shadowed_labels
= shadow
;
2509 decl
= make_label_decl (id
, /*local_p=*/1);
2510 TREE_VALUE (shadow
) = decl
;
2515 /* Returns nonzero if it is ill-formed to jump past the declaration of
2516 DECL. Returns 2 if it's also a real problem. */
2519 decl_jump_unsafe (tree decl
)
2521 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
2522 with automatic storage duration is not in scope to a point where it is
2523 in scope is ill-formed unless the variable has scalar type, class type
2524 with a trivial default constructor and a trivial destructor, a
2525 cv-qualified version of one of these types, or an array of one of the
2526 preceding types and is declared without an initializer (8.5). */
2527 tree type
= TREE_TYPE (decl
);
2529 if (TREE_CODE (decl
) != VAR_DECL
|| TREE_STATIC (decl
)
2530 || type
== error_mark_node
)
2533 type
= strip_array_types (type
);
2535 if (type_has_nontrivial_default_init (TREE_TYPE (decl
))
2536 || DECL_NONTRIVIALLY_INITIALIZED_P (decl
))
2539 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
2545 /* A subroutine of check_previous_goto_1 to identify a branch to the user. */
2548 identify_goto (tree decl
, const location_t
*locus
)
2551 permerror (input_location
, "jump to label %qD", decl
);
2553 permerror (input_location
, "jump to case label");
2555 permerror (*locus
, " from here");
2558 /* Check that a single previously seen jump to a newly defined label
2559 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2560 the jump context; NAMES are the names in scope in LEVEL at the jump
2561 context; LOCUS is the source position of the jump or 0. Returns
2562 true if all is well. */
2565 check_previous_goto_1 (tree decl
, struct cp_binding_level
* level
, tree names
,
2566 bool exited_omp
, const location_t
*locus
)
2568 struct cp_binding_level
*b
;
2569 bool identified
= false, saw_eh
= false, saw_omp
= false;
2573 identify_goto (decl
, locus
);
2574 error (" exits OpenMP structured block");
2575 identified
= saw_omp
= true;
2578 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
2580 tree new_decls
, old_decls
= (b
== level
? names
: NULL_TREE
);
2582 for (new_decls
= b
->names
; new_decls
!= old_decls
;
2583 new_decls
= TREE_CHAIN (new_decls
))
2585 int problem
= decl_jump_unsafe (new_decls
);
2591 identify_goto (decl
, locus
);
2595 error (" crosses initialization of %q+#D", new_decls
);
2597 permerror (input_location
, " enters scope of %q+#D which has "
2598 "non-trivial destructor", new_decls
);
2603 if ((b
->kind
== sk_try
|| b
->kind
== sk_catch
) && !saw_eh
)
2607 identify_goto (decl
, locus
);
2610 if (b
->kind
== sk_try
)
2611 error (" enters try block");
2613 error (" enters catch block");
2616 if (b
->kind
== sk_omp
&& !saw_omp
)
2620 identify_goto (decl
, locus
);
2623 error (" enters OpenMP structured block");
2632 check_previous_goto (tree decl
, struct named_label_use_entry
*use
)
2634 check_previous_goto_1 (decl
, use
->binding_level
,
2635 use
->names_in_scope
, use
->in_omp_scope
,
2636 &use
->o_goto_locus
);
2640 check_switch_goto (struct cp_binding_level
* level
)
2642 return check_previous_goto_1 (NULL_TREE
, level
, level
->names
, false, NULL
);
2645 /* Check that a new jump to a label DECL is OK. Called by
2646 finish_goto_stmt. */
2649 check_goto (tree decl
)
2651 struct named_label_entry
*ent
, dummy
;
2652 bool saw_catch
= false, identified
= false;
2655 /* We can't know where a computed goto is jumping.
2656 So we assume that it's OK. */
2657 if (TREE_CODE (decl
) != LABEL_DECL
)
2660 /* We didn't record any information about this label when we created it,
2661 and there's not much point since it's trivial to analyze as a return. */
2662 if (decl
== cdtor_label
)
2665 dummy
.label_decl
= decl
;
2666 ent
= (struct named_label_entry
*) htab_find (named_labels
, &dummy
);
2667 gcc_assert (ent
!= NULL
);
2669 /* If the label hasn't been defined yet, defer checking. */
2670 if (! DECL_INITIAL (decl
))
2672 struct named_label_use_entry
*new_use
;
2674 /* Don't bother creating another use if the last goto had the
2675 same data, and will therefore create the same set of errors. */
2677 && ent
->uses
->names_in_scope
== current_binding_level
->names
)
2680 new_use
= GGC_NEW (struct named_label_use_entry
);
2681 new_use
->binding_level
= current_binding_level
;
2682 new_use
->names_in_scope
= current_binding_level
->names
;
2683 new_use
->o_goto_locus
= input_location
;
2684 new_use
->in_omp_scope
= false;
2686 new_use
->next
= ent
->uses
;
2687 ent
->uses
= new_use
;
2691 if (ent
->in_try_scope
|| ent
->in_catch_scope
2692 || ent
->in_omp_scope
|| ent
->bad_decls
)
2694 permerror (input_location
, "jump to label %q+D", decl
);
2695 permerror (input_location
, " from here");
2699 for (bad
= ent
->bad_decls
; bad
; bad
= TREE_CHAIN (bad
))
2701 tree b
= TREE_VALUE (bad
);
2702 int u
= decl_jump_unsafe (b
);
2704 if (u
> 1 && DECL_ARTIFICIAL (b
))
2706 /* Can't skip init of __exception_info. */
2707 error_at (DECL_SOURCE_LOCATION (b
), " enters catch block");
2711 error (" skips initialization of %q+#D", b
);
2713 permerror (input_location
, " enters scope of %q+#D which has "
2714 "non-trivial destructor", b
);
2717 if (ent
->in_try_scope
)
2718 error (" enters try block");
2719 else if (ent
->in_catch_scope
&& !saw_catch
)
2720 error (" enters catch block");
2722 if (ent
->in_omp_scope
)
2723 error (" enters OpenMP structured block");
2724 else if (flag_openmp
)
2726 struct cp_binding_level
*b
;
2727 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
2729 if (b
== ent
->binding_level
)
2731 if (b
->kind
== sk_omp
)
2735 permerror (input_location
, "jump to label %q+D", decl
);
2736 permerror (input_location
, " from here");
2739 error (" exits OpenMP structured block");
2746 /* Check that a return is ok wrt OpenMP structured blocks.
2747 Called by finish_return_stmt. Returns true if all is well. */
2750 check_omp_return (void)
2752 struct cp_binding_level
*b
;
2753 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
2754 if (b
->kind
== sk_omp
)
2756 error ("invalid exit from OpenMP structured block");
2762 /* Define a label, specifying the location in the source file.
2763 Return the LABEL_DECL node for the label. */
2766 define_label (location_t location
, tree name
)
2768 struct named_label_entry
*ent
, dummy
;
2769 struct cp_binding_level
*p
;
2772 timevar_push (TV_NAME_LOOKUP
);
2774 decl
= lookup_label (name
);
2776 dummy
.label_decl
= decl
;
2777 ent
= (struct named_label_entry
*) htab_find (named_labels
, &dummy
);
2778 gcc_assert (ent
!= NULL
);
2780 /* After labels, make any new cleanups in the function go into their
2781 own new (temporary) binding contour. */
2782 for (p
= current_binding_level
;
2783 p
->kind
!= sk_function_parms
;
2785 p
->more_cleanups_ok
= 0;
2787 if (name
== get_identifier ("wchar_t"))
2788 permerror (input_location
, "label named wchar_t");
2790 if (DECL_INITIAL (decl
) != NULL_TREE
)
2792 error ("duplicate label %qD", decl
);
2793 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
2797 struct named_label_use_entry
*use
;
2799 /* Mark label as having been defined. */
2800 DECL_INITIAL (decl
) = error_mark_node
;
2801 /* Say where in the source. */
2802 DECL_SOURCE_LOCATION (decl
) = location
;
2804 ent
->binding_level
= current_binding_level
;
2805 ent
->names_in_scope
= current_binding_level
->names
;
2807 for (use
= ent
->uses
; use
; use
= use
->next
)
2808 check_previous_goto (decl
, use
);
2812 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2817 struct cp_binding_level
*level
;
2818 struct cp_switch
*next
;
2819 /* The SWITCH_STMT being built. */
2821 /* A splay-tree mapping the low element of a case range to the high
2822 element, or NULL_TREE if there is no high element. Used to
2823 determine whether or not a new case label duplicates an old case
2824 label. We need a tree, rather than simply a hash table, because
2825 of the GNU case range extension. */
2829 /* A stack of the currently active switch statements. The innermost
2830 switch statement is on the top of the stack. There is no need to
2831 mark the stack for garbage collection because it is only active
2832 during the processing of the body of a function, and we never
2833 collect at that point. */
2835 static struct cp_switch
*switch_stack
;
2837 /* Called right after a switch-statement condition is parsed.
2838 SWITCH_STMT is the switch statement being parsed. */
2841 push_switch (tree switch_stmt
)
2843 struct cp_switch
*p
= XNEW (struct cp_switch
);
2844 p
->level
= current_binding_level
;
2845 p
->next
= switch_stack
;
2846 p
->switch_stmt
= switch_stmt
;
2847 p
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
2854 struct cp_switch
*cs
= switch_stack
;
2855 location_t switch_location
;
2857 /* Emit warnings as needed. */
2858 if (EXPR_HAS_LOCATION (cs
->switch_stmt
))
2859 switch_location
= EXPR_LOCATION (cs
->switch_stmt
);
2861 switch_location
= input_location
;
2862 if (!processing_template_decl
)
2863 c_do_switch_warnings (cs
->cases
, switch_location
,
2864 SWITCH_STMT_TYPE (cs
->switch_stmt
),
2865 SWITCH_STMT_COND (cs
->switch_stmt
));
2867 splay_tree_delete (cs
->cases
);
2868 switch_stack
= switch_stack
->next
;
2872 /* Note that we've seen a definition of a case label, and complain if this
2873 is a bad place for one. */
2876 finish_case_label (location_t loc
, tree low_value
, tree high_value
)
2879 struct cp_binding_level
*p
;
2881 if (processing_template_decl
)
2885 /* For templates, just add the case label; we'll do semantic
2886 analysis at instantiation-time. */
2887 label
= build_decl (loc
, LABEL_DECL
, NULL_TREE
, NULL_TREE
);
2888 return add_stmt (build_case_label (loc
, low_value
, high_value
, label
));
2891 /* Find the condition on which this switch statement depends. */
2892 cond
= SWITCH_STMT_COND (switch_stack
->switch_stmt
);
2893 if (cond
&& TREE_CODE (cond
) == TREE_LIST
)
2894 cond
= TREE_VALUE (cond
);
2896 if (!check_switch_goto (switch_stack
->level
))
2897 return error_mark_node
;
2899 r
= c_add_case_label (loc
, switch_stack
->cases
, cond
,
2900 SWITCH_STMT_TYPE (switch_stack
->switch_stmt
),
2901 low_value
, high_value
);
2903 /* After labels, make any new cleanups in the function go into their
2904 own new (temporary) binding contour. */
2905 for (p
= current_binding_level
;
2906 p
->kind
!= sk_function_parms
;
2908 p
->more_cleanups_ok
= 0;
2913 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
2916 typename_hash (const void* k
)
2919 const_tree
const t
= (const_tree
) k
;
2921 hash
= (htab_hash_pointer (TYPE_CONTEXT (t
))
2922 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t
))));
2927 typedef struct typename_info
{
2935 /* Compare two TYPENAME_TYPEs. K1 is really of type `tree', K2 is
2936 really of type `typename_info*' */
2939 typename_compare (const void * k1
, const void * k2
)
2941 const_tree
const t1
= (const_tree
) k1
;
2942 const typename_info
*const t2
= (const typename_info
*) k2
;
2944 return (DECL_NAME (TYPE_NAME (t1
)) == t2
->name
2945 && TYPE_CONTEXT (t1
) == t2
->scope
2946 && TYPENAME_TYPE_FULLNAME (t1
) == t2
->template_id
2947 && TYPENAME_IS_ENUM_P (t1
) == t2
->enum_p
2948 && TYPENAME_IS_CLASS_P (t1
) == t2
->class_p
);
2951 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
2952 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
2954 Returns the new TYPENAME_TYPE. */
2956 static GTY ((param_is (union tree_node
))) htab_t typename_htab
;
2959 build_typename_type (tree context
, tree name
, tree fullname
,
2960 enum tag_types tag_type
)
2968 if (typename_htab
== NULL
)
2969 typename_htab
= htab_create_ggc (61, &typename_hash
,
2970 &typename_compare
, NULL
);
2972 ti
.scope
= FROB_CONTEXT (context
);
2974 ti
.template_id
= fullname
;
2975 ti
.enum_p
= tag_type
== enum_type
;
2976 ti
.class_p
= (tag_type
== class_type
2977 || tag_type
== record_type
2978 || tag_type
== union_type
);
2979 hash
= (htab_hash_pointer (ti
.scope
)
2980 ^ htab_hash_pointer (ti
.name
));
2982 /* See if we already have this type. */
2983 e
= htab_find_slot_with_hash (typename_htab
, &ti
, hash
, INSERT
);
2988 /* Build the TYPENAME_TYPE. */
2989 t
= cxx_make_type (TYPENAME_TYPE
);
2990 TYPE_CONTEXT (t
) = ti
.scope
;
2991 TYPENAME_TYPE_FULLNAME (t
) = ti
.template_id
;
2992 TYPENAME_IS_ENUM_P (t
) = ti
.enum_p
;
2993 TYPENAME_IS_CLASS_P (t
) = ti
.class_p
;
2995 /* Build the corresponding TYPE_DECL. */
2996 d
= build_decl (input_location
, TYPE_DECL
, name
, t
);
2997 TYPE_NAME (TREE_TYPE (d
)) = d
;
2998 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
2999 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3000 DECL_ARTIFICIAL (d
) = 1;
3002 /* Store it in the hash table. */
3005 /* TYPENAME_TYPEs must always be compared structurally, because
3006 they may or may not resolve down to another type depending on
3007 the currently open classes. */
3008 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3014 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
3015 provided to name the type. Returns an appropriate type, unless an
3016 error occurs, in which case error_mark_node is returned. If we
3017 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
3018 return that, rather than the _TYPE it corresponds to, in other
3019 cases we look through the type decl. If TF_ERROR is set, complain
3020 about errors, otherwise be quiet. */
3023 make_typename_type (tree context
, tree name
, enum tag_types tag_type
,
3024 tsubst_flags_t complain
)
3030 if (name
== error_mark_node
3031 || context
== NULL_TREE
3032 || context
== error_mark_node
)
3033 return error_mark_node
;
3037 if (!(TYPE_LANG_SPECIFIC (name
)
3038 && (CLASSTYPE_IS_TEMPLATE (name
)
3039 || CLASSTYPE_USE_TEMPLATE (name
))))
3040 name
= TYPE_IDENTIFIER (name
);
3042 /* Create a TEMPLATE_ID_EXPR for the type. */
3043 name
= build_nt (TEMPLATE_ID_EXPR
,
3044 CLASSTYPE_TI_TEMPLATE (name
),
3045 CLASSTYPE_TI_ARGS (name
));
3047 else if (TREE_CODE (name
) == TYPE_DECL
)
3048 name
= DECL_NAME (name
);
3052 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
3054 name
= TREE_OPERAND (name
, 0);
3055 if (TREE_CODE (name
) == TEMPLATE_DECL
)
3056 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
3057 else if (TREE_CODE (name
) == OVERLOAD
)
3059 error ("%qD is not a type", name
);
3060 return error_mark_node
;
3063 if (TREE_CODE (name
) == TEMPLATE_DECL
)
3065 error ("%qD used without template parameters", name
);
3066 return error_mark_node
;
3068 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
3069 gcc_assert (TYPE_P (context
));
3071 if (!MAYBE_CLASS_TYPE_P (context
))
3073 if (complain
& tf_error
)
3074 error ("%q#T is not a class", context
);
3075 return error_mark_node
;
3078 /* When the CONTEXT is a dependent type, NAME could refer to a
3079 dependent base class of CONTEXT. But look inside it anyway
3080 if CONTEXT is a currently open scope, in case it refers to a
3081 member of the current instantiation or a non-dependent base;
3082 lookup will stop when we hit a dependent base. */
3083 if (!dependent_scope_p (context
))
3084 /* We should only set WANT_TYPE when we're a nested typename type.
3085 Then we can give better diagnostics if we find a non-type. */
3086 t
= lookup_field (context
, name
, 2, /*want_type=*/true);
3090 if ((!t
|| TREE_CODE (t
) == TREE_LIST
) && dependent_type_p (context
))
3091 return build_typename_type (context
, name
, fullname
, tag_type
);
3093 want_template
= TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
;
3097 if (complain
& tf_error
)
3098 error (want_template
? "no class template named %q#T in %q#T"
3099 : "no type named %q#T in %q#T", name
, context
);
3100 return error_mark_node
;
3103 /* Pull out the template from an injected-class-name (or multiple). */
3105 t
= maybe_get_template_decl_from_type_decl (t
);
3107 if (TREE_CODE (t
) == TREE_LIST
)
3109 if (complain
& tf_error
)
3111 error ("lookup of %qT in %qT is ambiguous", name
, context
);
3112 print_candidates (t
);
3114 return error_mark_node
;
3117 if (want_template
&& !DECL_CLASS_TEMPLATE_P (t
))
3119 if (complain
& tf_error
)
3120 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3122 return error_mark_node
;
3124 if (!want_template
&& TREE_CODE (t
) != TYPE_DECL
)
3126 if (complain
& tf_error
)
3127 error ("%<typename %T::%D%> names %q#T, which is not a type",
3129 return error_mark_node
;
3132 if (complain
& tf_error
)
3133 perform_or_defer_access_check (TYPE_BINFO (context
), t
, t
);
3135 /* If we are currently parsing a template and if T is a typedef accessed
3136 through CONTEXT then we need to remember and check access of T at
3137 template instantiation time. */
3138 add_typedef_to_current_template_for_access_check (t
, context
, input_location
);
3141 return lookup_template_class (t
, TREE_OPERAND (fullname
, 1),
3143 /*entering_scope=*/0,
3144 tf_warning_or_error
| tf_user
);
3146 if (DECL_ARTIFICIAL (t
) || !(complain
& tf_keep_type_decl
))
3152 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3153 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3154 in which case error_mark_node is returned.
3156 If PARM_LIST is non-NULL, also make sure that the template parameter
3157 list of TEMPLATE_DECL matches.
3159 If COMPLAIN zero, don't complain about any errors that occur. */
3162 make_unbound_class_template (tree context
, tree name
, tree parm_list
,
3163 tsubst_flags_t complain
)
3169 name
= TYPE_IDENTIFIER (name
);
3170 else if (DECL_P (name
))
3171 name
= DECL_NAME (name
);
3172 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
3174 if (!dependent_type_p (context
)
3175 || currently_open_class (context
))
3177 tree tmpl
= NULL_TREE
;
3179 if (MAYBE_CLASS_TYPE_P (context
))
3180 tmpl
= lookup_field (context
, name
, 0, false);
3182 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
3184 if (complain
& tf_error
)
3185 error ("no class template named %q#T in %q#T", name
, context
);
3186 return error_mark_node
;
3190 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl
), parm_list
))
3192 if (complain
& tf_error
)
3194 error ("template parameters do not match template");
3195 error ("%q+D declared here", tmpl
);
3197 return error_mark_node
;
3200 if (complain
& tf_error
)
3201 perform_or_defer_access_check (TYPE_BINFO (context
), tmpl
, tmpl
);
3206 /* Build the UNBOUND_CLASS_TEMPLATE. */
3207 t
= cxx_make_type (UNBOUND_CLASS_TEMPLATE
);
3208 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
3209 TREE_TYPE (t
) = NULL_TREE
;
3210 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3212 /* Build the corresponding TEMPLATE_DECL. */
3213 d
= build_decl (input_location
, TEMPLATE_DECL
, name
, t
);
3214 TYPE_NAME (TREE_TYPE (d
)) = d
;
3215 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3216 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3217 DECL_ARTIFICIAL (d
) = 1;
3218 DECL_TEMPLATE_PARMS (d
) = parm_list
;
3225 /* Push the declarations of builtin types into the namespace.
3226 RID_INDEX is the index of the builtin type in the array
3227 RID_POINTERS. NAME is the name used when looking up the builtin
3228 type. TYPE is the _TYPE node for the builtin type. */
3231 record_builtin_type (enum rid rid_index
,
3235 tree rname
= NULL_TREE
, tname
= NULL_TREE
;
3236 tree tdecl
= NULL_TREE
;
3238 if ((int) rid_index
< (int) RID_MAX
)
3239 rname
= ridpointers
[(int) rid_index
];
3241 tname
= get_identifier (name
);
3243 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
3244 eliminated. Built-in types should not be looked up name; their
3245 names are keywords that the parser can recognize. However, there
3246 is code in c-common.c that uses identifier_global_value to look
3247 up built-in types by name. */
3250 tdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, tname
, type
);
3251 DECL_ARTIFICIAL (tdecl
) = 1;
3252 SET_IDENTIFIER_GLOBAL_VALUE (tname
, tdecl
);
3258 tdecl
= build_decl (BUILTINS_LOCATION
, TYPE_DECL
, rname
, type
);
3259 DECL_ARTIFICIAL (tdecl
) = 1;
3261 SET_IDENTIFIER_GLOBAL_VALUE (rname
, tdecl
);
3264 if (!TYPE_NAME (type
))
3265 TYPE_NAME (type
) = tdecl
;
3268 debug_hooks
->type_decl (tdecl
, 0);
3271 /* Record one of the standard Java types.
3272 * Declare it as having the given NAME.
3273 * If SIZE > 0, it is the size of one of the integral types;
3274 * otherwise it is the negative of the size of one of the other types. */
3277 record_builtin_java_type (const char* name
, int size
)
3281 type
= build_nonstandard_integer_type (size
, 0);
3282 else if (size
> -32)
3285 /* "__java_char" or ""__java_boolean". */
3286 type
= build_nonstandard_integer_type (-size
, 1);
3287 /* Get the signed type cached and attached to the unsigned type,
3288 so it doesn't get garbage-collected at "random" times,
3289 causing potential codegen differences out of different UIDs
3290 and different alias set numbers. */
3291 stype
= build_nonstandard_integer_type (-size
, 0);
3292 TREE_CHAIN (type
) = stype
;
3293 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
3296 { /* "__java_float" or ""__java_double". */
3297 type
= make_node (REAL_TYPE
);
3298 TYPE_PRECISION (type
) = - size
;
3301 record_builtin_type (RID_MAX
, name
, type
);
3302 decl
= TYPE_NAME (type
);
3304 /* Suppress generate debug symbol entries for these types,
3305 since for normal C++ they are just clutter.
3306 However, push_lang_context undoes this if extern "Java" is seen. */
3307 DECL_IGNORED_P (decl
) = 1;
3309 TYPE_FOR_JAVA (type
) = 1;
3313 /* Push a type into the namespace so that the back ends ignore it. */
3316 record_unknown_type (tree type
, const char* name
)
3318 tree decl
= pushdecl (build_decl (UNKNOWN_LOCATION
,
3319 TYPE_DECL
, get_identifier (name
), type
));
3320 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3321 DECL_IGNORED_P (decl
) = 1;
3322 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
3323 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
3324 TYPE_ALIGN (type
) = 1;
3325 TYPE_USER_ALIGN (type
) = 0;
3326 SET_TYPE_MODE (type
, TYPE_MODE (void_type_node
));
3329 /* A string for which we should create an IDENTIFIER_NODE at
3332 typedef struct predefined_identifier
3334 /* The name of the identifier. */
3335 const char *const name
;
3336 /* The place where the IDENTIFIER_NODE should be stored. */
3338 /* Nonzero if this is the name of a constructor or destructor. */
3339 const int ctor_or_dtor_p
;
3340 } predefined_identifier
;
3342 /* Create all the predefined identifiers. */
3345 initialize_predefined_identifiers (void)
3347 const predefined_identifier
*pid
;
3349 /* A table of identifiers to create at startup. */
3350 static const predefined_identifier predefined_identifiers
[] = {
3351 { "C++", &lang_name_cplusplus
, 0 },
3352 { "C", &lang_name_c
, 0 },
3353 { "Java", &lang_name_java
, 0 },
3354 /* Some of these names have a trailing space so that it is
3355 impossible for them to conflict with names written by users. */
3356 { "__ct ", &ctor_identifier
, 1 },
3357 { "__base_ctor ", &base_ctor_identifier
, 1 },
3358 { "__comp_ctor ", &complete_ctor_identifier
, 1 },
3359 { "__dt ", &dtor_identifier
, 1 },
3360 { "__comp_dtor ", &complete_dtor_identifier
, 1 },
3361 { "__base_dtor ", &base_dtor_identifier
, 1 },
3362 { "__deleting_dtor ", &deleting_dtor_identifier
, 1 },
3363 { IN_CHARGE_NAME
, &in_charge_identifier
, 0 },
3364 { "nelts", &nelts_identifier
, 0 },
3365 { THIS_NAME
, &this_identifier
, 0 },
3366 { VTABLE_DELTA_NAME
, &delta_identifier
, 0 },
3367 { VTABLE_PFN_NAME
, &pfn_identifier
, 0 },
3368 { "_vptr", &vptr_identifier
, 0 },
3369 { "__vtt_parm", &vtt_parm_identifier
, 0 },
3370 { "::", &global_scope_name
, 0 },
3371 { "std", &std_identifier
, 0 },
3375 for (pid
= predefined_identifiers
; pid
->name
; ++pid
)
3377 *pid
->node
= get_identifier (pid
->name
);
3378 if (pid
->ctor_or_dtor_p
)
3379 IDENTIFIER_CTOR_OR_DTOR_P (*pid
->node
) = 1;
3383 /* Create the predefined scalar types of C,
3384 and some nodes representing standard constants (0, 1, (void *)0).
3385 Initialize the global binding level.
3386 Make definitions for built-in primitive functions. */
3389 cxx_init_decl_processing (void)
3392 tree void_ftype_ptr
;
3394 build_common_tree_nodes (flag_signed_char
);
3396 /* Create all the identifiers we need. */
3397 initialize_predefined_identifiers ();
3399 /* Create the global variables. */
3400 push_to_top_level ();
3402 current_function_decl
= NULL_TREE
;
3403 current_binding_level
= NULL
;
3404 /* Enter the global namespace. */
3405 gcc_assert (global_namespace
== NULL_TREE
);
3406 global_namespace
= build_lang_decl (NAMESPACE_DECL
, global_scope_name
,
3408 TREE_PUBLIC (global_namespace
) = 1;
3409 begin_scope (sk_namespace
, global_namespace
);
3411 current_lang_name
= NULL_TREE
;
3413 if (flag_visibility_ms_compat
)
3414 default_visibility
= VISIBILITY_HIDDEN
;
3417 current_lang_name
= lang_name_c
;
3419 /* Create the `std' namespace. */
3420 push_namespace (std_identifier
);
3421 std_node
= current_namespace
;
3424 c_common_nodes_and_builtins ();
3426 java_byte_type_node
= record_builtin_java_type ("__java_byte", 8);
3427 java_short_type_node
= record_builtin_java_type ("__java_short", 16);
3428 java_int_type_node
= record_builtin_java_type ("__java_int", 32);
3429 java_long_type_node
= record_builtin_java_type ("__java_long", 64);
3430 java_float_type_node
= record_builtin_java_type ("__java_float", -32);
3431 java_double_type_node
= record_builtin_java_type ("__java_double", -64);
3432 java_char_type_node
= record_builtin_java_type ("__java_char", -16);
3433 java_boolean_type_node
= record_builtin_java_type ("__java_boolean", -1);
3435 integer_two_node
= build_int_cst (NULL_TREE
, 2);
3436 integer_three_node
= build_int_cst (NULL_TREE
, 3);
3438 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
3439 truthvalue_type_node
= boolean_type_node
;
3440 truthvalue_false_node
= boolean_false_node
;
3441 truthvalue_true_node
= boolean_true_node
;
3443 empty_except_spec
= build_tree_list (NULL_TREE
, NULL_TREE
);
3446 record_builtin_type (RID_MAX
, NULL
, string_type_node
);
3449 delta_type_node
= ptrdiff_type_node
;
3450 vtable_index_type
= ptrdiff_type_node
;
3452 vtt_parm_type
= build_pointer_type (const_ptr_type_node
);
3453 void_ftype
= build_function_type (void_type_node
, void_list_node
);
3454 void_ftype_ptr
= build_function_type (void_type_node
,
3455 tree_cons (NULL_TREE
,
3459 = build_exception_variant (void_ftype_ptr
, empty_except_spec
);
3461 /* C++ extensions */
3463 unknown_type_node
= make_node (UNKNOWN_TYPE
);
3464 record_unknown_type (unknown_type_node
, "unknown type");
3466 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3467 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
3469 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3471 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
3472 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
3474 init_list_type_node
= make_node (UNKNOWN_TYPE
);
3475 record_unknown_type (init_list_type_node
, "init list");
3478 /* Make sure we get a unique function type, so we can give
3479 its pointer type a name. (This wins for gdb.) */
3480 tree vfunc_type
= make_node (FUNCTION_TYPE
);
3481 TREE_TYPE (vfunc_type
) = integer_type_node
;
3482 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
3483 layout_type (vfunc_type
);
3485 vtable_entry_type
= build_pointer_type (vfunc_type
);
3487 record_builtin_type (RID_MAX
, VTBL_PTR_TYPE
, vtable_entry_type
);
3490 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
3491 layout_type (vtbl_type_node
);
3492 vtbl_type_node
= build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
3493 record_builtin_type (RID_MAX
, NULL
, vtbl_type_node
);
3494 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
3495 layout_type (vtbl_ptr_type_node
);
3496 record_builtin_type (RID_MAX
, NULL
, vtbl_ptr_type_node
);
3498 push_namespace (get_identifier ("__cxxabiv1"));
3499 abi_node
= current_namespace
;
3502 global_type_node
= make_node (LANG_TYPE
);
3503 record_unknown_type (global_type_node
, "global type");
3506 current_lang_name
= lang_name_cplusplus
;
3510 tree bad_alloc_type_node
;
3511 tree bad_alloc_decl
;
3512 tree newtype
, deltype
;
3513 tree ptr_ftype_sizetype
;
3515 push_namespace (std_identifier
);
3516 bad_alloc_id
= get_identifier ("bad_alloc");
3517 bad_alloc_type_node
= make_class_type (RECORD_TYPE
);
3518 TYPE_CONTEXT (bad_alloc_type_node
) = current_namespace
;
3520 = create_implicit_typedef (bad_alloc_id
, bad_alloc_type_node
);
3521 DECL_CONTEXT (bad_alloc_decl
) = current_namespace
;
3525 = build_function_type (ptr_type_node
,
3526 tree_cons (NULL_TREE
,
3529 newtype
= build_exception_variant
3530 (ptr_ftype_sizetype
, add_exception_specifier
3531 (NULL_TREE
, bad_alloc_type_node
, -1));
3532 deltype
= build_exception_variant (void_ftype_ptr
, empty_except_spec
);
3533 push_cp_library_fn (NEW_EXPR
, newtype
);
3534 push_cp_library_fn (VEC_NEW_EXPR
, newtype
);
3535 global_delete_fndecl
= push_cp_library_fn (DELETE_EXPR
, deltype
);
3536 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
);
3540 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype
);
3542 /* Perform other language dependent initializations. */
3543 init_class_processing ();
3544 init_rtti_processing ();
3545 init_template_processing ();
3547 if (flag_exceptions
)
3548 init_exception_processing ();
3550 if (! supports_one_only ())
3553 make_fname_decl
= cp_make_fname_decl
;
3554 start_fname_decls ();
3556 /* Show we use EH for cleanups. */
3557 if (flag_exceptions
)
3558 using_eh_for_cleanups ();
3561 /* Generate an initializer for a function naming variable from
3562 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3563 filled in with the type of the init. */
3566 cp_fname_init (const char* name
, tree
*type_p
)
3568 tree domain
= NULL_TREE
;
3570 tree init
= NULL_TREE
;
3575 length
= strlen (name
);
3576 domain
= build_index_type (size_int (length
));
3577 init
= build_string (length
+ 1, name
);
3580 type
= build_qualified_type (char_type_node
, TYPE_QUAL_CONST
);
3581 type
= build_cplus_array_type (type
, domain
);
3586 TREE_TYPE (init
) = type
;
3588 init
= error_mark_node
;
3593 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
3594 the decl, LOC is the location to give the decl, NAME is the
3595 initialization string and TYPE_DEP indicates whether NAME depended
3596 on the type of the function. We make use of that to detect
3597 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
3598 at the point of first use, so we mustn't push the decl now. */
3601 cp_make_fname_decl (location_t loc
, tree id
, int type_dep
)
3603 const char *const name
= (type_dep
&& processing_template_decl
3604 ? NULL
: fname_as_string (type_dep
));
3606 tree init
= cp_fname_init (name
, &type
);
3607 tree decl
= build_decl (loc
, VAR_DECL
, id
, type
);
3610 free (CONST_CAST (char *, name
));
3612 /* As we're using pushdecl_with_scope, we must set the context. */
3613 DECL_CONTEXT (decl
) = current_function_decl
;
3614 DECL_PRETTY_FUNCTION_P (decl
) = type_dep
;
3616 TREE_STATIC (decl
) = 1;
3617 TREE_READONLY (decl
) = 1;
3618 DECL_ARTIFICIAL (decl
) = 1;
3620 TREE_USED (decl
) = 1;
3622 if (current_function_decl
)
3624 struct cp_binding_level
*b
= current_binding_level
;
3625 while (b
->level_chain
->kind
!= sk_function_parms
)
3627 pushdecl_with_scope (decl
, b
, /*is_friend=*/false);
3628 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, NULL_TREE
,
3629 LOOKUP_ONLYCONVERTING
);
3632 pushdecl_top_level_and_finish (decl
, init
);
3638 builtin_function_1 (tree decl
, tree context
, bool is_global
)
3640 tree id
= DECL_NAME (decl
);
3641 const char *name
= IDENTIFIER_POINTER (id
);
3643 retrofit_lang_decl (decl
);
3645 DECL_ARTIFICIAL (decl
) = 1;
3646 SET_OVERLOADED_OPERATOR_CODE (decl
, ERROR_MARK
);
3647 SET_DECL_LANGUAGE (decl
, lang_c
);
3648 /* Runtime library routines are, by definition, available in an
3649 external shared object. */
3650 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
3651 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
3653 DECL_CONTEXT (decl
) = context
;
3656 pushdecl_top_level (decl
);
3660 /* A function in the user's namespace should have an explicit
3661 declaration before it is used. Mark the built-in function as
3662 anticipated but not actually declared. */
3663 if (name
[0] != '_' || name
[1] != '_')
3664 DECL_ANTICIPATED (decl
) = 1;
3665 else if (strncmp (name
+ 2, "builtin_", strlen ("builtin_")) != 0)
3667 size_t len
= strlen (name
);
3669 /* Treat __*_chk fortification functions as anticipated as well,
3670 unless they are __builtin_*. */
3671 if (len
> strlen ("___chk")
3672 && memcmp (name
+ len
- strlen ("_chk"),
3673 "_chk", strlen ("_chk") + 1) == 0)
3674 DECL_ANTICIPATED (decl
) = 1;
3681 cxx_builtin_function (tree decl
)
3683 tree id
= DECL_NAME (decl
);
3684 const char *name
= IDENTIFIER_POINTER (id
);
3685 /* All builtins that don't begin with an '_' should additionally
3686 go in the 'std' namespace. */
3689 tree decl2
= copy_node(decl
);
3690 push_namespace (std_identifier
);
3691 builtin_function_1 (decl2
, std_node
, false);
3695 return builtin_function_1 (decl
, NULL_TREE
, false);
3698 /* Like cxx_builtin_function, but guarantee the function is added to the global
3699 scope. This is to allow function specific options to add new machine
3700 dependent builtins when the target ISA changes via attribute((target(...)))
3701 which saves space on program startup if the program does not use non-generic
3705 cxx_builtin_function_ext_scope (tree decl
)
3708 tree id
= DECL_NAME (decl
);
3709 const char *name
= IDENTIFIER_POINTER (id
);
3710 /* All builtins that don't begin with an '_' should additionally
3711 go in the 'std' namespace. */
3714 tree decl2
= copy_node(decl
);
3715 push_namespace (std_identifier
);
3716 builtin_function_1 (decl2
, std_node
, true);
3720 return builtin_function_1 (decl
, NULL_TREE
, true);
3723 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
3724 function. Not called directly. */
3727 build_library_fn_1 (tree name
, enum tree_code operator_code
, tree type
)
3729 tree fn
= build_lang_decl (FUNCTION_DECL
, name
, type
);
3730 DECL_EXTERNAL (fn
) = 1;
3731 TREE_PUBLIC (fn
) = 1;
3732 DECL_ARTIFICIAL (fn
) = 1;
3733 SET_OVERLOADED_OPERATOR_CODE (fn
, operator_code
);
3734 SET_DECL_LANGUAGE (fn
, lang_c
);
3735 /* Runtime library routines are, by definition, available in an
3736 external shared object. */
3737 DECL_VISIBILITY (fn
) = VISIBILITY_DEFAULT
;
3738 DECL_VISIBILITY_SPECIFIED (fn
) = 1;
3742 /* Returns the _DECL for a library function with C linkage.
3743 We assume that such functions never throw; if this is incorrect,
3744 callers should unset TREE_NOTHROW. */
3747 build_library_fn (tree name
, tree type
)
3749 tree fn
= build_library_fn_1 (name
, ERROR_MARK
, type
);
3750 TREE_NOTHROW (fn
) = 1;
3754 /* Returns the _DECL for a library function with C++ linkage. */
3757 build_cp_library_fn (tree name
, enum tree_code operator_code
, tree type
)
3759 tree fn
= build_library_fn_1 (name
, operator_code
, type
);
3760 TREE_NOTHROW (fn
) = TYPE_NOTHROW_P (type
);
3761 DECL_CONTEXT (fn
) = FROB_CONTEXT (current_namespace
);
3762 SET_DECL_LANGUAGE (fn
, lang_cplusplus
);
3766 /* Like build_library_fn, but takes a C string instead of an
3770 build_library_fn_ptr (const char* name
, tree type
)
3772 return build_library_fn (get_identifier (name
), type
);
3775 /* Like build_cp_library_fn, but takes a C string instead of an
3779 build_cp_library_fn_ptr (const char* name
, tree type
)
3781 return build_cp_library_fn (get_identifier (name
), ERROR_MARK
, type
);
3784 /* Like build_library_fn, but also pushes the function so that we will
3785 be able to find it via IDENTIFIER_GLOBAL_VALUE. Also, the function
3786 may throw exceptions listed in RAISES. */
3789 push_library_fn (tree name
, tree type
, tree raises
)
3794 type
= build_exception_variant (type
, raises
);
3796 fn
= build_library_fn (name
, type
);
3797 pushdecl_top_level (fn
);
3801 /* Like build_cp_library_fn, but also pushes the function so that it
3802 will be found by normal lookup. */
3805 push_cp_library_fn (enum tree_code operator_code
, tree type
)
3807 tree fn
= build_cp_library_fn (ansi_opname (operator_code
),
3814 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
3818 push_void_library_fn (tree name
, tree parmtypes
)
3820 tree type
= build_function_type (void_type_node
, parmtypes
);
3821 return push_library_fn (name
, type
, NULL_TREE
);
3824 /* Like push_library_fn, but also note that this function throws
3825 and does not return. Used for __throw_foo and the like. */
3828 push_throw_library_fn (tree name
, tree type
)
3830 tree fn
= push_library_fn (name
, type
, NULL_TREE
);
3831 TREE_THIS_VOLATILE (fn
) = 1;
3832 TREE_NOTHROW (fn
) = 0;
3836 /* When we call finish_struct for an anonymous union, we create
3837 default copy constructors and such. But, an anonymous union
3838 shouldn't have such things; this function undoes the damage to the
3839 anonymous union type T.
3841 (The reason that we create the synthesized methods is that we don't
3842 distinguish `union { int i; }' from `typedef union { int i; } U'.
3843 The first is an anonymous union; the second is just an ordinary
3847 fixup_anonymous_aggr (tree t
)
3851 /* Wipe out memory of synthesized methods. */
3852 TYPE_HAS_USER_CONSTRUCTOR (t
) = 0;
3853 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
3854 TYPE_HAS_INIT_REF (t
) = 0;
3855 TYPE_HAS_CONST_INIT_REF (t
) = 0;
3856 TYPE_HAS_ASSIGN_REF (t
) = 0;
3857 TYPE_HAS_CONST_ASSIGN_REF (t
) = 0;
3859 /* Splice the implicitly generated functions out of the TYPE_METHODS
3861 q
= &TYPE_METHODS (t
);
3864 if (DECL_ARTIFICIAL (*q
))
3865 *q
= TREE_CHAIN (*q
);
3867 q
= &TREE_CHAIN (*q
);
3870 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
3871 if (TYPE_METHODS (t
))
3873 tree decl
= TYPE_MAIN_DECL (t
);
3875 if (TREE_CODE (t
) != UNION_TYPE
)
3876 error_at (DECL_SOURCE_LOCATION (decl
),
3877 "an anonymous struct cannot have function members");
3879 error_at (DECL_SOURCE_LOCATION (decl
),
3880 "an anonymous union cannot have function members");
3883 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
3884 assignment operators (because they cannot have these methods themselves).
3885 For anonymous unions this is already checked because they are not allowed
3886 in any union, otherwise we have to check it. */
3887 if (TREE_CODE (t
) != UNION_TYPE
)
3891 for (field
= TYPE_FIELDS (t
); field
; field
= TREE_CHAIN (field
))
3892 if (TREE_CODE (field
) == FIELD_DECL
)
3894 type
= TREE_TYPE (field
);
3895 if (CLASS_TYPE_P (type
))
3897 if (TYPE_NEEDS_CONSTRUCTING (type
))
3898 error ("member %q+#D with constructor not allowed "
3899 "in anonymous aggregate", field
);
3900 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
3901 error ("member %q+#D with destructor not allowed "
3902 "in anonymous aggregate", field
);
3903 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type
))
3904 error ("member %q+#D with copy assignment operator "
3905 "not allowed in anonymous aggregate", field
);
3911 /* Make sure that a declaration with no declarator is well-formed, i.e.
3912 just declares a tagged type or anonymous union.
3914 Returns the type declared; or NULL_TREE if none. */
3917 check_tag_decl (cp_decl_specifier_seq
*declspecs
)
3919 int saw_friend
= declspecs
->specs
[(int)ds_friend
] != 0;
3920 int saw_typedef
= declspecs
->specs
[(int)ds_typedef
] != 0;
3921 /* If a class, struct, or enum type is declared by the DECLSPECS
3922 (i.e, if a class-specifier, enum-specifier, or non-typename
3923 elaborated-type-specifier appears in the DECLSPECS),
3924 DECLARED_TYPE is set to the corresponding type. */
3925 tree declared_type
= NULL_TREE
;
3926 bool error_p
= false;
3928 if (declspecs
->multiple_types_p
)
3929 error ("multiple types in one declaration");
3930 else if (declspecs
->redefined_builtin_type
)
3932 if (!in_system_header
)
3933 permerror (input_location
, "redeclaration of C++ built-in type %qT",
3934 declspecs
->redefined_builtin_type
);
3939 && TYPE_P (declspecs
->type
)
3940 && ((TREE_CODE (declspecs
->type
) != TYPENAME_TYPE
3941 && MAYBE_CLASS_TYPE_P (declspecs
->type
))
3942 || TREE_CODE (declspecs
->type
) == ENUMERAL_TYPE
))
3943 declared_type
= declspecs
->type
;
3944 else if (declspecs
->type
== error_mark_node
)
3946 if (declared_type
== NULL_TREE
&& ! saw_friend
&& !error_p
)
3947 permerror (input_location
, "declaration does not declare anything");
3948 /* Check for an anonymous union. */
3949 else if (declared_type
&& RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type
))
3950 && TYPE_ANONYMOUS_P (declared_type
))
3952 /* 7/3 In a simple-declaration, the optional init-declarator-list
3953 can be omitted only when declaring a class (clause 9) or
3954 enumeration (7.2), that is, when the decl-specifier-seq contains
3955 either a class-specifier, an elaborated-type-specifier with
3956 a class-key (9.1), or an enum-specifier. In these cases and
3957 whenever a class-specifier or enum-specifier is present in the
3958 decl-specifier-seq, the identifiers in these specifiers are among
3959 the names being declared by the declaration (as class-name,
3960 enum-names, or enumerators, depending on the syntax). In such
3961 cases, and except for the declaration of an unnamed bit-field (9.6),
3962 the decl-specifier-seq shall introduce one or more names into the
3963 program, or shall redeclare a name introduced by a previous
3964 declaration. [Example:
3965 enum { }; // ill-formed
3966 typedef class { }; // ill-formed
3970 error ("missing type-name in typedef-declaration");
3973 /* Anonymous unions are objects, so they can have specifiers. */;
3974 SET_ANON_AGGR_TYPE_P (declared_type
);
3976 if (TREE_CODE (declared_type
) != UNION_TYPE
&& !in_system_header
)
3977 pedwarn (input_location
, OPT_pedantic
, "ISO C++ prohibits anonymous structs");
3982 if (declspecs
->specs
[(int)ds_inline
]
3983 || declspecs
->specs
[(int)ds_virtual
])
3984 error ("%qs can only be specified for functions",
3985 declspecs
->specs
[(int)ds_inline
]
3986 ? "inline" : "virtual");
3988 && (!current_class_type
3989 || current_scope () != current_class_type
))
3990 error ("%<friend%> can only be specified inside a class");
3991 else if (declspecs
->specs
[(int)ds_explicit
])
3992 error ("%<explicit%> can only be specified for constructors");
3993 else if (declspecs
->storage_class
)
3994 error ("a storage class can only be specified for objects "
3996 else if (declspecs
->specs
[(int)ds_const
]
3997 || declspecs
->specs
[(int)ds_volatile
]
3998 || declspecs
->specs
[(int)ds_restrict
]
3999 || declspecs
->specs
[(int)ds_thread
])
4000 error ("qualifiers can only be specified for objects "
4002 else if (saw_typedef
)
4003 warning (0, "%<typedef%> was ignored in this declaration");
4004 else if (declspecs
->specs
[(int) ds_constexpr
])
4005 error ("%<constexpr> cannot be used for type declarations");
4008 return declared_type
;
4011 /* Called when a declaration is seen that contains no names to declare.
4012 If its type is a reference to a structure, union or enum inherited
4013 from a containing scope, shadow that tag name for the current scope
4014 with a forward reference.
4015 If its type defines a new named structure or union
4016 or defines an enum, it is valid but we need not do anything here.
4017 Otherwise, it is an error.
4019 C++: may have to grok the declspecs to learn about static,
4020 complain for anonymous unions.
4022 Returns the TYPE declared -- or NULL_TREE if none. */
4025 shadow_tag (cp_decl_specifier_seq
*declspecs
)
4027 tree t
= check_tag_decl (declspecs
);
4032 if (declspecs
->attributes
)
4034 warning (0, "attribute ignored in declaration of %q+#T", t
);
4035 warning (0, "attribute for %q+#T must follow the %qs keyword",
4036 t
, class_key_or_enum_as_string (t
));
4040 if (maybe_process_partial_specialization (t
) == error_mark_node
)
4043 /* This is where the variables in an anonymous union are
4044 declared. An anonymous union declaration looks like:
4046 because there is no declarator after the union, the parser
4047 sends that declaration here. */
4048 if (ANON_AGGR_TYPE_P (t
))
4050 fixup_anonymous_aggr (t
);
4052 if (TYPE_FIELDS (t
))
4054 tree decl
= grokdeclarator (/*declarator=*/NULL
,
4055 declspecs
, NORMAL
, 0, NULL
);
4056 finish_anon_union (decl
);
4063 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
4066 groktypename (cp_decl_specifier_seq
*type_specifiers
,
4067 const cp_declarator
*declarator
,
4068 bool is_template_arg
)
4072 enum decl_context context
4073 = is_template_arg
? TEMPLATE_TYPE_ARG
: TYPENAME
;
4074 attrs
= type_specifiers
->attributes
;
4075 type_specifiers
->attributes
= NULL_TREE
;
4076 type
= grokdeclarator (declarator
, type_specifiers
, context
, 0, &attrs
);
4077 if (attrs
&& type
!= error_mark_node
)
4079 if (CLASS_TYPE_P (type
))
4080 warning (OPT_Wattributes
, "ignoring attributes applied to class type %qT "
4081 "outside of definition", type
);
4082 else if (MAYBE_CLASS_TYPE_P (type
))
4083 /* A template type parameter or other dependent type. */
4084 warning (OPT_Wattributes
, "ignoring attributes applied to dependent "
4085 "type %qT without an associated declaration", type
);
4087 cplus_decl_attributes (&type
, attrs
, 0);
4092 /* Process a DECLARATOR for a function-scope variable declaration,
4093 namespace-scope variable declaration, or function declaration.
4094 (Function definitions go through start_function; class member
4095 declarations appearing in the body of the class go through
4096 grokfield.) The DECL corresponding to the DECLARATOR is returned.
4097 If an error occurs, the error_mark_node is returned instead.
4099 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
4100 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
4101 for an explicitly defaulted function, or SD_DELETED for an explicitly
4102 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
4103 implicitly initialized via a default constructor. ATTRIBUTES and
4104 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
4105 *PUSHED_SCOPE_P is set to the scope entered in this function, if any; if
4106 set, the caller is responsible for calling pop_scope. */
4109 start_decl (const cp_declarator
*declarator
,
4110 cp_decl_specifier_seq
*declspecs
,
4113 tree prefix_attributes
,
4114 tree
*pushed_scope_p
)
4121 *pushed_scope_p
= NULL_TREE
;
4123 /* An object declared as __attribute__((deprecated)) suppresses
4124 warnings of uses of other deprecated items. */
4125 if (lookup_attribute ("deprecated", attributes
))
4126 deprecated_state
= DEPRECATED_SUPPRESS
;
4128 attributes
= chainon (attributes
, prefix_attributes
);
4130 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
4133 deprecated_state
= DEPRECATED_NORMAL
;
4135 if (decl
== NULL_TREE
|| TREE_CODE (decl
) == VOID_TYPE
4136 || decl
== error_mark_node
)
4137 return error_mark_node
;
4139 context
= DECL_CONTEXT (decl
);
4143 *pushed_scope_p
= push_scope (context
);
4145 /* We are only interested in class contexts, later. */
4146 if (TREE_CODE (context
) == NAMESPACE_DECL
)
4147 context
= NULL_TREE
;
4151 /* Is it valid for this decl to have an initializer at all?
4152 If not, set INITIALIZED to zero, which will indirectly
4153 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
4154 switch (TREE_CODE (decl
))
4157 error ("typedef %qD is initialized (use decltype instead)", decl
);
4158 return error_mark_node
;
4161 if (initialized
== SD_DELETED
)
4162 /* We'll handle the rest of the semantics later, but we need to
4163 set this now so it's visible to duplicate_decls. */
4164 DECL_DELETED_FN (decl
) = 1;
4173 if (! toplevel_bindings_p ()
4174 && DECL_EXTERNAL (decl
))
4175 warning (0, "declaration of %q#D has %<extern%> and is initialized",
4177 DECL_EXTERNAL (decl
) = 0;
4178 if (toplevel_bindings_p ())
4179 TREE_STATIC (decl
) = 1;
4182 /* If this is a typedef that names the class for linkage purposes
4183 (7.1.3p8), apply any attributes directly to the type. */
4184 if (TREE_CODE (decl
) == TYPE_DECL
4185 && TAGGED_TYPE_P (TREE_TYPE (decl
))
4186 && decl
== TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl
))))
4187 flags
= ATTR_FLAG_TYPE_IN_PLACE
;
4191 /* Set attributes here so if duplicate decl, will have proper attributes. */
4192 cplus_decl_attributes (&decl
, attributes
, flags
);
4194 /* Dllimported symbols cannot be defined. Static data members (which
4195 can be initialized in-class and dllimported) go through grokfield,
4196 not here, so we don't need to exclude those decls when checking for
4198 if (initialized
&& DECL_DLLIMPORT_P (decl
))
4200 error ("definition of %q#D is marked %<dllimport%>", decl
);
4201 DECL_DLLIMPORT_P (decl
) = 0;
4204 /* If #pragma weak was used, mark the decl weak now. */
4205 maybe_apply_pragma_weak (decl
);
4207 if (TREE_CODE (decl
) == FUNCTION_DECL
4208 && DECL_DECLARED_INLINE_P (decl
)
4209 && DECL_UNINLINABLE (decl
)
4210 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
4211 warning (0, "inline function %q+D given attribute noinline", decl
);
4213 if (context
&& COMPLETE_TYPE_P (complete_type (context
)))
4215 if (TREE_CODE (decl
) == VAR_DECL
)
4217 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, false);
4218 if (field
== NULL_TREE
|| TREE_CODE (field
) != VAR_DECL
)
4219 error ("%q#D is not a static member of %q#T", decl
, context
);
4222 if (DECL_CONTEXT (field
) != context
)
4224 if (!same_type_p (DECL_CONTEXT (field
), context
))
4225 permerror (input_location
, "ISO C++ does not permit %<%T::%D%> "
4226 "to be defined as %<%T::%D%>",
4227 DECL_CONTEXT (field
), DECL_NAME (decl
),
4228 context
, DECL_NAME (decl
));
4229 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
4231 if (processing_specialization
4232 && template_class_depth (context
) == 0
4233 && CLASSTYPE_TEMPLATE_SPECIALIZATION (context
))
4234 error ("template header not allowed in member definition "
4235 "of explicitly specialized class");
4236 /* Static data member are tricky; an in-class initialization
4237 still doesn't provide a definition, so the in-class
4238 declaration will have DECL_EXTERNAL set, but will have an
4239 initialization. Thus, duplicate_decls won't warn
4240 about this situation, and so we check here. */
4241 if (initialized
&& DECL_INITIALIZED_IN_CLASS_P (field
))
4242 error ("duplicate initialization of %qD", decl
);
4243 if (duplicate_decls (decl
, field
, /*newdecl_is_friend=*/false))
4245 if (declspecs
->specs
[(int) ds_constexpr
]
4246 && !DECL_DECLARED_CONSTEXPR_P (field
))
4247 error ("%qD declared %<constexpr%> outside its class", field
);
4252 tree field
= check_classfn (context
, decl
,
4253 (processing_template_decl
4254 > template_class_depth (context
))
4255 ? current_template_parms
4257 if (field
&& field
!= error_mark_node
4258 && duplicate_decls (decl
, field
,
4259 /*newdecl_is_friend=*/false))
4263 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
4264 DECL_IN_AGGR_P (decl
) = 0;
4265 /* Do not mark DECL as an explicit specialization if it was not
4266 already marked as an instantiation; a declaration should
4267 never be marked as a specialization unless we know what
4268 template is being specialized. */
4269 if (DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
4271 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
4273 /* [temp.expl.spec] An explicit specialization of a static data
4274 member of a template is a definition if the declaration
4275 includes an initializer; otherwise, it is a declaration.
4277 We check for processing_specialization so this only applies
4278 to the new specialization syntax. */
4279 if (!initialized
&& processing_specialization
)
4280 DECL_EXTERNAL (decl
) = 1;
4283 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
))
4284 permerror (input_location
, "declaration of %q#D outside of class is not definition",
4287 if (!ensure_literal_type_for_constexpr_object (decl
))
4288 return error_mark_node
;
4291 was_public
= TREE_PUBLIC (decl
);
4293 /* Enter this declaration into the symbol table. */
4294 decl
= maybe_push_decl (decl
);
4296 if (processing_template_decl
)
4297 decl
= push_template_decl (decl
);
4298 if (decl
== error_mark_node
)
4299 return error_mark_node
;
4301 /* Tell the back end to use or not use .common as appropriate. If we say
4302 -fconserve-space, we want this to save .data space, at the expense of
4303 wrong semantics. If we say -fno-conserve-space, we want this to
4304 produce errors about redefs; to do this we force variables into the
4306 if (flag_conserve_space
4307 && TREE_CODE (decl
) == VAR_DECL
4308 && TREE_PUBLIC (decl
)
4309 && !DECL_THREAD_LOCAL_P (decl
)
4310 && !have_global_bss_p ())
4311 DECL_COMMON (decl
) = 1;
4313 if (TREE_CODE (decl
) == VAR_DECL
4314 && DECL_NAMESPACE_SCOPE_P (decl
) && !TREE_PUBLIC (decl
) && !was_public
4315 && !DECL_THIS_STATIC (decl
) && !DECL_ARTIFICIAL (decl
))
4317 /* This is a const variable with implicit 'static'. Set
4318 DECL_THIS_STATIC so we can tell it from variables that are
4319 !TREE_PUBLIC because of the anonymous namespace. */
4320 gcc_assert (cp_type_readonly (TREE_TYPE (decl
)));
4321 DECL_THIS_STATIC (decl
) = 1;
4324 if (!processing_template_decl
&& TREE_CODE (decl
) == VAR_DECL
)
4325 start_decl_1 (decl
, initialized
);
4330 /* Process the declaration of a variable DECL. INITIALIZED is true
4331 iff DECL is explicitly initialized. (INITIALIZED is false if the
4332 variable is initialized via an implicitly-called constructor.)
4333 This function must be called for ordinary variables (including, for
4334 example, implicit instantiations of templates), but must not be
4335 called for template declarations. */
4338 start_decl_1 (tree decl
, bool initialized
)
4342 bool aggregate_definition_p
;
4344 gcc_assert (!processing_template_decl
);
4346 if (error_operand_p (decl
))
4349 gcc_assert (TREE_CODE (decl
) == VAR_DECL
);
4351 type
= TREE_TYPE (decl
);
4352 complete_p
= COMPLETE_TYPE_P (type
);
4353 aggregate_definition_p
= MAYBE_CLASS_TYPE_P (type
) && !DECL_EXTERNAL (decl
);
4355 /* If an explicit initializer is present, or if this is a definition
4356 of an aggregate, then we need a complete type at this point.
4357 (Scalars are always complete types, so there is nothing to
4358 check.) This code just sets COMPLETE_P; errors (if necessary)
4359 are issued below. */
4360 if ((initialized
|| aggregate_definition_p
)
4362 && COMPLETE_TYPE_P (complete_type (type
)))
4365 /* We will not yet have set TREE_READONLY on DECL if the type
4366 was "const", but incomplete, before this point. But, now, we
4367 have a complete type, so we can try again. */
4368 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
4372 /* Is it valid for this decl to have an initializer at all? */
4374 /* Don't allow initializations for incomplete types except for
4375 arrays which might be completed by the initialization. */
4377 ; /* A complete type is ok. */
4378 else if (type_uses_auto (type
))
4379 ; /* An auto type is ok. */
4380 else if (TREE_CODE (type
) != ARRAY_TYPE
)
4382 error ("variable %q#D has initializer but incomplete type", decl
);
4383 type
= TREE_TYPE (decl
) = error_mark_node
;
4385 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
4387 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
4388 error ("elements of array %q#D have incomplete type", decl
);
4389 /* else we already gave an error in start_decl. */
4392 else if (aggregate_definition_p
&& !complete_p
)
4394 if (type_uses_auto (type
))
4395 error ("declaration of %q#D has no initializer", decl
);
4397 error ("aggregate %q#D has incomplete type and cannot be defined",
4399 /* Change the type so that assemble_variable will give
4400 DECL an rtl we can live with: (mem (const_int 0)). */
4401 type
= TREE_TYPE (decl
) = error_mark_node
;
4404 /* Create a new scope to hold this declaration if necessary.
4405 Whether or not a new scope is necessary cannot be determined
4406 until after the type has been completed; if the type is a
4407 specialization of a class template it is not until after
4408 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4409 will be set correctly. */
4410 maybe_push_cleanup_level (type
);
4413 /* Handle initialization of references. DECL, TYPE, and INIT have the
4414 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
4415 but will be set to a new CLEANUP_STMT if a temporary is created
4416 that must be destroyed subsequently.
4418 Returns an initializer expression to use to initialize DECL, or
4419 NULL if the initialization can be performed statically.
4421 Quotes on semantics can be found in ARM 8.4.3. */
4424 grok_reference_init (tree decl
, tree type
, tree init
, tree
*cleanup
)
4428 if (init
== NULL_TREE
)
4430 if ((DECL_LANG_SPECIFIC (decl
) == 0
4431 || DECL_IN_AGGR_P (decl
) == 0)
4432 && ! DECL_THIS_EXTERN (decl
))
4433 error ("%qD declared as reference but not initialized", decl
);
4437 if (TREE_CODE (init
) == TREE_LIST
)
4438 init
= build_x_compound_expr_from_list (init
, "initializer");
4440 if (TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
4441 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
4442 /* Note: default conversion is only called in very special cases. */
4443 init
= decay_conversion (init
);
4445 /* Convert INIT to the reference type TYPE. This may involve the
4446 creation of a temporary, whose lifetime must be the same as that
4447 of the reference. If so, a DECL_EXPR for the temporary will be
4448 added just after the DECL_EXPR for DECL. That's why we don't set
4449 DECL_INITIAL for local references (instead assigning to them
4450 explicitly); we need to allow the temporary to be initialized
4452 tmp
= initialize_reference (type
, init
, decl
, cleanup
, tf_warning_or_error
);
4454 if (tmp
== error_mark_node
)
4456 else if (tmp
== NULL_TREE
)
4458 error ("cannot initialize %qT from %qT", type
, TREE_TYPE (init
));
4462 if (TREE_STATIC (decl
) && !TREE_CONSTANT (tmp
))
4465 DECL_INITIAL (decl
) = tmp
;
4470 /* Subroutine of check_initializer. We're initializing a DECL of
4471 std::initializer_list<T> TYPE from a braced-init-list INIT, and need to
4472 extend the lifetime of the underlying array to match that of the decl,
4473 just like for reference initialization. CLEANUP is as for
4474 grok_reference_init. */
4477 build_init_list_var_init (tree decl
, tree type
, tree init
, tree
*cleanup
)
4479 tree aggr_init
, array
, arrtype
;
4480 init
= perform_implicit_conversion (type
, init
, tf_warning_or_error
);
4481 if (error_operand_p (init
))
4482 return error_mark_node
;
4484 aggr_init
= TARGET_EXPR_INITIAL (init
);
4485 init
= build2 (INIT_EXPR
, type
, decl
, init
);
4487 array
= AGGR_INIT_EXPR_ARG (aggr_init
, 1);
4488 arrtype
= TREE_TYPE (array
);
4490 gcc_assert (TREE_CODE (array
) == ADDR_EXPR
);
4491 array
= TREE_OPERAND (array
, 0);
4492 /* If the array is constant, finish_compound_literal already made it a
4493 static variable and we don't need to do anything here. */
4494 if (decl
&& TREE_CODE (array
) == TARGET_EXPR
)
4497 tree var
= set_up_extended_ref_temp (decl
, array
, cleanup
, &subinit
);
4498 var
= build_address (var
);
4499 var
= convert (arrtype
, var
);
4500 AGGR_INIT_EXPR_ARG (aggr_init
, 1) = var
;
4501 init
= build2 (COMPOUND_EXPR
, TREE_TYPE (init
), subinit
, init
);
4506 /* Designated initializers in arrays are not supported in GNU C++.
4507 The parser cannot detect this error since it does not know whether
4508 a given brace-enclosed initializer is for a class type or for an
4509 array. This function checks that CE does not use a designated
4510 initializer. If it does, an error is issued. Returns true if CE
4511 is valid, i.e., does not have a designated initializer. */
4514 check_array_designated_initializer (const constructor_elt
*ce
)
4516 /* Designated initializers for array elements are not supported. */
4519 /* The parser only allows identifiers as designated
4521 if (ce
->index
== error_mark_node
)
4522 error ("name used in a GNU-style designated "
4523 "initializer for an array");
4526 gcc_assert (TREE_CODE (ce
->index
) == IDENTIFIER_NODE
);
4527 error ("name %qD used in a GNU-style designated "
4528 "initializer for an array", ce
->index
);
4536 /* When parsing `int a[] = {1, 2};' we don't know the size of the
4537 array until we finish parsing the initializer. If that's the
4538 situation we're in, update DECL accordingly. */
4541 maybe_deduce_size_from_array_init (tree decl
, tree init
)
4543 tree type
= TREE_TYPE (decl
);
4545 if (TREE_CODE (type
) == ARRAY_TYPE
4546 && TYPE_DOMAIN (type
) == NULL_TREE
4547 && TREE_CODE (decl
) != TYPE_DECL
)
4549 /* do_default is really a C-ism to deal with tentative definitions.
4550 But let's leave it here to ease the eventual merge. */
4551 int do_default
= !DECL_EXTERNAL (decl
);
4552 tree initializer
= init
? init
: DECL_INITIAL (decl
);
4555 /* Check that there are no designated initializers in INIT, as
4556 those are not supported in GNU C++, and as the middle-end
4557 will crash if presented with a non-numeric designated
4559 if (initializer
&& TREE_CODE (initializer
) == CONSTRUCTOR
)
4561 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (initializer
);
4562 constructor_elt
*ce
;
4565 VEC_iterate (constructor_elt
, v
, i
, ce
);
4567 if (!check_array_designated_initializer (ce
))
4573 failure
= cp_complete_array_type (&TREE_TYPE (decl
), initializer
,
4577 error ("initializer fails to determine size of %qD", decl
);
4578 TREE_TYPE (decl
) = error_mark_node
;
4580 else if (failure
== 2)
4584 error ("array size missing in %qD", decl
);
4585 TREE_TYPE (decl
) = error_mark_node
;
4587 /* If a `static' var's size isn't known, make it extern as
4588 well as static, so it does not get allocated. If it's not
4589 `static', then don't mark it extern; finish_incomplete_decl
4590 will give it a default size and it will get allocated. */
4591 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
4592 DECL_EXTERNAL (decl
) = 1;
4594 else if (failure
== 3)
4596 error ("zero-size array %qD", decl
);
4597 TREE_TYPE (decl
) = error_mark_node
;
4601 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl
)), decl
);
4603 relayout_decl (decl
);
4607 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
4608 any appropriate error messages regarding the layout. */
4611 layout_var_decl (tree decl
)
4615 type
= TREE_TYPE (decl
);
4616 if (type
== error_mark_node
)
4619 /* If we haven't already layed out this declaration, do so now.
4620 Note that we must not call complete type for an external object
4621 because it's type might involve templates that we are not
4622 supposed to instantiate yet. (And it's perfectly valid to say
4623 `extern X x' for some incomplete type `X'.) */
4624 if (!DECL_EXTERNAL (decl
))
4625 complete_type (type
);
4626 if (!DECL_SIZE (decl
)
4627 && TREE_TYPE (decl
) != error_mark_node
4628 && (COMPLETE_TYPE_P (type
)
4629 || (TREE_CODE (type
) == ARRAY_TYPE
4630 && !TYPE_DOMAIN (type
)
4631 && COMPLETE_TYPE_P (TREE_TYPE (type
)))))
4632 layout_decl (decl
, 0);
4634 if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
4636 /* An automatic variable with an incomplete type: that is an error.
4637 Don't talk about array types here, since we took care of that
4638 message in grokdeclarator. */
4639 error ("storage size of %qD isn't known", decl
);
4640 TREE_TYPE (decl
) = error_mark_node
;
4643 /* Keep this code around in case we later want to control debug info
4644 based on whether a type is "used". (jason 1999-11-11) */
4646 else if (!DECL_EXTERNAL (decl
) && MAYBE_CLASS_TYPE_P (ttype
))
4647 /* Let debugger know it should output info for this type. */
4648 note_debug_info_needed (ttype
);
4650 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
4651 note_debug_info_needed (DECL_CONTEXT (decl
));
4654 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
4655 && DECL_SIZE (decl
) != NULL_TREE
4656 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
4658 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
4659 constant_expression_warning (DECL_SIZE (decl
));
4662 error ("storage size of %qD isn't constant", decl
);
4663 TREE_TYPE (decl
) = error_mark_node
;
4668 /* If a local static variable is declared in an inline function, or if
4669 we have a weak definition, we must endeavor to create only one
4670 instance of the variable at link-time. */
4673 maybe_commonize_var (tree decl
)
4675 /* Static data in a function with comdat linkage also has comdat
4677 if (TREE_STATIC (decl
)
4678 /* Don't mess with __FUNCTION__. */
4679 && ! DECL_ARTIFICIAL (decl
)
4680 && DECL_FUNCTION_SCOPE_P (decl
)
4681 && vague_linkage_p (DECL_CONTEXT (decl
)))
4685 /* With weak symbols, we simply make the variable COMDAT;
4686 that will cause copies in multiple translations units to
4688 comdat_linkage (decl
);
4692 if (DECL_INITIAL (decl
) == NULL_TREE
4693 || DECL_INITIAL (decl
) == error_mark_node
)
4695 /* Without weak symbols, we can use COMMON to merge
4696 uninitialized variables. */
4697 TREE_PUBLIC (decl
) = 1;
4698 DECL_COMMON (decl
) = 1;
4702 /* While for initialized variables, we must use internal
4703 linkage -- which means that multiple copies will not
4705 TREE_PUBLIC (decl
) = 0;
4706 DECL_COMMON (decl
) = 0;
4707 warning_at (input_location
, 0,
4708 "sorry: semantics of inline function static "
4709 "data %q+#D are wrong (you'll wind up "
4710 "with multiple copies)", decl
);
4711 warning_at (DECL_SOURCE_LOCATION (decl
), 0,
4712 " you can work around this by removing "
4717 else if (DECL_LANG_SPECIFIC (decl
) && DECL_COMDAT (decl
))
4718 /* Set it up again; we might have set DECL_INITIAL since the last
4720 comdat_linkage (decl
);
4723 /* Issue an error message if DECL is an uninitialized const variable. */
4726 check_for_uninitialized_const_var (tree decl
)
4728 tree type
= TREE_TYPE (decl
);
4730 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_DECLARED_CONSTEXPR_P (decl
)
4731 && DECL_INITIAL (decl
) == NULL
)
4732 error ("missing initializer for constexpr %qD", decl
);
4734 /* ``Unless explicitly declared extern, a const object does not have
4735 external linkage and must be initialized. ($8.4; $12.1)'' ARM
4737 else if (TREE_CODE (decl
) == VAR_DECL
4738 && TREE_CODE (type
) != REFERENCE_TYPE
4739 && CP_TYPE_CONST_P (type
)
4740 && !TYPE_NEEDS_CONSTRUCTING (type
)
4741 && !DECL_INITIAL (decl
))
4742 error ("uninitialized const %qD", decl
);
4746 /* Structure holding the current initializer being processed by reshape_init.
4747 CUR is a pointer to the current element being processed, END is a pointer
4748 after the last element present in the initializer. */
4749 typedef struct reshape_iterator_t
4751 constructor_elt
*cur
;
4752 constructor_elt
*end
;
4755 static tree
reshape_init_r (tree
, reshape_iter
*, bool);
4757 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
4758 returned is the next FIELD_DECL (possibly FIELD itself) that can be
4759 initialized. If there are no more such fields, the return value
4763 next_initializable_field (tree field
)
4766 && (TREE_CODE (field
) != FIELD_DECL
4767 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
4768 || DECL_ARTIFICIAL (field
)))
4769 field
= TREE_CHAIN (field
);
4774 /* Subroutine of reshape_init_array and reshape_init_vector, which does
4775 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
4776 INTEGER_CST representing the size of the array minus one (the maximum index),
4777 or NULL_TREE if the array was declared without specifying the size. D is
4778 the iterator within the constructor. */
4781 reshape_init_array_1 (tree elt_type
, tree max_index
, reshape_iter
*d
)
4784 bool sized_array_p
= (max_index
!= NULL_TREE
);
4785 unsigned HOST_WIDE_INT max_index_cst
= 0;
4786 unsigned HOST_WIDE_INT index
;
4788 /* The initializer for an array is always a CONSTRUCTOR. */
4789 new_init
= build_constructor (init_list_type_node
, NULL
);
4793 /* Minus 1 is used for zero sized arrays. */
4794 if (integer_all_onesp (max_index
))
4797 if (host_integerp (max_index
, 1))
4798 max_index_cst
= tree_low_cst (max_index
, 1);
4799 /* sizetype is sign extended, not zero extended. */
4801 max_index_cst
= tree_low_cst (fold_convert (size_type_node
, max_index
),
4805 /* Loop until there are no more initializers. */
4807 d
->cur
!= d
->end
&& (!sized_array_p
|| index
<= max_index_cst
);
4812 check_array_designated_initializer (d
->cur
);
4813 elt_init
= reshape_init_r (elt_type
, d
, /*first_initializer_p=*/false);
4814 if (elt_init
== error_mark_node
)
4815 return error_mark_node
;
4816 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
), NULL_TREE
, elt_init
);
4822 /* Subroutine of reshape_init_r, processes the initializers for arrays.
4823 Parameters are the same of reshape_init_r. */
4826 reshape_init_array (tree type
, reshape_iter
*d
)
4828 tree max_index
= NULL_TREE
;
4830 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
4832 if (TYPE_DOMAIN (type
))
4833 max_index
= array_type_nelts (type
);
4835 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
);
4838 /* Subroutine of reshape_init_r, processes the initializers for vectors.
4839 Parameters are the same of reshape_init_r. */
4842 reshape_init_vector (tree type
, reshape_iter
*d
)
4844 tree max_index
= NULL_TREE
;
4847 gcc_assert (TREE_CODE (type
) == VECTOR_TYPE
);
4849 if (COMPOUND_LITERAL_P (d
->cur
->value
))
4851 tree value
= d
->cur
->value
;
4852 if (!same_type_p (TREE_TYPE (value
), type
))
4854 error ("invalid type %qT as initializer for a vector of type %qT",
4855 TREE_TYPE (d
->cur
->value
), type
);
4856 value
= error_mark_node
;
4862 /* For a vector, the representation type is a struct
4863 containing a single member which is an array of the
4864 appropriate size. */
4865 rtype
= TYPE_DEBUG_REPRESENTATION_TYPE (type
);
4866 if (rtype
&& TYPE_DOMAIN (TREE_TYPE (TYPE_FIELDS (rtype
))))
4867 max_index
= array_type_nelts (TREE_TYPE (TYPE_FIELDS (rtype
)));
4869 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
);
4872 /* Subroutine of reshape_init_r, processes the initializers for classes
4873 or union. Parameters are the same of reshape_init_r. */
4876 reshape_init_class (tree type
, reshape_iter
*d
, bool first_initializer_p
)
4881 gcc_assert (CLASS_TYPE_P (type
));
4883 /* The initializer for a class is always a CONSTRUCTOR. */
4884 new_init
= build_constructor (init_list_type_node
, NULL
);
4885 field
= next_initializable_field (TYPE_FIELDS (type
));
4891 An initializer for an aggregate member that is an
4892 empty class shall have the form of an empty
4893 initializer-list {}. */
4894 if (!first_initializer_p
)
4896 error ("initializer for %qT must be brace-enclosed", type
);
4897 return error_mark_node
;
4902 /* Loop through the initializable fields, gathering initializers. */
4903 while (d
->cur
!= d
->end
)
4907 /* Handle designated initializers, as an extension. */
4910 field
= lookup_field_1 (type
, d
->cur
->index
, /*want_type=*/false);
4912 if (!field
|| TREE_CODE (field
) != FIELD_DECL
)
4914 error ("%qT has no non-static data member named %qD", type
,
4916 return error_mark_node
;
4920 /* If we processed all the member of the class, we are done. */
4924 field_init
= reshape_init_r (TREE_TYPE (field
), d
,
4925 /*first_initializer_p=*/false);
4926 if (field_init
== error_mark_node
)
4927 return error_mark_node
;
4929 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
), field
, field_init
);
4933 When a union is initialized with a brace-enclosed
4934 initializer, the braces shall only contain an
4935 initializer for the first member of the union. */
4936 if (TREE_CODE (type
) == UNION_TYPE
)
4939 field
= next_initializable_field (TREE_CHAIN (field
));
4945 /* Subroutine of reshape_init, which processes a single initializer (part of
4946 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
4947 iterator within the CONSTRUCTOR which points to the initializer to process.
4948 FIRST_INITIALIZER_P is true if this is the first initializer of the
4949 outermost CONSTRUCTOR node. */
4952 reshape_init_r (tree type
, reshape_iter
*d
, bool first_initializer_p
)
4954 tree init
= d
->cur
->value
;
4956 if (error_operand_p (init
))
4957 return error_mark_node
;
4959 /* A non-aggregate type is always initialized with a single
4961 if (!CP_AGGREGATE_TYPE_P (type
))
4963 /* It is invalid to initialize a non-aggregate type with a
4964 brace-enclosed initializer before C++0x.
4965 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
4966 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
4967 a CONSTRUCTOR (with a record type). */
4968 if (TREE_CODE (init
) == CONSTRUCTOR
4969 && BRACE_ENCLOSED_INITIALIZER_P (init
)) /* p7626.C */
4971 if (SCALAR_TYPE_P (type
))
4973 error ("braces around scalar initializer for type %qT", type
);
4974 init
= error_mark_node
;
4977 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
4986 All implicit type conversions (clause _conv_) are considered when
4987 initializing the aggregate member with an initializer from an
4988 initializer-list. If the initializer can initialize a member,
4989 the member is initialized. Otherwise, if the member is itself a
4990 non-empty subaggregate, brace elision is assumed and the
4991 initializer is considered for the initialization of the first
4992 member of the subaggregate. */
4993 if (TREE_CODE (init
) != CONSTRUCTOR
4994 /* But don't try this for the first initializer, since that would be
4995 looking through the outermost braces; A a2 = { a1 }; is not a
4996 valid aggregate initialization. */
4997 && !first_initializer_p
4998 && (same_type_ignoring_top_level_qualifiers_p (type
, TREE_TYPE (init
))
4999 || can_convert_arg (type
, TREE_TYPE (init
), init
, LOOKUP_NORMAL
)))
5005 /* [dcl.init.string]
5007 A char array (whether plain char, signed char, or unsigned char)
5008 can be initialized by a string-literal (optionally enclosed in
5009 braces); a wchar_t array can be initialized by a wide
5010 string-literal (optionally enclosed in braces). */
5011 if (TREE_CODE (type
) == ARRAY_TYPE
5012 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type
))))
5014 tree str_init
= init
;
5016 /* Strip one level of braces if and only if they enclose a single
5017 element (as allowed by [dcl.init.string]). */
5018 if (!first_initializer_p
5019 && TREE_CODE (str_init
) == CONSTRUCTOR
5020 && VEC_length (constructor_elt
, CONSTRUCTOR_ELTS (str_init
)) == 1)
5022 str_init
= VEC_index (constructor_elt
,
5023 CONSTRUCTOR_ELTS (str_init
), 0)->value
;
5026 /* If it's a string literal, then it's the initializer for the array
5027 as a whole. Otherwise, continue with normal initialization for
5028 array types (one value per array element). */
5029 if (TREE_CODE (str_init
) == STRING_CST
)
5036 /* The following cases are about aggregates. If we are not within a full
5037 initializer already, and there is not a CONSTRUCTOR, it means that there
5038 is a missing set of braces (that is, we are processing the case for
5039 which reshape_init exists). */
5040 if (!first_initializer_p
)
5042 if (TREE_CODE (init
) == CONSTRUCTOR
)
5044 if (TREE_TYPE (init
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init
)))
5045 /* There is no need to reshape pointer-to-member function
5046 initializers, as they are always constructed correctly
5047 by the front end. */
5049 else if (COMPOUND_LITERAL_P (init
))
5050 /* For a nested compound literal, there is no need to reshape since
5051 brace elision is not allowed. Even if we decided to allow it,
5052 we should add a call to reshape_init in finish_compound_literal,
5053 before calling digest_init, so changing this code would still
5054 not be necessary. */
5055 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init
));
5059 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
5060 return reshape_init (type
, init
);
5064 warning (OPT_Wmissing_braces
, "missing braces around initializer for %qT",
5068 /* Dispatch to specialized routines. */
5069 if (CLASS_TYPE_P (type
))
5070 return reshape_init_class (type
, d
, first_initializer_p
);
5071 else if (TREE_CODE (type
) == ARRAY_TYPE
)
5072 return reshape_init_array (type
, d
);
5073 else if (TREE_CODE (type
) == VECTOR_TYPE
)
5074 return reshape_init_vector (type
, d
);
5079 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
5080 brace-enclosed aggregate initializer.
5082 INIT is the CONSTRUCTOR containing the list of initializers describing
5083 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
5084 It may not presently match the shape of the TYPE; for example:
5086 struct S { int a; int b; };
5087 struct S a[] = { 1, 2, 3, 4 };
5089 Here INIT will hold a VEC of four elements, rather than a
5090 VEC of two elements, each itself a VEC of two elements. This
5091 routine transforms INIT from the former form into the latter. The
5092 revised CONSTRUCTOR node is returned. */
5095 reshape_init (tree type
, tree init
)
5097 VEC(constructor_elt
, gc
) *v
;
5101 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
5103 v
= CONSTRUCTOR_ELTS (init
);
5105 /* An empty constructor does not need reshaping, and it is always a valid
5107 if (VEC_empty (constructor_elt
, v
))
5110 /* Recurse on this CONSTRUCTOR. */
5111 d
.cur
= VEC_index (constructor_elt
, v
, 0);
5112 d
.end
= d
.cur
+ VEC_length (constructor_elt
, v
);
5114 new_init
= reshape_init_r (type
, &d
, true);
5115 if (new_init
== error_mark_node
)
5116 return error_mark_node
;
5118 /* Make sure all the element of the constructor were used. Otherwise,
5119 issue an error about exceeding initializers. */
5121 error ("too many initializers for %qT", type
);
5126 /* Verify array initializer. Returns true if errors have been reported. */
5129 check_array_initializer (tree decl
, tree type
, tree init
)
5131 tree element_type
= TREE_TYPE (type
);
5133 /* The array type itself need not be complete, because the
5134 initializer may tell us how many elements are in the array.
5135 But, the elements of the array must be complete. */
5136 if (!COMPLETE_TYPE_P (complete_type (element_type
)))
5139 error ("elements of array %q#D have incomplete type", decl
);
5141 error ("elements of array %q#T have incomplete type", type
);
5144 /* It is not valid to initialize a VLA. */
5146 && ((COMPLETE_TYPE_P (type
) && !TREE_CONSTANT (TYPE_SIZE (type
)))
5147 || !TREE_CONSTANT (TYPE_SIZE (element_type
))))
5150 error ("variable-sized object %qD may not be initialized", decl
);
5152 error ("variable-sized compound literal");
5158 /* Subroutine of check_initializer; args are passed down from that function.
5159 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
5162 build_aggr_init_full_exprs (tree decl
, tree init
, int flags
)
5165 int saved_stmts_are_full_exprs_p
= 0;
5166 if (building_stmt_tree ())
5168 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
5169 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
5171 init
= build_aggr_init (decl
, init
, flags
, tf_warning_or_error
);
5172 if (building_stmt_tree ())
5173 current_stmt_tree ()->stmts_are_full_exprs_p
=
5174 saved_stmts_are_full_exprs_p
;
5178 /* Verify INIT (the initializer for DECL), and record the
5179 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
5180 grok_reference_init.
5182 If the return value is non-NULL, it is an expression that must be
5183 evaluated dynamically to initialize DECL. */
5186 check_initializer (tree decl
, tree init
, int flags
, tree
*cleanup
)
5188 tree type
= TREE_TYPE (decl
);
5189 tree init_code
= NULL
;
5191 /* Things that are going to be initialized need to have complete
5193 TREE_TYPE (decl
) = type
= complete_type (TREE_TYPE (decl
));
5195 if (type
== error_mark_node
)
5196 /* We will have already complained. */
5199 if (TREE_CODE (type
) == ARRAY_TYPE
)
5201 if (check_array_initializer (decl
, type
, init
))
5204 else if (!COMPLETE_TYPE_P (type
))
5206 error ("%qD has incomplete type", decl
);
5207 TREE_TYPE (decl
) = error_mark_node
;
5211 /* There is no way to make a variable-sized class type in GNU C++. */
5212 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type
)));
5214 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
))
5216 int init_len
= VEC_length (constructor_elt
, CONSTRUCTOR_ELTS (init
));
5217 if (SCALAR_TYPE_P (type
))
5221 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS
);
5222 init
= build_zero_init (type
, NULL_TREE
, false);
5224 else if (init_len
!= 1)
5226 error ("scalar object %qD requires one element in initializer",
5228 TREE_TYPE (decl
) = error_mark_node
;
5234 if (TREE_CODE (decl
) == CONST_DECL
)
5236 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
5238 DECL_INITIAL (decl
) = init
;
5240 gcc_assert (init
!= NULL_TREE
);
5243 else if (!DECL_EXTERNAL (decl
) && TREE_CODE (type
) == REFERENCE_TYPE
)
5244 init
= grok_reference_init (decl
, type
, init
, cleanup
);
5247 /* Do not reshape constructors of vectors (they don't need to be
5249 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
5251 if (is_std_init_list (type
))
5252 return build_init_list_var_init (decl
, type
, init
, cleanup
);
5253 else if (TYPE_NON_AGGREGATE_CLASS (type
))
5255 /* Don't reshape if the class has constructors. */
5256 if (cxx_dialect
== cxx98
)
5257 error ("in C++98 %qD must be initialized by constructor, "
5260 init
= build_tree_list (NULL_TREE
, init
);
5262 else if (TREE_CODE (type
) == VECTOR_TYPE
&& TYPE_VECTOR_OPAQUE (type
))
5264 error ("opaque vector types cannot be initialized");
5265 init
= error_mark_node
;
5268 init
= reshape_init (type
, init
);
5271 /* If DECL has an array type without a specific bound, deduce the
5272 array size from the initializer. */
5273 maybe_deduce_size_from_array_init (decl
, init
);
5274 type
= TREE_TYPE (decl
);
5275 if (type
== error_mark_node
)
5278 if (TYPE_NEEDS_CONSTRUCTING (type
)
5279 || (CLASS_TYPE_P (type
)
5280 && !BRACE_ENCLOSED_INITIALIZER_P (init
)))
5281 return build_aggr_init_full_exprs (decl
, init
, flags
);
5282 else if (TREE_CODE (init
) != TREE_VEC
)
5284 init_code
= store_init_value (decl
, init
, flags
);
5285 if (pedantic
&& TREE_CODE (type
) == ARRAY_TYPE
5286 && DECL_INITIAL (decl
)
5287 && TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
5288 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl
)))
5289 warning (0, "array %qD initialized by parenthesized string literal %qE",
5290 decl
, DECL_INITIAL (decl
));
5294 else if (DECL_EXTERNAL (decl
))
5296 else if (TYPE_P (type
) && TYPE_NEEDS_CONSTRUCTING (type
))
5297 return build_aggr_init_full_exprs (decl
, init
, flags
);
5298 else if (MAYBE_CLASS_TYPE_P (type
))
5300 tree core_type
= strip_array_types (type
);
5302 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
))
5303 error ("structure %qD with uninitialized const members", decl
);
5304 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
))
5305 error ("structure %qD with uninitialized reference members", decl
);
5307 check_for_uninitialized_const_var (decl
);
5310 check_for_uninitialized_const_var (decl
);
5312 if (init
&& init
!= error_mark_node
)
5313 init_code
= build2 (INIT_EXPR
, type
, decl
, init
);
5318 /* If DECL is not a local variable, give it RTL. */
5321 make_rtl_for_nonlocal_decl (tree decl
, tree init
, const char* asmspec
)
5323 int toplev
= toplevel_bindings_p ();
5325 const char *filename
;
5327 /* Set the DECL_ASSEMBLER_NAME for the object. */
5330 /* The `register' keyword, when used together with an
5331 asm-specification, indicates that the variable should be
5332 placed in a particular register. */
5333 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_REGISTER (decl
))
5335 set_user_assembler_name (decl
, asmspec
);
5336 DECL_HARD_REGISTER (decl
) = 1;
5340 if (TREE_CODE (decl
) == FUNCTION_DECL
5341 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
5342 set_builtin_user_assembler_name (decl
, asmspec
);
5343 set_user_assembler_name (decl
, asmspec
);
5347 /* Handle non-variables up front. */
5348 if (TREE_CODE (decl
) != VAR_DECL
)
5350 rest_of_decl_compilation (decl
, toplev
, at_eof
);
5354 /* If we see a class member here, it should be a static data
5356 if (DECL_LANG_SPECIFIC (decl
) && DECL_IN_AGGR_P (decl
))
5358 gcc_assert (TREE_STATIC (decl
));
5359 /* An in-class declaration of a static data member should be
5360 external; it is only a declaration, and not a definition. */
5361 if (init
== NULL_TREE
)
5362 gcc_assert (DECL_EXTERNAL (decl
) || !TREE_PUBLIC (decl
));
5365 /* We don't create any RTL for local variables. */
5366 if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
5369 /* We defer emission of local statics until the corresponding
5370 DECL_EXPR is expanded. */
5371 defer_p
= DECL_FUNCTION_SCOPE_P (decl
) || DECL_VIRTUAL_P (decl
);
5373 /* We try to defer namespace-scope static constants so that they are
5374 not emitted into the object file unnecessarily. */
5375 filename
= input_filename
;
5376 if (!DECL_VIRTUAL_P (decl
)
5377 && TREE_READONLY (decl
)
5378 && DECL_INITIAL (decl
) != NULL_TREE
5379 && DECL_INITIAL (decl
) != error_mark_node
5381 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
))
5383 && !TREE_PUBLIC (decl
))
5385 /* Fool with the linkage of static consts according to #pragma
5387 struct c_fileinfo
*finfo
= get_fileinfo (filename
);
5388 if (!finfo
->interface_unknown
&& !TREE_PUBLIC (decl
))
5390 TREE_PUBLIC (decl
) = 1;
5391 DECL_EXTERNAL (decl
) = finfo
->interface_only
;
5396 /* Likewise for template instantiations. */
5397 else if (DECL_LANG_SPECIFIC (decl
)
5398 && DECL_IMPLICIT_INSTANTIATION (decl
))
5401 /* If we're not deferring, go ahead and assemble the variable. */
5403 rest_of_decl_compilation (decl
, toplev
, at_eof
);
5406 /* walk_tree helper for wrap_temporary_cleanups, below. */
5409 wrap_cleanups_r (tree
*stmt_p
, int *walk_subtrees
, void *data
)
5411 if (TYPE_P (*stmt_p
))
5417 if (TREE_CODE (*stmt_p
) == TARGET_EXPR
)
5419 tree guard
= (tree
)data
;
5420 tree tcleanup
= TARGET_EXPR_CLEANUP (*stmt_p
);
5422 tcleanup
= build2 (TRY_CATCH_EXPR
, void_type_node
, tcleanup
, guard
);
5423 /* Tell honor_protect_cleanup_actions to handle this as a separate
5425 TRY_CATCH_IS_CLEANUP (tcleanup
) = 1;
5427 TARGET_EXPR_CLEANUP (*stmt_p
) = tcleanup
;
5433 /* We're initializing a local variable which has a cleanup GUARD. If there
5434 are any temporaries used in the initializer INIT of this variable, we
5435 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
5436 variable will be cleaned up properly if one of them throws.
5438 Unfortunately, there's no way to express this properly in terms of
5439 nesting, as the regions for the temporaries overlap the region for the
5440 variable itself; if there are two temporaries, the variable needs to be
5441 the first thing destroyed if either of them throws. However, we only
5442 want to run the variable's cleanup if it actually got constructed. So
5443 we need to guard the temporary cleanups with the variable's cleanup if
5444 they are run on the normal path, but not if they are run on the
5445 exceptional path. We implement this by telling
5446 honor_protect_cleanup_actions to strip the variable cleanup from the
5447 exceptional path. */
5450 wrap_temporary_cleanups (tree init
, tree guard
)
5452 cp_walk_tree_without_duplicates (&init
, wrap_cleanups_r
, (void *)guard
);
5455 /* Generate code to initialize DECL (a local variable). */
5458 initialize_local_var (tree decl
, tree init
)
5460 tree type
= TREE_TYPE (decl
);
5464 gcc_assert (TREE_CODE (decl
) == VAR_DECL
5465 || TREE_CODE (decl
) == RESULT_DECL
);
5466 gcc_assert (!TREE_STATIC (decl
));
5468 if (DECL_SIZE (decl
) == NULL_TREE
)
5470 /* If we used it already as memory, it must stay in memory. */
5471 DECL_INITIAL (decl
) = NULL_TREE
;
5472 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
5476 if (type
== error_mark_node
)
5479 /* Compute and store the initial value. */
5480 already_used
= TREE_USED (decl
) || TREE_USED (type
);
5482 /* Generate a cleanup, if necessary. */
5483 cleanup
= cxx_maybe_build_cleanup (decl
);
5485 /* Perform the initialization. */
5488 int saved_stmts_are_full_exprs_p
;
5490 /* If we're only initializing a single object, guard the destructors
5491 of any temporaries used in its initializer with its destructor.
5492 This isn't right for arrays because each element initialization is
5493 a full-expression. */
5494 if (cleanup
&& TREE_CODE (type
) != ARRAY_TYPE
)
5495 wrap_temporary_cleanups (init
, cleanup
);
5497 gcc_assert (building_stmt_tree ());
5498 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
5499 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
5500 finish_expr_stmt (init
);
5501 current_stmt_tree ()->stmts_are_full_exprs_p
=
5502 saved_stmts_are_full_exprs_p
;
5505 /* Set this to 0 so we can tell whether an aggregate which was
5506 initialized was ever used. Don't do this if it has a
5507 destructor, so we don't complain about the 'resource
5508 allocation is initialization' idiom. Now set
5509 attribute((unused)) on types so decls of that type will be
5510 marked used. (see TREE_USED, above.) */
5511 if (TYPE_NEEDS_CONSTRUCTING (type
)
5513 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type
)
5514 && DECL_NAME (decl
))
5515 TREE_USED (decl
) = 0;
5516 else if (already_used
)
5517 TREE_USED (decl
) = 1;
5520 finish_decl_cleanup (decl
, cleanup
);
5523 /* DECL is a VAR_DECL for a compiler-generated variable with static
5524 storage duration (like a virtual table) whose initializer is a
5525 compile-time constant. INIT must be either a TREE_LIST of values,
5526 or a CONSTRUCTOR. Initialize the variable and provide it to the
5530 initialize_artificial_var (tree decl
, tree init
)
5532 gcc_assert (DECL_ARTIFICIAL (decl
));
5533 if (TREE_CODE (init
) == TREE_LIST
)
5534 init
= build_constructor_from_list (TREE_TYPE (decl
), init
);
5535 gcc_assert (TREE_CODE (init
) == CONSTRUCTOR
);
5536 DECL_INITIAL (decl
) = init
;
5537 DECL_INITIALIZED_P (decl
) = 1;
5538 determine_visibility (decl
);
5539 layout_var_decl (decl
);
5540 maybe_commonize_var (decl
);
5541 make_rtl_for_nonlocal_decl (decl
, init
, /*asmspec=*/NULL
);
5544 /* INIT is the initializer for a variable, as represented by the
5545 parser. Returns true iff INIT is value-dependent. */
5548 value_dependent_init_p (tree init
)
5550 if (TREE_CODE (init
) == TREE_LIST
)
5551 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
5552 return any_value_dependent_elements_p (init
);
5553 else if (TREE_CODE (init
) == CONSTRUCTOR
)
5554 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
5556 VEC(constructor_elt
, gc
) *elts
;
5560 elts
= CONSTRUCTOR_ELTS (init
);
5561 nelts
= VEC_length (constructor_elt
, elts
);
5562 for (i
= 0; i
< nelts
; ++i
)
5563 if (value_dependent_init_p (VEC_index (constructor_elt
,
5568 /* It must be a simple expression, e.g., int i = 3; */
5569 return value_dependent_expression_p (init
);
5574 /* Finish processing of a declaration;
5575 install its line number and initial value.
5576 If the length of an array type is not known before,
5577 it must be determined now, from the initial value, or it is an error.
5579 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
5580 true, then INIT is an integral constant expression.
5582 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
5583 if the (init) syntax was used. */
5586 cp_finish_decl (tree decl
, tree init
, bool init_const_expr_p
,
5587 tree asmspec_tree
, int flags
)
5591 const char *asmspec
= NULL
;
5592 int was_readonly
= 0;
5593 bool var_definition_p
= false;
5594 int saved_processing_template_decl
;
5597 if (decl
== error_mark_node
)
5602 error ("assignment (not initialization) in declaration");
5606 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
5607 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
5608 gcc_assert (TREE_CODE (decl
) != PARM_DECL
);
5610 type
= TREE_TYPE (decl
);
5611 if (type
== error_mark_node
)
5614 /* Assume no cleanup is required. */
5615 cleanup
= NULL_TREE
;
5616 saved_processing_template_decl
= processing_template_decl
;
5618 /* If a name was specified, get the string. */
5619 if (global_scope_p (current_binding_level
))
5620 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
5621 if (asmspec_tree
&& asmspec_tree
!= error_mark_node
)
5622 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
5624 if (current_class_type
5625 && CP_DECL_CONTEXT (decl
) == current_class_type
5626 && TYPE_BEING_DEFINED (current_class_type
)
5627 && (DECL_INITIAL (decl
) || init
))
5628 DECL_INITIALIZED_IN_CLASS_P (decl
) = 1;
5630 auto_node
= type_uses_auto (type
);
5633 if (init
== NULL_TREE
)
5635 error ("declaration of %q#D has no initializer", decl
);
5636 TREE_TYPE (decl
) = error_mark_node
;
5639 if (TREE_CODE (init
) == TREE_LIST
)
5640 init
= build_x_compound_expr_from_list (init
, "initializer");
5641 if (describable_type (init
))
5643 type
= TREE_TYPE (decl
) = do_auto_deduction (type
, init
, auto_node
);
5644 if (type
== error_mark_node
)
5649 if (init
&& TREE_CODE (decl
) == FUNCTION_DECL
)
5652 if (init
== ridpointers
[(int)RID_DELETE
])
5654 /* FIXME check this is 1st decl. */
5655 DECL_DELETED_FN (decl
) = 1;
5656 DECL_DECLARED_INLINE_P (decl
) = 1;
5657 DECL_INITIAL (decl
) = error_mark_node
;
5658 FOR_EACH_CLONE (clone
, decl
)
5660 DECL_DELETED_FN (clone
) = 1;
5661 DECL_DECLARED_INLINE_P (clone
) = 1;
5662 DECL_INITIAL (clone
) = error_mark_node
;
5666 else if (init
== ridpointers
[(int)RID_DEFAULT
])
5668 if (defaultable_fn_check (decl
))
5669 DECL_DEFAULTED_FN (decl
) = 1;
5671 DECL_INITIAL (decl
) = NULL_TREE
;
5675 if (processing_template_decl
)
5677 bool type_dependent_p
;
5679 /* Add this declaration to the statement-tree. */
5680 if (at_function_scope_p ())
5681 add_decl_expr (decl
);
5683 type_dependent_p
= dependent_type_p (type
);
5685 if (check_for_bare_parameter_packs (init
))
5688 DECL_INITIAL (decl
) = NULL_TREE
;
5691 if (init
&& init_const_expr_p
&& TREE_CODE (decl
) == VAR_DECL
)
5693 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = 1;
5694 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl
))
5695 TREE_CONSTANT (decl
) = 1;
5698 /* Generally, initializers in templates are expanded when the
5699 template is instantiated. But, if DECL is an integral
5700 constant static data member, then it can be used in future
5701 integral constant expressions, and its value must be
5704 && DECL_CLASS_SCOPE_P (decl
)
5705 && DECL_INTEGRAL_CONSTANT_VAR_P (decl
)
5706 && !type_dependent_p
5707 && !value_dependent_init_p (init
)))
5710 DECL_INITIAL (decl
) = init
;
5711 if (TREE_CODE (decl
) == VAR_DECL
5712 && !DECL_PRETTY_FUNCTION_P (decl
)
5713 && !type_dependent_p
)
5714 maybe_deduce_size_from_array_init (decl
, init
);
5718 if (TREE_CODE (init
) == TREE_LIST
)
5720 /* If the parenthesized-initializer form was used (e.g.,
5721 "int A<N>::i(X)"), then INIT will be a TREE_LIST of initializer
5722 arguments. (There is generally only one.) We convert them
5725 for (; list
; list
= TREE_CHAIN (list
))
5727 tree elt
= TREE_VALUE (list
);
5728 TREE_VALUE (list
) = fold_non_dependent_expr (elt
);
5732 init
= fold_non_dependent_expr (init
);
5733 processing_template_decl
= 0;
5736 /* Take care of TYPE_DECLs up front. */
5737 if (TREE_CODE (decl
) == TYPE_DECL
)
5739 if (type
!= error_mark_node
5740 && MAYBE_CLASS_TYPE_P (type
) && DECL_NAME (decl
))
5742 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
5743 warning (0, "shadowing previous type declaration of %q#D", decl
);
5744 set_identifier_type_value (DECL_NAME (decl
), decl
);
5747 /* If we have installed this as the canonical typedef for this
5748 type, and that type has not been defined yet, delay emitting
5749 the debug information for it, as we will emit it later. */
5750 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
5751 && !COMPLETE_TYPE_P (TREE_TYPE (decl
)))
5752 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
5754 rest_of_decl_compilation (decl
, DECL_CONTEXT (decl
) == NULL_TREE
,
5759 /* A reference will be modified here, as it is initialized. */
5760 if (! DECL_EXTERNAL (decl
)
5761 && TREE_READONLY (decl
)
5762 && TREE_CODE (type
) == REFERENCE_TYPE
)
5765 TREE_READONLY (decl
) = 0;
5768 if (TREE_CODE (decl
) == VAR_DECL
)
5770 /* Only variables with trivial initialization and destruction can
5771 have thread-local storage. */
5772 if (DECL_THREAD_LOCAL_P (decl
)
5773 && (type_has_nontrivial_default_init (TREE_TYPE (decl
))
5774 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl
))))
5775 error ("%qD cannot be thread-local because it has non-trivial "
5776 "type %qT", decl
, TREE_TYPE (decl
));
5777 /* If this is a local variable that will need a mangled name,
5778 register it now. We must do this before processing the
5779 initializer for the variable, since the initialization might
5780 require a guard variable, and since the mangled name of the
5781 guard variable will depend on the mangled name of this
5783 if (DECL_FUNCTION_SCOPE_P (decl
)
5784 && TREE_STATIC (decl
)
5785 && !DECL_ARTIFICIAL (decl
))
5787 push_local_name (decl
);
5788 if (DECL_CONSTRUCTOR_P (current_function_decl
)
5789 || DECL_DESTRUCTOR_P (current_function_decl
))
5790 /* Normally local_decls is populated during GIMPLE lowering,
5791 but [cd]tors are never actually compiled directly. We need
5792 to put statics on the list so we can deal with the label
5793 address extension. */
5794 cfun
->local_decls
= tree_cons (NULL_TREE
, decl
,
5798 /* Convert the initializer to the type of DECL, if we have not
5799 already initialized DECL. */
5800 if (!DECL_INITIALIZED_P (decl
)
5801 /* If !DECL_EXTERNAL then DECL is being defined. In the
5802 case of a static data member initialized inside the
5803 class-specifier, there can be an initializer even if DECL
5804 is *not* defined. */
5805 && (!DECL_EXTERNAL (decl
) || init
))
5807 if (TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
5810 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
5811 /* Allow libjava/prims.cc define primitive classes. */
5812 if (init
!= NULL_TREE
5813 || jclass
== NULL_TREE
5814 || TREE_CODE (jclass
) != TYPE_DECL
5815 || !POINTER_TYPE_P (TREE_TYPE (jclass
))
5816 || !same_type_ignoring_top_level_qualifiers_p
5817 (type
, TREE_TYPE (TREE_TYPE (jclass
))))
5818 error ("Java object %qD not allocated with %<new%>", decl
);
5823 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = 1;
5824 if (init_const_expr_p
)
5826 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = 1;
5827 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl
))
5828 TREE_CONSTANT (decl
) = 1;
5831 init
= check_initializer (decl
, init
, flags
, &cleanup
);
5832 /* Thread-local storage cannot be dynamically initialized. */
5833 if (DECL_THREAD_LOCAL_P (decl
) && init
)
5835 error ("%qD is thread-local and so cannot be dynamically "
5836 "initialized", decl
);
5840 /* Check that the initializer for a static data member was a
5841 constant. Although we check in the parser that the
5842 initializer is an integral constant expression, we do not
5843 simplify division-by-zero at the point at which it
5844 occurs. Therefore, in:
5846 struct S { static const int i = 7 / 0; };
5848 we issue an error at this point. It would
5849 probably be better to forbid division by zero in
5850 integral constant expressions. */
5851 if (DECL_EXTERNAL (decl
) && init
)
5853 error ("%qD cannot be initialized by a non-constant expression"
5854 " when being declared", decl
);
5855 DECL_INITIALIZED_IN_CLASS_P (decl
) = 0;
5863 The memory occupied by any object of static storage
5864 duration is zero-initialized at program startup before
5865 any other initialization takes place.
5867 We cannot create an appropriate initializer until after
5868 the type of DECL is finalized. If DECL_INITIAL is set,
5869 then the DECL is statically initialized, and any
5870 necessary zero-initialization has already been performed. */
5871 if (TREE_STATIC (decl
) && !DECL_INITIAL (decl
))
5872 DECL_INITIAL (decl
) = build_zero_init (TREE_TYPE (decl
),
5873 /*nelts=*/NULL_TREE
,
5874 /*static_storage_p=*/true);
5875 /* Remember that the initialization for this variable has
5877 DECL_INITIALIZED_P (decl
) = 1;
5878 /* This declaration is the definition of this variable,
5879 unless we are initializing a static data member within
5880 the class specifier. */
5881 if (!DECL_EXTERNAL (decl
))
5882 var_definition_p
= true;
5884 /* If the variable has an array type, lay out the type, even if
5885 there is no initializer. It is valid to index through the
5886 array, and we must get TYPE_ALIGN set correctly on the array
5888 else if (TREE_CODE (type
) == ARRAY_TYPE
)
5891 if (!processing_template_decl
5892 && TREE_STATIC (decl
)
5893 && !at_function_scope_p ()
5894 && current_function_decl
== NULL
)
5895 /* So decl is a global variable or a static member of a
5896 non local class. Record the types it uses
5897 so that we can decide later to emit debug info for them. */
5898 record_types_used_by_current_var_decl (decl
);
5900 else if (TREE_CODE (decl
) == FIELD_DECL
5901 && TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
5902 error ("non-static data member %qD has Java class type", decl
);
5904 /* Add this declaration to the statement-tree. This needs to happen
5905 after the call to check_initializer so that the DECL_EXPR for a
5906 reference temp is added before the DECL_EXPR for the reference itself. */
5907 if (at_function_scope_p ())
5908 add_decl_expr (decl
);
5910 /* Let the middle end know about variables and functions -- but not
5911 static data members in uninstantiated class templates. */
5912 if (!saved_processing_template_decl
5913 && (TREE_CODE (decl
) == VAR_DECL
5914 || TREE_CODE (decl
) == FUNCTION_DECL
))
5916 if (TREE_CODE (decl
) == VAR_DECL
)
5918 layout_var_decl (decl
);
5919 maybe_commonize_var (decl
);
5922 /* This needs to happen after the linkage is set. */
5923 determine_visibility (decl
);
5925 if (var_definition_p
&& TREE_STATIC (decl
))
5927 /* If a TREE_READONLY variable needs initialization
5928 at runtime, it is no longer readonly and we need to
5929 avoid MEM_READONLY_P being set on RTL created for it. */
5932 if (TREE_READONLY (decl
))
5933 TREE_READONLY (decl
) = 0;
5936 else if (was_readonly
)
5937 TREE_READONLY (decl
) = 1;
5940 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
);
5942 /* Check for abstractness of the type. Notice that there is no
5943 need to strip array types here since the check for those types
5944 is already done within create_array_type_for_decl. */
5945 if (TREE_CODE (type
) == FUNCTION_TYPE
5946 || TREE_CODE (type
) == METHOD_TYPE
)
5947 abstract_virtuals_error (decl
, TREE_TYPE (type
));
5949 abstract_virtuals_error (decl
, type
);
5951 if (TREE_TYPE (decl
) == error_mark_node
)
5952 /* No initialization required. */
5954 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
5958 if (init
== ridpointers
[(int)RID_DEFAULT
])
5960 /* An out-of-class default definition is defined at
5961 the point where it is explicitly defaulted. */
5962 if (DECL_INITIAL (decl
) == error_mark_node
)
5963 synthesize_method (decl
);
5966 error ("function %q#D is initialized like a variable", decl
);
5968 /* else no initialization required. */
5970 else if (DECL_EXTERNAL (decl
)
5971 && ! (DECL_LANG_SPECIFIC (decl
)
5972 && DECL_NOT_REALLY_EXTERN (decl
)))
5975 DECL_INITIAL (decl
) = init
;
5977 /* A variable definition. */
5978 else if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
5979 /* Initialize the local variable. */
5980 initialize_local_var (decl
, init
);
5982 /* If a variable is defined, and then a subsequent
5983 definition with external linkage is encountered, we will
5984 get here twice for the same variable. We want to avoid
5985 calling expand_static_init more than once. For variables
5986 that are not static data members, we can call
5987 expand_static_init only when we actually process the
5988 initializer. It is not legal to redeclare a static data
5989 member, so this issue does not arise in that case. */
5990 else if (var_definition_p
&& TREE_STATIC (decl
))
5991 expand_static_init (decl
, init
);
5994 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
5995 reference, insert it in the statement-tree now. */
5997 push_cleanup (decl
, cleanup
, false);
6000 processing_template_decl
= saved_processing_template_decl
;
6003 TREE_READONLY (decl
) = 1;
6005 /* If this was marked 'used', be sure it will be output. */
6006 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl
)))
6007 mark_decl_referenced (decl
);
6010 /* Returns a declaration for a VAR_DECL as if:
6012 extern "C" TYPE NAME;
6014 had been seen. Used to create compiler-generated global
6018 declare_global_var (tree name
, tree type
)
6022 push_to_top_level ();
6023 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
6024 TREE_PUBLIC (decl
) = 1;
6025 DECL_EXTERNAL (decl
) = 1;
6026 DECL_ARTIFICIAL (decl
) = 1;
6027 /* If the user has explicitly declared this variable (perhaps
6028 because the code we are compiling is part of a low-level runtime
6029 library), then it is possible that our declaration will be merged
6030 with theirs by pushdecl. */
6031 decl
= pushdecl (decl
);
6032 cp_finish_decl (decl
, NULL_TREE
, false, NULL_TREE
, 0);
6033 pop_from_top_level ();
6038 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
6039 if "__cxa_atexit" is not being used) corresponding to the function
6040 to be called when the program exits. */
6043 get_atexit_fn_ptr_type (void)
6048 if (!atexit_fn_ptr_type_node
)
6050 if (flag_use_cxa_atexit
6051 && !targetm
.cxx
.use_atexit_for_cxa_atexit ())
6052 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
6053 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, void_list_node
);
6055 /* The parameter to "atexit" is "void (*)(void)". */
6056 arg_types
= void_list_node
;
6058 fn_type
= build_function_type (void_type_node
, arg_types
);
6059 atexit_fn_ptr_type_node
= build_pointer_type (fn_type
);
6062 return atexit_fn_ptr_type_node
;
6065 /* Returns a pointer to the `atexit' function. Note that if
6066 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
6067 `__cxa_atexit' function specified in the IA64 C++ ABI. */
6070 get_atexit_node (void)
6077 bool use_aeabi_atexit
;
6082 if (flag_use_cxa_atexit
&& !targetm
.cxx
.use_atexit_for_cxa_atexit ())
6084 /* The declaration for `__cxa_atexit' is:
6086 int __cxa_atexit (void (*)(void *), void *, void *)
6088 We build up the argument types and then then function type
6091 use_aeabi_atexit
= targetm
.cxx
.use_aeabi_atexit ();
6092 /* First, build the pointer-to-function type for the first
6094 fn_ptr_type
= get_atexit_fn_ptr_type ();
6095 /* Then, build the rest of the argument types. */
6096 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, void_list_node
);
6097 if (use_aeabi_atexit
)
6099 arg_types
= tree_cons (NULL_TREE
, fn_ptr_type
, arg_types
);
6100 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, arg_types
);
6104 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, arg_types
);
6105 arg_types
= tree_cons (NULL_TREE
, fn_ptr_type
, arg_types
);
6107 /* And the final __cxa_atexit type. */
6108 fn_type
= build_function_type (integer_type_node
, arg_types
);
6109 fn_ptr_type
= build_pointer_type (fn_type
);
6110 if (use_aeabi_atexit
)
6111 name
= "__aeabi_atexit";
6113 name
= "__cxa_atexit";
6117 /* The declaration for `atexit' is:
6119 int atexit (void (*)());
6121 We build up the argument types and then then function type
6123 fn_ptr_type
= get_atexit_fn_ptr_type ();
6124 arg_types
= tree_cons (NULL_TREE
, fn_ptr_type
, void_list_node
);
6125 /* Build the final atexit type. */
6126 fn_type
= build_function_type (integer_type_node
, arg_types
);
6130 /* Now, build the function declaration. */
6131 push_lang_context (lang_name_c
);
6132 atexit_fndecl
= build_library_fn_ptr (name
, fn_type
);
6133 mark_used (atexit_fndecl
);
6134 pop_lang_context ();
6135 atexit_node
= decay_conversion (atexit_fndecl
);
6140 /* Returns the __dso_handle VAR_DECL. */
6143 get_dso_handle_node (void)
6145 if (dso_handle_node
)
6146 return dso_handle_node
;
6148 /* Declare the variable. */
6149 dso_handle_node
= declare_global_var (get_identifier ("__dso_handle"),
6152 return dso_handle_node
;
6155 /* Begin a new function with internal linkage whose job will be simply
6156 to destroy some particular variable. */
6158 static GTY(()) int start_cleanup_cnt
;
6161 start_cleanup_fn (void)
6166 bool use_cxa_atexit
= flag_use_cxa_atexit
6167 && !targetm
.cxx
.use_atexit_for_cxa_atexit ();
6169 push_to_top_level ();
6171 /* No need to mangle this. */
6172 push_lang_context (lang_name_c
);
6174 /* Build the name of the function. */
6175 sprintf (name
, "__tcf_%d", start_cleanup_cnt
++);
6176 /* Build the function declaration. */
6177 fntype
= TREE_TYPE (get_atexit_fn_ptr_type ());
6178 fndecl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), fntype
);
6179 /* It's a function with internal linkage, generated by the
6181 TREE_PUBLIC (fndecl
) = 0;
6182 DECL_ARTIFICIAL (fndecl
) = 1;
6183 /* Make the function `inline' so that it is only emitted if it is
6184 actually needed. It is unlikely that it will be inlined, since
6185 it is only called via a function pointer, but we avoid unnecessary
6186 emissions this way. */
6187 DECL_DECLARED_INLINE_P (fndecl
) = 1;
6188 DECL_INTERFACE_KNOWN (fndecl
) = 1;
6189 /* Build the parameter. */
6194 parmdecl
= cp_build_parm_decl (NULL_TREE
, ptr_type_node
);
6195 DECL_CONTEXT (parmdecl
) = fndecl
;
6196 TREE_USED (parmdecl
) = 1;
6197 DECL_ARGUMENTS (fndecl
) = parmdecl
;
6201 start_preparsed_function (fndecl
, NULL_TREE
, SF_PRE_PARSED
);
6203 pop_lang_context ();
6205 return current_function_decl
;
6208 /* Finish the cleanup function begun by start_cleanup_fn. */
6211 end_cleanup_fn (void)
6213 expand_or_defer_fn (finish_function (0));
6215 pop_from_top_level ();
6218 /* Generate code to handle the destruction of DECL, an object with
6219 static storage duration. */
6222 register_dtor_fn (tree decl
)
6231 type
= TREE_TYPE (decl
);
6232 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
6233 return void_zero_node
;
6235 /* If we're using "__cxa_atexit" (or "__aeabi_atexit"), and DECL is
6236 a class object, we can just pass the destructor to
6237 "__cxa_atexit"; we don't have to build a temporary function to do
6239 use_dtor
= (flag_use_cxa_atexit
6240 && !targetm
.cxx
.use_atexit_for_cxa_atexit ()
6241 && CLASS_TYPE_P (type
));
6246 /* Find the destructor. */
6247 idx
= lookup_fnfields_1 (type
, complete_dtor_identifier
);
6248 gcc_assert (idx
>= 0);
6249 cleanup
= VEC_index (tree
, CLASSTYPE_METHOD_VEC (type
), idx
);
6250 /* Make sure it is accessible. */
6251 perform_or_defer_access_check (TYPE_BINFO (type
), cleanup
, cleanup
);
6255 /* Call build_cleanup before we enter the anonymous function so
6256 that any access checks will be done relative to the current
6257 scope, rather than the scope of the anonymous function. */
6258 build_cleanup (decl
);
6260 /* Now start the function. */
6261 cleanup
= start_cleanup_fn ();
6263 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
6264 to the original function, rather than the anonymous one. That
6265 will make the back end think that nested functions are in use,
6266 which causes confusion. */
6267 push_deferring_access_checks (dk_no_check
);
6268 fcall
= build_cleanup (decl
);
6269 pop_deferring_access_checks ();
6271 /* Create the body of the anonymous function. */
6272 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
6273 finish_expr_stmt (fcall
);
6274 finish_compound_stmt (compound_stmt
);
6278 /* Call atexit with the cleanup function. */
6279 mark_used (cleanup
);
6280 cleanup
= build_address (cleanup
);
6281 if (flag_use_cxa_atexit
&& !targetm
.cxx
.use_atexit_for_cxa_atexit ())
6287 /* We must convert CLEANUP to the type that "__cxa_atexit"
6289 cleanup
= build_nop (get_atexit_fn_ptr_type (), cleanup
);
6290 /* "__cxa_atexit" will pass the address of DECL to the
6291 cleanup function. */
6293 addr
= build_address (decl
);
6294 /* The declared type of the parameter to "__cxa_atexit" is
6295 "void *". For plain "T*", we could just let the
6296 machinery in cp_build_function_call convert it -- but if the
6297 type is "cv-qualified T *", then we need to convert it
6298 before passing it in, to avoid spurious errors. */
6299 addr
= build_nop (ptr_type_node
, addr
);
6302 /* Since the cleanup functions we build ignore the address
6303 they're given, there's no reason to pass the actual address
6304 in, and, in general, it's cheaper to pass NULL than any
6306 addr
= null_pointer_node
;
6307 args
= tree_cons (NULL_TREE
,
6308 cp_build_unary_op (ADDR_EXPR
, get_dso_handle_node (), 0,
6309 tf_warning_or_error
),
6311 if (targetm
.cxx
.use_aeabi_atexit ())
6313 args
= tree_cons (NULL_TREE
, cleanup
, args
);
6314 args
= tree_cons (NULL_TREE
, addr
, args
);
6318 args
= tree_cons (NULL_TREE
, addr
, args
);
6319 args
= tree_cons (NULL_TREE
, cleanup
, args
);
6323 args
= tree_cons (NULL_TREE
, cleanup
, NULL_TREE
);
6324 return cp_build_function_call (get_atexit_node (), args
,
6325 tf_warning_or_error
);
6328 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
6329 is its initializer. Generate code to handle the construction
6330 and destruction of DECL. */
6333 expand_static_init (tree decl
, tree init
)
6335 gcc_assert (TREE_CODE (decl
) == VAR_DECL
);
6336 gcc_assert (TREE_STATIC (decl
));
6338 /* Some variables require no initialization. */
6340 && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
))
6341 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
6344 if (DECL_FUNCTION_SCOPE_P (decl
))
6346 /* Emit code to perform this initialization but once. */
6347 tree if_stmt
= NULL_TREE
, inner_if_stmt
= NULL_TREE
;
6348 tree then_clause
= NULL_TREE
, inner_then_clause
= NULL_TREE
;
6349 tree guard
, guard_addr
;
6350 tree acquire_fn
, release_fn
, abort_fn
;
6353 /* Emit code to perform this initialization but once. This code
6356 static <type> guard;
6357 if (!guard.first_byte) {
6358 if (__cxa_guard_acquire (&guard)) {
6361 // Do initialization.
6362 flag = true; __cxa_guard_release (&guard);
6363 // Register variable for destruction at end of program.
6365 if (!flag) __cxa_guard_abort (&guard);
6369 Note that the `flag' variable is only set to 1 *after* the
6370 initialization is complete. This ensures that an exception,
6371 thrown during the construction, will cause the variable to
6372 reinitialized when we pass through this code again, as per:
6376 If the initialization exits by throwing an exception, the
6377 initialization is not complete, so it will be tried again
6378 the next time control enters the declaration.
6380 This process should be thread-safe, too; multiple threads
6381 should not be able to initialize the variable more than
6384 /* Create the guard variable. */
6385 guard
= get_guard (decl
);
6387 /* This optimization isn't safe on targets with relaxed memory
6388 consistency. On such targets we force synchronization in
6389 __cxa_guard_acquire. */
6390 if (!targetm
.relaxed_ordering
|| !flag_threadsafe_statics
)
6392 /* Begin the conditional initialization. */
6393 if_stmt
= begin_if_stmt ();
6394 finish_if_stmt_cond (get_guard_cond (guard
), if_stmt
);
6395 then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
6398 if (flag_threadsafe_statics
)
6400 guard_addr
= build_address (guard
);
6402 acquire_fn
= get_identifier ("__cxa_guard_acquire");
6403 release_fn
= get_identifier ("__cxa_guard_release");
6404 abort_fn
= get_identifier ("__cxa_guard_abort");
6405 if (!get_global_value_if_present (acquire_fn
, &acquire_fn
))
6407 tree argtypes
= tree_cons (NULL_TREE
, TREE_TYPE (guard_addr
),
6409 tree vfntype
= build_function_type (void_type_node
, argtypes
);
6410 acquire_fn
= push_library_fn
6411 (acquire_fn
, build_function_type (integer_type_node
, argtypes
),
6413 release_fn
= push_library_fn (release_fn
, vfntype
, NULL_TREE
);
6414 abort_fn
= push_library_fn (abort_fn
, vfntype
, NULL_TREE
);
6418 release_fn
= identifier_global_value (release_fn
);
6419 abort_fn
= identifier_global_value (abort_fn
);
6422 inner_if_stmt
= begin_if_stmt ();
6423 finish_if_stmt_cond (build_call_n (acquire_fn
, 1, guard_addr
),
6426 inner_then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
6427 begin
= get_target_expr (boolean_false_node
);
6428 flag
= TARGET_EXPR_SLOT (begin
);
6430 TARGET_EXPR_CLEANUP (begin
)
6431 = build3 (COND_EXPR
, void_type_node
, flag
,
6433 build_call_n (abort_fn
, 1, guard_addr
));
6434 CLEANUP_EH_ONLY (begin
) = 1;
6436 /* Do the initialization itself. */
6437 init
= add_stmt_to_compound (begin
, init
);
6438 init
= add_stmt_to_compound
6439 (init
, build2 (MODIFY_EXPR
, void_type_node
, flag
, boolean_true_node
));
6440 init
= add_stmt_to_compound
6441 (init
, build_call_n (release_fn
, 1, guard_addr
));
6444 init
= add_stmt_to_compound (init
, set_guard (guard
));
6446 /* Use atexit to register a function for destroying this static
6448 init
= add_stmt_to_compound (init
, register_dtor_fn (decl
));
6450 finish_expr_stmt (init
);
6452 if (flag_threadsafe_statics
)
6454 finish_compound_stmt (inner_then_clause
);
6455 finish_then_clause (inner_if_stmt
);
6456 finish_if_stmt (inner_if_stmt
);
6459 if (!targetm
.relaxed_ordering
|| !flag_threadsafe_statics
)
6461 finish_compound_stmt (then_clause
);
6462 finish_then_clause (if_stmt
);
6463 finish_if_stmt (if_stmt
);
6467 static_aggregates
= tree_cons (init
, decl
, static_aggregates
);
6471 /* Make TYPE a complete type based on INITIAL_VALUE.
6472 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6473 2 if there was no information (in which case assume 0 if DO_DEFAULT),
6474 3 if the initializer list is empty (in pedantic mode). */
6477 cp_complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
6480 tree type
, elt_type
;
6484 unsigned HOST_WIDE_INT i
;
6487 /* An array of character type can be initialized from a
6488 brace-enclosed string constant.
6490 FIXME: this code is duplicated from reshape_init. Probably
6491 we should just call reshape_init here? */
6492 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype
)))
6493 && TREE_CODE (initial_value
) == CONSTRUCTOR
6494 && !VEC_empty (constructor_elt
, CONSTRUCTOR_ELTS (initial_value
)))
6496 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (initial_value
);
6497 tree value
= VEC_index (constructor_elt
, v
, 0)->value
;
6499 if (TREE_CODE (value
) == STRING_CST
6500 && VEC_length (constructor_elt
, v
) == 1)
6501 initial_value
= value
;
6504 /* If any of the elements are parameter packs, we can't actually
6505 complete this type now because the array size is dependent. */
6506 if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
6508 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value
),
6511 if (PACK_EXPANSION_P (value
))
6517 failure
= complete_array_type (ptype
, initial_value
, do_default
);
6519 /* We can create the array before the element type is complete, which
6520 means that we didn't have these two bits set in the original type
6521 either. In completing the type, we are expected to propagate these
6522 bits. See also complete_type which does the same thing for arrays
6525 if (TYPE_DOMAIN (type
))
6527 elt_type
= TREE_TYPE (type
);
6528 TYPE_NEEDS_CONSTRUCTING (type
) = TYPE_NEEDS_CONSTRUCTING (elt_type
);
6529 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
6530 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
);
6536 /* Return zero if something is declared to be a member of type
6537 CTYPE when in the context of CUR_TYPE. STRING is the error
6538 message to print in that case. Otherwise, quietly return 1. */
6541 member_function_or_else (tree ctype
, tree cur_type
, enum overload_flags flags
)
6543 if (ctype
&& ctype
!= cur_type
)
6545 if (flags
== DTOR_FLAG
)
6546 error ("destructor for alien class %qT cannot be a member", ctype
);
6548 error ("constructor for alien class %qT cannot be a member", ctype
);
6554 /* Subroutine of `grokdeclarator'. */
6556 /* Generate errors possibly applicable for a given set of specifiers.
6557 This is for ARM $7.1.2. */
6560 bad_specifiers (tree object
,
6569 error ("%qD declared as a %<virtual%> %s", object
, type
);
6571 error ("%qD declared as an %<inline%> %s", object
, type
);
6573 error ("%<const%> and %<volatile%> function specifiers on "
6574 "%qD invalid in %s declaration",
6577 error ("%q+D declared as a friend", object
);
6579 && (TREE_CODE (object
) == TYPE_DECL
6580 || (!TYPE_PTRFN_P (TREE_TYPE (object
))
6581 && !TYPE_REFFN_P (TREE_TYPE (object
))
6582 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object
)))))
6583 error ("%q+D declared with an exception specification", object
);
6586 /* DECL is a member function or static data member and is presently
6587 being defined. Check that the definition is taking place in a
6591 check_class_member_definition_namespace (tree decl
)
6593 /* These checks only apply to member functions and static data
6595 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
6596 || TREE_CODE (decl
) == VAR_DECL
);
6597 /* We check for problems with specializations in pt.c in
6598 check_specialization_namespace, where we can issue better
6600 if (processing_specialization
)
6602 /* There are no restrictions on the placement of
6603 explicit instantiations. */
6604 if (processing_explicit_instantiation
)
6608 A member function definition that appears outside of the
6609 class definition shall appear in a namespace scope enclosing
6610 the class definition.
6614 The definition for a static data member shall appear in a
6615 namespace scope enclosing the member's class definition. */
6616 if (!is_ancestor (current_namespace
, DECL_CONTEXT (decl
)))
6617 permerror (input_location
, "definition of %qD is not in namespace enclosing %qT",
6618 decl
, DECL_CONTEXT (decl
));
6621 /* Build a PARM_DECL for the "this" parameter. TYPE is the
6622 METHOD_TYPE for a non-static member function; QUALS are the
6623 cv-qualifiers that apply to the function. */
6626 build_this_parm (tree type
, cp_cv_quals quals
)
6631 cp_cv_quals this_quals
;
6633 this_type
= TREE_VALUE (TYPE_ARG_TYPES (type
));
6634 /* The `this' parameter is implicitly `const'; it cannot be
6636 this_quals
= (quals
& TYPE_QUAL_RESTRICT
) | TYPE_QUAL_CONST
;
6637 qual_type
= cp_build_qualified_type (this_type
, this_quals
);
6638 parm
= build_artificial_parm (this_identifier
, qual_type
);
6639 cp_apply_type_quals_to_decl (this_quals
, parm
);
6643 /* CTYPE is class type, or null if non-class.
6644 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
6646 DECLARATOR is the function's name.
6647 PARMS is a chain of PARM_DECLs for the function.
6648 VIRTUALP is truthvalue of whether the function is virtual or not.
6649 FLAGS are to be passed through to `grokclassfn'.
6650 QUALS are qualifiers indicating whether the function is `const'
6652 RAISES is a list of exceptions that this function can raise.
6653 CHECK is 1 if we must find this method in CTYPE, 0 if we should
6654 not look, and -1 if we should not call `grokclassfn' at all.
6656 SFK is the kind of special function (if any) for the new function.
6658 Returns `NULL_TREE' if something goes wrong, after issuing
6659 applicable error messages. */
6662 grokfndecl (tree ctype
,
6666 tree orig_declarator
,
6668 enum overload_flags flags
,
6675 special_function_kind sfk
,
6680 location_t location
)
6683 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
6687 type
= build_exception_variant (type
, raises
);
6689 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
6691 /* If we have an explicit location, use it, otherwise use whatever
6692 build_lang_decl used (probably input_location). */
6693 if (location
!= UNKNOWN_LOCATION
)
6694 DECL_SOURCE_LOCATION (decl
) = location
;
6696 if (TREE_CODE (type
) == METHOD_TYPE
)
6699 parm
= build_this_parm (type
, quals
);
6700 TREE_CHAIN (parm
) = parms
;
6703 DECL_ARGUMENTS (decl
) = parms
;
6704 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
6705 DECL_CONTEXT (t
) = decl
;
6706 /* Propagate volatile out from type to decl. */
6707 if (TYPE_VOLATILE (type
))
6708 TREE_THIS_VOLATILE (decl
) = 1;
6710 /* Setup decl according to sfk. */
6713 case sfk_constructor
:
6714 case sfk_copy_constructor
:
6715 case sfk_move_constructor
:
6716 DECL_CONSTRUCTOR_P (decl
) = 1;
6718 case sfk_destructor
:
6719 DECL_DESTRUCTOR_P (decl
) = 1;
6725 /* If pointers to member functions use the least significant bit to
6726 indicate whether a function is virtual, ensure a pointer
6727 to this function will have that bit clear. */
6728 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
6729 && TREE_CODE (type
) == METHOD_TYPE
6730 && DECL_ALIGN (decl
) < 2 * BITS_PER_UNIT
)
6731 DECL_ALIGN (decl
) = 2 * BITS_PER_UNIT
;
6734 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
6738 ("defining explicit specialization %qD in friend declaration",
6742 tree fns
= TREE_OPERAND (orig_declarator
, 0);
6743 tree args
= TREE_OPERAND (orig_declarator
, 1);
6745 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
6747 /* Something like `template <class T> friend void f<T>()'. */
6748 error ("invalid use of template-id %qD in declaration "
6749 "of primary template",
6755 /* A friend declaration of the form friend void f<>(). Record
6756 the information in the TEMPLATE_ID_EXPR. */
6757 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
6759 if (TREE_CODE (fns
) == COMPONENT_REF
)
6761 /* Due to bison parser ickiness, we will have already looked
6762 up an operator_name or PFUNCNAME within the current class
6763 (see template_id in parse.y). If the current class contains
6764 such a name, we'll get a COMPONENT_REF here. Undo that. */
6766 gcc_assert (TREE_TYPE (TREE_OPERAND (fns
, 0))
6767 == current_class_type
);
6768 fns
= TREE_OPERAND (fns
, 1);
6770 gcc_assert (TREE_CODE (fns
) == IDENTIFIER_NODE
6771 || TREE_CODE (fns
) == OVERLOAD
);
6772 DECL_TEMPLATE_INFO (decl
) = build_template_info (fns
, args
);
6774 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
6775 if (TREE_PURPOSE (t
)
6776 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
6778 error ("default arguments are not allowed in declaration "
6779 "of friend template specialization %qD",
6786 error ("%<inline%> is not allowed in declaration of friend "
6787 "template specialization %qD",
6794 /* If this decl has namespace scope, set that up. */
6796 set_decl_namespace (decl
, in_namespace
, friendp
);
6798 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_decl_namespace ());
6800 /* `main' and builtins have implicit 'C' linkage. */
6801 if ((MAIN_NAME_P (declarator
)
6802 || (IDENTIFIER_LENGTH (declarator
) > 10
6803 && IDENTIFIER_POINTER (declarator
)[0] == '_'
6804 && IDENTIFIER_POINTER (declarator
)[1] == '_'
6805 && strncmp (IDENTIFIER_POINTER (declarator
)+2, "builtin_", 8) == 0))
6806 && current_lang_name
== lang_name_cplusplus
6807 && ctype
== NULL_TREE
6808 /* NULL_TREE means global namespace. */
6809 && DECL_CONTEXT (decl
) == NULL_TREE
)
6810 SET_DECL_LANGUAGE (decl
, lang_c
);
6812 /* Should probably propagate const out from type to decl I bet (mrs). */
6815 DECL_STATIC_FUNCTION_P (decl
) = 1;
6816 DECL_CONTEXT (decl
) = ctype
;
6821 DECL_CONTEXT (decl
) = ctype
;
6823 check_class_member_definition_namespace (decl
);
6826 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
6828 if (processing_template_decl
)
6829 error ("cannot declare %<::main%> to be a template");
6831 error ("cannot declare %<::main%> to be inline");
6833 error ("cannot declare %<::main%> to be static");
6838 /* Members of anonymous types and local classes have no linkage; make
6839 them internal. If a typedef is made later, this will be changed. */
6840 if (ctype
&& (TYPE_ANONYMOUS_P (ctype
)
6841 || decl_function_context (TYPE_MAIN_DECL (ctype
))))
6844 if (publicp
&& cxx_dialect
== cxx98
)
6846 /* [basic.link]: A name with no linkage (notably, the name of a class
6847 or enumeration declared in a local scope) shall not be used to
6848 declare an entity with linkage.
6850 DR 757 relaxes this restriction for C++0x. */
6851 t
= no_linkage_check (TREE_TYPE (decl
),
6852 /*relaxed_p=*/false);
6855 if (TYPE_ANONYMOUS_P (t
))
6857 if (DECL_EXTERN_C_P (decl
))
6858 /* Allow this; it's pretty common in C. */;
6861 permerror (input_location
, "anonymous type with no linkage "
6862 "used to declare function %q#D with linkage",
6864 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
6865 permerror (input_location
, "%q+#D does not refer to the unqualified "
6866 "type, so it is not used for linkage",
6871 permerror (input_location
, "type %qT with no linkage used to "
6872 "declare function %q#D with linkage", t
, decl
);
6876 TREE_PUBLIC (decl
) = publicp
;
6879 DECL_INTERFACE_KNOWN (decl
) = 1;
6880 DECL_NOT_REALLY_EXTERN (decl
) = 1;
6883 /* If the declaration was declared inline, mark it as such. */
6885 DECL_DECLARED_INLINE_P (decl
) = 1;
6887 DECL_EXTERNAL (decl
) = 1;
6888 if (quals
&& TREE_CODE (type
) == FUNCTION_TYPE
)
6891 ? G_("static member function %qD cannot have cv-qualifier")
6892 : G_("non-member function %qD cannot have cv-qualifier"),
6894 quals
= TYPE_UNQUALIFIED
;
6897 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
))
6898 && !grok_op_properties (decl
, /*complain=*/true))
6902 /* Make the init_value nonzero so pushdecl knows this is not
6903 tentative. error_mark_node is replaced later with the BLOCK. */
6904 DECL_INITIAL (decl
) = error_mark_node
;
6906 if (TYPE_NOTHROW_P (type
) || nothrow_libfn_p (decl
))
6907 TREE_NOTHROW (decl
) = 1;
6909 /* Caller will do the rest of this. */
6913 if (ctype
!= NULL_TREE
)
6914 grokclassfn (ctype
, decl
, flags
);
6916 decl
= check_explicit_specialization (orig_declarator
, decl
,
6919 4 * (friendp
!= 0));
6920 if (decl
== error_mark_node
)
6925 cplus_decl_attributes (&decl
, *attrlist
, 0);
6926 *attrlist
= NULL_TREE
;
6929 /* Check main's type after attributes have been applied. */
6930 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
6932 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
6935 tree oldtypeargs
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
6937 error ("%<::main%> must return %<int%>");
6938 newtype
= build_function_type (integer_type_node
, oldtypeargs
);
6939 TREE_TYPE (decl
) = newtype
;
6942 check_main_parameter_types (decl
);
6945 if (ctype
!= NULL_TREE
6946 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
6949 tree old_decl
= check_classfn (ctype
, decl
,
6950 (processing_template_decl
6951 > template_class_depth (ctype
))
6952 ? current_template_parms
6955 if (old_decl
== error_mark_node
)
6963 if (TREE_CODE (old_decl
) == TEMPLATE_DECL
)
6964 /* Because grokfndecl is always supposed to return a
6965 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
6966 here. We depend on our callers to figure out that its
6967 really a template that's being returned. */
6968 old_decl
= DECL_TEMPLATE_RESULT (old_decl
);
6970 if (DECL_STATIC_FUNCTION_P (old_decl
)
6971 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
6972 /* Remove the `this' parm added by grokclassfn.
6973 XXX Isn't this done in start_function, too? */
6974 revert_static_member_fn (decl
);
6975 if (DECL_ARTIFICIAL (old_decl
))
6977 error ("definition of implicitly-declared %qD", old_decl
);
6981 /* Since we've smashed OLD_DECL to its
6982 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
6983 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
6984 decl
= DECL_TEMPLATE_RESULT (decl
);
6986 /* Attempt to merge the declarations. This can fail, in
6987 the case of some invalid specialization declarations. */
6988 pushed_scope
= push_scope (ctype
);
6989 ok
= duplicate_decls (decl
, old_decl
, friendp
);
6991 pop_scope (pushed_scope
);
6994 error ("no %q#D member function declared in class %qT",
7002 if (DECL_CONSTRUCTOR_P (decl
) && !grok_ctor_properties (ctype
, decl
))
7005 if (ctype
== NULL_TREE
|| check
)
7009 DECL_VIRTUAL_P (decl
) = 1;
7014 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
7015 the linkage that DECL will receive in the object file. */
7018 set_linkage_for_static_data_member (tree decl
)
7020 /* A static data member always has static storage duration and
7021 external linkage. Note that static data members are forbidden in
7022 local classes -- the only situation in which a class has
7023 non-external linkage. */
7024 TREE_PUBLIC (decl
) = 1;
7025 TREE_STATIC (decl
) = 1;
7026 /* For non-template classes, static data members are always put
7027 out in exactly those files where they are defined, just as
7028 with ordinary namespace-scope variables. */
7029 if (!processing_template_decl
)
7030 DECL_INTERFACE_KNOWN (decl
) = 1;
7033 /* Create a VAR_DECL named NAME with the indicated TYPE.
7035 If SCOPE is non-NULL, it is the class type or namespace containing
7036 the variable. If SCOPE is NULL, the variable should is created in
7037 the innermost enclosings scope. */
7040 grokvardecl (tree type
,
7042 const cp_decl_specifier_seq
*declspecs
,
7048 tree explicit_scope
;
7050 gcc_assert (!name
|| TREE_CODE (name
) == IDENTIFIER_NODE
);
7052 /* Compute the scope in which to place the variable, but remember
7053 whether or not that scope was explicitly specified by the user. */
7054 explicit_scope
= scope
;
7057 /* An explicit "extern" specifier indicates a namespace-scope
7059 if (declspecs
->storage_class
== sc_extern
)
7060 scope
= current_decl_namespace ();
7061 else if (!at_function_scope_p ())
7062 scope
= current_scope ();
7066 && (/* If the variable is a namespace-scope variable declared in a
7067 template, we need DECL_LANG_SPECIFIC. */
7068 (TREE_CODE (scope
) == NAMESPACE_DECL
&& processing_template_decl
)
7069 /* Similarly for namespace-scope variables with language linkage
7071 || (TREE_CODE (scope
) == NAMESPACE_DECL
7072 && current_lang_name
!= lang_name_cplusplus
)
7073 /* Similarly for static data members. */
7075 decl
= build_lang_decl (VAR_DECL
, name
, type
);
7077 decl
= build_decl (input_location
, VAR_DECL
, name
, type
);
7079 if (explicit_scope
&& TREE_CODE (explicit_scope
) == NAMESPACE_DECL
)
7080 set_decl_namespace (decl
, explicit_scope
, 0);
7082 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
7084 if (declspecs
->storage_class
== sc_extern
)
7086 DECL_THIS_EXTERN (decl
) = 1;
7087 DECL_EXTERNAL (decl
) = !initialized
;
7090 if (DECL_CLASS_SCOPE_P (decl
))
7092 set_linkage_for_static_data_member (decl
);
7093 /* This function is only called with out-of-class definitions. */
7094 DECL_EXTERNAL (decl
) = 0;
7095 check_class_member_definition_namespace (decl
);
7097 /* At top level, either `static' or no s.c. makes a definition
7098 (perhaps tentative), and absence of `static' makes it public. */
7099 else if (toplevel_bindings_p ())
7101 TREE_PUBLIC (decl
) = (declspecs
->storage_class
!= sc_static
7102 && (DECL_THIS_EXTERN (decl
) || ! constp
));
7103 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
7105 /* Not at top level, only `static' makes a static definition. */
7108 TREE_STATIC (decl
) = declspecs
->storage_class
== sc_static
;
7109 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
7112 if (declspecs
->specs
[(int)ds_thread
])
7113 DECL_TLS_MODEL (decl
) = decl_default_tls_model (decl
);
7115 /* If the type of the decl has no linkage, make sure that we'll
7116 notice that in mark_used. */
7117 if (cxx_dialect
> cxx98
7118 && decl_linkage (decl
) != lk_none
7119 && DECL_LANG_SPECIFIC (decl
) == NULL
7120 && !DECL_EXTERN_C_P (decl
)
7121 && no_linkage_check (TREE_TYPE (decl
), /*relaxed_p=*/false))
7122 retrofit_lang_decl (decl
);
7124 if (TREE_PUBLIC (decl
))
7126 /* [basic.link]: A name with no linkage (notably, the name of a class
7127 or enumeration declared in a local scope) shall not be used to
7128 declare an entity with linkage.
7130 DR 757 relaxes this restriction for C++0x. */
7131 tree t
= (cxx_dialect
> cxx98
? NULL_TREE
7132 : no_linkage_check (TREE_TYPE (decl
), /*relaxed_p=*/false));
7135 if (TYPE_ANONYMOUS_P (t
))
7137 if (DECL_EXTERN_C_P (decl
))
7138 /* Allow this; it's pretty common in C. */
7142 /* DRs 132, 319 and 389 seem to indicate types with
7143 no linkage can only be used to declare extern "C"
7144 entities. Since it's not always an error in the
7145 ISO C++ 90 Standard, we only issue a warning. */
7146 warning (0, "anonymous type with no linkage used to declare "
7147 "variable %q#D with linkage", decl
);
7148 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
7149 warning (0, "%q+#D does not refer to the unqualified "
7150 "type, so it is not used for linkage",
7155 warning (0, "type %qT with no linkage used to declare variable "
7156 "%q#D with linkage", t
, decl
);
7160 DECL_INTERFACE_KNOWN (decl
) = 1;
7165 /* Create and return a canonical pointer to member function type, for
7166 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
7169 build_ptrmemfunc_type (tree type
)
7173 tree unqualified_variant
= NULL_TREE
;
7175 if (type
== error_mark_node
)
7178 /* If a canonical type already exists for this type, use it. We use
7179 this method instead of type_hash_canon, because it only does a
7180 simple equality check on the list of field members. */
7182 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
7185 /* Make sure that we always have the unqualified pointer-to-member
7187 if (cp_type_quals (type
) != TYPE_UNQUALIFIED
)
7189 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type
));
7191 t
= make_class_type (RECORD_TYPE
);
7192 xref_basetypes (t
, NULL_TREE
);
7194 /* Let the front end know this is a pointer to member function... */
7195 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
7196 /* ... and not really a class type. */
7197 SET_CLASS_TYPE_P (t
, 0);
7199 field
= build_decl (input_location
, FIELD_DECL
, pfn_identifier
, type
);
7202 field
= build_decl (input_location
, FIELD_DECL
, delta_identifier
,
7204 TREE_CHAIN (field
) = fields
;
7207 finish_builtin_struct (t
, "__ptrmemfunc_type", fields
, ptr_type_node
);
7209 /* Zap out the name so that the back end will give us the debugging
7210 information for this anonymous RECORD_TYPE. */
7211 TYPE_NAME (t
) = NULL_TREE
;
7213 /* If this is not the unqualified form of this pointer-to-member
7214 type, set the TYPE_MAIN_VARIANT for this type to be the
7215 unqualified type. Since they are actually RECORD_TYPEs that are
7216 not variants of each other, we must do this manually.
7217 As we just built a new type there is no need to do yet another copy. */
7218 if (cp_type_quals (type
) != TYPE_UNQUALIFIED
)
7220 int type_quals
= cp_type_quals (type
);
7221 TYPE_READONLY (t
) = (type_quals
& TYPE_QUAL_CONST
) != 0;
7222 TYPE_VOLATILE (t
) = (type_quals
& TYPE_QUAL_VOLATILE
) != 0;
7223 TYPE_RESTRICT (t
) = (type_quals
& TYPE_QUAL_RESTRICT
) != 0;
7224 TYPE_MAIN_VARIANT (t
) = unqualified_variant
;
7225 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (unqualified_variant
);
7226 TYPE_NEXT_VARIANT (unqualified_variant
) = t
;
7227 TREE_TYPE (TYPE_BINFO (t
)) = t
;
7230 /* Cache this pointer-to-member type so that we can find it again
7232 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
7234 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
7235 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7236 else if (TYPE_CANONICAL (type
) != type
)
7237 TYPE_CANONICAL (t
) = build_ptrmemfunc_type (TYPE_CANONICAL (type
));
7242 /* Create and return a pointer to data member type. */
7245 build_ptrmem_type (tree class_type
, tree member_type
)
7247 if (TREE_CODE (member_type
) == METHOD_TYPE
)
7249 tree arg_types
= TYPE_ARG_TYPES (member_type
);
7250 cp_cv_quals quals
= cp_type_quals (TREE_TYPE (TREE_VALUE (arg_types
)));
7251 member_type
= build_memfn_type (member_type
, class_type
, quals
);
7252 return build_ptrmemfunc_type (build_pointer_type (member_type
));
7256 gcc_assert (TREE_CODE (member_type
) != FUNCTION_TYPE
);
7257 return build_offset_type (class_type
, member_type
);
7261 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
7262 Check to see that the definition is valid. Issue appropriate error
7263 messages. Return 1 if the definition is particularly bad, or 0
7267 check_static_variable_definition (tree decl
, tree type
)
7269 /* Motion 10 at San Diego: If a static const integral data member is
7270 initialized with an integral constant expression, the initializer
7271 may appear either in the declaration (within the class), or in
7272 the definition, but not both. If it appears in the class, the
7273 member is a member constant. The file-scope definition is always
7275 if (!ARITHMETIC_TYPE_P (type
) && TREE_CODE (type
) != ENUMERAL_TYPE
)
7277 error ("invalid in-class initialization of static data member "
7278 "of non-integral type %qT",
7280 /* If we just return the declaration, crashes will sometimes
7281 occur. We therefore return void_type_node, as if this were a
7282 friend declaration, to cause callers to completely ignore
7283 this declaration. */
7286 else if (!CP_TYPE_CONST_P (type
))
7287 error ("ISO C++ forbids in-class initialization of non-const "
7288 "static member %qD",
7290 else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type
))
7291 pedwarn (input_location
, OPT_pedantic
, "ISO C++ forbids initialization of member constant "
7292 "%qD of non-integral type %qT", decl
, type
);
7297 /* Given the SIZE (i.e., number of elements) in an array, compute an
7298 appropriate index type for the array. If non-NULL, NAME is the
7299 name of the thing being declared. */
7302 compute_array_index_type (tree name
, tree size
)
7306 tree abi_1_itype
= NULL_TREE
;
7308 if (error_operand_p (size
))
7309 return error_mark_node
;
7311 type
= TREE_TYPE (size
);
7312 /* The array bound must be an integer type. */
7313 if (!dependent_type_p (type
) && !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type
))
7316 error ("size of array %qD has non-integral type %qT", name
, type
);
7318 error ("size of array has non-integral type %qT", type
);
7319 size
= integer_one_node
;
7320 type
= TREE_TYPE (size
);
7323 /* We can only call value_dependent_expression_p on integral constant
7324 expressions; the parser adds a dummy NOP_EXPR with TREE_SIDE_EFFECTS
7325 set if this isn't one. */
7326 if (processing_template_decl
7327 && (TREE_SIDE_EFFECTS (size
) || value_dependent_expression_p (size
)))
7329 /* We cannot do any checking for a SIZE that isn't known to be
7330 constant. Just build the index type and mark that it requires
7331 structural equality checks. */
7332 itype
= build_index_type (build_min (MINUS_EXPR
, sizetype
,
7333 size
, integer_one_node
));
7334 TYPE_DEPENDENT_P (itype
) = 1;
7335 TYPE_DEPENDENT_P_VALID (itype
) = 1;
7336 SET_TYPE_STRUCTURAL_EQUALITY (itype
);
7340 if (!abi_version_at_least (2) && processing_template_decl
)
7341 /* For abi-1, we handled all instances in templates the same way,
7342 even when they were non-dependent. This affects the manglings
7343 produced. So, we do the normal checking for non-dependent
7344 sizes, but at the end we'll return the same type that abi-1
7345 would have, but with TYPE_CANONICAL set to the "right"
7346 value that the current ABI would provide. */
7347 abi_1_itype
= build_index_type (build_min (MINUS_EXPR
, sizetype
,
7348 size
, integer_one_node
));
7350 /* The size might be the result of a cast. */
7351 STRIP_TYPE_NOPS (size
);
7353 /* It might be a const variable or enumeration constant. */
7354 size
= integral_constant_value (size
);
7355 if (error_operand_p (size
))
7356 return error_mark_node
;
7358 /* Normally, the array-bound will be a constant. */
7359 if (TREE_CODE (size
) == INTEGER_CST
)
7361 /* Check to see if the array bound overflowed. Make that an
7362 error, no matter how generous we're being. */
7363 constant_expression_error (size
);
7365 /* An array must have a positive number of elements. */
7366 if (INT_CST_LT (size
, integer_zero_node
))
7369 error ("size of array %qD is negative", name
);
7371 error ("size of array is negative");
7372 size
= integer_one_node
;
7374 /* As an extension we allow zero-sized arrays. We always allow
7375 them in system headers because glibc uses them. */
7376 else if (integer_zerop (size
) && !in_system_header
)
7379 pedwarn (input_location
, OPT_pedantic
, "ISO C++ forbids zero-size array %qD", name
);
7381 pedwarn (input_location
, OPT_pedantic
, "ISO C++ forbids zero-size array");
7384 else if (TREE_CONSTANT (size
))
7386 /* `(int) &fn' is not a valid array bound. */
7388 error ("size of array %qD is not an integral constant-expression",
7391 error ("size of array is not an integral constant-expression");
7392 size
= integer_one_node
;
7394 else if (pedantic
&& warn_vla
!= 0)
7397 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array %qD", name
);
7399 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array");
7401 else if (warn_vla
> 0)
7405 "variable length array %qD is used", name
);
7408 "variable length array is used");
7411 if (processing_template_decl
&& !TREE_CONSTANT (size
))
7412 /* A variable sized array. */
7413 itype
= build_min (MINUS_EXPR
, sizetype
, size
, integer_one_node
);
7416 HOST_WIDE_INT saved_processing_template_decl
;
7418 /* Compute the index of the largest element in the array. It is
7419 one less than the number of elements in the array. We save
7420 and restore PROCESSING_TEMPLATE_DECL so that computations in
7421 cp_build_binary_op will be appropriately folded. */
7422 saved_processing_template_decl
= processing_template_decl
;
7423 processing_template_decl
= 0;
7424 itype
= cp_build_binary_op (input_location
,
7426 cp_convert (ssizetype
, size
),
7427 cp_convert (ssizetype
, integer_one_node
),
7428 tf_warning_or_error
);
7429 itype
= fold (itype
);
7430 processing_template_decl
= saved_processing_template_decl
;
7432 if (!TREE_CONSTANT (itype
))
7433 /* A variable sized array. */
7434 itype
= variable_size (itype
);
7435 /* Make sure that there was no overflow when creating to a signed
7436 index type. (For example, on a 32-bit machine, an array with
7437 size 2^32 - 1 is too big.) */
7438 else if (TREE_CODE (itype
) == INTEGER_CST
7439 && TREE_OVERFLOW (itype
))
7441 error ("overflow in array dimension");
7442 TREE_OVERFLOW (itype
) = 0;
7446 /* Create and return the appropriate index type. */
7449 tree t
= build_index_type (itype
);
7450 TYPE_CANONICAL (abi_1_itype
) = TYPE_CANONICAL (t
);
7454 return build_index_type (itype
);
7457 /* Returns the scope (if any) in which the entity declared by
7458 DECLARATOR will be located. If the entity was declared with an
7459 unqualified name, NULL_TREE is returned. */
7462 get_scope_of_declarator (const cp_declarator
*declarator
)
7464 while (declarator
&& declarator
->kind
!= cdk_id
)
7465 declarator
= declarator
->declarator
;
7467 /* If the declarator-id is a SCOPE_REF, the scope in which the
7468 declaration occurs is the first operand. */
7470 && declarator
->u
.id
.qualifying_scope
)
7471 return declarator
->u
.id
.qualifying_scope
;
7473 /* Otherwise, the declarator is not a qualified name; the entity will
7474 be declared in the current scope. */
7478 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
7479 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
7483 create_array_type_for_decl (tree name
, tree type
, tree size
)
7485 tree itype
= NULL_TREE
;
7487 /* If things have already gone awry, bail now. */
7488 if (type
== error_mark_node
|| size
== error_mark_node
)
7489 return error_mark_node
;
7491 /* If there are some types which cannot be array elements,
7492 issue an error-message and return. */
7493 switch (TREE_CODE (type
))
7497 error ("declaration of %qD as array of void", name
);
7499 error ("creating array of void");
7500 return error_mark_node
;
7504 error ("declaration of %qD as array of functions", name
);
7506 error ("creating array of functions");
7507 return error_mark_node
;
7509 case REFERENCE_TYPE
:
7511 error ("declaration of %qD as array of references", name
);
7513 error ("creating array of references");
7514 return error_mark_node
;
7518 error ("declaration of %qD as array of function members", name
);
7520 error ("creating array of function members");
7521 return error_mark_node
;
7529 The constant expressions that specify the bounds of the arrays
7530 can be omitted only for the first member of the sequence. */
7531 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
7534 error ("declaration of %qD as multidimensional array must "
7535 "have bounds for all dimensions except the first",
7538 error ("multidimensional array must have bounds for all "
7539 "dimensions except the first");
7541 return error_mark_node
;
7544 /* Figure out the index type for the array. */
7546 itype
= compute_array_index_type (name
, size
);
7549 T is called the array element type; this type shall not be [...] an
7550 abstract class type. */
7551 abstract_virtuals_error (name
, type
);
7553 return build_cplus_array_type (type
, itype
);
7556 /* Check that it's OK to declare a function with the indicated TYPE.
7557 SFK indicates the kind of special function (if any) that this
7558 function is. OPTYPE is the type given in a conversion operator
7559 declaration, or the class type for a constructor/destructor.
7560 Returns the actual return type of the function; that
7561 may be different than TYPE if an error occurs, or for certain
7562 special functions. */
7565 check_special_function_return_type (special_function_kind sfk
,
7571 case sfk_constructor
:
7573 error ("return type specification for constructor invalid");
7575 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
7576 type
= build_pointer_type (optype
);
7578 type
= void_type_node
;
7581 case sfk_destructor
:
7583 error ("return type specification for destructor invalid");
7584 /* We can't use the proper return type here because we run into
7585 problems with ambiguous bases and covariant returns.
7586 Java classes are left unchanged because (void *) isn't a valid
7587 Java type, and we don't want to change the Java ABI. */
7588 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
7589 type
= build_pointer_type (void_type_node
);
7591 type
= void_type_node
;
7594 case sfk_conversion
:
7596 error ("return type specified for %<operator %T%>", optype
);
7607 /* A variable or data member (whose unqualified name is IDENTIFIER)
7608 has been declared with the indicated TYPE. If the TYPE is not
7609 acceptable, issue an error message and return a type to use for
7610 error-recovery purposes. */
7613 check_var_type (tree identifier
, tree type
)
7615 if (VOID_TYPE_P (type
))
7618 error ("unnamed variable or field declared void");
7619 else if (TREE_CODE (identifier
) == IDENTIFIER_NODE
)
7621 gcc_assert (!IDENTIFIER_OPNAME_P (identifier
));
7622 error ("variable or field %qE declared void", identifier
);
7625 error ("variable or field declared void");
7626 type
= error_mark_node
;
7632 /* Given declspecs and a declarator (abstract or otherwise), determine
7633 the name and type of the object declared and construct a DECL node
7636 DECLSPECS points to the representation of declaration-specifier
7637 sequence that precedes declarator.
7639 DECL_CONTEXT says which syntactic context this declaration is in:
7640 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
7641 FUNCDEF for a function definition. Like NORMAL but a few different
7642 error messages in each case. Return value may be zero meaning
7643 this definition is too screwy to try to parse.
7644 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
7645 handle member functions (which have FIELD context).
7646 Return value may be zero meaning this definition is too screwy to
7648 PARM for a parameter declaration (either within a function prototype
7649 or before a function body). Make a PARM_DECL, or return void_type_node.
7650 TPARM for a template parameter declaration.
7651 CATCHPARM for a parameter declaration before a catch clause.
7652 TYPENAME if for a typename (in a cast or sizeof).
7653 Don't make a DECL node; just return the ..._TYPE node.
7654 FIELD for a struct or union field; make a FIELD_DECL.
7655 BITFIELD for a field with specified width.
7657 INITIALIZED is as for start_decl.
7659 ATTRLIST is a pointer to the list of attributes, which may be NULL
7660 if there are none; *ATTRLIST may be modified if attributes from inside
7661 the declarator should be applied to the declaration.
7663 When this function is called, scoping variables (such as
7664 CURRENT_CLASS_TYPE) should reflect the scope in which the
7665 declaration occurs, not the scope in which the new declaration will
7666 be placed. For example, on:
7670 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
7673 Returns a DECL (if a declarator is present), a TYPE (if there is no
7674 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
7678 grokdeclarator (const cp_declarator
*declarator
,
7679 const cp_decl_specifier_seq
*declspecs
,
7680 enum decl_context decl_context
,
7684 tree type
= NULL_TREE
;
7686 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
7687 int explicit_int
= 0;
7688 int explicit_char
= 0;
7689 int defaulted_int
= 0;
7690 tree dependent_name
= NULL_TREE
;
7692 tree typedef_decl
= NULL_TREE
;
7693 const char *name
= NULL
;
7694 tree typedef_type
= NULL_TREE
;
7695 /* True if this declarator is a function definition. */
7696 bool funcdef_flag
= false;
7697 cp_declarator_kind innermost_code
= cdk_error
;
7700 /* See the code below that used this. */
7701 tree decl_attr
= NULL_TREE
;
7704 /* Keep track of what sort of function is being processed
7705 so that we can warn about default return values, or explicit
7706 return values which do not match prescribed defaults. */
7707 special_function_kind sfk
= sfk_none
;
7709 tree dname
= NULL_TREE
;
7710 tree ctor_return_type
= NULL_TREE
;
7711 enum overload_flags flags
= NO_SPECIAL
;
7712 /* cv-qualifiers that apply to the declarator, for a declaration of
7713 a member function. */
7714 cp_cv_quals memfn_quals
= TYPE_UNQUALIFIED
;
7715 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
7717 tree raises
= NULL_TREE
;
7718 int template_count
= 0;
7719 tree returned_attrs
= NULL_TREE
;
7720 tree parms
= NULL_TREE
;
7721 const cp_declarator
*id_declarator
;
7722 /* The unqualified name of the declarator; either an
7723 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
7724 tree unqualified_id
;
7725 /* The class type, if any, in which this entity is located,
7726 or NULL_TREE if none. Note that this value may be different from
7727 the current class type; for example if an attempt is made to declare
7728 "A::f" inside "B", this value will be "A". */
7729 tree ctype
= current_class_type
;
7730 /* The NAMESPACE_DECL for the namespace in which this entity is
7731 located. If an unqualified name is used to declare the entity,
7732 this value will be NULL_TREE, even if the entity is located at
7734 tree in_namespace
= NULL_TREE
;
7735 cp_storage_class storage_class
;
7736 bool unsigned_p
, signed_p
, short_p
, long_p
, thread_p
;
7737 bool type_was_error_mark_node
= false;
7738 bool parameter_pack_p
= declarator
? declarator
->parameter_pack_p
: false;
7739 bool template_type_arg
= false;
7740 bool template_parm_flag
= false;
7741 bool constexpr_p
= declspecs
->specs
[(int) ds_constexpr
];
7744 signed_p
= declspecs
->specs
[(int)ds_signed
];
7745 unsigned_p
= declspecs
->specs
[(int)ds_unsigned
];
7746 short_p
= declspecs
->specs
[(int)ds_short
];
7747 long_p
= declspecs
->specs
[(int)ds_long
];
7748 longlong
= declspecs
->specs
[(int)ds_long
] >= 2;
7749 thread_p
= declspecs
->specs
[(int)ds_thread
];
7751 if (decl_context
== FUNCDEF
)
7752 funcdef_flag
= true, decl_context
= NORMAL
;
7753 else if (decl_context
== MEMFUNCDEF
)
7754 funcdef_flag
= true, decl_context
= FIELD
;
7755 else if (decl_context
== BITFIELD
)
7756 bitfield
= 1, decl_context
= FIELD
;
7757 else if (decl_context
== TEMPLATE_TYPE_ARG
)
7758 template_type_arg
= true, decl_context
= TYPENAME
;
7759 else if (decl_context
== TPARM
)
7760 template_parm_flag
= true, decl_context
= PARM
;
7762 if (initialized
> 1)
7763 funcdef_flag
= true;
7765 /* Look inside a declarator for the name being declared
7766 and get it as a string, for an error message. */
7767 for (id_declarator
= declarator
;
7769 id_declarator
= id_declarator
->declarator
)
7771 if (id_declarator
->kind
!= cdk_id
)
7772 innermost_code
= id_declarator
->kind
;
7774 switch (id_declarator
->kind
)
7777 if (id_declarator
->declarator
7778 && id_declarator
->declarator
->kind
== cdk_id
)
7780 sfk
= id_declarator
->declarator
->u
.id
.sfk
;
7781 if (sfk
== sfk_destructor
)
7788 tree qualifying_scope
= id_declarator
->u
.id
.qualifying_scope
;
7789 tree decl
= id_declarator
->u
.id
.unqualified_name
;
7792 if (qualifying_scope
)
7794 if (at_function_scope_p ())
7798 A declarator-id shall not be qualified except
7801 None of the cases are permitted in block
7803 if (qualifying_scope
== global_namespace
)
7804 error ("invalid use of qualified-name %<::%D%>",
7806 else if (TYPE_P (qualifying_scope
))
7807 error ("invalid use of qualified-name %<%T::%D%>",
7808 qualifying_scope
, decl
);
7810 error ("invalid use of qualified-name %<%D::%D%>",
7811 qualifying_scope
, decl
);
7812 return error_mark_node
;
7814 else if (TYPE_P (qualifying_scope
))
7816 ctype
= qualifying_scope
;
7817 if (innermost_code
!= cdk_function
7818 && current_class_type
7819 && !UNIQUELY_DERIVED_FROM_P (ctype
,
7820 current_class_type
))
7822 error ("type %qT is not derived from type %qT",
7823 ctype
, current_class_type
);
7824 return error_mark_node
;
7827 else if (TREE_CODE (qualifying_scope
) == NAMESPACE_DECL
)
7828 in_namespace
= qualifying_scope
;
7830 switch (TREE_CODE (decl
))
7836 if (innermost_code
!= cdk_function
)
7838 error ("declaration of %qD as non-function", decl
);
7839 return error_mark_node
;
7841 else if (!qualifying_scope
7842 && !(current_class_type
&& at_class_scope_p ()))
7844 error ("declaration of %qD as non-member", decl
);
7845 return error_mark_node
;
7848 type
= TREE_OPERAND (decl
, 0);
7850 type
= constructor_name (type
);
7851 name
= identifier_to_locale (IDENTIFIER_POINTER (type
));
7856 case TEMPLATE_ID_EXPR
:
7858 tree fns
= TREE_OPERAND (decl
, 0);
7861 if (TREE_CODE (dname
) != IDENTIFIER_NODE
)
7863 gcc_assert (is_overloaded_fn (dname
));
7864 dname
= DECL_NAME (get_first_fn (dname
));
7869 case IDENTIFIER_NODE
:
7870 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
7873 if (C_IS_RESERVED_WORD (dname
))
7875 error ("declarator-id missing; using reserved word %qD",
7877 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
7879 else if (!IDENTIFIER_TYPENAME_P (dname
))
7880 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
7883 gcc_assert (flags
== NO_SPECIAL
);
7884 flags
= TYPENAME_FLAG
;
7885 ctor_return_type
= TREE_TYPE (dname
);
7886 sfk
= sfk_conversion
;
7887 if (is_typename_at_global_scope (dname
))
7888 name
= identifier_to_locale (IDENTIFIER_POINTER (dname
));
7890 name
= "<invalid operator>";
7907 return error_mark_node
;
7912 if (id_declarator
->kind
== cdk_id
)
7918 The declarator in a function-definition shall have the form
7919 D1 ( parameter-declaration-clause) ... */
7920 if (funcdef_flag
&& innermost_code
!= cdk_function
)
7922 error ("function definition does not declare parameters");
7923 return error_mark_node
;
7926 if (((dname
&& IDENTIFIER_OPNAME_P (dname
)) || flags
== TYPENAME_FLAG
)
7927 && innermost_code
!= cdk_function
7928 && ! (ctype
&& !declspecs
->any_specifiers_p
))
7930 error ("declaration of %qD as non-function", dname
);
7931 return error_mark_node
;
7934 /* Anything declared one level down from the top level
7935 must be one of the parameters of a function
7936 (because the body is at least two levels down). */
7938 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
7939 by not allowing C++ class definitions to specify their parameters
7940 with xdecls (must be spec.d in the parmlist).
7942 Since we now wait to push a class scope until we are sure that
7943 we are in a legitimate method context, we must set oldcname
7944 explicitly (since current_class_name is not yet alive).
7946 We also want to avoid calling this a PARM if it is in a namespace. */
7948 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
7950 struct cp_binding_level
*b
= current_binding_level
;
7951 current_binding_level
= b
->level_chain
;
7952 if (current_binding_level
!= 0 && toplevel_bindings_p ())
7953 decl_context
= PARM
;
7954 current_binding_level
= b
;
7958 name
= decl_context
== PARM
? "parameter" : "type name";
7960 /* If there were multiple types specified in the decl-specifier-seq,
7961 issue an error message. */
7962 if (declspecs
->multiple_types_p
)
7964 error ("two or more data types in declaration of %qs", name
);
7965 return error_mark_node
;
7968 if (declspecs
->conflicting_specifiers_p
)
7970 error ("conflicting specifiers in declaration of %qs", name
);
7971 return error_mark_node
;
7974 /* Extract the basic type from the decl-specifier-seq. */
7975 type
= declspecs
->type
;
7976 if (type
== error_mark_node
)
7979 type_was_error_mark_node
= true;
7981 /* If the entire declaration is itself tagged as deprecated then
7982 suppress reports of deprecated items. */
7983 if (type
&& TREE_DEPRECATED (type
)
7984 && deprecated_state
!= DEPRECATED_SUPPRESS
)
7985 warn_deprecated_use (type
, NULL_TREE
);
7986 if (type
&& TREE_CODE (type
) == TYPE_DECL
)
7988 typedef_decl
= type
;
7989 type
= TREE_TYPE (typedef_decl
);
7990 if (TREE_DEPRECATED (type
)
7991 && DECL_ARTIFICIAL (typedef_decl
)
7992 && deprecated_state
!= DEPRECATED_SUPPRESS
)
7993 warn_deprecated_use (type
, NULL_TREE
);
7995 /* No type at all: default to `int', and set DEFAULTED_INT
7996 because it was not a user-defined typedef. */
7997 if (type
== NULL_TREE
&& (signed_p
|| unsigned_p
|| long_p
|| short_p
))
7999 /* These imply 'int'. */
8000 type
= integer_type_node
;
8004 explicit_int
= declspecs
->explicit_int_p
;
8005 explicit_char
= declspecs
->explicit_char_p
;
8008 /* See the code below that used this. */
8010 decl_attr
= DECL_ATTRIBUTES (typedef_decl
);
8012 typedef_type
= type
;
8015 if (sfk
!= sfk_conversion
)
8016 ctor_return_type
= ctype
;
8018 if (sfk
!= sfk_none
)
8019 type
= check_special_function_return_type (sfk
, type
,
8021 else if (type
== NULL_TREE
)
8027 /* We handle `main' specially here, because 'main () { }' is so
8028 common. With no options, it is allowed. With -Wreturn-type,
8029 it is a warning. It is only an error with -pedantic-errors. */
8030 is_main
= (funcdef_flag
8031 && dname
&& MAIN_NAME_P (dname
)
8032 && ctype
== NULL_TREE
8033 && in_namespace
== NULL_TREE
8034 && current_namespace
== global_namespace
);
8036 if (type_was_error_mark_node
)
8037 /* We've already issued an error, don't complain more. */;
8038 else if (in_system_header
|| flag_ms_extensions
)
8039 /* Allow it, sigh. */;
8041 permerror (input_location
, "ISO C++ forbids declaration of %qs with no type", name
);
8043 pedwarn (input_location
, OPT_pedantic
,
8044 "ISO C++ forbids declaration of %qs with no type", name
);
8046 warning (OPT_Wreturn_type
,
8047 "ISO C++ forbids declaration of %qs with no type", name
);
8049 type
= integer_type_node
;
8054 /* Now process the modifiers that were specified
8055 and check for invalid combinations. */
8057 /* Long double is a special combination. */
8058 if (long_p
&& !longlong
&& TYPE_MAIN_VARIANT (type
) == double_type_node
)
8061 type
= build_qualified_type (long_double_type_node
,
8062 cp_type_quals (type
));
8065 /* Check all other uses of type modifiers. */
8067 if (unsigned_p
|| signed_p
|| long_p
|| short_p
)
8071 if ((signed_p
|| unsigned_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
8072 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
8073 else if (signed_p
&& unsigned_p
)
8074 error ("%<signed%> and %<unsigned%> specified together for %qs", name
);
8075 else if (longlong
&& TREE_CODE (type
) != INTEGER_TYPE
)
8076 error ("%<long long%> invalid for %qs", name
);
8077 else if (long_p
&& TREE_CODE (type
) == REAL_TYPE
)
8078 error ("%<long%> invalid for %qs", name
);
8079 else if (short_p
&& TREE_CODE (type
) == REAL_TYPE
)
8080 error ("%<short%> invalid for %qs", name
);
8081 else if ((long_p
|| short_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
8082 error ("%<long%> or %<short%> invalid for %qs", name
);
8083 else if ((long_p
|| short_p
) && explicit_char
)
8084 error ("%<long%> or %<short%> specified with char for %qs", name
);
8085 else if (long_p
&& short_p
)
8086 error ("%<long%> and %<short%> specified together for %qs", name
);
8087 else if (type
== char16_type_node
|| type
== char32_type_node
)
8089 if (signed_p
|| unsigned_p
)
8090 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
8091 else if (short_p
|| long_p
)
8092 error ("%<short%> or %<long%> invalid for %qs", name
);
8097 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& pedantic
)
8099 pedwarn (input_location
, OPT_pedantic
,
8100 "long, short, signed or unsigned used invalidly for %qs",
8102 if (flag_pedantic_errors
)
8107 /* Discard the type modifiers if they are invalid. */
8118 /* Decide whether an integer type is signed or not.
8119 Optionally treat bitfields as signed by default. */
8123 It is implementation-defined whether a plain (neither
8124 explicitly signed or unsigned) char, short, int, or long
8125 bit-field is signed or unsigned.
8127 Naturally, we extend this to long long as well. Note that
8128 this does not include wchar_t. */
8129 || (bitfield
&& !flag_signed_bitfields
8131 /* A typedef for plain `int' without `signed' can be
8132 controlled just like plain `int', but a typedef for
8133 `signed int' cannot be so controlled. */
8135 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
8136 && TREE_CODE (type
) == INTEGER_TYPE
8137 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
8140 type
= long_long_unsigned_type_node
;
8142 type
= long_unsigned_type_node
;
8144 type
= short_unsigned_type_node
;
8145 else if (type
== char_type_node
)
8146 type
= unsigned_char_type_node
;
8147 else if (typedef_decl
)
8148 type
= unsigned_type_for (type
);
8150 type
= unsigned_type_node
;
8152 else if (signed_p
&& type
== char_type_node
)
8153 type
= signed_char_type_node
;
8155 type
= long_long_integer_type_node
;
8157 type
= long_integer_type_node
;
8159 type
= short_integer_type_node
;
8161 if (declspecs
->specs
[(int)ds_complex
])
8163 if (TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
8164 error ("complex invalid for %qs", name
);
8165 /* If we just have "complex", it is equivalent to
8166 "complex double", but if any modifiers at all are specified it is
8167 the complex form of TYPE. E.g, "complex short" is
8168 "complex short int". */
8170 else if (defaulted_int
&& ! longlong
8171 && ! (long_p
|| short_p
|| signed_p
|| unsigned_p
))
8172 type
= complex_double_type_node
;
8173 else if (type
== integer_type_node
)
8174 type
= complex_integer_type_node
;
8175 else if (type
== float_type_node
)
8176 type
= complex_float_type_node
;
8177 else if (type
== double_type_node
)
8178 type
= complex_double_type_node
;
8179 else if (type
== long_double_type_node
)
8180 type
= complex_long_double_type_node
;
8182 type
= build_complex_type (type
);
8185 type_quals
= TYPE_UNQUALIFIED
;
8186 if (declspecs
->specs
[(int)ds_const
])
8187 type_quals
|= TYPE_QUAL_CONST
;
8188 /* A `constexpr' specifier used in an object declaration declares
8189 the object as `const'. */
8192 if (innermost_code
== cdk_function
)
8194 else if (declspecs
->specs
[(int)ds_const
] != 0)
8195 error ("both %<const%> and %<constexpr%> cannot be used here");
8197 type_quals
|= TYPE_QUAL_CONST
;
8199 if (declspecs
->specs
[(int)ds_volatile
])
8200 type_quals
|= TYPE_QUAL_VOLATILE
;
8201 if (declspecs
->specs
[(int)ds_restrict
])
8202 type_quals
|= TYPE_QUAL_RESTRICT
;
8203 if (sfk
== sfk_conversion
&& type_quals
!= TYPE_UNQUALIFIED
)
8204 error ("qualifiers are not allowed on declaration of %<operator %T%>",
8207 if (TREE_CODE (type
) == FUNCTION_TYPE
8208 && type_quals
!= TYPE_UNQUALIFIED
)
8210 /* This was an error in C++98 (cv-qualifiers cannot be added to
8211 a function type), but DR 295 makes the code well-formed by
8212 dropping the extra qualifiers. */
8213 if (pedantic
&& cxx_dialect
== cxx98
)
8215 tree bad_type
= build_qualified_type (type
, type_quals
);
8216 pedwarn (input_location
, OPT_pedantic
,
8217 "ignoring %qV qualifiers added to function type %qT",
8220 type_quals
= TYPE_UNQUALIFIED
;
8222 type_quals
|= cp_type_quals (type
);
8223 type
= cp_build_qualified_type_real
8224 (type
, type_quals
, ((typedef_decl
&& !DECL_ARTIFICIAL (typedef_decl
)
8225 ? tf_ignore_bad_quals
: 0) | tf_warning_or_error
));
8226 /* We might have ignored or rejected some of the qualifiers. */
8227 type_quals
= cp_type_quals (type
);
8230 inlinep
= !! declspecs
->specs
[(int)ds_inline
];
8231 virtualp
= !! declspecs
->specs
[(int)ds_virtual
];
8232 explicitp
= !! declspecs
->specs
[(int)ds_explicit
];
8234 storage_class
= declspecs
->storage_class
;
8235 if (storage_class
== sc_static
)
8236 staticp
= 1 + (decl_context
== FIELD
);
8238 if (virtualp
&& staticp
== 2)
8240 error ("member %qD cannot be declared both virtual and static", dname
);
8241 storage_class
= sc_none
;
8244 friendp
= !! declspecs
->specs
[(int)ds_friend
];
8246 if (dependent_name
&& !friendp
)
8248 error ("%<%T::%D%> is not a valid declarator", ctype
, dependent_name
);
8249 return error_mark_node
;
8252 /* Issue errors about use of storage classes for parameters. */
8253 if (decl_context
== PARM
)
8255 if (declspecs
->specs
[(int)ds_typedef
])
8257 error ("typedef declaration invalid in parameter declaration");
8258 return error_mark_node
;
8260 else if (template_parm_flag
&& storage_class
!= sc_none
)
8262 error ("storage class specified for template parameter %qs", name
);
8263 return error_mark_node
;
8265 else if (storage_class
== sc_static
8266 || storage_class
== sc_extern
8268 error ("storage class specifiers invalid in parameter declarations");
8270 if (type_uses_auto (type
))
8272 error ("parameter declared %<auto%>");
8273 type
= error_mark_node
;
8276 /* Function parameters cannot be constexpr. If we saw one, moan
8277 and pretend it wasn't there. */
8280 error ("a parameter cannot be declared %<constexpr%>");
8285 /* Give error if `virtual' is used outside of class declaration. */
8287 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
8289 error ("%<virtual%> outside class declaration");
8293 /* Static anonymous unions are dealt with here. */
8294 if (staticp
&& decl_context
== TYPENAME
8296 && ANON_AGGR_TYPE_P (declspecs
->type
))
8297 decl_context
= FIELD
;
8299 /* Warn about storage classes that are invalid for certain
8300 kinds of declarations (parameters, typenames, etc.). */
8303 && storage_class
!= sc_extern
8304 && storage_class
!= sc_static
)
8305 || declspecs
->specs
[(int)ds_typedef
]))
8307 error ("multiple storage classes in declaration of %qs", name
);
8310 if (decl_context
!= NORMAL
8311 && ((storage_class
!= sc_none
8312 && storage_class
!= sc_mutable
)
8315 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
8316 && (storage_class
== sc_register
8317 || storage_class
== sc_auto
))
8319 else if (declspecs
->specs
[(int)ds_typedef
])
8321 else if (decl_context
== FIELD
8322 /* C++ allows static class elements. */
8323 && storage_class
== sc_static
)
8324 /* C++ also allows inlines and signed and unsigned elements,
8325 but in those cases we don't come in here. */
8329 if (decl_context
== FIELD
)
8330 error ("storage class specified for %qs", name
);
8333 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
8334 error ("storage class specified for parameter %qs", name
);
8336 error ("storage class specified for typename");
8338 if (storage_class
== sc_register
8339 || storage_class
== sc_auto
8340 || storage_class
== sc_extern
8342 storage_class
= sc_none
;
8345 else if (storage_class
== sc_extern
&& funcdef_flag
8346 && ! toplevel_bindings_p ())
8347 error ("nested function %qs declared %<extern%>", name
);
8348 else if (toplevel_bindings_p ())
8350 if (storage_class
== sc_auto
)
8351 error ("top-level declaration of %qs specifies %<auto%>", name
);
8354 && storage_class
!= sc_extern
8355 && storage_class
!= sc_static
)
8357 error ("function-scope %qs implicitly auto and declared %<__thread%>",
8362 if (storage_class
&& friendp
)
8364 error ("storage class specifiers invalid in friend function declarations");
8365 storage_class
= sc_none
;
8370 unqualified_id
= NULL_TREE
;
8373 unqualified_id
= id_declarator
->u
.id
.unqualified_name
;
8374 switch (TREE_CODE (unqualified_id
))
8377 unqualified_id
= TREE_OPERAND (unqualified_id
, 0);
8378 if (TYPE_P (unqualified_id
))
8379 unqualified_id
= constructor_name (unqualified_id
);
8382 case IDENTIFIER_NODE
:
8383 case TEMPLATE_ID_EXPR
:
8391 /* Determine the type of the entity declared by recurring on the
8393 for (; declarator
; declarator
= declarator
->declarator
)
8395 const cp_declarator
*inner_declarator
;
8398 if (type
== error_mark_node
)
8399 return error_mark_node
;
8401 attrs
= declarator
->attributes
;
8407 if (declarator
== NULL
|| declarator
->kind
== cdk_id
)
8408 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
8409 if (declarator
->kind
== cdk_function
)
8410 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
8411 if (declarator
->kind
== cdk_array
)
8412 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
8413 returned_attrs
= decl_attributes (&type
,
8414 chainon (returned_attrs
, attrs
),
8418 if (declarator
->kind
== cdk_id
)
8421 inner_declarator
= declarator
->declarator
;
8423 switch (declarator
->kind
)
8426 type
= create_array_type_for_decl (dname
, type
,
8427 declarator
->u
.array
.bounds
);
8435 /* Declaring a function type.
8436 Make sure we have a valid type for the function to return. */
8438 if (type_quals
!= TYPE_UNQUALIFIED
)
8440 if (SCALAR_TYPE_P (type
) || VOID_TYPE_P (type
))
8441 warning (OPT_Wignored_qualifiers
,
8442 "type qualifiers ignored on function return type");
8443 /* We now know that the TYPE_QUALS don't apply to the
8444 decl, but to its return type. */
8445 type_quals
= TYPE_UNQUALIFIED
;
8447 errmsg
= targetm
.invalid_return_type (type
);
8451 type
= integer_type_node
;
8454 /* Error about some types functions can't return. */
8456 if (TREE_CODE (type
) == FUNCTION_TYPE
)
8458 error ("%qs declared as function returning a function", name
);
8459 return error_mark_node
;
8461 if (TREE_CODE (type
) == ARRAY_TYPE
)
8463 error ("%qs declared as function returning an array", name
);
8464 return error_mark_node
;
8467 /* Pick up type qualifiers which should be applied to `this'. */
8468 memfn_quals
= declarator
->u
.function
.qualifiers
;
8470 /* Pick up the exception specifications. */
8471 raises
= declarator
->u
.function
.exception_specification
;
8473 /* Say it's a definition only for the CALL_EXPR
8474 closest to the identifier. */
8475 funcdecl_p
= inner_declarator
&& inner_declarator
->kind
== cdk_id
;
8477 /* Handle a late-specified return type. */
8480 if (type_uses_auto (type
))
8482 if (!declarator
->u
.function
.late_return_type
)
8484 error ("%qs function uses %<auto%> type specifier without"
8485 " late return type", name
);
8486 return error_mark_node
;
8488 else if (!is_auto (type
))
8490 error ("%qs function with late return type has"
8491 " %qT as its type rather than plain %<auto%>",
8493 return error_mark_node
;
8496 else if (declarator
->u
.function
.late_return_type
)
8498 error ("%qs function with late return type not declared"
8499 " with %<auto%> type specifier", name
);
8500 return error_mark_node
;
8503 type
= splice_late_return_type
8504 (type
, declarator
->u
.function
.late_return_type
);
8505 if (type
== error_mark_node
)
8506 return error_mark_node
;
8508 if (ctype
== NULL_TREE
8509 && decl_context
== FIELD
8511 && (friendp
== 0 || dname
== current_class_name
))
8512 ctype
= current_class_type
;
8514 if (ctype
&& (sfk
== sfk_constructor
8515 || sfk
== sfk_destructor
))
8517 /* We are within a class's scope. If our declarator name
8518 is the same as the class name, and we are defining
8519 a function, then it is a constructor/destructor, and
8520 therefore returns a void type. */
8522 /* ISO C++ 12.4/2. A destructor may not be declared
8523 const or volatile. A destructor may not be
8526 ISO C++ 12.1. A constructor may not be declared
8527 const or volatile. A constructor may not be
8528 virtual. A constructor may not be static. */
8530 error ((flags
== DTOR_FLAG
)
8531 ? "destructor cannot be static member function"
8532 : "constructor cannot be static member function");
8535 error ((flags
== DTOR_FLAG
)
8536 ? "destructors may not be cv-qualified"
8537 : "constructors may not be cv-qualified");
8538 memfn_quals
= TYPE_UNQUALIFIED
;
8541 if (decl_context
== FIELD
8542 && !member_function_or_else (ctype
,
8545 return error_mark_node
;
8547 if (flags
!= DTOR_FLAG
)
8549 /* It's a constructor. */
8554 permerror (input_location
, "constructors cannot be declared virtual");
8557 if (decl_context
== FIELD
8558 && sfk
!= sfk_constructor
)
8559 return error_mark_node
;
8561 if (decl_context
== FIELD
)
8567 error ("can't initialize friend function %qs", name
);
8570 /* Cannot be both friend and virtual. */
8571 error ("virtual functions cannot be friends");
8574 if (decl_context
== NORMAL
)
8575 error ("friend declaration not in class definition");
8576 if (current_function_decl
&& funcdef_flag
)
8577 error ("can't define friend function %qs in a local "
8581 else if (ctype
&& sfk
== sfk_conversion
)
8585 maybe_warn_cpp0x (CPP0X_EXPLICIT_CONVERSION
);
8590 /* It is not allowed to use `constexpr' in a function
8591 declaration that is not a definition.
8592 That is too strict, though. */
8593 if (constexpr_p
&& !funcdef_flag
)
8595 error ("the %<constexpr%> specifier cannot be used in "
8596 "a function declaration that is not a definition");
8597 constexpr_p
= false;
8600 /* A constexpr non-static member function is implicitly const. */
8601 if (constexpr_p
&& decl_context
== FIELD
&& staticp
== 0
8602 && sfk
!= sfk_constructor
&& sfk
!= sfk_destructor
)
8603 memfn_quals
|= TYPE_QUAL_CONST
;
8605 arg_types
= grokparms (declarator
->u
.function
.parameters
,
8608 if (inner_declarator
8609 && inner_declarator
->kind
== cdk_id
8610 && inner_declarator
->u
.id
.sfk
== sfk_destructor
8611 && arg_types
!= void_list_node
)
8613 error ("destructors may not have parameters");
8614 arg_types
= void_list_node
;
8618 type
= build_function_type (type
, arg_types
);
8625 /* Filter out pointers-to-references and references-to-references.
8626 We can get these if a TYPE_DECL is used. */
8628 if (TREE_CODE (type
) == REFERENCE_TYPE
)
8630 if (declarator
->kind
!= cdk_reference
)
8632 error ("cannot declare pointer to %q#T", type
);
8633 type
= TREE_TYPE (type
);
8636 /* In C++0x, we allow reference to reference declarations
8637 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
8638 and template type arguments [14.3.1/4 temp.arg.type]. The
8639 check for direct reference to reference declarations, which
8640 are still forbidden, occurs below. Reasoning behind the change
8641 can be found in DR106, DR540, and the rvalue reference
8643 else if (cxx_dialect
== cxx98
)
8645 error ("cannot declare reference to %q#T", type
);
8646 type
= TREE_TYPE (type
);
8649 else if (VOID_TYPE_P (type
))
8651 if (declarator
->kind
== cdk_reference
)
8652 error ("cannot declare reference to %q#T", type
);
8653 else if (declarator
->kind
== cdk_ptrmem
)
8654 error ("cannot declare pointer to %q#T member", type
);
8657 /* We now know that the TYPE_QUALS don't apply to the decl,
8658 but to the target of the pointer. */
8659 type_quals
= TYPE_UNQUALIFIED
;
8661 if (declarator
->kind
== cdk_ptrmem
8662 && (TREE_CODE (type
) == FUNCTION_TYPE
8663 || (memfn_quals
&& TREE_CODE (type
) == METHOD_TYPE
)))
8665 memfn_quals
|= cp_type_quals (type
);
8666 type
= build_memfn_type (type
,
8667 declarator
->u
.pointer
.class_type
,
8669 memfn_quals
= TYPE_UNQUALIFIED
;
8672 if (TREE_CODE (type
) == FUNCTION_TYPE
8673 && cp_type_quals (type
) != TYPE_UNQUALIFIED
)
8674 error (declarator
->kind
== cdk_reference
8675 ? G_("cannot declare reference to qualified function type %qT")
8676 : G_("cannot declare pointer to qualified function type %qT"),
8679 if (declarator
->kind
== cdk_reference
)
8681 /* In C++0x, the type we are creating a reference to might be
8682 a typedef which is itself a reference type. In that case,
8683 we follow the reference collapsing rules in
8684 [7.1.3/8 dcl.typedef] to create the final reference type:
8686 "If a typedef TD names a type that is a reference to a type
8687 T, an attempt to create the type 'lvalue reference to cv TD'
8688 creates the type 'lvalue reference to T,' while an attempt
8689 to create the type "rvalue reference to cv TD' creates the
8692 if (!VOID_TYPE_P (type
))
8693 type
= cp_build_reference_type
8694 ((TREE_CODE (type
) == REFERENCE_TYPE
8695 ? TREE_TYPE (type
) : type
),
8696 (declarator
->u
.reference
.rvalue_ref
8697 && (TREE_CODE(type
) != REFERENCE_TYPE
8698 || TYPE_REF_IS_RVALUE (type
))));
8700 /* In C++0x, we need this check for direct reference to
8701 reference declarations, which are forbidden by
8702 [8.3.2/5 dcl.ref]. Reference to reference declarations
8703 are only allowed indirectly through typedefs and template
8704 type arguments. Example:
8706 void foo(int & &); // invalid ref-to-ref decl
8708 typedef int & int_ref;
8709 void foo(int_ref &); // valid ref-to-ref decl
8711 if (inner_declarator
&& inner_declarator
->kind
== cdk_reference
)
8712 error ("cannot declare reference to %q#T, which is not "
8713 "a typedef or a template type argument", type
);
8715 else if (TREE_CODE (type
) == METHOD_TYPE
)
8716 type
= build_ptrmemfunc_type (build_pointer_type (type
));
8717 else if (declarator
->kind
== cdk_ptrmem
)
8719 gcc_assert (TREE_CODE (declarator
->u
.pointer
.class_type
)
8721 if (declarator
->u
.pointer
.class_type
== error_mark_node
)
8722 /* We will already have complained. */
8723 type
= error_mark_node
;
8725 type
= build_ptrmem_type (declarator
->u
.pointer
.class_type
,
8729 type
= build_pointer_type (type
);
8731 /* Process a list of type modifier keywords (such as
8732 const or volatile) that were given inside the `*' or `&'. */
8734 if (declarator
->u
.pointer
.qualifiers
)
8737 = cp_build_qualified_type (type
,
8738 declarator
->u
.pointer
.qualifiers
);
8739 type_quals
= cp_type_quals (type
);
8752 if (unqualified_id
&& TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
8753 && TREE_CODE (type
) != FUNCTION_TYPE
8754 && TREE_CODE (type
) != METHOD_TYPE
)
8756 error ("template-id %qD used as a declarator",
8758 unqualified_id
= dname
;
8761 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
8762 qualified with a class-name, turn it into a METHOD_TYPE, unless
8763 we know that the function is static. We take advantage of this
8764 opportunity to do other processing that pertains to entities
8765 explicitly declared to be class members. Note that if DECLARATOR
8766 is non-NULL, we know it is a cdk_id declarator; otherwise, we
8767 would not have exited the loop above. */
8769 && declarator
->u
.id
.qualifying_scope
8770 && TYPE_P (declarator
->u
.id
.qualifying_scope
))
8774 ctype
= declarator
->u
.id
.qualifying_scope
;
8775 ctype
= TYPE_MAIN_VARIANT (ctype
);
8777 while (t
!= NULL_TREE
&& CLASS_TYPE_P (t
))
8779 /* You're supposed to have one `template <...>' for every
8780 template class, but you don't need one for a full
8781 specialization. For example:
8783 template <class T> struct S{};
8784 template <> struct S<int> { void f(); };
8785 void S<int>::f () {}
8787 is correct; there shouldn't be a `template <>' for the
8788 definition of `S<int>::f'. */
8789 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
)
8790 && !any_dependent_template_arguments_p (CLASSTYPE_TI_ARGS (t
)))
8791 /* T is an explicit (not partial) specialization. All
8792 containing classes must therefore also be explicitly
8795 if ((CLASSTYPE_USE_TEMPLATE (t
) || CLASSTYPE_IS_TEMPLATE (t
))
8796 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)))
8797 template_count
+= 1;
8799 t
= TYPE_MAIN_DECL (t
);
8800 t
= DECL_CONTEXT (t
);
8803 if (ctype
== current_class_type
)
8807 permerror (input_location
, "member functions are implicitly friends of their class");
8811 permerror (declarator
->id_loc
,
8812 "extra qualification %<%T::%> on member %qs",
8815 else if (/* If the qualifying type is already complete, then we
8816 can skip the following checks. */
8817 !COMPLETE_TYPE_P (ctype
)
8818 && (/* If the function is being defined, then
8819 qualifying type must certainly be complete. */
8821 /* A friend declaration of "T::f" is OK, even if
8822 "T" is a template parameter. But, if this
8823 function is not a friend, the qualifying type
8825 || (!friendp
&& !CLASS_TYPE_P (ctype
))
8826 /* For a declaration, the type need not be
8827 complete, if either it is dependent (since there
8828 is no meaningful definition of complete in that
8829 case) or the qualifying class is currently being
8831 || !(dependent_type_p (ctype
)
8832 || currently_open_class (ctype
)))
8833 /* Check that the qualifying type is complete. */
8834 && !complete_type_or_else (ctype
, NULL_TREE
))
8835 return error_mark_node
;
8836 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
8838 tree sname
= declarator
->u
.id
.unqualified_name
;
8840 if (current_class_type
8841 && (!friendp
|| funcdef_flag
))
8844 ? "cannot define member function %<%T::%s%> within %<%T%>"
8845 : "cannot declare member function %<%T::%s%> within %<%T%>",
8846 ctype
, name
, current_class_type
);
8847 return error_mark_node
;
8850 /* It is not permitted to define a member function outside ist
8851 membership class as `constexpr'. */
8853 error ("a constexpr function cannot be defined "
8854 "outside of its class");
8856 if (TREE_CODE (sname
) == IDENTIFIER_NODE
8857 && NEW_DELETE_OPNAME_P (sname
))
8858 /* Overloaded operator new and operator delete
8859 are always static functions. */
8862 type
= build_memfn_type (type
, ctype
, memfn_quals
);
8864 else if (declspecs
->specs
[(int)ds_typedef
]
8865 && current_class_type
)
8867 error ("cannot declare member %<%T::%s%> within %qT",
8868 ctype
, name
, current_class_type
);
8869 return error_mark_node
;
8873 /* Now TYPE has the actual type. */
8878 *attrlist
= chainon (returned_attrs
, *attrlist
);
8880 attrlist
= &returned_attrs
;
8883 /* Handle parameter packs. */
8884 if (parameter_pack_p
)
8886 if (decl_context
== PARM
)
8887 /* Turn the type into a pack expansion.*/
8888 type
= make_pack_expansion (type
);
8890 error ("non-parameter %qs cannot be a parameter pack", name
);
8893 /* Did array size calculations overflow? */
8895 if (TREE_CODE (type
) == ARRAY_TYPE
8896 && COMPLETE_TYPE_P (type
)
8897 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
8898 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type
)))
8900 error ("size of array %qs is too large", name
);
8901 /* If we proceed with the array type as it is, we'll eventually
8902 crash in tree_low_cst(). */
8903 type
= error_mark_node
;
8906 if ((decl_context
== FIELD
|| decl_context
== PARM
)
8907 && !processing_template_decl
8908 && variably_modified_type_p (type
, NULL_TREE
))
8910 if (decl_context
== FIELD
)
8911 error ("data member may not have variably modified type %qT", type
);
8913 error ("parameter may not have variably modified type %qT", type
);
8914 type
= error_mark_node
;
8917 if (explicitp
== 1 || (explicitp
&& friendp
))
8919 /* [dcl.fct.spec] The explicit specifier shall only be used in
8920 declarations of constructors within a class definition. */
8921 error ("only declarations of constructors can be %<explicit%>");
8925 if (storage_class
== sc_mutable
)
8927 if (decl_context
!= FIELD
|| friendp
)
8929 error ("non-member %qs cannot be declared %<mutable%>", name
);
8930 storage_class
= sc_none
;
8932 else if (decl_context
== TYPENAME
|| declspecs
->specs
[(int)ds_typedef
])
8934 error ("non-object member %qs cannot be declared %<mutable%>", name
);
8935 storage_class
= sc_none
;
8937 else if (TREE_CODE (type
) == FUNCTION_TYPE
8938 || TREE_CODE (type
) == METHOD_TYPE
)
8940 error ("function %qs cannot be declared %<mutable%>", name
);
8941 storage_class
= sc_none
;
8945 error ("static %qs cannot be declared %<mutable%>", name
);
8946 storage_class
= sc_none
;
8948 else if (type_quals
& TYPE_QUAL_CONST
)
8950 error ("const %qs cannot be declared %<mutable%>", name
);
8951 storage_class
= sc_none
;
8955 /* If this is declaring a typedef name, return a TYPE_DECL. */
8956 if (declspecs
->specs
[(int)ds_typedef
] && decl_context
!= TYPENAME
)
8960 /* Note that the grammar rejects storage classes
8961 in typenames, fields or parameters. */
8962 if (current_lang_name
== lang_name_java
)
8963 TYPE_FOR_JAVA (type
) = 1;
8965 /* This declaration:
8967 typedef void f(int) const;
8969 declares a function type which is not a member of any
8970 particular class, but which is cv-qualified; for
8971 example "f S::*" declares a pointer to a const-qualified
8972 member function of S. We record the cv-qualification in the
8974 if (memfn_quals
&& TREE_CODE (type
) == FUNCTION_TYPE
)
8976 type
= cp_build_qualified_type (type
, memfn_quals
);
8978 /* We have now dealt with these qualifiers. */
8979 memfn_quals
= TYPE_UNQUALIFIED
;
8982 if (decl_context
== FIELD
)
8983 decl
= build_lang_decl (TYPE_DECL
, unqualified_id
, type
);
8985 decl
= build_decl (input_location
, TYPE_DECL
, unqualified_id
, type
);
8986 if (id_declarator
&& declarator
->u
.id
.qualifying_scope
) {
8987 error_at (DECL_SOURCE_LOCATION (decl
),
8988 "typedef name may not be a nested-name-specifier");
8989 TREE_TYPE (decl
) = error_mark_node
;
8992 if (decl_context
!= FIELD
)
8994 if (!current_function_decl
)
8995 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
8996 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl
)
8997 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
8998 (current_function_decl
)))
8999 /* The TYPE_DECL is "abstract" because there will be
9000 clones of this constructor/destructor, and there will
9001 be copies of this TYPE_DECL generated in those
9003 DECL_ABSTRACT (decl
) = 1;
9005 else if (constructor_name_p (unqualified_id
, current_class_type
))
9006 permerror (input_location
, "ISO C++ forbids nested type %qD with same name "
9007 "as enclosing class",
9010 /* If the user declares "typedef struct {...} foo" then the
9011 struct will have an anonymous name. Fill that name in now.
9012 Nothing can refer to it, so nothing needs know about the name
9014 if (type
!= error_mark_node
9017 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
9018 && TYPE_ANONYMOUS_P (type
)
9019 && cp_type_quals (type
) == TYPE_UNQUALIFIED
)
9023 /* Replace the anonymous name with the real name everywhere. */
9024 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
9026 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t
)))
9028 debug_hooks
->set_name (t
, decl
);
9029 TYPE_NAME (t
) = decl
;
9033 if (TYPE_LANG_SPECIFIC (type
))
9034 TYPE_WAS_ANONYMOUS (type
) = 1;
9036 /* If this is a typedef within a template class, the nested
9037 type is a (non-primary) template. The name for the
9038 template needs updating as well. */
9039 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
9040 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
9041 = TYPE_IDENTIFIER (type
);
9043 /* Adjust linkage now that we aren't anonymous anymore. */
9044 set_linkage_according_to_type (type
, TYPE_MAIN_DECL (type
));
9045 determine_visibility (TYPE_MAIN_DECL (type
));
9047 /* FIXME remangle member functions; member functions of a
9048 type with external linkage have external linkage. */
9052 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
9053 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
9055 bad_specifiers (decl
, "type", virtualp
,
9056 memfn_quals
!= TYPE_UNQUALIFIED
,
9057 inlinep
, friendp
, raises
!= NULL_TREE
);
9062 /* Detect the case of an array type of unspecified size
9063 which came, as such, direct from a typedef name.
9064 We must copy the type, so that the array's domain can be
9065 individually set by the object's initializer. */
9067 if (type
&& typedef_type
9068 && TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
9069 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (typedef_type
))
9070 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
9072 /* Detect where we're using a typedef of function type to declare a
9073 function. PARMS will not be set, so we must create it now. */
9075 if (type
== typedef_type
&& TREE_CODE (type
) == FUNCTION_TYPE
)
9077 tree decls
= NULL_TREE
;
9080 for (args
= TYPE_ARG_TYPES (type
);
9081 args
&& args
!= void_list_node
;
9082 args
= TREE_CHAIN (args
))
9084 tree decl
= cp_build_parm_decl (NULL_TREE
, TREE_VALUE (args
));
9086 TREE_CHAIN (decl
) = decls
;
9090 parms
= nreverse (decls
);
9092 if (decl_context
!= TYPENAME
)
9094 /* A cv-qualifier-seq shall only be part of the function type
9095 for a non-static member function. [8.3.5/4 dcl.fct] */
9096 if (cp_type_quals (type
) != TYPE_UNQUALIFIED
9097 && (current_class_type
== NULL_TREE
|| staticp
) )
9100 ? G_("qualified function types cannot be used to "
9101 "declare static member functions")
9102 : G_("qualified function types cannot be used to "
9103 "declare free functions"));
9104 type
= TYPE_MAIN_VARIANT (type
);
9107 /* The qualifiers on the function type become the qualifiers on
9108 the non-static member function. */
9109 memfn_quals
|= cp_type_quals (type
);
9110 type_quals
= TYPE_UNQUALIFIED
;
9114 /* If this is a type name (such as, in a cast or sizeof),
9115 compute the type and return it now. */
9117 if (decl_context
== TYPENAME
)
9119 /* Note that the grammar rejects storage classes
9120 in typenames, fields or parameters. */
9121 if (type_quals
!= TYPE_UNQUALIFIED
)
9122 type_quals
= TYPE_UNQUALIFIED
;
9124 /* Special case: "friend class foo" looks like a TYPENAME context. */
9127 if (type_quals
!= TYPE_UNQUALIFIED
)
9129 error ("type qualifiers specified for friend class declaration");
9130 type_quals
= TYPE_UNQUALIFIED
;
9134 error ("%<inline%> specified for friend class declaration");
9140 /* Don't allow friend declaration without a class-key. */
9141 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
9142 permerror (input_location
, "template parameters cannot be friends");
9143 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
9144 permerror (input_location
, "friend declaration requires class-key, "
9145 "i.e. %<friend class %T::%D%>",
9146 TYPE_CONTEXT (type
), TYPENAME_TYPE_FULLNAME (type
));
9148 permerror (input_location
, "friend declaration requires class-key, "
9149 "i.e. %<friend %#T%>",
9153 /* Only try to do this stuff if we didn't already give up. */
9154 if (type
!= integer_type_node
)
9156 /* A friendly class? */
9157 if (current_class_type
)
9158 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
),
9161 error ("trying to make class %qT a friend of global scope",
9164 type
= void_type_node
;
9167 else if (memfn_quals
)
9169 if (ctype
== NULL_TREE
9170 && TREE_CODE (type
) == METHOD_TYPE
)
9171 ctype
= TYPE_METHOD_BASETYPE (type
);
9174 type
= build_memfn_type (type
, ctype
, memfn_quals
);
9175 /* Core issue #547: need to allow this in template type args. */
9176 else if (template_type_arg
&& TREE_CODE (type
) == FUNCTION_TYPE
)
9177 type
= cp_build_qualified_type (type
, memfn_quals
);
9179 error ("invalid qualifiers on non-member function type");
9184 else if (unqualified_id
== NULL_TREE
&& decl_context
!= PARM
9185 && decl_context
!= CATCHPARM
9186 && TREE_CODE (type
) != UNION_TYPE
9189 error ("abstract declarator %qT used as declaration", type
);
9190 return error_mark_node
;
9193 /* Only functions may be declared using an operator-function-id. */
9195 && IDENTIFIER_OPNAME_P (unqualified_id
)
9196 && TREE_CODE (type
) != FUNCTION_TYPE
9197 && TREE_CODE (type
) != METHOD_TYPE
)
9199 error ("declaration of %qD as non-function", unqualified_id
);
9200 return error_mark_node
;
9203 /* We don't check parameter types here because we can emit a better
9204 error message later. */
9205 if (decl_context
!= PARM
)
9207 type
= check_var_type (unqualified_id
, type
);
9208 if (type
== error_mark_node
)
9209 return error_mark_node
;
9212 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
9213 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
9215 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
9217 if (ctype
|| in_namespace
)
9218 error ("cannot use %<::%> in parameter declaration");
9220 /* A parameter declared as an array of T is really a pointer to T.
9221 One declared as a function is really a pointer to a function.
9222 One declared as a member is really a pointer to member. */
9224 if (TREE_CODE (type
) == ARRAY_TYPE
)
9226 /* Transfer const-ness of array into that of type pointed to. */
9227 type
= build_pointer_type (TREE_TYPE (type
));
9228 type_quals
= TYPE_UNQUALIFIED
;
9230 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
9231 type
= build_pointer_type (type
);
9237 if (decl_context
== PARM
)
9239 decl
= cp_build_parm_decl (unqualified_id
, type
);
9241 bad_specifiers (decl
, "parameter", virtualp
,
9242 memfn_quals
!= TYPE_UNQUALIFIED
,
9243 inlinep
, friendp
, raises
!= NULL_TREE
);
9245 else if (decl_context
== FIELD
)
9247 /* The C99 flexible array extension. */
9248 if (!staticp
&& TREE_CODE (type
) == ARRAY_TYPE
9249 && TYPE_DOMAIN (type
) == NULL_TREE
)
9251 tree itype
= compute_array_index_type (dname
, integer_zero_node
);
9252 type
= build_cplus_array_type (TREE_TYPE (type
), itype
);
9255 if (type
== error_mark_node
)
9257 /* Happens when declaring arrays of sizes which
9258 are error_mark_node, for example. */
9261 else if (in_namespace
&& !friendp
)
9263 /* Something like struct S { int N::j; }; */
9264 error ("invalid use of %<::%>");
9265 return error_mark_node
;
9267 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
9270 tree function_context
;
9274 if (ctype
== NULL_TREE
)
9275 ctype
= current_class_type
;
9277 if (ctype
== NULL_TREE
)
9279 error ("can't make %qD into a method -- not in a class",
9281 return error_mark_node
;
9284 /* ``A union may [ ... ] not [ have ] virtual functions.''
9286 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
9288 error ("function %qD declared virtual inside a union",
9290 return error_mark_node
;
9293 if (NEW_DELETE_OPNAME_P (unqualified_id
))
9297 error ("%qD cannot be declared virtual, since it "
9303 else if (staticp
< 2)
9304 type
= build_memfn_type (type
, ctype
, memfn_quals
);
9307 /* Check that the name used for a destructor makes sense. */
9308 if (sfk
== sfk_destructor
)
9310 tree uqname
= id_declarator
->u
.id
.unqualified_name
;
9314 gcc_assert (friendp
);
9315 error ("expected qualified name in friend declaration "
9316 "for destructor %qD", uqname
);
9317 return error_mark_node
;
9320 if (!check_dtor_name (ctype
, TREE_OPERAND (uqname
, 0)))
9322 error ("declaration of %qD as member of %qT",
9324 return error_mark_node
;
9327 error ("a destructor cannot be %<constexpr%>");
9329 else if (sfk
== sfk_constructor
&& friendp
)
9331 error ("expected qualified name in friend declaration "
9332 "for constructor %qD",
9333 id_declarator
->u
.id
.unqualified_name
);
9334 return error_mark_node
;
9337 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
9338 function_context
= (ctype
!= NULL_TREE
) ?
9339 decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
9340 publicp
= (! friendp
|| ! staticp
)
9341 && function_context
== NULL_TREE
;
9342 decl
= grokfndecl (ctype
, type
,
9343 TREE_CODE (unqualified_id
) != TEMPLATE_ID_EXPR
9344 ? unqualified_id
: dname
,
9347 virtualp
, flags
, memfn_quals
, raises
,
9348 friendp
? -1 : 0, friendp
, publicp
,
9349 inlinep
|| constexpr_p
,
9351 funcdef_flag
, template_count
, in_namespace
,
9352 attrlist
, declarator
->id_loc
);
9353 if (decl
== NULL_TREE
)
9354 return error_mark_node
;
9356 /* This clobbers the attrs stored in `decl' from `attrlist'. */
9357 /* The decl and setting of decl_attr is also turned off. */
9358 decl
= build_decl_attribute_variant (decl
, decl_attr
);
9361 /* [class.conv.ctor]
9363 A constructor declared without the function-specifier
9364 explicit that can be called with a single parameter
9365 specifies a conversion from the type of its first
9366 parameter to the type of its class. Such a constructor
9367 is called a converting constructor. */
9369 DECL_NONCONVERTING_P (decl
) = 1;
9371 else if (TREE_CODE (type
) == METHOD_TYPE
)
9373 /* We only get here for friend declarations of
9374 members of other classes. */
9375 /* All method decls are public, so tell grokfndecl to set
9376 TREE_PUBLIC, also. */
9377 decl
= grokfndecl (ctype
, type
,
9378 TREE_CODE (unqualified_id
) != TEMPLATE_ID_EXPR
9379 ? unqualified_id
: dname
,
9382 virtualp
, flags
, memfn_quals
, raises
,
9383 friendp
? -1 : 0, friendp
, 1, 0, sfk
,
9384 funcdef_flag
, template_count
, in_namespace
,
9386 declarator
->id_loc
);
9387 if (decl
== NULL_TREE
)
9388 return error_mark_node
;
9390 else if (!staticp
&& !dependent_type_p (type
)
9391 && !COMPLETE_TYPE_P (complete_type (type
))
9392 && (TREE_CODE (type
) != ARRAY_TYPE
|| initialized
== 0))
9395 error ("field %qD has incomplete type", unqualified_id
);
9397 error ("name %qT has incomplete type", type
);
9399 /* If we're instantiating a template, tell them which
9400 instantiation made the field's type be incomplete. */
9401 if (current_class_type
9402 && TYPE_NAME (current_class_type
)
9403 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type
))
9405 && declspecs
->type
== type
)
9406 error (" in instantiation of template %qT",
9407 current_class_type
);
9409 return error_mark_node
;
9415 error ("%qE is neither function nor member function; "
9416 "cannot be declared friend", unqualified_id
);
9424 /* Friends are treated specially. */
9425 if (ctype
== current_class_type
)
9426 ; /* We already issued a permerror. */
9427 else if (decl
&& DECL_NAME (decl
))
9429 if (template_class_depth (current_class_type
) == 0)
9431 decl
= check_explicit_specialization
9432 (unqualified_id
, decl
, template_count
,
9433 2 * funcdef_flag
+ 4);
9434 if (decl
== error_mark_node
)
9435 return error_mark_node
;
9438 DECL_DECLARED_CONSTEXPR_P (decl
) = constexpr_p
;
9439 decl
= do_friend (ctype
, unqualified_id
, decl
,
9445 return error_mark_node
;
9448 /* Structure field. It may not be a function, except for C++. */
9450 if (decl
== NULL_TREE
)
9456 /* An attempt is being made to initialize a non-static
9457 member. But, from [class.mem]:
9459 4 A member-declarator can contain a
9460 constant-initializer only if it declares a static
9461 member (_class.static_) of integral or enumeration
9462 type, see _class.static.data_.
9464 This used to be relatively common practice, but
9465 the rest of the compiler does not correctly
9466 handle the initialization unless the member is
9467 static so we make it static below. */
9468 permerror (input_location
, "ISO C++ forbids initialization of member %qD",
9470 permerror (input_location
, "making %qD static", unqualified_id
);
9474 if (uses_template_parms (type
))
9475 /* We'll check at instantiation time. */
9477 else if (check_static_variable_definition (unqualified_id
,
9479 /* If we just return the declaration, crashes
9480 will sometimes occur. We therefore return
9481 void_type_node, as if this was a friend
9482 declaration, to cause callers to completely
9483 ignore this declaration. */
9484 return error_mark_node
;
9489 /* C++ allows static class members. All other work
9490 for this is done by grokfield. */
9491 decl
= build_lang_decl (VAR_DECL
, unqualified_id
, type
);
9492 set_linkage_for_static_data_member (decl
);
9493 /* Even if there is an in-class initialization, DECL
9494 is considered undefined until an out-of-class
9495 definition is provided. */
9496 DECL_EXTERNAL (decl
) = 1;
9499 DECL_TLS_MODEL (decl
) = decl_default_tls_model (decl
);
9504 error ("non-static data member %qE declared %<constexpr%>",
9506 decl
= build_decl (input_location
,
9507 FIELD_DECL
, unqualified_id
, type
);
9508 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
9509 if (bitfield
&& !unqualified_id
)
9510 TREE_NO_WARNING (decl
) = 1;
9512 if (storage_class
== sc_mutable
)
9514 DECL_MUTABLE_P (decl
) = 1;
9515 storage_class
= sc_none
;
9519 bad_specifiers (decl
, "field", virtualp
,
9520 memfn_quals
!= TYPE_UNQUALIFIED
,
9521 inlinep
, friendp
, raises
!= NULL_TREE
);
9524 else if (TREE_CODE (type
) == FUNCTION_TYPE
9525 || TREE_CODE (type
) == METHOD_TYPE
)
9530 if (!unqualified_id
)
9531 return error_mark_node
;
9533 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
9534 original_name
= dname
;
9536 original_name
= unqualified_id
;
9538 if (storage_class
== sc_auto
)
9539 error ("storage class %<auto%> invalid for function %qs", name
);
9540 else if (storage_class
== sc_register
)
9541 error ("storage class %<register%> invalid for function %qs", name
);
9543 error ("storage class %<__thread%> invalid for function %qs", name
);
9545 /* Function declaration not at top level.
9546 Storage classes other than `extern' are not allowed
9547 and `extern' makes no difference. */
9548 if (! toplevel_bindings_p ()
9549 && (storage_class
== sc_static
9550 || declspecs
->specs
[(int)ds_inline
])
9553 if (storage_class
== sc_static
)
9554 pedwarn (input_location
, OPT_pedantic
,
9555 "%<static%> specified invalid for function %qs "
9556 "declared out of global scope", name
);
9558 pedwarn (input_location
, OPT_pedantic
,
9559 "%<inline%> specifier invalid for function %qs "
9560 "declared out of global scope", name
);
9563 if (ctype
!= NULL_TREE
9564 && TREE_CODE (ctype
) != NAMESPACE_DECL
&& !MAYBE_CLASS_TYPE_P (ctype
))
9566 error ("%q#T is not a class or a namespace", ctype
);
9570 if (ctype
== NULL_TREE
)
9574 error ("virtual non-class function %qs", name
);
9577 else if (sfk
== sfk_constructor
9578 || sfk
== sfk_destructor
)
9581 ? "%qs defined in a non-class scope"
9582 : "%qs declared in a non-class scope", name
);
9586 else if (TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2
9587 && !NEW_DELETE_OPNAME_P (original_name
))
9588 type
= build_method_type_directly (ctype
,
9590 TYPE_ARG_TYPES (type
));
9592 /* Record presence of `static'. */
9593 publicp
= (ctype
!= NULL_TREE
9594 || storage_class
== sc_extern
9595 || storage_class
!= sc_static
);
9597 decl
= grokfndecl (ctype
, type
, original_name
, parms
, unqualified_id
,
9598 virtualp
, flags
, memfn_quals
, raises
,
9600 publicp
, inlinep
|| constexpr_p
, sfk
, funcdef_flag
,
9601 template_count
, in_namespace
, attrlist
,
9602 declarator
->id_loc
);
9603 if (decl
== NULL_TREE
)
9604 return error_mark_node
;
9608 int invalid_static
= 0;
9610 /* Don't allow a static member function in a class, and forbid
9611 declaring main to be static. */
9612 if (TREE_CODE (type
) == METHOD_TYPE
)
9614 permerror (input_location
, "cannot declare member function %qD to have "
9615 "static linkage", decl
);
9618 else if (current_function_decl
)
9620 /* FIXME need arm citation */
9621 error ("cannot declare static function inside another function");
9628 storage_class
= sc_none
;
9634 /* It's a variable. */
9636 /* An uninitialized decl with `extern' is a reference. */
9637 decl
= grokvardecl (type
, unqualified_id
,
9640 (type_quals
& TYPE_QUAL_CONST
) != 0,
9641 ctype
? ctype
: in_namespace
);
9642 bad_specifiers (decl
, "variable", virtualp
,
9643 memfn_quals
!= TYPE_UNQUALIFIED
,
9644 inlinep
, friendp
, raises
!= NULL_TREE
);
9648 DECL_CONTEXT (decl
) = ctype
;
9651 permerror (input_location
, "%<static%> may not be used when defining "
9652 "(as opposed to declaring) a static data member");
9654 storage_class
= sc_none
;
9656 if (storage_class
== sc_register
&& TREE_STATIC (decl
))
9658 error ("static member %qD declared %<register%>", decl
);
9659 storage_class
= sc_none
;
9661 if (storage_class
== sc_extern
&& pedantic
)
9663 pedwarn (input_location
, OPT_pedantic
,
9664 "cannot explicitly declare member %q#D to have "
9665 "extern linkage", decl
);
9666 storage_class
= sc_none
;
9671 if (storage_class
== sc_extern
&& initialized
&& !funcdef_flag
)
9673 if (toplevel_bindings_p ())
9675 /* It's common practice (and completely valid) to have a const
9676 be initialized and declared extern. */
9677 if (!(type_quals
& TYPE_QUAL_CONST
))
9678 warning (0, "%qs initialized and declared %<extern%>", name
);
9682 error ("%qs has both %<extern%> and initializer", name
);
9683 return error_mark_node
;
9687 /* Record `register' declaration for warnings on &
9688 and in case doing stupid register allocation. */
9690 if (storage_class
== sc_register
)
9691 DECL_REGISTER (decl
) = 1;
9692 else if (storage_class
== sc_extern
)
9693 DECL_THIS_EXTERN (decl
) = 1;
9694 else if (storage_class
== sc_static
)
9695 DECL_THIS_STATIC (decl
) = 1;
9697 /* Don't forget constexprness. */
9698 if (VAR_OR_FUNCTION_DECL_P (decl
))
9699 DECL_DECLARED_CONSTEXPR_P (decl
) = constexpr_p
;
9701 /* Record constancy and volatility on the DECL itself . There's
9702 no need to do this when processing a template; we'll do this
9703 for the instantiated declaration based on the type of DECL. */
9704 if (!processing_template_decl
)
9705 cp_apply_type_quals_to_decl (type_quals
, decl
);
9711 /* Subroutine of start_function. Ensure that each of the parameter
9712 types (as listed in PARMS) is complete, as is required for a
9713 function definition. */
9716 require_complete_types_for_parms (tree parms
)
9718 for (; parms
; parms
= TREE_CHAIN (parms
))
9720 if (dependent_type_p (TREE_TYPE (parms
)))
9722 if (!VOID_TYPE_P (TREE_TYPE (parms
))
9723 && complete_type_or_else (TREE_TYPE (parms
), parms
))
9725 relayout_decl (parms
);
9726 DECL_ARG_TYPE (parms
) = type_passed_as (TREE_TYPE (parms
));
9729 /* grokparms or complete_type_or_else will have already issued
9731 TREE_TYPE (parms
) = error_mark_node
;
9735 /* Returns nonzero if T is a local variable. */
9738 local_variable_p (const_tree t
)
9740 if ((TREE_CODE (t
) == VAR_DECL
9741 /* A VAR_DECL with a context that is a _TYPE is a static data
9743 && !TYPE_P (CP_DECL_CONTEXT (t
))
9744 /* Any other non-local variable must be at namespace scope. */
9745 && !DECL_NAMESPACE_SCOPE_P (t
))
9746 || (TREE_CODE (t
) == PARM_DECL
))
9752 /* Like local_variable_p, but suitable for use as a tree-walking
9756 local_variable_p_walkfn (tree
*tp
, int *walk_subtrees
,
9757 void *data ATTRIBUTE_UNUSED
)
9759 if (local_variable_p (*tp
) && !DECL_ARTIFICIAL (*tp
))
9761 else if (TYPE_P (*tp
))
9768 /* Check that ARG, which is a default-argument expression for a
9769 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
9770 something goes wrong. DECL may also be a _TYPE node, rather than a
9771 DECL, if there is no DECL available. */
9774 check_default_argument (tree decl
, tree arg
)
9779 if (TREE_CODE (arg
) == DEFAULT_ARG
)
9780 /* We get a DEFAULT_ARG when looking at an in-class declaration
9781 with a default argument. Ignore the argument for now; we'll
9782 deal with it after the class is complete. */
9791 decl_type
= TREE_TYPE (decl
);
9793 if (arg
== error_mark_node
9794 || decl
== error_mark_node
9795 || TREE_TYPE (arg
) == error_mark_node
9796 || decl_type
== error_mark_node
)
9797 /* Something already went wrong. There's no need to check
9799 return error_mark_node
;
9801 /* [dcl.fct.default]
9803 A default argument expression is implicitly converted to the
9805 if (!TREE_TYPE (arg
)
9806 || !can_convert_arg (decl_type
, TREE_TYPE (arg
), arg
, LOOKUP_NORMAL
))
9809 error ("default argument for %q#D has type %qT",
9810 decl
, TREE_TYPE (arg
));
9812 error ("default argument for parameter of type %qT has type %qT",
9813 decl_type
, TREE_TYPE (arg
));
9815 return error_mark_node
;
9818 /* [dcl.fct.default]
9820 Local variables shall not be used in default argument
9823 The keyword `this' shall not be used in a default argument of a
9825 var
= cp_walk_tree_without_duplicates (&arg
, local_variable_p_walkfn
, NULL
);
9828 error ("default argument %qE uses local variable %qD", arg
, var
);
9829 return error_mark_node
;
9836 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
9839 type_is_deprecated (tree type
)
9841 enum tree_code code
;
9842 if (TREE_DEPRECATED (type
))
9844 if (TYPE_NAME (type
)
9845 && TREE_DEPRECATED (TYPE_NAME (type
)))
9848 /* Do warn about using typedefs to a deprecated class. */
9849 if (TAGGED_TYPE_P (type
) && type
!= TYPE_MAIN_VARIANT (type
))
9850 return type_is_deprecated (TYPE_MAIN_VARIANT (type
));
9852 code
= TREE_CODE (type
);
9854 if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
9855 || code
== OFFSET_TYPE
|| code
== FUNCTION_TYPE
9856 || code
== METHOD_TYPE
|| code
== ARRAY_TYPE
)
9857 return type_is_deprecated (TREE_TYPE (type
));
9859 if (TYPE_PTRMEMFUNC_P (type
))
9860 return type_is_deprecated
9861 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type
))));
9866 /* Decode the list of parameter types for a function type.
9867 Given the list of things declared inside the parens,
9868 return a list of types.
9870 If this parameter does not end with an ellipsis, we append
9873 *PARMS is set to the chain of PARM_DECLs created. */
9876 grokparms (tree parmlist
, tree
*parms
)
9878 tree result
= NULL_TREE
;
9879 tree decls
= NULL_TREE
;
9883 for (parm
= parmlist
; parm
!= NULL_TREE
; parm
= TREE_CHAIN (parm
))
9885 tree type
= NULL_TREE
;
9886 tree init
= TREE_PURPOSE (parm
);
9887 tree decl
= TREE_VALUE (parm
);
9890 if (parm
== void_list_node
)
9893 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
9896 type
= TREE_TYPE (decl
);
9897 if (VOID_TYPE_P (type
))
9899 if (same_type_p (type
, void_type_node
)
9900 && DECL_SELF_REFERENCE_P (type
)
9901 && !DECL_NAME (decl
) && !result
&& TREE_CHAIN (parm
) == void_list_node
)
9902 /* this is a parmlist of `(void)', which is ok. */
9904 cxx_incomplete_type_error (decl
, type
);
9905 /* It's not a good idea to actually create parameters of
9906 type `void'; other parts of the compiler assume that a
9907 void type terminates the parameter list. */
9908 type
= error_mark_node
;
9909 TREE_TYPE (decl
) = error_mark_node
;
9912 if (type
!= error_mark_node
9913 && TYPE_FOR_JAVA (type
)
9914 && MAYBE_CLASS_TYPE_P (type
))
9916 error ("parameter %qD has Java class type", decl
);
9917 type
= error_mark_node
;
9918 TREE_TYPE (decl
) = error_mark_node
;
9922 if (type
!= error_mark_node
9923 && (errmsg
= targetm
.invalid_parameter_type (type
)))
9926 type
= error_mark_node
;
9927 TREE_TYPE (decl
) = error_mark_node
;
9930 if (type
!= error_mark_node
)
9932 if (deprecated_state
!= DEPRECATED_SUPPRESS
)
9934 tree deptype
= type_is_deprecated (type
);
9936 warn_deprecated_use (deptype
, NULL_TREE
);
9939 /* Top-level qualifiers on the parameters are
9940 ignored for function types. */
9941 type
= cp_build_qualified_type (type
, 0);
9942 if (TREE_CODE (type
) == METHOD_TYPE
)
9944 error ("parameter %qD invalidly declared method type", decl
);
9945 type
= build_pointer_type (type
);
9946 TREE_TYPE (decl
) = type
;
9948 else if (abstract_virtuals_error (decl
, type
))
9949 any_error
= 1; /* Seems like a good idea. */
9950 else if (POINTER_TYPE_P (type
))
9952 /* [dcl.fct]/6, parameter types cannot contain pointers
9953 (references) to arrays of unknown bound. */
9954 tree t
= TREE_TYPE (type
);
9955 int ptr
= TYPE_PTR_P (type
);
9961 else if (TREE_CODE (t
) != ARRAY_TYPE
)
9963 else if (!TYPE_DOMAIN (t
))
9967 if (TREE_CODE (t
) == ARRAY_TYPE
)
9969 ? G_("parameter %qD includes pointer to array of "
9970 "unknown bound %qT")
9971 : G_("parameter %qD includes reference to array of "
9972 "unknown bound %qT"),
9978 else if (init
&& !processing_template_decl
)
9979 init
= check_default_argument (decl
, init
);
9982 if (TREE_CODE (decl
) == PARM_DECL
9983 && FUNCTION_PARAMETER_PACK_P (decl
)
9984 && TREE_CHAIN (parm
)
9985 && TREE_CHAIN (parm
) != void_list_node
)
9986 error ("parameter packs must be at the end of the parameter list");
9988 TREE_CHAIN (decl
) = decls
;
9990 result
= tree_cons (init
, type
, result
);
9992 decls
= nreverse (decls
);
9993 result
= nreverse (result
);
9995 result
= chainon (result
, void_list_node
);
10002 /* D is a constructor or overloaded `operator='.
10004 Let T be the class in which D is declared. Then, this function
10007 -1 if D's is an ill-formed constructor or copy assignment operator
10008 whose first parameter is of type `T'.
10009 0 if D is not a copy constructor or copy assignment
10011 1 if D is a copy constructor or copy assignment operator whose
10012 first parameter is a reference to non-const qualified T.
10013 2 if D is a copy constructor or copy assignment operator whose
10014 first parameter is a reference to const qualified T.
10016 This function can be used as a predicate. Positive values indicate
10017 a copy constructor and nonzero values indicate a copy assignment
10021 copy_fn_p (const_tree d
)
10027 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
10029 if (TREE_CODE (d
) == TEMPLATE_DECL
10030 || (DECL_TEMPLATE_INFO (d
)
10031 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
10032 /* Instantiations of template member functions are never copy
10033 functions. Note that member functions of templated classes are
10034 represented as template functions internally, and we must
10035 accept those as copy functions. */
10038 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
10042 arg_type
= TREE_VALUE (args
);
10043 if (arg_type
== error_mark_node
)
10046 if (TYPE_MAIN_VARIANT (arg_type
) == DECL_CONTEXT (d
))
10048 /* Pass by value copy assignment operator. */
10051 else if (TREE_CODE (arg_type
) == REFERENCE_TYPE
10052 && !TYPE_REF_IS_RVALUE (arg_type
)
10053 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)) == DECL_CONTEXT (d
))
10055 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type
)))
10061 args
= TREE_CHAIN (args
);
10063 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
10064 /* There are more non-optional args. */
10070 /* D is a constructor or overloaded `operator='.
10072 Let T be the class in which D is declared. Then, this function
10073 returns true when D is a move constructor or move assignment
10074 operator, false otherwise. */
10077 move_fn_p (const_tree d
)
10081 bool result
= false;
10083 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
10085 if (cxx_dialect
== cxx98
)
10086 /* There are no move constructors if we are in C++98 mode. */
10089 if (TREE_CODE (d
) == TEMPLATE_DECL
10090 || (DECL_TEMPLATE_INFO (d
)
10091 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
10092 /* Instantiations of template member functions are never copy
10093 functions. Note that member functions of templated classes are
10094 represented as template functions internally, and we must
10095 accept those as copy functions. */
10098 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
10102 arg_type
= TREE_VALUE (args
);
10103 if (arg_type
== error_mark_node
)
10106 if (TREE_CODE (arg_type
) == REFERENCE_TYPE
10107 && TYPE_REF_IS_RVALUE (arg_type
)
10108 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)),
10112 args
= TREE_CHAIN (args
);
10114 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
10115 /* There are more non-optional args. */
10121 /* Remember any special properties of member function DECL. */
10124 grok_special_member_properties (tree decl
)
10128 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
10131 class_type
= DECL_CONTEXT (decl
);
10132 if (DECL_CONSTRUCTOR_P (decl
))
10134 int ctor
= copy_fn_p (decl
);
10136 if (!DECL_ARTIFICIAL (decl
))
10137 TYPE_HAS_USER_CONSTRUCTOR (class_type
) = 1;
10143 A non-template constructor for class X is a copy
10144 constructor if its first parameter is of type X&, const
10145 X&, volatile X& or const volatile X&, and either there
10146 are no other parameters or else all other parameters have
10147 default arguments. */
10148 TYPE_HAS_INIT_REF (class_type
) = 1;
10149 if (user_provided_p (decl
))
10150 TYPE_HAS_COMPLEX_INIT_REF (class_type
) = 1;
10152 TYPE_HAS_CONST_INIT_REF (class_type
) = 1;
10154 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl
)))
10156 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type
) = 1;
10157 if (user_provided_p (decl
))
10158 TYPE_HAS_COMPLEX_DFLT (class_type
) = 1;
10160 else if (is_list_ctor (decl
))
10161 TYPE_HAS_LIST_CTOR (class_type
) = 1;
10163 else if (DECL_OVERLOADED_OPERATOR_P (decl
) == NOP_EXPR
)
10167 A non-template assignment operator for class X is a copy
10168 assignment operator if its parameter is of type X, X&, const
10169 X&, volatile X& or const volatile X&. */
10171 int assop
= copy_fn_p (decl
);
10175 TYPE_HAS_ASSIGN_REF (class_type
) = 1;
10176 if (user_provided_p (decl
))
10177 TYPE_HAS_COMPLEX_ASSIGN_REF (class_type
) = 1;
10179 TYPE_HAS_CONST_ASSIGN_REF (class_type
) = 1;
10184 /* Check a constructor DECL has the correct form. Complains
10185 if the class has a constructor of the form X(X). */
10188 grok_ctor_properties (const_tree ctype
, const_tree decl
)
10190 int ctor_parm
= copy_fn_p (decl
);
10196 A declaration of a constructor for a class X is ill-formed if
10197 its first parameter is of type (optionally cv-qualified) X
10198 and either there are no other parameters or else all other
10199 parameters have default arguments.
10201 We *don't* complain about member template instantiations that
10202 have this form, though; they can occur as we try to decide
10203 what constructor to use during overload resolution. Since
10204 overload resolution will never prefer such a constructor to
10205 the non-template copy constructor (which is either explicitly
10206 or implicitly defined), there's no need to worry about their
10207 existence. Theoretically, they should never even be
10208 instantiated, but that's hard to forestall. */
10209 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
10217 /* An operator with this code is unary, but can also be binary. */
10220 ambi_op_p (enum tree_code code
)
10222 return (code
== INDIRECT_REF
10223 || code
== ADDR_EXPR
10224 || code
== UNARY_PLUS_EXPR
10225 || code
== NEGATE_EXPR
10226 || code
== PREINCREMENT_EXPR
10227 || code
== PREDECREMENT_EXPR
);
10230 /* An operator with this name can only be unary. */
10233 unary_op_p (enum tree_code code
)
10235 return (code
== TRUTH_NOT_EXPR
10236 || code
== BIT_NOT_EXPR
10237 || code
== COMPONENT_REF
10238 || code
== TYPE_EXPR
);
10241 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
10242 errors are issued for invalid declarations. */
10245 grok_op_properties (tree decl
, bool complain
)
10247 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
10249 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
10250 tree name
= DECL_NAME (decl
);
10251 enum tree_code operator_code
;
10256 /* Count the number of arguments and check for ellipsis. */
10257 for (argtype
= argtypes
, arity
= 0;
10258 argtype
&& argtype
!= void_list_node
;
10259 argtype
= TREE_CHAIN (argtype
))
10261 ellipsis_p
= !argtype
;
10263 class_type
= DECL_CONTEXT (decl
);
10264 if (class_type
&& !CLASS_TYPE_P (class_type
))
10265 class_type
= NULL_TREE
;
10267 if (DECL_CONV_FN_P (decl
))
10268 operator_code
= TYPE_EXPR
;
10272 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
10273 if (ansi_opname (CODE) == name) \
10275 operator_code = (CODE); \
10278 else if (ansi_assopname (CODE) == name) \
10280 operator_code = (CODE); \
10281 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
10285 #include "operators.def"
10286 #undef DEF_OPERATOR
10288 gcc_unreachable ();
10291 gcc_assert (operator_code
!= MAX_TREE_CODES
);
10292 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
10295 switch (operator_code
)
10298 TYPE_HAS_NEW_OPERATOR (class_type
) = 1;
10302 TYPE_GETS_DELETE (class_type
) |= 1;
10306 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type
) = 1;
10309 case VEC_DELETE_EXPR
:
10310 TYPE_GETS_DELETE (class_type
) |= 2;
10317 /* [basic.std.dynamic.allocation]/1:
10319 A program is ill-formed if an allocation function is declared
10320 in a namespace scope other than global scope or declared static
10323 The same also holds true for deallocation functions. */
10324 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
10325 || operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
10327 if (DECL_NAMESPACE_SCOPE_P (decl
))
10329 if (CP_DECL_CONTEXT (decl
) != global_namespace
)
10331 error ("%qD may not be declared within a namespace", decl
);
10334 else if (!TREE_PUBLIC (decl
))
10336 error ("%qD may not be declared as static", decl
);
10342 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
)
10344 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
10345 DECL_IS_OPERATOR_NEW (decl
) = 1;
10347 else if (operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
10348 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
10351 /* An operator function must either be a non-static member function
10352 or have at least one parameter of a class, a reference to a class,
10353 an enumeration, or a reference to an enumeration. 13.4.0.6 */
10354 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
10356 if (operator_code
== TYPE_EXPR
10357 || operator_code
== CALL_EXPR
10358 || operator_code
== COMPONENT_REF
10359 || operator_code
== ARRAY_REF
10360 || operator_code
== NOP_EXPR
)
10362 error ("%qD must be a nonstatic member function", decl
);
10369 if (DECL_STATIC_FUNCTION_P (decl
))
10371 error ("%qD must be either a non-static member "
10372 "function or a non-member function", decl
);
10376 for (p
= argtypes
; p
&& p
!= void_list_node
; p
= TREE_CHAIN (p
))
10378 tree arg
= non_reference (TREE_VALUE (p
));
10379 if (arg
== error_mark_node
)
10382 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
10383 because these checks are performed even on
10384 template functions. */
10385 if (MAYBE_CLASS_TYPE_P (arg
)
10386 || TREE_CODE (arg
) == ENUMERAL_TYPE
)
10390 if (!p
|| p
== void_list_node
)
10393 error ("%qD must have an argument of class or "
10394 "enumerated type", decl
);
10400 /* There are no restrictions on the arguments to an overloaded
10402 if (operator_code
== CALL_EXPR
)
10405 /* Warn about conversion operators that will never be used. */
10406 if (IDENTIFIER_TYPENAME_P (name
)
10407 && ! DECL_TEMPLATE_INFO (decl
)
10409 /* Warn only declaring the function; there is no need to
10410 warn again about out-of-class definitions. */
10411 && class_type
== current_class_type
)
10413 tree t
= TREE_TYPE (name
);
10414 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
10417 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
10419 if (TREE_CODE (t
) == VOID_TYPE
)
10420 warning (OPT_Wconversion
,
10422 ? G_("conversion to a reference to void "
10423 "will never use a type conversion operator")
10424 : G_("conversion to void "
10425 "will never use a type conversion operator"));
10426 else if (class_type
)
10428 if (t
== class_type
)
10429 warning (OPT_Wconversion
,
10431 ? G_("conversion to a reference to the same type "
10432 "will never use a type conversion operator")
10433 : G_("conversion to the same type "
10434 "will never use a type conversion operator"));
10435 /* Don't force t to be complete here. */
10436 else if (MAYBE_CLASS_TYPE_P (t
)
10437 && COMPLETE_TYPE_P (t
)
10438 && DERIVED_FROM_P (t
, class_type
))
10439 warning (OPT_Wconversion
,
10441 ? G_("conversion to a reference to a base class "
10442 "will never use a type conversion operator")
10443 : G_("conversion to a base class "
10444 "will never use a type conversion operator"));
10449 if (operator_code
== COND_EXPR
)
10452 error ("ISO C++ prohibits overloading operator ?:");
10455 else if (ellipsis_p
)
10457 error ("%qD must not have variable number of arguments", decl
);
10460 else if (ambi_op_p (operator_code
))
10463 /* We pick the one-argument operator codes by default, so
10464 we don't have to change anything. */
10466 else if (arity
== 2)
10468 /* If we thought this was a unary operator, we now know
10469 it to be a binary operator. */
10470 switch (operator_code
)
10473 operator_code
= MULT_EXPR
;
10477 operator_code
= BIT_AND_EXPR
;
10480 case UNARY_PLUS_EXPR
:
10481 operator_code
= PLUS_EXPR
;
10485 operator_code
= MINUS_EXPR
;
10488 case PREINCREMENT_EXPR
:
10489 operator_code
= POSTINCREMENT_EXPR
;
10492 case PREDECREMENT_EXPR
:
10493 operator_code
= POSTDECREMENT_EXPR
;
10497 gcc_unreachable ();
10500 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
10502 if ((operator_code
== POSTINCREMENT_EXPR
10503 || operator_code
== POSTDECREMENT_EXPR
)
10504 && ! processing_template_decl
10505 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)), integer_type_node
))
10508 error ("postfix %qD must take %<int%> as its argument",
10511 error ("postfix %qD must take %<int%> as its second "
10519 error ("%qD must take either zero or one argument", decl
);
10521 error ("%qD must take either one or two arguments", decl
);
10525 /* More Effective C++ rule 6. */
10527 && (operator_code
== POSTINCREMENT_EXPR
10528 || operator_code
== POSTDECREMENT_EXPR
10529 || operator_code
== PREINCREMENT_EXPR
10530 || operator_code
== PREDECREMENT_EXPR
))
10532 tree arg
= TREE_VALUE (argtypes
);
10533 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
10534 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
10535 arg
= TREE_TYPE (arg
);
10536 arg
= TYPE_MAIN_VARIANT (arg
);
10537 if (operator_code
== PREINCREMENT_EXPR
10538 || operator_code
== PREDECREMENT_EXPR
)
10540 if (TREE_CODE (ret
) != REFERENCE_TYPE
10541 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
10543 warning (OPT_Weffc__
, "prefix %qD should return %qT", decl
,
10544 build_reference_type (arg
));
10548 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
10549 warning (OPT_Weffc__
, "postfix %qD should return %qT", decl
, arg
);
10553 else if (unary_op_p (operator_code
))
10558 error ("%qD must take %<void%>", decl
);
10560 error ("%qD must take exactly one argument", decl
);
10564 else /* if (binary_op_p (operator_code)) */
10569 error ("%qD must take exactly one argument", decl
);
10571 error ("%qD must take exactly two arguments", decl
);
10575 /* More Effective C++ rule 7. */
10577 && (operator_code
== TRUTH_ANDIF_EXPR
10578 || operator_code
== TRUTH_ORIF_EXPR
10579 || operator_code
== COMPOUND_EXPR
))
10580 warning (OPT_Weffc__
, "user-defined %qD always evaluates both arguments",
10584 /* Effective C++ rule 23. */
10587 && !DECL_ASSIGNMENT_OPERATOR_P (decl
)
10588 && (operator_code
== PLUS_EXPR
10589 || operator_code
== MINUS_EXPR
10590 || operator_code
== TRUNC_DIV_EXPR
10591 || operator_code
== MULT_EXPR
10592 || operator_code
== TRUNC_MOD_EXPR
)
10593 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
10594 warning (OPT_Weffc__
, "%qD should return by value", decl
);
10596 /* [over.oper]/8 */
10597 for (; argtypes
&& argtypes
!= void_list_node
;
10598 argtypes
= TREE_CHAIN (argtypes
))
10599 if (TREE_PURPOSE (argtypes
))
10601 TREE_PURPOSE (argtypes
) = NULL_TREE
;
10602 if (operator_code
== POSTINCREMENT_EXPR
10603 || operator_code
== POSTDECREMENT_EXPR
)
10605 pedwarn (input_location
, OPT_pedantic
, "%qD cannot have default arguments",
10610 error ("%qD cannot have default arguments", decl
);
10618 /* Return a string giving the keyword associate with CODE. */
10620 static const char *
10621 tag_name (enum tag_types code
)
10633 case typename_type
:
10636 gcc_unreachable ();
10640 /* Name lookup in an elaborated-type-specifier (after the keyword
10641 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
10642 elaborated-type-specifier is invalid, issue a diagnostic and return
10643 error_mark_node; otherwise, return the *_TYPE to which it referred.
10644 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
10647 check_elaborated_type_specifier (enum tag_types tag_code
,
10649 bool allow_template_p
)
10655 struct S { struct S *p; };
10657 name lookup will find the TYPE_DECL for the implicit "S::S"
10658 typedef. Adjust for that here. */
10659 if (DECL_SELF_REFERENCE_P (decl
))
10660 decl
= TYPE_NAME (TREE_TYPE (decl
));
10662 type
= TREE_TYPE (decl
);
10664 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
10665 is false for this case as well. */
10666 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
10668 error ("using template type parameter %qT after %qs",
10669 type
, tag_name (tag_code
));
10670 return error_mark_node
;
10674 If the identifier resolves to a typedef-name or a template
10675 type-parameter, the elaborated-type-specifier is ill-formed.
10677 In other words, the only legitimate declaration to use in the
10678 elaborated type specifier is the implicit typedef created when
10679 the type is declared. */
10680 else if (!DECL_IMPLICIT_TYPEDEF_P (decl
)
10681 && !DECL_SELF_REFERENCE_P (decl
)
10682 && tag_code
!= typename_type
)
10684 error ("using typedef-name %qD after %qs", decl
, tag_name (tag_code
));
10685 error ("%q+D has a previous declaration here", decl
);
10686 return error_mark_node
;
10688 else if (TREE_CODE (type
) != RECORD_TYPE
10689 && TREE_CODE (type
) != UNION_TYPE
10690 && tag_code
!= enum_type
10691 && tag_code
!= typename_type
)
10693 error ("%qT referred to as %qs", type
, tag_name (tag_code
));
10694 error ("%q+T has a previous declaration here", type
);
10695 return error_mark_node
;
10697 else if (TREE_CODE (type
) != ENUMERAL_TYPE
10698 && tag_code
== enum_type
)
10700 error ("%qT referred to as enum", type
);
10701 error ("%q+T has a previous declaration here", type
);
10702 return error_mark_node
;
10704 else if (!allow_template_p
10705 && TREE_CODE (type
) == RECORD_TYPE
10706 && CLASSTYPE_IS_TEMPLATE (type
))
10708 /* If a class template appears as elaborated type specifier
10709 without a template header such as:
10711 template <class T> class C {};
10712 void f(class C); // No template header here
10714 then the required template argument is missing. */
10715 error ("template argument required for %<%s %T%>",
10716 tag_name (tag_code
),
10717 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
)));
10718 return error_mark_node
;
10724 /* Lookup NAME in elaborate type specifier in scope according to
10725 SCOPE and issue diagnostics if necessary.
10726 Return *_TYPE node upon success, NULL_TREE when the NAME is not
10727 found, and ERROR_MARK_NODE for type error. */
10730 lookup_and_check_tag (enum tag_types tag_code
, tree name
,
10731 tag_scope scope
, bool template_header_p
)
10735 if (scope
== ts_global
)
10737 /* First try ordinary name lookup, ignoring hidden class name
10738 injected via friend declaration. */
10739 decl
= lookup_name_prefer_type (name
, 2);
10740 /* If that fails, the name will be placed in the smallest
10741 non-class, non-function-prototype scope according to 3.3.1/5.
10742 We may already have a hidden name declared as friend in this
10743 scope. So lookup again but not ignoring hidden names.
10744 If we find one, that name will be made visible rather than
10745 creating a new tag. */
10747 decl
= lookup_type_scope (name
, ts_within_enclosing_non_class
);
10750 decl
= lookup_type_scope (name
, scope
);
10752 if (decl
&& DECL_CLASS_TEMPLATE_P (decl
))
10753 decl
= DECL_TEMPLATE_RESULT (decl
);
10755 if (decl
&& TREE_CODE (decl
) == TYPE_DECL
)
10757 /* Look for invalid nested type:
10761 if (scope
== ts_current
&& DECL_SELF_REFERENCE_P (decl
))
10763 error ("%qD has the same name as the class in which it is "
10766 return error_mark_node
;
10769 /* Two cases we need to consider when deciding if a class
10770 template is allowed as an elaborated type specifier:
10771 1. It is a self reference to its own class.
10772 2. It comes with a template header.
10776 template <class T> class C {
10777 class C *c1; // DECL_SELF_REFERENCE_P is true
10780 template <class U> class C; // template_header_p is true
10781 template <class T> class C<T>::D {
10782 class C *c2; // DECL_SELF_REFERENCE_P is true
10785 t
= check_elaborated_type_specifier (tag_code
,
10788 | DECL_SELF_REFERENCE_P (decl
));
10791 else if (decl
&& TREE_CODE (decl
) == TREE_LIST
)
10793 error ("reference to %qD is ambiguous", name
);
10794 print_candidates (decl
);
10795 return error_mark_node
;
10801 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
10802 Define the tag as a forward-reference if it is not defined.
10804 If a declaration is given, process it here, and report an error if
10805 multiple declarations are not identical.
10807 SCOPE is TS_CURRENT when this is also a definition. Only look in
10808 the current frame for the name (since C++ allows new names in any
10809 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
10810 declaration. Only look beginning from the current scope outward up
10811 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
10813 TEMPLATE_HEADER_P is true when this declaration is preceded by
10814 a set of template parameters. */
10817 xref_tag (enum tag_types tag_code
, tree name
,
10818 tag_scope scope
, bool template_header_p
)
10820 enum tree_code code
;
10822 tree context
= NULL_TREE
;
10824 timevar_push (TV_NAME_LOOKUP
);
10826 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
10832 code
= RECORD_TYPE
;
10838 code
= ENUMERAL_TYPE
;
10841 gcc_unreachable ();
10844 /* In case of anonymous name, xref_tag is only called to
10845 make type node and push name. Name lookup is not required. */
10846 if (ANON_AGGRNAME_P (name
))
10849 t
= lookup_and_check_tag (tag_code
, name
,
10850 scope
, template_header_p
);
10852 if (t
== error_mark_node
)
10853 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
10855 if (scope
!= ts_current
&& t
&& current_class_type
10856 && template_class_depth (current_class_type
)
10857 && template_header_p
)
10859 /* Since SCOPE is not TS_CURRENT, we are not looking at a
10860 definition of this tag. Since, in addition, we are currently
10861 processing a (member) template declaration of a template
10862 class, we must be very careful; consider:
10869 { template <class V>
10870 friend struct S1; };
10872 Here, the S2::S1 declaration should not be confused with the
10873 outer declaration. In particular, the inner version should
10874 have a template parameter of level 2, not level 1. This
10875 would be particularly important if the member declaration
10878 template <class V = U> friend struct S1;
10880 say, when we should tsubst into `U' when instantiating
10881 S2. On the other hand, when presented with:
10891 we must find the inner binding eventually. We
10892 accomplish this by making sure that the new type we
10893 create to represent this declaration has the right
10895 context
= TYPE_CONTEXT (t
);
10901 /* If no such tag is yet defined, create a forward-reference node
10902 and record it as the "definition".
10903 When a real declaration of this type is found,
10904 the forward-reference will be altered into a real type. */
10905 if (code
== ENUMERAL_TYPE
)
10907 error ("use of enum %q#D without previous declaration", name
);
10908 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
10912 t
= make_class_type (code
);
10913 TYPE_CONTEXT (t
) = context
;
10914 t
= pushtag (name
, t
, scope
);
10919 if (template_header_p
&& MAYBE_CLASS_TYPE_P (t
))
10921 if (!redeclare_class_template (t
, current_template_parms
))
10922 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
10924 else if (!processing_template_decl
10925 && CLASS_TYPE_P (t
)
10926 && CLASSTYPE_IS_TEMPLATE (t
))
10928 error ("redeclaration of %qT as a non-template", t
);
10929 error ("previous declaration %q+D", t
);
10930 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
10933 /* Make injected friend class visible. */
10934 if (scope
!= ts_within_enclosing_non_class
10935 && hidden_name_p (TYPE_NAME (t
)))
10937 DECL_ANTICIPATED (TYPE_NAME (t
)) = 0;
10938 DECL_FRIEND_P (TYPE_NAME (t
)) = 0;
10940 if (TYPE_TEMPLATE_INFO (t
))
10942 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t
)) = 0;
10943 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t
)) = 0;
10948 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
10952 xref_tag_from_type (tree old
, tree id
, tag_scope scope
)
10954 enum tag_types tag_kind
;
10956 if (TREE_CODE (old
) == RECORD_TYPE
)
10957 tag_kind
= (CLASSTYPE_DECLARED_CLASS (old
) ? class_type
: record_type
);
10959 tag_kind
= union_type
;
10961 if (id
== NULL_TREE
)
10962 id
= TYPE_IDENTIFIER (old
);
10964 return xref_tag (tag_kind
, id
, scope
, false);
10967 /* Create the binfo hierarchy for REF with (possibly NULL) base list
10968 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
10969 access_* node, and the TREE_VALUE is the type of the base-class.
10970 Non-NULL TREE_TYPE indicates virtual inheritance.
10972 Returns true if the binfo hierarchy was successfully created,
10973 false if an error was detected. */
10976 xref_basetypes (tree ref
, tree base_list
)
10979 tree binfo
, base_binfo
;
10980 unsigned max_vbases
= 0; /* Maximum direct & indirect virtual bases. */
10981 unsigned max_bases
= 0; /* Maximum direct bases. */
10983 tree default_access
;
10984 tree igo_prev
; /* Track Inheritance Graph Order. */
10986 if (ref
== error_mark_node
)
10989 /* The base of a derived class is private by default, all others are
10991 default_access
= (TREE_CODE (ref
) == RECORD_TYPE
10992 && CLASSTYPE_DECLARED_CLASS (ref
)
10993 ? access_private_node
: access_public_node
);
10995 /* First, make sure that any templates in base-classes are
10996 instantiated. This ensures that if we call ourselves recursively
10997 we do not get confused about which classes are marked and which
10999 basep
= &base_list
;
11002 tree basetype
= TREE_VALUE (*basep
);
11004 if (!(processing_template_decl
&& uses_template_parms (basetype
))
11005 && !complete_type_or_else (basetype
, NULL
))
11006 /* An incomplete type. Remove it from the list. */
11007 *basep
= TREE_CHAIN (*basep
);
11011 if (TREE_TYPE (*basep
))
11013 if (CLASS_TYPE_P (basetype
))
11014 max_vbases
+= VEC_length (tree
, CLASSTYPE_VBASECLASSES (basetype
));
11015 basep
= &TREE_CHAIN (*basep
);
11019 TYPE_MARKED_P (ref
) = 1;
11021 /* The binfo slot should be empty, unless this is an (ill-formed)
11023 gcc_assert (!TYPE_BINFO (ref
) || TYPE_SIZE (ref
));
11024 gcc_assert (TYPE_MAIN_VARIANT (ref
) == ref
);
11026 binfo
= make_tree_binfo (max_bases
);
11028 TYPE_BINFO (ref
) = binfo
;
11029 BINFO_OFFSET (binfo
) = size_zero_node
;
11030 BINFO_TYPE (binfo
) = ref
;
11032 /* Apply base-class info set up to the variants of this type. */
11033 fixup_type_variants (ref
);
11037 BINFO_BASE_ACCESSES (binfo
) = VEC_alloc (tree
, gc
, max_bases
);
11038 /* An aggregate cannot have baseclasses. */
11039 CLASSTYPE_NON_AGGREGATE (ref
) = 1;
11041 if (TREE_CODE (ref
) == UNION_TYPE
)
11043 error ("derived union %qT invalid", ref
);
11050 if (TYPE_FOR_JAVA (ref
))
11052 error ("Java class %qT cannot have multiple bases", ref
);
11059 CLASSTYPE_VBASECLASSES (ref
) = VEC_alloc (tree
, gc
, max_vbases
);
11061 if (TYPE_FOR_JAVA (ref
))
11063 error ("Java class %qT cannot have virtual bases", ref
);
11068 for (igo_prev
= binfo
; base_list
; base_list
= TREE_CHAIN (base_list
))
11070 tree access
= TREE_PURPOSE (base_list
);
11071 int via_virtual
= TREE_TYPE (base_list
) != NULL_TREE
;
11072 tree basetype
= TREE_VALUE (base_list
);
11074 if (access
== access_default_node
)
11075 access
= default_access
;
11077 if (PACK_EXPANSION_P (basetype
))
11078 basetype
= PACK_EXPANSION_PATTERN (basetype
);
11079 if (TREE_CODE (basetype
) == TYPE_DECL
)
11080 basetype
= TREE_TYPE (basetype
);
11081 if (!MAYBE_CLASS_TYPE_P (basetype
) || TREE_CODE (basetype
) == UNION_TYPE
)
11083 error ("base type %qT fails to be a struct or class type",
11088 if (TYPE_FOR_JAVA (basetype
) && (current_lang_depth () == 0))
11089 TYPE_FOR_JAVA (ref
) = 1;
11091 base_binfo
= NULL_TREE
;
11092 if (CLASS_TYPE_P (basetype
) && !dependent_type_p (basetype
))
11094 base_binfo
= TYPE_BINFO (basetype
);
11095 /* The original basetype could have been a typedef'd type. */
11096 basetype
= BINFO_TYPE (base_binfo
);
11098 /* Inherit flags from the base. */
11099 TYPE_HAS_NEW_OPERATOR (ref
)
11100 |= TYPE_HAS_NEW_OPERATOR (basetype
);
11101 TYPE_HAS_ARRAY_NEW_OPERATOR (ref
)
11102 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype
);
11103 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
11104 TYPE_HAS_CONVERSION (ref
) |= TYPE_HAS_CONVERSION (basetype
);
11105 CLASSTYPE_DIAMOND_SHAPED_P (ref
)
11106 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype
);
11107 CLASSTYPE_REPEATED_BASE_P (ref
)
11108 |= CLASSTYPE_REPEATED_BASE_P (basetype
);
11111 /* We must do this test after we've seen through a typedef
11113 if (TYPE_MARKED_P (basetype
))
11115 if (basetype
== ref
)
11116 error ("recursive type %qT undefined", basetype
);
11118 error ("duplicate base type %qT invalid", basetype
);
11122 if (PACK_EXPANSION_P (TREE_VALUE (base_list
)))
11123 /* Regenerate the pack expansion for the bases. */
11124 basetype
= make_pack_expansion (basetype
);
11126 TYPE_MARKED_P (basetype
) = 1;
11128 base_binfo
= copy_binfo (base_binfo
, basetype
, ref
,
11129 &igo_prev
, via_virtual
);
11130 if (!BINFO_INHERITANCE_CHAIN (base_binfo
))
11131 BINFO_INHERITANCE_CHAIN (base_binfo
) = binfo
;
11133 BINFO_BASE_APPEND (binfo
, base_binfo
);
11134 BINFO_BASE_ACCESS_APPEND (binfo
, access
);
11137 if (VEC_space (tree
, CLASSTYPE_VBASECLASSES (ref
), 1))
11138 /* If we have space in the vbase vector, we must have shared at
11139 least one of them, and are therefore diamond shaped. */
11140 CLASSTYPE_DIAMOND_SHAPED_P (ref
) = 1;
11142 /* Unmark all the types. */
11143 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
11144 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
11145 TYPE_MARKED_P (ref
) = 0;
11147 /* Now see if we have a repeated base type. */
11148 if (!CLASSTYPE_REPEATED_BASE_P (ref
))
11150 for (base_binfo
= binfo
; base_binfo
;
11151 base_binfo
= TREE_CHAIN (base_binfo
))
11153 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
11155 CLASSTYPE_REPEATED_BASE_P (ref
) = 1;
11158 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 1;
11160 for (base_binfo
= binfo
; base_binfo
;
11161 base_binfo
= TREE_CHAIN (base_binfo
))
11162 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
11163 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
11172 /* Begin compiling the definition of an enumeration type.
11175 UNDERLYING_TYPE is the type that will be used as the storage for
11176 the enumeration type. This should be NULL_TREE if no storage type
11179 SCOPED_ENUM_P is true if this is a scoped enumeration type.
11181 Returns the type object, as yet incomplete.
11182 Also records info about it so that build_enumerator
11183 may be used to declare the individual values as they are read. */
11186 start_enum (tree name
, tree underlying_type
, bool scoped_enum_p
)
11190 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
11192 /* If this is the real definition for a previous forward reference,
11193 fill in the contents in the same object that used to be the
11194 forward reference. */
11196 enumtype
= lookup_and_check_tag (enum_type
, name
,
11197 /*tag_scope=*/ts_current
,
11198 /*template_header_p=*/false);
11200 if (enumtype
!= NULL_TREE
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
11202 error_at (input_location
, "multiple definition of %q#T", enumtype
);
11203 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype
)),
11204 "previous definition here");
11205 /* Clear out TYPE_VALUES, and start again. */
11206 TYPE_VALUES (enumtype
) = NULL_TREE
;
11210 /* In case of error, make a dummy enum to allow parsing to
11212 if (enumtype
== error_mark_node
)
11213 name
= make_anon_name ();
11215 enumtype
= cxx_make_type (ENUMERAL_TYPE
);
11216 enumtype
= pushtag (name
, enumtype
, /*tag_scope=*/ts_current
);
11219 if (enumtype
== error_mark_node
)
11224 SET_SCOPED_ENUM_P (enumtype
, 1);
11225 begin_scope (sk_scoped_enum
, enumtype
);
11227 /* [C++0x dcl.enum]p5:
11229 If not explicitly specified, the underlying type of a scoped
11230 enumeration type is int. */
11231 if (!underlying_type
)
11232 underlying_type
= integer_type_node
;
11235 if (underlying_type
)
11237 if (CP_INTEGRAL_TYPE_P (underlying_type
))
11239 TYPE_MIN_VALUE (enumtype
) = TYPE_MIN_VALUE (underlying_type
);
11240 TYPE_MAX_VALUE (enumtype
) = TYPE_MAX_VALUE (underlying_type
);
11241 TYPE_SIZE (enumtype
) = TYPE_SIZE (underlying_type
);
11242 TYPE_SIZE_UNIT (enumtype
) = TYPE_SIZE_UNIT (underlying_type
);
11243 SET_TYPE_MODE (enumtype
, TYPE_MODE (underlying_type
));
11244 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (underlying_type
);
11245 TYPE_ALIGN (enumtype
) = TYPE_ALIGN (underlying_type
);
11246 TYPE_USER_ALIGN (enumtype
) = TYPE_USER_ALIGN (underlying_type
);
11247 TYPE_UNSIGNED (enumtype
) = TYPE_UNSIGNED (underlying_type
);
11248 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
11250 else if (!dependent_type_p (underlying_type
))
11251 error ("underlying type %<%T%> of %<%T%> must be an integral type",
11252 underlying_type
, enumtype
);
11258 /* After processing and defining all the values of an enumeration type,
11259 install their decls in the enumeration type and finish it off.
11260 ENUMTYPE is the type object and VALUES a list of name-value pairs. */
11263 finish_enum (tree enumtype
)
11272 bool use_short_enum
;
11277 tree underlying_type
= NULL_TREE
;
11278 bool fixed_underlying_type_p
11279 = ENUM_UNDERLYING_TYPE (enumtype
) != NULL_TREE
;
11281 /* We built up the VALUES in reverse order. */
11282 TYPE_VALUES (enumtype
) = nreverse (TYPE_VALUES (enumtype
));
11284 /* For an enum defined in a template, just set the type of the values;
11285 all further processing is postponed until the template is
11286 instantiated. We need to set the type so that tsubst of a CONST_DECL
11288 if (processing_template_decl
)
11290 for (values
= TYPE_VALUES (enumtype
);
11292 values
= TREE_CHAIN (values
))
11293 TREE_TYPE (TREE_VALUE (values
)) = enumtype
;
11294 if (at_function_scope_p ())
11295 add_stmt (build_min (TAG_DEFN
, enumtype
));
11296 if (SCOPED_ENUM_P (enumtype
))
11301 /* Determine the minimum and maximum values of the enumerators. */
11302 if (TYPE_VALUES (enumtype
))
11304 minnode
= maxnode
= NULL_TREE
;
11306 for (values
= TYPE_VALUES (enumtype
);
11308 values
= TREE_CHAIN (values
))
11310 decl
= TREE_VALUE (values
);
11312 /* [dcl.enum]: Following the closing brace of an enum-specifier,
11313 each enumerator has the type of its enumeration. Prior to the
11314 closing brace, the type of each enumerator is the type of its
11315 initializing value. */
11316 TREE_TYPE (decl
) = enumtype
;
11318 /* Update the minimum and maximum values, if appropriate. */
11319 value
= DECL_INITIAL (decl
);
11320 if (value
== error_mark_node
)
11321 value
= integer_zero_node
;
11322 /* Figure out what the minimum and maximum values of the
11323 enumerators are. */
11325 minnode
= maxnode
= value
;
11326 else if (tree_int_cst_lt (maxnode
, value
))
11328 else if (tree_int_cst_lt (value
, minnode
))
11335 If the enumerator-list is empty, the underlying type is as if
11336 the enumeration had a single enumerator with value 0. */
11337 minnode
= maxnode
= integer_zero_node
;
11339 /* Compute the number of bits require to represent all values of the
11340 enumeration. We must do this before the type of MINNODE and
11341 MAXNODE are transformed, since tree_int_cst_min_precision relies
11342 on the TREE_TYPE of the value it is passed. */
11343 unsignedp
= tree_int_cst_sgn (minnode
) >= 0;
11344 lowprec
= tree_int_cst_min_precision (minnode
, unsignedp
);
11345 highprec
= tree_int_cst_min_precision (maxnode
, unsignedp
);
11346 precision
= MAX (lowprec
, highprec
);
11348 if (!fixed_underlying_type_p
)
11350 /* Determine the underlying type of the enumeration.
11354 The underlying type of an enumeration is an integral type that
11355 can represent all the enumerator values defined in the
11356 enumeration. It is implementation-defined which integral type is
11357 used as the underlying type for an enumeration except that the
11358 underlying type shall not be larger than int unless the value of
11359 an enumerator cannot fit in an int or unsigned int.
11361 We use "int" or an "unsigned int" as the underlying type, even if
11362 a smaller integral type would work, unless the user has
11363 explicitly requested that we use the smallest possible type. The
11364 user can request that for all enumerations with a command line
11365 flag, or for just one enumeration with an attribute. */
11367 use_short_enum
= flag_short_enums
11368 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype
));
11370 for (itk
= (use_short_enum
? itk_char
: itk_int
);
11374 underlying_type
= integer_types
[itk
];
11375 if (TYPE_PRECISION (underlying_type
) >= precision
11376 && TYPE_UNSIGNED (underlying_type
) == unsignedp
)
11379 if (itk
== itk_none
)
11383 IF no integral type can represent all the enumerator values, the
11384 enumeration is ill-formed. */
11385 error ("no integral type can represent all of the enumerator values "
11386 "for %qT", enumtype
);
11387 precision
= TYPE_PRECISION (long_long_integer_type_node
);
11388 underlying_type
= integer_types
[itk_unsigned_long_long
];
11393 The value of sizeof() applied to an enumeration type, an object
11394 of an enumeration type, or an enumerator, is the value of sizeof()
11395 applied to the underlying type. */
11396 TYPE_SIZE (enumtype
) = TYPE_SIZE (underlying_type
);
11397 TYPE_SIZE_UNIT (enumtype
) = TYPE_SIZE_UNIT (underlying_type
);
11398 SET_TYPE_MODE (enumtype
, TYPE_MODE (underlying_type
));
11399 TYPE_ALIGN (enumtype
) = TYPE_ALIGN (underlying_type
);
11400 TYPE_USER_ALIGN (enumtype
) = TYPE_USER_ALIGN (underlying_type
);
11401 TYPE_UNSIGNED (enumtype
) = TYPE_UNSIGNED (underlying_type
);
11403 /* Set the underlying type of the enumeration type to the
11404 computed enumeration type, restricted to the enumerator
11406 ENUM_UNDERLYING_TYPE (enumtype
)
11407 = build_distinct_type_copy (underlying_type
);
11408 set_min_and_max_values_for_integral_type
11409 (ENUM_UNDERLYING_TYPE (enumtype
), precision
, unsignedp
);
11412 underlying_type
= ENUM_UNDERLYING_TYPE (enumtype
);
11414 /* Compute the minimum and maximum values for the type.
11418 For an enumeration where emin is the smallest enumerator and emax
11419 is the largest, the values of the enumeration are the values of the
11420 underlying type in the range bmin to bmax, where bmin and bmax are,
11421 respectively, the smallest and largest values of the smallest bit-
11422 field that can store emin and emax. */
11424 /* The middle-end currently assumes that types with TYPE_PRECISION
11425 narrower than their underlying type are suitably zero or sign
11426 extended to fill their mode. g++ doesn't make these guarantees.
11427 Until the middle-end can represent such paradoxical types, we
11428 set the TYPE_PRECISION to the width of the underlying type. */
11429 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (underlying_type
);
11431 set_min_and_max_values_for_integral_type (enumtype
, precision
, unsignedp
);
11433 /* Convert each of the enumerators to the type of the underlying
11434 type of the enumeration. */
11435 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
11437 location_t saved_location
;
11439 decl
= TREE_VALUE (values
);
11440 saved_location
= input_location
;
11441 input_location
= DECL_SOURCE_LOCATION (decl
);
11442 if (fixed_underlying_type_p
)
11443 /* If the enumeration type has a fixed underlying type, we
11444 already checked all of the enumerator values. */
11445 value
= DECL_INITIAL (decl
);
11447 value
= perform_implicit_conversion (underlying_type
,
11448 DECL_INITIAL (decl
),
11449 tf_warning_or_error
);
11450 input_location
= saved_location
;
11452 /* Do not clobber shared ints. */
11453 value
= copy_node (value
);
11455 TREE_TYPE (value
) = enumtype
;
11456 DECL_INITIAL (decl
) = value
;
11459 /* Fix up all variant types of this enum type. */
11460 for (t
= TYPE_MAIN_VARIANT (enumtype
); t
; t
= TYPE_NEXT_VARIANT (t
))
11462 TYPE_VALUES (t
) = TYPE_VALUES (enumtype
);
11463 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (enumtype
);
11464 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (enumtype
);
11465 TYPE_SIZE (t
) = TYPE_SIZE (enumtype
);
11466 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (enumtype
);
11467 SET_TYPE_MODE (t
, TYPE_MODE (enumtype
));
11468 TYPE_PRECISION (t
) = TYPE_PRECISION (enumtype
);
11469 TYPE_ALIGN (t
) = TYPE_ALIGN (enumtype
);
11470 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (enumtype
);
11471 TYPE_UNSIGNED (t
) = TYPE_UNSIGNED (enumtype
);
11472 ENUM_UNDERLYING_TYPE (t
) = ENUM_UNDERLYING_TYPE (enumtype
);
11475 /* Finish up the scope of a scoped enumeration. */
11476 if (SCOPED_ENUM_P (enumtype
))
11479 /* Finish debugging output for this type. */
11480 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
11483 /* Build and install a CONST_DECL for an enumeration constant of the
11484 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
11485 Assignment of sequential values by default is handled here. */
11488 build_enumerator (tree name
, tree value
, tree enumtype
)
11494 /* If the VALUE was erroneous, pretend it wasn't there; that will
11495 result in the enum being assigned the next value in sequence. */
11496 if (value
== error_mark_node
)
11499 /* Remove no-op casts from the value. */
11501 STRIP_TYPE_NOPS (value
);
11503 if (! processing_template_decl
)
11505 /* Validate and default VALUE. */
11506 if (value
!= NULL_TREE
)
11508 value
= integral_constant_value (value
);
11510 if (TREE_CODE (value
) == INTEGER_CST
)
11512 value
= perform_integral_promotions (value
);
11513 constant_expression_warning (value
);
11517 error ("enumerator value for %qD is not an integer constant", name
);
11522 /* Default based on previous value. */
11523 if (value
== NULL_TREE
)
11525 if (TYPE_VALUES (enumtype
))
11528 unsigned HOST_WIDE_INT lo
;
11532 /* The next value is the previous value plus one.
11533 add_double doesn't know the type of the target expression,
11534 so we must check with int_fits_type_p as well. */
11535 prev_value
= DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype
)));
11536 if (error_operand_p (prev_value
))
11537 value
= error_mark_node
;
11540 overflowed
= add_double (TREE_INT_CST_LOW (prev_value
),
11541 TREE_INT_CST_HIGH (prev_value
),
11543 value
= build_int_cst_wide (TREE_TYPE (prev_value
), lo
, hi
);
11545 |= !int_fits_type_p (value
, TREE_TYPE (prev_value
));
11549 error ("overflow in enumeration values at %qD", name
);
11550 value
= error_mark_node
;
11555 value
= integer_zero_node
;
11558 /* Remove no-op casts from the value. */
11559 STRIP_TYPE_NOPS (value
);
11561 /* If the underlying type of the enum is fixed, check whether
11562 the enumerator values fits in the underlying type. If it
11563 does not fit, the program is ill-formed [C++0x dcl.enum]. */
11564 if (ENUM_UNDERLYING_TYPE (enumtype
)
11566 && TREE_CODE (value
) == INTEGER_CST
11567 && !int_fits_type_p (value
, ENUM_UNDERLYING_TYPE (enumtype
)))
11569 error ("enumerator value %E is too large for underlying type %<%T%>",
11570 value
, ENUM_UNDERLYING_TYPE (enumtype
));
11572 /* Silently convert the value so that we can continue. */
11573 value
= perform_implicit_conversion (ENUM_UNDERLYING_TYPE (enumtype
),
11578 /* C++ associates enums with global, function, or class declarations. */
11579 context
= current_scope ();
11581 /* Build the actual enumeration constant. Note that the enumeration
11582 constants have the underlying type of the enum (if it is fixed)
11583 or the type of their initializer (if the underlying type of the
11584 enum is not fixed):
11588 If the underlying type is fixed, the type of each enumerator
11589 prior to the closing brace is the underlying type; if the
11590 initializing value of an enumerator cannot be represented by
11591 the underlying type, the program is ill-formed. If the
11592 underlying type is not fixed, the type of each enumerator is
11593 the type of its initializing value.
11595 If the underlying type is not fixed, it will be computed by
11596 finish_enum and we will reset the type of this enumerator. Of
11597 course, if we're processing a template, there may be no value. */
11598 type
= value
? TREE_TYPE (value
) : NULL_TREE
;
11600 if (context
&& context
== current_class_type
)
11601 /* This enum declaration is local to the class. We need the full
11602 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
11603 decl
= build_lang_decl (CONST_DECL
, name
, type
);
11605 /* It's a global enum, or it's local to a function. (Note local to
11606 a function could mean local to a class method. */
11607 decl
= build_decl (input_location
, CONST_DECL
, name
, type
);
11609 DECL_CONTEXT (decl
) = FROB_CONTEXT (context
);
11610 TREE_CONSTANT (decl
) = 1;
11611 TREE_READONLY (decl
) = 1;
11612 DECL_INITIAL (decl
) = value
;
11614 if (context
&& context
== current_class_type
&& !SCOPED_ENUM_P (enumtype
))
11615 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
11616 on the TYPE_FIELDS list for `S'. (That's so that you can say
11617 things like `S::i' later.) */
11618 finish_member_declaration (decl
);
11622 /* Add this enumeration constant to the list for this type. */
11623 TYPE_VALUES (enumtype
) = tree_cons (name
, decl
, TYPE_VALUES (enumtype
));
11626 /* Look for an enumerator with the given NAME within the enumeration
11627 type ENUMTYPE. This routine is used primarily for qualified name
11628 lookup into an enumerator in C++0x, e.g.,
11630 enum class Color { Red, Green, Blue };
11632 Color color = Color::Red;
11634 Returns the value corresponding to the enumerator, or
11635 NULL_TREE if no such enumerator was found. */
11637 lookup_enumerator (tree enumtype
, tree name
)
11640 gcc_assert (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
);
11642 e
= purpose_member (name
, TYPE_VALUES (enumtype
));
11643 return e
? TREE_VALUE (e
) : NULL_TREE
;
11647 /* We're defining DECL. Make sure that its type is OK. Return TRUE
11648 if its type is changed to void. */
11651 check_function_type (tree decl
, tree current_function_parms
)
11653 tree fntype
= TREE_TYPE (decl
);
11654 tree return_type
= complete_type (TREE_TYPE (fntype
));
11656 /* In a function definition, arg types must be complete. */
11657 require_complete_types_for_parms (current_function_parms
);
11659 /* constexpr functions must have literal argument types and
11660 literal return type. */
11661 validate_constexpr_fundecl (decl
);
11663 if (dependent_type_p (return_type
))
11665 if (!COMPLETE_OR_VOID_TYPE_P (return_type
)
11666 || (TYPE_FOR_JAVA (return_type
) && MAYBE_CLASS_TYPE_P (return_type
)))
11668 tree args
= TYPE_ARG_TYPES (fntype
);
11670 if (!COMPLETE_OR_VOID_TYPE_P (return_type
))
11671 error ("return type %q#T is incomplete", return_type
);
11673 error ("return type has Java class type %q#T", return_type
);
11675 /* Make it return void instead. */
11676 if (TREE_CODE (fntype
) == METHOD_TYPE
)
11677 fntype
= build_method_type_directly (TREE_TYPE (TREE_VALUE (args
)),
11679 TREE_CHAIN (args
));
11681 fntype
= build_function_type (void_type_node
, args
);
11683 = build_exception_variant (fntype
,
11684 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl
)));
11685 fntype
= (cp_build_type_attribute_variant
11686 (fntype
, TYPE_ATTRIBUTES (TREE_TYPE (decl
))));
11687 TREE_TYPE (decl
) = fntype
;
11692 abstract_virtuals_error (decl
, TREE_TYPE (fntype
));
11697 /* Create the FUNCTION_DECL for a function definition.
11698 DECLSPECS and DECLARATOR are the parts of the declaration;
11699 they describe the function's name and the type it returns,
11700 but twisted together in a fashion that parallels the syntax of C.
11702 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
11703 DECLARATOR is really the DECL for the function we are about to
11704 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
11705 indicating that the function is an inline defined in-class.
11707 This function creates a binding context for the function body
11708 as well as setting up the FUNCTION_DECL in current_function_decl.
11710 For C++, we must first check whether that datum makes any sense.
11711 For example, "class A local_a(1,2);" means that variable local_a
11712 is an aggregate of type A, which should have a constructor
11713 applied to it with the argument list [1, 2].
11715 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
11716 or may be a BLOCK if the function has been defined previously
11717 in this translation unit. On exit, DECL_INITIAL (decl1) will be
11718 error_mark_node if the function has never been defined, or
11719 a BLOCK if the function has been defined somewhere. */
11722 start_preparsed_function (tree decl1
, tree attrs
, int flags
)
11724 tree ctype
= NULL_TREE
;
11727 int doing_friend
= 0;
11728 struct cp_binding_level
*bl
;
11729 tree current_function_parms
;
11730 struct c_fileinfo
*finfo
11731 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1
)));
11732 bool honor_interface
;
11734 /* Sanity check. */
11735 gcc_assert (TREE_CODE (TREE_VALUE (void_list_node
)) == VOID_TYPE
);
11736 gcc_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
);
11738 fntype
= TREE_TYPE (decl1
);
11739 if (TREE_CODE (fntype
) == METHOD_TYPE
)
11740 ctype
= TYPE_METHOD_BASETYPE (fntype
);
11742 /* ISO C++ 11.4/5. A friend function defined in a class is in
11743 the (lexical) scope of the class in which it is defined. */
11744 if (!ctype
&& DECL_FRIEND_P (decl1
))
11746 ctype
= DECL_FRIEND_CONTEXT (decl1
);
11748 /* CTYPE could be null here if we're dealing with a template;
11749 for example, `inline friend float foo()' inside a template
11750 will have no CTYPE set. */
11751 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
11757 if (DECL_DECLARED_INLINE_P (decl1
)
11758 && lookup_attribute ("noinline", attrs
))
11759 warning (0, "inline function %q+D given attribute noinline", decl1
);
11761 /* Handle gnu_inline attribute. */
11762 if (GNU_INLINE_P (decl1
))
11764 DECL_EXTERNAL (decl1
) = 1;
11765 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
11766 DECL_INTERFACE_KNOWN (decl1
) = 1;
11767 DECL_DISREGARD_INLINE_LIMITS (decl1
) = 1;
11770 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1
))
11771 /* This is a constructor, we must ensure that any default args
11772 introduced by this definition are propagated to the clones
11773 now. The clones are used directly in overload resolution. */
11774 adjust_clone_args (decl1
);
11776 /* Sometimes we don't notice that a function is a static member, and
11777 build a METHOD_TYPE for it. Fix that up now. */
11778 if (ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
)
11779 && TREE_CODE (TREE_TYPE (decl1
)) == METHOD_TYPE
)
11781 revert_static_member_fn (decl1
);
11785 /* Set up current_class_type, and enter the scope of the class, if
11788 push_nested_class (ctype
);
11789 else if (DECL_STATIC_FUNCTION_P (decl1
))
11790 push_nested_class (DECL_CONTEXT (decl1
));
11792 /* Now that we have entered the scope of the class, we must restore
11793 the bindings for any template parameters surrounding DECL1, if it
11794 is an inline member template. (Order is important; consider the
11795 case where a template parameter has the same name as a field of
11796 the class.) It is not until after this point that
11797 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
11798 if (flags
& SF_INCLASS_INLINE
)
11799 maybe_begin_member_template_processing (decl1
);
11801 /* Effective C++ rule 15. */
11803 && DECL_OVERLOADED_OPERATOR_P (decl1
) == NOP_EXPR
11804 && TREE_CODE (TREE_TYPE (fntype
)) == VOID_TYPE
)
11805 warning (OPT_Weffc__
, "%<operator=%> should return a reference to %<*this%>");
11807 /* Make the init_value nonzero so pushdecl knows this is not tentative.
11808 error_mark_node is replaced below (in poplevel) with the BLOCK. */
11809 if (!DECL_INITIAL (decl1
))
11810 DECL_INITIAL (decl1
) = error_mark_node
;
11812 /* This function exists in static storage.
11813 (This does not mean `static' in the C sense!) */
11814 TREE_STATIC (decl1
) = 1;
11816 /* We must call push_template_decl after current_class_type is set
11817 up. (If we are processing inline definitions after exiting a
11818 class scope, current_class_type will be NULL_TREE until set above
11819 by push_nested_class.) */
11820 if (processing_template_decl
)
11822 /* FIXME: Handle error_mark_node more gracefully. */
11823 tree newdecl1
= push_template_decl (decl1
);
11824 if (newdecl1
!= error_mark_node
)
11828 /* We are now in the scope of the function being defined. */
11829 current_function_decl
= decl1
;
11831 /* Save the parm names or decls from this function's declarator
11832 where store_parm_decls will find them. */
11833 current_function_parms
= DECL_ARGUMENTS (decl1
);
11835 /* Make sure the parameter and return types are reasonable. When
11836 you declare a function, these types can be incomplete, but they
11837 must be complete when you define the function.
11839 Use function_return_type to build the return declaration for the
11840 function if FNTYPE isn't changed to void. */
11841 if (check_function_type (decl1
, current_function_parms
))
11842 restype
= TREE_TYPE (fntype
);
11844 restype
= function_return_type (decl1
);
11845 if (DECL_RESULT (decl1
) == NULL_TREE
)
11849 resdecl
= build_decl (input_location
, RESULT_DECL
, 0, restype
);
11850 DECL_ARTIFICIAL (resdecl
) = 1;
11851 DECL_IGNORED_P (resdecl
) = 1;
11852 DECL_RESULT (decl1
) = resdecl
;
11854 cp_apply_type_quals_to_decl (cp_type_quals (restype
), resdecl
);
11857 /* Let the user know we're compiling this function. */
11858 announce_function (decl1
);
11860 /* Record the decl so that the function name is defined.
11861 If we already have a decl for this name, and it is a FUNCTION_DECL,
11862 use the old decl. */
11863 if (!processing_template_decl
&& !(flags
& SF_PRE_PARSED
))
11865 /* A specialization is not used to guide overload resolution. */
11866 if (!DECL_FUNCTION_MEMBER_P (decl1
)
11867 && !(DECL_USE_TEMPLATE (decl1
) &&
11868 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1
))))
11870 tree olddecl
= pushdecl (decl1
);
11872 if (olddecl
== error_mark_node
)
11873 /* If something went wrong when registering the declaration,
11874 use DECL1; we have to have a FUNCTION_DECL to use when
11875 parsing the body of the function. */
11879 /* Otherwise, OLDDECL is either a previous declaration
11880 of the same function or DECL1 itself. */
11882 if (warn_missing_declarations
11883 && olddecl
== decl1
11884 && !DECL_MAIN_P (decl1
)
11885 && TREE_PUBLIC (decl1
)
11886 && !DECL_DECLARED_INLINE_P (decl1
))
11890 /* Check whether DECL1 is in an anonymous
11892 for (context
= DECL_CONTEXT (decl1
);
11894 context
= DECL_CONTEXT (context
))
11896 if (TREE_CODE (context
) == NAMESPACE_DECL
11897 && DECL_NAME (context
) == NULL_TREE
)
11901 if (context
== NULL
)
11902 warning (OPT_Wmissing_declarations
,
11903 "no previous declaration for %q+D", decl1
);
11911 /* We need to set the DECL_CONTEXT. */
11912 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
11913 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
11915 fntype
= TREE_TYPE (decl1
);
11917 /* If #pragma weak applies, mark the decl appropriately now.
11918 The pragma only applies to global functions. Because
11919 determining whether or not the #pragma applies involves
11920 computing the mangled name for the declaration, we cannot
11921 apply the pragma until after we have merged this declaration
11922 with any previous declarations; if the original declaration
11923 has a linkage specification, that specification applies to
11924 the definition as well, and may affect the mangled name. */
11925 if (!DECL_CONTEXT (decl1
))
11926 maybe_apply_pragma_weak (decl1
);
11929 /* Reset this in case the call to pushdecl changed it. */
11930 current_function_decl
= decl1
;
11932 gcc_assert (DECL_INITIAL (decl1
));
11934 /* This function may already have been parsed, in which case just
11935 return; our caller will skip over the body without parsing. */
11936 if (DECL_INITIAL (decl1
) != error_mark_node
)
11939 /* Initialize RTL machinery. We cannot do this until
11940 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
11941 even when processing a template; this is how we get
11942 CFUN set up, and our per-function variables initialized.
11943 FIXME factor out the non-RTL stuff. */
11944 bl
= current_binding_level
;
11945 allocate_struct_function (decl1
, processing_template_decl
);
11947 /* Initialize the language data structures. Whenever we start
11948 a new function, we destroy temporaries in the usual way. */
11949 cfun
->language
= GGC_CNEW (struct language_function
);
11950 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
11951 current_binding_level
= bl
;
11953 /* Even though we're inside a function body, we still don't want to
11954 call expand_expr to calculate the size of a variable-sized array.
11955 We haven't necessarily assigned RTL to all variables yet, so it's
11956 not safe to try to expand expressions involving them. */
11957 cfun
->dont_save_pending_sizes_p
= 1;
11959 /* Start the statement-tree, start the tree now. */
11960 DECL_SAVED_TREE (decl1
) = push_stmt_list ();
11962 /* If we are (erroneously) defining a function that we have already
11963 defined before, wipe out what we knew before. */
11964 if (!DECL_PENDING_INLINE_P (decl1
))
11965 DECL_SAVED_FUNCTION_DATA (decl1
) = NULL
;
11967 if (ctype
&& !doing_friend
&& !DECL_STATIC_FUNCTION_P (decl1
))
11969 /* We know that this was set up by `grokclassfn'. We do not
11970 wait until `store_parm_decls', since evil parse errors may
11971 never get us to that point. Here we keep the consistency
11972 between `current_class_type' and `current_class_ptr'. */
11973 tree t
= DECL_ARGUMENTS (decl1
);
11975 gcc_assert (t
!= NULL_TREE
&& TREE_CODE (t
) == PARM_DECL
);
11976 gcc_assert (TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
);
11978 cp_function_chain
->x_current_class_ref
11979 = cp_build_indirect_ref (t
, RO_NULL
, tf_warning_or_error
);
11980 cp_function_chain
->x_current_class_ptr
= t
;
11982 /* Constructors and destructors need to know whether they're "in
11983 charge" of initializing virtual base classes. */
11984 t
= TREE_CHAIN (t
);
11985 if (DECL_HAS_IN_CHARGE_PARM_P (decl1
))
11987 current_in_charge_parm
= t
;
11988 t
= TREE_CHAIN (t
);
11990 if (DECL_HAS_VTT_PARM_P (decl1
))
11992 gcc_assert (DECL_NAME (t
) == vtt_parm_identifier
);
11993 current_vtt_parm
= t
;
11997 honor_interface
= (!DECL_TEMPLATE_INSTANTIATION (decl1
)
11998 /* Implicitly-defined methods (like the
11999 destructor for a class in which no destructor
12000 is explicitly declared) must not be defined
12001 until their definition is needed. So, we
12002 ignore interface specifications for
12003 compiler-generated functions. */
12004 && !DECL_ARTIFICIAL (decl1
));
12006 if (DECL_INTERFACE_KNOWN (decl1
))
12008 tree ctx
= decl_function_context (decl1
);
12010 if (DECL_NOT_REALLY_EXTERN (decl1
))
12011 DECL_EXTERNAL (decl1
) = 0;
12013 if (ctx
!= NULL_TREE
&& DECL_DECLARED_INLINE_P (ctx
)
12014 && TREE_PUBLIC (ctx
))
12015 /* This is a function in a local class in an extern inline
12017 comdat_linkage (decl1
);
12019 /* If this function belongs to an interface, it is public.
12020 If it belongs to someone else's interface, it is also external.
12021 This only affects inlines and template instantiations. */
12022 else if (!finfo
->interface_unknown
&& honor_interface
)
12024 if (DECL_DECLARED_INLINE_P (decl1
)
12025 || DECL_TEMPLATE_INSTANTIATION (decl1
)
12026 || processing_template_decl
)
12028 DECL_EXTERNAL (decl1
)
12029 = (finfo
->interface_only
12030 || (DECL_DECLARED_INLINE_P (decl1
)
12031 && ! flag_implement_inlines
12032 && !DECL_VINDEX (decl1
)));
12034 /* For WIN32 we also want to put these in linkonce sections. */
12035 maybe_make_one_only (decl1
);
12038 DECL_EXTERNAL (decl1
) = 0;
12039 DECL_INTERFACE_KNOWN (decl1
) = 1;
12040 /* If this function is in an interface implemented in this file,
12041 make sure that the back end knows to emit this function
12043 if (!DECL_EXTERNAL (decl1
))
12044 mark_needed (decl1
);
12046 else if (finfo
->interface_unknown
&& finfo
->interface_only
12047 && honor_interface
)
12049 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
12050 interface, we will have both finfo->interface_unknown and
12051 finfo->interface_only set. In that case, we don't want to
12052 use the normal heuristics because someone will supply a
12053 #pragma implementation elsewhere, and deducing it here would
12054 produce a conflict. */
12055 comdat_linkage (decl1
);
12056 DECL_EXTERNAL (decl1
) = 0;
12057 DECL_INTERFACE_KNOWN (decl1
) = 1;
12058 DECL_DEFER_OUTPUT (decl1
) = 1;
12062 /* This is a definition, not a reference.
12063 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
12064 if (!GNU_INLINE_P (decl1
))
12065 DECL_EXTERNAL (decl1
) = 0;
12067 if ((DECL_DECLARED_INLINE_P (decl1
)
12068 || DECL_TEMPLATE_INSTANTIATION (decl1
))
12069 && ! DECL_INTERFACE_KNOWN (decl1
))
12070 DECL_DEFER_OUTPUT (decl1
) = 1;
12072 DECL_INTERFACE_KNOWN (decl1
) = 1;
12075 /* Determine the ELF visibility attribute for the function. We must not
12076 do this before calling "pushdecl", as we must allow "duplicate_decls"
12077 to merge any attributes appropriately. We also need to wait until
12079 if (!DECL_CLONED_FUNCTION_P (decl1
))
12080 determine_visibility (decl1
);
12082 begin_scope (sk_function_parms
, decl1
);
12086 if (DECL_DESTRUCTOR_P (decl1
)
12087 || (DECL_CONSTRUCTOR_P (decl1
)
12088 && targetm
.cxx
.cdtor_returns_this ()))
12090 cdtor_label
= build_decl (input_location
,
12091 LABEL_DECL
, NULL_TREE
, NULL_TREE
);
12092 DECL_CONTEXT (cdtor_label
) = current_function_decl
;
12095 start_fname_decls ();
12097 store_parm_decls (current_function_parms
);
12101 /* Like start_preparsed_function, except that instead of a
12102 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
12104 Returns 1 on success. If the DECLARATOR is not suitable for a function
12105 (it defines a datum instead), we return 0, which tells
12106 yyparse to report a parse error. */
12109 start_function (cp_decl_specifier_seq
*declspecs
,
12110 const cp_declarator
*declarator
,
12115 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, &attrs
);
12116 if (decl1
== error_mark_node
)
12118 /* If the declarator is not suitable for a function definition,
12119 cause a syntax error. */
12120 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
)
12122 error ("invalid function declaration");
12126 if (DECL_MAIN_P (decl1
))
12127 /* main must return int. grokfndecl should have corrected it
12128 (and issued a diagnostic) if the user got it wrong. */
12129 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1
)),
12130 integer_type_node
));
12132 start_preparsed_function (decl1
, attrs
, /*flags=*/SF_DEFAULT
);
12137 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
12141 use_eh_spec_block (tree fn
)
12143 return (flag_exceptions
&& flag_enforce_eh_specs
12144 && !processing_template_decl
12145 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
))
12146 /* We insert the EH_SPEC_BLOCK only in the original
12147 function; then, it is copied automatically to the
12149 && !DECL_CLONED_FUNCTION_P (fn
)
12150 /* Implicitly-generated constructors and destructors have
12151 exception specifications. However, those specifications
12152 are the union of the possible exceptions specified by the
12153 constructors/destructors for bases and members, so no
12154 unallowed exception will ever reach this function. By
12155 not creating the EH_SPEC_BLOCK we save a little memory,
12156 and we avoid spurious warnings about unreachable
12158 && !DECL_ARTIFICIAL (fn
));
12161 /* Store the parameter declarations into the current function declaration.
12162 This is called after parsing the parameter declarations, before
12163 digesting the body of the function.
12165 Also install to binding contour return value identifier, if any. */
12168 store_parm_decls (tree current_function_parms
)
12170 tree fndecl
= current_function_decl
;
12173 /* This is a chain of any other decls that came in among the parm
12174 declarations. If a parm is declared with enum {foo, bar} x;
12175 then CONST_DECLs for foo and bar are put here. */
12176 tree nonparms
= NULL_TREE
;
12178 if (current_function_parms
)
12180 /* This case is when the function was defined with an ANSI prototype.
12181 The parms already have decls, so we need not do anything here
12182 except record them as in effect
12183 and complain if any redundant old-style parm decls were written. */
12185 tree specparms
= current_function_parms
;
12188 /* Must clear this because it might contain TYPE_DECLs declared
12190 current_binding_level
->names
= NULL
;
12192 /* If we're doing semantic analysis, then we'll call pushdecl
12193 for each of these. We must do them in reverse order so that
12194 they end in the correct forward order. */
12195 specparms
= nreverse (specparms
);
12197 for (parm
= specparms
; parm
; parm
= next
)
12199 next
= TREE_CHAIN (parm
);
12200 if (TREE_CODE (parm
) == PARM_DECL
)
12202 if (DECL_NAME (parm
) == NULL_TREE
12203 || TREE_CODE (parm
) != VOID_TYPE
)
12206 error ("parameter %qD declared void", parm
);
12210 /* If we find an enum constant or a type tag,
12211 put it aside for the moment. */
12212 TREE_CHAIN (parm
) = NULL_TREE
;
12213 nonparms
= chainon (nonparms
, parm
);
12217 /* Get the decls in their original chain order and record in the
12218 function. This is all and only the PARM_DECLs that were
12219 pushed into scope by the loop above. */
12220 DECL_ARGUMENTS (fndecl
) = getdecls ();
12223 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
12225 /* Now store the final chain of decls for the arguments
12226 as the decl-chain of the current lexical scope.
12227 Put the enumerators in as well, at the front so that
12228 DECL_ARGUMENTS is not modified. */
12229 current_binding_level
->names
= chainon (nonparms
, DECL_ARGUMENTS (fndecl
));
12231 if (use_eh_spec_block (current_function_decl
))
12232 current_eh_spec_block
= begin_eh_spec_block ();
12236 /* We have finished doing semantic analysis on DECL, but have not yet
12237 generated RTL for its body. Save away our current state, so that
12238 when we want to generate RTL later we know what to do. */
12241 save_function_data (tree decl
)
12243 struct language_function
*f
;
12245 /* Save the language-specific per-function data so that we can
12246 get it back when we really expand this function. */
12247 gcc_assert (!DECL_PENDING_INLINE_P (decl
));
12250 f
= GGC_NEW (struct language_function
);
12251 memcpy (f
, cp_function_chain
, sizeof (struct language_function
));
12252 DECL_SAVED_FUNCTION_DATA (decl
) = f
;
12254 /* Clear out the bits we don't need. */
12255 f
->base
.x_stmt_tree
.x_cur_stmt_list
= NULL_TREE
;
12256 f
->bindings
= NULL
;
12257 f
->x_local_names
= NULL
;
12261 /* Set the return value of the constructor (if present). */
12264 finish_constructor_body (void)
12269 if (targetm
.cxx
.cdtor_returns_this ()
12270 && (! TYPE_FOR_JAVA (current_class_type
)))
12272 /* Any return from a constructor will end up here. */
12273 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
12275 val
= DECL_ARGUMENTS (current_function_decl
);
12276 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
12277 DECL_RESULT (current_function_decl
), val
);
12278 /* Return the address of the object. */
12279 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
12280 add_stmt (exprstmt
);
12284 /* Do all the processing for the beginning of a destructor; set up the
12285 vtable pointers and cleanups for bases and members. */
12288 begin_destructor_body (void)
12290 tree compound_stmt
;
12292 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
12293 issued an error message. We still want to try to process the
12294 body of the function, but initialize_vtbl_ptrs will crash if
12295 TYPE_BINFO is NULL. */
12296 if (COMPLETE_TYPE_P (current_class_type
))
12298 compound_stmt
= begin_compound_stmt (0);
12299 /* Make all virtual function table pointers in non-virtual base
12300 classes point to CURRENT_CLASS_TYPE's virtual function
12302 initialize_vtbl_ptrs (current_class_ptr
);
12303 finish_compound_stmt (compound_stmt
);
12305 /* And insert cleanups for our bases and members so that they
12306 will be properly destroyed if we throw. */
12307 push_base_cleanups ();
12311 /* At the end of every destructor we generate code to delete the object if
12312 necessary. Do that now. */
12315 finish_destructor_body (void)
12319 /* Any return from a destructor will end up here; that way all base
12320 and member cleanups will be run when the function returns. */
12321 add_stmt (build_stmt (input_location
, LABEL_EXPR
, cdtor_label
));
12323 /* In a virtual destructor, we must call delete. */
12324 if (DECL_VIRTUAL_P (current_function_decl
))
12327 tree virtual_size
= cxx_sizeof (current_class_type
);
12331 At the point of definition of a virtual destructor (including
12332 an implicit definition), non-placement operator delete shall
12333 be looked up in the scope of the destructor's class and if
12334 found shall be accessible and unambiguous. */
12335 exprstmt
= build_op_delete_call(DELETE_EXPR
, current_class_ptr
,
12337 /*global_p=*/false,
12338 /*placement=*/NULL_TREE
,
12339 /*alloc_fn=*/NULL_TREE
);
12341 if_stmt
= begin_if_stmt ();
12342 finish_if_stmt_cond (build2 (BIT_AND_EXPR
, integer_type_node
,
12343 current_in_charge_parm
,
12346 finish_expr_stmt (exprstmt
);
12347 finish_then_clause (if_stmt
);
12348 finish_if_stmt (if_stmt
);
12351 if (targetm
.cxx
.cdtor_returns_this ())
12355 val
= DECL_ARGUMENTS (current_function_decl
);
12356 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
12357 DECL_RESULT (current_function_decl
), val
);
12358 /* Return the address of the object. */
12359 exprstmt
= build_stmt (input_location
, RETURN_EXPR
, val
);
12360 add_stmt (exprstmt
);
12364 /* Do the necessary processing for the beginning of a function body, which
12365 in this case includes member-initializers, but not the catch clauses of
12366 a function-try-block. Currently, this means opening a binding level
12367 for the member-initializers (in a ctor) and member cleanups (in a dtor). */
12370 begin_function_body (void)
12374 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
12377 if (processing_template_decl
)
12378 /* Do nothing now. */;
12380 /* Always keep the BLOCK node associated with the outermost pair of
12381 curly braces of a function. These are needed for correct
12382 operation of dwarfout.c. */
12383 keep_next_level (true);
12385 stmt
= begin_compound_stmt (BCS_FN_BODY
);
12387 if (processing_template_decl
)
12388 /* Do nothing now. */;
12389 else if (DECL_DESTRUCTOR_P (current_function_decl
))
12390 begin_destructor_body ();
12395 /* Do the processing for the end of a function body. Currently, this means
12396 closing out the cleanups for fully-constructed bases and members, and in
12397 the case of the destructor, deleting the object if desired. Again, this
12398 is only meaningful for [cd]tors, since they are the only functions where
12399 there is a significant distinction between the main body and any
12400 function catch clauses. Handling, say, main() return semantics here
12401 would be wrong, as flowing off the end of a function catch clause for
12402 main() would also need to return 0. */
12405 finish_function_body (tree compstmt
)
12407 if (compstmt
== NULL_TREE
)
12410 /* Close the block. */
12411 finish_compound_stmt (compstmt
);
12413 if (processing_template_decl
)
12414 /* Do nothing now. */;
12415 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
12416 finish_constructor_body ();
12417 else if (DECL_DESTRUCTOR_P (current_function_decl
))
12418 finish_destructor_body ();
12421 /* Given a function, returns the BLOCK corresponding to the outermost level
12422 of curly braces, skipping the artificial block created for constructor
12426 outer_curly_brace_block (tree fndecl
)
12428 tree block
= BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl
));
12429 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
12430 /* Skip the artificial function body block. */
12431 block
= BLOCK_SUBBLOCKS (block
);
12435 /* Finish up a function declaration and compile that function
12436 all the way to assembler language output. The free the storage
12437 for the function definition.
12439 FLAGS is a bitwise or of the following values:
12441 We just finished processing the body of an in-class inline
12442 function definition. (This processing will have taken place
12443 after the class definition is complete.) */
12446 finish_function (int flags
)
12448 tree fndecl
= current_function_decl
;
12449 tree restype
, ctype
= NULL_TREE
;
12450 int inclass_inline
= (flags
& 2) != 0;
12453 /* When we get some parse errors, we can end up without a
12454 current_function_decl, so cope. */
12455 if (fndecl
== NULL_TREE
)
12456 return error_mark_node
;
12458 gcc_assert (!defer_mark_used_calls
);
12459 defer_mark_used_calls
= true;
12461 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl
)
12462 && DECL_VIRTUAL_P (fndecl
)
12463 && !processing_template_decl
)
12465 tree fnclass
= DECL_CONTEXT (fndecl
);
12466 if (fndecl
== CLASSTYPE_KEY_METHOD (fnclass
))
12467 keyed_classes
= tree_cons (NULL_TREE
, fnclass
, keyed_classes
);
12470 nested
= function_depth
> 1;
12471 restype
= function_return_type (fndecl
);
12473 /* TREE_READONLY (fndecl) = 1;
12474 This caused &foo to be of type ptr-to-const-function
12475 which then got a warning when stored in a ptr-to-function variable. */
12477 gcc_assert (building_stmt_tree ());
12478 /* The current function is being defined, so its DECL_INITIAL should
12479 be set, and unless there's a multiple definition, it should be
12480 error_mark_node. */
12481 gcc_assert (DECL_INITIAL (fndecl
) == error_mark_node
);
12483 /* For a cloned function, we've already got all the code we need;
12484 there's no need to add any extra bits. */
12485 if (!DECL_CLONED_FUNCTION_P (fndecl
))
12487 if (DECL_MAIN_P (current_function_decl
))
12491 /* Make it so that `main' always returns 0 by default (or
12494 stmt
= finish_return_stmt (integer_one_node
);
12496 stmt
= finish_return_stmt (integer_zero_node
);
12498 /* Hack. We don't want the middle-end to warn that this
12499 return is unreachable, so put the statement on the
12502 location_t linezero
= linemap_line_start (line_table
, 0, 1);
12503 SET_EXPR_LOCATION (stmt
, linezero
);
12507 if (use_eh_spec_block (current_function_decl
))
12508 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
12509 (TREE_TYPE (current_function_decl
)),
12510 current_eh_spec_block
);
12513 /* If we're saving up tree structure, tie off the function now. */
12514 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
12516 finish_fname_decls ();
12518 /* If this function can't throw any exceptions, remember that. */
12519 if (!processing_template_decl
12520 && !cp_function_chain
->can_throw
12521 && !flag_non_call_exceptions
12522 && !DECL_REPLACEABLE_P (fndecl
))
12523 TREE_NOTHROW (fndecl
) = 1;
12525 /* This must come after expand_function_end because cleanups might
12526 have declarations (from inline functions) that need to go into
12527 this function's blocks. */
12529 /* If the current binding level isn't the outermost binding level
12530 for this function, either there is a bug, or we have experienced
12531 syntax errors and the statement tree is malformed. */
12532 if (current_binding_level
->kind
!= sk_function_parms
)
12534 /* Make sure we have already experienced errors. */
12535 gcc_assert (errorcount
);
12537 /* Throw away the broken statement tree and extra binding
12539 DECL_SAVED_TREE (fndecl
) = alloc_stmt_list ();
12541 while (current_binding_level
->kind
!= sk_function_parms
)
12543 if (current_binding_level
->kind
== sk_class
)
12544 pop_nested_class ();
12546 poplevel (0, 0, 0);
12549 poplevel (1, 0, 1);
12551 /* Statements should always be full-expressions at the outermost set
12552 of curly braces for a function. */
12553 gcc_assert (stmts_are_full_exprs_p ());
12555 /* Set up the named return value optimization, if we can. Candidate
12556 variables are selected in check_return_expr. */
12557 if (current_function_return_value
)
12559 tree r
= current_function_return_value
;
12562 if (r
!= error_mark_node
12563 /* This is only worth doing for fns that return in memory--and
12564 simpler, since we don't have to worry about promoted modes. */
12565 && aggregate_value_p (restype
, fndecl
)
12566 /* Only allow this for variables declared in the outer scope of
12567 the function so we know that their lifetime always ends with a
12568 return; see g++.dg/opt/nrv6.C. We could be more flexible if
12569 we were to do this optimization in tree-ssa. */
12570 && (outer
= outer_curly_brace_block (fndecl
))
12571 && chain_member (r
, BLOCK_VARS (outer
)))
12572 finalize_nrv (&DECL_SAVED_TREE (fndecl
), r
, DECL_RESULT (fndecl
));
12574 current_function_return_value
= NULL_TREE
;
12577 /* Remember that we were in class scope. */
12578 if (current_class_name
)
12579 ctype
= current_class_type
;
12581 /* Must mark the RESULT_DECL as being in this function. */
12582 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
12584 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
12585 to the FUNCTION_DECL node itself. */
12586 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
12588 /* Save away current state, if appropriate. */
12589 if (!processing_template_decl
)
12590 save_function_data (fndecl
);
12592 /* Complain if there's just no return statement. */
12593 if ((warn_return_type
12594 || DECL_IS_IFUNC (fndecl
))
12595 && TREE_CODE (restype
) != VOID_TYPE
12596 && !dependent_type_p (restype
)
12597 && !current_function_returns_value
&& !current_function_returns_null
12598 /* Don't complain if we abort or throw. */
12599 && !current_function_returns_abnormally
12600 /* Don't complain if we are declared noreturn. */
12601 && !TREE_THIS_VOLATILE (fndecl
)
12602 && !DECL_NAME (DECL_RESULT (fndecl
))
12603 && !TREE_NO_WARNING (fndecl
)
12604 /* Structor return values (if any) are set by the compiler. */
12605 && !DECL_CONSTRUCTOR_P (fndecl
)
12606 && !DECL_DESTRUCTOR_P (fndecl
))
12608 if (DECL_IS_IFUNC (fndecl
))
12609 error ("control reaches end of indirect function");
12611 warning (OPT_Wreturn_type
,
12612 "no return statement in function returning non-void");
12613 TREE_NO_WARNING (fndecl
) = 1;
12616 /* Store the end of the function, so that we get good line number
12617 info for the epilogue. */
12618 cfun
->function_end_locus
= input_location
;
12620 /* Genericize before inlining. */
12621 if (!processing_template_decl
)
12623 struct language_function
*f
= DECL_SAVED_FUNCTION_DATA (fndecl
);
12624 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE
, fndecl
);
12625 cp_genericize (fndecl
);
12626 /* Clear out the bits we don't need. */
12627 f
->x_current_class_ptr
= NULL
;
12628 f
->x_current_class_ref
= NULL
;
12629 f
->x_eh_spec_block
= NULL
;
12630 f
->x_in_charge_parm
= NULL
;
12631 f
->x_vtt_parm
= NULL
;
12632 f
->x_return_value
= NULL
;
12633 f
->bindings
= NULL
;
12634 f
->extern_decl_map
= NULL
;
12636 /* Clear out the bits we don't need. */
12637 local_names
= NULL
;
12639 /* We're leaving the context of this function, so zap cfun. It's still in
12640 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
12642 current_function_decl
= NULL
;
12644 /* If this is an in-class inline definition, we may have to pop the
12645 bindings for the template parameters that we added in
12646 maybe_begin_member_template_processing when start_function was
12648 if (inclass_inline
)
12649 maybe_end_member_template_processing ();
12651 /* Leave the scope of the class. */
12653 pop_nested_class ();
12659 /* Let the error reporting routines know that we're outside a
12660 function. For a nested function, this value is used in
12661 cxx_pop_function_context and then reset via pop_function_context. */
12662 current_function_decl
= NULL_TREE
;
12664 defer_mark_used_calls
= false;
12665 if (deferred_mark_used_calls
)
12670 for (i
= 0; VEC_iterate (tree
, deferred_mark_used_calls
, i
, decl
); i
++)
12672 VEC_free (tree
, gc
, deferred_mark_used_calls
);
12678 /* Create the FUNCTION_DECL for a function definition.
12679 DECLSPECS and DECLARATOR are the parts of the declaration;
12680 they describe the return type and the name of the function,
12681 but twisted together in a fashion that parallels the syntax of C.
12683 This function creates a binding context for the function body
12684 as well as setting up the FUNCTION_DECL in current_function_decl.
12686 Returns a FUNCTION_DECL on success.
12688 If the DECLARATOR is not suitable for a function (it defines a datum
12689 instead), we return 0, which tells yyparse to report a parse error.
12691 May return void_type_node indicating that this method is actually
12692 a friend. See grokfield for more details.
12694 Came here with a `.pushlevel' .
12696 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
12697 CHANGES TO CODE IN `grokfield'. */
12700 grokmethod (cp_decl_specifier_seq
*declspecs
,
12701 const cp_declarator
*declarator
, tree attrlist
)
12703 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
12706 if (fndecl
== error_mark_node
)
12707 return error_mark_node
;
12709 if (fndecl
== NULL
|| TREE_CODE (fndecl
) != FUNCTION_DECL
)
12711 error ("invalid member function declaration");
12712 return error_mark_node
;
12716 cplus_decl_attributes (&fndecl
, attrlist
, 0);
12718 /* Pass friends other than inline friend functions back. */
12719 if (fndecl
== void_type_node
)
12722 if (DECL_IN_AGGR_P (fndecl
))
12724 if (DECL_CONTEXT (fndecl
)
12725 && TREE_CODE (DECL_CONTEXT (fndecl
)) != NAMESPACE_DECL
)
12726 error ("%qD is already defined in class %qT", fndecl
,
12727 DECL_CONTEXT (fndecl
));
12728 return error_mark_node
;
12731 check_template_shadow (fndecl
);
12733 DECL_DECLARED_INLINE_P (fndecl
) = 1;
12734 DECL_NO_INLINE_WARNING_P (fndecl
) = 1;
12736 /* We process method specializations in finish_struct_1. */
12737 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
12739 fndecl
= push_template_decl (fndecl
);
12740 if (fndecl
== error_mark_node
)
12744 if (! DECL_FRIEND_P (fndecl
))
12746 if (TREE_CHAIN (fndecl
))
12748 fndecl
= copy_node (fndecl
);
12749 TREE_CHAIN (fndecl
) = NULL_TREE
;
12753 cp_finish_decl (fndecl
, NULL_TREE
, false, NULL_TREE
, 0);
12755 DECL_IN_AGGR_P (fndecl
) = 1;
12760 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
12761 we can lay it out later, when and if its type becomes complete. */
12764 maybe_register_incomplete_var (tree var
)
12766 gcc_assert (TREE_CODE (var
) == VAR_DECL
);
12768 /* Keep track of variables with incomplete types. */
12769 if (!processing_template_decl
&& TREE_TYPE (var
) != error_mark_node
12770 && DECL_EXTERNAL (var
))
12772 tree inner_type
= TREE_TYPE (var
);
12774 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
12775 inner_type
= TREE_TYPE (inner_type
);
12776 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
12778 if ((!COMPLETE_TYPE_P (inner_type
) && CLASS_TYPE_P (inner_type
))
12779 /* RTTI TD entries are created while defining the type_info. */
12780 || (TYPE_LANG_SPECIFIC (inner_type
)
12781 && TYPE_BEING_DEFINED (inner_type
)))
12782 incomplete_vars
= tree_cons (inner_type
, var
, incomplete_vars
);
12786 /* Called when a class type (given by TYPE) is defined. If there are
12787 any existing VAR_DECLs whose type has been completed by this
12788 declaration, update them now. */
12791 complete_vars (tree type
)
12793 tree
*list
= &incomplete_vars
;
12795 gcc_assert (CLASS_TYPE_P (type
));
12798 if (same_type_p (type
, TREE_PURPOSE (*list
)))
12800 tree var
= TREE_VALUE (*list
);
12801 tree type
= TREE_TYPE (var
);
12802 /* Complete the type of the variable. The VAR_DECL itself
12803 will be laid out in expand_expr. */
12804 complete_type (type
);
12805 cp_apply_type_quals_to_decl (cp_type_quals (type
), var
);
12806 /* Remove this entry from the list. */
12807 *list
= TREE_CHAIN (*list
);
12810 list
= &TREE_CHAIN (*list
);
12813 /* Check for pending declarations which may have abstract type. */
12814 complete_type_check_abstract (type
);
12817 /* If DECL is of a type which needs a cleanup, build and return an
12818 expression to perform that cleanup here. Return NULL_TREE if no
12819 cleanup need be done. */
12822 cxx_maybe_build_cleanup (tree decl
)
12828 /* Assume no cleanup is required. */
12829 cleanup
= NULL_TREE
;
12831 if (error_operand_p (decl
))
12834 /* Handle "__attribute__((cleanup))". We run the cleanup function
12835 before the destructor since the destructor is what actually
12836 terminates the lifetime of the object. */
12837 attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
12844 /* Get the name specified by the user for the cleanup function. */
12845 id
= TREE_VALUE (TREE_VALUE (attr
));
12846 /* Look up the name to find the cleanup function to call. It is
12847 important to use lookup_name here because that is what is
12848 used in c-common.c:handle_cleanup_attribute when performing
12849 initial checks on the attribute. Note that those checks
12850 include ensuring that the function found is not an overloaded
12851 function, or an object with an overloaded call operator,
12852 etc.; we can rely on the fact that the function found is an
12853 ordinary FUNCTION_DECL. */
12854 fn
= lookup_name (id
);
12855 arg
= build_address (decl
);
12857 cleanup
= cp_build_function_call (fn
, build_tree_list (NULL_TREE
,
12859 tf_warning_or_error
);
12861 /* Handle ordinary C++ destructors. */
12862 type
= TREE_TYPE (decl
);
12863 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
12865 int flags
= LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
;
12866 bool has_vbases
= (TREE_CODE (type
) == RECORD_TYPE
12867 && CLASSTYPE_VBASECLASSES (type
));
12871 if (TREE_CODE (type
) == ARRAY_TYPE
)
12874 addr
= build_address (decl
);
12876 /* Optimize for space over speed here. */
12877 if (!has_vbases
|| flag_expensive_optimizations
)
12878 flags
|= LOOKUP_NONVIRTUAL
;
12880 call
= build_delete (TREE_TYPE (addr
), addr
,
12881 sfk_complete_destructor
, flags
, 0);
12883 cleanup
= build_compound_expr (input_location
, cleanup
, call
);
12891 /* When a stmt has been parsed, this function is called. */
12898 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
12899 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
12900 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
12903 static_fn_type (tree memfntype
)
12909 if (TYPE_PTRMEMFUNC_P (memfntype
))
12910 memfntype
= TYPE_PTRMEMFUNC_FN_TYPE (memfntype
);
12911 if (POINTER_TYPE_P (memfntype
)
12912 || TREE_CODE (memfntype
) == FUNCTION_DECL
)
12913 memfntype
= TREE_TYPE (memfntype
);
12914 if (TREE_CODE (memfntype
) == FUNCTION_TYPE
)
12916 gcc_assert (TREE_CODE (memfntype
) == METHOD_TYPE
);
12917 args
= TYPE_ARG_TYPES (memfntype
);
12918 fntype
= build_function_type (TREE_TYPE (memfntype
), TREE_CHAIN (args
));
12919 quals
= cp_type_quals (TREE_TYPE (TREE_VALUE (args
)));
12920 fntype
= build_qualified_type (fntype
, quals
);
12921 fntype
= (cp_build_type_attribute_variant
12922 (fntype
, TYPE_ATTRIBUTES (memfntype
)));
12923 fntype
= (build_exception_variant
12924 (fntype
, TYPE_RAISES_EXCEPTIONS (memfntype
)));
12928 /* DECL was originally constructed as a non-static member function,
12929 but turned out to be static. Update it accordingly. */
12932 revert_static_member_fn (tree decl
)
12934 TREE_TYPE (decl
) = static_fn_type (decl
);
12936 if (cp_type_quals (TREE_TYPE (decl
)) != TYPE_UNQUALIFIED
)
12937 error ("static member function %q#D declared with type qualifiers", decl
);
12939 if (DECL_ARGUMENTS (decl
))
12940 DECL_ARGUMENTS (decl
) = TREE_CHAIN (DECL_ARGUMENTS (decl
));
12941 DECL_STATIC_FUNCTION_P (decl
) = 1;
12944 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
12945 one of the language-independent trees. */
12947 enum cp_tree_node_structure_enum
12948 cp_tree_node_structure (union lang_tree_node
* t
)
12950 switch (TREE_CODE (&t
->generic
))
12952 case DEFAULT_ARG
: return TS_CP_DEFAULT_ARG
;
12953 case IDENTIFIER_NODE
: return TS_CP_IDENTIFIER
;
12954 case OVERLOAD
: return TS_CP_OVERLOAD
;
12955 case TEMPLATE_PARM_INDEX
: return TS_CP_TPI
;
12956 case PTRMEM_CST
: return TS_CP_PTRMEM
;
12957 case BASELINK
: return TS_CP_BASELINK
;
12958 case STATIC_ASSERT
: return TS_CP_STATIC_ASSERT
;
12959 case ARGUMENT_PACK_SELECT
: return TS_CP_ARGUMENT_PACK_SELECT
;
12960 case TRAIT_EXPR
: return TS_CP_TRAIT_EXPR
;
12961 case LAMBDA_EXPR
: return TS_CP_LAMBDA_EXPR
;
12962 case TEMPLATE_INFO
: return TS_CP_TEMPLATE_INFO
;
12963 default: return TS_CP_GENERIC
;
12967 /* Build the void_list_node (void_type_node having been created). */
12969 build_void_list_node (void)
12971 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
12976 cp_missing_noreturn_ok_p (tree decl
)
12978 /* A missing noreturn is ok for the `main' function. */
12979 return DECL_MAIN_P (decl
);
12982 /* Return the COMDAT group into which DECL should be placed. */
12985 cxx_comdat_group (tree decl
)
12989 /* Virtual tables, construction virtual tables, and virtual table
12990 tables all go in a single COMDAT group, named after the primary
12992 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_VTABLE_OR_VTT_P (decl
))
12993 name
= DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl
)));
12994 /* For all other DECLs, the COMDAT group is the mangled name of the
12995 declaration itself. */
12998 while (DECL_THUNK_P (decl
))
13000 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
13001 into the same section as the target function. In that case
13002 we must return target's name. */
13003 tree target
= THUNK_TARGET (decl
);
13004 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target
)
13005 && DECL_SECTION_NAME (target
) != NULL
13006 && DECL_ONE_ONLY (target
))
13011 name
= DECL_ASSEMBLER_NAME (decl
);
13017 #include "gt-cp-decl.h"