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 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
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"
50 #include "diagnostic.h"
53 #include "tree-flow.h"
55 static tree
grokparms (cp_parameter_declarator
*, tree
*);
56 static const char *redeclaration_error_message (tree
, tree
);
58 static int decl_jump_unsafe (tree
);
59 static void require_complete_types_for_parms (tree
);
60 static int ambi_op_p (enum tree_code
);
61 static int unary_op_p (enum tree_code
);
62 static void push_local_name (tree
);
63 static tree
grok_reference_init (tree
, tree
, tree
, tree
*);
64 static tree
grokfndecl (tree
, tree
, tree
, tree
, tree
, int,
65 enum overload_flags
, cp_cv_quals
,
66 tree
, int, int, int, int, int, int, tree
);
67 static tree
grokvardecl (tree
, tree
, const cp_decl_specifier_seq
*,
69 static void record_unknown_type (tree
, const char *);
70 static tree
builtin_function_1 (const char *, tree
, tree
,
71 enum built_in_function code
,
72 enum built_in_class cl
, const char *,
74 static tree
build_library_fn_1 (tree
, enum tree_code
, tree
);
75 static int member_function_or_else (tree
, tree
, enum overload_flags
);
76 static void bad_specifiers (tree
, const char *, int, int, int, int,
78 static void check_for_uninitialized_const_var (tree
);
79 static hashval_t
typename_hash (const void *);
80 static int typename_compare (const void *, const void *);
81 static tree
local_variable_p_walkfn (tree
*, int *, void *);
82 static tree
record_builtin_java_type (const char *, int);
83 static const char *tag_name (enum tag_types code
);
84 static int walk_namespaces_r (tree
, walk_namespaces_fn
, void *);
85 static int walk_globals_r (tree
, void*);
86 static int walk_vtables_r (tree
, void*);
87 static tree
make_label_decl (tree
, int);
88 static void use_label (tree
);
89 static void check_previous_goto_1 (tree
, struct cp_binding_level
*, tree
,
91 static void check_previous_goto (struct named_label_use_list
*);
92 static void check_switch_goto (struct cp_binding_level
*);
93 static void check_previous_gotos (tree
);
94 static void pop_label (tree
, tree
);
95 static void pop_labels (tree
);
96 static void maybe_deduce_size_from_array_init (tree
, tree
);
97 static void layout_var_decl (tree
);
98 static void maybe_commonize_var (tree
);
99 static tree
check_initializer (tree
, tree
, int, tree
*);
100 static void make_rtl_for_nonlocal_decl (tree
, tree
, const char *);
101 static void save_function_data (tree
);
102 static void check_function_type (tree
, tree
);
103 static void finish_constructor_body (void);
104 static void begin_destructor_body (void);
105 static void finish_destructor_body (void);
106 static tree
create_array_type_for_decl (tree
, tree
, tree
);
107 static tree
get_atexit_node (void);
108 static tree
get_dso_handle_node (void);
109 static tree
start_cleanup_fn (void);
110 static void end_cleanup_fn (void);
111 static tree
cp_make_fname_decl (tree
, int);
112 static void initialize_predefined_identifiers (void);
113 static tree check_special_function_return_type
114 (special_function_kind
, tree
, tree
);
115 static tree
push_cp_library_fn (enum tree_code
, tree
);
116 static tree
build_cp_library_fn (tree
, enum tree_code
, tree
);
117 static void store_parm_decls (tree
);
118 static void initialize_local_var (tree
, tree
);
119 static void expand_static_init (tree
, tree
);
120 static tree
next_initializable_field (tree
);
121 static tree
reshape_init (tree
, tree
*);
122 static tree
build_typename_type (tree
, tree
, tree
);
124 /* Erroneous argument lists can use this *IFF* they do not modify it. */
125 tree error_mark_list
;
127 /* The following symbols are subsumed in the cp_global_trees array, and
128 listed here individually for documentation purposes.
131 tree wchar_decl_node;
133 tree vtable_entry_type;
134 tree delta_type_node;
135 tree __t_desc_type_node;
136 tree ti_desc_type_node;
137 tree bltn_desc_type_node, ptr_desc_type_node;
138 tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
139 tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
140 tree ptm_desc_type_node;
141 tree base_desc_type_node;
143 tree class_type_node;
144 tree unknown_type_node;
146 Array type `vtable_entry_type[]'
149 tree vtbl_ptr_type_node;
156 A FUNCTION_DECL which can call `abort'. Not necessarily the
157 one that the user will declare, but sufficient to be called
158 by routines that want to abort the program.
162 The FUNCTION_DECL for the default `::operator delete'.
164 tree global_delete_fndecl;
167 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
172 tree cp_global_trees
[CPTI_MAX
];
174 /* Indicates that there is a type value in some namespace, although
175 that is not necessarily in scope at the moment. */
177 tree global_type_node
;
179 /* The node that holds the "name" of the global scope. */
180 tree global_scope_name
;
182 /* Used only for jumps to as-yet undefined labels, since jumps to
183 defined labels can have their validity checked immediately. */
185 struct named_label_use_list
GTY(())
187 struct cp_binding_level
*binding_level
;
190 location_t o_goto_locus
;
191 struct named_label_use_list
*next
;
194 #define named_label_uses cp_function_chain->x_named_label_uses
196 #define local_names cp_function_chain->x_local_names
198 /* A list of objects which have constructors or destructors
199 which reside in the global scope. The decl is stored in
200 the TREE_VALUE slot and the initializer is stored
201 in the TREE_PURPOSE slot. */
202 tree static_aggregates
;
206 /* A node for the integer constants 2, and 3. */
208 tree integer_two_node
, integer_three_node
;
210 /* A list of all LABEL_DECLs in the function that have names. Here so
211 we can clear out their names' definitions at the end of the
212 function, and so we can check the validity of jumps to these labels. */
214 struct named_label_list
GTY(())
216 struct cp_binding_level
*binding_level
;
221 struct named_label_list
*next
;
222 unsigned int in_try_scope
: 1;
223 unsigned int in_catch_scope
: 1;
226 #define named_labels cp_function_chain->x_named_labels
228 /* The number of function bodies which we are currently processing.
229 (Zero if we are at namespace scope, one inside the body of a
230 function, two inside the body of a function in a local class, etc.) */
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
238 enum deprecated_states
{
243 static enum deprecated_states deprecated_state
= DEPRECATED_NORMAL
;
245 /* True if a declaration with an `extern' linkage specifier is being
247 bool have_extern_spec
;
250 /* A TREE_LIST of VAR_DECLs. The TREE_PURPOSE is a RECORD_TYPE or
251 UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type. At the
252 time the VAR_DECL was declared, the type was incomplete. */
254 static GTY(()) tree incomplete_vars
;
256 /* Returns the kind of template specialization we are currently
257 processing, given that it's declaration contained N_CLASS_SCOPES
258 explicit scope qualifications. */
261 current_tmpl_spec_kind (int n_class_scopes
)
263 int n_template_parm_scopes
= 0;
264 int seen_specialization_p
= 0;
265 int innermost_specialization_p
= 0;
266 struct cp_binding_level
*b
;
268 /* Scan through the template parameter scopes. */
269 for (b
= current_binding_level
;
270 b
->kind
== sk_template_parms
;
273 /* If we see a specialization scope inside a parameter scope,
274 then something is wrong. That corresponds to a declaration
277 template <class T> template <> ...
279 which is always invalid since [temp.expl.spec] forbids the
280 specialization of a class member template if the enclosing
281 class templates are not explicitly specialized as well. */
282 if (b
->explicit_spec_p
)
284 if (n_template_parm_scopes
== 0)
285 innermost_specialization_p
= 1;
287 seen_specialization_p
= 1;
289 else if (seen_specialization_p
== 1)
290 return tsk_invalid_member_spec
;
292 ++n_template_parm_scopes
;
295 /* Handle explicit instantiations. */
296 if (processing_explicit_instantiation
)
298 if (n_template_parm_scopes
!= 0)
299 /* We've seen a template parameter list during an explicit
300 instantiation. For example:
302 template <class T> template void f(int);
304 This is erroneous. */
305 return tsk_invalid_expl_inst
;
307 return tsk_expl_inst
;
310 if (n_template_parm_scopes
< n_class_scopes
)
311 /* We've not seen enough template headers to match all the
312 specialized classes present. For example:
314 template <class T> void R<T>::S<T>::f(int);
316 This is invalid; there needs to be one set of template
317 parameters for each class. */
318 return tsk_insufficient_parms
;
319 else if (n_template_parm_scopes
== n_class_scopes
)
320 /* We're processing a non-template declaration (even though it may
321 be a member of a template class.) For example:
323 template <class T> void S<T>::f(int);
325 The `class T' maches the `S<T>', leaving no template headers
326 corresponding to the `f'. */
328 else if (n_template_parm_scopes
> n_class_scopes
+ 1)
329 /* We've got too many template headers. For example:
331 template <> template <class T> void f (T);
333 There need to be more enclosing classes. */
334 return tsk_excessive_parms
;
336 /* This must be a template. It's of the form:
338 template <class T> template <class U> void S<T>::f(U);
340 This is a specialization if the innermost level was a
341 specialization; otherwise it's just a definition of the
343 return innermost_specialization_p
? tsk_expl_spec
: tsk_template
;
346 /* Exit the current scope. */
354 /* When a label goes out of scope, check to see if that label was used
355 in a valid manner, and issue any appropriate warnings or errors. */
358 pop_label (tree label
, tree old_value
)
360 if (!processing_template_decl
)
362 if (DECL_INITIAL (label
) == NULL_TREE
)
366 cp_error_at ("label `%D' used but not defined", label
);
367 #ifdef USE_MAPPED_LOCATION
368 location
= input_location
; /* FIXME want (input_filename, (line)0) */
370 location
.file
= input_filename
;
373 /* Avoid crashing later. */
374 define_label (location
, DECL_NAME (label
));
376 else if (warn_unused_label
&& !TREE_USED (label
))
377 cp_warning_at ("label `%D' defined but not used", label
);
380 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label
), old_value
);
383 /* At the end of a function, all labels declared within the function
384 go out of scope. BLOCK is the top-level block for the
388 pop_labels (tree block
)
390 struct named_label_list
*link
;
392 /* Clear out the definitions of all label names, since their scopes
394 for (link
= named_labels
; link
; link
= link
->next
)
396 pop_label (link
->label_decl
, link
->old_value
);
397 /* Put the labels into the "variables" of the top-level block,
398 so debugger can see them. */
399 TREE_CHAIN (link
->label_decl
) = BLOCK_VARS (block
);
400 BLOCK_VARS (block
) = link
->label_decl
;
406 /* Exit a binding level.
407 Pop the level off, and restore the state of the identifier-decl mappings
408 that were in effect when this level was entered.
410 If KEEP == 1, this level had explicit declarations, so
411 and create a "block" (a BLOCK node) for the level
412 to record its declarations and subblocks for symbol table output.
414 If FUNCTIONBODY is nonzero, this level is the body of a function,
415 so create a block as if KEEP were set and also clear out all
418 If REVERSE is nonzero, reverse the order of decls before putting
419 them into the BLOCK. */
422 poplevel (int keep
, int reverse
, int functionbody
)
425 /* The chain of decls was accumulated in reverse order.
426 Put it into forward order, just for cleanliness. */
428 int tmp
= functionbody
;
429 int real_functionbody
;
433 int leaving_for_scope
;
436 timevar_push (TV_NAME_LOOKUP
);
441 gcc_assert (current_binding_level
->kind
!= sk_class
);
443 real_functionbody
= (current_binding_level
->kind
== sk_cleanup
444 ? ((functionbody
= 0), tmp
) : functionbody
);
445 subblocks
= functionbody
>= 0 ? current_binding_level
->blocks
: 0;
447 gcc_assert (!VEC_length(cp_class_binding
,
448 current_binding_level
->class_shadowed
));
450 /* We used to use KEEP == 2 to indicate that the new block should go
451 at the beginning of the list of blocks at this binding level,
452 rather than the end. This hack is no longer used. */
453 gcc_assert (keep
== 0 || keep
== 1);
455 if (current_binding_level
->keep
)
458 /* Any uses of undefined labels, and any defined labels, now operate
459 under constraints of next binding contour. */
460 if (cfun
&& !functionbody
)
462 struct cp_binding_level
*level_chain
;
463 level_chain
= current_binding_level
->level_chain
;
466 struct named_label_use_list
*uses
;
467 struct named_label_list
*labels
;
468 for (labels
= named_labels
; labels
; labels
= labels
->next
)
469 if (labels
->binding_level
== current_binding_level
)
472 if (current_binding_level
->kind
== sk_try
)
473 labels
->in_try_scope
= 1;
474 if (current_binding_level
->kind
== sk_catch
)
475 labels
->in_catch_scope
= 1;
476 for (decl
= labels
->names_in_scope
; decl
;
477 decl
= TREE_CHAIN (decl
))
478 if (decl_jump_unsafe (decl
))
479 labels
->bad_decls
= tree_cons (NULL_TREE
, decl
,
481 labels
->binding_level
= level_chain
;
482 labels
->names_in_scope
= level_chain
->names
;
485 for (uses
= named_label_uses
; uses
; uses
= uses
->next
)
486 if (uses
->binding_level
== current_binding_level
)
488 uses
->binding_level
= level_chain
;
489 uses
->names_in_scope
= level_chain
->names
;
494 /* Get the decls in the order they were written.
495 Usually current_binding_level->names is in reverse order.
496 But parameter decls were previously put in forward order. */
499 current_binding_level
->names
500 = decls
= nreverse (current_binding_level
->names
);
502 decls
= current_binding_level
->names
;
504 /* If there were any declarations or structure tags in that level,
505 or if this level is a function body,
506 create a BLOCK to record them for the life of this function. */
508 if (keep
== 1 || functionbody
)
509 block
= make_node (BLOCK
);
510 if (block
!= NULL_TREE
)
512 BLOCK_VARS (block
) = decls
;
513 BLOCK_SUBBLOCKS (block
) = subblocks
;
516 /* In each subblock, record that this is its superior. */
518 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
519 BLOCK_SUPERCONTEXT (link
) = block
;
521 /* We still support the old for-scope rules, whereby the variables
522 in a for-init statement were in scope after the for-statement
523 ended. We only use the new rules if flag_new_for_scope is
526 = current_binding_level
->kind
== sk_for
&& flag_new_for_scope
== 1;
528 /* Before we remove the declarations first check for unused variables. */
529 if (warn_unused_variable
530 && !processing_template_decl
)
531 for (decl
= getdecls (); decl
; decl
= TREE_CHAIN (decl
))
532 if (TREE_CODE (decl
) == VAR_DECL
533 && ! TREE_USED (decl
)
534 && ! DECL_IN_SYSTEM_HEADER (decl
)
535 && DECL_NAME (decl
) && ! DECL_ARTIFICIAL (decl
))
536 warning ("%Junused variable '%D'", decl
, decl
);
538 /* Remove declarations for all the DECLs in this level. */
539 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
541 if (leaving_for_scope
&& TREE_CODE (link
) == VAR_DECL
544 tree name
= DECL_NAME (link
);
548 ob
= outer_binding (name
,
549 IDENTIFIER_BINDING (name
),
552 ns_binding
= IDENTIFIER_NAMESPACE_VALUE (name
);
554 ns_binding
= NULL_TREE
;
556 if (ob
&& ob
->scope
== current_binding_level
->level_chain
)
557 /* We have something like:
562 and we are leaving the `for' scope. There's no reason to
563 keep the binding of the inner `i' in this case. */
564 pop_binding (name
, link
);
565 else if ((ob
&& (TREE_CODE (ob
->value
) == TYPE_DECL
))
566 || (ns_binding
&& TREE_CODE (ns_binding
) == TYPE_DECL
))
567 /* Here, we have something like:
575 We must pop the for-scope binding so we know what's a
576 type and what isn't. */
577 pop_binding (name
, link
);
580 /* Mark this VAR_DECL as dead so that we can tell we left it
581 there only for backward compatibility. */
582 DECL_DEAD_FOR_LOCAL (link
) = 1;
584 /* Keep track of what should have happened when we
585 popped the binding. */
587 DECL_SHADOWED_FOR_VAR (link
) = ob
->value
;
589 /* Add it to the list of dead variables in the next
590 outermost binding to that we can remove these when we
591 leave that binding. */
592 current_binding_level
->level_chain
->dead_vars_from_for
593 = tree_cons (NULL_TREE
, link
,
594 current_binding_level
->level_chain
->
597 /* Although we don't pop the cxx_binding, we do clear
598 its SCOPE since the scope is going away now. */
599 IDENTIFIER_BINDING (name
)->scope
600 = current_binding_level
->level_chain
;
605 /* Remove the binding. */
608 if (TREE_CODE (decl
) == TREE_LIST
)
609 decl
= TREE_VALUE (decl
);
612 pop_binding (DECL_NAME (decl
), decl
);
613 else if (TREE_CODE (decl
) == OVERLOAD
)
614 pop_binding (DECL_NAME (OVL_FUNCTION (decl
)), decl
);
620 /* Remove declarations for any `for' variables from inner scopes
621 that we kept around. */
622 for (link
= current_binding_level
->dead_vars_from_for
;
623 link
; link
= TREE_CHAIN (link
))
624 pop_binding (DECL_NAME (TREE_VALUE (link
)), TREE_VALUE (link
));
626 /* Restore the IDENTIFIER_TYPE_VALUEs. */
627 for (link
= current_binding_level
->type_shadowed
;
628 link
; link
= TREE_CHAIN (link
))
629 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
631 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
632 for (link
= current_binding_level
->shadowed_labels
;
634 link
= TREE_CHAIN (link
))
635 pop_label (TREE_VALUE (link
), TREE_PURPOSE (link
));
637 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
638 list if a `using' declaration put them there. The debugging
639 back-ends won't understand OVERLOAD, so we remove them here.
640 Because the BLOCK_VARS are (temporarily) shared with
641 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
642 popped all the bindings. */
647 for (d
= &BLOCK_VARS (block
); *d
; )
649 if (TREE_CODE (*d
) == TREE_LIST
)
650 *d
= TREE_CHAIN (*d
);
652 d
= &TREE_CHAIN (*d
);
656 /* If the level being exited is the top level of a function,
657 check over all the labels. */
660 /* Since this is the top level block of a function, the vars are
661 the function's parameters. Don't leave them in the BLOCK
662 because they are found in the FUNCTION_DECL instead. */
663 BLOCK_VARS (block
) = 0;
667 kind
= current_binding_level
->kind
;
668 if (kind
== sk_cleanup
)
672 /* If this is a temporary binding created for a cleanup, then we'll
673 have pushed a statement list level. Pop that, create a new
674 BIND_EXPR for the block, and insert it into the stream. */
675 stmt
= pop_stmt_list (current_binding_level
->statement_list
);
676 stmt
= c_build_bind_expr (block
, stmt
);
682 DECL_INITIAL (current_function_decl
) = block
;
684 current_binding_level
->blocks
685 = chainon (current_binding_level
->blocks
, block
);
687 /* If we did not make a block for the level just exited,
688 any blocks made for inner levels
689 (since they cannot be recorded as subblocks in that level)
690 must be carried forward so they will later become subblocks
691 of something else. */
693 current_binding_level
->blocks
694 = chainon (current_binding_level
->blocks
, subblocks
);
696 /* Each and every BLOCK node created here in `poplevel' is important
697 (e.g. for proper debugging information) so if we created one
698 earlier, mark it as "used". */
700 TREE_USED (block
) = 1;
702 /* All temporary bindings created for cleanups are popped silently. */
703 if (kind
== sk_cleanup
)
706 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, block
);
709 /* Delete the node BLOCK from the current binding level.
710 This is used for the block inside a stmt expr ({...})
711 so that the block can be reinserted where appropriate. */
714 delete_block (tree block
)
717 if (current_binding_level
->blocks
== block
)
718 current_binding_level
->blocks
= TREE_CHAIN (block
);
719 for (t
= current_binding_level
->blocks
; t
;)
721 if (TREE_CHAIN (t
) == block
)
722 TREE_CHAIN (t
) = TREE_CHAIN (block
);
726 TREE_CHAIN (block
) = NULL_TREE
;
727 /* Clear TREE_USED which is always set by poplevel.
728 The flag is set again if insert_block is called. */
729 TREE_USED (block
) = 0;
732 /* Insert BLOCK at the end of the list of subblocks of the
733 current binding level. This is used when a BIND_EXPR is expanded,
734 to handle the BLOCK node inside the BIND_EXPR. */
737 insert_block (tree block
)
739 TREE_USED (block
) = 1;
740 current_binding_level
->blocks
741 = chainon (current_binding_level
->blocks
, block
);
744 /* Returns nonzero if T is a virtual function table. */
747 vtable_decl_p (tree t
, void* data ATTRIBUTE_UNUSED
)
749 return (TREE_CODE (t
) == VAR_DECL
&& DECL_VIRTUAL_P (t
));
752 /* Returns nonzero if T is a TYPE_DECL for a type with virtual
756 vtype_decl_p (tree t
, void *data ATTRIBUTE_UNUSED
)
758 return (TREE_CODE (t
) == TYPE_DECL
759 && TREE_CODE (TREE_TYPE (t
)) == RECORD_TYPE
760 && TYPE_POLYMORPHIC_P (TREE_TYPE (t
)));
763 struct walk_globals_data
{
769 /* Walk the vtable declarations in NAMESPACE. Whenever one is found
770 for which P returns nonzero, call F with its address. If any call
771 to F returns a nonzero value, return a nonzero value. */
774 walk_vtables_r (tree
namespace, void* data
)
776 struct walk_globals_data
* wgd
= (struct walk_globals_data
*) data
;
777 walk_globals_fn f
= wgd
->f
;
779 tree decl
= NAMESPACE_LEVEL (namespace)->vtables
;
782 for (; decl
; decl
= TREE_CHAIN (decl
))
783 result
|= (*f
) (&decl
, d
);
788 /* Walk the vtable declarations. Whenever one is found for which P
789 returns nonzero, call F with its address. If any call to F
790 returns a nonzero value, return a nonzero value. */
792 walk_vtables (walk_globals_pred p
, walk_globals_fn f
, void *data
)
794 struct walk_globals_data wgd
;
799 return walk_namespaces (walk_vtables_r
, &wgd
);
802 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
803 itself, calling F for each. The DATA is passed to F as well. */
806 walk_namespaces_r (tree
namespace, walk_namespaces_fn f
, void* data
)
809 tree current
= NAMESPACE_LEVEL (namespace)->namespaces
;
811 result
|= (*f
) (namespace, data
);
813 for (; current
; current
= TREE_CHAIN (current
))
814 result
|= walk_namespaces_r (current
, f
, data
);
819 /* Walk all the namespaces, calling F for each. The DATA is passed to
823 walk_namespaces (walk_namespaces_fn f
, void* data
)
825 return walk_namespaces_r (global_namespace
, f
, data
);
828 /* Walk the global declarations in NAMESPACE. Whenever one is found
829 for which P returns nonzero, call F with its address. If any call
830 to F returns a nonzero value, return a nonzero value. */
833 walk_globals_r (tree
namespace, void* data
)
835 struct walk_globals_data
* wgd
= (struct walk_globals_data
*) data
;
836 walk_globals_pred p
= wgd
->p
;
837 walk_globals_fn f
= wgd
->f
;
842 t
= &NAMESPACE_LEVEL (namespace)->names
;
849 result
|= (*f
) (t
, d
);
851 /* If F changed *T, then *T still points at the next item to
854 t
= &TREE_CHAIN (*t
);
860 /* Walk the global declarations. Whenever one is found for which P
861 returns true, call F with its address. If any call to F
862 returns true, return true. */
865 walk_globals (walk_globals_pred p
, walk_globals_fn f
, void *data
)
867 struct walk_globals_data wgd
;
872 return walk_namespaces (walk_globals_r
, &wgd
);
875 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
876 DATA is non-NULL, this is the last time we will call
877 wrapup_global_declarations for this NAMESPACE. */
880 wrapup_globals_for_namespace (tree
namespace, void* data
)
882 struct cp_binding_level
*level
= NAMESPACE_LEVEL (namespace);
883 varray_type statics
= level
->static_decls
;
884 tree
*vec
= &VARRAY_TREE (statics
, 0);
885 int len
= VARRAY_ACTIVE_SIZE (statics
);
886 int last_time
= (data
!= 0);
890 check_global_declarations (vec
, len
);
894 /* Write out any globals that need to be output. */
895 return wrapup_global_declarations (vec
, len
);
899 /* In C++, you don't have to write `struct S' to refer to `S'; you
900 can just use `S'. We accomplish this by creating a TYPE_DECL as
901 if the user had written `typedef struct S S'. Create and return
902 the TYPE_DECL for TYPE. */
905 create_implicit_typedef (tree name
, tree type
)
909 decl
= build_decl (TYPE_DECL
, name
, type
);
910 DECL_ARTIFICIAL (decl
) = 1;
911 /* There are other implicit type declarations, like the one *within*
912 a class that allows you to write `S::S'. We must distinguish
914 SET_DECL_IMPLICIT_TYPEDEF_P (decl
);
915 TYPE_NAME (type
) = decl
;
920 /* Remember a local name for name-mangling purposes. */
923 push_local_name (tree decl
)
928 timevar_push (TV_NAME_LOOKUP
);
930 VARRAY_TREE_INIT (local_names
, 8, "local_names");
932 name
= DECL_NAME (decl
);
934 nelts
= VARRAY_ACTIVE_SIZE (local_names
);
935 for (i
= 0; i
< nelts
; i
++)
937 t
= VARRAY_TREE (local_names
, i
);
938 if (DECL_NAME (t
) == name
)
940 if (!DECL_LANG_SPECIFIC (decl
))
941 retrofit_lang_decl (decl
);
942 DECL_LANG_SPECIFIC (decl
)->decl_flags
.u2sel
= 1;
943 if (DECL_LANG_SPECIFIC (t
))
944 DECL_DISCRIMINATOR (decl
) = DECL_DISCRIMINATOR (t
) + 1;
946 DECL_DISCRIMINATOR (decl
) = 1;
948 VARRAY_TREE (local_names
, i
) = decl
;
949 timevar_pop (TV_NAME_LOOKUP
);
954 VARRAY_PUSH_TREE (local_names
, decl
);
955 timevar_pop (TV_NAME_LOOKUP
);
958 /* Subroutine of duplicate_decls: return truthvalue of whether
959 or not types of these decls match.
961 For C++, we must compare the parameter list so that `int' can match
962 `int&' in a parameter position, but `int&' is not confused with
966 decls_match (tree newdecl
, tree olddecl
)
970 if (newdecl
== olddecl
)
973 if (TREE_CODE (newdecl
) != TREE_CODE (olddecl
))
974 /* If the two DECLs are not even the same kind of thing, we're not
975 interested in their types. */
978 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
980 tree f1
= TREE_TYPE (newdecl
);
981 tree f2
= TREE_TYPE (olddecl
);
982 tree p1
= TYPE_ARG_TYPES (f1
);
983 tree p2
= TYPE_ARG_TYPES (f2
);
985 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
986 && ! (DECL_EXTERN_C_P (newdecl
)
987 && DECL_EXTERN_C_P (olddecl
)))
990 if (TREE_CODE (f1
) != TREE_CODE (f2
))
993 if (same_type_p (TREE_TYPE (f1
), TREE_TYPE (f2
)))
995 if (p2
== NULL_TREE
&& DECL_EXTERN_C_P (olddecl
)
996 && (DECL_BUILT_IN (olddecl
)
997 #ifndef NO_IMPLICIT_EXTERN_C
998 || (DECL_IN_SYSTEM_HEADER (newdecl
) && !DECL_CLASS_SCOPE_P (newdecl
))
999 || (DECL_IN_SYSTEM_HEADER (olddecl
) && !DECL_CLASS_SCOPE_P (olddecl
))
1003 types_match
= self_promoting_args_p (p1
);
1004 if (p1
== void_list_node
)
1005 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
1007 #ifndef NO_IMPLICIT_EXTERN_C
1008 else if (p1
== NULL_TREE
1009 && (DECL_EXTERN_C_P (olddecl
)
1010 && DECL_IN_SYSTEM_HEADER (olddecl
)
1011 && !DECL_CLASS_SCOPE_P (olddecl
))
1012 && (DECL_EXTERN_C_P (newdecl
)
1013 && DECL_IN_SYSTEM_HEADER (newdecl
)
1014 && !DECL_CLASS_SCOPE_P (newdecl
)))
1016 types_match
= self_promoting_args_p (p2
);
1017 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
1021 types_match
= compparms (p1
, p2
);
1026 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1028 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
))
1029 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)))
1032 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1033 DECL_TEMPLATE_PARMS (olddecl
)))
1036 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1037 types_match
= same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
)),
1038 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
)));
1040 types_match
= decls_match (DECL_TEMPLATE_RESULT (olddecl
),
1041 DECL_TEMPLATE_RESULT (newdecl
));
1045 if (TREE_TYPE (newdecl
) == error_mark_node
)
1046 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
1047 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
1048 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
1049 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
1052 types_match
= comptypes (TREE_TYPE (newdecl
),
1053 TREE_TYPE (olddecl
),
1054 COMPARE_REDECLARATION
);
1060 /* If NEWDECL is `static' and an `extern' was seen previously,
1061 warn about it. OLDDECL is the previous declaration.
1063 Note that this does not apply to the C++ case of declaring
1064 a variable `extern const' and then later `const'.
1066 Don't complain about built-in functions, since they are beyond
1067 the user's control. */
1070 warn_extern_redeclared_static (tree newdecl
, tree olddecl
)
1074 if (TREE_CODE (newdecl
) == TYPE_DECL
1075 || TREE_CODE (newdecl
) == TEMPLATE_DECL
1076 || TREE_CODE (newdecl
) == CONST_DECL
1077 || TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1080 /* Don't get confused by static member functions; that's a different
1082 if (TREE_CODE (newdecl
) == FUNCTION_DECL
1083 && DECL_STATIC_FUNCTION_P (newdecl
))
1086 /* If the old declaration was `static', or the new one isn't, then
1087 then everything is OK. */
1088 if (DECL_THIS_STATIC (olddecl
) || !DECL_THIS_STATIC (newdecl
))
1091 /* It's OK to declare a builtin function as `static'. */
1092 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1093 && DECL_ARTIFICIAL (olddecl
))
1096 name
= DECL_ASSEMBLER_NAME (newdecl
);
1097 pedwarn ("`%D' was declared `extern' and later `static'", newdecl
);
1098 cp_pedwarn_at ("previous declaration of `%D'", olddecl
);
1101 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1102 If the redeclaration is invalid, a diagnostic is issued, and the
1103 error_mark_node is returned. Otherwise, OLDDECL is returned.
1105 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1109 duplicate_decls (tree newdecl
, tree olddecl
)
1111 unsigned olddecl_uid
= DECL_UID (olddecl
);
1112 int olddecl_friend
= 0, types_match
= 0;
1113 int new_defines_function
= 0;
1115 if (newdecl
== olddecl
)
1118 types_match
= decls_match (newdecl
, olddecl
);
1120 /* If either the type of the new decl or the type of the old decl is an
1121 error_mark_node, then that implies that we have already issued an
1122 error (earlier) for some bogus type specification, and in that case,
1123 it is rather pointless to harass the user with yet more error message
1124 about the same declaration, so just pretend the types match here. */
1125 if (TREE_TYPE (newdecl
) == error_mark_node
1126 || TREE_TYPE (olddecl
) == error_mark_node
)
1129 if (DECL_P (olddecl
)
1130 && TREE_CODE (newdecl
) == FUNCTION_DECL
1131 && TREE_CODE (olddecl
) == FUNCTION_DECL
1132 && (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
)))
1134 if (DECL_DECLARED_INLINE_P (newdecl
)
1135 && DECL_UNINLINABLE (newdecl
)
1136 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
1137 /* Already warned elsewhere. */;
1138 else if (DECL_DECLARED_INLINE_P (olddecl
)
1139 && DECL_UNINLINABLE (olddecl
)
1140 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
1141 /* Already warned. */;
1142 else if (DECL_DECLARED_INLINE_P (newdecl
)
1143 && DECL_UNINLINABLE (olddecl
)
1144 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
1146 warning ("%Jfunction '%D' redeclared as inline", newdecl
, newdecl
);
1147 warning ("%Jprevious declaration of '%D' with attribute noinline",
1150 else if (DECL_DECLARED_INLINE_P (olddecl
)
1151 && DECL_UNINLINABLE (newdecl
)
1152 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
1154 warning ("%Jfunction '%D' redeclared with attribute noinline",
1156 warning ("%Jprevious declaration of '%D' was inline",
1161 /* Check for redeclaration and other discrepancies. */
1162 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1163 && DECL_ARTIFICIAL (olddecl
))
1165 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
1167 /* Avoid warnings redeclaring anticipated built-ins. */
1168 if (DECL_ANTICIPATED (olddecl
))
1171 /* If you declare a built-in or predefined function name as static,
1172 the old definition is overridden, but optionally warn this was a
1173 bad choice of name. */
1174 if (! TREE_PUBLIC (newdecl
))
1177 warning ("shadowing %s function `%#D'",
1178 DECL_BUILT_IN (olddecl
) ? "built-in" : "library",
1180 /* Discard the old built-in function. */
1183 /* If the built-in is not ansi, then programs can override
1184 it even globally without an error. */
1185 else if (! DECL_BUILT_IN (olddecl
))
1186 warning ("library function `%#D' redeclared as non-function `%#D'",
1190 error ("declaration of `%#D'", newdecl
);
1191 error ("conflicts with built-in declaration `%#D'",
1196 else if (!types_match
)
1198 /* Avoid warnings redeclaring anticipated built-ins. */
1199 if (DECL_ANTICIPATED (olddecl
))
1201 /* Deal with fileptr_type_node. FILE type is not known
1202 at the time we create the builtins. */
1205 for (t1
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1206 t2
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1208 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1211 else if (TREE_VALUE (t2
) == fileptr_type_node
)
1213 tree t
= TREE_VALUE (t1
);
1215 if (TREE_CODE (t
) == POINTER_TYPE
1216 && TYPE_NAME (TREE_TYPE (t
))
1217 && DECL_NAME (TYPE_NAME (TREE_TYPE (t
)))
1218 == get_identifier ("FILE")
1219 && compparms (TREE_CHAIN (t1
), TREE_CHAIN (t2
)))
1221 tree oldargs
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1223 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))
1224 = TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
1225 types_match
= decls_match (newdecl
, olddecl
);
1227 return duplicate_decls (newdecl
, olddecl
);
1228 TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) = oldargs
;
1231 else if (! same_type_p (TREE_VALUE (t1
), TREE_VALUE (t2
)))
1234 else if ((DECL_EXTERN_C_P (newdecl
)
1235 && DECL_EXTERN_C_P (olddecl
))
1236 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1237 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
1239 /* A near match; override the builtin. */
1241 if (TREE_PUBLIC (newdecl
))
1243 warning ("new declaration `%#D'", newdecl
);
1244 warning ("ambiguates built-in declaration `%#D'",
1247 else if (warn_shadow
)
1248 warning ("shadowing %s function `%#D'",
1249 DECL_BUILT_IN (olddecl
) ? "built-in" : "library",
1253 /* Discard the old built-in function. */
1256 /* Replace the old RTL to avoid problems with inlining. */
1257 COPY_DECL_RTL (newdecl
, olddecl
);
1259 /* Even if the types match, prefer the new declarations type
1260 for anticipated built-ins, for exception lists, etc... */
1261 else if (DECL_ANTICIPATED (olddecl
))
1263 tree type
= TREE_TYPE (newdecl
);
1264 tree attribs
= (*targetm
.merge_type_attributes
)
1265 (TREE_TYPE (olddecl
), type
);
1267 type
= cp_build_type_attribute_variant (type
, attribs
);
1268 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = type
;
1271 /* Whether or not the builtin can throw exceptions has no
1272 bearing on this declarator. */
1273 TREE_NOTHROW (olddecl
) = 0;
1275 if (DECL_THIS_STATIC (newdecl
) && !DECL_THIS_STATIC (olddecl
))
1277 /* If a builtin function is redeclared as `static', merge
1278 the declarations, but make the original one static. */
1279 DECL_THIS_STATIC (olddecl
) = 1;
1280 TREE_PUBLIC (olddecl
) = 0;
1282 /* Make the old declaration consistent with the new one so
1283 that all remnants of the builtin-ness of this function
1284 will be banished. */
1285 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
1286 COPY_DECL_RTL (newdecl
, olddecl
);
1289 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
1291 if ((TREE_CODE (olddecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (olddecl
)
1292 && TREE_CODE (newdecl
) != TYPE_DECL
1293 && ! (TREE_CODE (newdecl
) == TEMPLATE_DECL
1294 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
))
1295 || (TREE_CODE (newdecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (newdecl
)
1296 && TREE_CODE (olddecl
) != TYPE_DECL
1297 && ! (TREE_CODE (olddecl
) == TEMPLATE_DECL
1298 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
1301 /* We do nothing special here, because C++ does such nasty
1302 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1303 get shadowed, and know that if we need to find a TYPE_DECL
1304 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1305 slot of the identifier. */
1309 if ((TREE_CODE (newdecl
) == FUNCTION_DECL
1310 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
1311 || (TREE_CODE (olddecl
) == FUNCTION_DECL
1312 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
1315 error ("`%#D' redeclared as different kind of symbol", newdecl
);
1316 if (TREE_CODE (olddecl
) == TREE_LIST
)
1317 olddecl
= TREE_VALUE (olddecl
);
1318 cp_error_at ("previous declaration of `%#D'", olddecl
);
1320 return error_mark_node
;
1322 else if (!types_match
)
1324 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
))
1325 /* These are certainly not duplicate declarations; they're
1326 from different scopes. */
1329 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1331 /* The name of a class template may not be declared to refer to
1332 any other template, class, function, object, namespace, value,
1333 or type in the same scope. */
1334 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
1335 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1337 error ("declaration of template `%#D'", newdecl
);
1338 cp_error_at ("conflicts with previous declaration `%#D'",
1341 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
1342 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
1343 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
1344 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))))
1345 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1346 DECL_TEMPLATE_PARMS (olddecl
))
1347 /* Template functions can be disambiguated by
1349 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl
)),
1350 TREE_TYPE (TREE_TYPE (olddecl
))))
1352 error ("new declaration `%#D'", newdecl
);
1353 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
1357 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1359 if (DECL_EXTERN_C_P (newdecl
) && DECL_EXTERN_C_P (olddecl
))
1361 error ("declaration of C function `%#D' conflicts with",
1363 cp_error_at ("previous declaration `%#D' here", olddecl
);
1365 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1366 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
1368 error ("new declaration `%#D'", newdecl
);
1369 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
1376 error ("conflicting declaration '%#D'", newdecl
);
1377 cp_error_at ("'%D' has a previous declaration as `%#D'",
1382 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1383 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
1384 && (!DECL_TEMPLATE_INFO (newdecl
)
1385 || (DECL_TI_TEMPLATE (newdecl
)
1386 != DECL_TI_TEMPLATE (olddecl
))))
1387 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1388 && (!DECL_TEMPLATE_INFO (olddecl
)
1389 || (DECL_TI_TEMPLATE (olddecl
)
1390 != DECL_TI_TEMPLATE (newdecl
))))))
1391 /* It's OK to have a template specialization and a non-template
1392 with the same type, or to have specializations of two
1393 different templates with the same type. Note that if one is a
1394 specialization, and the other is an instantiation of the same
1395 template, that we do not exit at this point. That situation
1396 can occur if we instantiate a template class, and then
1397 specialize one of its methods. This situation is valid, but
1398 the declarations must be merged in the usual way. */
1400 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1401 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
1402 && !DECL_USE_TEMPLATE (newdecl
))
1403 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
1404 && !DECL_USE_TEMPLATE (olddecl
))))
1405 /* One of the declarations is a template instantiation, and the
1406 other is not a template at all. That's OK. */
1408 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1410 /* In [namespace.alias] we have:
1412 In a declarative region, a namespace-alias-definition can be
1413 used to redefine a namespace-alias declared in that declarative
1414 region to refer only to the namespace to which it already
1417 Therefore, if we encounter a second alias directive for the same
1418 alias, we can just ignore the second directive. */
1419 if (DECL_NAMESPACE_ALIAS (newdecl
)
1420 && (DECL_NAMESPACE_ALIAS (newdecl
)
1421 == DECL_NAMESPACE_ALIAS (olddecl
)))
1423 /* [namespace.alias]
1425 A namespace-name or namespace-alias shall not be declared as
1426 the name of any other entity in the same declarative region.
1427 A namespace-name defined at global scope shall not be
1428 declared as the name of any other entity in any glogal scope
1430 error ("declaration of `namespace %D' conflicts with", newdecl
);
1431 cp_error_at ("previous declaration of `namespace %D' here", olddecl
);
1432 return error_mark_node
;
1436 const char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
1439 error (errmsg
, newdecl
);
1440 if (DECL_NAME (olddecl
) != NULL_TREE
)
1441 cp_error_at ((DECL_INITIAL (olddecl
)
1442 && namespace_bindings_p ())
1443 ? "`%#D' previously defined here"
1444 : "`%#D' previously declared here", olddecl
);
1445 return error_mark_node
;
1447 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1448 && DECL_INITIAL (olddecl
) != NULL_TREE
1449 && TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) == NULL_TREE
1450 && TYPE_ARG_TYPES (TREE_TYPE (newdecl
)) != NULL_TREE
)
1452 /* Prototype decl follows defn w/o prototype. */
1453 cp_warning_at ("prototype for `%#D'", newdecl
);
1454 warning ("%Jfollows non-prototype definition here", olddecl
);
1456 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1457 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
1459 /* extern "C" int foo ();
1460 int foo () { bar (); }
1462 if (current_lang_depth () == 0)
1463 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
1466 cp_error_at ("previous declaration of `%#D' with %L linkage",
1467 olddecl
, DECL_LANGUAGE (olddecl
));
1468 error ("conflicts with new declaration with %L linkage",
1469 DECL_LANGUAGE (newdecl
));
1473 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
1475 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
1477 tree t1
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1478 tree t2
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
1481 if (TREE_CODE (TREE_TYPE (newdecl
)) == METHOD_TYPE
)
1482 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
);
1484 for (; t1
&& t1
!= void_list_node
;
1485 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
1486 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
1488 if (1 == simple_cst_equal (TREE_PURPOSE (t1
),
1491 pedwarn ("default argument given for parameter %d of `%#D'",
1493 cp_pedwarn_at ("after previous specification in `%#D'",
1498 error ("default argument given for parameter %d of `%#D'",
1500 cp_error_at ("after previous specification in `%#D'",
1505 if (DECL_DECLARED_INLINE_P (newdecl
)
1506 && ! DECL_DECLARED_INLINE_P (olddecl
)
1507 && TREE_ADDRESSABLE (olddecl
) && warn_inline
)
1509 warning ("`%#D' was used before it was declared inline", newdecl
);
1510 warning ("%Jprevious non-inline declaration here", olddecl
);
1515 /* Do not merge an implicit typedef with an explicit one. In:
1519 typedef class A A __attribute__ ((foo));
1521 the attribute should apply only to the typedef. */
1522 if (TREE_CODE (olddecl
) == TYPE_DECL
1523 && (DECL_IMPLICIT_TYPEDEF_P (olddecl
)
1524 || DECL_IMPLICIT_TYPEDEF_P (newdecl
)))
1527 /* If new decl is `static' and an `extern' was seen previously,
1529 warn_extern_redeclared_static (newdecl
, olddecl
);
1531 /* We have committed to returning 1 at this point. */
1532 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1534 /* Now that functions must hold information normally held
1535 by field decls, there is extra work to do so that
1536 declaration information does not get destroyed during
1538 if (DECL_VINDEX (olddecl
))
1539 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
1540 if (DECL_CONTEXT (olddecl
))
1541 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
1542 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
1543 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
1544 DECL_PURE_VIRTUAL_P (newdecl
) |= DECL_PURE_VIRTUAL_P (olddecl
);
1545 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
1546 DECL_NEEDS_FINAL_OVERRIDER_P (newdecl
) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl
);
1547 DECL_THIS_STATIC (newdecl
) |= DECL_THIS_STATIC (olddecl
);
1548 if (DECL_OVERLOADED_OPERATOR_P (olddecl
) != ERROR_MARK
)
1549 SET_OVERLOADED_OPERATOR_CODE
1550 (newdecl
, DECL_OVERLOADED_OPERATOR_P (olddecl
));
1551 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
1553 /* Optionally warn about more than one declaration for the same
1554 name, but don't warn about a function declaration followed by a
1556 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
1557 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
1558 /* Don't warn about extern decl followed by definition. */
1559 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
1560 /* Don't warn about friends, let add_friend take care of it. */
1561 && ! (DECL_FRIEND_P (newdecl
) || DECL_FRIEND_P (olddecl
)))
1563 warning ("redundant redeclaration of `%D' in same scope", newdecl
);
1564 cp_warning_at ("previous declaration of `%D'", olddecl
);
1568 /* Deal with C++: must preserve virtual function table size. */
1569 if (TREE_CODE (olddecl
) == TYPE_DECL
)
1571 tree newtype
= TREE_TYPE (newdecl
);
1572 tree oldtype
= TREE_TYPE (olddecl
);
1574 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
1575 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
1576 CLASSTYPE_FRIEND_CLASSES (newtype
)
1577 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
1579 DECL_ORIGINAL_TYPE (newdecl
) = DECL_ORIGINAL_TYPE (olddecl
);
1582 /* Copy all the DECL_... slots specified in the new decl
1583 except for any that we copy here from the old type. */
1584 DECL_ATTRIBUTES (newdecl
)
1585 = (*targetm
.merge_decl_attributes
) (olddecl
, newdecl
);
1587 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1589 TREE_TYPE (olddecl
) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
));
1590 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
1591 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
1592 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
1594 /* If the new declaration is a definition, update the file and
1595 line information on the declaration. */
1596 if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl
)) == NULL_TREE
1597 && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl
)) != NULL_TREE
)
1599 DECL_SOURCE_LOCATION (olddecl
)
1600 = DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (olddecl
))
1601 = DECL_SOURCE_LOCATION (newdecl
);
1602 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
1603 DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (olddecl
))
1604 = DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (newdecl
));
1607 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
1609 DECL_INLINE (DECL_TEMPLATE_RESULT (olddecl
))
1610 |= DECL_INLINE (DECL_TEMPLATE_RESULT (newdecl
));
1611 DECL_DECLARED_INLINE_P (DECL_TEMPLATE_RESULT (olddecl
))
1612 |= DECL_DECLARED_INLINE_P (DECL_TEMPLATE_RESULT (newdecl
));
1620 /* Automatically handles default parameters. */
1621 tree oldtype
= TREE_TYPE (olddecl
);
1624 /* Merge the data types specified in the two decls. */
1625 newtype
= merge_types (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
1627 /* If merge_types produces a non-typedef type, just use the old type. */
1628 if (TREE_CODE (newdecl
) == TYPE_DECL
1629 && newtype
== DECL_ORIGINAL_TYPE (newdecl
))
1632 if (TREE_CODE (newdecl
) == VAR_DECL
)
1634 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
1635 DECL_INITIALIZED_P (newdecl
) |= DECL_INITIALIZED_P (olddecl
);
1636 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl
)
1637 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl
);
1640 /* Do this after calling `merge_types' so that default
1641 parameters don't confuse us. */
1642 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1643 && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
))
1644 != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl
))))
1646 TREE_TYPE (newdecl
) = build_exception_variant (newtype
,
1647 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
)));
1648 TREE_TYPE (olddecl
) = build_exception_variant (newtype
,
1649 TYPE_RAISES_EXCEPTIONS (oldtype
));
1651 if ((pedantic
|| ! DECL_IN_SYSTEM_HEADER (olddecl
))
1652 && ! DECL_IS_BUILTIN (olddecl
)
1654 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
)),
1655 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl
)), 1))
1657 error ("declaration of `%F' throws different exceptions",
1659 cp_error_at ("than previous declaration `%F'", olddecl
);
1662 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
1664 /* Lay the type out, unless already done. */
1665 if (! same_type_p (newtype
, oldtype
)
1666 && TREE_TYPE (newdecl
) != error_mark_node
1667 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
1668 layout_type (TREE_TYPE (newdecl
));
1670 if ((TREE_CODE (newdecl
) == VAR_DECL
1671 || TREE_CODE (newdecl
) == PARM_DECL
1672 || TREE_CODE (newdecl
) == RESULT_DECL
1673 || TREE_CODE (newdecl
) == FIELD_DECL
1674 || TREE_CODE (newdecl
) == TYPE_DECL
)
1675 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
1676 layout_decl (newdecl
, 0);
1678 /* Merge the type qualifiers. */
1679 if (TREE_READONLY (newdecl
))
1680 TREE_READONLY (olddecl
) = 1;
1681 if (TREE_THIS_VOLATILE (newdecl
))
1682 TREE_THIS_VOLATILE (olddecl
) = 1;
1684 /* Merge the initialization information. */
1685 if (DECL_INITIAL (newdecl
) == NULL_TREE
1686 && DECL_INITIAL (olddecl
) != NULL_TREE
)
1688 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
1689 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
1690 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl
)
1691 && DECL_LANG_SPECIFIC (newdecl
)
1692 && DECL_LANG_SPECIFIC (olddecl
))
1694 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
1695 DECL_STRUCT_FUNCTION (newdecl
) = DECL_STRUCT_FUNCTION (olddecl
);
1699 /* Merge the section attribute.
1700 We want to issue an error if the sections conflict but that must be
1701 done later in decl_attributes since we are called before attributes
1703 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
1704 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
1706 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1708 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
1709 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
1710 DECL_NO_LIMIT_STACK (newdecl
) |= DECL_NO_LIMIT_STACK (olddecl
);
1711 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
1712 TREE_READONLY (newdecl
) |= TREE_READONLY (olddecl
);
1713 TREE_NOTHROW (newdecl
) |= TREE_NOTHROW (olddecl
);
1714 DECL_IS_MALLOC (newdecl
) |= DECL_IS_MALLOC (olddecl
);
1715 DECL_IS_PURE (newdecl
) |= DECL_IS_PURE (olddecl
);
1716 /* Keep the old RTL. */
1717 COPY_DECL_RTL (olddecl
, newdecl
);
1719 else if (TREE_CODE (newdecl
) == VAR_DECL
1720 && (DECL_SIZE (olddecl
) || !DECL_SIZE (newdecl
)))
1722 /* Keep the old RTL. We cannot keep the old RTL if the old
1723 declaration was for an incomplete object and the new
1724 declaration is not since many attributes of the RTL will
1726 COPY_DECL_RTL (olddecl
, newdecl
);
1729 /* If cannot merge, then use the new type and qualifiers,
1730 and don't preserve the old rtl. */
1733 /* Clean out any memory we had of the old declaration. */
1734 tree oldstatic
= value_member (olddecl
, static_aggregates
);
1736 TREE_VALUE (oldstatic
) = error_mark_node
;
1738 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
1739 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
1740 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
1741 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
1744 /* Merge the storage class information. */
1745 merge_weak (newdecl
, olddecl
);
1747 DECL_ONE_ONLY (newdecl
) |= DECL_ONE_ONLY (olddecl
);
1748 DECL_DEFER_OUTPUT (newdecl
) |= DECL_DEFER_OUTPUT (olddecl
);
1749 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
1750 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
1751 if (! DECL_EXTERNAL (olddecl
))
1752 DECL_EXTERNAL (newdecl
) = 0;
1754 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
1756 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
1757 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
1758 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
1759 DECL_TEMPLATE_INSTANTIATED (newdecl
)
1760 |= DECL_TEMPLATE_INSTANTIATED (olddecl
);
1761 /* Don't really know how much of the language-specific
1762 values we should copy from old to new. */
1763 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
1764 DECL_LANG_SPECIFIC (newdecl
)->decl_flags
.u2
=
1765 DECL_LANG_SPECIFIC (olddecl
)->decl_flags
.u2
;
1766 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
1767 DECL_REPO_AVAILABLE_P (newdecl
) = DECL_REPO_AVAILABLE_P (olddecl
);
1768 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
1769 DECL_INITIALIZED_IN_CLASS_P (newdecl
)
1770 |= DECL_INITIALIZED_IN_CLASS_P (olddecl
);
1771 olddecl_friend
= DECL_FRIEND_P (olddecl
);
1773 /* Only functions have DECL_BEFRIENDING_CLASSES. */
1774 if (TREE_CODE (newdecl
) == FUNCTION_DECL
1775 || DECL_FUNCTION_TEMPLATE_P (newdecl
))
1777 DECL_BEFRIENDING_CLASSES (newdecl
)
1778 = chainon (DECL_BEFRIENDING_CLASSES (newdecl
),
1779 DECL_BEFRIENDING_CLASSES (olddecl
));
1780 /* DECL_THUNKS is only valid for virtual functions,
1781 otherwise it is a DECL_FRIEND_CONTEXT. */
1782 if (DECL_VIRTUAL_P (newdecl
))
1783 DECL_THUNKS (newdecl
) = DECL_THUNKS (olddecl
);
1787 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1789 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
1790 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
1792 /* If newdecl is not a specialization, then it is not a
1793 template-related function at all. And that means that we
1794 should have exited above, returning 0. */
1795 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
));
1797 if (TREE_USED (olddecl
))
1798 /* From [temp.expl.spec]:
1800 If a template, a member template or the member of a class
1801 template is explicitly specialized then that
1802 specialization shall be declared before the first use of
1803 that specialization that would cause an implicit
1804 instantiation to take place, in every translation unit in
1805 which such a use occurs. */
1806 error ("explicit specialization of %D after first use",
1809 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
1811 /* [temp.expl.spec/14] We don't inline explicit specialization
1812 just because the primary template says so. */
1816 if (DECL_PENDING_INLINE_INFO (newdecl
) == 0)
1817 DECL_PENDING_INLINE_INFO (newdecl
) = DECL_PENDING_INLINE_INFO (olddecl
);
1819 DECL_DECLARED_INLINE_P (newdecl
) |= DECL_DECLARED_INLINE_P (olddecl
);
1821 /* If either decl says `inline', this fn is inline, unless
1822 its definition was passed already. */
1823 if (DECL_INLINE (newdecl
) && DECL_INITIAL (olddecl
) == NULL_TREE
)
1824 DECL_INLINE (olddecl
) = 1;
1825 DECL_INLINE (newdecl
) = DECL_INLINE (olddecl
);
1827 DECL_UNINLINABLE (newdecl
) = DECL_UNINLINABLE (olddecl
)
1828 = (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
));
1831 /* Preserve abstractness on cloned [cd]tors. */
1832 DECL_ABSTRACT (newdecl
) = DECL_ABSTRACT (olddecl
);
1836 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
1837 COPY_DECL_ASSEMBLER_NAME (newdecl
, olddecl
);
1838 COPY_DECL_RTL (newdecl
, olddecl
);
1840 if (! types_match
|| new_defines_function
)
1842 /* These need to be copied so that the names are available.
1843 Note that if the types do match, we'll preserve inline
1844 info and other bits, but if not, we won't. */
1845 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
1846 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
1848 if (new_defines_function
)
1849 /* If defining a function declared with other language
1850 linkage, use the previously declared language linkage. */
1851 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
1852 else if (types_match
)
1854 /* If redeclaring a builtin function, and not a definition,
1855 it stays built in. */
1856 if (DECL_BUILT_IN (olddecl
))
1858 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
1859 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
1860 /* If we're keeping the built-in definition, keep the rtl,
1861 regardless of declaration matches. */
1862 COPY_DECL_RTL (olddecl
, newdecl
);
1865 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
1866 /* Don't clear out the arguments if we're redefining a function. */
1867 if (DECL_ARGUMENTS (olddecl
))
1868 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
1871 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1872 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
1874 /* Now preserve various other info from the definition. */
1875 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
1876 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
1877 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
1878 COPY_DECL_ASSEMBLER_NAME (olddecl
, newdecl
);
1880 /* Warn about conflicting visibility specifications. */
1881 if (DECL_VISIBILITY_SPECIFIED (olddecl
)
1882 && DECL_VISIBILITY_SPECIFIED (newdecl
)
1883 && DECL_VISIBILITY (newdecl
) != DECL_VISIBILITY (olddecl
))
1885 warning ("%J'%D': visibility attribute ignored because it",
1887 warning ("%Jconflicts with previous declaration here", olddecl
);
1889 /* Choose the declaration which specified visibility. */
1890 if (DECL_VISIBILITY_SPECIFIED (olddecl
))
1892 DECL_VISIBILITY (newdecl
) = DECL_VISIBILITY (olddecl
);
1893 DECL_VISIBILITY_SPECIFIED (newdecl
) = 1;
1896 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1900 function_size
= sizeof (struct tree_decl
);
1902 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
1903 (char *) newdecl
+ sizeof (struct tree_common
),
1904 function_size
- sizeof (struct tree_common
));
1906 if (DECL_TEMPLATE_INSTANTIATION (newdecl
))
1907 /* If newdecl is a template instantiation, it is possible that
1908 the following sequence of events has occurred:
1910 o A friend function was declared in a class template. The
1911 class template was instantiated.
1913 o The instantiation of the friend declaration was
1914 recorded on the instantiation list, and is newdecl.
1916 o Later, however, instantiate_class_template called pushdecl
1917 on the newdecl to perform name injection. But, pushdecl in
1918 turn called duplicate_decls when it discovered that another
1919 declaration of a global function with the same name already
1922 o Here, in duplicate_decls, we decided to clobber newdecl.
1924 If we're going to do that, we'd better make sure that
1925 olddecl, and not newdecl, is on the list of
1926 instantiations so that if we try to do the instantiation
1927 again we won't get the clobbered declaration. */
1928 reregister_specialization (newdecl
,
1929 DECL_TI_TEMPLATE (newdecl
),
1934 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
1935 (char *) newdecl
+ sizeof (struct tree_common
),
1936 sizeof (struct tree_decl
) - sizeof (struct tree_common
)
1937 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
1940 DECL_UID (olddecl
) = olddecl_uid
;
1942 DECL_FRIEND_P (olddecl
) = 1;
1944 /* NEWDECL contains the merged attribute lists.
1945 Update OLDDECL to be the same. */
1946 DECL_ATTRIBUTES (olddecl
) = DECL_ATTRIBUTES (newdecl
);
1948 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
1949 so that encode_section_info has a chance to look at the new decl
1950 flags and attributes. */
1951 if (DECL_RTL_SET_P (olddecl
)
1952 && (TREE_CODE (olddecl
) == FUNCTION_DECL
1953 || (TREE_CODE (olddecl
) == VAR_DECL
1954 && TREE_STATIC (olddecl
))))
1955 make_decl_rtl (olddecl
);
1960 /* Return zero if the declaration NEWDECL is valid
1961 when the declaration OLDDECL (assumed to be for the same name)
1962 has already been seen.
1963 Otherwise return an error message format string with a %s
1964 where the identifier should go. */
1967 redeclaration_error_message (tree newdecl
, tree olddecl
)
1969 if (TREE_CODE (newdecl
) == TYPE_DECL
)
1971 /* Because C++ can put things into name space for free,
1972 constructs like "typedef struct foo { ... } foo"
1973 would look like an erroneous redeclaration. */
1974 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
1977 return "redefinition of `%#D'";
1979 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1981 /* If this is a pure function, its olddecl will actually be
1982 the original initialization to `0' (which we force to call
1983 abort()). Don't complain about redefinition in this case. */
1984 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_PURE_VIRTUAL_P (olddecl
))
1987 /* If both functions come from different namespaces, this is not
1988 a redeclaration - this is a conflict with a used function. */
1989 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
1990 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
))
1991 return "`%D' conflicts with used function";
1993 /* We'll complain about linkage mismatches in
1994 warn_extern_redeclared_static. */
1996 /* Defining the same name twice is no good. */
1997 if (DECL_INITIAL (olddecl
) != NULL_TREE
1998 && DECL_INITIAL (newdecl
) != NULL_TREE
)
2000 if (DECL_NAME (olddecl
) == NULL_TREE
)
2001 return "`%#D' not declared in class";
2003 return "redefinition of `%#D'";
2007 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2011 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2013 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl
))
2014 && COMPLETE_TYPE_P (TREE_TYPE (olddecl
)))
2015 return "redefinition of `%#D'";
2019 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != FUNCTION_DECL
2020 || (DECL_TEMPLATE_RESULT (newdecl
)
2021 == DECL_TEMPLATE_RESULT (olddecl
)))
2024 nt
= DECL_TEMPLATE_RESULT (newdecl
);
2025 if (DECL_TEMPLATE_INFO (nt
))
2026 nt
= DECL_TEMPLATE_RESULT (template_for_substitution (nt
));
2027 ot
= DECL_TEMPLATE_RESULT (olddecl
);
2028 if (DECL_TEMPLATE_INFO (ot
))
2029 ot
= DECL_TEMPLATE_RESULT (template_for_substitution (ot
));
2030 if (DECL_INITIAL (nt
) && DECL_INITIAL (ot
))
2031 return "redefinition of `%#D'";
2035 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl
))
2037 /* Objects declared at top level: */
2038 /* If at least one is a reference, it's ok. */
2039 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
2041 /* Reject two definitions. */
2042 return "redefinition of `%#D'";
2046 /* Objects declared with block scope: */
2047 /* Reject two definitions, and reject a definition
2048 together with an external reference. */
2049 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
2050 return "redeclaration of `%#D'";
2055 /* Create a new label, named ID. */
2058 make_label_decl (tree id
, int local_p
)
2062 decl
= build_decl (LABEL_DECL
, id
, void_type_node
);
2064 DECL_CONTEXT (decl
) = current_function_decl
;
2065 DECL_MODE (decl
) = VOIDmode
;
2066 C_DECLARED_LABEL_FLAG (decl
) = local_p
;
2068 /* Say where one reference is to the label, for the sake of the
2069 error if it is not defined. */
2070 DECL_SOURCE_LOCATION (decl
) = input_location
;
2072 /* Record the fact that this identifier is bound to this label. */
2073 SET_IDENTIFIER_LABEL_VALUE (id
, decl
);
2078 /* Record this label on the list of used labels so that we can check
2079 at the end of the function to see whether or not the label was
2080 actually defined, and so we can check when the label is defined whether
2081 this use is valid. */
2084 use_label (tree decl
)
2086 if (named_label_uses
== NULL
2087 || named_label_uses
->names_in_scope
!= current_binding_level
->names
2088 || named_label_uses
->label_decl
!= decl
)
2090 struct named_label_use_list
*new_ent
;
2091 new_ent
= GGC_NEW (struct named_label_use_list
);
2092 new_ent
->label_decl
= decl
;
2093 new_ent
->names_in_scope
= current_binding_level
->names
;
2094 new_ent
->binding_level
= current_binding_level
;
2095 new_ent
->o_goto_locus
= input_location
;
2096 new_ent
->next
= named_label_uses
;
2097 named_label_uses
= new_ent
;
2101 /* Look for a label named ID in the current function. If one cannot
2102 be found, create one. (We keep track of used, but undefined,
2103 labels, and complain about them at the end of a function.) */
2106 lookup_label (tree id
)
2109 struct named_label_list
*ent
;
2111 timevar_push (TV_NAME_LOOKUP
);
2112 /* You can't use labels at global scope. */
2113 if (current_function_decl
== NULL_TREE
)
2115 error ("label `%E' referenced outside of any function", id
);
2116 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
2119 /* See if we've already got this label. */
2120 decl
= IDENTIFIER_LABEL_VALUE (id
);
2121 if (decl
!= NULL_TREE
&& DECL_CONTEXT (decl
) == current_function_decl
)
2122 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2124 /* Record this label on the list of labels used in this function.
2125 We do this before calling make_label_decl so that we get the
2126 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2127 ent
= GGC_CNEW (struct named_label_list
);
2128 ent
->old_value
= IDENTIFIER_LABEL_VALUE (id
);
2129 ent
->next
= named_labels
;
2132 /* We need a new label. */
2133 decl
= make_label_decl (id
, /*local_p=*/0);
2135 /* Now fill in the information we didn't have before. */
2136 ent
->label_decl
= decl
;
2138 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2141 /* Declare a local label named ID. */
2144 declare_local_label (tree id
)
2148 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2149 this scope we can restore the old value of
2150 IDENTIFIER_TYPE_VALUE. */
2151 current_binding_level
->shadowed_labels
2152 = tree_cons (IDENTIFIER_LABEL_VALUE (id
), NULL_TREE
,
2153 current_binding_level
->shadowed_labels
);
2154 /* Look for the label. */
2155 decl
= make_label_decl (id
, /*local_p=*/1);
2156 /* Now fill in the information we didn't have before. */
2157 TREE_VALUE (current_binding_level
->shadowed_labels
) = decl
;
2162 /* Returns nonzero if it is ill-formed to jump past the declaration of
2163 DECL. Returns 2 if it's also a real problem. */
2166 decl_jump_unsafe (tree decl
)
2168 if (TREE_CODE (decl
) != VAR_DECL
|| TREE_STATIC (decl
))
2171 if (DECL_INITIAL (decl
) == NULL_TREE
2172 && pod_type_p (TREE_TYPE (decl
)))
2175 /* This is really only important if we're crossing an initialization.
2176 The POD stuff is just pedantry; why should it matter if the class
2177 contains a field of pointer to member type? */
2178 if (DECL_INITIAL (decl
)
2179 || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
))))
2184 /* Check that a single previously seen jump to a newly defined label
2185 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2186 the jump context; NAMES are the names in scope in LEVEL at the jump
2187 context; FILE and LINE are the source position of the jump or 0. */
2190 check_previous_goto_1 (tree decl
,
2191 struct cp_binding_level
* level
,
2192 tree names
, const location_t
*locus
)
2196 struct cp_binding_level
*b
= current_binding_level
;
2197 for (; b
; b
= b
->level_chain
)
2199 tree new_decls
= b
->names
;
2200 tree old_decls
= (b
== level
? names
: NULL_TREE
);
2201 for (; new_decls
!= old_decls
;
2202 new_decls
= TREE_CHAIN (new_decls
))
2204 int problem
= decl_jump_unsafe (new_decls
);
2211 pedwarn ("jump to label `%D'", decl
);
2213 pedwarn ("jump to case label");
2216 pedwarn ("%H from here", locus
);
2221 cp_error_at (" crosses initialization of `%#D'",
2224 cp_pedwarn_at (" enters scope of non-POD `%#D'",
2230 if ((b
->kind
== sk_try
|| b
->kind
== sk_catch
) && ! saw_eh
)
2235 pedwarn ("jump to label `%D'", decl
);
2237 pedwarn ("jump to case label");
2240 pedwarn ("%H from here", locus
);
2243 if (b
->kind
== sk_try
)
2244 error (" enters try block");
2246 error (" enters catch block");
2253 check_previous_goto (struct named_label_use_list
* use
)
2255 check_previous_goto_1 (use
->label_decl
, use
->binding_level
,
2256 use
->names_in_scope
, &use
->o_goto_locus
);
2260 check_switch_goto (struct cp_binding_level
* level
)
2262 check_previous_goto_1 (NULL_TREE
, level
, level
->names
, NULL
);
2265 /* Check that any previously seen jumps to a newly defined label DECL
2266 are OK. Called by define_label. */
2269 check_previous_gotos (tree decl
)
2271 struct named_label_use_list
**usep
;
2273 if (! TREE_USED (decl
))
2276 for (usep
= &named_label_uses
; *usep
; )
2278 struct named_label_use_list
*use
= *usep
;
2279 if (use
->label_decl
== decl
)
2281 check_previous_goto (use
);
2285 usep
= &(use
->next
);
2289 /* Check that a new jump to a label DECL is OK. Called by
2290 finish_goto_stmt. */
2293 check_goto (tree decl
)
2297 struct named_label_list
*lab
;
2299 /* We can't know where a computed goto is jumping. So we assume
2301 if (! DECL_P (decl
))
2304 /* If the label hasn't been defined yet, defer checking. */
2305 if (! DECL_INITIAL (decl
))
2311 for (lab
= named_labels
; lab
; lab
= lab
->next
)
2312 if (decl
== lab
->label_decl
)
2315 /* If the label is not on named_labels it's a gcc local label, so
2316 it must be in an outer scope, so jumping to it is always OK. */
2320 if ((lab
->in_try_scope
|| lab
->in_catch_scope
|| lab
->bad_decls
)
2323 cp_pedwarn_at ("jump to label `%D'", decl
);
2324 pedwarn (" from here");
2328 for (bad
= lab
->bad_decls
; bad
; bad
= TREE_CHAIN (bad
))
2330 tree b
= TREE_VALUE (bad
);
2331 int u
= decl_jump_unsafe (b
);
2333 if (u
> 1 && DECL_ARTIFICIAL (b
))
2334 /* Can't skip init of __exception_info. */
2335 error ("%J enters catch block", b
);
2337 cp_error_at (" skips initialization of `%#D'", b
);
2339 cp_pedwarn_at (" enters scope of non-POD `%#D'", b
);
2342 if (lab
->in_try_scope
)
2343 error (" enters try block");
2344 else if (lab
->in_catch_scope
)
2345 error (" enters catch block");
2348 /* Define a label, specifying the location in the source file.
2349 Return the LABEL_DECL node for the label. */
2352 define_label (location_t location
, tree name
)
2354 tree decl
= lookup_label (name
);
2355 struct named_label_list
*ent
;
2356 struct cp_binding_level
*p
;
2358 timevar_push (TV_NAME_LOOKUP
);
2359 for (ent
= named_labels
; ent
; ent
= ent
->next
)
2360 if (ent
->label_decl
== decl
)
2363 /* After labels, make any new cleanups in the function go into their
2364 own new (temporary) binding contour. */
2365 for (p
= current_binding_level
;
2366 p
->kind
!= sk_function_parms
;
2368 p
->more_cleanups_ok
= 0;
2370 if (name
== get_identifier ("wchar_t"))
2371 pedwarn ("label named wchar_t");
2373 if (DECL_INITIAL (decl
) != NULL_TREE
)
2374 error ("duplicate label `%D'", decl
);
2377 /* Mark label as having been defined. */
2378 DECL_INITIAL (decl
) = error_mark_node
;
2379 /* Say where in the source. */
2380 DECL_SOURCE_LOCATION (decl
) = location
;
2383 ent
->names_in_scope
= current_binding_level
->names
;
2384 ent
->binding_level
= current_binding_level
;
2386 check_previous_gotos (decl
);
2389 timevar_pop (TV_NAME_LOOKUP
);
2395 struct cp_binding_level
*level
;
2396 struct cp_switch
*next
;
2397 /* The SWITCH_STMT being built. */
2399 /* A splay-tree mapping the low element of a case range to the high
2400 element, or NULL_TREE if there is no high element. Used to
2401 determine whether or not a new case label duplicates an old case
2402 label. We need a tree, rather than simply a hash table, because
2403 of the GNU case range extension. */
2407 /* A stack of the currently active switch statements. The innermost
2408 switch statement is on the top of the stack. There is no need to
2409 mark the stack for garbage collection because it is only active
2410 during the processing of the body of a function, and we never
2411 collect at that point. */
2413 static struct cp_switch
*switch_stack
;
2415 /* Called right after a switch-statement condition is parsed.
2416 SWITCH_STMT is the switch statement being parsed. */
2419 push_switch (tree switch_stmt
)
2421 struct cp_switch
*p
= xmalloc (sizeof (struct cp_switch
));
2422 p
->level
= current_binding_level
;
2423 p
->next
= switch_stack
;
2424 p
->switch_stmt
= switch_stmt
;
2425 p
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
2432 struct cp_switch
*cs
= switch_stack
;
2434 /* Emit warnings as needed. */
2435 c_do_switch_warnings (cs
->cases
, cs
->switch_stmt
);
2437 splay_tree_delete (cs
->cases
);
2438 switch_stack
= switch_stack
->next
;
2442 /* Note that we've seen a definition of a case label, and complain if this
2443 is a bad place for one. */
2446 finish_case_label (tree low_value
, tree high_value
)
2449 struct cp_binding_level
*p
;
2451 if (processing_template_decl
)
2455 /* For templates, just add the case label; we'll do semantic
2456 analysis at instantiation-time. */
2457 label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
2458 return add_stmt (build_case_label (low_value
, high_value
, label
));
2461 /* Find the condition on which this switch statement depends. */
2462 cond
= SWITCH_COND (switch_stack
->switch_stmt
);
2463 if (cond
&& TREE_CODE (cond
) == TREE_LIST
)
2464 cond
= TREE_VALUE (cond
);
2466 r
= c_add_case_label (switch_stack
->cases
, cond
, TREE_TYPE (cond
),
2467 low_value
, high_value
);
2469 check_switch_goto (switch_stack
->level
);
2471 /* After labels, make any new cleanups in the function go into their
2472 own new (temporary) binding contour. */
2473 for (p
= current_binding_level
;
2474 p
->kind
!= sk_function_parms
;
2476 p
->more_cleanups_ok
= 0;
2481 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
2484 typename_hash (const void* k
)
2489 hash
= (htab_hash_pointer (TYPE_CONTEXT (t
))
2490 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t
))));
2495 /* Compare two TYPENAME_TYPEs. K1 and K2 are really of type `tree'. */
2498 typename_compare (const void * k1
, const void * k2
)
2507 d1
= TYPE_NAME (t1
);
2508 d2
= TYPE_NAME (t2
);
2510 return (DECL_NAME (d1
) == DECL_NAME (d2
)
2511 && TYPE_CONTEXT (t1
) == TYPE_CONTEXT (t2
)
2512 && ((TREE_TYPE (t1
) != NULL_TREE
)
2513 == (TREE_TYPE (t2
) != NULL_TREE
))
2514 && same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
2515 && TYPENAME_TYPE_FULLNAME (t1
) == TYPENAME_TYPE_FULLNAME (t2
));
2518 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
2519 the type of `T', NAME is the IDENTIFIER_NODE for `t'. If BASE_TYPE
2520 is non-NULL, this type is being created by the implicit typename
2521 extension, and BASE_TYPE is a type named `t' in some base class of
2522 `T' which depends on template parameters.
2524 Returns the new TYPENAME_TYPE. */
2526 static GTY ((param_is (union tree_node
))) htab_t typename_htab
;
2529 build_typename_type (tree context
, tree name
, tree fullname
)
2535 if (typename_htab
== NULL
)
2537 typename_htab
= htab_create_ggc (61, &typename_hash
,
2538 &typename_compare
, NULL
);
2541 /* Build the TYPENAME_TYPE. */
2542 t
= make_aggr_type (TYPENAME_TYPE
);
2543 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
2544 TYPENAME_TYPE_FULLNAME (t
) = fullname
;
2546 /* Build the corresponding TYPE_DECL. */
2547 d
= build_decl (TYPE_DECL
, name
, t
);
2548 TYPE_NAME (TREE_TYPE (d
)) = d
;
2549 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
2550 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
2551 DECL_ARTIFICIAL (d
) = 1;
2553 /* See if we already have this type. */
2554 e
= htab_find_slot (typename_htab
, t
, INSERT
);
2563 /* Resolve `typename CONTEXT::NAME'. Returns an appropriate type,
2564 unless an error occurs, in which case error_mark_node is returned.
2565 If we locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is
2566 set, we return that, rather than the _TYPE it corresponds to, in
2567 other cases we look through the type decl. If TF_ERROR is set,
2568 complain about errors, otherwise be quiet. */
2571 make_typename_type (tree context
, tree name
, tsubst_flags_t complain
)
2575 if (name
== error_mark_node
2576 || context
== NULL_TREE
2577 || context
== error_mark_node
)
2578 return error_mark_node
;
2582 if (!(TYPE_LANG_SPECIFIC (name
)
2583 && (CLASSTYPE_IS_TEMPLATE (name
)
2584 || CLASSTYPE_USE_TEMPLATE (name
))))
2585 name
= TYPE_IDENTIFIER (name
);
2587 /* Create a TEMPLATE_ID_EXPR for the type. */
2588 name
= build_nt (TEMPLATE_ID_EXPR
,
2589 CLASSTYPE_TI_TEMPLATE (name
),
2590 CLASSTYPE_TI_ARGS (name
));
2592 else if (TREE_CODE (name
) == TYPE_DECL
)
2593 name
= DECL_NAME (name
);
2597 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
2599 name
= TREE_OPERAND (name
, 0);
2600 if (TREE_CODE (name
) == TEMPLATE_DECL
)
2601 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
2603 if (TREE_CODE (name
) == TEMPLATE_DECL
)
2605 error ("`%D' used without template parameters", name
);
2606 return error_mark_node
;
2608 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
2610 if (TREE_CODE (context
) == NAMESPACE_DECL
)
2612 /* We can get here from typename_sub0 in the explicit_template_type
2613 expansion. Just fail. */
2614 if (complain
& tf_error
)
2615 error ("no class template named `%#T' in `%#T'",
2617 return error_mark_node
;
2620 if (!dependent_type_p (context
)
2621 || currently_open_class (context
))
2623 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
2625 tree tmpl
= NULL_TREE
;
2626 if (IS_AGGR_TYPE (context
))
2627 tmpl
= lookup_field (context
, name
, 0, false);
2628 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
2630 if (complain
& tf_error
)
2631 error ("no class template named `%#T' in `%#T'",
2633 return error_mark_node
;
2636 if (complain
& tf_error
)
2637 perform_or_defer_access_check (TYPE_BINFO (context
), tmpl
);
2639 return lookup_template_class (tmpl
,
2640 TREE_OPERAND (fullname
, 1),
2642 /*entering_scope=*/0,
2643 tf_error
| tf_warning
| tf_user
);
2649 if (!IS_AGGR_TYPE (context
))
2651 if (complain
& tf_error
)
2652 error ("no type named `%#T' in `%#T'", name
, context
);
2653 return error_mark_node
;
2656 t
= lookup_field (context
, name
, 0, true);
2659 if (TREE_CODE (t
) != TYPE_DECL
)
2661 if (complain
& tf_error
)
2662 error ("no type named `%#T' in `%#T'", name
, context
);
2663 return error_mark_node
;
2666 if (complain
& tf_error
)
2667 perform_or_defer_access_check (TYPE_BINFO (context
), t
);
2669 if (DECL_ARTIFICIAL (t
) || !(complain
& tf_keep_type_decl
))
2677 /* If the CONTEXT is not a template type, then either the field is
2678 there now or its never going to be. */
2679 if (!dependent_type_p (context
))
2681 if (complain
& tf_error
)
2682 error ("no type named `%#T' in `%#T'", name
, context
);
2683 return error_mark_node
;
2686 return build_typename_type (context
, name
, fullname
);
2689 /* Resolve `CONTEXT::template NAME'. Returns an appropriate type,
2690 unless an error occurs, in which case error_mark_node is returned.
2691 If we locate a TYPE_DECL, we return that, rather than the _TYPE it
2692 corresponds to. If COMPLAIN zero, don't complain about any errors
2696 make_unbound_class_template (tree context
, tree name
, tsubst_flags_t complain
)
2702 name
= TYPE_IDENTIFIER (name
);
2703 else if (DECL_P (name
))
2704 name
= DECL_NAME (name
);
2705 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
2708 if (!dependent_type_p (context
)
2709 || currently_open_class (context
))
2711 tree tmpl
= NULL_TREE
;
2713 if (IS_AGGR_TYPE (context
))
2714 tmpl
= lookup_field (context
, name
, 0, false);
2716 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
2718 if (complain
& tf_error
)
2719 error ("no class template named `%#T' in `%#T'", name
, context
);
2720 return error_mark_node
;
2723 if (complain
& tf_error
)
2724 perform_or_defer_access_check (TYPE_BINFO (context
), tmpl
);
2729 /* Build the UNBOUND_CLASS_TEMPLATE. */
2730 t
= make_aggr_type (UNBOUND_CLASS_TEMPLATE
);
2731 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
2732 TREE_TYPE (t
) = NULL_TREE
;
2734 /* Build the corresponding TEMPLATE_DECL. */
2735 d
= build_decl (TEMPLATE_DECL
, name
, t
);
2736 TYPE_NAME (TREE_TYPE (d
)) = d
;
2737 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
2738 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
2739 DECL_ARTIFICIAL (d
) = 1;
2746 /* Push the declarations of builtin types into the namespace.
2747 RID_INDEX is the index of the builtin type in the array
2748 RID_POINTERS. NAME is the name used when looking up the builtin
2749 type. TYPE is the _TYPE node for the builtin type. */
2752 record_builtin_type (enum rid rid_index
,
2756 tree rname
= NULL_TREE
, tname
= NULL_TREE
;
2757 tree tdecl
= NULL_TREE
;
2759 if ((int) rid_index
< (int) RID_MAX
)
2760 rname
= ridpointers
[(int) rid_index
];
2762 tname
= get_identifier (name
);
2764 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
2765 eliminated. Built-in types should not be looked up name; their
2766 names are keywords that the parser can recognize. However, there
2767 is code in c-common.c that uses identifier_global_value to look
2768 up built-in types by name. */
2771 tdecl
= build_decl (TYPE_DECL
, tname
, type
);
2772 DECL_ARTIFICIAL (tdecl
) = 1;
2773 SET_IDENTIFIER_GLOBAL_VALUE (tname
, tdecl
);
2779 tdecl
= build_decl (TYPE_DECL
, rname
, type
);
2780 DECL_ARTIFICIAL (tdecl
) = 1;
2782 SET_IDENTIFIER_GLOBAL_VALUE (rname
, tdecl
);
2785 if (!TYPE_NAME (type
))
2786 TYPE_NAME (type
) = tdecl
;
2789 debug_hooks
->type_decl (tdecl
, 0);
2792 /* Record one of the standard Java types.
2793 * Declare it as having the given NAME.
2794 * If SIZE > 0, it is the size of one of the integral types;
2795 * otherwise it is the negative of the size of one of the other types. */
2798 record_builtin_java_type (const char* name
, int size
)
2802 type
= make_signed_type (size
);
2803 else if (size
> -32)
2804 { /* "__java_char" or ""__java_boolean". */
2805 type
= make_unsigned_type (-size
);
2806 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
2809 { /* "__java_float" or ""__java_double". */
2810 type
= make_node (REAL_TYPE
);
2811 TYPE_PRECISION (type
) = - size
;
2814 record_builtin_type (RID_MAX
, name
, type
);
2815 decl
= TYPE_NAME (type
);
2817 /* Suppress generate debug symbol entries for these types,
2818 since for normal C++ they are just clutter.
2819 However, push_lang_context undoes this if extern "Java" is seen. */
2820 DECL_IGNORED_P (decl
) = 1;
2822 TYPE_FOR_JAVA (type
) = 1;
2826 /* Push a type into the namespace so that the back-ends ignore it. */
2829 record_unknown_type (tree type
, const char* name
)
2831 tree decl
= pushdecl (build_decl (TYPE_DECL
, get_identifier (name
), type
));
2832 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
2833 DECL_IGNORED_P (decl
) = 1;
2834 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
2835 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
2836 TYPE_ALIGN (type
) = 1;
2837 TYPE_USER_ALIGN (type
) = 0;
2838 TYPE_MODE (type
) = TYPE_MODE (void_type_node
);
2841 /* An string for which we should create an IDENTIFIER_NODE at
2844 typedef struct predefined_identifier
2846 /* The name of the identifier. */
2847 const char *const name
;
2848 /* The place where the IDENTIFIER_NODE should be stored. */
2850 /* Nonzero if this is the name of a constructor or destructor. */
2851 const int ctor_or_dtor_p
;
2852 } predefined_identifier
;
2854 /* Create all the predefined identifiers. */
2857 initialize_predefined_identifiers (void)
2859 const predefined_identifier
*pid
;
2861 /* A table of identifiers to create at startup. */
2862 static const predefined_identifier predefined_identifiers
[] = {
2863 { "C++", &lang_name_cplusplus
, 0 },
2864 { "C", &lang_name_c
, 0 },
2865 { "Java", &lang_name_java
, 0 },
2866 { CTOR_NAME
, &ctor_identifier
, 1 },
2867 { "__base_ctor", &base_ctor_identifier
, 1 },
2868 { "__comp_ctor", &complete_ctor_identifier
, 1 },
2869 { DTOR_NAME
, &dtor_identifier
, 1 },
2870 { "__comp_dtor", &complete_dtor_identifier
, 1 },
2871 { "__base_dtor", &base_dtor_identifier
, 1 },
2872 { "__deleting_dtor", &deleting_dtor_identifier
, 1 },
2873 { IN_CHARGE_NAME
, &in_charge_identifier
, 0 },
2874 { "nelts", &nelts_identifier
, 0 },
2875 { THIS_NAME
, &this_identifier
, 0 },
2876 { VTABLE_DELTA_NAME
, &delta_identifier
, 0 },
2877 { VTABLE_PFN_NAME
, &pfn_identifier
, 0 },
2878 { "_vptr", &vptr_identifier
, 0 },
2879 { "__vtt_parm", &vtt_parm_identifier
, 0 },
2880 { "::", &global_scope_name
, 0 },
2881 { "std", &std_identifier
, 0 },
2885 for (pid
= predefined_identifiers
; pid
->name
; ++pid
)
2887 *pid
->node
= get_identifier (pid
->name
);
2888 if (pid
->ctor_or_dtor_p
)
2889 IDENTIFIER_CTOR_OR_DTOR_P (*pid
->node
) = 1;
2893 /* Create the predefined scalar types of C,
2894 and some nodes representing standard constants (0, 1, (void *)0).
2895 Initialize the global binding level.
2896 Make definitions for built-in primitive functions. */
2899 cxx_init_decl_processing (void)
2902 tree void_ftype_ptr
;
2904 build_common_tree_nodes (flag_signed_char
, false);
2906 /* Create all the identifiers we need. */
2907 initialize_predefined_identifiers ();
2909 /* Create the global variables. */
2910 push_to_top_level ();
2912 current_function_decl
= NULL_TREE
;
2913 current_binding_level
= NULL
;
2914 /* Enter the global namespace. */
2915 gcc_assert (global_namespace
== NULL_TREE
);
2916 global_namespace
= build_lang_decl (NAMESPACE_DECL
, global_scope_name
,
2918 begin_scope (sk_namespace
, global_namespace
);
2920 current_lang_name
= NULL_TREE
;
2922 /* Adjust various flags based on command-line settings. */
2923 if (!flag_permissive
)
2924 flag_pedantic_errors
= 1;
2925 if (!flag_no_inline
)
2927 flag_inline_trees
= 1;
2930 if (flag_inline_functions
)
2932 flag_inline_trees
= 2;
2933 flag_inline_functions
= 0;
2936 /* Force minimum function alignment if using the least significant
2937 bit of function pointers to store the virtual bit. */
2938 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
2939 && force_align_functions_log
< 1)
2940 force_align_functions_log
= 1;
2943 current_lang_name
= lang_name_c
;
2945 error_mark_list
= build_tree_list (error_mark_node
, error_mark_node
);
2946 TREE_TYPE (error_mark_list
) = error_mark_node
;
2948 /* Create the `std' namespace. */
2949 push_namespace (std_identifier
);
2950 std_node
= current_namespace
;
2953 c_common_nodes_and_builtins ();
2955 java_byte_type_node
= record_builtin_java_type ("__java_byte", 8);
2956 java_short_type_node
= record_builtin_java_type ("__java_short", 16);
2957 java_int_type_node
= record_builtin_java_type ("__java_int", 32);
2958 java_long_type_node
= record_builtin_java_type ("__java_long", 64);
2959 java_float_type_node
= record_builtin_java_type ("__java_float", -32);
2960 java_double_type_node
= record_builtin_java_type ("__java_double", -64);
2961 java_char_type_node
= record_builtin_java_type ("__java_char", -16);
2962 java_boolean_type_node
= record_builtin_java_type ("__java_boolean", -1);
2964 integer_two_node
= build_int_cst (NULL_TREE
, 2);
2965 integer_three_node
= build_int_cst (NULL_TREE
, 3);
2967 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
2968 truthvalue_type_node
= boolean_type_node
;
2969 truthvalue_false_node
= boolean_false_node
;
2970 truthvalue_true_node
= boolean_true_node
;
2972 empty_except_spec
= build_tree_list (NULL_TREE
, NULL_TREE
);
2975 record_builtin_type (RID_MAX
, NULL
, string_type_node
);
2978 delta_type_node
= ptrdiff_type_node
;
2979 vtable_index_type
= ptrdiff_type_node
;
2981 vtt_parm_type
= build_pointer_type (const_ptr_type_node
);
2982 void_ftype
= build_function_type (void_type_node
, void_list_node
);
2983 void_ftype_ptr
= build_function_type (void_type_node
,
2984 tree_cons (NULL_TREE
,
2988 = build_exception_variant (void_ftype_ptr
, empty_except_spec
);
2990 /* C++ extensions */
2992 unknown_type_node
= make_node (UNKNOWN_TYPE
);
2993 record_unknown_type (unknown_type_node
, "unknown type");
2995 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
2996 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
2998 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3000 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
3001 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
3004 /* Make sure we get a unique function type, so we can give
3005 its pointer type a name. (This wins for gdb.) */
3006 tree vfunc_type
= make_node (FUNCTION_TYPE
);
3007 TREE_TYPE (vfunc_type
) = integer_type_node
;
3008 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
3009 layout_type (vfunc_type
);
3011 vtable_entry_type
= build_pointer_type (vfunc_type
);
3013 record_builtin_type (RID_MAX
, VTBL_PTR_TYPE
, vtable_entry_type
);
3016 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
3017 layout_type (vtbl_type_node
);
3018 vtbl_type_node
= build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
3019 record_builtin_type (RID_MAX
, NULL
, vtbl_type_node
);
3020 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
3021 layout_type (vtbl_ptr_type_node
);
3022 record_builtin_type (RID_MAX
, NULL
, vtbl_ptr_type_node
);
3024 push_namespace (get_identifier ("__cxxabiv1"));
3025 abi_node
= current_namespace
;
3028 global_type_node
= make_node (LANG_TYPE
);
3029 record_unknown_type (global_type_node
, "global type");
3032 current_lang_name
= lang_name_cplusplus
;
3036 tree bad_alloc_type_node
;
3037 tree bad_alloc_decl
;
3038 tree newtype
, deltype
;
3039 tree ptr_ftype_sizetype
;
3041 push_namespace (std_identifier
);
3042 bad_alloc_id
= get_identifier ("bad_alloc");
3043 bad_alloc_type_node
= make_aggr_type (RECORD_TYPE
);
3044 TYPE_CONTEXT (bad_alloc_type_node
) = current_namespace
;
3046 = create_implicit_typedef (bad_alloc_id
, bad_alloc_type_node
);
3047 DECL_CONTEXT (bad_alloc_decl
) = current_namespace
;
3048 TYPE_STUB_DECL (bad_alloc_type_node
) = bad_alloc_decl
;
3052 = build_function_type (ptr_type_node
,
3053 tree_cons (NULL_TREE
,
3056 newtype
= build_exception_variant
3057 (ptr_ftype_sizetype
, add_exception_specifier
3058 (NULL_TREE
, bad_alloc_type_node
, -1));
3059 deltype
= build_exception_variant (void_ftype_ptr
, empty_except_spec
);
3060 push_cp_library_fn (NEW_EXPR
, newtype
);
3061 push_cp_library_fn (VEC_NEW_EXPR
, newtype
);
3062 global_delete_fndecl
= push_cp_library_fn (DELETE_EXPR
, deltype
);
3063 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
);
3067 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype
);
3069 /* Perform other language dependent initializations. */
3070 init_class_processing ();
3071 init_rtti_processing ();
3073 if (flag_exceptions
)
3074 init_exception_processing ();
3076 if (! supports_one_only ())
3079 make_fname_decl
= cp_make_fname_decl
;
3080 start_fname_decls ();
3082 /* Show we use EH for cleanups. */
3083 if (flag_exceptions
)
3084 using_eh_for_cleanups ();
3087 /* Generate an initializer for a function naming variable from
3088 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3089 filled in with the type of the init. */
3092 cp_fname_init (const char* name
, tree
*type_p
)
3094 tree domain
= NULL_TREE
;
3096 tree init
= NULL_TREE
;
3101 length
= strlen (name
);
3102 domain
= build_index_type (size_int (length
));
3103 init
= build_string (length
+ 1, name
);
3106 type
= build_qualified_type (char_type_node
, TYPE_QUAL_CONST
);
3107 type
= build_cplus_array_type (type
, domain
);
3112 TREE_TYPE (init
) = type
;
3114 init
= error_mark_node
;
3119 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
3120 decl, NAME is the initialization string and TYPE_DEP indicates whether
3121 NAME depended on the type of the function. We make use of that to detect
3122 __PRETTY_FUNCTION__ inside a template fn. This is being done
3123 lazily at the point of first use, so we mustn't push the decl now. */
3126 cp_make_fname_decl (tree id
, int type_dep
)
3128 const char *const name
= (type_dep
&& processing_template_decl
3129 ? NULL
: fname_as_string (type_dep
));
3131 tree init
= cp_fname_init (name
, &type
);
3132 tree decl
= build_decl (VAR_DECL
, id
, type
);
3135 free ((char *) name
);
3137 /* As we're using pushdecl_with_scope, we must set the context. */
3138 DECL_CONTEXT (decl
) = current_function_decl
;
3139 DECL_PRETTY_FUNCTION_P (decl
) = type_dep
;
3141 TREE_STATIC (decl
) = 1;
3142 TREE_READONLY (decl
) = 1;
3143 DECL_ARTIFICIAL (decl
) = 1;
3144 DECL_INITIAL (decl
) = init
;
3146 TREE_USED (decl
) = 1;
3148 if (current_function_decl
)
3150 struct cp_binding_level
*b
= current_binding_level
;
3151 while (b
->level_chain
->kind
!= sk_function_parms
)
3153 pushdecl_with_scope (decl
, b
);
3154 cp_finish_decl (decl
, init
, NULL_TREE
, LOOKUP_ONLYCONVERTING
);
3157 pushdecl_top_level_and_finish (decl
, init
);
3162 /* Make a definition for a builtin function named NAME in the current
3163 namespace, whose data type is TYPE and whose context is CONTEXT.
3164 TYPE should be a function type with argument types.
3166 CLASS and CODE tell later passes how to compile calls to this function.
3167 See tree.h for possible values.
3169 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3170 the name to be called if we can't opencode the function.
3171 If ATTRS is nonzero, use that for the function's attribute
3175 builtin_function_1 (const char* name
,
3178 enum built_in_function code
,
3179 enum built_in_class
class,
3180 const char* libname
,
3183 tree decl
= build_library_fn_1 (get_identifier (name
), ERROR_MARK
, type
);
3184 DECL_BUILT_IN_CLASS (decl
) = class;
3185 DECL_FUNCTION_CODE (decl
) = code
;
3186 DECL_CONTEXT (decl
) = context
;
3190 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
3191 we cannot change DECL_ASSEMBLER_NAME until we have installed this
3192 function in the namespace. */
3194 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier (libname
));
3196 /* Warn if a function in the namespace for users
3197 is used without an occasion to consider it declared. */
3198 if (name
[0] != '_' || name
[1] != '_')
3199 DECL_ANTICIPATED (decl
) = 1;
3201 /* Possibly apply some default attributes to this built-in function. */
3203 decl_attributes (&decl
, attrs
, ATTR_FLAG_BUILT_IN
);
3205 decl_attributes (&decl
, NULL_TREE
, 0);
3210 /* Entry point for the benefit of c_common_nodes_and_builtins.
3212 Make a definition for a builtin function named NAME and whose data type
3213 is TYPE. TYPE should be a function type with argument types. This
3214 function places the anticipated declaration in the global namespace
3215 and additionally in the std namespace if appropriate.
3217 CLASS and CODE tell later passes how to compile calls to this function.
3218 See tree.h for possible values.
3220 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3221 the name to be called if we can't opencode the function.
3223 If ATTRS is nonzero, use that for the function's attribute
3227 builtin_function (const char* name
,
3230 enum built_in_class cl
,
3231 const char* libname
,
3234 /* All builtins that don't begin with an '_' should additionally
3235 go in the 'std' namespace. */
3238 push_namespace (std_identifier
);
3239 builtin_function_1 (name
, type
, std_node
, code
, cl
, libname
, attrs
);
3243 return builtin_function_1 (name
, type
, NULL_TREE
, code
,
3244 cl
, libname
, attrs
);
3247 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
3248 function. Not called directly. */
3251 build_library_fn_1 (tree name
, enum tree_code operator_code
, tree type
)
3253 tree fn
= build_lang_decl (FUNCTION_DECL
, name
, type
);
3254 DECL_EXTERNAL (fn
) = 1;
3255 TREE_PUBLIC (fn
) = 1;
3256 DECL_ARTIFICIAL (fn
) = 1;
3257 TREE_NOTHROW (fn
) = 1;
3258 SET_OVERLOADED_OPERATOR_CODE (fn
, operator_code
);
3259 SET_DECL_LANGUAGE (fn
, lang_c
);
3260 /* Runtime library routines are, by definition, available in an
3261 external shared object. */
3262 DECL_VISIBILITY (fn
) = VISIBILITY_DEFAULT
;
3263 DECL_VISIBILITY_SPECIFIED (fn
) = 1;
3267 /* Returns the _DECL for a library function with C linkage.
3268 We assume that such functions never throw; if this is incorrect,
3269 callers should unset TREE_NOTHROW. */
3272 build_library_fn (tree name
, tree type
)
3274 return build_library_fn_1 (name
, ERROR_MARK
, type
);
3277 /* Returns the _DECL for a library function with C++ linkage. */
3280 build_cp_library_fn (tree name
, enum tree_code operator_code
, tree type
)
3282 tree fn
= build_library_fn_1 (name
, operator_code
, type
);
3283 TREE_NOTHROW (fn
) = TYPE_NOTHROW_P (type
);
3284 DECL_CONTEXT (fn
) = FROB_CONTEXT (current_namespace
);
3285 SET_DECL_LANGUAGE (fn
, lang_cplusplus
);
3289 /* Like build_library_fn, but takes a C string instead of an
3293 build_library_fn_ptr (const char* name
, tree type
)
3295 return build_library_fn (get_identifier (name
), type
);
3298 /* Like build_cp_library_fn, but takes a C string instead of an
3302 build_cp_library_fn_ptr (const char* name
, tree type
)
3304 return build_cp_library_fn (get_identifier (name
), ERROR_MARK
, type
);
3307 /* Like build_library_fn, but also pushes the function so that we will
3308 be able to find it via IDENTIFIER_GLOBAL_VALUE. */
3311 push_library_fn (tree name
, tree type
)
3313 tree fn
= build_library_fn (name
, type
);
3314 pushdecl_top_level (fn
);
3318 /* Like build_cp_library_fn, but also pushes the function so that it
3319 will be found by normal lookup. */
3322 push_cp_library_fn (enum tree_code operator_code
, tree type
)
3324 tree fn
= build_cp_library_fn (ansi_opname (operator_code
),
3331 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
3335 push_void_library_fn (tree name
, tree parmtypes
)
3337 tree type
= build_function_type (void_type_node
, parmtypes
);
3338 return push_library_fn (name
, type
);
3341 /* Like push_library_fn, but also note that this function throws
3342 and does not return. Used for __throw_foo and the like. */
3345 push_throw_library_fn (tree name
, tree type
)
3347 tree fn
= push_library_fn (name
, type
);
3348 TREE_THIS_VOLATILE (fn
) = 1;
3349 TREE_NOTHROW (fn
) = 0;
3353 /* When we call finish_struct for an anonymous union, we create
3354 default copy constructors and such. But, an anonymous union
3355 shouldn't have such things; this function undoes the damage to the
3356 anonymous union type T.
3358 (The reason that we create the synthesized methods is that we don't
3359 distinguish `union { int i; }' from `typedef union { int i; } U'.
3360 The first is an anonymous union; the second is just an ordinary
3364 fixup_anonymous_aggr (tree t
)
3368 /* Wipe out memory of synthesized methods. */
3369 TYPE_HAS_CONSTRUCTOR (t
) = 0;
3370 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
3371 TYPE_HAS_INIT_REF (t
) = 0;
3372 TYPE_HAS_CONST_INIT_REF (t
) = 0;
3373 TYPE_HAS_ASSIGN_REF (t
) = 0;
3374 TYPE_HAS_CONST_ASSIGN_REF (t
) = 0;
3376 /* Splice the implicitly generated functions out of the TYPE_METHODS
3378 q
= &TYPE_METHODS (t
);
3381 if (DECL_ARTIFICIAL (*q
))
3382 *q
= TREE_CHAIN (*q
);
3384 q
= &TREE_CHAIN (*q
);
3387 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
3388 if (TYPE_METHODS (t
))
3389 error ("%Jan anonymous union cannot have function members",
3390 TYPE_MAIN_DECL (t
));
3392 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
3393 assignment operators (because they cannot have these methods themselves).
3394 For anonymous unions this is already checked because they are not allowed
3395 in any union, otherwise we have to check it. */
3396 if (TREE_CODE (t
) != UNION_TYPE
)
3400 for (field
= TYPE_FIELDS (t
); field
; field
= TREE_CHAIN (field
))
3401 if (TREE_CODE (field
) == FIELD_DECL
)
3403 type
= TREE_TYPE (field
);
3404 if (CLASS_TYPE_P (type
))
3406 if (TYPE_NEEDS_CONSTRUCTING (type
))
3407 cp_error_at ("member %#D' with constructor not allowed in anonymous aggregate",
3409 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
3410 cp_error_at ("member %#D' with destructor not allowed in anonymous aggregate",
3412 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type
))
3413 cp_error_at ("member %#D' with copy assignment operator not allowed in anonymous aggregate",
3420 /* Make sure that a declaration with no declarator is well-formed, i.e.
3421 just declares a tagged type or anonymous union.
3423 Returns the type declared; or NULL_TREE if none. */
3426 check_tag_decl (cp_decl_specifier_seq
*declspecs
)
3428 int saw_friend
= declspecs
->specs
[(int)ds_friend
] != 0;
3429 int saw_typedef
= declspecs
->specs
[(int)ds_typedef
] != 0;
3430 /* If a class, struct, or enum type is declared by the DECLSPECS
3431 (i.e, if a class-specifier, enum-specifier, or non-typename
3432 elaborated-type-specifier appears in the DECLSPECS),
3433 DECLARED_TYPE is set to the corresponding type. */
3434 tree declared_type
= NULL_TREE
;
3435 bool error_p
= false;
3437 if (declspecs
->multiple_types_p
)
3438 error ("multiple types in one declaration");
3439 else if (declspecs
->redefined_builtin_type
)
3441 if (!in_system_header
)
3442 pedwarn ("redeclaration of C++ built-in type %qT",
3443 declspecs
->redefined_builtin_type
);
3447 if (TYPE_P (declspecs
->type
)
3448 && ((TREE_CODE (declspecs
->type
) != TYPENAME_TYPE
3449 && IS_AGGR_TYPE (declspecs
->type
))
3450 || TREE_CODE (declspecs
->type
) == ENUMERAL_TYPE
))
3451 declared_type
= declspecs
->type
;
3452 else if (declspecs
->type
== error_mark_node
)
3454 if (declared_type
== NULL_TREE
&& ! saw_friend
&& !error_p
)
3455 pedwarn ("declaration does not declare anything");
3456 /* Check for an anonymous union. */
3457 else if (declared_type
&& IS_AGGR_TYPE_CODE (TREE_CODE (declared_type
))
3458 && TYPE_ANONYMOUS_P (declared_type
))
3460 /* 7/3 In a simple-declaration, the optional init-declarator-list
3461 can be omitted only when declaring a class (clause 9) or
3462 enumeration (7.2), that is, when the decl-specifier-seq contains
3463 either a class-specifier, an elaborated-type-specifier with
3464 a class-key (9.1), or an enum-specifier. In these cases and
3465 whenever a class-specifier or enum-specifier is present in the
3466 decl-specifier-seq, the identifiers in these specifiers are among
3467 the names being declared by the declaration (as class-name,
3468 enum-names, or enumerators, depending on the syntax). In such
3469 cases, and except for the declaration of an unnamed bit-field (9.6),
3470 the decl-specifier-seq shall introduce one or more names into the
3471 program, or shall redeclare a name introduced by a previous
3472 declaration. [Example:
3473 enum { }; // ill-formed
3474 typedef class { }; // ill-formed
3478 error ("missing type-name in typedef-declaration");
3481 /* Anonymous unions are objects, so they can have specifiers. */;
3482 SET_ANON_AGGR_TYPE_P (declared_type
);
3484 if (TREE_CODE (declared_type
) != UNION_TYPE
&& pedantic
3485 && !in_system_header
)
3486 pedwarn ("ISO C++ prohibits anonymous structs");
3491 if (declspecs
->specs
[(int)ds_inline
]
3492 || declspecs
->specs
[(int)ds_virtual
])
3493 error ("`%s' can only be specified for functions",
3494 declspecs
->specs
[(int)ds_inline
]
3495 ? "inline" : "virtual");
3497 && (!current_class_type
3498 || current_scope () != current_class_type
))
3499 error ("`friend' can only be specified inside a class");
3500 else if (declspecs
->specs
[(int)ds_explicit
])
3501 error ("`explicit' can only be specified for constructors");
3502 else if (declspecs
->storage_class
)
3503 error ("a storage class can only be specified for objects "
3505 else if (declspecs
->specs
[(int)ds_const
]
3506 || declspecs
->specs
[(int)ds_volatile
]
3507 || declspecs
->specs
[(int)ds_restrict
]
3508 || declspecs
->specs
[(int)ds_thread
])
3509 error ("qualifiers can only be specified for objects "
3513 return declared_type
;
3516 /* Called when a declaration is seen that contains no names to declare.
3517 If its type is a reference to a structure, union or enum inherited
3518 from a containing scope, shadow that tag name for the current scope
3519 with a forward reference.
3520 If its type defines a new named structure or union
3521 or defines an enum, it is valid but we need not do anything here.
3522 Otherwise, it is an error.
3524 C++: may have to grok the declspecs to learn about static,
3525 complain for anonymous unions.
3527 Returns the TYPE declared -- or NULL_TREE if none. */
3530 shadow_tag (cp_decl_specifier_seq
*declspecs
)
3532 tree t
= check_tag_decl (declspecs
);
3537 maybe_process_partial_specialization (t
);
3539 /* This is where the variables in an anonymous union are
3540 declared. An anonymous union declaration looks like:
3542 because there is no declarator after the union, the parser
3543 sends that declaration here. */
3544 if (ANON_AGGR_TYPE_P (t
))
3546 fixup_anonymous_aggr (t
);
3548 if (TYPE_FIELDS (t
))
3550 tree decl
= grokdeclarator (/*declarator=*/NULL
,
3551 declspecs
, NORMAL
, 0, NULL
);
3552 finish_anon_union (decl
);
3559 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
3562 groktypename (cp_decl_specifier_seq
*type_specifiers
,
3563 const cp_declarator
*declarator
)
3567 attrs
= type_specifiers
->attributes
;
3568 type_specifiers
->attributes
= NULL_TREE
;
3569 type
= grokdeclarator (declarator
, type_specifiers
, TYPENAME
, 0, &attrs
);
3571 cplus_decl_attributes (&type
, attrs
, 0);
3575 /* Decode a declarator in an ordinary declaration or data definition.
3576 This is called as soon as the type information and variable name
3577 have been parsed, before parsing the initializer if any.
3578 Here we create the ..._DECL node, fill in its type,
3579 and put it on the list of decls for the current context.
3580 The ..._DECL node is returned as the value.
3582 Exception: for arrays where the length is not specified,
3583 the type is left null, to be filled in by `cp_finish_decl'.
3585 Function definitions do not come here; they go to start_function
3586 instead. However, external and forward declarations of functions
3587 do go through here. Structure field declarations are done by
3588 grokfield and not through here. */
3591 start_decl (const cp_declarator
*declarator
,
3592 cp_decl_specifier_seq
*declspecs
,
3595 tree prefix_attributes
,
3602 /* This should only be done once on the top most decl. */
3603 if (have_extern_spec
)
3605 declspecs
->storage_class
= sc_extern
;
3606 have_extern_spec
= false;
3609 /* An object declared as __attribute__((deprecated)) suppresses
3610 warnings of uses of other deprecated items. */
3611 if (lookup_attribute ("deprecated", attributes
))
3612 deprecated_state
= DEPRECATED_SUPPRESS
;
3614 attributes
= chainon (attributes
, prefix_attributes
);
3616 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
3619 deprecated_state
= DEPRECATED_NORMAL
;
3621 if (decl
== NULL_TREE
|| TREE_CODE (decl
) == VOID_TYPE
)
3624 type
= TREE_TYPE (decl
);
3626 if (type
== error_mark_node
)
3629 context
= DECL_CONTEXT (decl
);
3632 *pop_scope_p
= push_scope (context
);
3634 *pop_scope_p
= false;
3636 /* We are only interested in class contexts, later. */
3637 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
3638 context
= NULL_TREE
;
3641 /* Is it valid for this decl to have an initializer at all?
3642 If not, set INITIALIZED to zero, which will indirectly
3643 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
3644 switch (TREE_CODE (decl
))
3647 error ("typedef `%D' is initialized (use __typeof__ instead)", decl
);
3652 error ("function `%#D' is initialized like a variable", decl
);
3662 if (! toplevel_bindings_p ()
3663 && DECL_EXTERNAL (decl
))
3664 warning ("declaration of `%#D' has `extern' and is initialized",
3666 DECL_EXTERNAL (decl
) = 0;
3667 if (toplevel_bindings_p ())
3668 TREE_STATIC (decl
) = 1;
3670 /* Tell `pushdecl' this is an initialized decl
3671 even though we don't yet have the initializer expression.
3672 Also tell `cp_finish_decl' it may store the real initializer. */
3673 DECL_INITIAL (decl
) = error_mark_node
;
3676 /* Set attributes here so if duplicate decl, will have proper attributes. */
3677 cplus_decl_attributes (&decl
, attributes
, 0);
3679 /* If #pragma weak was used, mark the decl weak now. */
3680 if (global_scope_p (current_binding_level
))
3681 maybe_apply_pragma_weak (decl
);
3683 if (TREE_CODE (decl
) == FUNCTION_DECL
3684 && DECL_DECLARED_INLINE_P (decl
)
3685 && DECL_UNINLINABLE (decl
)
3686 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
3687 warning ("%Jinline function '%D' given attribute noinline", decl
, decl
);
3689 if (context
&& COMPLETE_TYPE_P (complete_type (context
)))
3691 if (TREE_CODE (decl
) == VAR_DECL
)
3693 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, false);
3694 if (field
== NULL_TREE
|| TREE_CODE (field
) != VAR_DECL
)
3695 error ("`%#D' is not a static member of `%#T'", decl
, context
);
3698 if (DECL_CONTEXT (field
) != context
)
3700 if (!same_type_p (DECL_CONTEXT (field
), context
))
3701 pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
3702 DECL_CONTEXT (field
), DECL_NAME (decl
),
3703 context
, DECL_NAME (decl
));
3704 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
3706 /* Static data member are tricky; an in-class initialization
3707 still doesn't provide a definition, so the in-class
3708 declaration will have DECL_EXTERNAL set, but will have an
3709 initialization. Thus, duplicate_decls won't warn
3710 about this situation, and so we check here. */
3711 if (DECL_INITIAL (decl
) && DECL_INITIAL (field
))
3712 error ("duplicate initialization of %D", decl
);
3713 if (duplicate_decls (decl
, field
))
3719 tree field
= check_classfn (context
, decl
,
3720 (processing_template_decl
3721 > template_class_depth (context
))
3722 ? current_template_parms
3724 if (field
&& duplicate_decls (decl
, field
))
3728 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
3729 DECL_IN_AGGR_P (decl
) = 0;
3730 if ((DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
3731 || CLASSTYPE_TEMPLATE_INSTANTIATION (context
))
3733 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
3734 /* [temp.expl.spec] An explicit specialization of a static data
3735 member of a template is a definition if the declaration
3736 includes an initializer; otherwise, it is a declaration.
3738 We check for processing_specialization so this only applies
3739 to the new specialization syntax. */
3740 if (DECL_INITIAL (decl
) == NULL_TREE
&& processing_specialization
)
3741 DECL_EXTERNAL (decl
) = 1;
3744 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
))
3745 pedwarn ("declaration of `%#D' outside of class is not definition",
3749 /* Enter this declaration into the symbol table. */
3750 tem
= maybe_push_decl (decl
);
3752 if (processing_template_decl
)
3753 tem
= push_template_decl (tem
);
3754 if (tem
== error_mark_node
)
3755 return error_mark_node
;
3757 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
3758 /* Tell the back-end to use or not use .common as appropriate. If we say
3759 -fconserve-space, we want this to save .data space, at the expense of
3760 wrong semantics. If we say -fno-conserve-space, we want this to
3761 produce errors about redefs; to do this we force variables into the
3763 DECL_COMMON (tem
) = ((TREE_CODE (tem
) != VAR_DECL
3764 || !DECL_THREAD_LOCAL (tem
))
3765 && (flag_conserve_space
|| ! TREE_PUBLIC (tem
)));
3768 if (! processing_template_decl
)
3775 start_decl_1 (tree decl
)
3777 tree type
= TREE_TYPE (decl
);
3778 int initialized
= (DECL_INITIAL (decl
) != NULL_TREE
);
3780 if (type
== error_mark_node
)
3784 /* Is it valid for this decl to have an initializer at all?
3785 If not, set INITIALIZED to zero, which will indirectly
3786 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
3788 /* Don't allow initializations for incomplete types except for
3789 arrays which might be completed by the initialization. */
3790 if (COMPLETE_TYPE_P (complete_type (type
)))
3791 ; /* A complete type is ok. */
3792 else if (TREE_CODE (type
) != ARRAY_TYPE
)
3794 error ("variable `%#D' has initializer but incomplete type",
3797 type
= TREE_TYPE (decl
) = error_mark_node
;
3799 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
3801 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
3802 error ("elements of array `%#D' have incomplete type", decl
);
3803 /* else we already gave an error in start_decl. */
3809 && TREE_CODE (decl
) != TYPE_DECL
3810 && TREE_CODE (decl
) != TEMPLATE_DECL
3811 && type
!= error_mark_node
3812 && IS_AGGR_TYPE (type
)
3813 && ! DECL_EXTERNAL (decl
))
3815 if ((! processing_template_decl
|| ! uses_template_parms (type
))
3816 && !COMPLETE_TYPE_P (complete_type (type
)))
3818 error ("aggregate `%#D' has incomplete type and cannot be defined",
3820 /* Change the type so that assemble_variable will give
3821 DECL an rtl we can live with: (mem (const_int 0)). */
3822 type
= TREE_TYPE (decl
) = error_mark_node
;
3826 /* If any base type in the hierarchy of TYPE needs a constructor,
3827 then we set initialized to 1. This way any nodes which are
3828 created for the purposes of initializing this aggregate
3829 will live as long as it does. This is necessary for global
3830 aggregates which do not have their initializers processed until
3831 the end of the file. */
3832 initialized
= TYPE_NEEDS_CONSTRUCTING (type
);
3837 DECL_INITIAL (decl
) = NULL_TREE
;
3839 /* Create a new scope to hold this declaration if necessary.
3840 Whether or not a new scope is necessary cannot be determined
3841 until after the type has been completed; if the type is a
3842 specialization of a class template it is not until after
3843 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
3844 will be set correctly. */
3845 maybe_push_cleanup_level (type
);
3848 /* Handle initialization of references. DECL, TYPE, and INIT have the
3849 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
3850 but will be set to a new CLEANUP_STMT if a temporary is created
3851 that must be destroyed subsequently.
3853 Returns an initializer expression to use to initialize DECL, or
3854 NULL if the initialization can be performed statically.
3856 Quotes on semantics can be found in ARM 8.4.3. */
3859 grok_reference_init (tree decl
, tree type
, tree init
, tree
*cleanup
)
3863 if (init
== NULL_TREE
)
3865 if ((DECL_LANG_SPECIFIC (decl
) == 0
3866 || DECL_IN_AGGR_P (decl
) == 0)
3867 && ! DECL_THIS_EXTERN (decl
))
3868 error ("`%D' declared as reference but not initialized", decl
);
3872 if (TREE_CODE (init
) == CONSTRUCTOR
)
3874 error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl
);
3878 if (TREE_CODE (init
) == TREE_LIST
)
3879 init
= build_x_compound_expr_from_list (init
, "initializer");
3881 if (TREE_CODE (TREE_TYPE (init
)) == REFERENCE_TYPE
)
3882 init
= convert_from_reference (init
);
3884 if (TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
3885 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
3886 /* Note: default conversion is only called in very special cases. */
3887 init
= decay_conversion (init
);
3889 /* Convert INIT to the reference type TYPE. This may involve the
3890 creation of a temporary, whose lifetime must be the same as that
3891 of the reference. If so, a DECL_EXPR for the temporary will be
3892 added just after the DECL_EXPR for DECL. That's why we don't set
3893 DECL_INITIAL for local references (instead assigning to them
3894 explicitly); we need to allow the temporary to be initialized
3896 tmp
= initialize_reference (type
, init
, decl
, cleanup
);
3898 if (tmp
== error_mark_node
)
3900 else if (tmp
== NULL_TREE
)
3902 error ("cannot initialize `%T' from `%T'", type
, TREE_TYPE (init
));
3906 if (TREE_STATIC (decl
) && !TREE_CONSTANT (tmp
))
3909 DECL_INITIAL (decl
) = tmp
;
3914 /* When parsing `int a[] = {1, 2};' we don't know the size of the
3915 array until we finish parsing the initializer. If that's the
3916 situation we're in, update DECL accordingly. */
3919 maybe_deduce_size_from_array_init (tree decl
, tree init
)
3921 tree type
= TREE_TYPE (decl
);
3923 if (TREE_CODE (type
) == ARRAY_TYPE
3924 && TYPE_DOMAIN (type
) == NULL_TREE
3925 && TREE_CODE (decl
) != TYPE_DECL
)
3927 /* do_default is really a C-ism to deal with tentative definitions.
3928 But let's leave it here to ease the eventual merge. */
3929 int do_default
= !DECL_EXTERNAL (decl
);
3930 tree initializer
= init
? init
: DECL_INITIAL (decl
);
3931 int failure
= complete_array_type (type
, initializer
, do_default
);
3934 error ("initializer fails to determine size of `%D'", decl
);
3939 error ("array size missing in `%D'", decl
);
3940 /* If a `static' var's size isn't known, make it extern as
3941 well as static, so it does not get allocated. If it's not
3942 `static', then don't mark it extern; finish_incomplete_decl
3943 will give it a default size and it will get allocated. */
3944 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
3945 DECL_EXTERNAL (decl
) = 1;
3948 if (pedantic
&& TYPE_DOMAIN (type
) != NULL_TREE
3949 && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)),
3951 error ("zero-size array `%D'", decl
);
3953 layout_decl (decl
, 0);
3957 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
3958 any appropriate error messages regarding the layout. */
3961 layout_var_decl (tree decl
)
3963 tree type
= TREE_TYPE (decl
);
3965 tree ttype
= target_type (type
);
3968 /* If we haven't already layed out this declaration, do so now.
3969 Note that we must not call complete type for an external object
3970 because it's type might involve templates that we are not
3971 supposed to instantiate yet. (And it's perfectly valid to say
3972 `extern X x' for some incomplete type `X'.) */
3973 if (!DECL_EXTERNAL (decl
))
3974 complete_type (type
);
3975 if (!DECL_SIZE (decl
)
3976 && TREE_TYPE (decl
) != error_mark_node
3977 && (COMPLETE_TYPE_P (type
)
3978 || (TREE_CODE (type
) == ARRAY_TYPE
3979 && !TYPE_DOMAIN (type
)
3980 && COMPLETE_TYPE_P (TREE_TYPE (type
)))))
3981 layout_decl (decl
, 0);
3983 if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
3985 /* An automatic variable with an incomplete type: that is an error.
3986 Don't talk about array types here, since we took care of that
3987 message in grokdeclarator. */
3988 error ("storage size of `%D' isn't known", decl
);
3989 TREE_TYPE (decl
) = error_mark_node
;
3992 /* Keep this code around in case we later want to control debug info
3993 based on whether a type is "used". (jason 1999-11-11) */
3995 else if (!DECL_EXTERNAL (decl
) && IS_AGGR_TYPE (ttype
))
3996 /* Let debugger know it should output info for this type. */
3997 note_debug_info_needed (ttype
);
3999 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
4000 note_debug_info_needed (DECL_CONTEXT (decl
));
4003 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
4004 && DECL_SIZE (decl
) != NULL_TREE
4005 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
4007 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
4008 constant_expression_warning (DECL_SIZE (decl
));
4010 error ("storage size of `%D' isn't constant", decl
);
4013 if (TREE_STATIC (decl
)
4014 && !DECL_ARTIFICIAL (decl
)
4015 && current_function_decl
4016 && DECL_CONTEXT (decl
) == current_function_decl
)
4017 push_local_name (decl
);
4020 /* If a local static variable is declared in an inline function, or if
4021 we have a weak definition, we must endeavor to create only one
4022 instance of the variable at link-time. */
4025 maybe_commonize_var (tree decl
)
4027 /* Static data in a function with comdat linkage also has comdat
4029 if (TREE_STATIC (decl
)
4030 /* Don't mess with __FUNCTION__. */
4031 && ! DECL_ARTIFICIAL (decl
)
4032 && DECL_FUNCTION_SCOPE_P (decl
)
4033 /* Unfortunately, import_export_decl has not always been called
4034 before the function is processed, so we cannot simply check
4036 && (DECL_COMDAT (DECL_CONTEXT (decl
))
4037 || ((DECL_DECLARED_INLINE_P (DECL_CONTEXT (decl
))
4038 || DECL_TEMPLATE_INSTANTIATION (DECL_CONTEXT (decl
)))
4039 && TREE_PUBLIC (DECL_CONTEXT (decl
)))))
4043 /* With weak symbols, we simply make the variable COMDAT;
4044 that will cause copies in multiple translations units to
4046 comdat_linkage (decl
);
4050 if (DECL_INITIAL (decl
) == NULL_TREE
4051 || DECL_INITIAL (decl
) == error_mark_node
)
4053 /* Without weak symbols, we can use COMMON to merge
4054 uninitialized variables. */
4055 TREE_PUBLIC (decl
) = 1;
4056 DECL_COMMON (decl
) = 1;
4060 /* While for initialized variables, we must use internal
4061 linkage -- which means that multiple copies will not
4063 TREE_PUBLIC (decl
) = 0;
4064 DECL_COMMON (decl
) = 0;
4065 cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl
);
4066 warning ("%J you can work around this by removing the initializer",
4071 else if (DECL_LANG_SPECIFIC (decl
) && DECL_COMDAT (decl
))
4072 /* Set it up again; we might have set DECL_INITIAL since the last
4074 comdat_linkage (decl
);
4077 /* Issue an error message if DECL is an uninitialized const variable. */
4080 check_for_uninitialized_const_var (tree decl
)
4082 tree type
= TREE_TYPE (decl
);
4084 /* ``Unless explicitly declared extern, a const object does not have
4085 external linkage and must be initialized. ($8.4; $12.1)'' ARM
4087 if (TREE_CODE (decl
) == VAR_DECL
4088 && TREE_CODE (type
) != REFERENCE_TYPE
4089 && CP_TYPE_CONST_P (type
)
4090 && !TYPE_NEEDS_CONSTRUCTING (type
)
4091 && !DECL_INITIAL (decl
))
4092 error ("uninitialized const `%D'", decl
);
4095 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
4096 returned is the next FIELD_DECL (possibly FIELD itself) that can be
4097 initialized. If there are no more such fields, the return value
4101 next_initializable_field (tree field
)
4104 && (TREE_CODE (field
) != FIELD_DECL
4105 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
4106 || DECL_ARTIFICIAL (field
)))
4107 field
= TREE_CHAIN (field
);
4112 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
4113 brace-enclosed aggregate initializer.
4115 *INITP is one of a list of initializers describing a brace-enclosed
4116 initializer for an entity of the indicated aggregate TYPE. It may
4117 not presently match the shape of the TYPE; for example:
4119 struct S { int a; int b; };
4120 struct S a[] = { 1, 2, 3, 4 };
4122 Here *INITP will point to TREE_LIST of four elements, rather than a
4123 list of two elements, each itself a list of two elements. This
4124 routine transforms INIT from the former form into the latter. The
4125 revised initializer is returned. */
4128 reshape_init (tree type
, tree
*initp
)
4132 tree old_init_value
;
4134 bool brace_enclosed_p
;
4137 old_init_value
= (TREE_CODE (*initp
) == TREE_LIST
4138 ? TREE_VALUE (*initp
) : old_init
);
4140 gcc_assert (old_init_value
);
4142 /* If the initializer is brace-enclosed, pull initializers from the
4143 enclosed elements. Advance past the brace-enclosed initializer
4145 if (TREE_CODE (old_init_value
) == CONSTRUCTOR
4146 && BRACE_ENCLOSED_INITIALIZER_P (old_init_value
))
4148 *initp
= TREE_CHAIN (old_init
);
4149 TREE_CHAIN (old_init
) = NULL_TREE
;
4150 inits
= CONSTRUCTOR_ELTS (old_init_value
);
4152 brace_enclosed_p
= true;
4157 brace_enclosed_p
= false;
4160 /* A non-aggregate type is always initialized with a single
4162 if (!CP_AGGREGATE_TYPE_P (type
))
4164 *initp
= TREE_CHAIN (old_init
);
4165 TREE_CHAIN (old_init
) = NULL_TREE
;
4166 /* It is invalid to initialize a non-aggregate type with a
4167 brace-enclosed initializer. */
4168 if (brace_enclosed_p
)
4170 error ("brace-enclosed initializer used to initialize `%T'",
4172 if (TREE_CODE (old_init
) == TREE_LIST
)
4173 TREE_VALUE (old_init
) = error_mark_node
;
4175 old_init
= error_mark_node
;
4183 All implicit type conversions (clause _conv_) are considered when
4184 initializing the aggregate member with an initializer from an
4185 initializer-list. If the initializer can initialize a member,
4186 the member is initialized. Otherwise, if the member is itself a
4187 non-empty subaggregate, brace elision is assumed and the
4188 initializer is considered for the initialization of the first
4189 member of the subaggregate. */
4190 if (!brace_enclosed_p
4191 && can_convert_arg (type
, TREE_TYPE (old_init_value
), old_init_value
))
4193 *initp
= TREE_CHAIN (old_init
);
4194 TREE_CHAIN (old_init
) = NULL_TREE
;
4198 if (TREE_CODE (old_init_value
) == STRING_CST
4199 && TREE_CODE (type
) == ARRAY_TYPE
4200 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type
))))
4202 /* [dcl.init.string]
4204 A char array (whether plain char, signed char, or unsigned char)
4205 can be initialized by a string-literal (optionally enclosed in
4206 braces); a wchar_t array can be initialized by a wide
4207 string-literal (optionally enclosed in braces). */
4208 new_init
= old_init
;
4209 /* Move past the initializer. */
4210 *initp
= TREE_CHAIN (old_init
);
4211 TREE_CHAIN (old_init
) = NULL_TREE
;
4215 /* Build a CONSTRUCTOR to hold the contents of the aggregate. */
4216 new_init
= build_constructor (NULL_TREE
, NULL_TREE
);
4218 if (CLASS_TYPE_P (type
))
4222 field
= next_initializable_field (TYPE_FIELDS (type
));
4228 An initializer for an aggregate member that is an
4229 empty class shall have the form of an empty
4230 initializer-list {}. */
4231 if (!brace_enclosed_p
)
4233 error ("initializer for `%T' must be brace-enclosed",
4235 return error_mark_node
;
4240 /* Loop through the initializable fields, gathering
4246 /* Handle designated initializers, as an extension. */
4247 if (TREE_PURPOSE (*initp
))
4250 pedwarn ("ISO C++ does not allow designated initializers");
4251 field
= lookup_field_1 (type
, TREE_PURPOSE (*initp
),
4252 /*want_type=*/false);
4253 if (!field
|| TREE_CODE (field
) != FIELD_DECL
)
4254 error ("`%T' has no non-static data member named `%D'",
4255 type
, TREE_PURPOSE (*initp
));
4260 field_init
= reshape_init (TREE_TYPE (field
), initp
);
4261 if (field_init
== error_mark_node
)
4262 return error_mark_node
;
4263 TREE_CHAIN (field_init
) = CONSTRUCTOR_ELTS (new_init
);
4264 CONSTRUCTOR_ELTS (new_init
) = field_init
;
4267 When a union is initialized with a brace-enclosed
4268 initializer, the braces shall only contain an
4269 initializer for the first member of the union. */
4270 if (TREE_CODE (type
) == UNION_TYPE
)
4272 field
= next_initializable_field (TREE_CHAIN (field
));
4276 else if (TREE_CODE (type
) == ARRAY_TYPE
4277 || TREE_CODE (type
) == VECTOR_TYPE
)
4282 /* If the bound of the array is known, take no more initializers
4283 than are allowed. */
4284 max_index
= NULL_TREE
;
4285 if (TREE_CODE (type
) == ARRAY_TYPE
)
4287 if (TYPE_DOMAIN (type
))
4288 max_index
= array_type_nelts (type
);
4292 /* For a vector, the representation type is a struct
4293 containing a single member which is an array of the
4294 appropriate size. */
4295 tree rtype
= TYPE_DEBUG_REPRESENTATION_TYPE (type
);
4296 if (rtype
&& TYPE_DOMAIN (TREE_TYPE (TYPE_FIELDS (rtype
))))
4297 max_index
= array_type_nelts (TREE_TYPE (TYPE_FIELDS (rtype
)));
4300 /* Loop through the array elements, gathering initializers. */
4301 for (index
= size_zero_node
;
4302 *initp
&& (!max_index
|| !tree_int_cst_lt (max_index
, index
));
4303 index
= size_binop (PLUS_EXPR
, index
, size_one_node
))
4307 element_init
= reshape_init (TREE_TYPE (type
), initp
);
4308 if (element_init
== error_mark_node
)
4309 return error_mark_node
;
4310 TREE_CHAIN (element_init
) = CONSTRUCTOR_ELTS (new_init
);
4311 CONSTRUCTOR_ELTS (new_init
) = element_init
;
4312 if (TREE_PURPOSE (element_init
))
4314 tree next_index
= TREE_PURPOSE (element_init
);
4315 if (TREE_CODE (next_index
) == IDENTIFIER_NODE
)
4317 error ("name `%D' used in a GNU-style designated "
4318 "initializer for an array", next_index
);
4319 TREE_PURPOSE (element_init
) = NULL_TREE
;
4329 /* The initializers were placed in reverse order in the
4331 CONSTRUCTOR_ELTS (new_init
) = nreverse (CONSTRUCTOR_ELTS (new_init
));
4333 if (TREE_CODE (old_init
) == TREE_LIST
)
4334 new_init
= build_tree_list (TREE_PURPOSE (old_init
), new_init
);
4337 /* If this was a brace-enclosed initializer and all of the
4338 initializers were not used up, there is a problem. */
4339 if (brace_enclosed_p
&& *initp
)
4340 error ("too many initializers for `%T'", type
);
4345 /* Verify INIT (the initializer for DECL), and record the
4346 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
4347 grok_reference_init.
4349 If the return value is non-NULL, it is an expression that must be
4350 evaluated dynamically to initialize DECL. */
4353 check_initializer (tree decl
, tree init
, int flags
, tree
*cleanup
)
4355 tree type
= TREE_TYPE (decl
);
4356 tree init_code
= NULL
;
4358 /* If `start_decl' didn't like having an initialization, ignore it now. */
4359 if (init
!= NULL_TREE
&& DECL_INITIAL (decl
) == NULL_TREE
)
4362 /* If an initializer is present, DECL_INITIAL has been
4363 error_mark_node, to indicate that an as-of-yet unevaluated
4364 initialization will occur. From now on, DECL_INITIAL reflects
4365 the static initialization -- if any -- of DECL. */
4366 DECL_INITIAL (decl
) = NULL_TREE
;
4368 /* Things that are going to be initialized need to have complete
4370 TREE_TYPE (decl
) = type
= complete_type (TREE_TYPE (decl
));
4372 if (type
== error_mark_node
)
4373 /* We will have already complained. */
4375 else if (init
&& COMPLETE_TYPE_P (type
)
4376 && !TREE_CONSTANT (TYPE_SIZE (type
)))
4378 error ("variable-sized object `%D' may not be initialized", decl
);
4381 else if (TREE_CODE (type
) == ARRAY_TYPE
4382 && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
4384 error ("elements of array `%#D' have incomplete type", decl
);
4387 else if (TREE_CODE (type
) != ARRAY_TYPE
&& !COMPLETE_TYPE_P (type
))
4389 error ("`%D' has incomplete type", decl
);
4390 TREE_TYPE (decl
) = error_mark_node
;
4394 if (TREE_CODE (decl
) == CONST_DECL
)
4396 gcc_assert (TREE_CODE (decl
) != REFERENCE_TYPE
);
4398 DECL_INITIAL (decl
) = init
;
4400 gcc_assert (init
!= NULL_TREE
);
4403 else if (!DECL_EXTERNAL (decl
) && TREE_CODE (type
) == REFERENCE_TYPE
)
4404 init
= grok_reference_init (decl
, type
, init
, cleanup
);
4407 if (TREE_CODE (init
) == CONSTRUCTOR
4408 && BRACE_ENCLOSED_INITIALIZER_P (init
))
4410 /* [dcl.init] paragraph 13,
4411 If T is a scalar type, then a declaration of the form
4416 reshape_init will complain about the extra braces,
4417 and doesn't do anything useful in the case where TYPE is
4418 scalar, so just don't call it. */
4419 if (CP_AGGREGATE_TYPE_P (type
))
4420 init
= reshape_init (type
, &init
);
4422 if ((*targetm
.vector_opaque_p
) (type
))
4424 error ("opaque vector types cannot be initialized");
4425 init
= error_mark_node
;
4429 /* If DECL has an array type without a specific bound, deduce the
4430 array size from the initializer. */
4431 maybe_deduce_size_from_array_init (decl
, init
);
4432 type
= TREE_TYPE (decl
);
4434 if (TYPE_HAS_CONSTRUCTOR (type
) || TYPE_NEEDS_CONSTRUCTING (type
))
4436 if (TREE_CODE (type
) == ARRAY_TYPE
)
4437 goto initialize_aggr
;
4438 else if (TREE_CODE (init
) == CONSTRUCTOR
4439 && BRACE_ENCLOSED_INITIALIZER_P (init
))
4441 if (TYPE_NON_AGGREGATE_CLASS (type
))
4443 error ("`%D' must be initialized by constructor, not by `{...}'",
4445 init
= error_mark_node
;
4448 goto dont_use_constructor
;
4452 int saved_stmts_are_full_exprs_p
;
4455 saved_stmts_are_full_exprs_p
= 0;
4456 if (building_stmt_tree ())
4458 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
4459 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
4461 init
= build_aggr_init (decl
, init
, flags
);
4462 if (building_stmt_tree ())
4463 current_stmt_tree ()->stmts_are_full_exprs_p
=
4464 saved_stmts_are_full_exprs_p
;
4470 dont_use_constructor
:
4471 if (TREE_CODE (init
) != TREE_VEC
)
4473 init_code
= store_init_value (decl
, init
);
4478 else if (DECL_EXTERNAL (decl
))
4480 else if (TYPE_P (type
) && TYPE_NEEDS_CONSTRUCTING (type
))
4481 goto initialize_aggr
;
4482 else if (IS_AGGR_TYPE (type
))
4484 tree core_type
= strip_array_types (type
);
4486 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
))
4487 error ("structure `%D' with uninitialized const members", decl
);
4488 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
))
4489 error ("structure `%D' with uninitialized reference members",
4492 check_for_uninitialized_const_var (decl
);
4495 check_for_uninitialized_const_var (decl
);
4497 if (init
&& init
!= error_mark_node
)
4498 init_code
= build2 (INIT_EXPR
, type
, decl
, init
);
4503 /* If DECL is not a local variable, give it RTL. */
4506 make_rtl_for_nonlocal_decl (tree decl
, tree init
, const char* asmspec
)
4508 int toplev
= toplevel_bindings_p ();
4511 /* Set the DECL_ASSEMBLER_NAME for the object. */
4514 /* The `register' keyword, when used together with an
4515 asm-specification, indicates that the variable should be
4516 placed in a particular register. */
4517 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_REGISTER (decl
))
4519 change_decl_assembler_name (decl
, get_identifier (asmspec
));
4520 DECL_HARD_REGISTER (decl
) = 1;
4523 set_user_assembler_name (decl
, asmspec
);
4526 /* Handle non-variables up front. */
4527 if (TREE_CODE (decl
) != VAR_DECL
)
4529 rest_of_decl_compilation (decl
, toplev
, at_eof
);
4533 /* If we see a class member here, it should be a static data
4535 if (DECL_LANG_SPECIFIC (decl
) && DECL_IN_AGGR_P (decl
))
4537 gcc_assert (TREE_STATIC (decl
));
4538 /* An in-class declaration of a static data member should be
4539 external; it is only a declaration, and not a definition. */
4540 if (init
== NULL_TREE
)
4541 gcc_assert (DECL_EXTERNAL (decl
));
4544 /* We don't create any RTL for local variables. */
4545 if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
4548 /* We defer emission of local statics until the corresponding
4549 DECL_EXPR is expanded. */
4550 defer_p
= DECL_FUNCTION_SCOPE_P (decl
) || DECL_VIRTUAL_P (decl
);
4552 /* We try to defer namespace-scope static constants so that they are
4553 not emitted into the object file unnecessarily. */
4554 if (!DECL_VIRTUAL_P (decl
)
4555 && TREE_READONLY (decl
)
4556 && DECL_INITIAL (decl
) != NULL_TREE
4557 && DECL_INITIAL (decl
) != error_mark_node
4558 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
))
4560 && !TREE_PUBLIC (decl
))
4562 /* Fool with the linkage of static consts according to #pragma
4564 if (!interface_unknown
&& !TREE_PUBLIC (decl
))
4566 TREE_PUBLIC (decl
) = 1;
4567 DECL_EXTERNAL (decl
) = interface_only
;
4572 /* Likewise for template instantiations. */
4573 else if (DECL_LANG_SPECIFIC (decl
)
4574 && DECL_IMPLICIT_INSTANTIATION (decl
))
4577 /* If we're not deferring, go ahead and assemble the variable. */
4579 rest_of_decl_compilation (decl
, toplev
, at_eof
);
4582 /* Generate code to initialize DECL (a local variable). */
4585 initialize_local_var (tree decl
, tree init
)
4587 tree type
= TREE_TYPE (decl
);
4590 gcc_assert (TREE_CODE (decl
) == VAR_DECL
4591 || TREE_CODE (decl
) == RESULT_DECL
);
4592 gcc_assert (!TREE_STATIC (decl
));
4594 if (DECL_SIZE (decl
) == NULL_TREE
)
4596 /* If we used it already as memory, it must stay in memory. */
4597 DECL_INITIAL (decl
) = NULL_TREE
;
4598 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
4601 if (DECL_SIZE (decl
) && type
!= error_mark_node
)
4605 /* Compute and store the initial value. */
4606 already_used
= TREE_USED (decl
) || TREE_USED (type
);
4608 /* Perform the initialization. */
4611 int saved_stmts_are_full_exprs_p
;
4613 gcc_assert (building_stmt_tree ());
4614 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
4615 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
4616 finish_expr_stmt (init
);
4617 current_stmt_tree ()->stmts_are_full_exprs_p
=
4618 saved_stmts_are_full_exprs_p
;
4621 /* Set this to 0 so we can tell whether an aggregate which was
4622 initialized was ever used. Don't do this if it has a
4623 destructor, so we don't complain about the 'resource
4624 allocation is initialization' idiom. Now set
4625 attribute((unused)) on types so decls of that type will be
4626 marked used. (see TREE_USED, above.) */
4627 if (TYPE_NEEDS_CONSTRUCTING (type
)
4629 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type
)
4630 && DECL_NAME (decl
))
4631 TREE_USED (decl
) = 0;
4632 else if (already_used
)
4633 TREE_USED (decl
) = 1;
4636 /* Generate a cleanup, if necessary. */
4637 cleanup
= cxx_maybe_build_cleanup (decl
);
4638 if (DECL_SIZE (decl
) && cleanup
)
4639 finish_decl_cleanup (decl
, cleanup
);
4642 /* Finish processing of a declaration;
4643 install its line number and initial value.
4644 If the length of an array type is not known before,
4645 it must be determined now, from the initial value, or it is an error.
4647 INIT holds the value of an initializer that should be allowed to escape
4650 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
4651 if the (init) syntax was used. */
4654 cp_finish_decl (tree decl
, tree init
, tree asmspec_tree
, int flags
)
4657 tree ttype
= NULL_TREE
;
4659 const char *asmspec
= NULL
;
4660 int was_readonly
= 0;
4662 if (decl
== error_mark_node
)
4667 error ("assignment (not initialization) in declaration");
4671 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
4673 /* Assume no cleanup is required. */
4674 cleanup
= NULL_TREE
;
4676 /* If a name was specified, get the string. */
4677 if (global_scope_p (current_binding_level
))
4678 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
4680 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
4682 if (init
&& TREE_CODE (init
) == NAMESPACE_DECL
)
4684 error ("cannot initialize `%D' to namespace `%D'",
4689 if (current_class_type
4690 && CP_DECL_CONTEXT (decl
) == current_class_type
4691 && TYPE_BEING_DEFINED (current_class_type
)
4692 && (DECL_INITIAL (decl
) || init
))
4693 DECL_INITIALIZED_IN_CLASS_P (decl
) = 1;
4695 type
= TREE_TYPE (decl
);
4697 if (type
== error_mark_node
)
4700 if (TYPE_HAS_MUTABLE_P (type
))
4701 TREE_READONLY (decl
) = 0;
4703 if (processing_template_decl
)
4705 /* Add this declaration to the statement-tree. */
4706 if (at_function_scope_p ())
4707 add_decl_expr (decl
);
4709 if (init
&& DECL_INITIAL (decl
))
4710 DECL_INITIAL (decl
) = init
;
4711 if (TREE_CODE (decl
) == VAR_DECL
4712 && !DECL_PRETTY_FUNCTION_P (decl
)
4713 && !dependent_type_p (TREE_TYPE (decl
)))
4714 maybe_deduce_size_from_array_init (decl
, init
);
4718 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
4719 gcc_assert (TREE_CODE (decl
) != PARM_DECL
);
4721 /* Take care of TYPE_DECLs up front. */
4722 if (TREE_CODE (decl
) == TYPE_DECL
)
4724 if (type
!= error_mark_node
4725 && IS_AGGR_TYPE (type
) && DECL_NAME (decl
))
4727 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
4728 warning ("shadowing previous type declaration of `%#D'", decl
);
4729 set_identifier_type_value (DECL_NAME (decl
), decl
);
4732 /* If we have installed this as the canonical typedef for this
4733 type, and that type has not been defined yet, delay emitting
4734 the debug information for it, as we will emit it later. */
4735 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
4736 && !COMPLETE_TYPE_P (TREE_TYPE (decl
)))
4737 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
4739 rest_of_decl_compilation (decl
, DECL_CONTEXT (decl
) == NULL_TREE
,
4744 if (TREE_CODE (decl
) != FUNCTION_DECL
)
4745 ttype
= target_type (type
);
4748 /* Currently, GNU C++ puts constants in text space, making them
4749 impossible to initialize. In the future, one would hope for
4750 an operating system which understood the difference between
4751 initialization and the running of a program. */
4752 if (! DECL_EXTERNAL (decl
) && TREE_READONLY (decl
))
4755 if (TYPE_NEEDS_CONSTRUCTING (type
)
4756 || TREE_CODE (type
) == REFERENCE_TYPE
)
4757 TREE_READONLY (decl
) = 0;
4760 if (TREE_CODE (decl
) == VAR_DECL
)
4762 /* Only PODs can have thread-local storage. Other types may require
4763 various kinds of non-trivial initialization. */
4764 if (DECL_THREAD_LOCAL (decl
) && !pod_type_p (TREE_TYPE (decl
)))
4765 error ("`%D' cannot be thread-local because it has non-POD type `%T'",
4766 decl
, TREE_TYPE (decl
));
4767 /* Convert the initializer to the type of DECL, if we have not
4768 already initialized DECL. */
4769 if (!DECL_INITIALIZED_P (decl
)
4770 /* If !DECL_EXTERNAL then DECL is being defined. In the
4771 case of a static data member initialized inside the
4772 class-specifier, there can be an initializer even if DECL
4773 is *not* defined. */
4774 && (!DECL_EXTERNAL (decl
) || init
))
4776 init
= check_initializer (decl
, init
, flags
, &cleanup
);
4777 /* Thread-local storage cannot be dynamically initialized. */
4778 if (DECL_THREAD_LOCAL (decl
) && init
)
4780 error ("`%D' is thread-local and so cannot be dynamically "
4781 "initialized", decl
);
4788 The memory occupied by any object of static storage
4789 duration is zero-initialized at program startup before
4790 any other initialization takes place.
4792 We cannot create an appropriate initializer until after
4793 the type of DECL is finalized. If DECL_INITIAL is set,
4794 then the DECL is statically initialized, and any
4795 necessary zero-initialization has already been performed. */
4796 if (TREE_STATIC (decl
) && !DECL_INITIAL (decl
))
4797 DECL_INITIAL (decl
) = build_zero_init (TREE_TYPE (decl
),
4798 /*nelts=*/NULL_TREE
,
4799 /*static_storage_p=*/true);
4800 /* Remember that the initialization for this variable has
4802 DECL_INITIALIZED_P (decl
) = 1;
4803 /* The variable is being defined, so determine its
4805 determine_visibility (decl
);
4807 /* If the variable has an array type, lay out the type, even if
4808 there is no initializer. It is valid to index through the
4809 array, and we must get TYPE_ALIGN set correctly on the array
4811 else if (TREE_CODE (type
) == ARRAY_TYPE
)
4815 /* Add this declaration to the statement-tree. This needs to happen
4816 after the call to check_initializer so that the DECL_EXPR for a
4817 reference temp is added before the DECL_EXPR for the reference itself. */
4818 if (at_function_scope_p ())
4819 add_decl_expr (decl
);
4821 if (TREE_CODE (decl
) == VAR_DECL
)
4822 layout_var_decl (decl
);
4824 /* Output the assembler code and/or RTL code for variables and functions,
4825 unless the type is an undefined structure or union.
4826 If not, it will get done when the type is completed. */
4827 if (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == FUNCTION_DECL
)
4829 if (TREE_CODE (decl
) == VAR_DECL
)
4830 maybe_commonize_var (decl
);
4832 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
);
4834 /* Check for abstractness of the type. Notice that there is no
4835 need to strip array types here since the check for those types
4836 is already done within create_array_type_for_decl. */
4837 if (TREE_CODE (type
) == FUNCTION_TYPE
4838 || TREE_CODE (type
) == METHOD_TYPE
)
4839 abstract_virtuals_error (decl
, TREE_TYPE (type
));
4841 abstract_virtuals_error (decl
, type
);
4843 if (TREE_CODE (decl
) == FUNCTION_DECL
4844 || TREE_TYPE (decl
) == error_mark_node
)
4845 /* No initialization required. */
4847 else if (DECL_EXTERNAL (decl
)
4848 && ! (DECL_LANG_SPECIFIC (decl
)
4849 && DECL_NOT_REALLY_EXTERN (decl
)))
4852 DECL_INITIAL (decl
) = init
;
4856 /* A variable definition. */
4857 if (DECL_FUNCTION_SCOPE_P (decl
))
4859 /* Initialize the local variable. */
4860 if (processing_template_decl
)
4862 if (init
|| DECL_INITIAL (decl
) == error_mark_node
)
4863 DECL_INITIAL (decl
) = init
;
4865 else if (!TREE_STATIC (decl
))
4866 initialize_local_var (decl
, init
);
4869 if (TREE_STATIC (decl
))
4870 expand_static_init (decl
, init
);
4874 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
4875 reference, insert it in the statement-tree now. */
4877 push_cleanup (decl
, cleanup
, false);
4882 TREE_READONLY (decl
) = 1;
4884 /* If this was marked 'used', be sure it will be output. */
4885 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl
)))
4886 mark_decl_referenced (decl
);
4889 /* This is here for a midend callback from c-common.c. */
4892 finish_decl (tree decl
, tree init
, tree asmspec_tree
)
4894 cp_finish_decl (decl
, init
, asmspec_tree
, 0);
4897 /* Returns a declaration for a VAR_DECL as if:
4899 extern "C" TYPE NAME;
4901 had been seen. Used to create compiler-generated global
4905 declare_global_var (tree name
, tree type
)
4909 push_to_top_level ();
4910 decl
= build_decl (VAR_DECL
, name
, type
);
4911 TREE_PUBLIC (decl
) = 1;
4912 DECL_EXTERNAL (decl
) = 1;
4913 DECL_ARTIFICIAL (decl
) = 1;
4915 cp_finish_decl (decl
, NULL_TREE
, NULL_TREE
, 0);
4916 pop_from_top_level ();
4921 /* Returns a pointer to the `atexit' function. Note that if
4922 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
4923 `__cxa_atexit' function specified in the IA64 C++ ABI. */
4926 get_atexit_node (void)
4937 if (flag_use_cxa_atexit
)
4939 /* The declaration for `__cxa_atexit' is:
4941 int __cxa_atexit (void (*)(void *), void *, void *)
4943 We build up the argument types and then then function type
4946 /* First, build the pointer-to-function type for the first
4948 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, void_list_node
);
4949 fn_type
= build_function_type (void_type_node
, arg_types
);
4950 fn_ptr_type
= build_pointer_type (fn_type
);
4951 /* Then, build the rest of the argument types. */
4952 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, void_list_node
);
4953 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, arg_types
);
4954 arg_types
= tree_cons (NULL_TREE
, fn_ptr_type
, arg_types
);
4955 /* And the final __cxa_atexit type. */
4956 fn_type
= build_function_type (integer_type_node
, arg_types
);
4957 fn_ptr_type
= build_pointer_type (fn_type
);
4958 name
= "__cxa_atexit";
4962 /* The declaration for `atexit' is:
4964 int atexit (void (*)());
4966 We build up the argument types and then then function type
4968 fn_type
= build_function_type (void_type_node
, void_list_node
);
4969 fn_ptr_type
= build_pointer_type (fn_type
);
4970 arg_types
= tree_cons (NULL_TREE
, fn_ptr_type
, void_list_node
);
4971 /* Build the final atexit type. */
4972 fn_type
= build_function_type (integer_type_node
, arg_types
);
4976 /* Now, build the function declaration. */
4977 push_lang_context (lang_name_c
);
4978 atexit_fndecl
= build_library_fn_ptr (name
, fn_type
);
4979 mark_used (atexit_fndecl
);
4980 pop_lang_context ();
4981 atexit_node
= decay_conversion (atexit_fndecl
);
4986 /* Returns the __dso_handle VAR_DECL. */
4989 get_dso_handle_node (void)
4991 if (dso_handle_node
)
4992 return dso_handle_node
;
4994 /* Declare the variable. */
4995 dso_handle_node
= declare_global_var (get_identifier ("__dso_handle"),
4998 return dso_handle_node
;
5001 /* Begin a new function with internal linkage whose job will be simply
5002 to destroy some particular variable. */
5004 static GTY(()) int start_cleanup_cnt
;
5007 start_cleanup_fn (void)
5009 int old_interface_only
= interface_only
;
5010 int old_interface_unknown
= interface_unknown
;
5016 push_to_top_level ();
5018 /* No need to mangle this. */
5019 push_lang_context (lang_name_c
);
5022 interface_unknown
= 1;
5024 /* Build the parameter-types. */
5025 parmtypes
= void_list_node
;
5026 /* Functions passed to __cxa_atexit take an additional parameter.
5027 We'll just ignore it. After we implement the new calling
5028 convention for destructors, we can eliminate the use of
5029 additional cleanup functions entirely in the -fnew-abi case. */
5030 if (flag_use_cxa_atexit
)
5031 parmtypes
= tree_cons (NULL_TREE
, ptr_type_node
, parmtypes
);
5032 /* Build the function type itself. */
5033 fntype
= build_function_type (void_type_node
, parmtypes
);
5034 /* Build the name of the function. */
5035 sprintf (name
, "__tcf_%d", start_cleanup_cnt
++);
5036 /* Build the function declaration. */
5037 fndecl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), fntype
);
5038 /* It's a function with internal linkage, generated by the
5040 TREE_PUBLIC (fndecl
) = 0;
5041 DECL_ARTIFICIAL (fndecl
) = 1;
5042 /* Make the function `inline' so that it is only emitted if it is
5043 actually needed. It is unlikely that it will be inlined, since
5044 it is only called via a function pointer, but we avoid unnecessary
5045 emissions this way. */
5046 DECL_INLINE (fndecl
) = 1;
5047 DECL_DECLARED_INLINE_P (fndecl
) = 1;
5048 DECL_INTERFACE_KNOWN (fndecl
) = 1;
5049 /* Build the parameter. */
5050 if (flag_use_cxa_atexit
)
5054 parmdecl
= cp_build_parm_decl (NULL_TREE
, ptr_type_node
);
5055 DECL_CONTEXT (parmdecl
) = fndecl
;
5056 TREE_USED (parmdecl
) = 1;
5057 DECL_ARGUMENTS (fndecl
) = parmdecl
;
5061 start_preparsed_function (fndecl
, NULL_TREE
, SF_PRE_PARSED
);
5063 interface_unknown
= old_interface_unknown
;
5064 interface_only
= old_interface_only
;
5066 pop_lang_context ();
5068 return current_function_decl
;
5071 /* Finish the cleanup function begun by start_cleanup_fn. */
5074 end_cleanup_fn (void)
5076 expand_or_defer_fn (finish_function (0));
5078 pop_from_top_level ();
5081 /* Generate code to handle the destruction of DECL, an object with
5082 static storage duration. */
5085 register_dtor_fn (tree decl
)
5092 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
5093 return void_zero_node
;
5095 /* Call build_cleanup before we enter the anonymous function so that
5096 any access checks will be done relative to the current scope,
5097 rather than the scope of the anonymous function. */
5098 build_cleanup (decl
);
5100 /* Now start the function. */
5101 cleanup
= start_cleanup_fn ();
5103 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
5104 to the original function, rather than the anonymous one. That
5105 will make the back-end think that nested functions are in use,
5106 which causes confusion. */
5108 push_deferring_access_checks (dk_no_check
);
5109 fcall
= build_cleanup (decl
);
5110 pop_deferring_access_checks ();
5112 /* Create the body of the anonymous function. */
5113 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
5114 finish_expr_stmt (fcall
);
5115 finish_compound_stmt (compound_stmt
);
5118 /* Call atexit with the cleanup function. */
5119 cxx_mark_addressable (cleanup
);
5120 mark_used (cleanup
);
5121 cleanup
= build_unary_op (ADDR_EXPR
, cleanup
, 0);
5122 if (flag_use_cxa_atexit
)
5124 args
= tree_cons (NULL_TREE
,
5125 build_unary_op (ADDR_EXPR
, get_dso_handle_node (), 0),
5127 args
= tree_cons (NULL_TREE
, null_pointer_node
, args
);
5128 args
= tree_cons (NULL_TREE
, cleanup
, args
);
5131 args
= tree_cons (NULL_TREE
, cleanup
, NULL_TREE
);
5132 return build_function_call (get_atexit_node (), args
);
5135 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
5136 is its initializer. Generate code to handle the construction
5137 and destruction of DECL. */
5140 expand_static_init (tree decl
, tree init
)
5142 gcc_assert (TREE_CODE (decl
) == VAR_DECL
);
5143 gcc_assert (TREE_STATIC (decl
));
5145 /* Some variables require no initialization. */
5147 && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
))
5148 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
5151 if (DECL_FUNCTION_SCOPE_P (decl
))
5153 /* Emit code to perform this initialization but once. */
5154 tree if_stmt
, inner_if_stmt
;
5155 tree then_clause
, inner_then_clause
;
5156 tree guard
, guard_addr
, guard_addr_list
;
5157 tree acquire_fn
, release_fn
, abort_fn
;
5160 /* Emit code to perform this initialization but once. This code
5163 static <type> guard;
5164 if (!guard.first_byte) {
5165 if (__cxa_guard_acquire (&guard)) {
5168 // Do initialization.
5169 flag = true; __cxa_guard_release (&guard);
5170 // Register variable for destruction at end of program.
5172 if (!flag) __cxa_guard_abort (&guard);
5176 Note that the `flag' variable is only set to 1 *after* the
5177 initialization is complete. This ensures that an exception,
5178 thrown during the construction, will cause the variable to
5179 reinitialized when we pass through this code again, as per:
5183 If the initialization exits by throwing an exception, the
5184 initialization is not complete, so it will be tried again
5185 the next time control enters the declaration.
5187 This process should be thread-safe, too; multiple threads
5188 should not be able to initialize the variable more than
5191 /* Create the guard variable. */
5192 guard
= get_guard (decl
);
5194 /* Begin the conditional initialization. */
5195 if_stmt
= begin_if_stmt ();
5196 finish_if_stmt_cond (get_guard_cond (guard
), if_stmt
);
5197 then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
5199 if (flag_threadsafe_statics
)
5201 guard_addr
= build_address (guard
);
5202 guard_addr_list
= build_tree_list (NULL_TREE
, guard_addr
);
5204 acquire_fn
= get_identifier ("__cxa_guard_acquire");
5205 release_fn
= get_identifier ("__cxa_guard_release");
5206 abort_fn
= get_identifier ("__cxa_guard_abort");
5207 if (!get_global_value_if_present (acquire_fn
, &acquire_fn
))
5209 tree argtypes
= tree_cons (NULL_TREE
, TREE_TYPE (guard_addr
),
5211 tree vfntype
= build_function_type (void_type_node
, argtypes
);
5212 acquire_fn
= push_library_fn
5213 (acquire_fn
, build_function_type (integer_type_node
, argtypes
));
5214 release_fn
= push_library_fn (release_fn
, vfntype
);
5215 abort_fn
= push_library_fn (abort_fn
, vfntype
);
5219 release_fn
= identifier_global_value (release_fn
);
5220 abort_fn
= identifier_global_value (abort_fn
);
5223 inner_if_stmt
= begin_if_stmt ();
5224 finish_if_stmt_cond (build_call (acquire_fn
, guard_addr_list
),
5227 inner_then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
5228 begin
= get_target_expr (boolean_false_node
);
5229 flag
= TARGET_EXPR_SLOT (begin
);
5231 TARGET_EXPR_CLEANUP (begin
)
5232 = build (COND_EXPR
, void_type_node
, flag
,
5234 build_call (abort_fn
, guard_addr_list
));
5235 CLEANUP_EH_ONLY (begin
) = 1;
5237 /* Do the initialization itself. */
5238 init
= add_stmt_to_compound (begin
, init
);
5239 init
= add_stmt_to_compound
5240 (init
, build (MODIFY_EXPR
, void_type_node
, flag
, boolean_true_node
));
5241 init
= add_stmt_to_compound
5242 (init
, build_call (release_fn
, guard_addr_list
));
5245 init
= add_stmt_to_compound (init
, set_guard (guard
));
5247 /* Use atexit to register a function for destroying this static
5249 init
= add_stmt_to_compound (init
, register_dtor_fn (decl
));
5251 finish_expr_stmt (init
);
5253 if (flag_threadsafe_statics
)
5255 finish_compound_stmt (inner_then_clause
);
5256 finish_then_clause (inner_if_stmt
);
5257 finish_if_stmt (inner_if_stmt
);
5260 finish_compound_stmt (then_clause
);
5261 finish_then_clause (if_stmt
);
5262 finish_if_stmt (if_stmt
);
5265 static_aggregates
= tree_cons (init
, decl
, static_aggregates
);
5269 /* Make TYPE a complete type based on INITIAL_VALUE.
5270 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
5271 2 if there was no information (in which case assume 0 if DO_DEFAULT). */
5274 complete_array_type (tree type
, tree initial_value
, int do_default
)
5276 tree maxindex
= NULL_TREE
;
5281 /* An array of character type can be initialized from a
5282 brace-enclosed string constant. */
5283 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type
)))
5284 && TREE_CODE (initial_value
) == CONSTRUCTOR
5285 && CONSTRUCTOR_ELTS (initial_value
)
5286 && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value
)))
5288 && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value
)) == NULL_TREE
)
5289 initial_value
= TREE_VALUE (CONSTRUCTOR_ELTS (initial_value
));
5291 /* Note MAXINDEX is really the maximum index, one less than the
5293 if (TREE_CODE (initial_value
) == STRING_CST
)
5296 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
5297 maxindex
= build_int_cst (NULL_TREE
,
5298 (TREE_STRING_LENGTH (initial_value
)
5301 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
5303 tree elts
= CONSTRUCTOR_ELTS (initial_value
);
5305 maxindex
= ssize_int (-1);
5306 for (; elts
; elts
= TREE_CHAIN (elts
))
5308 if (TREE_PURPOSE (elts
))
5309 maxindex
= TREE_PURPOSE (elts
);
5311 maxindex
= size_binop (PLUS_EXPR
, maxindex
, ssize_int (1));
5316 /* Make an error message unless that happened already. */
5317 if (initial_value
!= error_mark_node
)
5320 initial_value
= NULL_TREE
;
5322 /* Prevent further error messages. */
5323 maxindex
= build_int_cst (NULL_TREE
, 0);
5330 maxindex
= build_int_cst (NULL_TREE
, 0);
5340 domain
= build_index_type (maxindex
);
5341 TYPE_DOMAIN (type
) = domain
;
5344 itype
= TREE_TYPE (initial_value
);
5347 if (itype
&& !TYPE_DOMAIN (itype
))
5348 TYPE_DOMAIN (itype
) = domain
;
5349 /* The type of the main variant should never be used for arrays
5350 of different sizes. It should only ever be completed with the
5351 size of the array. */
5352 if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)))
5353 TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)) = domain
;
5355 elt_type
= TREE_TYPE (type
);
5356 TYPE_NEEDS_CONSTRUCTING (type
)
5357 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type
));
5358 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
5359 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type
));
5362 /* Lay out the type now that we can get the real answer. */
5369 /* Return zero if something is declared to be a member of type
5370 CTYPE when in the context of CUR_TYPE. STRING is the error
5371 message to print in that case. Otherwise, quietly return 1. */
5374 member_function_or_else (tree ctype
, tree cur_type
, enum overload_flags flags
)
5376 if (ctype
&& ctype
!= cur_type
)
5378 if (flags
== DTOR_FLAG
)
5379 error ("destructor for alien class `%T' cannot be a member",
5382 error ("constructor for alien class `%T' cannot be a member",
5389 /* Subroutine of `grokdeclarator'. */
5391 /* Generate errors possibly applicable for a given set of specifiers.
5392 This is for ARM $7.1.2. */
5395 bad_specifiers (tree object
,
5404 error ("`%D' declared as a `virtual' %s", object
, type
);
5406 error ("`%D' declared as an `inline' %s", object
, type
);
5408 error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
5411 cp_error_at ("`%D' declared as a friend", object
);
5413 && (TREE_CODE (object
) == TYPE_DECL
5414 || (!TYPE_PTRFN_P (TREE_TYPE (object
))
5415 && !TYPE_REFFN_P (TREE_TYPE (object
))
5416 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object
)))))
5417 cp_error_at ("`%D' declared with an exception specification", object
);
5420 /* CTYPE is class type, or null if non-class.
5421 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
5423 DECLARATOR is the function's name.
5424 PARMS is a chain of PARM_DECLs for the function.
5425 VIRTUALP is truthvalue of whether the function is virtual or not.
5426 FLAGS are to be passed through to `grokclassfn'.
5427 QUALS are qualifiers indicating whether the function is `const'
5429 RAISES is a list of exceptions that this function can raise.
5430 CHECK is 1 if we must find this method in CTYPE, 0 if we should
5431 not look, and -1 if we should not call `grokclassfn' at all.
5433 Returns `NULL_TREE' if something goes wrong, after issuing
5434 applicable error messages. */
5437 grokfndecl (tree ctype
,
5441 tree orig_declarator
,
5443 enum overload_flags flags
,
5455 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
5456 int has_default_arg
= 0;
5460 type
= build_exception_variant (type
, raises
);
5462 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
5463 DECL_ARGUMENTS (decl
) = parms
;
5464 /* Propagate volatile out from type to decl. */
5465 if (TYPE_VOLATILE (type
))
5466 TREE_THIS_VOLATILE (decl
) = 1;
5468 /* If this decl has namespace scope, set that up. */
5470 set_decl_namespace (decl
, in_namespace
, friendp
);
5472 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
5474 /* `main' and builtins have implicit 'C' linkage. */
5475 if ((MAIN_NAME_P (declarator
)
5476 || (IDENTIFIER_LENGTH (declarator
) > 10
5477 && IDENTIFIER_POINTER (declarator
)[0] == '_'
5478 && IDENTIFIER_POINTER (declarator
)[1] == '_'
5479 && strncmp (IDENTIFIER_POINTER (declarator
)+2, "builtin_", 8) == 0))
5480 && current_lang_name
== lang_name_cplusplus
5481 && ctype
== NULL_TREE
5482 /* NULL_TREE means global namespace. */
5483 && DECL_CONTEXT (decl
) == NULL_TREE
)
5484 SET_DECL_LANGUAGE (decl
, lang_c
);
5486 /* Should probably propagate const out from type to decl I bet (mrs). */
5489 DECL_STATIC_FUNCTION_P (decl
) = 1;
5490 DECL_CONTEXT (decl
) = ctype
;
5494 DECL_CONTEXT (decl
) = ctype
;
5496 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
5498 if (processing_template_decl
)
5499 error ("cannot declare `::main' to be a template");
5501 error ("cannot declare `::main' to be inline");
5503 error ("cannot declare `::main' to be static");
5504 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
5506 error ("`main' must return `int'");
5511 /* Members of anonymous types and local classes have no linkage; make
5512 them internal. If a typedef is made later, this will be changed. */
5513 if (ctype
&& (TYPE_ANONYMOUS_P (ctype
)
5514 || decl_function_context (TYPE_MAIN_DECL (ctype
))))
5519 /* [basic.link]: A name with no linkage (notably, the name of a class
5520 or enumeration declared in a local scope) shall not be used to
5521 declare an entity with linkage.
5523 Only check this for public decls for now. See core 319, 389. */
5524 t
= no_linkage_check (TREE_TYPE (decl
),
5525 /*relaxed_p=*/false);
5528 if (TYPE_ANONYMOUS_P (t
))
5530 if (DECL_EXTERN_C_P (decl
))
5531 /* Allow this; it's pretty common in C. */;
5534 pedwarn ("non-local function `%#D' uses anonymous type",
5536 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
5538 `%#D' does not refer to the unqualified type, so it is not used for linkage",
5543 pedwarn ("non-local function `%#D' uses local type `%T'",
5548 TREE_PUBLIC (decl
) = publicp
;
5551 DECL_INTERFACE_KNOWN (decl
) = 1;
5552 DECL_NOT_REALLY_EXTERN (decl
) = 1;
5555 /* If the declaration was declared inline, mark it as such. */
5557 DECL_DECLARED_INLINE_P (decl
) = 1;
5558 /* We inline functions that are explicitly declared inline, or, when
5559 the user explicitly asks us to, all functions. */
5560 if (DECL_DECLARED_INLINE_P (decl
)
5561 || (flag_inline_trees
== 2 && !DECL_INLINE (decl
) && funcdef_flag
))
5562 DECL_INLINE (decl
) = 1;
5564 DECL_EXTERNAL (decl
) = 1;
5565 if (quals
&& TREE_CODE (type
) == FUNCTION_TYPE
)
5567 error ("%smember function `%D' cannot have cv-qualifier",
5568 (ctype
? "static " : "non-"), decl
);
5569 quals
= TYPE_UNQUALIFIED
;
5572 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
)))
5573 grok_op_properties (decl
, friendp
, /*complain=*/true);
5575 if (ctype
&& decl_function_context (decl
))
5576 DECL_NO_STATIC_CHAIN (decl
) = 1;
5578 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
5579 if (TREE_PURPOSE (t
)
5580 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
5582 has_default_arg
= 1;
5587 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
5591 ("defining explicit specialization `%D' in friend declaration",
5595 tree fns
= TREE_OPERAND (orig_declarator
, 0);
5596 tree args
= TREE_OPERAND (orig_declarator
, 1);
5598 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
5600 /* Something like `template <class T> friend void f<T>()'. */
5601 error ("invalid use of template-id `%D' in declaration of primary template",
5607 /* A friend declaration of the form friend void f<>(). Record
5608 the information in the TEMPLATE_ID_EXPR. */
5609 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
5611 if (TREE_CODE (fns
) == COMPONENT_REF
)
5613 /* Due to bison parser ickiness, we will have already looked
5614 up an operator_name or PFUNCNAME within the current class
5615 (see template_id in parse.y). If the current class contains
5616 such a name, we'll get a COMPONENT_REF here. Undo that. */
5618 gcc_assert (TREE_TYPE (TREE_OPERAND (fns
, 0))
5619 == current_class_type
);
5620 fns
= TREE_OPERAND (fns
, 1);
5622 gcc_assert (TREE_CODE (fns
) == IDENTIFIER_NODE
5623 || TREE_CODE (fns
) == OVERLOAD
);
5624 DECL_TEMPLATE_INFO (decl
) = tree_cons (fns
, args
, NULL_TREE
);
5626 if (has_default_arg
)
5628 error ("default arguments are not allowed in declaration of friend template specialization `%D'",
5635 error ("`inline' is not allowed in declaration of friend template specialization `%D'",
5643 /* Make the init_value nonzero so pushdecl knows this is not
5644 tentative. error_mark_node is replaced later with the BLOCK. */
5645 DECL_INITIAL (decl
) = error_mark_node
;
5647 if (TYPE_NOTHROW_P (type
) || nothrow_libfn_p (decl
))
5648 TREE_NOTHROW (decl
) = 1;
5650 /* Caller will do the rest of this. */
5654 if (flags
== NO_SPECIAL
&& ctype
&& constructor_name_p (declarator
, ctype
))
5655 DECL_CONSTRUCTOR_P (decl
) = 1;
5657 /* Function gets the ugly name, field gets the nice one. This call
5658 may change the type of the function (because of default
5660 if (ctype
!= NULL_TREE
)
5661 grokclassfn (ctype
, decl
, flags
, quals
);
5663 decl
= check_explicit_specialization (orig_declarator
, decl
,
5665 2 * (funcdef_flag
!= 0) +
5666 4 * (friendp
!= 0));
5667 if (decl
== error_mark_node
)
5670 if (ctype
!= NULL_TREE
5671 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
5676 old_decl
= check_classfn (ctype
, decl
,
5677 (processing_template_decl
5678 > template_class_depth (ctype
))
5679 ? current_template_parms
5682 if (old_decl
&& TREE_CODE (old_decl
) == TEMPLATE_DECL
)
5683 /* Because grokfndecl is always supposed to return a
5684 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
5685 here. We depend on our callers to figure out that its
5686 really a template that's being returned. */
5687 old_decl
= DECL_TEMPLATE_RESULT (old_decl
);
5689 if (old_decl
&& DECL_STATIC_FUNCTION_P (old_decl
)
5690 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
5691 /* Remove the `this' parm added by grokclassfn.
5692 XXX Isn't this done in start_function, too? */
5693 revert_static_member_fn (decl
);
5694 if (old_decl
&& DECL_ARTIFICIAL (old_decl
))
5695 error ("definition of implicitly-declared `%D'", old_decl
);
5702 /* Since we've smashed OLD_DECL to its
5703 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
5704 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
5705 decl
= DECL_TEMPLATE_RESULT (decl
);
5707 /* Attempt to merge the declarations. This can fail, in
5708 the case of some invalid specialization declarations. */
5709 pop_p
= push_scope (ctype
);
5710 ok
= duplicate_decls (decl
, old_decl
);
5715 error ("no `%#D' member function declared in class `%T'",
5723 if (DECL_CONSTRUCTOR_P (decl
) && !grok_ctor_properties (ctype
, decl
))
5726 if (ctype
== NULL_TREE
|| check
)
5730 DECL_VIRTUAL_P (decl
) = 1;
5735 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
5736 the linkage that DECL will receive in the object file. */
5739 set_linkage_for_static_data_member (tree decl
)
5741 /* A static data member always has static storage duration and
5742 external linkage. Note that static data members are forbidden in
5743 local classes -- the only situation in which a class has
5744 non-external linkage. */
5745 TREE_PUBLIC (decl
) = 1;
5746 TREE_STATIC (decl
) = 1;
5747 /* For non-template classes, static data members are always put
5748 out in exactly those files where they are defined, just as
5749 with ordinarly namespace-scope variables. */
5750 if (!processing_template_decl
)
5751 DECL_INTERFACE_KNOWN (decl
) = 1;
5754 /* Create a VAR_DECL named NAME with the indicated TYPE.
5756 If SCOPE is non-NULL, it is the class type or namespace containing
5757 the variable. If SCOPE is NULL, the variable should is created in
5758 the innermost enclosings scope. */
5761 grokvardecl (tree type
,
5763 const cp_decl_specifier_seq
*declspecs
,
5770 gcc_assert (!name
|| TREE_CODE (name
) == IDENTIFIER_NODE
);
5772 /* Compute the scope in which to place the variable. */
5775 /* An explicit "extern" specifier indicates a namespace-scope
5777 if (declspecs
->storage_class
== sc_extern
)
5778 scope
= current_namespace
;
5779 else if (!at_function_scope_p ())
5781 scope
= current_scope ();
5783 scope
= current_namespace
;
5788 && (/* If the variable is a namespace-scope variable declared in a
5789 template, we need DECL_LANG_SPECIFIC. */
5790 (TREE_CODE (scope
) == NAMESPACE_DECL
&& processing_template_decl
)
5791 /* Similarly for namespace-scope variables with language linkage
5793 || (TREE_CODE (scope
) == NAMESPACE_DECL
5794 && current_lang_name
!= lang_name_cplusplus
)
5795 /* Similarly for static data members. */
5797 decl
= build_lang_decl (VAR_DECL
, name
, type
);
5799 decl
= build_decl (VAR_DECL
, name
, type
);
5801 if (scope
&& TREE_CODE (scope
) == NAMESPACE_DECL
)
5802 set_decl_namespace (decl
, scope
, 0);
5804 DECL_CONTEXT (decl
) = scope
;
5806 if (declspecs
->storage_class
== sc_extern
)
5808 DECL_THIS_EXTERN (decl
) = 1;
5809 DECL_EXTERNAL (decl
) = !initialized
;
5812 if (DECL_CLASS_SCOPE_P (decl
))
5814 set_linkage_for_static_data_member (decl
);
5815 /* This function is only called with out-of-class definitions. */
5816 DECL_EXTERNAL (decl
) = 0;
5818 /* At top level, either `static' or no s.c. makes a definition
5819 (perhaps tentative), and absence of `static' makes it public. */
5820 else if (toplevel_bindings_p ())
5822 TREE_PUBLIC (decl
) = (declspecs
->storage_class
!= sc_static
5823 && (DECL_THIS_EXTERN (decl
) || ! constp
));
5824 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
5826 /* Not at top level, only `static' makes a static definition. */
5829 TREE_STATIC (decl
) = declspecs
->storage_class
== sc_static
;
5830 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
5833 if (declspecs
->specs
[(int)ds_thread
])
5835 if (targetm
.have_tls
)
5836 DECL_THREAD_LOCAL (decl
) = 1;
5838 /* A mere warning is sure to result in improper semantics
5839 at runtime. Don't bother to allow this to compile. */
5840 error ("thread-local storage not supported for this target");
5843 if (TREE_PUBLIC (decl
))
5845 /* [basic.link]: A name with no linkage (notably, the name of a class
5846 or enumeration declared in a local scope) shall not be used to
5847 declare an entity with linkage.
5849 Only check this for public decls for now. */
5850 tree t
= no_linkage_check (TREE_TYPE (decl
),
5851 /*relaxed_p=*/false);
5854 if (TYPE_ANONYMOUS_P (t
))
5856 if (DECL_EXTERN_C_P (decl
))
5857 /* Allow this; it's pretty common in C. */;
5860 pedwarn ("non-local variable `%#D' uses anonymous type",
5862 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
5864 `%#D' does not refer to the unqualified type, so it is not used for linkage",
5869 pedwarn ("non-local variable `%#D' uses local type `%T'",
5877 /* Create and return a canonical pointer to member function type, for
5878 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
5881 build_ptrmemfunc_type (tree type
)
5885 tree unqualified_variant
= NULL_TREE
;
5887 if (type
== error_mark_node
)
5890 /* If a canonical type already exists for this type, use it. We use
5891 this method instead of type_hash_canon, because it only does a
5892 simple equality check on the list of field members. */
5894 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
5897 /* Make sure that we always have the unqualified pointer-to-member
5899 if (cp_type_quals (type
) != TYPE_UNQUALIFIED
)
5901 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type
));
5903 t
= make_aggr_type (RECORD_TYPE
);
5904 xref_basetypes (t
, NULL_TREE
);
5906 /* Let the front-end know this is a pointer to member function... */
5907 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
5908 /* ... and not really an aggregate. */
5909 SET_IS_AGGR_TYPE (t
, 0);
5911 field
= build_decl (FIELD_DECL
, pfn_identifier
, type
);
5914 field
= build_decl (FIELD_DECL
, delta_identifier
, delta_type_node
);
5915 TREE_CHAIN (field
) = fields
;
5918 finish_builtin_struct (t
, "__ptrmemfunc_type", fields
, ptr_type_node
);
5920 /* Zap out the name so that the back-end will give us the debugging
5921 information for this anonymous RECORD_TYPE. */
5922 TYPE_NAME (t
) = NULL_TREE
;
5924 /* If this is not the unqualified form of this pointer-to-member
5925 type, set the TYPE_MAIN_VARIANT for this type to be the
5926 unqualified type. Since they are actually RECORD_TYPEs that are
5927 not variants of each other, we must do this manually. */
5928 if (cp_type_quals (type
) != TYPE_UNQUALIFIED
)
5930 t
= build_qualified_type (t
, cp_type_quals (type
));
5931 TYPE_MAIN_VARIANT (t
) = unqualified_variant
;
5932 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (unqualified_variant
);
5933 TYPE_NEXT_VARIANT (unqualified_variant
) = t
;
5936 /* Cache this pointer-to-member type so that we can find it again
5938 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
5943 /* Create and return a pointer to data member type. */
5946 build_ptrmem_type (tree class_type
, tree member_type
)
5948 if (TREE_CODE (member_type
) == METHOD_TYPE
)
5952 arg_types
= TYPE_ARG_TYPES (member_type
);
5953 class_type
= (cp_build_qualified_type
5955 cp_type_quals (TREE_TYPE (TREE_VALUE (arg_types
)))));
5957 = build_method_type_directly (class_type
,
5958 TREE_TYPE (member_type
),
5959 TREE_CHAIN (arg_types
));
5960 return build_ptrmemfunc_type (build_pointer_type (member_type
));
5964 gcc_assert (TREE_CODE (member_type
) != FUNCTION_TYPE
);
5965 return build_offset_type (class_type
, member_type
);
5969 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
5970 Check to see that the definition is valid. Issue appropriate error
5971 messages. Return 1 if the definition is particularly bad, or 0
5975 check_static_variable_definition (tree decl
, tree type
)
5977 /* Motion 10 at San Diego: If a static const integral data member is
5978 initialized with an integral constant expression, the initializer
5979 may appear either in the declaration (within the class), or in
5980 the definition, but not both. If it appears in the class, the
5981 member is a member constant. The file-scope definition is always
5983 if (!ARITHMETIC_TYPE_P (type
) && TREE_CODE (type
) != ENUMERAL_TYPE
)
5985 error ("invalid in-class initialization of static data member of non-integral type `%T'",
5987 /* If we just return the declaration, crashes will sometimes
5988 occur. We therefore return void_type_node, as if this were a
5989 friend declaration, to cause callers to completely ignore
5990 this declaration. */
5993 else if (!CP_TYPE_CONST_P (type
))
5994 error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
5996 else if (pedantic
&& !INTEGRAL_TYPE_P (type
))
5997 pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl
, type
);
6002 /* Given the SIZE (i.e., number of elements) in an array, compute an
6003 appropriate index type for the array. If non-NULL, NAME is the
6004 name of the thing being declared. */
6007 compute_array_index_type (tree name
, tree size
)
6009 tree type
= TREE_TYPE (size
);
6012 /* The array bound must be an integer type. */
6013 if (!dependent_type_p (type
) && !INTEGRAL_TYPE_P (type
))
6016 error ("size of array `%D' has non-integral type `%T'", name
, type
);
6018 error ("size of array has non-integral type `%T'", type
);
6019 size
= integer_one_node
;
6020 type
= TREE_TYPE (size
);
6023 if (abi_version_at_least (2)
6024 /* We should only handle value dependent expressions specially. */
6025 ? value_dependent_expression_p (size
)
6026 /* But for abi-1, we handled all instances in templates. This
6027 effects the manglings produced. */
6028 : processing_template_decl
)
6029 return build_index_type (build_min (MINUS_EXPR
, sizetype
,
6030 size
, integer_one_node
));
6032 /* The size might be the result of a cast. */
6033 STRIP_TYPE_NOPS (size
);
6035 /* It might be a const variable or enumeration constant. */
6036 size
= decl_constant_value (size
);
6038 /* Normally, the array-bound will be a constant. */
6039 if (TREE_CODE (size
) == INTEGER_CST
)
6041 /* Check to see if the array bound overflowed. Make that an
6042 error, no matter how generous we're being. */
6043 int old_flag_pedantic_errors
= flag_pedantic_errors
;
6044 int old_pedantic
= pedantic
;
6045 pedantic
= flag_pedantic_errors
= 1;
6046 constant_expression_warning (size
);
6047 pedantic
= old_pedantic
;
6048 flag_pedantic_errors
= old_flag_pedantic_errors
;
6050 /* An array must have a positive number of elements. */
6051 if (INT_CST_LT (size
, integer_zero_node
))
6054 error ("size of array `%D' is negative", name
);
6056 error ("size of array is negative");
6057 size
= integer_one_node
;
6059 /* As an extension we allow zero-sized arrays. We always allow
6060 them in system headers because glibc uses them. */
6061 else if (integer_zerop (size
) && pedantic
&& !in_system_header
)
6064 pedwarn ("ISO C++ forbids zero-size array `%D'", name
);
6066 pedwarn ("ISO C++ forbids zero-size array");
6069 else if (TREE_CONSTANT (size
))
6071 /* `(int) &fn' is not a valid array bound. */
6073 error ("size of array `%D' is not an integral constant-expression",
6076 error ("size of array is not an integral constant-expression");
6081 pedwarn ("ISO C++ forbids variable-size array `%D'", name
);
6083 pedwarn ("ISO C++ forbids variable-size array");
6086 if (processing_template_decl
&& !TREE_CONSTANT (size
))
6087 /* A variable sized array. */
6088 itype
= build_min (MINUS_EXPR
, sizetype
, size
, integer_one_node
);
6091 /* Compute the index of the largest element in the array. It is
6092 one less than the number of elements in the array. */
6094 = fold (cp_build_binary_op (MINUS_EXPR
,
6095 cp_convert (ssizetype
, size
),
6096 cp_convert (ssizetype
, integer_one_node
)));
6097 if (!TREE_CONSTANT (itype
))
6098 /* A variable sized array. */
6099 itype
= variable_size (itype
);
6100 /* Make sure that there was no overflow when creating to a signed
6101 index type. (For example, on a 32-bit machine, an array with
6102 size 2^32 - 1 is too big.) */
6103 else if (TREE_OVERFLOW (itype
))
6105 error ("overflow in array dimension");
6106 TREE_OVERFLOW (itype
) = 0;
6110 /* Create and return the appropriate index type. */
6111 return build_index_type (itype
);
6114 /* Returns the scope (if any) in which the entity declared by
6115 DECLARATOR will be located. If the entity was declared with an
6116 unqualified name, NULL_TREE is returned. */
6119 get_scope_of_declarator (const cp_declarator
*declarator
)
6121 while (declarator
&& declarator
->kind
!= cdk_id
)
6122 declarator
= declarator
->declarator
;
6124 /* If the declarator-id is a SCOPE_REF, the scope in which the
6125 declaration occurs is the first operand. */
6127 && declarator
->u
.id
.name
6128 && TREE_CODE (declarator
->u
.id
.name
) == SCOPE_REF
)
6129 return TREE_OPERAND (declarator
->u
.id
.name
, 0);
6131 /* Otherwise, the declarator is not a quablified name; the entity will
6132 be declared in the current scope. */
6136 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
6137 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
6141 create_array_type_for_decl (tree name
, tree type
, tree size
)
6143 tree itype
= NULL_TREE
;
6144 const char* error_msg
;
6146 /* If things have already gone awry, bail now. */
6147 if (type
== error_mark_node
|| size
== error_mark_node
)
6148 return error_mark_node
;
6150 /* Assume that everything will go OK. */
6153 /* There are some types which cannot be array elements. */
6154 switch (TREE_CODE (type
))
6157 error_msg
= "array of void";
6161 error_msg
= "array of functions";
6164 case REFERENCE_TYPE
:
6165 error_msg
= "array of references";
6169 error_msg
= "array of function members";
6176 /* If something went wrong, issue an error-message and return. */
6180 error ("declaration of `%D' as %s", name
, error_msg
);
6182 error ("creating %s", error_msg
);
6184 return error_mark_node
;
6189 The constant expressions that specify the bounds of the arrays
6190 can be omitted only for the first member of the sequence. */
6191 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
6194 error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
6197 error ("multidimensional array must have bounds for all dimensions except the first");
6199 return error_mark_node
;
6202 /* Figure out the index type for the array. */
6204 itype
= compute_array_index_type (name
, size
);
6207 T is called the array element type; this type shall not be [...] an
6208 abstract class type. */
6209 abstract_virtuals_error (name
, type
);
6211 return build_cplus_array_type (type
, itype
);
6214 /* Check that it's OK to declare a function with the indicated TYPE.
6215 SFK indicates the kind of special function (if any) that this
6216 function is. OPTYPE is the type given in a conversion operator
6217 declaration, or the class type for a constructor/destructor.
6218 Returns the actual return type of the function; that
6219 may be different than TYPE if an error occurs, or for certain
6220 special functions. */
6223 check_special_function_return_type (special_function_kind sfk
,
6229 case sfk_constructor
:
6231 error ("return type specification for constructor invalid");
6233 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
6234 type
= build_pointer_type (optype
);
6236 type
= void_type_node
;
6239 case sfk_destructor
:
6241 error ("return type specification for destructor invalid");
6242 /* We can't use the proper return type here because we run into
6243 problems with abiguous bases and covariant returns.
6244 Java classes are left unchanged because (void *) isn't a valid
6245 Java type, and we don't want to change the Java ABI. */
6246 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
6247 type
= build_pointer_type (void_type_node
);
6249 type
= void_type_node
;
6252 case sfk_conversion
:
6253 if (type
&& !same_type_p (type
, optype
))
6254 error ("operator `%T' declared to return `%T'", optype
, type
);
6256 pedwarn ("return type specified for `operator %T'", optype
);
6268 /* Given declspecs and a declarator (abstract or otherwise), determine
6269 the name and type of the object declared and construct a DECL node
6272 DECLSPECS is a chain of tree_list nodes whose value fields
6273 are the storage classes and type specifiers.
6275 DECL_CONTEXT says which syntactic context this declaration is in:
6276 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
6277 FUNCDEF for a function definition. Like NORMAL but a few different
6278 error messages in each case. Return value may be zero meaning
6279 this definition is too screwy to try to parse.
6280 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
6281 handle member functions (which have FIELD context).
6282 Return value may be zero meaning this definition is too screwy to
6284 PARM for a parameter declaration (either within a function prototype
6285 or before a function body). Make a PARM_DECL, or return void_type_node.
6286 CATCHPARM for a parameter declaration before a catch clause.
6287 TYPENAME if for a typename (in a cast or sizeof).
6288 Don't make a DECL node; just return the ..._TYPE node.
6289 FIELD for a struct or union field; make a FIELD_DECL.
6290 BITFIELD for a field with specified width.
6291 INITIALIZED is 1 if the decl has an initializer.
6293 ATTRLIST is a pointer to the list of attributes, which may be NULL
6294 if there are none; *ATTRLIST may be modified if attributes from inside
6295 the declarator should be applied to the declaration.
6297 When this function is called, scoping variables (such as
6298 CURRENT_CLASS_TYPE) should reflect the scope in which the
6299 declaration occurs, not the scope in which the new declaration will
6300 be placed. For example, on:
6304 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
6305 should not be `S'. */
6308 grokdeclarator (const cp_declarator
*declarator
,
6309 const cp_decl_specifier_seq
*declspecs
,
6310 enum decl_context decl_context
,
6314 tree type
= NULL_TREE
;
6317 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
6318 int explicit_int
= 0;
6319 int explicit_char
= 0;
6320 int defaulted_int
= 0;
6321 tree dependant_name
= NULL_TREE
;
6323 tree typedef_decl
= NULL_TREE
;
6324 const char *name
= NULL
;
6325 tree typedef_type
= NULL_TREE
;
6326 int funcdef_flag
= 0;
6327 cp_declarator_kind innermost_code
= cdk_error
;
6330 /* See the code below that used this. */
6331 tree decl_attr
= NULL_TREE
;
6334 /* Keep track of what sort of function is being processed
6335 so that we can warn about default return values, or explicit
6336 return values which do not match prescribed defaults. */
6337 special_function_kind sfk
= sfk_none
;
6339 tree dname
= NULL_TREE
;
6340 tree ctor_return_type
= NULL_TREE
;
6341 enum overload_flags flags
= NO_SPECIAL
;
6342 cp_cv_quals quals
= TYPE_UNQUALIFIED
;
6343 tree raises
= NULL_TREE
;
6344 int template_count
= 0;
6345 tree returned_attrs
= NULL_TREE
;
6346 tree parms
= NULL_TREE
;
6347 const cp_declarator
*id_declarator
;
6348 /* The unqualified name of the declarator; either an
6349 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
6350 tree unqualified_id
;
6351 /* The class type, if any, in which this entity is located,
6352 or NULL_TREE if none. Note that this value may be different from
6353 the current class type; for example if an attempt is made to declare
6354 "A::f" inside "B", this value will be "A". */
6355 tree ctype
= current_class_type
;
6356 /* The NAMESPACE_DECL for the namespace in which this entity is
6357 located. If an unqualified name is used to declare the entity,
6358 this value will be NULL_TREE, even if the entity is located at
6360 tree in_namespace
= NULL_TREE
;
6362 cp_storage_class storage_class
;
6363 bool unsigned_p
, signed_p
, short_p
, long_p
, thread_p
;
6365 signed_p
= declspecs
->specs
[(int)ds_signed
];
6366 unsigned_p
= declspecs
->specs
[(int)ds_unsigned
];
6367 short_p
= declspecs
->specs
[(int)ds_short
];
6368 long_p
= declspecs
->specs
[(int)ds_long
];
6369 thread_p
= declspecs
->specs
[(int)ds_thread
];
6371 if (decl_context
== FUNCDEF
)
6372 funcdef_flag
= 1, decl_context
= NORMAL
;
6373 else if (decl_context
== MEMFUNCDEF
)
6374 funcdef_flag
= -1, decl_context
= FIELD
;
6375 else if (decl_context
== BITFIELD
)
6376 bitfield
= 1, decl_context
= FIELD
;
6378 /* Look inside a declarator for the name being declared
6379 and get it as a string, for an error message. */
6380 for (id_declarator
= declarator
;
6382 id_declarator
= id_declarator
->declarator
)
6384 if (id_declarator
->kind
!= cdk_id
)
6385 innermost_code
= id_declarator
->kind
;
6387 switch (id_declarator
->kind
)
6390 if (id_declarator
->declarator
6391 && id_declarator
->declarator
->kind
== cdk_id
)
6393 sfk
= id_declarator
->declarator
->u
.id
.sfk
;
6394 if (sfk
== sfk_destructor
)
6401 tree decl
= id_declarator
->u
.id
.name
;
6404 if (TREE_CODE (decl
) == SCOPE_REF
)
6406 tree qualifying_scope
= TREE_OPERAND (decl
, 0);
6408 /* It is valid to write:
6410 class C { void f(); };
6414 The standard is not clear about whether `typedef const C D' is
6415 legal; as of 2002-09-15 the committee is considering
6416 that question. EDG 3.0 allows that syntax.
6417 Therefore, we do as well. */
6418 if (qualifying_scope
&& TYPE_P (qualifying_scope
))
6420 ctype
= TYPE_MAIN_VARIANT (qualifying_scope
);
6421 if (innermost_code
!= cdk_function
6422 && current_class_type
6423 && !UNIQUELY_DERIVED_FROM_P (ctype
,
6424 current_class_type
))
6426 error ("type `%T' is not derived from type `%T'",
6427 ctype
, current_class_type
);
6430 TREE_OPERAND (decl
, 0) = ctype
;
6432 else if (TREE_CODE (qualifying_scope
) == NAMESPACE_DECL
)
6433 in_namespace
= qualifying_scope
;
6434 decl
= TREE_OPERAND (decl
, 1);
6436 if (TREE_CODE (decl
) == BASELINK
)
6437 decl
= BASELINK_FUNCTIONS (decl
);
6438 if (decl
== error_mark_node
)
6439 return error_mark_node
;
6440 switch (TREE_CODE (decl
))
6444 tree type
= TREE_OPERAND (decl
, 0);
6445 type
= constructor_name (type
);
6446 name
= IDENTIFIER_POINTER (type
);
6450 case TEMPLATE_ID_EXPR
:
6452 tree fns
= TREE_OPERAND (decl
, 0);
6455 if (TREE_CODE (dname
) == COMPONENT_REF
)
6456 dname
= TREE_OPERAND (dname
, 1);
6457 if (TREE_CODE (dname
) != IDENTIFIER_NODE
)
6459 gcc_assert (is_overloaded_fn (dname
));
6460 dname
= DECL_NAME (get_first_fn (dname
));
6465 case IDENTIFIER_NODE
:
6466 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
6469 if (C_IS_RESERVED_WORD (dname
))
6471 error ("declarator-id missing; using reserved word `%D'",
6473 name
= IDENTIFIER_POINTER (dname
);
6475 else if (!IDENTIFIER_TYPENAME_P (dname
))
6476 name
= IDENTIFIER_POINTER (dname
);
6479 gcc_assert (flags
== NO_SPECIAL
);
6480 flags
= TYPENAME_FLAG
;
6481 ctor_return_type
= TREE_TYPE (dname
);
6482 sfk
= sfk_conversion
;
6483 if (is_typename_at_global_scope (dname
))
6484 name
= IDENTIFIER_POINTER (dname
);
6486 name
= "<invalid operator>";
6491 dname
= constructor_name (TREE_TYPE (decl
));
6492 name
= IDENTIFIER_POINTER (dname
);
6513 if (id_declarator
->kind
== cdk_id
)
6517 /* A function definition's declarator must have the form of
6518 a function declarator. */
6520 if (funcdef_flag
&& innermost_code
!= cdk_function
)
6523 if (((dname
&& IDENTIFIER_OPNAME_P (dname
)) || flags
== TYPENAME_FLAG
)
6524 && innermost_code
!= cdk_function
6525 && ! (ctype
&& !declspecs
->any_specifiers_p
))
6527 error ("declaration of `%D' as non-function", dname
);
6528 return void_type_node
;
6531 /* Anything declared one level down from the top level
6532 must be one of the parameters of a function
6533 (because the body is at least two levels down). */
6535 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
6536 by not allowing C++ class definitions to specify their parameters
6537 with xdecls (must be spec.d in the parmlist).
6539 Since we now wait to push a class scope until we are sure that
6540 we are in a legitimate method context, we must set oldcname
6541 explicitly (since current_class_name is not yet alive).
6543 We also want to avoid calling this a PARM if it is in a namespace. */
6545 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
6547 struct cp_binding_level
*b
= current_binding_level
;
6548 current_binding_level
= b
->level_chain
;
6549 if (current_binding_level
!= 0 && toplevel_bindings_p ())
6550 decl_context
= PARM
;
6551 current_binding_level
= b
;
6555 name
= decl_context
== PARM
? "parameter" : "type name";
6557 /* If there were multiple types specified in the decl-specifier-seq,
6558 issue an error message. */
6559 if (declspecs
->multiple_types_p
)
6560 error ("two or more data types in declaration of `%s'", name
);
6561 /* Extract the basic type from the decl-specifier-seq. */
6562 type
= declspecs
->type
;
6563 if (type
== error_mark_node
)
6565 /* If the entire declaration is itself tagged as deprecated then
6566 suppress reports of deprecated items. */
6567 if (type
&& TREE_DEPRECATED (type
)
6568 && deprecated_state
!= DEPRECATED_SUPPRESS
)
6569 warn_deprecated_use (type
);
6570 if (type
&& TREE_CODE (type
) == TYPE_DECL
)
6572 typedef_decl
= type
;
6573 type
= TREE_TYPE (typedef_decl
);
6575 /* No type at all: default to `int', and set DEFAULTED_INT
6576 because it was not a user-defined typedef. */
6577 if (type
== NULL_TREE
&& (signed_p
|| unsigned_p
|| long_p
|| short_p
))
6579 /* These imply 'int'. */
6580 type
= integer_type_node
;
6584 explicit_int
= declspecs
->explicit_int_p
;
6585 explicit_char
= declspecs
->explicit_char_p
;
6587 /* Check for repeated decl-specifiers. */
6588 for (ds
= ds_first
; ds
!= ds_last
; ++ds
)
6590 unsigned count
= declspecs
->specs
[(int)ds
];
6593 /* The "long" specifier is a special case because of
6598 error ("`long long long' is too long for GCC");
6599 else if (pedantic
&& !in_system_header
&& warn_long_long
)
6600 pedwarn ("ISO C++ does not support `long long'");
6604 else if (declspecs
->specs
[(int)ds
] > 1)
6606 static const char *const decl_spec_names
[] = {
6622 error ("duplicate `%s'", decl_spec_names
[(int)ds
]);
6627 /* See the code below that used this. */
6629 decl_attr
= DECL_ATTRIBUTES (typedef_decl
);
6631 typedef_type
= type
;
6634 if (sfk
!= sfk_conversion
)
6635 ctor_return_type
= ctype
;
6637 if (sfk
!= sfk_none
)
6638 type
= check_special_function_return_type (sfk
, type
,
6640 else if (type
== NULL_TREE
)
6646 /* We handle `main' specially here, because 'main () { }' is so
6647 common. With no options, it is allowed. With -Wreturn-type,
6648 it is a warning. It is only an error with -pedantic-errors. */
6649 is_main
= (funcdef_flag
6650 && dname
&& MAIN_NAME_P (dname
)
6651 && ctype
== NULL_TREE
6652 && in_namespace
== NULL_TREE
6653 && current_namespace
== global_namespace
);
6655 if (in_system_header
|| flag_ms_extensions
)
6656 /* Allow it, sigh. */;
6657 else if (pedantic
|| ! is_main
)
6658 pedwarn ("ISO C++ forbids declaration of `%s' with no type",
6660 else if (warn_return_type
)
6661 warning ("ISO C++ forbids declaration of `%s' with no type",
6664 type
= integer_type_node
;
6669 /* Now process the modifiers that were specified
6670 and check for invalid combinations. */
6672 /* Long double is a special combination. */
6673 if (long_p
&& TYPE_MAIN_VARIANT (type
) == double_type_node
)
6676 type
= build_qualified_type (long_double_type_node
,
6677 cp_type_quals (type
));
6680 /* Check all other uses of type modifiers. */
6682 if (unsigned_p
|| signed_p
|| long_p
|| short_p
)
6686 if (TREE_CODE (type
) == REAL_TYPE
)
6687 error ("short, signed or unsigned invalid for `%s'", name
);
6688 else if (TREE_CODE (type
) != INTEGER_TYPE
)
6689 error ("long, short, signed or unsigned invalid for `%s'", name
);
6690 else if (long_p
&& short_p
)
6691 error ("long and short specified together for `%s'", name
);
6692 else if ((long_p
|| short_p
) && explicit_char
)
6693 error ("long or short specified with char for `%s'", name
);
6694 else if ((long_p
|| short_p
) && TREE_CODE (type
) == REAL_TYPE
)
6695 error ("long or short specified with floating type for `%s'", name
);
6696 else if (signed_p
&& unsigned_p
)
6697 error ("signed and unsigned given together for `%s'", name
);
6701 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& pedantic
)
6703 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
6705 if (flag_pedantic_errors
)
6710 /* Discard the type modifiers if they are invalid. */
6721 /* Decide whether an integer type is signed or not.
6722 Optionally treat bitfields as signed by default. */
6726 It is implementation-defined whether a plain (neither
6727 explicitly signed or unsigned) char, short, int, or long
6728 bit-field is signed or unsigned.
6730 Naturally, we extend this to long long as well. Note that
6731 this does not include wchar_t. */
6732 || (bitfield
&& !flag_signed_bitfields
6734 /* A typedef for plain `int' without `signed' can be
6735 controlled just like plain `int', but a typedef for
6736 `signed int' cannot be so controlled. */
6738 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
6739 && (TREE_CODE (type
) == INTEGER_TYPE
6740 || TREE_CODE (type
) == CHAR_TYPE
)
6741 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
6744 type
= long_long_unsigned_type_node
;
6746 type
= long_unsigned_type_node
;
6748 type
= short_unsigned_type_node
;
6749 else if (type
== char_type_node
)
6750 type
= unsigned_char_type_node
;
6751 else if (typedef_decl
)
6752 type
= c_common_unsigned_type (type
);
6754 type
= unsigned_type_node
;
6756 else if (signed_p
&& type
== char_type_node
)
6757 type
= signed_char_type_node
;
6759 type
= long_long_integer_type_node
;
6761 type
= long_integer_type_node
;
6763 type
= short_integer_type_node
;
6765 if (declspecs
->specs
[(int)ds_complex
])
6767 if (TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
6768 error ("complex invalid for `%s'", name
);
6769 /* If we just have "complex", it is equivalent to
6770 "complex double", but if any modifiers at all are specified it is
6771 the complex form of TYPE. E.g, "complex short" is
6772 "complex short int". */
6774 else if (defaulted_int
&& ! longlong
6775 && ! (long_p
|| short_p
|| signed_p
|| unsigned_p
))
6776 type
= complex_double_type_node
;
6777 else if (type
== integer_type_node
)
6778 type
= complex_integer_type_node
;
6779 else if (type
== float_type_node
)
6780 type
= complex_float_type_node
;
6781 else if (type
== double_type_node
)
6782 type
= complex_double_type_node
;
6783 else if (type
== long_double_type_node
)
6784 type
= complex_long_double_type_node
;
6786 type
= build_complex_type (type
);
6789 type_quals
= TYPE_UNQUALIFIED
;
6790 if (declspecs
->specs
[(int)ds_const
])
6791 type_quals
|= TYPE_QUAL_CONST
;
6792 if (declspecs
->specs
[(int)ds_volatile
])
6793 type_quals
|= TYPE_QUAL_VOLATILE
;
6794 if (declspecs
->specs
[(int)ds_restrict
])
6795 type_quals
|= TYPE_QUAL_RESTRICT
;
6796 if (sfk
== sfk_conversion
&& type_quals
!= TYPE_UNQUALIFIED
)
6797 error ("qualifiers are not allowed on declaration of `operator %T'",
6800 type_quals
|= cp_type_quals (type
);
6801 type
= cp_build_qualified_type_real
6802 (type
, type_quals
, ((typedef_decl
&& !DECL_ARTIFICIAL (typedef_decl
)
6803 ? tf_ignore_bad_quals
: 0) | tf_error
| tf_warning
));
6804 /* We might have ignored or rejected some of the qualifiers. */
6805 type_quals
= cp_type_quals (type
);
6808 inlinep
= !! declspecs
->specs
[(int)ds_inline
];
6809 virtualp
= !! declspecs
->specs
[(int)ds_virtual
];
6810 explicitp
= !! declspecs
->specs
[(int)ds_explicit
];
6812 storage_class
= declspecs
->storage_class
;
6813 if (storage_class
== sc_static
)
6814 staticp
= 1 + (decl_context
== FIELD
);
6816 if (virtualp
&& staticp
== 2)
6818 error ("member `%D' cannot be declared both virtual and static",
6822 friendp
= !! declspecs
->specs
[(int)ds_friend
];
6824 if (dependant_name
&& !friendp
)
6826 error ("`%T::%D' is not a valid declarator", ctype
, dependant_name
);
6827 return void_type_node
;
6830 /* Issue errors about use of storage classes for parameters. */
6831 if (decl_context
== PARM
)
6833 if (declspecs
->specs
[(int)ds_typedef
])
6834 error ("typedef declaration invalid in parameter declaration");
6835 else if (storage_class
== sc_static
6836 || storage_class
== sc_extern
6838 error ("storage class specifiers invalid in parameter declarations");
6841 /* Give error if `virtual' is used outside of class declaration. */
6843 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
6845 error ("virtual outside class declaration");
6849 /* Static anonymous unions are dealt with here. */
6850 if (staticp
&& decl_context
== TYPENAME
6852 && ANON_AGGR_TYPE_P (declspecs
->type
))
6853 decl_context
= FIELD
;
6855 /* Warn about storage classes that are invalid for certain
6856 kinds of declarations (parameters, typenames, etc.). */
6857 if (declspecs
->multiple_storage_classes_p
)
6858 error ("multiple storage classes in declaration of `%s'", name
);
6861 && storage_class
!= sc_extern
6862 && storage_class
!= sc_static
)
6863 || declspecs
->specs
[(int)ds_typedef
]))
6865 error ("multiple storage classes in declaration of `%s'", name
);
6868 else if (decl_context
!= NORMAL
6869 && ((storage_class
!= sc_none
6870 && storage_class
!= sc_mutable
)
6873 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
6874 && (storage_class
== sc_register
6875 || storage_class
== sc_auto
))
6877 else if (declspecs
->specs
[(int)ds_typedef
])
6879 else if (decl_context
== FIELD
6880 /* C++ allows static class elements. */
6881 && storage_class
== sc_static
)
6882 /* C++ also allows inlines and signed and unsigned elements,
6883 but in those cases we don't come in here. */
6887 if (decl_context
== FIELD
)
6889 tree tmp
= NULL_TREE
;
6894 /* Avoid trying to get an operand off an identifier node. */
6895 if (declarator
->kind
!= cdk_id
)
6896 tmp
= declarator
->declarator
->u
.id
.name
;
6898 tmp
= declarator
->u
.id
.name
;
6899 op
= IDENTIFIER_OPNAME_P (tmp
);
6900 if (IDENTIFIER_TYPENAME_P (tmp
))
6902 if (is_typename_at_global_scope (tmp
))
6903 name
= IDENTIFIER_POINTER (tmp
);
6905 name
= "<invalid operator>";
6908 error ("storage class specified for %s `%s'",
6909 op
? "member operator" : "field",
6914 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
6915 error ("storage class specified for parameter `%s'", name
);
6917 error ("storage class specified for typename");
6919 if (storage_class
== sc_register
6920 || storage_class
== sc_auto
6921 || storage_class
== sc_extern
6923 storage_class
= sc_none
;
6926 else if (storage_class
== sc_extern
&& initialized
6929 if (toplevel_bindings_p ())
6931 /* It's common practice (and completely valid) to have a const
6932 be initialized and declared extern. */
6933 if (!(type_quals
& TYPE_QUAL_CONST
))
6934 warning ("`%s' initialized and declared `extern'", name
);
6937 error ("`%s' has both `extern' and initializer", name
);
6939 else if (storage_class
== sc_extern
&& funcdef_flag
6940 && ! toplevel_bindings_p ())
6941 error ("nested function `%s' declared `extern'", name
);
6942 else if (toplevel_bindings_p ())
6944 if (storage_class
== sc_auto
)
6945 error ("top-level declaration of `%s' specifies `auto'", name
);
6948 && storage_class
!= sc_extern
6949 && storage_class
!= sc_static
)
6951 error ("function-scope `%s' implicitly auto and declared `__thread'",
6956 if (storage_class
&& friendp
)
6957 error ("storage class specifiers invalid in friend function declarations");
6960 unqualified_id
= NULL_TREE
;
6963 unqualified_id
= id_declarator
->u
.id
.name
;
6964 if (TREE_CODE (unqualified_id
) == SCOPE_REF
)
6965 unqualified_id
= TREE_OPERAND (unqualified_id
, 1);
6966 if (TREE_CODE (unqualified_id
) == BASELINK
)
6967 unqualified_id
= BASELINK_FUNCTIONS (unqualified_id
);
6968 switch (TREE_CODE (unqualified_id
))
6972 = constructor_name (TREE_OPERAND (unqualified_id
, 0));
6977 = constructor_name (TREE_TYPE (unqualified_id
));
6980 case IDENTIFIER_NODE
:
6981 case TEMPLATE_ID_EXPR
:
6989 /* Determine the type of the entity declared by recurring on the
6992 declarator
&& declarator
->kind
!= cdk_id
;
6993 declarator
= declarator
->declarator
)
6995 const cp_declarator
*inner_declarator
;
6998 if (type
== error_mark_node
)
6999 return error_mark_node
;
7001 inner_declarator
= declarator
->declarator
;
7003 attrs
= declarator
->attributes
;
7009 if (declarator
== NULL
|| declarator
->kind
== cdk_id
)
7010 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
7011 if (declarator
->kind
== cdk_function
)
7012 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
7013 if (declarator
->kind
== cdk_array
)
7014 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
7015 returned_attrs
= decl_attributes (&type
,
7016 chainon (returned_attrs
, attrs
),
7020 switch (declarator
->kind
)
7023 type
= create_array_type_for_decl (dname
, type
,
7024 declarator
->u
.array
.bounds
);
7025 if (inner_declarator
7026 && (inner_declarator
->kind
== cdk_pointer
7027 || inner_declarator
->kind
== cdk_reference
7028 || inner_declarator
->kind
== cdk_ptrmem
))
7029 /* We can never complete an array type which is the
7030 target of a pointer, so go ahead and lay it out. */
7039 /* Declaring a function type.
7040 Make sure we have a valid type for the function to return. */
7042 /* We now know that the TYPE_QUALS don't apply to the
7043 decl, but to its return type. */
7044 type_quals
= TYPE_UNQUALIFIED
;
7046 /* Warn about some types functions can't return. */
7048 if (TREE_CODE (type
) == FUNCTION_TYPE
)
7050 error ("`%s' declared as function returning a function", name
);
7051 type
= integer_type_node
;
7053 if (TREE_CODE (type
) == ARRAY_TYPE
)
7055 error ("`%s' declared as function returning an array", name
);
7056 type
= integer_type_node
;
7059 /* Pick up type qualifiers which should be applied to `this'. */
7060 quals
= declarator
->u
.function
.qualifiers
;
7062 /* Pick up the exception specifications. */
7063 raises
= declarator
->u
.function
.exception_specification
;
7065 /* Say it's a definition only for the CALL_EXPR
7066 closest to the identifier. */
7067 funcdecl_p
= inner_declarator
&& inner_declarator
->kind
== cdk_id
;
7069 if (ctype
== NULL_TREE
7070 && decl_context
== FIELD
7072 && (friendp
== 0 || dname
== current_class_name
))
7073 ctype
= current_class_type
;
7075 if (ctype
&& sfk
== sfk_conversion
)
7076 TYPE_HAS_CONVERSION (ctype
) = 1;
7077 if (ctype
&& (sfk
== sfk_constructor
7078 || sfk
== sfk_destructor
))
7080 /* We are within a class's scope. If our declarator name
7081 is the same as the class name, and we are defining
7082 a function, then it is a constructor/destructor, and
7083 therefore returns a void type. */
7085 if (flags
== DTOR_FLAG
)
7087 /* ISO C++ 12.4/2. A destructor may not be
7088 declared const or volatile. A destructor may
7091 error ("destructor cannot be static member function");
7094 error ("destructors may not be cv-qualified");
7095 quals
= TYPE_UNQUALIFIED
;
7097 if (decl_context
== FIELD
)
7099 if (! member_function_or_else (ctype
,
7102 return void_type_node
;
7105 else /* It's a constructor. */
7109 /* ISO C++ 12.1. A constructor may not be
7110 declared const or volatile. A constructor may
7111 not be virtual. A constructor may not be
7114 error ("constructor cannot be static member function");
7117 pedwarn ("constructors cannot be declared virtual");
7122 error ("constructors may not be cv-qualified");
7123 quals
= TYPE_UNQUALIFIED
;
7125 if (decl_context
== FIELD
)
7127 if (! member_function_or_else (ctype
,
7130 return void_type_node
;
7131 TYPE_HAS_CONSTRUCTOR (ctype
) = 1;
7132 if (sfk
!= sfk_constructor
)
7136 if (decl_context
== FIELD
)
7142 error ("can't initialize friend function `%s'", name
);
7145 /* Cannot be both friend and virtual. */
7146 error ("virtual functions cannot be friends");
7149 if (decl_context
== NORMAL
)
7150 error ("friend declaration not in class definition");
7151 if (current_function_decl
&& funcdef_flag
)
7152 error ("can't define friend function `%s' in a local class definition",
7156 arg_types
= grokparms (declarator
->u
.function
.parameters
,
7159 if (inner_declarator
7160 && inner_declarator
->kind
== cdk_id
7161 && inner_declarator
->u
.id
.sfk
== sfk_destructor
7162 && arg_types
!= void_list_node
)
7164 error ("destructors may not have parameters");
7165 arg_types
= void_list_node
;
7169 type
= build_function_type (type
, arg_types
);
7176 /* Filter out pointers-to-references and references-to-references.
7177 We can get these if a TYPE_DECL is used. */
7179 if (TREE_CODE (type
) == REFERENCE_TYPE
)
7181 error (declarator
->kind
== cdk_reference
7182 ? "cannot declare reference to `%#T'"
7183 : "cannot declare pointer to `%#T'", type
);
7184 type
= TREE_TYPE (type
);
7186 else if (VOID_TYPE_P (type
))
7188 if (declarator
->kind
== cdk_reference
)
7189 error ("cannot declare reference to `%#T'", type
);
7190 else if (declarator
->kind
== cdk_ptrmem
)
7191 error ("cannot declare pointer to `%#T' member", type
);
7194 /* We now know that the TYPE_QUALS don't apply to the decl,
7195 but to the target of the pointer. */
7196 type_quals
= TYPE_UNQUALIFIED
;
7198 if (declarator
->kind
== cdk_ptrmem
7199 && (TREE_CODE (type
) == FUNCTION_TYPE
7200 || (quals
&& TREE_CODE (type
) == METHOD_TYPE
)))
7202 tree dummy
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
7203 grok_method_quals (declarator
->u
.pointer
.class_type
,
7205 type
= TREE_TYPE (dummy
);
7206 quals
= TYPE_UNQUALIFIED
;
7209 if (declarator
->kind
== cdk_reference
)
7211 if (!VOID_TYPE_P (type
))
7212 type
= build_reference_type (type
);
7214 else if (TREE_CODE (type
) == METHOD_TYPE
)
7215 type
= build_ptrmemfunc_type (build_pointer_type (type
));
7216 else if (declarator
->kind
== cdk_ptrmem
)
7217 type
= build_ptrmem_type (declarator
->u
.pointer
.class_type
,
7220 type
= build_pointer_type (type
);
7222 /* Process a list of type modifier keywords (such as
7223 const or volatile) that were given inside the `*' or `&'. */
7225 if (declarator
->u
.pointer
.qualifiers
)
7228 = cp_build_qualified_type (type
,
7229 declarator
->u
.pointer
.qualifiers
);
7230 type_quals
= cp_type_quals (type
);
7243 if (unqualified_id
&& TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
7244 && TREE_CODE (type
) != FUNCTION_TYPE
7245 && TREE_CODE (type
) != METHOD_TYPE
)
7247 error ("template-id `%D' used as a declarator",
7249 unqualified_id
= dname
;
7252 /* If DECLARATOR is non-NULL, we know it is a cdk_id declarator;
7253 otherwise, we would not have exited the loop above. */
7255 && TREE_CODE (declarator
->u
.id
.name
) == SCOPE_REF
7256 /* If the qualifying scope was invalid, it will have been set to
7258 && TREE_OPERAND (declarator
->u
.id
.name
, 0)
7259 && TYPE_P (TREE_OPERAND (declarator
->u
.id
.name
, 0)))
7263 ctype
= TREE_OPERAND (declarator
->u
.id
.name
, 0);
7265 ctype
= TYPE_MAIN_VARIANT (ctype
);
7267 while (t
!= NULL_TREE
&& CLASS_TYPE_P (t
))
7269 /* You're supposed to have one `template <...>' for every
7270 template class, but you don't need one for a full
7271 specialization. For example:
7273 template <class T> struct S{};
7274 template <> struct S<int> { void f(); };
7275 void S<int>::f () {}
7277 is correct; there shouldn't be a `template <>' for the
7278 definition of `S<int>::f'. */
7279 if (CLASSTYPE_TEMPLATE_INFO (t
)
7280 && (CLASSTYPE_TEMPLATE_INSTANTIATION (t
)
7281 || uses_template_parms (CLASSTYPE_TI_ARGS (t
)))
7282 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)))
7283 template_count
+= 1;
7285 t
= TYPE_MAIN_DECL (t
);
7286 t
= DECL_CONTEXT (t
);
7289 if (ctype
== current_class_type
)
7295 Is this ill-formed? */
7298 pedwarn ("extra qualification `%T::' on member `%s' ignored",
7301 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
7303 tree sname
= TREE_OPERAND (declarator
->u
.id
.name
, 1);
7305 if (TREE_CODE (sname
) == IDENTIFIER_NODE
7306 && NEW_DELETE_OPNAME_P (sname
))
7307 /* Overloaded operator new and operator delete
7308 are always static functions. */
7310 else if (current_class_type
== NULL_TREE
|| friendp
)
7312 = build_method_type_directly (ctype
,
7314 TYPE_ARG_TYPES (type
));
7317 error ("cannot declare member function `%T::%s' within `%T'",
7318 ctype
, name
, current_class_type
);
7319 return error_mark_node
;
7322 else if (declspecs
->specs
[(int)ds_typedef
]
7323 || COMPLETE_TYPE_P (complete_type (ctype
)))
7325 /* Have to move this code elsewhere in this function.
7326 this code is used for i.e., typedef int A::M; M *pm;
7328 It is? How? jason 10/2/94 */
7330 if (current_class_type
)
7332 error ("cannot declare member `%T::%s' within `%T'",
7333 ctype
, name
, current_class_type
);
7334 return void_type_node
;
7339 cxx_incomplete_type_error (NULL_TREE
, ctype
);
7340 return error_mark_node
;
7347 *attrlist
= chainon (returned_attrs
, *attrlist
);
7349 attrlist
= &returned_attrs
;
7352 /* Now TYPE has the actual type. */
7354 /* Did array size calculations overflow? */
7356 if (TREE_CODE (type
) == ARRAY_TYPE
7357 && COMPLETE_TYPE_P (type
)
7358 && TREE_OVERFLOW (TYPE_SIZE (type
)))
7360 error ("size of array `%s' is too large", name
);
7361 /* If we proceed with the array type as it is, we'll eventually
7362 crash in tree_low_cst(). */
7363 type
= error_mark_node
;
7366 if ((decl_context
== FIELD
|| decl_context
== PARM
)
7367 && !processing_template_decl
7368 && variably_modified_type_p (type
, NULL_TREE
))
7370 if (decl_context
== FIELD
)
7371 error ("data member may not have variably modified type `%T'", type
);
7373 error ("parameter may not have variably modified type `%T'", type
);
7374 type
= error_mark_node
;
7377 if (explicitp
== 1 || (explicitp
&& friendp
))
7379 /* [dcl.fct.spec] The explicit specifier shall only be used in
7380 declarations of constructors within a class definition. */
7381 error ("only declarations of constructors can be `explicit'");
7385 if (storage_class
== sc_mutable
)
7387 if (decl_context
!= FIELD
|| friendp
)
7389 error ("non-member `%s' cannot be declared `mutable'", name
);
7390 storage_class
= sc_none
;
7392 else if (decl_context
== TYPENAME
|| declspecs
->specs
[(int)ds_typedef
])
7394 error ("non-object member `%s' cannot be declared `mutable'", name
);
7395 storage_class
= sc_none
;
7397 else if (TREE_CODE (type
) == FUNCTION_TYPE
7398 || TREE_CODE (type
) == METHOD_TYPE
)
7400 error ("function `%s' cannot be declared `mutable'", name
);
7401 storage_class
= sc_none
;
7405 error ("static `%s' cannot be declared `mutable'", name
);
7406 storage_class
= sc_none
;
7408 else if (type_quals
& TYPE_QUAL_CONST
)
7410 error ("const `%s' cannot be declared `mutable'", name
);
7411 storage_class
= sc_none
;
7415 /* If this is declaring a typedef name, return a TYPE_DECL. */
7416 if (declspecs
->specs
[(int)ds_typedef
] && decl_context
!= TYPENAME
)
7420 /* Note that the grammar rejects storage classes
7421 in typenames, fields or parameters. */
7422 if (current_lang_name
== lang_name_java
)
7423 TYPE_FOR_JAVA (type
) = 1;
7425 if (decl_context
== FIELD
)
7427 if (constructor_name_p (unqualified_id
, current_class_type
))
7428 pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
7430 decl
= build_lang_decl (TYPE_DECL
, unqualified_id
, type
);
7434 decl
= build_decl (TYPE_DECL
, unqualified_id
, type
);
7435 if (in_namespace
|| ctype
)
7436 error ("%Jtypedef name may not be a nested-name-specifier", decl
);
7437 if (!current_function_decl
)
7438 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
7441 /* If the user declares "typedef struct {...} foo" then the
7442 struct will have an anonymous name. Fill that name in now.
7443 Nothing can refer to it, so nothing needs know about the name
7445 if (type
!= error_mark_node
7448 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
7449 && TYPE_ANONYMOUS_P (type
)
7450 /* Don't do this if there are attributes. */
7451 && (!attrlist
|| !*attrlist
)
7452 && cp_type_quals (type
) == TYPE_UNQUALIFIED
)
7454 tree oldname
= TYPE_NAME (type
);
7457 /* Replace the anonymous name with the real name everywhere. */
7458 lookup_tag_reverse (type
, unqualified_id
);
7459 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
7460 if (TYPE_NAME (t
) == oldname
)
7461 TYPE_NAME (t
) = decl
;
7463 if (TYPE_LANG_SPECIFIC (type
))
7464 TYPE_WAS_ANONYMOUS (type
) = 1;
7466 /* If this is a typedef within a template class, the nested
7467 type is a (non-primary) template. The name for the
7468 template needs updating as well. */
7469 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
7470 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
7471 = TYPE_IDENTIFIER (type
);
7473 /* FIXME remangle member functions; member functions of a
7474 type with external linkage have external linkage. */
7479 if (ctype
== NULL_TREE
)
7481 if (TREE_CODE (type
) != METHOD_TYPE
)
7482 error ("%Jinvalid type qualifier for non-member function type",
7485 ctype
= TYPE_METHOD_BASETYPE (type
);
7487 if (ctype
!= NULL_TREE
)
7488 grok_method_quals (ctype
, decl
, quals
);
7492 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
7493 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
7495 bad_specifiers (decl
, "type", virtualp
, quals
!= TYPE_UNQUALIFIED
,
7496 inlinep
, friendp
, raises
!= NULL_TREE
);
7501 /* Detect the case of an array type of unspecified size
7502 which came, as such, direct from a typedef name.
7503 We must copy the type, so that the array's domain can be
7504 individually set by the object's initializer. */
7506 if (type
&& typedef_type
7507 && TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
7508 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (typedef_type
))
7509 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
7511 /* Detect where we're using a typedef of function type to declare a
7512 function. PARMS will not be set, so we must create it now. */
7514 if (type
== typedef_type
&& TREE_CODE (type
) == FUNCTION_TYPE
)
7516 tree decls
= NULL_TREE
;
7519 for (args
= TYPE_ARG_TYPES (type
); args
; args
= TREE_CHAIN (args
))
7521 tree decl
= cp_build_parm_decl (NULL_TREE
, TREE_VALUE (args
));
7523 TREE_CHAIN (decl
) = decls
;
7527 parms
= nreverse (decls
);
7530 /* If this is a type name (such as, in a cast or sizeof),
7531 compute the type and return it now. */
7533 if (decl_context
== TYPENAME
)
7535 /* Note that the grammar rejects storage classes
7536 in typenames, fields or parameters. */
7537 if (type_quals
!= TYPE_UNQUALIFIED
)
7538 type_quals
= TYPE_UNQUALIFIED
;
7540 /* Special case: "friend class foo" looks like a TYPENAME context. */
7543 if (type_quals
!= TYPE_UNQUALIFIED
)
7545 error ("type qualifiers specified for friend class declaration");
7546 type_quals
= TYPE_UNQUALIFIED
;
7550 error ("`inline' specified for friend class declaration");
7556 /* Don't allow friend declaration without a class-key. */
7557 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
7558 pedwarn ("template parameters cannot be friends");
7559 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
7560 pedwarn ("friend declaration requires class-key, "
7561 "i.e. `friend class %T::%D'",
7562 TYPE_CONTEXT (type
), TYPENAME_TYPE_FULLNAME (type
));
7564 pedwarn ("friend declaration requires class-key, "
7565 "i.e. `friend %#T'",
7569 /* Only try to do this stuff if we didn't already give up. */
7570 if (type
!= integer_type_node
)
7572 /* A friendly class? */
7573 if (current_class_type
)
7574 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
),
7577 error ("trying to make class `%T' a friend of global scope",
7580 type
= void_type_node
;
7585 if (ctype
== NULL_TREE
)
7587 if (TREE_CODE (type
) != METHOD_TYPE
)
7588 error ("invalid qualifiers on non-member function type");
7590 ctype
= TYPE_METHOD_BASETYPE (type
);
7594 tree dummy
= build_decl (TYPE_DECL
, unqualified_id
, type
);
7595 grok_method_quals (ctype
, dummy
, quals
);
7596 type
= TREE_TYPE (dummy
);
7602 else if (unqualified_id
== NULL_TREE
&& decl_context
!= PARM
7603 && decl_context
!= CATCHPARM
7604 && TREE_CODE (type
) != UNION_TYPE
7607 error ("abstract declarator `%T' used as declaration", type
);
7608 unqualified_id
= make_anon_name ();
7611 /* `void' at top level (not within pointer)
7612 is allowed only in typedefs or type names.
7613 We don't complain about parms either, but that is because
7614 a better error message can be made later. */
7616 if (TREE_CODE (type
) == VOID_TYPE
&& decl_context
!= PARM
)
7618 if (! unqualified_id
)
7619 error ("unnamed variable or field declared void");
7620 else if (TREE_CODE (unqualified_id
) == IDENTIFIER_NODE
)
7622 if (IDENTIFIER_OPNAME_P (unqualified_id
))
7625 error ("variable or field `%s' declared void", name
);
7628 error ("variable or field declared void");
7629 type
= integer_type_node
;
7632 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
7633 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
7635 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
7637 if (ctype
|| in_namespace
)
7638 error ("cannot use `::' in parameter declaration");
7640 /* A parameter declared as an array of T is really a pointer to T.
7641 One declared as a function is really a pointer to a function.
7642 One declared as a member is really a pointer to member. */
7644 if (TREE_CODE (type
) == ARRAY_TYPE
)
7646 /* Transfer const-ness of array into that of type pointed to. */
7647 type
= build_pointer_type (TREE_TYPE (type
));
7648 type_quals
= TYPE_UNQUALIFIED
;
7650 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
7651 type
= build_pointer_type (type
);
7657 if (decl_context
== PARM
)
7659 decl
= cp_build_parm_decl (unqualified_id
, type
);
7661 bad_specifiers (decl
, "parameter", virtualp
, quals
!= TYPE_UNQUALIFIED
,
7662 inlinep
, friendp
, raises
!= NULL_TREE
);
7664 else if (decl_context
== FIELD
)
7666 /* The C99 flexible array extension. */
7667 if (!staticp
&& TREE_CODE (type
) == ARRAY_TYPE
7668 && TYPE_DOMAIN (type
) == NULL_TREE
)
7670 tree itype
= compute_array_index_type (dname
, integer_zero_node
);
7671 type
= build_cplus_array_type (TREE_TYPE (type
), itype
);
7674 if (type
== error_mark_node
)
7676 /* Happens when declaring arrays of sizes which
7677 are error_mark_node, for example. */
7680 else if (in_namespace
&& !friendp
)
7682 /* Something like struct S { int N::j; }; */
7683 error ("invalid use of `::'");
7686 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
7689 tree function_context
;
7691 /* We catch the others as conflicts with the builtin
7693 if (friendp
&& unqualified_id
== ridpointers
[(int) RID_SIGNED
])
7695 error ("function `%D' cannot be declared friend",
7702 if (ctype
== NULL_TREE
)
7703 ctype
= current_class_type
;
7705 if (ctype
== NULL_TREE
)
7707 error ("can't make `%D' into a method -- not in a class",
7709 return void_type_node
;
7712 /* ``A union may [ ... ] not [ have ] virtual functions.''
7714 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
7716 error ("function `%D' declared virtual inside a union",
7718 return void_type_node
;
7721 if (NEW_DELETE_OPNAME_P (unqualified_id
))
7725 error ("`%D' cannot be declared virtual, since it is always static",
7730 else if (staticp
< 2)
7731 type
= build_method_type_directly (ctype
,
7733 TYPE_ARG_TYPES (type
));
7736 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
7737 function_context
= (ctype
!= NULL_TREE
) ?
7738 decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
7739 publicp
= (! friendp
|| ! staticp
)
7740 && function_context
== NULL_TREE
;
7741 decl
= grokfndecl (ctype
, type
,
7742 TREE_CODE (unqualified_id
) != TEMPLATE_ID_EXPR
7743 ? unqualified_id
: dname
,
7746 virtualp
, flags
, quals
, raises
,
7747 friendp
? -1 : 0, friendp
, publicp
, inlinep
,
7748 funcdef_flag
, template_count
, in_namespace
);
7749 if (decl
== NULL_TREE
)
7752 /* This clobbers the attrs stored in `decl' from `attrlist'. */
7753 /* The decl and setting of decl_attr is also turned off. */
7754 decl
= build_decl_attribute_variant (decl
, decl_attr
);
7757 /* [class.conv.ctor]
7759 A constructor declared without the function-specifier
7760 explicit that can be called with a single parameter
7761 specifies a conversion from the type of its first
7762 parameter to the type of its class. Such a constructor
7763 is called a converting constructor. */
7765 DECL_NONCONVERTING_P (decl
) = 1;
7766 else if (DECL_CONSTRUCTOR_P (decl
))
7768 /* The constructor can be called with exactly one
7769 parameter if there is at least one parameter, and
7770 any subsequent parameters have default arguments.
7771 Ignore any compiler-added parms. */
7772 tree arg_types
= FUNCTION_FIRST_USER_PARMTYPE (decl
);
7774 if (arg_types
== void_list_node
7776 && TREE_CHAIN (arg_types
)
7777 && TREE_CHAIN (arg_types
) != void_list_node
7778 && !TREE_PURPOSE (TREE_CHAIN (arg_types
))))
7779 DECL_NONCONVERTING_P (decl
) = 1;
7782 else if (TREE_CODE (type
) == METHOD_TYPE
)
7784 /* We only get here for friend declarations of
7785 members of other classes. */
7786 /* All method decls are public, so tell grokfndecl to set
7787 TREE_PUBLIC, also. */
7788 decl
= grokfndecl (ctype
, type
,
7789 TREE_CODE (unqualified_id
) != TEMPLATE_ID_EXPR
7790 ? unqualified_id
: dname
,
7793 virtualp
, flags
, quals
, raises
,
7794 friendp
? -1 : 0, friendp
, 1, 0, funcdef_flag
,
7795 template_count
, in_namespace
);
7796 if (decl
== NULL_TREE
)
7799 else if (!staticp
&& !dependent_type_p (type
)
7800 && !COMPLETE_TYPE_P (complete_type (type
))
7801 && (TREE_CODE (type
) != ARRAY_TYPE
|| initialized
== 0))
7804 error ("field `%D' has incomplete type", unqualified_id
);
7806 error ("name `%T' has incomplete type", type
);
7808 /* If we're instantiating a template, tell them which
7809 instantiation made the field's type be incomplete. */
7810 if (current_class_type
7811 && TYPE_NAME (current_class_type
)
7812 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type
))
7814 && declspecs
->type
== type
)
7815 error (" in instantiation of template `%T'",
7816 current_class_type
);
7818 type
= error_mark_node
;
7825 error ("`%E' is neither function nor member function; "
7826 "cannot be declared friend", unqualified_id
);
7834 /* Friends are treated specially. */
7835 if (ctype
== current_class_type
)
7836 warning ("member functions are implicitly friends of their class");
7837 else if (decl
&& DECL_NAME (decl
))
7839 if (template_class_depth (current_class_type
) == 0)
7841 decl
= check_explicit_specialization
7842 (unqualified_id
, decl
, template_count
,
7843 2 * (funcdef_flag
!= 0) + 4);
7844 if (decl
== error_mark_node
)
7845 return error_mark_node
;
7848 decl
= do_friend (ctype
, unqualified_id
, decl
,
7849 *attrlist
, flags
, quals
, funcdef_flag
);
7853 return void_type_node
;
7856 /* Structure field. It may not be a function, except for C++. */
7858 if (decl
== NULL_TREE
)
7864 /* An attempt is being made to initialize a non-static
7865 member. But, from [class.mem]:
7867 4 A member-declarator can contain a
7868 constant-initializer only if it declares a static
7869 member (_class.static_) of integral or enumeration
7870 type, see _class.static.data_.
7872 This used to be relatively common practice, but
7873 the rest of the compiler does not correctly
7874 handle the initialization unless the member is
7875 static so we make it static below. */
7876 pedwarn ("ISO C++ forbids initialization of member `%D'",
7878 pedwarn ("making `%D' static", unqualified_id
);
7882 if (uses_template_parms (type
))
7883 /* We'll check at instantiation time. */
7885 else if (check_static_variable_definition (unqualified_id
,
7887 /* If we just return the declaration, crashes
7888 will sometimes occur. We therefore return
7889 void_type_node, as if this was a friend
7890 declaration, to cause callers to completely
7891 ignore this declaration. */
7892 return void_type_node
;
7897 /* C++ allows static class members. All other work
7898 for this is done by grokfield. */
7899 decl
= build_lang_decl (VAR_DECL
, unqualified_id
, type
);
7900 set_linkage_for_static_data_member (decl
);
7901 /* Even if there is an in-class initialization, DECL
7902 is considered undefined until an out-of-class
7903 definition is provided. */
7904 DECL_EXTERNAL (decl
) = 1;
7908 decl
= build_decl (FIELD_DECL
, unqualified_id
, type
);
7909 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
7910 if (storage_class
== sc_mutable
)
7912 DECL_MUTABLE_P (decl
) = 1;
7913 storage_class
= sc_none
;
7917 bad_specifiers (decl
, "field", virtualp
, quals
!= TYPE_UNQUALIFIED
,
7918 inlinep
, friendp
, raises
!= NULL_TREE
);
7921 else if (TREE_CODE (type
) == FUNCTION_TYPE
7922 || TREE_CODE (type
) == METHOD_TYPE
)
7927 if (!unqualified_id
)
7930 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
7931 original_name
= dname
;
7933 original_name
= unqualified_id
;
7935 if (storage_class
== sc_auto
)
7936 error ("storage class `auto' invalid for function `%s'", name
);
7937 else if (storage_class
== sc_register
)
7938 error ("storage class `register' invalid for function `%s'", name
);
7940 error ("storage class `__thread' invalid for function `%s'", name
);
7942 /* Function declaration not at top level.
7943 Storage classes other than `extern' are not allowed
7944 and `extern' makes no difference. */
7945 if (! toplevel_bindings_p ()
7946 && (storage_class
== sc_static
7947 || declspecs
->specs
[(int)ds_inline
])
7950 if (storage_class
== sc_static
)
7951 pedwarn ("`static' specified invalid for function `%s' declared out of global scope", name
);
7953 pedwarn ("`inline' specifier invalid for function `%s' declared out of global scope", name
);
7956 if (ctype
== NULL_TREE
)
7960 error ("virtual non-class function `%s'", name
);
7964 else if (TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2
7965 && !NEW_DELETE_OPNAME_P (original_name
))
7966 type
= build_method_type_directly (ctype
,
7968 TYPE_ARG_TYPES (type
));
7970 /* Record presence of `static'. */
7971 publicp
= (ctype
!= NULL_TREE
7972 || storage_class
== sc_extern
7973 || storage_class
!= sc_static
);
7975 decl
= grokfndecl (ctype
, type
, original_name
, parms
, unqualified_id
,
7976 virtualp
, flags
, quals
, raises
,
7978 publicp
, inlinep
, funcdef_flag
,
7979 template_count
, in_namespace
);
7980 if (decl
== NULL_TREE
)
7985 int invalid_static
= 0;
7987 /* Don't allow a static member function in a class, and forbid
7988 declaring main to be static. */
7989 if (TREE_CODE (type
) == METHOD_TYPE
)
7991 pedwarn ("cannot declare member function `%D' to have static linkage", decl
);
7994 else if (current_function_decl
)
7996 /* FIXME need arm citation */
7997 error ("cannot declare static function inside another function");
8004 storage_class
= sc_none
;
8010 /* It's a variable. */
8012 /* An uninitialized decl with `extern' is a reference. */
8013 decl
= grokvardecl (type
, unqualified_id
,
8016 (type_quals
& TYPE_QUAL_CONST
) != 0,
8017 ctype
? ctype
: in_namespace
);
8018 bad_specifiers (decl
, "variable", virtualp
, quals
!= TYPE_UNQUALIFIED
,
8019 inlinep
, friendp
, raises
!= NULL_TREE
);
8023 DECL_CONTEXT (decl
) = ctype
;
8026 pedwarn ("`static' may not be used when defining (as opposed to declaring) a static data member");
8028 storage_class
= sc_none
;
8030 if (storage_class
== sc_register
&& TREE_STATIC (decl
))
8032 error ("static member `%D' declared `register'", decl
);
8033 storage_class
= sc_none
;
8035 if (storage_class
== sc_extern
&& pedantic
)
8037 pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
8039 storage_class
= sc_none
;
8044 /* Record `register' declaration for warnings on &
8045 and in case doing stupid register allocation. */
8047 if (storage_class
== sc_register
)
8048 DECL_REGISTER (decl
) = 1;
8049 else if (storage_class
== sc_extern
)
8050 DECL_THIS_EXTERN (decl
) = 1;
8051 else if (storage_class
== sc_static
)
8052 DECL_THIS_STATIC (decl
) = 1;
8054 /* Record constancy and volatility. There's no need to do this
8055 when processing a template; we'll do this for the instantiated
8056 declaration based on the type of DECL. */
8057 if (!processing_template_decl
)
8058 c_apply_type_quals_to_decl (type_quals
, decl
);
8064 /* Subroutine of start_function. Ensure that each of the parameter
8065 types (as listed in PARMS) is complete, as is required for a
8066 function definition. */
8069 require_complete_types_for_parms (tree parms
)
8071 for (; parms
; parms
= TREE_CHAIN (parms
))
8073 if (VOID_TYPE_P (TREE_TYPE (parms
)))
8074 /* grokparms will have already issued an error. */
8075 TREE_TYPE (parms
) = error_mark_node
;
8076 else if (complete_type_or_else (TREE_TYPE (parms
), parms
))
8078 layout_decl (parms
, 0);
8079 DECL_ARG_TYPE (parms
) = type_passed_as (TREE_TYPE (parms
));
8084 /* Returns nonzero if T is a local variable. */
8087 local_variable_p (tree t
)
8089 if ((TREE_CODE (t
) == VAR_DECL
8090 /* A VAR_DECL with a context that is a _TYPE is a static data
8092 && !TYPE_P (CP_DECL_CONTEXT (t
))
8093 /* Any other non-local variable must be at namespace scope. */
8094 && !DECL_NAMESPACE_SCOPE_P (t
))
8095 || (TREE_CODE (t
) == PARM_DECL
))
8101 /* Returns nonzero if T is an automatic local variable or a label.
8102 (These are the declarations that need to be remapped when the code
8103 containing them is duplicated.) */
8106 nonstatic_local_decl_p (tree t
)
8108 return ((local_variable_p (t
) && !TREE_STATIC (t
))
8109 || TREE_CODE (t
) == LABEL_DECL
8110 || TREE_CODE (t
) == RESULT_DECL
);
8113 /* Like local_variable_p, but suitable for use as a tree-walking
8117 local_variable_p_walkfn (tree
*tp
, int *walk_subtrees
,
8118 void *data ATTRIBUTE_UNUSED
)
8120 if (local_variable_p (*tp
) && !DECL_ARTIFICIAL (*tp
))
8122 else if (TYPE_P (*tp
))
8129 /* Check that ARG, which is a default-argument expression for a
8130 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
8131 something goes wrong. DECL may also be a _TYPE node, rather than a
8132 DECL, if there is no DECL available. */
8135 check_default_argument (tree decl
, tree arg
)
8140 if (TREE_CODE (arg
) == DEFAULT_ARG
)
8141 /* We get a DEFAULT_ARG when looking at an in-class declaration
8142 with a default argument. Ignore the argument for now; we'll
8143 deal with it after the class is complete. */
8146 if (processing_template_decl
|| uses_template_parms (arg
))
8147 /* We don't do anything checking until instantiation-time. Note
8148 that there may be uninstantiated arguments even for an
8149 instantiated function, since default arguments are not
8150 instantiated until they are needed. */
8159 decl_type
= TREE_TYPE (decl
);
8161 if (arg
== error_mark_node
8162 || decl
== error_mark_node
8163 || TREE_TYPE (arg
) == error_mark_node
8164 || decl_type
== error_mark_node
)
8165 /* Something already went wrong. There's no need to check
8167 return error_mark_node
;
8169 /* [dcl.fct.default]
8171 A default argument expression is implicitly converted to the
8173 if (!TREE_TYPE (arg
)
8174 || !can_convert_arg (decl_type
, TREE_TYPE (arg
), arg
))
8177 error ("default argument for `%#D' has type `%T'",
8178 decl
, TREE_TYPE (arg
));
8180 error ("default argument for parameter of type `%T' has type `%T'",
8181 decl_type
, TREE_TYPE (arg
));
8183 return error_mark_node
;
8186 /* [dcl.fct.default]
8188 Local variables shall not be used in default argument
8191 The keyword `this' shall not be used in a default argument of a
8193 var
= walk_tree_without_duplicates (&arg
, local_variable_p_walkfn
,
8197 error ("default argument `%E' uses local variable `%D'",
8199 return error_mark_node
;
8206 /* Decode the list of parameter types for a function type.
8207 Given the list of things declared inside the parens,
8208 return a list of types.
8210 If this parameter does not end with an ellipsis, we append
8213 *PARMS is set to the chain of PARM_DECLs created. */
8216 grokparms (cp_parameter_declarator
*first_parm
, tree
*parms
)
8218 tree result
= NULL_TREE
;
8219 tree decls
= NULL_TREE
;
8220 int ellipsis
= !first_parm
|| first_parm
->ellipsis_p
;
8221 cp_parameter_declarator
*parm
;
8224 for (parm
= first_parm
; parm
!= NULL
; parm
= parm
->next
)
8226 tree type
= NULL_TREE
;
8227 tree init
= parm
->default_argument
;
8231 if (parm
== no_parameters
)
8234 attrs
= parm
->decl_specifiers
.attributes
;
8235 parm
->decl_specifiers
.attributes
= NULL_TREE
;
8236 decl
= grokdeclarator (parm
->declarator
, &parm
->decl_specifiers
,
8237 PARM
, init
!= NULL_TREE
, &attrs
);
8238 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
8242 cplus_decl_attributes (&decl
, attrs
, 0);
8244 type
= TREE_TYPE (decl
);
8245 if (VOID_TYPE_P (type
))
8247 if (same_type_p (type
, void_type_node
)
8248 && !DECL_NAME (decl
) && !result
&& !parm
->next
&& !ellipsis
)
8249 /* this is a parmlist of `(void)', which is ok. */
8251 cxx_incomplete_type_error (decl
, type
);
8252 /* It's not a good idea to actually create parameters of
8253 type `void'; other parts of the compiler assume that a
8254 void type terminates the parameter list. */
8255 type
= error_mark_node
;
8256 TREE_TYPE (decl
) = error_mark_node
;
8259 if (type
!= error_mark_node
)
8261 /* Top-level qualifiers on the parameters are
8262 ignored for function types. */
8263 type
= cp_build_qualified_type (type
, 0);
8264 if (TREE_CODE (type
) == METHOD_TYPE
)
8266 error ("parameter `%D' invalidly declared method type", decl
);
8267 type
= build_pointer_type (type
);
8268 TREE_TYPE (decl
) = type
;
8270 else if (abstract_virtuals_error (decl
, type
))
8271 any_error
= 1; /* Seems like a good idea. */
8272 else if (POINTER_TYPE_P (type
))
8274 /* [dcl.fct]/6, parameter types cannot contain pointers
8275 (references) to arrays of unknown bound. */
8276 tree t
= TREE_TYPE (type
);
8277 int ptr
= TYPE_PTR_P (type
);
8283 else if (TREE_CODE (t
) != ARRAY_TYPE
)
8285 else if (!TYPE_DOMAIN (t
))
8289 if (TREE_CODE (t
) == ARRAY_TYPE
)
8290 error ("parameter `%D' includes %s to array of unknown bound `%T'",
8291 decl
, ptr
? "pointer" : "reference", t
);
8294 if (!any_error
&& init
)
8295 init
= check_default_argument (decl
, init
);
8300 TREE_CHAIN (decl
) = decls
;
8302 result
= tree_cons (init
, type
, result
);
8304 decls
= nreverse (decls
);
8305 result
= nreverse (result
);
8307 result
= chainon (result
, void_list_node
);
8314 /* D is a constructor or overloaded `operator='.
8316 Let T be the class in which D is declared. Then, this function
8319 -1 if D's is an ill-formed constructor or copy assignment operator
8320 whose first parameter is of type `T'.
8321 0 if D is not a copy constructor or copy assignment
8323 1 if D is a copy constructor or copy assignment operator whose
8324 first parameter is a reference to const qualified T.
8325 2 if D is a copy constructor or copy assignment operator whose
8326 first parameter is a reference to non-const qualified T.
8328 This function can be used as a predicate. Positive values indicate
8329 a copy constructor and nonzero values indicate a copy assignment
8339 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
8341 if (DECL_TEMPLATE_INFO (d
) && is_member_template (DECL_TI_TEMPLATE (d
)))
8342 /* Instantiations of template member functions are never copy
8343 functions. Note that member functions of templated classes are
8344 represented as template functions internally, and we must
8345 accept those as copy functions. */
8348 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
8352 arg_type
= TREE_VALUE (args
);
8354 if (TYPE_MAIN_VARIANT (arg_type
) == DECL_CONTEXT (d
))
8356 /* Pass by value copy assignment operator. */
8359 else if (TREE_CODE (arg_type
) == REFERENCE_TYPE
8360 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)) == DECL_CONTEXT (d
))
8362 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type
)))
8368 args
= TREE_CHAIN (args
);
8370 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
8371 /* There are more non-optional args. */
8377 /* Remember any special properties of member function DECL. */
8379 void grok_special_member_properties (tree decl
)
8381 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P(decl
))
8382 ; /* Not special. */
8383 else if (DECL_CONSTRUCTOR_P (decl
))
8385 int ctor
= copy_fn_p (decl
);
8391 A non-template constructor for class X is a copy
8392 constructor if its first parameter is of type X&, const
8393 X&, volatile X& or const volatile X&, and either there
8394 are no other parameters or else all other parameters have
8395 default arguments. */
8396 TYPE_HAS_INIT_REF (DECL_CONTEXT (decl
)) = 1;
8398 TYPE_HAS_CONST_INIT_REF (DECL_CONTEXT (decl
)) = 1;
8400 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl
)))
8401 TYPE_HAS_DEFAULT_CONSTRUCTOR (DECL_CONTEXT (decl
)) = 1;
8403 else if (DECL_OVERLOADED_OPERATOR_P (decl
) == NOP_EXPR
)
8407 A non-template assignment operator for class X is a copy
8408 assignment operator if its parameter is of type X, X&, const
8409 X&, volatile X& or const volatile X&. */
8411 int assop
= copy_fn_p (decl
);
8415 TYPE_HAS_ASSIGN_REF (DECL_CONTEXT (decl
)) = 1;
8417 TYPE_HAS_CONST_ASSIGN_REF (DECL_CONTEXT (decl
)) = 1;
8422 /* Check a constructor DECL has the correct form. Complains
8423 if the class has a constructor of the form X(X). */
8426 grok_ctor_properties (tree ctype
, tree decl
)
8428 int ctor_parm
= copy_fn_p (decl
);
8434 A declaration of a constructor for a class X is ill-formed if
8435 its first parameter is of type (optionally cv-qualified) X
8436 and either there are no other parameters or else all other
8437 parameters have default arguments.
8439 We *don't* complain about member template instantiations that
8440 have this form, though; they can occur as we try to decide
8441 what constructor to use during overload resolution. Since
8442 overload resolution will never prefer such a constructor to
8443 the non-template copy constructor (which is either explicitly
8444 or implicitly defined), there's no need to worry about their
8445 existence. Theoretically, they should never even be
8446 instantiated, but that's hard to forestall. */
8447 error ("invalid constructor; you probably meant `%T (const %T&)'",
8455 /* An operator with this code is unary, but can also be binary. */
8458 ambi_op_p (enum tree_code code
)
8460 return (code
== INDIRECT_REF
8461 || code
== ADDR_EXPR
8462 || code
== CONVERT_EXPR
8463 || code
== NEGATE_EXPR
8464 || code
== PREINCREMENT_EXPR
8465 || code
== PREDECREMENT_EXPR
);
8468 /* An operator with this name can only be unary. */
8471 unary_op_p (enum tree_code code
)
8473 return (code
== TRUTH_NOT_EXPR
8474 || code
== BIT_NOT_EXPR
8475 || code
== COMPONENT_REF
8476 || code
== TYPE_EXPR
);
8479 /* DECL is a declaration for an overloaded operator. Returns true if
8480 the declaration is valid; false otherwise. If COMPLAIN is true,
8481 errors are issued for invalid declarations. */
8484 grok_op_properties (tree decl
, int friendp
, bool complain
)
8486 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
8488 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
8489 tree name
= DECL_NAME (decl
);
8490 enum tree_code operator_code
;
8494 /* Assume that the declaration is valid. */
8497 /* Count the number of arguments. */
8498 for (argtype
= argtypes
, arity
= 0;
8499 argtype
&& argtype
!= void_list_node
;
8500 argtype
= TREE_CHAIN (argtype
))
8503 if (current_class_type
== NULL_TREE
)
8506 if (DECL_CONV_FN_P (decl
))
8507 operator_code
= TYPE_EXPR
;
8511 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
8512 if (ansi_opname (CODE) == name) \
8514 operator_code = (CODE); \
8517 else if (ansi_assopname (CODE) == name) \
8519 operator_code = (CODE); \
8520 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
8524 #include "operators.def"
8530 gcc_assert (operator_code
!= LAST_CPLUS_TREE_CODE
);
8531 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
8535 switch (operator_code
)
8538 TYPE_HAS_NEW_OPERATOR (current_class_type
) = 1;
8542 TYPE_GETS_DELETE (current_class_type
) |= 1;
8546 TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type
) = 1;
8549 case VEC_DELETE_EXPR
:
8550 TYPE_GETS_DELETE (current_class_type
) |= 2;
8558 /* [basic.std.dynamic.allocation]/1:
8560 A program is ill-formed if an allocation function is declared
8561 in a namespace scope other than global scope or declared static
8564 The same also holds true for deallocation functions. */
8565 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
8566 || operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
8568 if (DECL_NAMESPACE_SCOPE_P (decl
))
8570 if (CP_DECL_CONTEXT (decl
) != global_namespace
)
8571 error ("`%D' may not be declared within a namespace", decl
);
8572 else if (!TREE_PUBLIC (decl
))
8573 error ("`%D' may not be declared as static", decl
);
8577 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
)
8578 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
8579 else if (operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
8580 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
8583 /* An operator function must either be a non-static member function
8584 or have at least one parameter of a class, a reference to a class,
8585 an enumeration, or a reference to an enumeration. 13.4.0.6 */
8586 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
8588 if (operator_code
== TYPE_EXPR
8589 || operator_code
== CALL_EXPR
8590 || operator_code
== COMPONENT_REF
8591 || operator_code
== ARRAY_REF
8592 || operator_code
== NOP_EXPR
)
8593 error ("`%D' must be a nonstatic member function", decl
);
8598 if (DECL_STATIC_FUNCTION_P (decl
))
8599 error ("`%D' must be either a non-static member function or a non-member function", decl
);
8601 for (p
= argtypes
; p
&& p
!= void_list_node
; p
= TREE_CHAIN (p
))
8603 tree arg
= non_reference (TREE_VALUE (p
));
8604 /* IS_AGGR_TYPE, rather than CLASS_TYPE_P, is used
8605 because these checks are performed even on
8606 template functions. */
8607 if (IS_AGGR_TYPE (arg
) || TREE_CODE (arg
) == ENUMERAL_TYPE
)
8611 if (!p
|| p
== void_list_node
)
8616 error ("`%D' must have an argument of class or "
8624 /* There are no restrictions on the arguments to an overloaded
8626 if (operator_code
== CALL_EXPR
)
8629 if (IDENTIFIER_TYPENAME_P (name
) && ! DECL_TEMPLATE_INFO (decl
))
8631 tree t
= TREE_TYPE (name
);
8634 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
8635 const char *what
= 0;
8638 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
8640 if (TREE_CODE (t
) == VOID_TYPE
)
8642 else if (t
== current_class_type
)
8643 what
= "the same type";
8644 /* Don't force t to be complete here. */
8645 else if (IS_AGGR_TYPE (t
)
8646 && COMPLETE_TYPE_P (t
)
8647 && DERIVED_FROM_P (t
, current_class_type
))
8648 what
= "a base class";
8650 if (what
&& warn_conversion
)
8651 warning ("conversion to %s%s will never use a type conversion operator",
8652 ref
? "a reference to " : "", what
);
8655 if (operator_code
== COND_EXPR
)
8658 error ("ISO C++ prohibits overloading operator ?:");
8660 else if (ambi_op_p (operator_code
))
8663 /* We pick the one-argument operator codes by default, so
8664 we don't have to change anything. */
8666 else if (arity
== 2)
8668 /* If we thought this was a unary operator, we now know
8669 it to be a binary operator. */
8670 switch (operator_code
)
8673 operator_code
= MULT_EXPR
;
8677 operator_code
= BIT_AND_EXPR
;
8681 operator_code
= PLUS_EXPR
;
8685 operator_code
= MINUS_EXPR
;
8688 case PREINCREMENT_EXPR
:
8689 operator_code
= POSTINCREMENT_EXPR
;
8692 case PREDECREMENT_EXPR
:
8693 operator_code
= POSTDECREMENT_EXPR
;
8700 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
8702 if ((operator_code
== POSTINCREMENT_EXPR
8703 || operator_code
== POSTDECREMENT_EXPR
)
8704 && ! processing_template_decl
8705 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)), integer_type_node
))
8708 error ("postfix `%D' must take `int' as its argument",
8712 ("postfix `%D' must take `int' as its second argument",
8719 error ("`%D' must take either zero or one argument", decl
);
8721 error ("`%D' must take either one or two arguments", decl
);
8724 /* More Effective C++ rule 6. */
8726 && (operator_code
== POSTINCREMENT_EXPR
8727 || operator_code
== POSTDECREMENT_EXPR
8728 || operator_code
== PREINCREMENT_EXPR
8729 || operator_code
== PREDECREMENT_EXPR
))
8731 tree arg
= TREE_VALUE (argtypes
);
8732 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
8733 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
8734 arg
= TREE_TYPE (arg
);
8735 arg
= TYPE_MAIN_VARIANT (arg
);
8736 if (operator_code
== PREINCREMENT_EXPR
8737 || operator_code
== PREDECREMENT_EXPR
)
8739 if (TREE_CODE (ret
) != REFERENCE_TYPE
8740 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
8742 warning ("prefix `%D' should return `%T'", decl
,
8743 build_reference_type (arg
));
8747 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
8748 warning ("postfix `%D' should return `%T'", decl
, arg
);
8752 else if (unary_op_p (operator_code
))
8757 error ("`%D' must take `void'", decl
);
8759 error ("`%D' must take exactly one argument", decl
);
8762 else /* if (binary_op_p (operator_code)) */
8767 error ("`%D' must take exactly one argument", decl
);
8769 error ("`%D' must take exactly two arguments", decl
);
8772 /* More Effective C++ rule 7. */
8774 && (operator_code
== TRUTH_ANDIF_EXPR
8775 || operator_code
== TRUTH_ORIF_EXPR
8776 || operator_code
== COMPOUND_EXPR
))
8777 warning ("user-defined `%D' always evaluates both arguments",
8781 /* Effective C++ rule 23. */
8784 && !DECL_ASSIGNMENT_OPERATOR_P (decl
)
8785 && (operator_code
== PLUS_EXPR
8786 || operator_code
== MINUS_EXPR
8787 || operator_code
== TRUNC_DIV_EXPR
8788 || operator_code
== MULT_EXPR
8789 || operator_code
== TRUNC_MOD_EXPR
)
8790 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
8791 warning ("`%D' should return by value", decl
);
8794 for (; argtypes
&& argtypes
!= void_list_node
;
8795 argtypes
= TREE_CHAIN (argtypes
))
8796 if (TREE_PURPOSE (argtypes
))
8798 TREE_PURPOSE (argtypes
) = NULL_TREE
;
8799 if (operator_code
== POSTINCREMENT_EXPR
8800 || operator_code
== POSTDECREMENT_EXPR
)
8803 pedwarn ("`%D' cannot have default arguments", decl
);
8806 error ("`%D' cannot have default arguments", decl
);
8815 tag_name (enum tag_types code
)
8832 /* Name lookup in an elaborated-type-specifier (after the keyword
8833 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
8834 elaborated-type-specifier is invalid, issue a diagnostic and return
8835 error_mark_node; otherwise, return the *_TYPE to which it referred.
8836 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
8839 check_elaborated_type_specifier (enum tag_types tag_code
,
8841 bool allow_template_p
)
8847 struct S { struct S *p; };
8849 name lookup will find the TYPE_DECL for the implicit "S::S"
8850 typedef. Adjust for that here. */
8851 if (DECL_SELF_REFERENCE_P (decl
))
8852 decl
= TYPE_NAME (TREE_TYPE (decl
));
8854 type
= TREE_TYPE (decl
);
8858 If the identifier resolves to a typedef-name or a template
8859 type-parameter, the elaborated-type-specifier is ill-formed.
8861 In other words, the only legitimate declaration to use in the
8862 elaborated type specifier is the implicit typedef created when
8863 the type is declared. */
8864 if (!DECL_IMPLICIT_TYPEDEF_P (decl
))
8866 error ("using typedef-name `%D' after `%s'", decl
, tag_name (tag_code
));
8867 return IS_AGGR_TYPE (type
) ? type
: error_mark_node
;
8870 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
8872 error ("using template type parameter `%T' after `%s'",
8873 type
, tag_name (tag_code
));
8874 return error_mark_node
;
8876 else if (TREE_CODE (type
) != RECORD_TYPE
8877 && TREE_CODE (type
) != UNION_TYPE
8878 && tag_code
!= enum_type
)
8880 error ("`%T' referred to as `%s'", type
, tag_name (tag_code
));
8881 return error_mark_node
;
8883 else if (TREE_CODE (type
) != ENUMERAL_TYPE
8884 && tag_code
== enum_type
)
8886 error ("`%T' referred to as enum", type
);
8887 return error_mark_node
;
8889 else if (!allow_template_p
8890 && TREE_CODE (type
) == RECORD_TYPE
8891 && CLASSTYPE_IS_TEMPLATE (type
))
8893 /* If a class template appears as elaborated type specifier
8894 without a template header such as:
8896 template <class T> class C {};
8897 void f(class C); // No template header here
8899 then the required template argument is missing. */
8901 error ("template argument required for `%s %T'",
8902 tag_name (tag_code
),
8903 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
)));
8904 return error_mark_node
;
8910 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
8911 Define the tag as a forward-reference if it is not defined.
8913 If a declaration is given, process it here, and report an error if
8914 multiple declarations are not identical.
8916 GLOBALIZE is false when this is also a definition. Only look in
8917 the current frame for the name (since C++ allows new names in any
8920 TEMPLATE_HEADER_P is true when this declaration is preceded by
8921 a set of template parameters. */
8924 xref_tag (enum tag_types tag_code
, tree name
,
8925 bool globalize
, bool template_header_p
)
8927 enum tree_code code
;
8929 struct cp_binding_level
*b
= current_binding_level
;
8930 tree context
= NULL_TREE
;
8932 timevar_push (TV_NAME_LOOKUP
);
8934 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
8946 code
= ENUMERAL_TYPE
;
8954 /* If we know we are defining this tag, only look it up in
8955 this scope and don't try to find it as a type. */
8956 t
= lookup_tag (code
, name
, b
, 1);
8960 tree decl
= lookup_name (name
, 2);
8962 if (decl
&& DECL_CLASS_TEMPLATE_P (decl
))
8963 decl
= DECL_TEMPLATE_RESULT (decl
);
8965 if (decl
&& TREE_CODE (decl
) == TYPE_DECL
)
8967 /* Two cases we need to consider when deciding if a class
8968 template is allowed as an elaborated type specifier:
8969 1. It is a self reference to its own class.
8970 2. It comes with a template header.
8974 template <class T> class C {
8975 class C *c1; // DECL_SELF_REFERENCE_P is true
8978 template <class U> class C; // template_header_p is true
8979 template <class T> class C<T>::D {
8980 class C *c2; // DECL_SELF_REFERENCE_P is true
8983 t
= check_elaborated_type_specifier (tag_code
,
8986 | DECL_SELF_REFERENCE_P (decl
));
8987 if (t
== error_mark_node
)
8988 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
8993 if (t
&& current_class_type
8994 && template_class_depth (current_class_type
)
8995 && template_header_p
)
8997 /* Since GLOBALIZE is nonzero, we are not looking at a
8998 definition of this tag. Since, in addition, we are currently
8999 processing a (member) template declaration of a template
9000 class, we must be very careful; consider:
9007 { template <class V>
9008 friend struct S1; };
9010 Here, the S2::S1 declaration should not be confused with the
9011 outer declaration. In particular, the inner version should
9012 have a template parameter of level 2, not level 1. This
9013 would be particularly important if the member declaration
9016 template <class V = U> friend struct S1;
9018 say, when we should tsubst into `U' when instantiating
9019 S2. On the other hand, when presented with:
9029 we must find the inner binding eventually. We
9030 accomplish this by making sure that the new type we
9031 create to represent this declaration has the right
9033 context
= TYPE_CONTEXT (t
);
9040 /* If no such tag is yet defined, create a forward-reference node
9041 and record it as the "definition".
9042 When a real declaration of this type is found,
9043 the forward-reference will be altered into a real type. */
9044 if (code
== ENUMERAL_TYPE
)
9046 error ("use of enum `%#D' without previous declaration", name
);
9047 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
9051 t
= make_aggr_type (code
);
9052 TYPE_CONTEXT (t
) = context
;
9053 pushtag (name
, t
, globalize
);
9058 if (!globalize
&& processing_template_decl
&& IS_AGGR_TYPE (t
))
9059 redeclare_class_template (t
, current_template_parms
);
9060 else if (!processing_template_decl
9062 && CLASSTYPE_IS_TEMPLATE (t
))
9064 error ("redeclaration of `%T' as a non-template", t
);
9065 t
= error_mark_node
;
9069 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
9073 xref_tag_from_type (tree old
, tree id
, int globalize
)
9075 enum tag_types tag_kind
;
9077 if (TREE_CODE (old
) == RECORD_TYPE
)
9078 tag_kind
= (CLASSTYPE_DECLARED_CLASS (old
) ? class_type
: record_type
);
9080 tag_kind
= union_type
;
9082 if (id
== NULL_TREE
)
9083 id
= TYPE_IDENTIFIER (old
);
9085 return xref_tag (tag_kind
, id
, globalize
, false);
9088 /* Create the binfo hierarchy for REF with (possibly NULL) base list
9089 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
9090 access_* node, and the TREE_VALUE is the type of the base-class.
9091 Non-NULL TREE_TYPE indicates virtual inheritance. */
9094 xref_basetypes (tree ref
, tree base_list
)
9097 tree binfo
, base_binfo
;
9098 unsigned max_vbases
= 0; /* Maxium direct & indirect virtual bases. */
9099 unsigned max_bases
= 0; /* Maxium direct bases. */
9101 tree default_access
;
9102 tree igo_prev
; /* Track Inheritance Graph Order. */
9104 if (ref
== error_mark_node
)
9107 /* The base of a derived class is private by default, all others are
9109 default_access
= (TREE_CODE (ref
) == RECORD_TYPE
9110 && CLASSTYPE_DECLARED_CLASS (ref
)
9111 ? access_private_node
: access_public_node
);
9113 /* First, make sure that any templates in base-classes are
9114 instantiated. This ensures that if we call ourselves recursively
9115 we do not get confused about which classes are marked and which
9120 tree basetype
= TREE_VALUE (*basep
);
9122 if (!(processing_template_decl
&& uses_template_parms (basetype
))
9123 && !complete_type_or_else (basetype
, NULL
))
9124 /* An incomplete type. Remove it from the list. */
9125 *basep
= TREE_CHAIN (*basep
);
9129 if (TREE_TYPE (*basep
))
9131 if (CLASS_TYPE_P (basetype
))
9132 max_vbases
+= VEC_length (tree
, CLASSTYPE_VBASECLASSES (basetype
));
9133 basep
= &TREE_CHAIN (*basep
);
9137 SET_CLASSTYPE_MARKED (ref
);
9139 /* The binfo slot should be empty, unless this is an (ill-formed)
9141 gcc_assert (!TYPE_BINFO (ref
) || TYPE_SIZE (ref
));
9142 gcc_assert (TYPE_MAIN_VARIANT (ref
) == ref
);
9144 binfo
= make_tree_binfo (max_bases
);
9146 TYPE_BINFO (ref
) = binfo
;
9147 BINFO_OFFSET (binfo
) = size_zero_node
;
9148 BINFO_TYPE (binfo
) = ref
;
9152 BINFO_BASE_ACCESSES (binfo
) = VEC_alloc (tree
, max_bases
);
9153 /* An aggregate cannot have baseclasses. */
9154 CLASSTYPE_NON_AGGREGATE (ref
) = 1;
9156 if (TREE_CODE (ref
) == UNION_TYPE
)
9157 error ("derived union `%T' invalid", ref
);
9162 TYPE_USES_MULTIPLE_INHERITANCE (ref
) = 1;
9163 /* If there is more than one non-empty they cannot be at the
9165 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref
) = 1;
9167 if (TYPE_FOR_JAVA (ref
))
9168 error ("Java class '%T' cannot have multiple bases", ref
);
9173 CLASSTYPE_VBASECLASSES (ref
) = VEC_alloc (tree
, max_vbases
);
9174 TYPE_USES_VIRTUAL_BASECLASSES (ref
) = 1;
9175 /* Converting to a virtual base class requires looking up the
9176 offset of the virtual base. */
9177 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref
) = 1;
9179 if (TYPE_FOR_JAVA (ref
))
9180 error ("Java class '%T' cannot have virtual bases", ref
);
9183 for (igo_prev
= binfo
; base_list
; base_list
= TREE_CHAIN (base_list
))
9185 tree access
= TREE_PURPOSE (base_list
);
9186 int via_virtual
= TREE_TYPE (base_list
) != NULL_TREE
;
9187 tree basetype
= TREE_VALUE (base_list
);
9189 if (access
== access_default_node
)
9190 access
= default_access
;
9192 if (TREE_CODE (basetype
) == TYPE_DECL
)
9193 basetype
= TREE_TYPE (basetype
);
9194 if (TREE_CODE (basetype
) != RECORD_TYPE
9195 && TREE_CODE (basetype
) != TYPENAME_TYPE
9196 && TREE_CODE (basetype
) != TEMPLATE_TYPE_PARM
9197 && TREE_CODE (basetype
) != BOUND_TEMPLATE_TEMPLATE_PARM
)
9199 error ("base type `%T' fails to be a struct or class type",
9204 if (CLASSTYPE_MARKED (basetype
))
9206 if (basetype
== ref
)
9207 error ("recursive type `%T' undefined", basetype
);
9209 error ("duplicate base type `%T' invalid", basetype
);
9212 SET_CLASSTYPE_MARKED (basetype
);
9214 if (TYPE_FOR_JAVA (basetype
) && (current_lang_depth () == 0))
9215 TYPE_FOR_JAVA (ref
) = 1;
9217 base_binfo
= NULL_TREE
;
9218 if (CLASS_TYPE_P (basetype
) && !dependent_type_p (basetype
))
9220 base_binfo
= TYPE_BINFO (basetype
);
9221 /* The orignal basetype could have been a typedef'd type. */
9222 basetype
= BINFO_TYPE (base_binfo
);
9224 /* Inherit flags from the base. */
9225 TYPE_HAS_NEW_OPERATOR (ref
)
9226 |= TYPE_HAS_NEW_OPERATOR (basetype
);
9227 TYPE_HAS_ARRAY_NEW_OPERATOR (ref
)
9228 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype
);
9229 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
9230 TYPE_USES_MULTIPLE_INHERITANCE (ref
)
9231 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype
);
9232 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref
)
9233 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype
);
9234 TYPE_HAS_CONVERSION (ref
) |= TYPE_HAS_CONVERSION (basetype
);
9237 base_binfo
= copy_binfo (base_binfo
, basetype
, ref
,
9238 &igo_prev
, via_virtual
);
9239 if (!BINFO_INHERITANCE_CHAIN (base_binfo
))
9240 BINFO_INHERITANCE_CHAIN (base_binfo
) = binfo
;
9242 BINFO_BASE_APPEND (binfo
, base_binfo
);
9243 BINFO_BASE_ACCESS_APPEND (binfo
, access
);
9246 /* Unmark all the types. */
9247 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
9248 CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (base_binfo
));
9249 CLEAR_CLASSTYPE_MARKED (ref
);
9253 /* Begin compiling the definition of an enumeration type.
9254 NAME is its name (or null if anonymous).
9255 Returns the type object, as yet incomplete.
9256 Also records info about it so that build_enumerator
9257 may be used to declare the individual values as they are read. */
9260 start_enum (tree name
)
9262 tree enumtype
= NULL_TREE
;
9263 struct cp_binding_level
*b
= current_binding_level
;
9265 /* If this is the real definition for a previous forward reference,
9266 fill in the contents in the same object that used to be the
9267 forward reference. */
9269 if (name
!= NULL_TREE
)
9270 enumtype
= lookup_tag (ENUMERAL_TYPE
, name
, b
, 1);
9272 if (enumtype
!= NULL_TREE
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
9274 error ("multiple definition of `%#T'", enumtype
);
9275 error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype
));
9276 /* Clear out TYPE_VALUES, and start again. */
9277 TYPE_VALUES (enumtype
) = NULL_TREE
;
9281 enumtype
= make_node (ENUMERAL_TYPE
);
9282 pushtag (name
, enumtype
, 0);
9288 /* After processing and defining all the values of an enumeration type,
9289 install their decls in the enumeration type and finish it off.
9290 ENUMTYPE is the type object and VALUES a list of name-value pairs. */
9293 finish_enum (tree enumtype
)
9305 integer_type_kind itk
;
9306 tree underlying_type
= NULL_TREE
;
9308 /* We built up the VALUES in reverse order. */
9309 TYPE_VALUES (enumtype
) = nreverse (TYPE_VALUES (enumtype
));
9311 /* For an enum defined in a template, just set the type of the values;
9312 all further processing is postponed until the template is
9313 instantiated. We need to set the type so that tsubst of a CONST_DECL
9315 if (processing_template_decl
)
9317 for (values
= TYPE_VALUES (enumtype
);
9319 values
= TREE_CHAIN (values
))
9320 TREE_TYPE (TREE_VALUE (values
)) = enumtype
;
9321 if (at_function_scope_p ())
9322 add_stmt (build_min (TAG_DEFN
, enumtype
));
9326 /* Determine the minimum and maximum values of the enumerators. */
9327 if (TYPE_VALUES (enumtype
))
9329 minnode
= maxnode
= NULL_TREE
;
9331 for (values
= TYPE_VALUES (enumtype
);
9333 values
= TREE_CHAIN (values
))
9335 decl
= TREE_VALUE (values
);
9337 /* [dcl.enum]: Following the closing brace of an enum-specifier,
9338 each enumerator has the type of its enumeration. Prior to the
9339 closing brace, the type of each enumerator is the type of its
9340 initializing value. */
9341 TREE_TYPE (decl
) = enumtype
;
9343 /* Update the minimum and maximum values, if appropriate. */
9344 value
= DECL_INITIAL (decl
);
9345 /* Figure out what the minimum and maximum values of the
9348 minnode
= maxnode
= value
;
9349 else if (tree_int_cst_lt (maxnode
, value
))
9351 else if (tree_int_cst_lt (value
, minnode
))
9358 If the enumerator-list is empty, the underlying type is as if
9359 the enumeration had a single enumerator with value 0. */
9360 minnode
= maxnode
= integer_zero_node
;
9362 /* Compute the number of bits require to represent all values of the
9363 enumeration. We must do this before the type of MINNODE and
9364 MAXNODE are transformed, since min_precision relies on the
9365 TREE_TYPE of the value it is passed. */
9366 unsignedp
= tree_int_cst_sgn (minnode
) >= 0;
9367 lowprec
= min_precision (minnode
, unsignedp
);
9368 highprec
= min_precision (maxnode
, unsignedp
);
9369 precision
= MAX (lowprec
, highprec
);
9371 /* Determine the underlying type of the enumeration.
9375 The underlying type of an enumeration is an integral type that
9376 can represent all the enumerator values defined in the
9377 enumeration. It is implementation-defined which integral type is
9378 used as the underlying type for an enumeration except that the
9379 underlying type shall not be larger than int unless the value of
9380 an enumerator cannot fit in an int or unsigned int.
9382 We use "int" or an "unsigned int" as the underlying type, even if
9383 a smaller integral type would work, unless the user has
9384 explicitly requested that we use the smallest possible type. */
9385 for (itk
= (flag_short_enums
? itk_char
: itk_int
);
9389 underlying_type
= integer_types
[itk
];
9390 if (TYPE_PRECISION (underlying_type
) >= precision
9391 && TYPE_UNSIGNED (underlying_type
) == unsignedp
)
9394 if (itk
== itk_none
)
9398 IF no integral type can represent all the enumerator values, the
9399 enumeration is ill-formed. */
9400 error ("no integral type can represent all of the enumerator values "
9401 "for `%T'", enumtype
);
9402 precision
= TYPE_PRECISION (long_long_integer_type_node
);
9403 underlying_type
= integer_types
[itk_unsigned_long_long
];
9406 /* Compute the minium and maximum values for the type.
9410 For an enumeration where emin is the smallest enumerator and emax
9411 is the largest, the values of the enumeration are the values of the
9412 underlying type in the range bmin to bmax, where bmin and bmax are,
9413 respectively, the smallest and largest values of the smallest bit-
9414 field that can store emin and emax. */
9416 /* The middle-end currently assumes that types with TYPE_PRECISION
9417 narrower than their underlying type are suitably zero or sign
9418 extended to fill their mode. g++ doesn't make these guarantees.
9419 Until the middle-end can represent such paradoxical types, we
9420 set the TYPE_PRECISON to the width of the underlying type. */
9421 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (underlying_type
);
9423 set_min_and_max_values_for_integral_type (enumtype
, precision
, unsignedp
);
9427 The value of sizeof() applied to an enumeration type, an object
9428 of an enumeration type, or an enumerator, is the value of sizeof()
9429 applied to the underlying type. */
9430 TYPE_SIZE (enumtype
) = TYPE_SIZE (underlying_type
);
9431 TYPE_SIZE_UNIT (enumtype
) = TYPE_SIZE_UNIT (underlying_type
);
9432 TYPE_MODE (enumtype
) = TYPE_MODE (underlying_type
);
9433 TYPE_ALIGN (enumtype
) = TYPE_ALIGN (underlying_type
);
9434 TYPE_USER_ALIGN (enumtype
) = TYPE_USER_ALIGN (underlying_type
);
9435 TYPE_UNSIGNED (enumtype
) = TYPE_UNSIGNED (underlying_type
);
9437 /* Convert each of the enumerators to the type of the underlying
9438 type of the enumeration. */
9439 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
9441 decl
= TREE_VALUE (values
);
9442 value
= perform_implicit_conversion (underlying_type
,
9443 DECL_INITIAL (decl
));
9445 /* Do not clobber shared ints. */
9446 value
= copy_node (value
);
9448 TREE_TYPE (value
) = enumtype
;
9449 DECL_INITIAL (decl
) = value
;
9450 TREE_VALUE (values
) = value
;
9453 /* Fix up all variant types of this enum type. */
9454 for (t
= TYPE_MAIN_VARIANT (enumtype
); t
; t
= TYPE_NEXT_VARIANT (t
))
9456 TYPE_VALUES (t
) = TYPE_VALUES (enumtype
);
9457 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (enumtype
);
9458 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (enumtype
);
9459 TYPE_SIZE (t
) = TYPE_SIZE (enumtype
);
9460 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (enumtype
);
9461 TYPE_MODE (t
) = TYPE_MODE (enumtype
);
9462 TYPE_PRECISION (t
) = TYPE_PRECISION (enumtype
);
9463 TYPE_ALIGN (t
) = TYPE_ALIGN (enumtype
);
9464 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (enumtype
);
9465 TYPE_UNSIGNED (t
) = TYPE_UNSIGNED (enumtype
);
9468 /* Finish debugging output for this type. */
9469 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
9472 /* Build and install a CONST_DECL for an enumeration constant of the
9473 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
9474 Assignment of sequential values by default is handled here. */
9477 build_enumerator (tree name
, tree value
, tree enumtype
)
9483 /* Remove no-op casts from the value. */
9485 STRIP_TYPE_NOPS (value
);
9487 if (! processing_template_decl
)
9489 /* Validate and default VALUE. */
9490 if (value
!= NULL_TREE
)
9492 value
= decl_constant_value (value
);
9494 if (TREE_CODE (value
) == INTEGER_CST
)
9496 value
= perform_integral_promotions (value
);
9497 constant_expression_warning (value
);
9501 error ("enumerator value for `%D' not integer constant", name
);
9506 /* Default based on previous value. */
9507 if (value
== NULL_TREE
)
9511 if (TYPE_VALUES (enumtype
))
9513 /* The next value is the previous value ... */
9514 prev_value
= DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype
)));
9516 value
= cp_build_binary_op (PLUS_EXPR
,
9520 if (tree_int_cst_lt (value
, prev_value
))
9521 error ("overflow in enumeration values at `%D'", name
);
9524 value
= integer_zero_node
;
9527 /* Remove no-op casts from the value. */
9528 STRIP_TYPE_NOPS (value
);
9531 /* C++ associates enums with global, function, or class declarations. */
9532 context
= current_scope ();
9534 context
= current_namespace
;
9536 /* Build the actual enumeration constant. Note that the enumeration
9537 constants have the type of their initializers until the
9538 enumeration is complete:
9542 Following the closing brace of an enum-specifier, each enumer-
9543 ator has the type of its enumeration. Prior to the closing
9544 brace, the type of each enumerator is the type of its
9547 In finish_enum we will reset the type. Of course, if we're
9548 processing a template, there may be no value. */
9549 type
= value
? TREE_TYPE (value
) : NULL_TREE
;
9551 if (context
&& context
== current_class_type
)
9552 /* This enum declaration is local to the class. We need the full
9553 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
9554 decl
= build_lang_decl (CONST_DECL
, name
, type
);
9556 /* It's a global enum, or it's local to a function. (Note local to
9557 a function could mean local to a class method. */
9558 decl
= build_decl (CONST_DECL
, name
, type
);
9560 DECL_CONTEXT (decl
) = FROB_CONTEXT (context
);
9561 TREE_CONSTANT (decl
) = 1;
9562 TREE_INVARIANT (decl
) = 1;
9563 TREE_READONLY (decl
) = 1;
9564 DECL_INITIAL (decl
) = value
;
9566 if (context
&& context
== current_class_type
)
9567 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
9568 on the TYPE_FIELDS list for `S'. (That's so that you can say
9569 things like `S::i' later.) */
9570 finish_member_declaration (decl
);
9574 /* Add this enumeration constant to the list for this type. */
9575 TYPE_VALUES (enumtype
) = tree_cons (name
, decl
, TYPE_VALUES (enumtype
));
9579 /* We're defining DECL. Make sure that it's type is OK. */
9582 check_function_type (tree decl
, tree current_function_parms
)
9584 tree fntype
= TREE_TYPE (decl
);
9585 tree return_type
= complete_type (TREE_TYPE (fntype
));
9587 /* In a function definition, arg types must be complete. */
9588 require_complete_types_for_parms (current_function_parms
);
9590 if (!COMPLETE_OR_VOID_TYPE_P (return_type
))
9592 error ("return type `%#T' is incomplete", TREE_TYPE (fntype
));
9594 /* Make it return void instead, but don't change the
9595 type of the DECL_RESULT, in case we have a named return value. */
9596 if (TREE_CODE (fntype
) == METHOD_TYPE
)
9598 tree ctype
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype
)));
9600 = build_method_type_directly (ctype
,
9602 FUNCTION_ARG_CHAIN (decl
));
9606 = build_function_type (void_type_node
,
9607 TYPE_ARG_TYPES (TREE_TYPE (decl
)));
9609 = build_exception_variant (fntype
,
9610 TYPE_RAISES_EXCEPTIONS (fntype
));
9613 abstract_virtuals_error (decl
, TREE_TYPE (fntype
));
9616 /* Create the FUNCTION_DECL for a function definition.
9617 DECLSPECS and DECLARATOR are the parts of the declaration;
9618 they describe the function's name and the type it returns,
9619 but twisted together in a fashion that parallels the syntax of C.
9621 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
9622 DECLARATOR is really the DECL for the function we are about to
9623 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
9624 indicating that the function is an inline defined in-class.
9626 This function creates a binding context for the function body
9627 as well as setting up the FUNCTION_DECL in current_function_decl.
9629 For C++, we must first check whether that datum makes any sense.
9630 For example, "class A local_a(1,2);" means that variable local_a
9631 is an aggregate of type A, which should have a constructor
9632 applied to it with the argument list [1, 2]. */
9635 start_preparsed_function (tree decl1
, tree attrs
, int flags
)
9637 tree ctype
= NULL_TREE
;
9640 int doing_friend
= 0;
9641 struct cp_binding_level
*bl
;
9642 tree current_function_parms
;
9645 gcc_assert (TREE_CODE (TREE_VALUE (void_list_node
)) == VOID_TYPE
);
9646 gcc_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
);
9648 fntype
= TREE_TYPE (decl1
);
9649 if (TREE_CODE (fntype
) == METHOD_TYPE
)
9650 ctype
= TYPE_METHOD_BASETYPE (fntype
);
9652 /* ISO C++ 11.4/5. A friend function defined in a class is in
9653 the (lexical) scope of the class in which it is defined. */
9654 if (!ctype
&& DECL_FRIEND_P (decl1
))
9656 ctype
= DECL_FRIEND_CONTEXT (decl1
);
9658 /* CTYPE could be null here if we're dealing with a template;
9659 for example, `inline friend float foo()' inside a template
9660 will have no CTYPE set. */
9661 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
9667 if (DECL_DECLARED_INLINE_P (decl1
)
9668 && lookup_attribute ("noinline", attrs
))
9669 warning ("%Jinline function '%D' given attribute noinline", decl1
, decl1
);
9671 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1
))
9672 /* This is a constructor, we must ensure that any default args
9673 introduced by this definition are propagated to the clones
9674 now. The clones are used directly in overload resolution. */
9675 adjust_clone_args (decl1
);
9677 /* Sometimes we don't notice that a function is a static member, and
9678 build a METHOD_TYPE for it. Fix that up now. */
9679 if (ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
)
9680 && TREE_CODE (TREE_TYPE (decl1
)) == METHOD_TYPE
)
9682 revert_static_member_fn (decl1
);
9686 /* Set up current_class_type, and enter the scope of the class, if
9689 push_nested_class (ctype
);
9690 else if (DECL_STATIC_FUNCTION_P (decl1
))
9691 push_nested_class (DECL_CONTEXT (decl1
));
9693 /* Now that we have entered the scope of the class, we must restore
9694 the bindings for any template parameters surrounding DECL1, if it
9695 is an inline member template. (Order is important; consider the
9696 case where a template parameter has the same name as a field of
9697 the class.) It is not until after this point that
9698 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
9699 if (flags
& SF_INCLASS_INLINE
)
9700 maybe_begin_member_template_processing (decl1
);
9702 /* Effective C++ rule 15. */
9704 && DECL_OVERLOADED_OPERATOR_P (decl1
) == NOP_EXPR
9705 && TREE_CODE (TREE_TYPE (fntype
)) == VOID_TYPE
)
9706 warning ("`operator=' should return a reference to `*this'");
9708 /* Make the init_value nonzero so pushdecl knows this is not tentative.
9709 error_mark_node is replaced below (in poplevel) with the BLOCK. */
9710 if (!DECL_INITIAL (decl1
))
9711 DECL_INITIAL (decl1
) = error_mark_node
;
9713 /* This function exists in static storage.
9714 (This does not mean `static' in the C sense!) */
9715 TREE_STATIC (decl1
) = 1;
9717 /* We must call push_template_decl after current_class_type is set
9718 up. (If we are processing inline definitions after exiting a
9719 class scope, current_class_type will be NULL_TREE until set above
9720 by push_nested_class.) */
9721 if (processing_template_decl
)
9722 decl1
= push_template_decl (decl1
);
9724 /* We are now in the scope of the function being defined. */
9725 current_function_decl
= decl1
;
9727 /* Save the parm names or decls from this function's declarator
9728 where store_parm_decls will find them. */
9729 current_function_parms
= DECL_ARGUMENTS (decl1
);
9731 /* Make sure the parameter and return types are reasonable. When
9732 you declare a function, these types can be incomplete, but they
9733 must be complete when you define the function. */
9734 if (! processing_template_decl
)
9735 check_function_type (decl1
, current_function_parms
);
9737 /* Build the return declaration for the function. */
9738 restype
= TREE_TYPE (fntype
);
9739 /* Promote the value to int before returning it. */
9740 if (c_promoting_integer_type_p (restype
))
9741 restype
= type_promotes_to (restype
);
9742 if (DECL_RESULT (decl1
) == NULL_TREE
)
9746 resdecl
= build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (restype
));
9747 DECL_ARTIFICIAL (resdecl
) = 1;
9748 DECL_IGNORED_P (resdecl
) = 1;
9749 DECL_RESULT (decl1
) = resdecl
;
9751 c_apply_type_quals_to_decl (cp_type_quals (restype
), resdecl
);
9754 /* Initialize RTL machinery. We cannot do this until
9755 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
9756 even when processing a template; this is how we get
9757 CFUN set up, and our per-function variables initialized.
9758 FIXME factor out the non-RTL stuff. */
9759 bl
= current_binding_level
;
9760 allocate_struct_function (decl1
);
9761 current_binding_level
= bl
;
9763 /* Even though we're inside a function body, we still don't want to
9764 call expand_expr to calculate the size of a variable-sized array.
9765 We haven't necessarily assigned RTL to all variables yet, so it's
9766 not safe to try to expand expressions involving them. */
9767 cfun
->x_dont_save_pending_sizes_p
= 1;
9769 /* Start the statement-tree, start the tree now. */
9770 DECL_SAVED_TREE (decl1
) = push_stmt_list ();
9772 /* Let the user know we're compiling this function. */
9773 announce_function (decl1
);
9775 /* Record the decl so that the function name is defined.
9776 If we already have a decl for this name, and it is a FUNCTION_DECL,
9777 use the old decl. */
9778 if (!processing_template_decl
&& !(flags
& SF_PRE_PARSED
))
9780 /* A specialization is not used to guide overload resolution. */
9781 if (!DECL_FUNCTION_MEMBER_P (decl1
)
9782 && !(DECL_USE_TEMPLATE (decl1
) &&
9783 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1
))))
9785 tree olddecl
= pushdecl (decl1
);
9787 if (olddecl
== error_mark_node
)
9788 /* If something went wrong when registering the declaration,
9789 use DECL1; we have to have a FUNCTION_DECL to use when
9790 parsing the body of the function. */
9793 /* Otherwise, OLDDECL is either a previous declaration of
9794 the same function or DECL1 itself. */
9799 /* We need to set the DECL_CONTEXT. */
9800 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
9801 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
9802 /* And make sure we have enough default args. */
9803 check_default_args (decl1
);
9805 fntype
= TREE_TYPE (decl1
);
9808 /* Determine the ELF visibility attribute for the function. We must
9809 not do this before calling "pushdecl", as we must allow
9810 "duplicate_decls" to merge any attributes appropriately. */
9811 if (!DECL_CLONED_FUNCTION_P (decl1
))
9812 determine_visibility (decl1
);
9814 /* Reset these in case the call to pushdecl changed them. */
9815 current_function_decl
= decl1
;
9818 /* If we are (erroneously) defining a function that we have already
9819 defined before, wipe out what we knew before. */
9820 if (!DECL_PENDING_INLINE_P (decl1
))
9821 DECL_SAVED_FUNCTION_DATA (decl1
) = NULL
;
9823 if (ctype
&& !doing_friend
&& !DECL_STATIC_FUNCTION_P (decl1
))
9825 /* We know that this was set up by `grokclassfn'. We do not
9826 wait until `store_parm_decls', since evil parse errors may
9827 never get us to that point. Here we keep the consistency
9828 between `current_class_type' and `current_class_ptr'. */
9829 tree t
= DECL_ARGUMENTS (decl1
);
9831 gcc_assert (t
!= NULL_TREE
&& TREE_CODE (t
) == PARM_DECL
);
9832 gcc_assert (TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
);
9834 cp_function_chain
->x_current_class_ref
9835 = build_indirect_ref (t
, NULL
);
9836 cp_function_chain
->x_current_class_ptr
= t
;
9838 /* Constructors and destructors need to know whether they're "in
9839 charge" of initializing virtual base classes. */
9841 if (DECL_HAS_IN_CHARGE_PARM_P (decl1
))
9843 current_in_charge_parm
= t
;
9846 if (DECL_HAS_VTT_PARM_P (decl1
))
9848 if (DECL_NAME (t
) != vtt_parm_identifier
)
9850 current_vtt_parm
= t
;
9854 if (DECL_INTERFACE_KNOWN (decl1
))
9856 tree ctx
= decl_function_context (decl1
);
9858 if (DECL_NOT_REALLY_EXTERN (decl1
))
9859 DECL_EXTERNAL (decl1
) = 0;
9861 if (ctx
!= NULL_TREE
&& DECL_DECLARED_INLINE_P (ctx
)
9862 && TREE_PUBLIC (ctx
))
9863 /* This is a function in a local class in an extern inline
9865 comdat_linkage (decl1
);
9867 /* If this function belongs to an interface, it is public.
9868 If it belongs to someone else's interface, it is also external.
9869 This only affects inlines and template instantiations. */
9870 else if (interface_unknown
== 0
9871 && ! DECL_TEMPLATE_INSTANTIATION (decl1
))
9873 if (DECL_DECLARED_INLINE_P (decl1
)
9874 || DECL_TEMPLATE_INSTANTIATION (decl1
)
9875 || processing_template_decl
)
9877 DECL_EXTERNAL (decl1
)
9879 || (DECL_DECLARED_INLINE_P (decl1
)
9880 && ! flag_implement_inlines
9881 && !DECL_VINDEX (decl1
)));
9883 /* For WIN32 we also want to put these in linkonce sections. */
9884 maybe_make_one_only (decl1
);
9887 DECL_EXTERNAL (decl1
) = 0;
9888 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
9889 DECL_INTERFACE_KNOWN (decl1
) = 1;
9890 /* If this function is in an interface implemented in this file,
9891 make sure that the backend knows to emit this function
9893 if (!DECL_EXTERNAL (decl1
))
9894 mark_needed (decl1
);
9896 else if (interface_unknown
&& interface_only
9897 && ! DECL_TEMPLATE_INSTANTIATION (decl1
))
9899 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
9900 interface, we will have interface_only set but not
9901 interface_known. In that case, we don't want to use the normal
9902 heuristics because someone will supply a #pragma implementation
9903 elsewhere, and deducing it here would produce a conflict. */
9904 comdat_linkage (decl1
);
9905 DECL_EXTERNAL (decl1
) = 0;
9906 DECL_INTERFACE_KNOWN (decl1
) = 1;
9907 DECL_DEFER_OUTPUT (decl1
) = 1;
9911 /* This is a definition, not a reference.
9912 So clear DECL_EXTERNAL. */
9913 DECL_EXTERNAL (decl1
) = 0;
9915 if ((DECL_DECLARED_INLINE_P (decl1
)
9916 || DECL_TEMPLATE_INSTANTIATION (decl1
))
9917 && ! DECL_INTERFACE_KNOWN (decl1
)
9918 /* Don't try to defer nested functions for now. */
9919 && ! decl_function_context (decl1
))
9920 DECL_DEFER_OUTPUT (decl1
) = 1;
9922 DECL_INTERFACE_KNOWN (decl1
) = 1;
9925 begin_scope (sk_function_parms
, decl1
);
9929 if (DECL_DESTRUCTOR_P (decl1
)
9930 || (DECL_CONSTRUCTOR_P (decl1
)
9931 && targetm
.cxx
.cdtor_returns_this ()))
9933 cdtor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
9934 DECL_CONTEXT (cdtor_label
) = current_function_decl
;
9937 start_fname_decls ();
9939 store_parm_decls (current_function_parms
);
9943 /* Like start_preparsed_function, except that instead of a
9944 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
9946 Returns 1 on success. If the DECLARATOR is not suitable for a function
9947 (it defines a datum instead), we return 0, which tells
9948 yyparse to report a parse error. */
9951 start_function (cp_decl_specifier_seq
*declspecs
,
9952 const cp_declarator
*declarator
,
9957 if (have_extern_spec
)
9959 declspecs
->storage_class
= sc_extern
;
9960 /* This should only be done once on the outermost decl. */
9961 have_extern_spec
= false;
9964 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, &attrs
);
9965 /* If the declarator is not suitable for a function definition,
9966 cause a syntax error. */
9967 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
)
9970 cplus_decl_attributes (&decl1
, attrs
, 0);
9972 /* If #pragma weak was used, mark the decl weak now. */
9973 if (global_scope_p (current_binding_level
))
9974 maybe_apply_pragma_weak (decl1
);
9976 if (DECL_MAIN_P (decl1
))
9978 /* If this doesn't return integer_type, or a typedef to
9979 integer_type, complain. */
9980 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl1
)), integer_type_node
))
9982 if (pedantic
|| warn_return_type
)
9983 pedwarn ("return type for `main' changed to `int'");
9984 TREE_TYPE (decl1
) = default_function_type
;
9988 start_preparsed_function (decl1
, attrs
, /*flags=*/SF_DEFAULT
);
9993 /* Store the parameter declarations into the current function declaration.
9994 This is called after parsing the parameter declarations, before
9995 digesting the body of the function.
9997 Also install to binding contour return value identifier, if any. */
10000 store_parm_decls (tree current_function_parms
)
10002 tree fndecl
= current_function_decl
;
10005 /* This is a chain of any other decls that came in among the parm
10006 declarations. If a parm is declared with enum {foo, bar} x;
10007 then CONST_DECLs for foo and bar are put here. */
10008 tree nonparms
= NULL_TREE
;
10010 if (current_function_parms
)
10012 /* This case is when the function was defined with an ANSI prototype.
10013 The parms already have decls, so we need not do anything here
10014 except record them as in effect
10015 and complain if any redundant old-style parm decls were written. */
10017 tree specparms
= current_function_parms
;
10020 /* Must clear this because it might contain TYPE_DECLs declared
10022 current_binding_level
->names
= NULL
;
10024 /* If we're doing semantic analysis, then we'll call pushdecl
10025 for each of these. We must do them in reverse order so that
10026 they end in the correct forward order. */
10027 specparms
= nreverse (specparms
);
10029 for (parm
= specparms
; parm
; parm
= next
)
10031 next
= TREE_CHAIN (parm
);
10032 if (TREE_CODE (parm
) == PARM_DECL
)
10034 if (DECL_NAME (parm
) == NULL_TREE
10035 || TREE_CODE (parm
) != VOID_TYPE
)
10038 error ("parameter `%D' declared void", parm
);
10042 /* If we find an enum constant or a type tag,
10043 put it aside for the moment. */
10044 TREE_CHAIN (parm
) = NULL_TREE
;
10045 nonparms
= chainon (nonparms
, parm
);
10049 /* Get the decls in their original chain order and record in the
10050 function. This is all and only the PARM_DECLs that were
10051 pushed into scope by the loop above. */
10052 DECL_ARGUMENTS (fndecl
) = getdecls ();
10055 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
10057 /* Now store the final chain of decls for the arguments
10058 as the decl-chain of the current lexical scope.
10059 Put the enumerators in as well, at the front so that
10060 DECL_ARGUMENTS is not modified. */
10061 current_binding_level
->names
= chainon (nonparms
, DECL_ARGUMENTS (fndecl
));
10063 /* For a cloned function, we've already got all the code we need;
10064 there's no need to add any extra bits. */
10065 if (!DECL_CLONED_FUNCTION_P (fndecl
))
10067 /* Do the starting of the exception specifications, if we have any. */
10068 if (flag_exceptions
&& !processing_template_decl
10069 && flag_enforce_eh_specs
10070 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl
)))
10071 current_eh_spec_block
= begin_eh_spec_block ();
10076 /* We have finished doing semantic analysis on DECL, but have not yet
10077 generated RTL for its body. Save away our current state, so that
10078 when we want to generate RTL later we know what to do. */
10081 save_function_data (tree decl
)
10083 struct language_function
*f
;
10085 /* Save the language-specific per-function data so that we can
10086 get it back when we really expand this function. */
10087 gcc_assert (!DECL_PENDING_INLINE_P (decl
));
10090 f
= GGC_NEW (struct language_function
);
10091 memcpy (f
, cp_function_chain
, sizeof (struct language_function
));
10092 DECL_SAVED_FUNCTION_DATA (decl
) = f
;
10094 /* Clear out the bits we don't need. */
10095 f
->base
.x_stmt_tree
.x_cur_stmt_list
= NULL_TREE
;
10096 f
->x_named_label_uses
= NULL
;
10097 f
->bindings
= NULL
;
10098 f
->x_local_names
= NULL
;
10102 /* Set the return value of the constructor (if present). */
10105 finish_constructor_body (void)
10110 if (targetm
.cxx
.cdtor_returns_this ())
10112 /* Any return from a constructor will end up here. */
10113 add_stmt (build_stmt (LABEL_EXPR
, cdtor_label
));
10115 val
= DECL_ARGUMENTS (current_function_decl
);
10116 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
10117 DECL_RESULT (current_function_decl
), val
);
10118 /* Return the address of the object. */
10119 exprstmt
= build_stmt (RETURN_EXPR
, val
);
10120 add_stmt (exprstmt
);
10124 /* Do all the processing for the beginning of a destructor; set up the
10125 vtable pointers and cleanups for bases and members. */
10128 begin_destructor_body (void)
10131 tree compound_stmt
;
10133 /* If the dtor is empty, and we know there is not any possible
10134 way we could use any vtable entries, before they are possibly
10135 set by a base class dtor, we don't have to setup the vtables,
10136 as we know that any base class dtor will set up any vtables
10137 it needs. We avoid MI, because one base class dtor can do a
10138 virtual dispatch to an overridden function that would need to
10139 have a non-related vtable set up, we cannot avoid setting up
10140 vtables in that case. We could change this to see if there
10141 is just one vtable.
10143 ??? In the destructor for a class, the vtables are set
10144 appropriately for that class. There will be no non-related
10145 vtables. jason 2001-12-11. */
10146 if_stmt
= begin_if_stmt ();
10148 /* If it is not safe to avoid setting up the vtables, then
10149 someone will change the condition to be boolean_true_node.
10150 (Actually, for now, we do not have code to set the condition
10151 appropriately, so we just assume that we always need to
10152 initialize the vtables.) */
10153 finish_if_stmt_cond (boolean_true_node
, if_stmt
);
10155 compound_stmt
= begin_compound_stmt (0);
10157 /* Make all virtual function table pointers in non-virtual base
10158 classes point to CURRENT_CLASS_TYPE's virtual function
10160 initialize_vtbl_ptrs (current_class_ptr
);
10162 finish_compound_stmt (compound_stmt
);
10163 finish_then_clause (if_stmt
);
10164 finish_if_stmt (if_stmt
);
10166 /* And insert cleanups for our bases and members so that they
10167 will be properly destroyed if we throw. */
10168 push_base_cleanups ();
10171 /* At the end of every destructor we generate code to delete the object if
10172 necessary. Do that now. */
10175 finish_destructor_body (void)
10179 /* Any return from a destructor will end up here; that way all base
10180 and member cleanups will be run when the function returns. */
10181 add_stmt (build_stmt (LABEL_EXPR
, cdtor_label
));
10183 /* In a virtual destructor, we must call delete. */
10184 if (DECL_VIRTUAL_P (current_function_decl
))
10187 tree virtual_size
= cxx_sizeof (current_class_type
);
10191 At the point of definition of a virtual destructor (including
10192 an implicit definition), non-placement operator delete shall
10193 be looked up in the scope of the destructor's class and if
10194 found shall be accessible and unambiguous. */
10195 exprstmt
= build_op_delete_call
10196 (DELETE_EXPR
, current_class_ptr
, virtual_size
,
10197 /*global_p=*/false, NULL_TREE
);
10199 if_stmt
= begin_if_stmt ();
10200 finish_if_stmt_cond (build2 (BIT_AND_EXPR
, integer_type_node
,
10201 current_in_charge_parm
,
10204 finish_expr_stmt (exprstmt
);
10205 finish_then_clause (if_stmt
);
10206 finish_if_stmt (if_stmt
);
10209 if (targetm
.cxx
.cdtor_returns_this ())
10213 val
= DECL_ARGUMENTS (current_function_decl
);
10214 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
10215 DECL_RESULT (current_function_decl
), val
);
10216 /* Return the address of the object. */
10217 exprstmt
= build_stmt (RETURN_EXPR
, val
);
10218 add_stmt (exprstmt
);
10222 /* Do the necessary processing for the beginning of a function body, which
10223 in this case includes member-initializers, but not the catch clauses of
10224 a function-try-block. Currently, this means opening a binding level
10225 for the member-initializers (in a ctor) and member cleanups (in a dtor).
10226 In other functions, this isn't necessary, but it doesn't hurt. */
10229 begin_function_body (void)
10233 if (processing_template_decl
)
10234 /* Do nothing now. */;
10236 /* Always keep the BLOCK node associated with the outermost pair of
10237 curly braces of a function. These are needed for correct
10238 operation of dwarfout.c. */
10239 keep_next_level (true);
10241 stmt
= begin_compound_stmt (BCS_FN_BODY
);
10243 if (processing_template_decl
)
10244 /* Do nothing now. */;
10245 else if (DECL_DESTRUCTOR_P (current_function_decl
))
10246 begin_destructor_body ();
10251 /* Do the processing for the end of a function body. Currently, this means
10252 closing out the cleanups for fully-constructed bases and members, and in
10253 the case of the destructor, deleting the object if desired. Again, this
10254 is only meaningful for [cd]tors, since they are the only functions where
10255 there is a significant distinction between the main body and any
10256 function catch clauses. Handling, say, main() return semantics here
10257 would be wrong, as flowing off the end of a function catch clause for
10258 main() would also need to return 0. */
10261 finish_function_body (tree compstmt
)
10263 /* Close the block. */
10264 finish_compound_stmt (compstmt
);
10266 if (processing_template_decl
)
10267 /* Do nothing now. */;
10268 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
10269 finish_constructor_body ();
10270 else if (DECL_DESTRUCTOR_P (current_function_decl
))
10271 finish_destructor_body ();
10274 /* Finish up a function declaration and compile that function
10275 all the way to assembler language output. The free the storage
10276 for the function definition.
10278 FLAGS is a bitwise or of the following values:
10280 We just finished processing the body of an in-class inline
10281 function definition. (This processing will have taken place
10282 after the class definition is complete.) */
10285 finish_function (int flags
)
10287 tree fndecl
= current_function_decl
;
10288 tree fntype
, ctype
= NULL_TREE
;
10289 int inclass_inline
= (flags
& 2) != 0;
10292 /* When we get some parse errors, we can end up without a
10293 current_function_decl, so cope. */
10294 if (fndecl
== NULL_TREE
)
10295 return error_mark_node
;
10297 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl
)
10298 && DECL_VIRTUAL_P (fndecl
)
10299 && !processing_template_decl
)
10301 tree fnclass
= DECL_CONTEXT (fndecl
);
10302 if (fndecl
== CLASSTYPE_KEY_METHOD (fnclass
))
10303 keyed_classes
= tree_cons (NULL_TREE
, fnclass
, keyed_classes
);
10306 nested
= function_depth
> 1;
10307 fntype
= TREE_TYPE (fndecl
);
10309 /* TREE_READONLY (fndecl) = 1;
10310 This caused &foo to be of type ptr-to-const-function
10311 which then got a warning when stored in a ptr-to-function variable. */
10313 gcc_assert (building_stmt_tree ());
10315 /* For a cloned function, we've already got all the code we need;
10316 there's no need to add any extra bits. */
10317 if (!DECL_CLONED_FUNCTION_P (fndecl
))
10319 if (DECL_MAIN_P (current_function_decl
))
10321 /* Make it so that `main' always returns 0 by default. */
10323 finish_return_stmt (integer_one_node
);
10325 finish_return_stmt (integer_zero_node
);
10329 /* Finish dealing with exception specifiers. */
10330 if (flag_exceptions
&& !processing_template_decl
10331 && flag_enforce_eh_specs
10332 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl
)))
10333 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
10334 (TREE_TYPE (current_function_decl
)),
10335 current_eh_spec_block
);
10338 /* If we're saving up tree structure, tie off the function now. */
10339 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
10341 finish_fname_decls ();
10343 /* If this function can't throw any exceptions, remember that. */
10344 if (!processing_template_decl
10345 && !cp_function_chain
->can_throw
10346 && !flag_non_call_exceptions
)
10347 TREE_NOTHROW (fndecl
) = 1;
10349 /* This must come after expand_function_end because cleanups might
10350 have declarations (from inline functions) that need to go into
10351 this function's blocks. */
10353 /* If the current binding level isn't the outermost binding level
10354 for this function, either there is a bug, or we have experienced
10355 syntax errors and the statement tree is malformed. */
10356 if (current_binding_level
->kind
!= sk_function_parms
)
10358 /* Make sure we have already experienced errors. */
10359 if (errorcount
== 0)
10362 /* Throw away the broken statement tree and extra binding
10364 DECL_SAVED_TREE (fndecl
) = alloc_stmt_list ();
10366 while (current_binding_level
->kind
!= sk_function_parms
)
10368 if (current_binding_level
->kind
== sk_class
)
10369 pop_nested_class ();
10371 poplevel (0, 0, 0);
10374 poplevel (1, 0, 1);
10376 /* Statements should always be full-expressions at the outermost set
10377 of curly braces for a function. */
10378 gcc_assert (stmts_are_full_exprs_p ());
10380 /* Set up the named return value optimization, if we can. Candidate
10381 variables are selected in check_return_value. */
10382 if (current_function_return_value
)
10384 tree r
= current_function_return_value
;
10387 if (r
!= error_mark_node
10388 /* This is only worth doing for fns that return in memory--and
10389 simpler, since we don't have to worry about promoted modes. */
10390 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl
)), fndecl
)
10391 /* Only allow this for variables declared in the outer scope of
10392 the function so we know that their lifetime always ends with a
10393 return; see g++.dg/opt/nrv6.C. We could be more flexible if
10394 we were to do this optimization in tree-ssa. */
10395 && (outer
= BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl
)))
10396 /* Skip the artificial function body block. */
10397 && (outer
= BLOCK_SUBBLOCKS (outer
))
10398 && chain_member (r
, BLOCK_VARS (outer
)))
10399 finalize_nrv (&DECL_SAVED_TREE (fndecl
), r
, DECL_RESULT (fndecl
));
10401 current_function_return_value
= NULL_TREE
;
10404 /* Remember that we were in class scope. */
10405 if (current_class_name
)
10406 ctype
= current_class_type
;
10408 /* Must mark the RESULT_DECL as being in this function. */
10409 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
10411 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
10412 to the FUNCTION_DECL node itself. */
10413 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
10415 /* Save away current state, if appropriate. */
10416 if (!processing_template_decl
)
10417 save_function_data (fndecl
);
10419 /* Complain if there's just no return statement. */
10420 if (warn_return_type
10421 && TREE_CODE (TREE_TYPE (fntype
)) != VOID_TYPE
10422 && !dependent_type_p (TREE_TYPE (fntype
))
10423 && !current_function_returns_value
&& !current_function_returns_null
10424 /* Don't complain if we abort or throw. */
10425 && !current_function_returns_abnormally
10426 && !DECL_NAME (DECL_RESULT (fndecl
))
10427 /* Normally, with -Wreturn-type, flow will complain. Unless we're an
10428 inline function, as we might never be compiled separately. */
10429 && (DECL_INLINE (fndecl
) || processing_template_decl
)
10430 /* Structor return values (if any) are set by the compiler. */
10431 && !DECL_CONSTRUCTOR_P (fndecl
)
10432 && !DECL_DESTRUCTOR_P (fndecl
))
10433 warning ("no return statement in function returning non-void");
10435 /* Store the end of the function, so that we get good line number
10436 info for the epilogue. */
10437 cfun
->function_end_locus
= input_location
;
10439 /* Genericize before inlining. */
10440 if (!processing_template_decl
)
10442 cp_genericize (fndecl
);
10444 /* Handle attribute((warn_unused_result)). Relies on gimple input. */
10445 c_warn_unused_result (&DECL_SAVED_TREE (fndecl
));
10448 /* We're leaving the context of this function, so zap cfun. It's still in
10449 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
10451 current_function_decl
= NULL
;
10453 /* If this is an in-class inline definition, we may have to pop the
10454 bindings for the template parameters that we added in
10455 maybe_begin_member_template_processing when start_function was
10457 if (inclass_inline
)
10458 maybe_end_member_template_processing ();
10460 /* Leave the scope of the class. */
10462 pop_nested_class ();
10468 /* Let the error reporting routines know that we're outside a
10469 function. For a nested function, this value is used in
10470 cxx_pop_function_context and then reset via pop_function_context. */
10471 current_function_decl
= NULL_TREE
;
10476 /* Create the FUNCTION_DECL for a function definition.
10477 DECLSPECS and DECLARATOR are the parts of the declaration;
10478 they describe the return type and the name of the function,
10479 but twisted together in a fashion that parallels the syntax of C.
10481 This function creates a binding context for the function body
10482 as well as setting up the FUNCTION_DECL in current_function_decl.
10484 Returns a FUNCTION_DECL on success.
10486 If the DECLARATOR is not suitable for a function (it defines a datum
10487 instead), we return 0, which tells yyparse to report a parse error.
10489 May return void_type_node indicating that this method is actually
10490 a friend. See grokfield for more details.
10492 Came here with a `.pushlevel' .
10494 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
10495 CHANGES TO CODE IN `grokfield'. */
10498 start_method (cp_decl_specifier_seq
*declspecs
,
10499 const cp_declarator
*declarator
, tree attrlist
)
10501 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
10504 if (fndecl
== error_mark_node
)
10505 return error_mark_node
;
10507 if (fndecl
== NULL
|| TREE_CODE (fndecl
) != FUNCTION_DECL
)
10509 error ("invalid member function declaration");
10510 return error_mark_node
;
10514 cplus_decl_attributes (&fndecl
, attrlist
, 0);
10516 /* Pass friends other than inline friend functions back. */
10517 if (fndecl
== void_type_node
)
10520 if (DECL_IN_AGGR_P (fndecl
))
10522 if (DECL_CONTEXT (fndecl
)
10523 && TREE_CODE( DECL_CONTEXT (fndecl
)) != NAMESPACE_DECL
)
10524 error ("`%D' is already defined in class `%T'", fndecl
,
10525 DECL_CONTEXT (fndecl
));
10526 return void_type_node
;
10529 check_template_shadow (fndecl
);
10531 DECL_DECLARED_INLINE_P (fndecl
) = 1;
10532 if (flag_default_inline
)
10533 DECL_INLINE (fndecl
) = 1;
10535 /* We process method specializations in finish_struct_1. */
10536 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
10538 fndecl
= push_template_decl (fndecl
);
10539 if (fndecl
== error_mark_node
)
10543 if (! DECL_FRIEND_P (fndecl
))
10545 if (TREE_CHAIN (fndecl
))
10547 fndecl
= copy_node (fndecl
);
10548 TREE_CHAIN (fndecl
) = NULL_TREE
;
10550 grok_special_member_properties (fndecl
);
10553 cp_finish_decl (fndecl
, NULL_TREE
, NULL_TREE
, 0);
10555 /* Make a place for the parms. */
10556 begin_scope (sk_function_parms
, fndecl
);
10558 DECL_IN_AGGR_P (fndecl
) = 1;
10562 /* Go through the motions of finishing a function definition.
10563 We don't compile this method until after the whole class has
10566 FINISH_METHOD must return something that looks as though it
10567 came from GROKFIELD (since we are defining a method, after all).
10569 This is called after parsing the body of the function definition.
10570 STMTS is the chain of statements that makes up the function body.
10572 DECL is the ..._DECL that `start_method' provided. */
10575 finish_method (tree decl
)
10577 tree fndecl
= decl
;
10582 if (decl
== void_type_node
)
10585 old_initial
= DECL_INITIAL (fndecl
);
10587 /* Undo the level for the parms (from start_method).
10588 This is like poplevel, but it causes nothing to be
10589 saved. Saving information here confuses symbol-table
10590 output routines. Besides, this information will
10591 be correctly output when this method is actually
10594 /* Clear out the meanings of the local variables of this level;
10595 also record in each decl which block it belongs to. */
10597 for (link
= current_binding_level
->names
; link
; link
= TREE_CHAIN (link
))
10599 if (DECL_NAME (link
) != NULL_TREE
)
10600 pop_binding (DECL_NAME (link
), link
);
10601 gcc_assert (TREE_CODE (link
) != FUNCTION_DECL
);
10602 DECL_CONTEXT (link
) = NULL_TREE
;
10605 poplevel (0, 0, 0);
10607 DECL_INITIAL (fndecl
) = old_initial
;
10609 /* We used to check if the context of FNDECL was different from
10610 current_class_type as another way to get inside here. This didn't work
10611 for String.cc in libg++. */
10612 if (DECL_FRIEND_P (fndecl
))
10614 CLASSTYPE_INLINE_FRIENDS (current_class_type
)
10615 = tree_cons (NULL_TREE
, fndecl
, CLASSTYPE_INLINE_FRIENDS (current_class_type
));
10616 decl
= void_type_node
;
10623 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
10624 we can lay it out later, when and if its type becomes complete. */
10627 maybe_register_incomplete_var (tree var
)
10629 gcc_assert (TREE_CODE (var
) == VAR_DECL
);
10631 /* Keep track of variables with incomplete types. */
10632 if (!processing_template_decl
&& TREE_TYPE (var
) != error_mark_node
10633 && DECL_EXTERNAL (var
))
10635 tree inner_type
= TREE_TYPE (var
);
10637 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
10638 inner_type
= TREE_TYPE (inner_type
);
10639 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
10641 if ((!COMPLETE_TYPE_P (inner_type
) && CLASS_TYPE_P (inner_type
))
10642 /* RTTI TD entries are created while defining the type_info. */
10643 || (TYPE_LANG_SPECIFIC (inner_type
)
10644 && TYPE_BEING_DEFINED (inner_type
)))
10645 incomplete_vars
= tree_cons (inner_type
, var
, incomplete_vars
);
10649 /* Called when a class type (given by TYPE) is defined. If there are
10650 any existing VAR_DECLs whose type hsa been completed by this
10651 declaration, update them now. */
10654 complete_vars (tree type
)
10656 tree
*list
= &incomplete_vars
;
10658 gcc_assert (CLASS_TYPE_P (type
));
10661 if (same_type_p (type
, TREE_PURPOSE (*list
)))
10663 tree var
= TREE_VALUE (*list
);
10664 /* Complete the type of the variable. The VAR_DECL itself
10665 will be laid out in expand_expr. */
10666 complete_type (TREE_TYPE (var
));
10667 /* Remove this entry from the list. */
10668 *list
= TREE_CHAIN (*list
);
10671 list
= &TREE_CHAIN (*list
);
10674 /* Check for pending declarations which may have abstract type. */
10675 complete_type_check_abstract (type
);
10678 /* If DECL is of a type which needs a cleanup, build that cleanup
10682 cxx_maybe_build_cleanup (tree decl
)
10684 tree type
= TREE_TYPE (decl
);
10686 if (type
!= error_mark_node
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
10688 int flags
= LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
;
10691 if (TREE_CODE (type
) == ARRAY_TYPE
)
10695 cxx_mark_addressable (decl
);
10696 rval
= build_unary_op (ADDR_EXPR
, decl
, 0);
10699 /* Optimize for space over speed here. */
10700 if (! TYPE_USES_VIRTUAL_BASECLASSES (type
)
10701 || flag_expensive_optimizations
)
10702 flags
|= LOOKUP_NONVIRTUAL
;
10704 rval
= build_delete (TREE_TYPE (rval
), rval
,
10705 sfk_complete_destructor
, flags
, 0);
10707 if (TYPE_USES_VIRTUAL_BASECLASSES (type
)
10708 && ! TYPE_HAS_DESTRUCTOR (type
))
10709 rval
= build_compound_expr (rval
, build_vbase_delete (type
, decl
));
10716 /* When a stmt has been parsed, this function is called. */
10723 /* DECL was originally constructed as a non-static member function,
10724 but turned out to be static. Update it accordingly. */
10727 revert_static_member_fn (tree decl
)
10730 tree function
= TREE_TYPE (decl
);
10731 tree args
= TYPE_ARG_TYPES (function
);
10733 if (cp_type_quals (TREE_TYPE (TREE_VALUE (args
)))
10734 != TYPE_UNQUALIFIED
)
10735 error ("static member function `%#D' declared with type qualifiers",
10738 args
= TREE_CHAIN (args
);
10739 tmp
= build_function_type (TREE_TYPE (function
), args
);
10740 tmp
= build_qualified_type (tmp
, cp_type_quals (function
));
10741 tmp
= build_exception_variant (tmp
,
10742 TYPE_RAISES_EXCEPTIONS (function
));
10743 TREE_TYPE (decl
) = tmp
;
10744 if (DECL_ARGUMENTS (decl
))
10745 DECL_ARGUMENTS (decl
) = TREE_CHAIN (DECL_ARGUMENTS (decl
));
10746 DECL_STATIC_FUNCTION_P (decl
) = 1;
10749 /* Initialize the variables used during compilation of a C++
10753 cxx_push_function_context (struct function
* f
)
10755 struct language_function
*p
= GGC_CNEW (struct language_function
);
10758 /* Whenever we start a new function, we destroy temporaries in the
10760 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
10766 if (DECL_SAVED_FUNCTION_DATA (fn
))
10768 /* If we already parsed this function, and we're just expanding it
10769 now, restore saved state. */
10770 *cp_function_chain
= *DECL_SAVED_FUNCTION_DATA (fn
);
10772 /* We don't need the saved data anymore. Unless this is an inline
10773 function; we need the named return value info for
10774 declare_return_variable. */
10775 if (! DECL_INLINE (fn
))
10776 DECL_SAVED_FUNCTION_DATA (fn
) = NULL
;
10781 /* Free the language-specific parts of F, now that we've finished
10782 compiling the function. */
10785 cxx_pop_function_context (struct function
* f
)
10790 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
10791 one of the language-independent trees. */
10793 enum cp_tree_node_structure_enum
10794 cp_tree_node_structure (union lang_tree_node
* t
)
10796 switch (TREE_CODE (&t
->generic
))
10798 case DEFAULT_ARG
: return TS_CP_DEFAULT_ARG
;
10799 case IDENTIFIER_NODE
: return TS_CP_IDENTIFIER
;
10800 case OVERLOAD
: return TS_CP_OVERLOAD
;
10801 case TEMPLATE_PARM_INDEX
: return TS_CP_TPI
;
10802 case TINST_LEVEL
: return TS_CP_TINST_LEVEL
;
10803 case PTRMEM_CST
: return TS_CP_PTRMEM
;
10804 case BASELINK
: return TS_CP_BASELINK
;
10805 default: return TS_CP_GENERIC
;
10809 /* Build the void_list_node (void_type_node having been created). */
10811 build_void_list_node (void)
10813 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
10818 cp_missing_noreturn_ok_p (tree decl
)
10820 /* A missing noreturn is ok for the `main' function. */
10821 return DECL_MAIN_P (decl
);
10824 #include "gt-cp-decl.h"
10825 #include "gtype-cp.h"