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 begin_constructor_body (void);
104 static void finish_constructor_body (void);
105 static void begin_destructor_body (void);
106 static void finish_destructor_body (void);
107 static tree
create_array_type_for_decl (tree
, tree
, tree
);
108 static tree
get_atexit_node (void);
109 static tree
get_dso_handle_node (void);
110 static tree
start_cleanup_fn (void);
111 static void end_cleanup_fn (void);
112 static tree
cp_make_fname_decl (tree
, int);
113 static void initialize_predefined_identifiers (void);
114 static tree check_special_function_return_type
115 (special_function_kind
, tree
, tree
);
116 static tree
push_cp_library_fn (enum tree_code
, tree
);
117 static tree
build_cp_library_fn (tree
, enum tree_code
, tree
);
118 static void store_parm_decls (tree
);
119 static void initialize_local_var (tree
, tree
);
120 static void expand_static_init (tree
, tree
);
121 static tree
next_initializable_field (tree
);
122 static tree
reshape_init (tree
, tree
*);
123 static tree
build_typename_type (tree
, tree
, tree
);
125 /* Erroneous argument lists can use this *IFF* they do not modify it. */
126 tree error_mark_list
;
128 /* The following symbols are subsumed in the cp_global_trees array, and
129 listed here individually for documentation purposes.
132 tree wchar_decl_node;
134 tree vtable_entry_type;
135 tree delta_type_node;
136 tree __t_desc_type_node;
137 tree ti_desc_type_node;
138 tree bltn_desc_type_node, ptr_desc_type_node;
139 tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
140 tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
141 tree ptm_desc_type_node;
142 tree base_desc_type_node;
144 tree class_type_node;
145 tree unknown_type_node;
147 Array type `vtable_entry_type[]'
150 tree vtbl_ptr_type_node;
157 A FUNCTION_DECL which can call `abort'. Not necessarily the
158 one that the user will declare, but sufficient to be called
159 by routines that want to abort the program.
163 The FUNCTION_DECL for the default `::operator delete'.
165 tree global_delete_fndecl;
168 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
173 tree cp_global_trees
[CPTI_MAX
];
175 /* Indicates that there is a type value in some namespace, although
176 that is not necessarily in scope at the moment. */
178 tree global_type_node
;
180 /* The node that holds the "name" of the global scope. */
181 tree global_scope_name
;
183 /* Used only for jumps to as-yet undefined labels, since jumps to
184 defined labels can have their validity checked immediately. */
186 struct named_label_use_list
GTY(())
188 struct cp_binding_level
*binding_level
;
191 location_t o_goto_locus
;
192 struct named_label_use_list
*next
;
195 #define named_label_uses cp_function_chain->x_named_label_uses
197 #define local_names cp_function_chain->x_local_names
199 /* A list of objects which have constructors or destructors
200 which reside in the global scope. The decl is stored in
201 the TREE_VALUE slot and the initializer is stored
202 in the TREE_PURPOSE slot. */
203 tree static_aggregates
;
207 /* A node for the integer constants 2, and 3. */
209 tree integer_two_node
, integer_three_node
;
211 /* A list of all LABEL_DECLs in the function that have names. Here so
212 we can clear out their names' definitions at the end of the
213 function, and so we can check the validity of jumps to these labels. */
215 struct named_label_list
GTY(())
217 struct cp_binding_level
*binding_level
;
222 struct named_label_list
*next
;
223 unsigned int in_try_scope
: 1;
224 unsigned int in_catch_scope
: 1;
227 #define named_labels cp_function_chain->x_named_labels
229 /* The number of function bodies which we are currently processing.
230 (Zero if we are at namespace scope, one inside the body of a
231 function, two inside the body of a function in a local class, etc.) */
234 /* States indicating how grokdeclarator() should handle declspecs marked
235 with __attribute__((deprecated)). An object declared as
236 __attribute__((deprecated)) suppresses warnings of uses of other
239 enum deprecated_states
{
244 static enum deprecated_states deprecated_state
= DEPRECATED_NORMAL
;
246 /* True if a declaration with an `extern' linkage specifier is being
248 bool have_extern_spec
;
251 /* A TREE_LIST of VAR_DECLs. The TREE_PURPOSE is a RECORD_TYPE or
252 UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type. At the
253 time the VAR_DECL was declared, the type was incomplete. */
255 static GTY(()) tree incomplete_vars
;
257 /* Returns the kind of template specialization we are currently
258 processing, given that it's declaration contained N_CLASS_SCOPES
259 explicit scope qualifications. */
262 current_tmpl_spec_kind (int n_class_scopes
)
264 int n_template_parm_scopes
= 0;
265 int seen_specialization_p
= 0;
266 int innermost_specialization_p
= 0;
267 struct cp_binding_level
*b
;
269 /* Scan through the template parameter scopes. */
270 for (b
= current_binding_level
;
271 b
->kind
== sk_template_parms
;
274 /* If we see a specialization scope inside a parameter scope,
275 then something is wrong. That corresponds to a declaration
278 template <class T> template <> ...
280 which is always invalid since [temp.expl.spec] forbids the
281 specialization of a class member template if the enclosing
282 class templates are not explicitly specialized as well. */
283 if (b
->explicit_spec_p
)
285 if (n_template_parm_scopes
== 0)
286 innermost_specialization_p
= 1;
288 seen_specialization_p
= 1;
290 else if (seen_specialization_p
== 1)
291 return tsk_invalid_member_spec
;
293 ++n_template_parm_scopes
;
296 /* Handle explicit instantiations. */
297 if (processing_explicit_instantiation
)
299 if (n_template_parm_scopes
!= 0)
300 /* We've seen a template parameter list during an explicit
301 instantiation. For example:
303 template <class T> template void f(int);
305 This is erroneous. */
306 return tsk_invalid_expl_inst
;
308 return tsk_expl_inst
;
311 if (n_template_parm_scopes
< n_class_scopes
)
312 /* We've not seen enough template headers to match all the
313 specialized classes present. For example:
315 template <class T> void R<T>::S<T>::f(int);
317 This is invalid; there needs to be one set of template
318 parameters for each class. */
319 return tsk_insufficient_parms
;
320 else if (n_template_parm_scopes
== n_class_scopes
)
321 /* We're processing a non-template declaration (even though it may
322 be a member of a template class.) For example:
324 template <class T> void S<T>::f(int);
326 The `class T' maches the `S<T>', leaving no template headers
327 corresponding to the `f'. */
329 else if (n_template_parm_scopes
> n_class_scopes
+ 1)
330 /* We've got too many template headers. For example:
332 template <> template <class T> void f (T);
334 There need to be more enclosing classes. */
335 return tsk_excessive_parms
;
337 /* This must be a template. It's of the form:
339 template <class T> template <class U> void S<T>::f(U);
341 This is a specialization if the innermost level was a
342 specialization; otherwise it's just a definition of the
344 return innermost_specialization_p
? tsk_expl_spec
: tsk_template
;
347 /* Exit the current scope. */
355 /* When a label goes out of scope, check to see if that label was used
356 in a valid manner, and issue any appropriate warnings or errors. */
359 pop_label (tree label
, tree old_value
)
361 if (!processing_template_decl
)
363 if (DECL_INITIAL (label
) == NULL_TREE
)
367 cp_error_at ("label `%D' used but not defined", label
);
368 #ifdef USE_MAPPED_LOCATION
369 location
= input_location
; /* FIXME want (input_filename, (line)0) */
371 location
.file
= input_filename
;
374 /* Avoid crashing later. */
375 define_label (location
, DECL_NAME (label
));
377 else if (warn_unused_label
&& !TREE_USED (label
))
378 cp_warning_at ("label `%D' defined but not used", label
);
381 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label
), old_value
);
384 /* At the end of a function, all labels declared within the function
385 go out of scope. BLOCK is the top-level block for the
389 pop_labels (tree block
)
391 struct named_label_list
*link
;
393 /* Clear out the definitions of all label names, since their scopes
395 for (link
= named_labels
; link
; link
= link
->next
)
397 pop_label (link
->label_decl
, link
->old_value
);
398 /* Put the labels into the "variables" of the top-level block,
399 so debugger can see them. */
400 TREE_CHAIN (link
->label_decl
) = BLOCK_VARS (block
);
401 BLOCK_VARS (block
) = link
->label_decl
;
407 /* Exit a binding level.
408 Pop the level off, and restore the state of the identifier-decl mappings
409 that were in effect when this level was entered.
411 If KEEP == 1, this level had explicit declarations, so
412 and create a "block" (a BLOCK node) for the level
413 to record its declarations and subblocks for symbol table output.
415 If FUNCTIONBODY is nonzero, this level is the body of a function,
416 so create a block as if KEEP were set and also clear out all
419 If REVERSE is nonzero, reverse the order of decls before putting
420 them into the BLOCK. */
423 poplevel (int keep
, int reverse
, int functionbody
)
426 /* The chain of decls was accumulated in reverse order.
427 Put it into forward order, just for cleanliness. */
429 int tmp
= functionbody
;
430 int real_functionbody
;
434 int leaving_for_scope
;
437 timevar_push (TV_NAME_LOOKUP
);
442 my_friendly_assert (current_binding_level
->kind
!= sk_class
, 19990916);
444 real_functionbody
= (current_binding_level
->kind
== sk_cleanup
445 ? ((functionbody
= 0), tmp
) : functionbody
);
446 subblocks
= functionbody
>= 0 ? current_binding_level
->blocks
: 0;
448 my_friendly_assert (VEC_length(cp_class_binding
,
449 current_binding_level
->class_shadowed
) == 0,
452 /* We used to use KEEP == 2 to indicate that the new block should go
453 at the beginning of the list of blocks at this binding level,
454 rather than the end. This hack is no longer used. */
455 my_friendly_assert (keep
== 0 || keep
== 1, 0);
457 if (current_binding_level
->keep
)
460 /* Any uses of undefined labels, and any defined labels, now operate
461 under constraints of next binding contour. */
462 if (cfun
&& !functionbody
)
464 struct cp_binding_level
*level_chain
;
465 level_chain
= current_binding_level
->level_chain
;
468 struct named_label_use_list
*uses
;
469 struct named_label_list
*labels
;
470 for (labels
= named_labels
; labels
; labels
= labels
->next
)
471 if (labels
->binding_level
== current_binding_level
)
474 if (current_binding_level
->kind
== sk_try
)
475 labels
->in_try_scope
= 1;
476 if (current_binding_level
->kind
== sk_catch
)
477 labels
->in_catch_scope
= 1;
478 for (decl
= labels
->names_in_scope
; decl
;
479 decl
= TREE_CHAIN (decl
))
480 if (decl_jump_unsafe (decl
))
481 labels
->bad_decls
= tree_cons (NULL_TREE
, decl
,
483 labels
->binding_level
= level_chain
;
484 labels
->names_in_scope
= level_chain
->names
;
487 for (uses
= named_label_uses
; uses
; uses
= uses
->next
)
488 if (uses
->binding_level
== current_binding_level
)
490 uses
->binding_level
= level_chain
;
491 uses
->names_in_scope
= level_chain
->names
;
496 /* Get the decls in the order they were written.
497 Usually current_binding_level->names is in reverse order.
498 But parameter decls were previously put in forward order. */
501 current_binding_level
->names
502 = decls
= nreverse (current_binding_level
->names
);
504 decls
= current_binding_level
->names
;
506 /* If there were any declarations or structure tags in that level,
507 or if this level is a function body,
508 create a BLOCK to record them for the life of this function. */
510 if (keep
== 1 || functionbody
)
511 block
= make_node (BLOCK
);
512 if (block
!= NULL_TREE
)
514 BLOCK_VARS (block
) = decls
;
515 BLOCK_SUBBLOCKS (block
) = subblocks
;
518 /* In each subblock, record that this is its superior. */
520 for (link
= subblocks
; link
; link
= TREE_CHAIN (link
))
521 BLOCK_SUPERCONTEXT (link
) = block
;
523 /* We still support the old for-scope rules, whereby the variables
524 in a for-init statement were in scope after the for-statement
525 ended. We only use the new rules if flag_new_for_scope is
528 = current_binding_level
->kind
== sk_for
&& flag_new_for_scope
== 1;
530 /* Before we remove the declarations first check for unused variables. */
531 if (warn_unused_variable
532 && !processing_template_decl
)
533 for (decl
= getdecls (); decl
; decl
= TREE_CHAIN (decl
))
534 if (TREE_CODE (decl
) == VAR_DECL
535 && ! TREE_USED (decl
)
536 && ! DECL_IN_SYSTEM_HEADER (decl
)
537 && DECL_NAME (decl
) && ! DECL_ARTIFICIAL (decl
))
538 warning ("%Junused variable '%D'", decl
, decl
);
540 /* Remove declarations for all the DECLs in this level. */
541 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
543 if (leaving_for_scope
&& TREE_CODE (link
) == VAR_DECL
546 tree name
= DECL_NAME (link
);
550 ob
= outer_binding (name
,
551 IDENTIFIER_BINDING (name
),
554 ns_binding
= IDENTIFIER_NAMESPACE_VALUE (name
);
556 ns_binding
= NULL_TREE
;
558 if (ob
&& ob
->scope
== current_binding_level
->level_chain
)
559 /* We have something like:
564 and we are leaving the `for' scope. There's no reason to
565 keep the binding of the inner `i' in this case. */
566 pop_binding (name
, link
);
567 else if ((ob
&& (TREE_CODE (ob
->value
) == TYPE_DECL
))
568 || (ns_binding
&& TREE_CODE (ns_binding
) == TYPE_DECL
))
569 /* Here, we have something like:
577 We must pop the for-scope binding so we know what's a
578 type and what isn't. */
579 pop_binding (name
, link
);
582 /* Mark this VAR_DECL as dead so that we can tell we left it
583 there only for backward compatibility. */
584 DECL_DEAD_FOR_LOCAL (link
) = 1;
586 /* Keep track of what should have happened when we
587 popped the binding. */
589 DECL_SHADOWED_FOR_VAR (link
) = ob
->value
;
591 /* Add it to the list of dead variables in the next
592 outermost binding to that we can remove these when we
593 leave that binding. */
594 current_binding_level
->level_chain
->dead_vars_from_for
595 = tree_cons (NULL_TREE
, link
,
596 current_binding_level
->level_chain
->
599 /* Although we don't pop the cxx_binding, we do clear
600 its SCOPE since the scope is going away now. */
601 IDENTIFIER_BINDING (name
)->scope
602 = current_binding_level
->level_chain
;
607 /* Remove the binding. */
610 if (TREE_CODE (decl
) == TREE_LIST
)
611 decl
= TREE_VALUE (decl
);
614 pop_binding (DECL_NAME (decl
), decl
);
615 else if (TREE_CODE (decl
) == OVERLOAD
)
616 pop_binding (DECL_NAME (OVL_FUNCTION (decl
)), decl
);
622 /* Remove declarations for any `for' variables from inner scopes
623 that we kept around. */
624 for (link
= current_binding_level
->dead_vars_from_for
;
625 link
; link
= TREE_CHAIN (link
))
626 pop_binding (DECL_NAME (TREE_VALUE (link
)), TREE_VALUE (link
));
628 /* Restore the IDENTIFIER_TYPE_VALUEs. */
629 for (link
= current_binding_level
->type_shadowed
;
630 link
; link
= TREE_CHAIN (link
))
631 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
633 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
634 for (link
= current_binding_level
->shadowed_labels
;
636 link
= TREE_CHAIN (link
))
637 pop_label (TREE_VALUE (link
), TREE_PURPOSE (link
));
639 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
640 list if a `using' declaration put them there. The debugging
641 back-ends won't understand OVERLOAD, so we remove them here.
642 Because the BLOCK_VARS are (temporarily) shared with
643 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
644 popped all the bindings. */
649 for (d
= &BLOCK_VARS (block
); *d
; )
651 if (TREE_CODE (*d
) == TREE_LIST
)
652 *d
= TREE_CHAIN (*d
);
654 d
= &TREE_CHAIN (*d
);
658 /* If the level being exited is the top level of a function,
659 check over all the labels. */
662 /* Since this is the top level block of a function, the vars are
663 the function's parameters. Don't leave them in the BLOCK
664 because they are found in the FUNCTION_DECL instead. */
665 BLOCK_VARS (block
) = 0;
669 kind
= current_binding_level
->kind
;
670 if (kind
== sk_cleanup
)
674 /* If this is a temporary binding created for a cleanup, then we'll
675 have pushed a statement list level. Pop that, create a new
676 BIND_EXPR for the block, and insert it into the stream. */
677 stmt
= pop_stmt_list (current_binding_level
->statement_list
);
678 stmt
= c_build_bind_expr (block
, stmt
);
684 DECL_INITIAL (current_function_decl
) = block
;
686 current_binding_level
->blocks
687 = chainon (current_binding_level
->blocks
, block
);
689 /* If we did not make a block for the level just exited,
690 any blocks made for inner levels
691 (since they cannot be recorded as subblocks in that level)
692 must be carried forward so they will later become subblocks
693 of something else. */
695 current_binding_level
->blocks
696 = chainon (current_binding_level
->blocks
, subblocks
);
698 /* Each and every BLOCK node created here in `poplevel' is important
699 (e.g. for proper debugging information) so if we created one
700 earlier, mark it as "used". */
702 TREE_USED (block
) = 1;
704 /* All temporary bindings created for cleanups are popped silently. */
705 if (kind
== sk_cleanup
)
708 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, block
);
711 /* Delete the node BLOCK from the current binding level.
712 This is used for the block inside a stmt expr ({...})
713 so that the block can be reinserted where appropriate. */
716 delete_block (tree block
)
719 if (current_binding_level
->blocks
== block
)
720 current_binding_level
->blocks
= TREE_CHAIN (block
);
721 for (t
= current_binding_level
->blocks
; t
;)
723 if (TREE_CHAIN (t
) == block
)
724 TREE_CHAIN (t
) = TREE_CHAIN (block
);
728 TREE_CHAIN (block
) = NULL_TREE
;
729 /* Clear TREE_USED which is always set by poplevel.
730 The flag is set again if insert_block is called. */
731 TREE_USED (block
) = 0;
734 /* Insert BLOCK at the end of the list of subblocks of the
735 current binding level. This is used when a BIND_EXPR is expanded,
736 to handle the BLOCK node inside the BIND_EXPR. */
739 insert_block (tree block
)
741 TREE_USED (block
) = 1;
742 current_binding_level
->blocks
743 = chainon (current_binding_level
->blocks
, block
);
746 /* Returns nonzero if T is a virtual function table. */
749 vtable_decl_p (tree t
, void* data ATTRIBUTE_UNUSED
)
751 return (TREE_CODE (t
) == VAR_DECL
&& DECL_VIRTUAL_P (t
));
754 /* Returns nonzero if T is a TYPE_DECL for a type with virtual
758 vtype_decl_p (tree t
, void *data ATTRIBUTE_UNUSED
)
760 return (TREE_CODE (t
) == TYPE_DECL
761 && TREE_CODE (TREE_TYPE (t
)) == RECORD_TYPE
762 && TYPE_POLYMORPHIC_P (TREE_TYPE (t
)));
765 struct walk_globals_data
{
771 /* Walk the vtable declarations in NAMESPACE. Whenever one is found
772 for which P returns nonzero, call F with its address. If any call
773 to F returns a nonzero value, return a nonzero value. */
776 walk_vtables_r (tree
namespace, void* data
)
778 struct walk_globals_data
* wgd
= (struct walk_globals_data
*) data
;
779 walk_globals_fn f
= wgd
->f
;
781 tree decl
= NAMESPACE_LEVEL (namespace)->vtables
;
784 for (; decl
; decl
= TREE_CHAIN (decl
))
785 result
|= (*f
) (&decl
, d
);
790 /* Walk the vtable declarations. Whenever one is found for which P
791 returns nonzero, call F with its address. If any call to F
792 returns a nonzero value, return a nonzero value. */
794 walk_vtables (walk_globals_pred p
, walk_globals_fn f
, void *data
)
796 struct walk_globals_data wgd
;
801 return walk_namespaces (walk_vtables_r
, &wgd
);
804 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
805 itself, calling F for each. The DATA is passed to F as well. */
808 walk_namespaces_r (tree
namespace, walk_namespaces_fn f
, void* data
)
811 tree current
= NAMESPACE_LEVEL (namespace)->namespaces
;
813 result
|= (*f
) (namespace, data
);
815 for (; current
; current
= TREE_CHAIN (current
))
816 result
|= walk_namespaces_r (current
, f
, data
);
821 /* Walk all the namespaces, calling F for each. The DATA is passed to
825 walk_namespaces (walk_namespaces_fn f
, void* data
)
827 return walk_namespaces_r (global_namespace
, f
, data
);
830 /* Walk the global declarations in NAMESPACE. Whenever one is found
831 for which P returns nonzero, call F with its address. If any call
832 to F returns a nonzero value, return a nonzero value. */
835 walk_globals_r (tree
namespace, void* data
)
837 struct walk_globals_data
* wgd
= (struct walk_globals_data
*) data
;
838 walk_globals_pred p
= wgd
->p
;
839 walk_globals_fn f
= wgd
->f
;
844 t
= &NAMESPACE_LEVEL (namespace)->names
;
851 result
|= (*f
) (t
, d
);
853 /* If F changed *T, then *T still points at the next item to
856 t
= &TREE_CHAIN (*t
);
862 /* Walk the global declarations. Whenever one is found for which P
863 returns true, call F with its address. If any call to F
864 returns true, return true. */
867 walk_globals (walk_globals_pred p
, walk_globals_fn f
, void *data
)
869 struct walk_globals_data wgd
;
874 return walk_namespaces (walk_globals_r
, &wgd
);
877 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
878 DATA is non-NULL, this is the last time we will call
879 wrapup_global_declarations for this NAMESPACE. */
882 wrapup_globals_for_namespace (tree
namespace, void* data
)
884 struct cp_binding_level
*level
= NAMESPACE_LEVEL (namespace);
885 varray_type statics
= level
->static_decls
;
886 tree
*vec
= &VARRAY_TREE (statics
, 0);
887 int len
= VARRAY_ACTIVE_SIZE (statics
);
888 int last_time
= (data
!= 0);
892 check_global_declarations (vec
, len
);
896 /* Write out any globals that need to be output. */
897 return wrapup_global_declarations (vec
, len
);
901 /* In C++, you don't have to write `struct S' to refer to `S'; you
902 can just use `S'. We accomplish this by creating a TYPE_DECL as
903 if the user had written `typedef struct S S'. Create and return
904 the TYPE_DECL for TYPE. */
907 create_implicit_typedef (tree name
, tree type
)
911 decl
= build_decl (TYPE_DECL
, name
, type
);
912 DECL_ARTIFICIAL (decl
) = 1;
913 /* There are other implicit type declarations, like the one *within*
914 a class that allows you to write `S::S'. We must distinguish
916 SET_DECL_IMPLICIT_TYPEDEF_P (decl
);
917 TYPE_NAME (type
) = decl
;
922 /* Remember a local name for name-mangling purposes. */
925 push_local_name (tree decl
)
930 timevar_push (TV_NAME_LOOKUP
);
932 VARRAY_TREE_INIT (local_names
, 8, "local_names");
934 name
= DECL_NAME (decl
);
936 nelts
= VARRAY_ACTIVE_SIZE (local_names
);
937 for (i
= 0; i
< nelts
; i
++)
939 t
= VARRAY_TREE (local_names
, i
);
940 if (DECL_NAME (t
) == name
)
942 if (!DECL_LANG_SPECIFIC (decl
))
943 retrofit_lang_decl (decl
);
944 DECL_LANG_SPECIFIC (decl
)->decl_flags
.u2sel
= 1;
945 if (DECL_LANG_SPECIFIC (t
))
946 DECL_DISCRIMINATOR (decl
) = DECL_DISCRIMINATOR (t
) + 1;
948 DECL_DISCRIMINATOR (decl
) = 1;
950 VARRAY_TREE (local_names
, i
) = decl
;
951 timevar_pop (TV_NAME_LOOKUP
);
956 VARRAY_PUSH_TREE (local_names
, decl
);
957 timevar_pop (TV_NAME_LOOKUP
);
960 /* Subroutine of duplicate_decls: return truthvalue of whether
961 or not types of these decls match.
963 For C++, we must compare the parameter list so that `int' can match
964 `int&' in a parameter position, but `int&' is not confused with
968 decls_match (tree newdecl
, tree olddecl
)
972 if (newdecl
== olddecl
)
975 if (TREE_CODE (newdecl
) != TREE_CODE (olddecl
))
976 /* If the two DECLs are not even the same kind of thing, we're not
977 interested in their types. */
980 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
982 tree f1
= TREE_TYPE (newdecl
);
983 tree f2
= TREE_TYPE (olddecl
);
984 tree p1
= TYPE_ARG_TYPES (f1
);
985 tree p2
= TYPE_ARG_TYPES (f2
);
987 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
988 && ! (DECL_EXTERN_C_P (newdecl
)
989 && DECL_EXTERN_C_P (olddecl
)))
992 if (TREE_CODE (f1
) != TREE_CODE (f2
))
995 if (same_type_p (TREE_TYPE (f1
), TREE_TYPE (f2
)))
997 if (p2
== NULL_TREE
&& DECL_EXTERN_C_P (olddecl
)
998 && (DECL_BUILT_IN (olddecl
)
999 #ifndef NO_IMPLICIT_EXTERN_C
1000 || (DECL_IN_SYSTEM_HEADER (newdecl
) && !DECL_CLASS_SCOPE_P (newdecl
))
1001 || (DECL_IN_SYSTEM_HEADER (olddecl
) && !DECL_CLASS_SCOPE_P (olddecl
))
1005 types_match
= self_promoting_args_p (p1
);
1006 if (p1
== void_list_node
)
1007 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
1009 #ifndef NO_IMPLICIT_EXTERN_C
1010 else if (p1
== NULL_TREE
1011 && (DECL_EXTERN_C_P (olddecl
)
1012 && DECL_IN_SYSTEM_HEADER (olddecl
)
1013 && !DECL_CLASS_SCOPE_P (olddecl
))
1014 && (DECL_EXTERN_C_P (newdecl
)
1015 && DECL_IN_SYSTEM_HEADER (newdecl
)
1016 && !DECL_CLASS_SCOPE_P (newdecl
)))
1018 types_match
= self_promoting_args_p (p2
);
1019 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
1023 types_match
= compparms (p1
, p2
);
1028 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1030 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
))
1031 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)))
1034 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1035 DECL_TEMPLATE_PARMS (olddecl
)))
1038 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1039 types_match
= same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
)),
1040 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
)));
1042 types_match
= decls_match (DECL_TEMPLATE_RESULT (olddecl
),
1043 DECL_TEMPLATE_RESULT (newdecl
));
1047 if (TREE_TYPE (newdecl
) == error_mark_node
)
1048 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
1049 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
1050 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
1051 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
1054 types_match
= comptypes (TREE_TYPE (newdecl
),
1055 TREE_TYPE (olddecl
),
1056 COMPARE_REDECLARATION
);
1062 /* If NEWDECL is `static' and an `extern' was seen previously,
1063 warn about it. OLDDECL is the previous declaration.
1065 Note that this does not apply to the C++ case of declaring
1066 a variable `extern const' and then later `const'.
1068 Don't complain about built-in functions, since they are beyond
1069 the user's control. */
1072 warn_extern_redeclared_static (tree newdecl
, tree olddecl
)
1076 if (TREE_CODE (newdecl
) == TYPE_DECL
1077 || TREE_CODE (newdecl
) == TEMPLATE_DECL
1078 || TREE_CODE (newdecl
) == CONST_DECL
1079 || TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1082 /* Don't get confused by static member functions; that's a different
1084 if (TREE_CODE (newdecl
) == FUNCTION_DECL
1085 && DECL_STATIC_FUNCTION_P (newdecl
))
1088 /* If the old declaration was `static', or the new one isn't, then
1089 then everything is OK. */
1090 if (DECL_THIS_STATIC (olddecl
) || !DECL_THIS_STATIC (newdecl
))
1093 /* It's OK to declare a builtin function as `static'. */
1094 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1095 && DECL_ARTIFICIAL (olddecl
))
1098 name
= DECL_ASSEMBLER_NAME (newdecl
);
1099 pedwarn ("`%D' was declared `extern' and later `static'", newdecl
);
1100 cp_pedwarn_at ("previous declaration of `%D'", olddecl
);
1103 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1104 If the redeclaration is invalid, a diagnostic is issued, and the
1105 error_mark_node is returned. Otherwise, OLDDECL is returned.
1107 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1111 duplicate_decls (tree newdecl
, tree olddecl
)
1113 unsigned olddecl_uid
= DECL_UID (olddecl
);
1114 int olddecl_friend
= 0, types_match
= 0;
1115 int new_defines_function
= 0;
1117 if (newdecl
== olddecl
)
1120 types_match
= decls_match (newdecl
, olddecl
);
1122 /* If either the type of the new decl or the type of the old decl is an
1123 error_mark_node, then that implies that we have already issued an
1124 error (earlier) for some bogus type specification, and in that case,
1125 it is rather pointless to harass the user with yet more error message
1126 about the same declaration, so just pretend the types match here. */
1127 if (TREE_TYPE (newdecl
) == error_mark_node
1128 || TREE_TYPE (olddecl
) == error_mark_node
)
1131 if (DECL_P (olddecl
)
1132 && TREE_CODE (newdecl
) == FUNCTION_DECL
1133 && TREE_CODE (olddecl
) == FUNCTION_DECL
1134 && (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
)))
1136 if (DECL_DECLARED_INLINE_P (newdecl
)
1137 && DECL_UNINLINABLE (newdecl
)
1138 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
1139 /* Already warned elsewhere. */;
1140 else if (DECL_DECLARED_INLINE_P (olddecl
)
1141 && DECL_UNINLINABLE (olddecl
)
1142 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
1143 /* Already warned. */;
1144 else if (DECL_DECLARED_INLINE_P (newdecl
)
1145 && DECL_UNINLINABLE (olddecl
)
1146 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
1148 warning ("%Jfunction '%D' redeclared as inline", newdecl
, newdecl
);
1149 warning ("%Jprevious declaration of '%D' with attribute noinline",
1152 else if (DECL_DECLARED_INLINE_P (olddecl
)
1153 && DECL_UNINLINABLE (newdecl
)
1154 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
1156 warning ("%Jfunction '%D' redeclared with attribute noinline",
1158 warning ("%Jprevious declaration of '%D' was inline",
1163 /* Check for redeclaration and other discrepancies. */
1164 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1165 && DECL_ARTIFICIAL (olddecl
))
1167 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
1169 /* Avoid warnings redeclaring anticipated built-ins. */
1170 if (DECL_ANTICIPATED (olddecl
))
1173 /* If you declare a built-in or predefined function name as static,
1174 the old definition is overridden, but optionally warn this was a
1175 bad choice of name. */
1176 if (! TREE_PUBLIC (newdecl
))
1179 warning ("shadowing %s function `%#D'",
1180 DECL_BUILT_IN (olddecl
) ? "built-in" : "library",
1182 /* Discard the old built-in function. */
1185 /* If the built-in is not ansi, then programs can override
1186 it even globally without an error. */
1187 else if (! DECL_BUILT_IN (olddecl
))
1188 warning ("library function `%#D' redeclared as non-function `%#D'",
1192 error ("declaration of `%#D'", newdecl
);
1193 error ("conflicts with built-in declaration `%#D'",
1198 else if (!types_match
)
1200 /* Avoid warnings redeclaring anticipated built-ins. */
1201 if (DECL_ANTICIPATED (olddecl
))
1203 /* Deal with fileptr_type_node. FILE type is not known
1204 at the time we create the builtins. */
1207 for (t1
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1208 t2
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1210 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1213 else if (TREE_VALUE (t2
) == fileptr_type_node
)
1215 tree t
= TREE_VALUE (t1
);
1217 if (TREE_CODE (t
) == POINTER_TYPE
1218 && TYPE_NAME (TREE_TYPE (t
))
1219 && DECL_NAME (TYPE_NAME (TREE_TYPE (t
)))
1220 == get_identifier ("FILE")
1221 && compparms (TREE_CHAIN (t1
), TREE_CHAIN (t2
)))
1223 tree oldargs
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1225 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))
1226 = TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
1227 types_match
= decls_match (newdecl
, olddecl
);
1229 return duplicate_decls (newdecl
, olddecl
);
1230 TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) = oldargs
;
1233 else if (! same_type_p (TREE_VALUE (t1
), TREE_VALUE (t2
)))
1236 else if ((DECL_EXTERN_C_P (newdecl
)
1237 && DECL_EXTERN_C_P (olddecl
))
1238 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1239 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
1241 /* A near match; override the builtin. */
1243 if (TREE_PUBLIC (newdecl
))
1245 warning ("new declaration `%#D'", newdecl
);
1246 warning ("ambiguates built-in declaration `%#D'",
1249 else if (warn_shadow
)
1250 warning ("shadowing %s function `%#D'",
1251 DECL_BUILT_IN (olddecl
) ? "built-in" : "library",
1255 /* Discard the old built-in function. */
1258 /* Replace the old RTL to avoid problems with inlining. */
1259 COPY_DECL_RTL (newdecl
, olddecl
);
1261 /* Even if the types match, prefer the new declarations type
1262 for anticipated built-ins, for exception lists, etc... */
1263 else if (DECL_ANTICIPATED (olddecl
))
1265 tree type
= TREE_TYPE (newdecl
);
1266 tree attribs
= (*targetm
.merge_type_attributes
)
1267 (TREE_TYPE (olddecl
), type
);
1269 type
= cp_build_type_attribute_variant (type
, attribs
);
1270 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = type
;
1273 /* Whether or not the builtin can throw exceptions has no
1274 bearing on this declarator. */
1275 TREE_NOTHROW (olddecl
) = 0;
1277 if (DECL_THIS_STATIC (newdecl
) && !DECL_THIS_STATIC (olddecl
))
1279 /* If a builtin function is redeclared as `static', merge
1280 the declarations, but make the original one static. */
1281 DECL_THIS_STATIC (olddecl
) = 1;
1282 TREE_PUBLIC (olddecl
) = 0;
1284 /* Make the old declaration consistent with the new one so
1285 that all remnants of the builtin-ness of this function
1286 will be banished. */
1287 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
1288 COPY_DECL_RTL (newdecl
, olddecl
);
1291 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
1293 if ((TREE_CODE (olddecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (olddecl
)
1294 && TREE_CODE (newdecl
) != TYPE_DECL
1295 && ! (TREE_CODE (newdecl
) == TEMPLATE_DECL
1296 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
))
1297 || (TREE_CODE (newdecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (newdecl
)
1298 && TREE_CODE (olddecl
) != TYPE_DECL
1299 && ! (TREE_CODE (olddecl
) == TEMPLATE_DECL
1300 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
1303 /* We do nothing special here, because C++ does such nasty
1304 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1305 get shadowed, and know that if we need to find a TYPE_DECL
1306 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1307 slot of the identifier. */
1311 if ((TREE_CODE (newdecl
) == FUNCTION_DECL
1312 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
1313 || (TREE_CODE (olddecl
) == FUNCTION_DECL
1314 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
1317 error ("`%#D' redeclared as different kind of symbol", newdecl
);
1318 if (TREE_CODE (olddecl
) == TREE_LIST
)
1319 olddecl
= TREE_VALUE (olddecl
);
1320 cp_error_at ("previous declaration of `%#D'", olddecl
);
1322 return error_mark_node
;
1324 else if (!types_match
)
1326 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
))
1327 /* These are certainly not duplicate declarations; they're
1328 from different scopes. */
1331 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1333 /* The name of a class template may not be declared to refer to
1334 any other template, class, function, object, namespace, value,
1335 or type in the same scope. */
1336 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
1337 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1339 error ("declaration of template `%#D'", newdecl
);
1340 cp_error_at ("conflicts with previous declaration `%#D'",
1343 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
1344 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
1345 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
1346 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))))
1347 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1348 DECL_TEMPLATE_PARMS (olddecl
))
1349 /* Template functions can be disambiguated by
1351 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl
)),
1352 TREE_TYPE (TREE_TYPE (olddecl
))))
1354 error ("new declaration `%#D'", newdecl
);
1355 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
1359 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1361 if (DECL_EXTERN_C_P (newdecl
) && DECL_EXTERN_C_P (olddecl
))
1363 error ("declaration of C function `%#D' conflicts with",
1365 cp_error_at ("previous declaration `%#D' here", olddecl
);
1367 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1368 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
1370 error ("new declaration `%#D'", newdecl
);
1371 cp_error_at ("ambiguates old declaration `%#D'", olddecl
);
1378 error ("conflicting declaration '%#D'", newdecl
);
1379 cp_error_at ("'%D' has a previous declaration as `%#D'",
1384 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1385 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
1386 && (!DECL_TEMPLATE_INFO (newdecl
)
1387 || (DECL_TI_TEMPLATE (newdecl
)
1388 != DECL_TI_TEMPLATE (olddecl
))))
1389 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1390 && (!DECL_TEMPLATE_INFO (olddecl
)
1391 || (DECL_TI_TEMPLATE (olddecl
)
1392 != DECL_TI_TEMPLATE (newdecl
))))))
1393 /* It's OK to have a template specialization and a non-template
1394 with the same type, or to have specializations of two
1395 different templates with the same type. Note that if one is a
1396 specialization, and the other is an instantiation of the same
1397 template, that we do not exit at this point. That situation
1398 can occur if we instantiate a template class, and then
1399 specialize one of its methods. This situation is valid, but
1400 the declarations must be merged in the usual way. */
1402 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1403 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
1404 && !DECL_USE_TEMPLATE (newdecl
))
1405 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
1406 && !DECL_USE_TEMPLATE (olddecl
))))
1407 /* One of the declarations is a template instantiation, and the
1408 other is not a template at all. That's OK. */
1410 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1412 /* In [namespace.alias] we have:
1414 In a declarative region, a namespace-alias-definition can be
1415 used to redefine a namespace-alias declared in that declarative
1416 region to refer only to the namespace to which it already
1419 Therefore, if we encounter a second alias directive for the same
1420 alias, we can just ignore the second directive. */
1421 if (DECL_NAMESPACE_ALIAS (newdecl
)
1422 && (DECL_NAMESPACE_ALIAS (newdecl
)
1423 == DECL_NAMESPACE_ALIAS (olddecl
)))
1425 /* [namespace.alias]
1427 A namespace-name or namespace-alias shall not be declared as
1428 the name of any other entity in the same declarative region.
1429 A namespace-name defined at global scope shall not be
1430 declared as the name of any other entity in any glogal scope
1432 error ("declaration of `namespace %D' conflicts with", newdecl
);
1433 cp_error_at ("previous declaration of `namespace %D' here", olddecl
);
1434 return error_mark_node
;
1438 const char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
1441 error (errmsg
, newdecl
);
1442 if (DECL_NAME (olddecl
) != NULL_TREE
)
1443 cp_error_at ((DECL_INITIAL (olddecl
)
1444 && namespace_bindings_p ())
1445 ? "`%#D' previously defined here"
1446 : "`%#D' previously declared here", olddecl
);
1447 return error_mark_node
;
1449 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1450 && DECL_INITIAL (olddecl
) != NULL_TREE
1451 && TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) == NULL_TREE
1452 && TYPE_ARG_TYPES (TREE_TYPE (newdecl
)) != NULL_TREE
)
1454 /* Prototype decl follows defn w/o prototype. */
1455 cp_warning_at ("prototype for `%#D'", newdecl
);
1456 warning ("%Jfollows non-prototype definition here", olddecl
);
1458 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1459 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
1461 /* extern "C" int foo ();
1462 int foo () { bar (); }
1464 if (current_lang_depth () == 0)
1465 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
1468 cp_error_at ("previous declaration of `%#D' with %L linkage",
1469 olddecl
, DECL_LANGUAGE (olddecl
));
1470 error ("conflicts with new declaration with %L linkage",
1471 DECL_LANGUAGE (newdecl
));
1475 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
1477 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
1479 tree t1
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1480 tree t2
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
1483 if (TREE_CODE (TREE_TYPE (newdecl
)) == METHOD_TYPE
)
1484 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
);
1486 for (; t1
&& t1
!= void_list_node
;
1487 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
1488 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
1490 if (1 == simple_cst_equal (TREE_PURPOSE (t1
),
1493 pedwarn ("default argument given for parameter %d of `%#D'",
1495 cp_pedwarn_at ("after previous specification in `%#D'",
1500 error ("default argument given for parameter %d of `%#D'",
1502 cp_error_at ("after previous specification in `%#D'",
1507 if (DECL_DECLARED_INLINE_P (newdecl
)
1508 && ! DECL_DECLARED_INLINE_P (olddecl
)
1509 && TREE_ADDRESSABLE (olddecl
) && warn_inline
)
1511 warning ("`%#D' was used before it was declared inline", newdecl
);
1512 warning ("%Jprevious non-inline declaration here", olddecl
);
1517 /* Do not merge an implicit typedef with an explicit one. In:
1521 typedef class A A __attribute__ ((foo));
1523 the attribute should apply only to the typedef. */
1524 if (TREE_CODE (olddecl
) == TYPE_DECL
1525 && (DECL_IMPLICIT_TYPEDEF_P (olddecl
)
1526 || DECL_IMPLICIT_TYPEDEF_P (newdecl
)))
1529 /* If new decl is `static' and an `extern' was seen previously,
1531 warn_extern_redeclared_static (newdecl
, olddecl
);
1533 /* We have committed to returning 1 at this point. */
1534 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1536 /* Now that functions must hold information normally held
1537 by field decls, there is extra work to do so that
1538 declaration information does not get destroyed during
1540 if (DECL_VINDEX (olddecl
))
1541 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
1542 if (DECL_CONTEXT (olddecl
))
1543 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
1544 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
1545 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
1546 DECL_PURE_VIRTUAL_P (newdecl
) |= DECL_PURE_VIRTUAL_P (olddecl
);
1547 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
1548 DECL_NEEDS_FINAL_OVERRIDER_P (newdecl
) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl
);
1549 DECL_THIS_STATIC (newdecl
) |= DECL_THIS_STATIC (olddecl
);
1550 if (DECL_OVERLOADED_OPERATOR_P (olddecl
) != ERROR_MARK
)
1551 SET_OVERLOADED_OPERATOR_CODE
1552 (newdecl
, DECL_OVERLOADED_OPERATOR_P (olddecl
));
1553 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
1555 /* Optionally warn about more than one declaration for the same
1556 name, but don't warn about a function declaration followed by a
1558 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
1559 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
1560 /* Don't warn about extern decl followed by definition. */
1561 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
1562 /* Don't warn about friends, let add_friend take care of it. */
1563 && ! (DECL_FRIEND_P (newdecl
) || DECL_FRIEND_P (olddecl
)))
1565 warning ("redundant redeclaration of `%D' in same scope", newdecl
);
1566 cp_warning_at ("previous declaration of `%D'", olddecl
);
1570 /* Deal with C++: must preserve virtual function table size. */
1571 if (TREE_CODE (olddecl
) == TYPE_DECL
)
1573 tree newtype
= TREE_TYPE (newdecl
);
1574 tree oldtype
= TREE_TYPE (olddecl
);
1576 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
1577 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
1578 CLASSTYPE_FRIEND_CLASSES (newtype
)
1579 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
1581 DECL_ORIGINAL_TYPE (newdecl
) = DECL_ORIGINAL_TYPE (olddecl
);
1584 /* Copy all the DECL_... slots specified in the new decl
1585 except for any that we copy here from the old type. */
1586 DECL_ATTRIBUTES (newdecl
)
1587 = (*targetm
.merge_decl_attributes
) (olddecl
, newdecl
);
1589 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1591 TREE_TYPE (olddecl
) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
));
1592 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
1593 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
1594 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
1596 /* If the new declaration is a definition, update the file and
1597 line information on the declaration. */
1598 if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl
)) == NULL_TREE
1599 && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl
)) != NULL_TREE
)
1601 DECL_SOURCE_LOCATION (olddecl
)
1602 = DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (olddecl
))
1603 = DECL_SOURCE_LOCATION (newdecl
);
1604 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
1605 DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (olddecl
))
1606 = DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (newdecl
));
1609 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
1611 DECL_INLINE (DECL_TEMPLATE_RESULT (olddecl
))
1612 |= DECL_INLINE (DECL_TEMPLATE_RESULT (newdecl
));
1613 DECL_DECLARED_INLINE_P (DECL_TEMPLATE_RESULT (olddecl
))
1614 |= DECL_DECLARED_INLINE_P (DECL_TEMPLATE_RESULT (newdecl
));
1622 /* Automatically handles default parameters. */
1623 tree oldtype
= TREE_TYPE (olddecl
);
1626 /* Merge the data types specified in the two decls. */
1627 newtype
= merge_types (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
1629 /* If merge_types produces a non-typedef type, just use the old type. */
1630 if (TREE_CODE (newdecl
) == TYPE_DECL
1631 && newtype
== DECL_ORIGINAL_TYPE (newdecl
))
1634 if (TREE_CODE (newdecl
) == VAR_DECL
)
1636 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
1637 DECL_INITIALIZED_P (newdecl
) |= DECL_INITIALIZED_P (olddecl
);
1638 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl
)
1639 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl
);
1642 /* Do this after calling `merge_types' so that default
1643 parameters don't confuse us. */
1644 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1645 && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
))
1646 != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl
))))
1648 TREE_TYPE (newdecl
) = build_exception_variant (newtype
,
1649 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
)));
1650 TREE_TYPE (olddecl
) = build_exception_variant (newtype
,
1651 TYPE_RAISES_EXCEPTIONS (oldtype
));
1653 if ((pedantic
|| ! DECL_IN_SYSTEM_HEADER (olddecl
))
1654 && ! DECL_IS_BUILTIN (olddecl
)
1656 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl
)),
1657 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl
)), 1))
1659 error ("declaration of `%F' throws different exceptions",
1661 cp_error_at ("than previous declaration `%F'", olddecl
);
1664 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
1666 /* Lay the type out, unless already done. */
1667 if (! same_type_p (newtype
, oldtype
)
1668 && TREE_TYPE (newdecl
) != error_mark_node
1669 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
1670 layout_type (TREE_TYPE (newdecl
));
1672 if ((TREE_CODE (newdecl
) == VAR_DECL
1673 || TREE_CODE (newdecl
) == PARM_DECL
1674 || TREE_CODE (newdecl
) == RESULT_DECL
1675 || TREE_CODE (newdecl
) == FIELD_DECL
1676 || TREE_CODE (newdecl
) == TYPE_DECL
)
1677 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
1678 layout_decl (newdecl
, 0);
1680 /* Merge the type qualifiers. */
1681 if (TREE_READONLY (newdecl
))
1682 TREE_READONLY (olddecl
) = 1;
1683 if (TREE_THIS_VOLATILE (newdecl
))
1684 TREE_THIS_VOLATILE (olddecl
) = 1;
1686 /* Merge the initialization information. */
1687 if (DECL_INITIAL (newdecl
) == NULL_TREE
1688 && DECL_INITIAL (olddecl
) != NULL_TREE
)
1690 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
1691 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
1692 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl
)
1693 && DECL_LANG_SPECIFIC (newdecl
)
1694 && DECL_LANG_SPECIFIC (olddecl
))
1696 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
1697 DECL_STRUCT_FUNCTION (newdecl
) = DECL_STRUCT_FUNCTION (olddecl
);
1701 /* Merge the section attribute.
1702 We want to issue an error if the sections conflict but that must be
1703 done later in decl_attributes since we are called before attributes
1705 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
1706 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
1708 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1710 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
1711 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
1712 DECL_NO_LIMIT_STACK (newdecl
) |= DECL_NO_LIMIT_STACK (olddecl
);
1713 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
1714 TREE_READONLY (newdecl
) |= TREE_READONLY (olddecl
);
1715 TREE_NOTHROW (newdecl
) |= TREE_NOTHROW (olddecl
);
1716 DECL_IS_MALLOC (newdecl
) |= DECL_IS_MALLOC (olddecl
);
1717 DECL_IS_PURE (newdecl
) |= DECL_IS_PURE (olddecl
);
1718 /* Keep the old RTL. */
1719 COPY_DECL_RTL (olddecl
, newdecl
);
1721 else if (TREE_CODE (newdecl
) == VAR_DECL
1722 && (DECL_SIZE (olddecl
) || !DECL_SIZE (newdecl
)))
1724 /* Keep the old RTL. We cannot keep the old RTL if the old
1725 declaration was for an incomplete object and the new
1726 declaration is not since many attributes of the RTL will
1728 COPY_DECL_RTL (olddecl
, newdecl
);
1731 /* If cannot merge, then use the new type and qualifiers,
1732 and don't preserve the old rtl. */
1735 /* Clean out any memory we had of the old declaration. */
1736 tree oldstatic
= value_member (olddecl
, static_aggregates
);
1738 TREE_VALUE (oldstatic
) = error_mark_node
;
1740 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
1741 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
1742 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
1743 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
1746 /* Merge the storage class information. */
1747 merge_weak (newdecl
, olddecl
);
1749 DECL_ONE_ONLY (newdecl
) |= DECL_ONE_ONLY (olddecl
);
1750 DECL_DEFER_OUTPUT (newdecl
) |= DECL_DEFER_OUTPUT (olddecl
);
1751 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
1752 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
1753 if (! DECL_EXTERNAL (olddecl
))
1754 DECL_EXTERNAL (newdecl
) = 0;
1756 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
1758 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
1759 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
1760 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
1761 DECL_TEMPLATE_INSTANTIATED (newdecl
)
1762 |= DECL_TEMPLATE_INSTANTIATED (olddecl
);
1763 /* Don't really know how much of the language-specific
1764 values we should copy from old to new. */
1765 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
1766 DECL_LANG_SPECIFIC (newdecl
)->decl_flags
.u2
=
1767 DECL_LANG_SPECIFIC (olddecl
)->decl_flags
.u2
;
1768 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
1769 DECL_REPO_AVAILABLE_P (newdecl
) = DECL_REPO_AVAILABLE_P (olddecl
);
1770 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
1771 DECL_INITIALIZED_IN_CLASS_P (newdecl
)
1772 |= DECL_INITIALIZED_IN_CLASS_P (olddecl
);
1773 olddecl_friend
= DECL_FRIEND_P (olddecl
);
1775 /* Only functions have DECL_BEFRIENDING_CLASSES. */
1776 if (TREE_CODE (newdecl
) == FUNCTION_DECL
1777 || DECL_FUNCTION_TEMPLATE_P (newdecl
))
1779 DECL_BEFRIENDING_CLASSES (newdecl
)
1780 = chainon (DECL_BEFRIENDING_CLASSES (newdecl
),
1781 DECL_BEFRIENDING_CLASSES (olddecl
));
1782 /* DECL_THUNKS is only valid for virtual functions,
1783 otherwise it is a DECL_FRIEND_CONTEXT. */
1784 if (DECL_VIRTUAL_P (newdecl
))
1785 DECL_THUNKS (newdecl
) = DECL_THUNKS (olddecl
);
1789 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1791 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
1792 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
1794 /* If newdecl is not a specialization, then it is not a
1795 template-related function at all. And that means that we
1796 should have exited above, returning 0. */
1797 my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
),
1800 if (TREE_USED (olddecl
))
1801 /* From [temp.expl.spec]:
1803 If a template, a member template or the member of a class
1804 template is explicitly specialized then that
1805 specialization shall be declared before the first use of
1806 that specialization that would cause an implicit
1807 instantiation to take place, in every translation unit in
1808 which such a use occurs. */
1809 error ("explicit specialization of %D after first use",
1812 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
1814 /* [temp.expl.spec/14] We don't inline explicit specialization
1815 just because the primary template says so. */
1819 if (DECL_PENDING_INLINE_INFO (newdecl
) == 0)
1820 DECL_PENDING_INLINE_INFO (newdecl
) = DECL_PENDING_INLINE_INFO (olddecl
);
1822 DECL_DECLARED_INLINE_P (newdecl
) |= DECL_DECLARED_INLINE_P (olddecl
);
1824 /* If either decl says `inline', this fn is inline, unless
1825 its definition was passed already. */
1826 if (DECL_INLINE (newdecl
) && DECL_INITIAL (olddecl
) == NULL_TREE
)
1827 DECL_INLINE (olddecl
) = 1;
1828 DECL_INLINE (newdecl
) = DECL_INLINE (olddecl
);
1830 DECL_UNINLINABLE (newdecl
) = DECL_UNINLINABLE (olddecl
)
1831 = (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
));
1834 /* Preserve abstractness on cloned [cd]tors. */
1835 DECL_ABSTRACT (newdecl
) = DECL_ABSTRACT (olddecl
);
1839 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
1840 COPY_DECL_ASSEMBLER_NAME (newdecl
, olddecl
);
1841 COPY_DECL_RTL (newdecl
, olddecl
);
1843 if (! types_match
|| new_defines_function
)
1845 /* These need to be copied so that the names are available.
1846 Note that if the types do match, we'll preserve inline
1847 info and other bits, but if not, we won't. */
1848 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
1849 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
1851 if (new_defines_function
)
1852 /* If defining a function declared with other language
1853 linkage, use the previously declared language linkage. */
1854 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
1855 else if (types_match
)
1857 /* If redeclaring a builtin function, and not a definition,
1858 it stays built in. */
1859 if (DECL_BUILT_IN (olddecl
))
1861 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
1862 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
1863 /* If we're keeping the built-in definition, keep the rtl,
1864 regardless of declaration matches. */
1865 COPY_DECL_RTL (olddecl
, newdecl
);
1868 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
1869 /* Don't clear out the arguments if we're redefining a function. */
1870 if (DECL_ARGUMENTS (olddecl
))
1871 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
1874 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1875 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
1877 /* Now preserve various other info from the definition. */
1878 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
1879 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
1880 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
1881 COPY_DECL_ASSEMBLER_NAME (olddecl
, newdecl
);
1883 /* Warn about conflicting visibility specifications. */
1884 if (DECL_VISIBILITY_SPECIFIED (olddecl
)
1885 && DECL_VISIBILITY_SPECIFIED (newdecl
)
1886 && DECL_VISIBILITY (newdecl
) != DECL_VISIBILITY (olddecl
))
1888 warning ("%J'%D': visibility attribute ignored because it",
1890 warning ("%Jconflicts with previous declaration here", olddecl
);
1892 /* Choose the declaration which specified visibility. */
1893 if (DECL_VISIBILITY_SPECIFIED (olddecl
))
1895 DECL_VISIBILITY (newdecl
) = DECL_VISIBILITY (olddecl
);
1896 DECL_VISIBILITY_SPECIFIED (newdecl
) = 1;
1899 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1903 function_size
= sizeof (struct tree_decl
);
1905 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
1906 (char *) newdecl
+ sizeof (struct tree_common
),
1907 function_size
- sizeof (struct tree_common
));
1909 if (DECL_TEMPLATE_INSTANTIATION (newdecl
))
1910 /* If newdecl is a template instantiation, it is possible that
1911 the following sequence of events has occurred:
1913 o A friend function was declared in a class template. The
1914 class template was instantiated.
1916 o The instantiation of the friend declaration was
1917 recorded on the instantiation list, and is newdecl.
1919 o Later, however, instantiate_class_template called pushdecl
1920 on the newdecl to perform name injection. But, pushdecl in
1921 turn called duplicate_decls when it discovered that another
1922 declaration of a global function with the same name already
1925 o Here, in duplicate_decls, we decided to clobber newdecl.
1927 If we're going to do that, we'd better make sure that
1928 olddecl, and not newdecl, is on the list of
1929 instantiations so that if we try to do the instantiation
1930 again we won't get the clobbered declaration. */
1931 reregister_specialization (newdecl
,
1932 DECL_TI_TEMPLATE (newdecl
),
1937 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
1938 (char *) newdecl
+ sizeof (struct tree_common
),
1939 sizeof (struct tree_decl
) - sizeof (struct tree_common
)
1940 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
1943 DECL_UID (olddecl
) = olddecl_uid
;
1945 DECL_FRIEND_P (olddecl
) = 1;
1947 /* NEWDECL contains the merged attribute lists.
1948 Update OLDDECL to be the same. */
1949 DECL_ATTRIBUTES (olddecl
) = DECL_ATTRIBUTES (newdecl
);
1951 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
1952 so that encode_section_info has a chance to look at the new decl
1953 flags and attributes. */
1954 if (DECL_RTL_SET_P (olddecl
)
1955 && (TREE_CODE (olddecl
) == FUNCTION_DECL
1956 || (TREE_CODE (olddecl
) == VAR_DECL
1957 && TREE_STATIC (olddecl
))))
1958 make_decl_rtl (olddecl
, NULL
);
1963 /* Return zero if the declaration NEWDECL is valid
1964 when the declaration OLDDECL (assumed to be for the same name)
1965 has already been seen.
1966 Otherwise return an error message format string with a %s
1967 where the identifier should go. */
1970 redeclaration_error_message (tree newdecl
, tree olddecl
)
1972 if (TREE_CODE (newdecl
) == TYPE_DECL
)
1974 /* Because C++ can put things into name space for free,
1975 constructs like "typedef struct foo { ... } foo"
1976 would look like an erroneous redeclaration. */
1977 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
1980 return "redefinition of `%#D'";
1982 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1984 /* If this is a pure function, its olddecl will actually be
1985 the original initialization to `0' (which we force to call
1986 abort()). Don't complain about redefinition in this case. */
1987 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_PURE_VIRTUAL_P (olddecl
))
1990 /* If both functions come from different namespaces, this is not
1991 a redeclaration - this is a conflict with a used function. */
1992 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
1993 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
))
1994 return "`%D' conflicts with used function";
1996 /* We'll complain about linkage mismatches in
1997 warn_extern_redeclared_static. */
1999 /* Defining the same name twice is no good. */
2000 if (DECL_INITIAL (olddecl
) != NULL_TREE
2001 && DECL_INITIAL (newdecl
) != NULL_TREE
)
2003 if (DECL_NAME (olddecl
) == NULL_TREE
)
2004 return "`%#D' not declared in class";
2006 return "redefinition of `%#D'";
2010 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2014 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2016 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl
))
2017 && COMPLETE_TYPE_P (TREE_TYPE (olddecl
)))
2018 return "redefinition of `%#D'";
2022 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != FUNCTION_DECL
2023 || (DECL_TEMPLATE_RESULT (newdecl
)
2024 == DECL_TEMPLATE_RESULT (olddecl
)))
2027 nt
= DECL_TEMPLATE_RESULT (newdecl
);
2028 if (DECL_TEMPLATE_INFO (nt
))
2029 nt
= DECL_TEMPLATE_RESULT (template_for_substitution (nt
));
2030 ot
= DECL_TEMPLATE_RESULT (olddecl
);
2031 if (DECL_TEMPLATE_INFO (ot
))
2032 ot
= DECL_TEMPLATE_RESULT (template_for_substitution (ot
));
2033 if (DECL_INITIAL (nt
) && DECL_INITIAL (ot
))
2034 return "redefinition of `%#D'";
2038 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl
))
2040 /* Objects declared at top level: */
2041 /* If at least one is a reference, it's ok. */
2042 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
2044 /* Reject two definitions. */
2045 return "redefinition of `%#D'";
2049 /* Objects declared with block scope: */
2050 /* Reject two definitions, and reject a definition
2051 together with an external reference. */
2052 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
2053 return "redeclaration of `%#D'";
2058 /* Create a new label, named ID. */
2061 make_label_decl (tree id
, int local_p
)
2065 decl
= build_decl (LABEL_DECL
, id
, void_type_node
);
2067 DECL_CONTEXT (decl
) = current_function_decl
;
2068 DECL_MODE (decl
) = VOIDmode
;
2069 C_DECLARED_LABEL_FLAG (decl
) = local_p
;
2071 /* Say where one reference is to the label, for the sake of the
2072 error if it is not defined. */
2073 DECL_SOURCE_LOCATION (decl
) = input_location
;
2075 /* Record the fact that this identifier is bound to this label. */
2076 SET_IDENTIFIER_LABEL_VALUE (id
, decl
);
2081 /* Record this label on the list of used labels so that we can check
2082 at the end of the function to see whether or not the label was
2083 actually defined, and so we can check when the label is defined whether
2084 this use is valid. */
2087 use_label (tree decl
)
2089 if (named_label_uses
== NULL
2090 || named_label_uses
->names_in_scope
!= current_binding_level
->names
2091 || named_label_uses
->label_decl
!= decl
)
2093 struct named_label_use_list
*new_ent
;
2094 new_ent
= GGC_NEW (struct named_label_use_list
);
2095 new_ent
->label_decl
= decl
;
2096 new_ent
->names_in_scope
= current_binding_level
->names
;
2097 new_ent
->binding_level
= current_binding_level
;
2098 new_ent
->o_goto_locus
= input_location
;
2099 new_ent
->next
= named_label_uses
;
2100 named_label_uses
= new_ent
;
2104 /* Look for a label named ID in the current function. If one cannot
2105 be found, create one. (We keep track of used, but undefined,
2106 labels, and complain about them at the end of a function.) */
2109 lookup_label (tree id
)
2112 struct named_label_list
*ent
;
2114 timevar_push (TV_NAME_LOOKUP
);
2115 /* You can't use labels at global scope. */
2116 if (current_function_decl
== NULL_TREE
)
2118 error ("label `%E' referenced outside of any function", id
);
2119 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
2122 /* See if we've already got this label. */
2123 decl
= IDENTIFIER_LABEL_VALUE (id
);
2124 if (decl
!= NULL_TREE
&& DECL_CONTEXT (decl
) == current_function_decl
)
2125 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2127 /* Record this label on the list of labels used in this function.
2128 We do this before calling make_label_decl so that we get the
2129 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2130 ent
= GGC_CNEW (struct named_label_list
);
2131 ent
->old_value
= IDENTIFIER_LABEL_VALUE (id
);
2132 ent
->next
= named_labels
;
2135 /* We need a new label. */
2136 decl
= make_label_decl (id
, /*local_p=*/0);
2138 /* Now fill in the information we didn't have before. */
2139 ent
->label_decl
= decl
;
2141 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2144 /* Declare a local label named ID. */
2147 declare_local_label (tree id
)
2151 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2152 this scope we can restore the old value of
2153 IDENTIFIER_TYPE_VALUE. */
2154 current_binding_level
->shadowed_labels
2155 = tree_cons (IDENTIFIER_LABEL_VALUE (id
), NULL_TREE
,
2156 current_binding_level
->shadowed_labels
);
2157 /* Look for the label. */
2158 decl
= make_label_decl (id
, /*local_p=*/1);
2159 /* Now fill in the information we didn't have before. */
2160 TREE_VALUE (current_binding_level
->shadowed_labels
) = decl
;
2165 /* Returns nonzero if it is ill-formed to jump past the declaration of
2166 DECL. Returns 2 if it's also a real problem. */
2169 decl_jump_unsafe (tree decl
)
2171 if (TREE_CODE (decl
) != VAR_DECL
|| TREE_STATIC (decl
))
2174 if (DECL_INITIAL (decl
) == NULL_TREE
2175 && pod_type_p (TREE_TYPE (decl
)))
2178 /* This is really only important if we're crossing an initialization.
2179 The POD stuff is just pedantry; why should it matter if the class
2180 contains a field of pointer to member type? */
2181 if (DECL_INITIAL (decl
)
2182 || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
))))
2187 /* Check that a single previously seen jump to a newly defined label
2188 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2189 the jump context; NAMES are the names in scope in LEVEL at the jump
2190 context; FILE and LINE are the source position of the jump or 0. */
2193 check_previous_goto_1 (tree decl
,
2194 struct cp_binding_level
* level
,
2195 tree names
, const location_t
*locus
)
2199 struct cp_binding_level
*b
= current_binding_level
;
2200 for (; b
; b
= b
->level_chain
)
2202 tree new_decls
= b
->names
;
2203 tree old_decls
= (b
== level
? names
: NULL_TREE
);
2204 for (; new_decls
!= old_decls
;
2205 new_decls
= TREE_CHAIN (new_decls
))
2207 int problem
= decl_jump_unsafe (new_decls
);
2214 pedwarn ("jump to label `%D'", decl
);
2216 pedwarn ("jump to case label");
2219 pedwarn ("%H from here", locus
);
2224 cp_error_at (" crosses initialization of `%#D'",
2227 cp_pedwarn_at (" enters scope of non-POD `%#D'",
2233 if ((b
->kind
== sk_try
|| b
->kind
== sk_catch
) && ! saw_eh
)
2238 pedwarn ("jump to label `%D'", decl
);
2240 pedwarn ("jump to case label");
2243 pedwarn ("%H from here", locus
);
2246 if (b
->kind
== sk_try
)
2247 error (" enters try block");
2249 error (" enters catch block");
2256 check_previous_goto (struct named_label_use_list
* use
)
2258 check_previous_goto_1 (use
->label_decl
, use
->binding_level
,
2259 use
->names_in_scope
, &use
->o_goto_locus
);
2263 check_switch_goto (struct cp_binding_level
* level
)
2265 check_previous_goto_1 (NULL_TREE
, level
, level
->names
, NULL
);
2268 /* Check that any previously seen jumps to a newly defined label DECL
2269 are OK. Called by define_label. */
2272 check_previous_gotos (tree decl
)
2274 struct named_label_use_list
**usep
;
2276 if (! TREE_USED (decl
))
2279 for (usep
= &named_label_uses
; *usep
; )
2281 struct named_label_use_list
*use
= *usep
;
2282 if (use
->label_decl
== decl
)
2284 check_previous_goto (use
);
2288 usep
= &(use
->next
);
2292 /* Check that a new jump to a label DECL is OK. Called by
2293 finish_goto_stmt. */
2296 check_goto (tree decl
)
2300 struct named_label_list
*lab
;
2302 /* We can't know where a computed goto is jumping. So we assume
2304 if (! DECL_P (decl
))
2307 /* If the label hasn't been defined yet, defer checking. */
2308 if (! DECL_INITIAL (decl
))
2314 for (lab
= named_labels
; lab
; lab
= lab
->next
)
2315 if (decl
== lab
->label_decl
)
2318 /* If the label is not on named_labels it's a gcc local label, so
2319 it must be in an outer scope, so jumping to it is always OK. */
2323 if ((lab
->in_try_scope
|| lab
->in_catch_scope
|| lab
->bad_decls
)
2326 cp_pedwarn_at ("jump to label `%D'", decl
);
2327 pedwarn (" from here");
2331 for (bad
= lab
->bad_decls
; bad
; bad
= TREE_CHAIN (bad
))
2333 tree b
= TREE_VALUE (bad
);
2334 int u
= decl_jump_unsafe (b
);
2336 if (u
> 1 && DECL_ARTIFICIAL (b
))
2337 /* Can't skip init of __exception_info. */
2338 error ("%J enters catch block", b
);
2340 cp_error_at (" skips initialization of `%#D'", b
);
2342 cp_pedwarn_at (" enters scope of non-POD `%#D'", b
);
2345 if (lab
->in_try_scope
)
2346 error (" enters try block");
2347 else if (lab
->in_catch_scope
)
2348 error (" enters catch block");
2351 /* Define a label, specifying the location in the source file.
2352 Return the LABEL_DECL node for the label. */
2355 define_label (location_t location
, tree name
)
2357 tree decl
= lookup_label (name
);
2358 struct named_label_list
*ent
;
2359 struct cp_binding_level
*p
;
2361 timevar_push (TV_NAME_LOOKUP
);
2362 for (ent
= named_labels
; ent
; ent
= ent
->next
)
2363 if (ent
->label_decl
== decl
)
2366 /* After labels, make any new cleanups in the function go into their
2367 own new (temporary) binding contour. */
2368 for (p
= current_binding_level
;
2369 p
->kind
!= sk_function_parms
;
2371 p
->more_cleanups_ok
= 0;
2373 if (name
== get_identifier ("wchar_t"))
2374 pedwarn ("label named wchar_t");
2376 if (DECL_INITIAL (decl
) != NULL_TREE
)
2377 error ("duplicate label `%D'", decl
);
2380 /* Mark label as having been defined. */
2381 DECL_INITIAL (decl
) = error_mark_node
;
2382 /* Say where in the source. */
2383 DECL_SOURCE_LOCATION (decl
) = location
;
2386 ent
->names_in_scope
= current_binding_level
->names
;
2387 ent
->binding_level
= current_binding_level
;
2389 check_previous_gotos (decl
);
2392 timevar_pop (TV_NAME_LOOKUP
);
2398 struct cp_binding_level
*level
;
2399 struct cp_switch
*next
;
2400 /* The SWITCH_STMT being built. */
2402 /* A splay-tree mapping the low element of a case range to the high
2403 element, or NULL_TREE if there is no high element. Used to
2404 determine whether or not a new case label duplicates an old case
2405 label. We need a tree, rather than simply a hash table, because
2406 of the GNU case range extension. */
2410 /* A stack of the currently active switch statements. The innermost
2411 switch statement is on the top of the stack. There is no need to
2412 mark the stack for garbage collection because it is only active
2413 during the processing of the body of a function, and we never
2414 collect at that point. */
2416 static struct cp_switch
*switch_stack
;
2418 /* Called right after a switch-statement condition is parsed.
2419 SWITCH_STMT is the switch statement being parsed. */
2422 push_switch (tree switch_stmt
)
2424 struct cp_switch
*p
= xmalloc (sizeof (struct cp_switch
));
2425 p
->level
= current_binding_level
;
2426 p
->next
= switch_stack
;
2427 p
->switch_stmt
= switch_stmt
;
2428 p
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
2435 struct cp_switch
*cs
= switch_stack
;
2437 /* Emit warnings as needed. */
2438 c_do_switch_warnings (cs
->cases
, cs
->switch_stmt
);
2440 splay_tree_delete (cs
->cases
);
2441 switch_stack
= switch_stack
->next
;
2445 /* Note that we've seen a definition of a case label, and complain if this
2446 is a bad place for one. */
2449 finish_case_label (tree low_value
, tree high_value
)
2452 struct cp_binding_level
*p
;
2454 if (processing_template_decl
)
2458 /* For templates, just add the case label; we'll do semantic
2459 analysis at instantiation-time. */
2460 label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
2461 return add_stmt (build_case_label (low_value
, high_value
, label
));
2464 /* Find the condition on which this switch statement depends. */
2465 cond
= SWITCH_COND (switch_stack
->switch_stmt
);
2466 if (cond
&& TREE_CODE (cond
) == TREE_LIST
)
2467 cond
= TREE_VALUE (cond
);
2469 r
= c_add_case_label (switch_stack
->cases
, cond
, TREE_TYPE (cond
),
2470 low_value
, high_value
);
2472 check_switch_goto (switch_stack
->level
);
2474 /* After labels, make any new cleanups in the function go into their
2475 own new (temporary) binding contour. */
2476 for (p
= current_binding_level
;
2477 p
->kind
!= sk_function_parms
;
2479 p
->more_cleanups_ok
= 0;
2484 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
2487 typename_hash (const void* k
)
2492 hash
= (htab_hash_pointer (TYPE_CONTEXT (t
))
2493 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t
))));
2498 /* Compare two TYPENAME_TYPEs. K1 and K2 are really of type `tree'. */
2501 typename_compare (const void * k1
, const void * k2
)
2510 d1
= TYPE_NAME (t1
);
2511 d2
= TYPE_NAME (t2
);
2513 return (DECL_NAME (d1
) == DECL_NAME (d2
)
2514 && TYPE_CONTEXT (t1
) == TYPE_CONTEXT (t2
)
2515 && ((TREE_TYPE (t1
) != NULL_TREE
)
2516 == (TREE_TYPE (t2
) != NULL_TREE
))
2517 && same_type_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
2518 && TYPENAME_TYPE_FULLNAME (t1
) == TYPENAME_TYPE_FULLNAME (t2
));
2521 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
2522 the type of `T', NAME is the IDENTIFIER_NODE for `t'. If BASE_TYPE
2523 is non-NULL, this type is being created by the implicit typename
2524 extension, and BASE_TYPE is a type named `t' in some base class of
2525 `T' which depends on template parameters.
2527 Returns the new TYPENAME_TYPE. */
2529 static GTY ((param_is (union tree_node
))) htab_t typename_htab
;
2532 build_typename_type (tree context
, tree name
, tree fullname
)
2538 if (typename_htab
== NULL
)
2540 typename_htab
= htab_create_ggc (61, &typename_hash
,
2541 &typename_compare
, NULL
);
2544 /* Build the TYPENAME_TYPE. */
2545 t
= make_aggr_type (TYPENAME_TYPE
);
2546 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
2547 TYPENAME_TYPE_FULLNAME (t
) = fullname
;
2549 /* Build the corresponding TYPE_DECL. */
2550 d
= build_decl (TYPE_DECL
, name
, t
);
2551 TYPE_NAME (TREE_TYPE (d
)) = d
;
2552 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
2553 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
2554 DECL_ARTIFICIAL (d
) = 1;
2556 /* See if we already have this type. */
2557 e
= htab_find_slot (typename_htab
, t
, INSERT
);
2566 /* Resolve `typename CONTEXT::NAME'. Returns an appropriate type,
2567 unless an error occurs, in which case error_mark_node is returned.
2568 If we locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is
2569 set, we return that, rather than the _TYPE it corresponds to, in
2570 other cases we look through the type decl. If TF_ERROR is set,
2571 complain about errors, otherwise be quiet. */
2574 make_typename_type (tree context
, tree name
, tsubst_flags_t complain
)
2578 if (name
== error_mark_node
2579 || context
== NULL_TREE
2580 || context
== error_mark_node
)
2581 return error_mark_node
;
2585 if (!(TYPE_LANG_SPECIFIC (name
)
2586 && (CLASSTYPE_IS_TEMPLATE (name
)
2587 || CLASSTYPE_USE_TEMPLATE (name
))))
2588 name
= TYPE_IDENTIFIER (name
);
2590 /* Create a TEMPLATE_ID_EXPR for the type. */
2591 name
= build_nt (TEMPLATE_ID_EXPR
,
2592 CLASSTYPE_TI_TEMPLATE (name
),
2593 CLASSTYPE_TI_ARGS (name
));
2595 else if (TREE_CODE (name
) == TYPE_DECL
)
2596 name
= DECL_NAME (name
);
2600 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
2602 name
= TREE_OPERAND (name
, 0);
2603 if (TREE_CODE (name
) == TEMPLATE_DECL
)
2604 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
2606 if (TREE_CODE (name
) == TEMPLATE_DECL
)
2608 error ("`%D' used without template parameters", name
);
2609 return error_mark_node
;
2611 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 20030802);
2613 if (TREE_CODE (context
) == NAMESPACE_DECL
)
2615 /* We can get here from typename_sub0 in the explicit_template_type
2616 expansion. Just fail. */
2617 if (complain
& tf_error
)
2618 error ("no class template named `%#T' in `%#T'",
2620 return error_mark_node
;
2623 if (!dependent_type_p (context
)
2624 || currently_open_class (context
))
2626 if (TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
)
2628 tree tmpl
= NULL_TREE
;
2629 if (IS_AGGR_TYPE (context
))
2630 tmpl
= lookup_field (context
, name
, 0, false);
2631 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
2633 if (complain
& tf_error
)
2634 error ("no class template named `%#T' in `%#T'",
2636 return error_mark_node
;
2639 if (complain
& tf_error
)
2640 perform_or_defer_access_check (TYPE_BINFO (context
), tmpl
);
2642 return lookup_template_class (tmpl
,
2643 TREE_OPERAND (fullname
, 1),
2645 /*entering_scope=*/0,
2646 tf_error
| tf_warning
| tf_user
);
2652 if (!IS_AGGR_TYPE (context
))
2654 if (complain
& tf_error
)
2655 error ("no type named `%#T' in `%#T'", name
, context
);
2656 return error_mark_node
;
2659 t
= lookup_field (context
, name
, 0, true);
2662 if (TREE_CODE (t
) != TYPE_DECL
)
2664 if (complain
& tf_error
)
2665 error ("no type named `%#T' in `%#T'", name
, context
);
2666 return error_mark_node
;
2669 if (complain
& tf_error
)
2670 perform_or_defer_access_check (TYPE_BINFO (context
), t
);
2672 if (DECL_ARTIFICIAL (t
) || !(complain
& tf_keep_type_decl
))
2680 /* If the CONTEXT is not a template type, then either the field is
2681 there now or its never going to be. */
2682 if (!dependent_type_p (context
))
2684 if (complain
& tf_error
)
2685 error ("no type named `%#T' in `%#T'", name
, context
);
2686 return error_mark_node
;
2689 return build_typename_type (context
, name
, fullname
);
2692 /* Resolve `CONTEXT::template NAME'. Returns an appropriate type,
2693 unless an error occurs, in which case error_mark_node is returned.
2694 If we locate a TYPE_DECL, we return that, rather than the _TYPE it
2695 corresponds to. If COMPLAIN zero, don't complain about any errors
2699 make_unbound_class_template (tree context
, tree name
, tsubst_flags_t complain
)
2705 name
= TYPE_IDENTIFIER (name
);
2706 else if (DECL_P (name
))
2707 name
= DECL_NAME (name
);
2708 if (TREE_CODE (name
) != IDENTIFIER_NODE
)
2711 if (!dependent_type_p (context
)
2712 || currently_open_class (context
))
2714 tree tmpl
= NULL_TREE
;
2716 if (IS_AGGR_TYPE (context
))
2717 tmpl
= lookup_field (context
, name
, 0, false);
2719 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
2721 if (complain
& tf_error
)
2722 error ("no class template named `%#T' in `%#T'", name
, context
);
2723 return error_mark_node
;
2726 if (complain
& tf_error
)
2727 perform_or_defer_access_check (TYPE_BINFO (context
), tmpl
);
2732 /* Build the UNBOUND_CLASS_TEMPLATE. */
2733 t
= make_aggr_type (UNBOUND_CLASS_TEMPLATE
);
2734 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
2735 TREE_TYPE (t
) = NULL_TREE
;
2737 /* Build the corresponding TEMPLATE_DECL. */
2738 d
= build_decl (TEMPLATE_DECL
, name
, t
);
2739 TYPE_NAME (TREE_TYPE (d
)) = d
;
2740 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
2741 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
2742 DECL_ARTIFICIAL (d
) = 1;
2749 /* Push the declarations of builtin types into the namespace.
2750 RID_INDEX is the index of the builtin type in the array
2751 RID_POINTERS. NAME is the name used when looking up the builtin
2752 type. TYPE is the _TYPE node for the builtin type. */
2755 record_builtin_type (enum rid rid_index
,
2759 tree rname
= NULL_TREE
, tname
= NULL_TREE
;
2760 tree tdecl
= NULL_TREE
;
2762 if ((int) rid_index
< (int) RID_MAX
)
2763 rname
= ridpointers
[(int) rid_index
];
2765 tname
= get_identifier (name
);
2767 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
2768 eliminated. Built-in types should not be looked up name; their
2769 names are keywords that the parser can recognize. However, there
2770 is code in c-common.c that uses identifier_global_value to look
2771 up built-in types by name. */
2774 tdecl
= build_decl (TYPE_DECL
, tname
, type
);
2775 DECL_ARTIFICIAL (tdecl
) = 1;
2776 SET_IDENTIFIER_GLOBAL_VALUE (tname
, tdecl
);
2782 tdecl
= build_decl (TYPE_DECL
, rname
, type
);
2783 DECL_ARTIFICIAL (tdecl
) = 1;
2785 SET_IDENTIFIER_GLOBAL_VALUE (rname
, tdecl
);
2788 if (!TYPE_NAME (type
))
2789 TYPE_NAME (type
) = tdecl
;
2792 debug_hooks
->type_decl (tdecl
, 0);
2795 /* Record one of the standard Java types.
2796 * Declare it as having the given NAME.
2797 * If SIZE > 0, it is the size of one of the integral types;
2798 * otherwise it is the negative of the size of one of the other types. */
2801 record_builtin_java_type (const char* name
, int size
)
2805 type
= make_signed_type (size
);
2806 else if (size
> -32)
2807 { /* "__java_char" or ""__java_boolean". */
2808 type
= make_unsigned_type (-size
);
2809 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
2812 { /* "__java_float" or ""__java_double". */
2813 type
= make_node (REAL_TYPE
);
2814 TYPE_PRECISION (type
) = - size
;
2817 record_builtin_type (RID_MAX
, name
, type
);
2818 decl
= TYPE_NAME (type
);
2820 /* Suppress generate debug symbol entries for these types,
2821 since for normal C++ they are just clutter.
2822 However, push_lang_context undoes this if extern "Java" is seen. */
2823 DECL_IGNORED_P (decl
) = 1;
2825 TYPE_FOR_JAVA (type
) = 1;
2829 /* Push a type into the namespace so that the back-ends ignore it. */
2832 record_unknown_type (tree type
, const char* name
)
2834 tree decl
= pushdecl (build_decl (TYPE_DECL
, get_identifier (name
), type
));
2835 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
2836 DECL_IGNORED_P (decl
) = 1;
2837 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
2838 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
2839 TYPE_ALIGN (type
) = 1;
2840 TYPE_USER_ALIGN (type
) = 0;
2841 TYPE_MODE (type
) = TYPE_MODE (void_type_node
);
2844 /* An string for which we should create an IDENTIFIER_NODE at
2847 typedef struct predefined_identifier
2849 /* The name of the identifier. */
2850 const char *const name
;
2851 /* The place where the IDENTIFIER_NODE should be stored. */
2853 /* Nonzero if this is the name of a constructor or destructor. */
2854 const int ctor_or_dtor_p
;
2855 } predefined_identifier
;
2857 /* Create all the predefined identifiers. */
2860 initialize_predefined_identifiers (void)
2862 const predefined_identifier
*pid
;
2864 /* A table of identifiers to create at startup. */
2865 static const predefined_identifier predefined_identifiers
[] = {
2866 { "C++", &lang_name_cplusplus
, 0 },
2867 { "C", &lang_name_c
, 0 },
2868 { "Java", &lang_name_java
, 0 },
2869 { CTOR_NAME
, &ctor_identifier
, 1 },
2870 { "__base_ctor", &base_ctor_identifier
, 1 },
2871 { "__comp_ctor", &complete_ctor_identifier
, 1 },
2872 { DTOR_NAME
, &dtor_identifier
, 1 },
2873 { "__comp_dtor", &complete_dtor_identifier
, 1 },
2874 { "__base_dtor", &base_dtor_identifier
, 1 },
2875 { "__deleting_dtor", &deleting_dtor_identifier
, 1 },
2876 { IN_CHARGE_NAME
, &in_charge_identifier
, 0 },
2877 { "nelts", &nelts_identifier
, 0 },
2878 { THIS_NAME
, &this_identifier
, 0 },
2879 { VTABLE_DELTA_NAME
, &delta_identifier
, 0 },
2880 { VTABLE_PFN_NAME
, &pfn_identifier
, 0 },
2881 { "_vptr", &vptr_identifier
, 0 },
2882 { "__vtt_parm", &vtt_parm_identifier
, 0 },
2883 { "::", &global_scope_name
, 0 },
2884 { "std", &std_identifier
, 0 },
2888 for (pid
= predefined_identifiers
; pid
->name
; ++pid
)
2890 *pid
->node
= get_identifier (pid
->name
);
2891 if (pid
->ctor_or_dtor_p
)
2892 IDENTIFIER_CTOR_OR_DTOR_P (*pid
->node
) = 1;
2896 /* Create the predefined scalar types of C,
2897 and some nodes representing standard constants (0, 1, (void *)0).
2898 Initialize the global binding level.
2899 Make definitions for built-in primitive functions. */
2902 cxx_init_decl_processing (void)
2905 tree void_ftype_ptr
;
2907 build_common_tree_nodes (flag_signed_char
);
2909 /* Create all the identifiers we need. */
2910 initialize_predefined_identifiers ();
2912 /* Create the global variables. */
2913 push_to_top_level ();
2915 current_function_decl
= NULL_TREE
;
2916 current_binding_level
= NULL
;
2917 /* Enter the global namespace. */
2918 my_friendly_assert (global_namespace
== NULL_TREE
, 375);
2919 global_namespace
= build_lang_decl (NAMESPACE_DECL
, global_scope_name
,
2921 begin_scope (sk_namespace
, global_namespace
);
2923 current_lang_name
= NULL_TREE
;
2925 /* Adjust various flags based on command-line settings. */
2926 if (!flag_permissive
)
2927 flag_pedantic_errors
= 1;
2928 if (!flag_no_inline
)
2930 flag_inline_trees
= 1;
2933 if (flag_inline_functions
)
2935 flag_inline_trees
= 2;
2936 flag_inline_functions
= 0;
2939 /* Force minimum function alignment if using the least significant
2940 bit of function pointers to store the virtual bit. */
2941 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
2942 && force_align_functions_log
< 1)
2943 force_align_functions_log
= 1;
2946 current_lang_name
= lang_name_c
;
2948 error_mark_list
= build_tree_list (error_mark_node
, error_mark_node
);
2949 TREE_TYPE (error_mark_list
) = error_mark_node
;
2951 /* Create the `std' namespace. */
2952 push_namespace (std_identifier
);
2953 std_node
= current_namespace
;
2956 c_common_nodes_and_builtins ();
2958 java_byte_type_node
= record_builtin_java_type ("__java_byte", 8);
2959 java_short_type_node
= record_builtin_java_type ("__java_short", 16);
2960 java_int_type_node
= record_builtin_java_type ("__java_int", 32);
2961 java_long_type_node
= record_builtin_java_type ("__java_long", 64);
2962 java_float_type_node
= record_builtin_java_type ("__java_float", -32);
2963 java_double_type_node
= record_builtin_java_type ("__java_double", -64);
2964 java_char_type_node
= record_builtin_java_type ("__java_char", -16);
2965 java_boolean_type_node
= record_builtin_java_type ("__java_boolean", -1);
2967 integer_two_node
= build_int_2 (2, 0);
2968 TREE_TYPE (integer_two_node
) = integer_type_node
;
2969 integer_three_node
= build_int_2 (3, 0);
2970 TREE_TYPE (integer_three_node
) = integer_type_node
;
2972 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
2973 truthvalue_type_node
= boolean_type_node
;
2974 truthvalue_false_node
= boolean_false_node
;
2975 truthvalue_true_node
= boolean_true_node
;
2977 empty_except_spec
= build_tree_list (NULL_TREE
, NULL_TREE
);
2980 record_builtin_type (RID_MAX
, NULL
, string_type_node
);
2983 delta_type_node
= ptrdiff_type_node
;
2984 vtable_index_type
= ptrdiff_type_node
;
2986 vtt_parm_type
= build_pointer_type (const_ptr_type_node
);
2987 void_ftype
= build_function_type (void_type_node
, void_list_node
);
2988 void_ftype_ptr
= build_function_type (void_type_node
,
2989 tree_cons (NULL_TREE
,
2993 = build_exception_variant (void_ftype_ptr
, empty_except_spec
);
2995 /* C++ extensions */
2997 unknown_type_node
= make_node (UNKNOWN_TYPE
);
2998 record_unknown_type (unknown_type_node
, "unknown type");
3000 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3001 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
3003 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3005 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
3006 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
3009 /* Make sure we get a unique function type, so we can give
3010 its pointer type a name. (This wins for gdb.) */
3011 tree vfunc_type
= make_node (FUNCTION_TYPE
);
3012 TREE_TYPE (vfunc_type
) = integer_type_node
;
3013 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
3014 layout_type (vfunc_type
);
3016 vtable_entry_type
= build_pointer_type (vfunc_type
);
3018 record_builtin_type (RID_MAX
, VTBL_PTR_TYPE
, vtable_entry_type
);
3021 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
3022 layout_type (vtbl_type_node
);
3023 vtbl_type_node
= build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
3024 record_builtin_type (RID_MAX
, NULL
, vtbl_type_node
);
3025 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
3026 layout_type (vtbl_ptr_type_node
);
3027 record_builtin_type (RID_MAX
, NULL
, vtbl_ptr_type_node
);
3029 push_namespace (get_identifier ("__cxxabiv1"));
3030 abi_node
= current_namespace
;
3033 global_type_node
= make_node (LANG_TYPE
);
3034 record_unknown_type (global_type_node
, "global type");
3037 current_lang_name
= lang_name_cplusplus
;
3041 tree bad_alloc_type_node
;
3042 tree bad_alloc_decl
;
3043 tree newtype
, deltype
;
3044 tree ptr_ftype_sizetype
;
3046 push_namespace (std_identifier
);
3047 bad_alloc_id
= get_identifier ("bad_alloc");
3048 bad_alloc_type_node
= make_aggr_type (RECORD_TYPE
);
3049 TYPE_CONTEXT (bad_alloc_type_node
) = current_namespace
;
3051 = create_implicit_typedef (bad_alloc_id
, bad_alloc_type_node
);
3052 DECL_CONTEXT (bad_alloc_decl
) = current_namespace
;
3053 TYPE_STUB_DECL (bad_alloc_type_node
) = bad_alloc_decl
;
3057 = build_function_type (ptr_type_node
,
3058 tree_cons (NULL_TREE
,
3061 newtype
= build_exception_variant
3062 (ptr_ftype_sizetype
, add_exception_specifier
3063 (NULL_TREE
, bad_alloc_type_node
, -1));
3064 deltype
= build_exception_variant (void_ftype_ptr
, empty_except_spec
);
3065 push_cp_library_fn (NEW_EXPR
, newtype
);
3066 push_cp_library_fn (VEC_NEW_EXPR
, newtype
);
3067 global_delete_fndecl
= push_cp_library_fn (DELETE_EXPR
, deltype
);
3068 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
);
3072 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype
);
3074 /* Perform other language dependent initializations. */
3075 init_class_processing ();
3076 init_rtti_processing ();
3078 if (flag_exceptions
)
3079 init_exception_processing ();
3081 if (! supports_one_only ())
3084 make_fname_decl
= cp_make_fname_decl
;
3085 start_fname_decls ();
3087 /* Show we use EH for cleanups. */
3088 if (flag_exceptions
)
3089 using_eh_for_cleanups ();
3092 /* Generate an initializer for a function naming variable from
3093 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3094 filled in with the type of the init. */
3097 cp_fname_init (const char* name
, tree
*type_p
)
3099 tree domain
= NULL_TREE
;
3101 tree init
= NULL_TREE
;
3106 length
= strlen (name
);
3107 domain
= build_index_type (size_int (length
));
3108 init
= build_string (length
+ 1, name
);
3111 type
= build_qualified_type (char_type_node
, TYPE_QUAL_CONST
);
3112 type
= build_cplus_array_type (type
, domain
);
3117 TREE_TYPE (init
) = type
;
3119 init
= error_mark_node
;
3124 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
3125 decl, NAME is the initialization string and TYPE_DEP indicates whether
3126 NAME depended on the type of the function. We make use of that to detect
3127 __PRETTY_FUNCTION__ inside a template fn. This is being done
3128 lazily at the point of first use, so we mustn't push the decl now. */
3131 cp_make_fname_decl (tree id
, int type_dep
)
3133 const char *const name
= (type_dep
&& processing_template_decl
3134 ? NULL
: fname_as_string (type_dep
));
3136 tree init
= cp_fname_init (name
, &type
);
3137 tree decl
= build_decl (VAR_DECL
, id
, type
);
3140 free ((char *) name
);
3142 /* As we're using pushdecl_with_scope, we must set the context. */
3143 DECL_CONTEXT (decl
) = current_function_decl
;
3144 DECL_PRETTY_FUNCTION_P (decl
) = type_dep
;
3146 TREE_STATIC (decl
) = 1;
3147 TREE_READONLY (decl
) = 1;
3148 DECL_ARTIFICIAL (decl
) = 1;
3149 DECL_INITIAL (decl
) = init
;
3151 TREE_USED (decl
) = 1;
3153 if (current_function_decl
)
3155 struct cp_binding_level
*b
= current_binding_level
;
3156 while (b
->level_chain
->kind
!= sk_function_parms
)
3158 pushdecl_with_scope (decl
, b
);
3159 cp_finish_decl (decl
, init
, NULL_TREE
, LOOKUP_ONLYCONVERTING
);
3162 pushdecl_top_level_and_finish (decl
, init
);
3167 /* Make a definition for a builtin function named NAME in the current
3168 namespace, whose data type is TYPE and whose context is CONTEXT.
3169 TYPE should be a function type with argument types.
3171 CLASS and CODE tell later passes how to compile calls to this function.
3172 See tree.h for possible values.
3174 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3175 the name to be called if we can't opencode the function.
3176 If ATTRS is nonzero, use that for the function's attribute
3180 builtin_function_1 (const char* name
,
3183 enum built_in_function code
,
3184 enum built_in_class
class,
3185 const char* libname
,
3188 tree decl
= build_library_fn_1 (get_identifier (name
), ERROR_MARK
, type
);
3189 DECL_BUILT_IN_CLASS (decl
) = class;
3190 DECL_FUNCTION_CODE (decl
) = code
;
3191 DECL_CONTEXT (decl
) = context
;
3195 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
3196 we cannot change DECL_ASSEMBLER_NAME until we have installed this
3197 function in the namespace. */
3199 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier (libname
));
3201 /* Warn if a function in the namespace for users
3202 is used without an occasion to consider it declared. */
3203 if (name
[0] != '_' || name
[1] != '_')
3204 DECL_ANTICIPATED (decl
) = 1;
3206 /* Possibly apply some default attributes to this built-in function. */
3208 decl_attributes (&decl
, attrs
, ATTR_FLAG_BUILT_IN
);
3210 decl_attributes (&decl
, NULL_TREE
, 0);
3215 /* Entry point for the benefit of c_common_nodes_and_builtins.
3217 Make a definition for a builtin function named NAME and whose data type
3218 is TYPE. TYPE should be a function type with argument types. This
3219 function places the anticipated declaration in the global namespace
3220 and additionally in the std namespace if appropriate.
3222 CLASS and CODE tell later passes how to compile calls to this function.
3223 See tree.h for possible values.
3225 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3226 the name to be called if we can't opencode the function.
3228 If ATTRS is nonzero, use that for the function's attribute
3232 builtin_function (const char* name
,
3235 enum built_in_class cl
,
3236 const char* libname
,
3239 /* All builtins that don't begin with an '_' should additionally
3240 go in the 'std' namespace. */
3243 push_namespace (std_identifier
);
3244 builtin_function_1 (name
, type
, std_node
, code
, cl
, libname
, attrs
);
3248 return builtin_function_1 (name
, type
, NULL_TREE
, code
,
3249 cl
, libname
, attrs
);
3252 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
3253 function. Not called directly. */
3256 build_library_fn_1 (tree name
, enum tree_code operator_code
, tree type
)
3258 tree fn
= build_lang_decl (FUNCTION_DECL
, name
, type
);
3259 DECL_EXTERNAL (fn
) = 1;
3260 TREE_PUBLIC (fn
) = 1;
3261 DECL_ARTIFICIAL (fn
) = 1;
3262 TREE_NOTHROW (fn
) = 1;
3263 SET_OVERLOADED_OPERATOR_CODE (fn
, operator_code
);
3264 SET_DECL_LANGUAGE (fn
, lang_c
);
3265 /* Runtime library routines are, by definition, available in an
3266 external shared object. */
3267 DECL_VISIBILITY (fn
) = VISIBILITY_DEFAULT
;
3268 DECL_VISIBILITY_SPECIFIED (fn
) = 1;
3272 /* Returns the _DECL for a library function with C linkage.
3273 We assume that such functions never throw; if this is incorrect,
3274 callers should unset TREE_NOTHROW. */
3277 build_library_fn (tree name
, tree type
)
3279 return build_library_fn_1 (name
, ERROR_MARK
, type
);
3282 /* Returns the _DECL for a library function with C++ linkage. */
3285 build_cp_library_fn (tree name
, enum tree_code operator_code
, tree type
)
3287 tree fn
= build_library_fn_1 (name
, operator_code
, type
);
3288 TREE_NOTHROW (fn
) = TYPE_NOTHROW_P (type
);
3289 DECL_CONTEXT (fn
) = FROB_CONTEXT (current_namespace
);
3290 SET_DECL_LANGUAGE (fn
, lang_cplusplus
);
3294 /* Like build_library_fn, but takes a C string instead of an
3298 build_library_fn_ptr (const char* name
, tree type
)
3300 return build_library_fn (get_identifier (name
), type
);
3303 /* Like build_cp_library_fn, but takes a C string instead of an
3307 build_cp_library_fn_ptr (const char* name
, tree type
)
3309 return build_cp_library_fn (get_identifier (name
), ERROR_MARK
, type
);
3312 /* Like build_library_fn, but also pushes the function so that we will
3313 be able to find it via IDENTIFIER_GLOBAL_VALUE. */
3316 push_library_fn (tree name
, tree type
)
3318 tree fn
= build_library_fn (name
, type
);
3319 pushdecl_top_level (fn
);
3323 /* Like build_cp_library_fn, but also pushes the function so that it
3324 will be found by normal lookup. */
3327 push_cp_library_fn (enum tree_code operator_code
, tree type
)
3329 tree fn
= build_cp_library_fn (ansi_opname (operator_code
),
3336 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
3340 push_void_library_fn (tree name
, tree parmtypes
)
3342 tree type
= build_function_type (void_type_node
, parmtypes
);
3343 return push_library_fn (name
, type
);
3346 /* Like push_library_fn, but also note that this function throws
3347 and does not return. Used for __throw_foo and the like. */
3350 push_throw_library_fn (tree name
, tree type
)
3352 tree fn
= push_library_fn (name
, type
);
3353 TREE_THIS_VOLATILE (fn
) = 1;
3354 TREE_NOTHROW (fn
) = 0;
3358 /* When we call finish_struct for an anonymous union, we create
3359 default copy constructors and such. But, an anonymous union
3360 shouldn't have such things; this function undoes the damage to the
3361 anonymous union type T.
3363 (The reason that we create the synthesized methods is that we don't
3364 distinguish `union { int i; }' from `typedef union { int i; } U'.
3365 The first is an anonymous union; the second is just an ordinary
3369 fixup_anonymous_aggr (tree t
)
3373 /* Wipe out memory of synthesized methods. */
3374 TYPE_HAS_CONSTRUCTOR (t
) = 0;
3375 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
3376 TYPE_HAS_INIT_REF (t
) = 0;
3377 TYPE_HAS_CONST_INIT_REF (t
) = 0;
3378 TYPE_HAS_ASSIGN_REF (t
) = 0;
3379 TYPE_HAS_CONST_ASSIGN_REF (t
) = 0;
3381 /* Splice the implicitly generated functions out of the TYPE_METHODS
3383 q
= &TYPE_METHODS (t
);
3386 if (DECL_ARTIFICIAL (*q
))
3387 *q
= TREE_CHAIN (*q
);
3389 q
= &TREE_CHAIN (*q
);
3392 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
3393 if (TYPE_METHODS (t
))
3394 error ("%Jan anonymous union cannot have function members",
3395 TYPE_MAIN_DECL (t
));
3397 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
3398 assignment operators (because they cannot have these methods themselves).
3399 For anonymous unions this is already checked because they are not allowed
3400 in any union, otherwise we have to check it. */
3401 if (TREE_CODE (t
) != UNION_TYPE
)
3405 for (field
= TYPE_FIELDS (t
); field
; field
= TREE_CHAIN (field
))
3406 if (TREE_CODE (field
) == FIELD_DECL
)
3408 type
= TREE_TYPE (field
);
3409 if (CLASS_TYPE_P (type
))
3411 if (TYPE_NEEDS_CONSTRUCTING (type
))
3412 cp_error_at ("member %#D' with constructor not allowed in anonymous aggregate",
3414 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
3415 cp_error_at ("member %#D' with destructor not allowed in anonymous aggregate",
3417 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type
))
3418 cp_error_at ("member %#D' with copy assignment operator not allowed in anonymous aggregate",
3425 /* Make sure that a declaration with no declarator is well-formed, i.e.
3426 just declares a tagged type or anonymous union.
3428 Returns the type declared; or NULL_TREE if none. */
3431 check_tag_decl (cp_decl_specifier_seq
*declspecs
)
3433 int saw_friend
= declspecs
->specs
[(int)ds_friend
] != 0;
3434 int saw_typedef
= declspecs
->specs
[(int)ds_typedef
] != 0;
3435 /* If a class, struct, or enum type is declared by the DECLSPECS
3436 (i.e, if a class-specifier, enum-specifier, or non-typename
3437 elaborated-type-specifier appears in the DECLSPECS),
3438 DECLARED_TYPE is set to the corresponding type. */
3439 tree declared_type
= NULL_TREE
;
3440 bool error_p
= false;
3442 if (declspecs
->multiple_types_p
)
3443 error ("multiple types in one declaration");
3444 else if (declspecs
->redefined_builtin_type
)
3446 if (!in_system_header
)
3447 pedwarn ("redeclaration of C++ built-in type %qT",
3448 declspecs
->redefined_builtin_type
);
3452 if (TYPE_P (declspecs
->type
)
3453 && ((TREE_CODE (declspecs
->type
) != TYPENAME_TYPE
3454 && IS_AGGR_TYPE (declspecs
->type
))
3455 || TREE_CODE (declspecs
->type
) == ENUMERAL_TYPE
))
3456 declared_type
= declspecs
->type
;
3457 else if (declspecs
->type
== error_mark_node
)
3459 if (declared_type
== NULL_TREE
&& ! saw_friend
&& !error_p
)
3460 pedwarn ("declaration does not declare anything");
3461 /* Check for an anonymous union. */
3462 else if (declared_type
&& IS_AGGR_TYPE_CODE (TREE_CODE (declared_type
))
3463 && TYPE_ANONYMOUS_P (declared_type
))
3465 /* 7/3 In a simple-declaration, the optional init-declarator-list
3466 can be omitted only when declaring a class (clause 9) or
3467 enumeration (7.2), that is, when the decl-specifier-seq contains
3468 either a class-specifier, an elaborated-type-specifier with
3469 a class-key (9.1), or an enum-specifier. In these cases and
3470 whenever a class-specifier or enum-specifier is present in the
3471 decl-specifier-seq, the identifiers in these specifiers are among
3472 the names being declared by the declaration (as class-name,
3473 enum-names, or enumerators, depending on the syntax). In such
3474 cases, and except for the declaration of an unnamed bit-field (9.6),
3475 the decl-specifier-seq shall introduce one or more names into the
3476 program, or shall redeclare a name introduced by a previous
3477 declaration. [Example:
3478 enum { }; // ill-formed
3479 typedef class { }; // ill-formed
3483 error ("missing type-name in typedef-declaration");
3486 /* Anonymous unions are objects, so they can have specifiers. */;
3487 SET_ANON_AGGR_TYPE_P (declared_type
);
3489 if (TREE_CODE (declared_type
) != UNION_TYPE
&& pedantic
3490 && !in_system_header
)
3491 pedwarn ("ISO C++ prohibits anonymous structs");
3496 if (declspecs
->specs
[(int)ds_inline
]
3497 || declspecs
->specs
[(int)ds_virtual
])
3498 error ("`%s' can only be specified for functions",
3499 declspecs
->specs
[(int)ds_inline
]
3500 ? "inline" : "virtual");
3502 && (!current_class_type
3503 || current_scope () != current_class_type
))
3504 error ("`friend' can only be specified inside a class");
3505 else if (declspecs
->specs
[(int)ds_explicit
])
3506 error ("`explicit' can only be specified for constructors");
3507 else if (declspecs
->storage_class
)
3508 error ("a storage class can only be specified for objects "
3510 else if (declspecs
->specs
[(int)ds_const
]
3511 || declspecs
->specs
[(int)ds_volatile
]
3512 || declspecs
->specs
[(int)ds_restrict
]
3513 || declspecs
->specs
[(int)ds_thread
])
3514 error ("qualifiers can only be specified for objects "
3518 return declared_type
;
3521 /* Called when a declaration is seen that contains no names to declare.
3522 If its type is a reference to a structure, union or enum inherited
3523 from a containing scope, shadow that tag name for the current scope
3524 with a forward reference.
3525 If its type defines a new named structure or union
3526 or defines an enum, it is valid but we need not do anything here.
3527 Otherwise, it is an error.
3529 C++: may have to grok the declspecs to learn about static,
3530 complain for anonymous unions.
3532 Returns the TYPE declared -- or NULL_TREE if none. */
3535 shadow_tag (cp_decl_specifier_seq
*declspecs
)
3537 tree t
= check_tag_decl (declspecs
);
3542 maybe_process_partial_specialization (t
);
3544 /* This is where the variables in an anonymous union are
3545 declared. An anonymous union declaration looks like:
3547 because there is no declarator after the union, the parser
3548 sends that declaration here. */
3549 if (ANON_AGGR_TYPE_P (t
))
3551 fixup_anonymous_aggr (t
);
3553 if (TYPE_FIELDS (t
))
3555 tree decl
= grokdeclarator (/*declarator=*/NULL
,
3556 declspecs
, NORMAL
, 0, NULL
);
3557 finish_anon_union (decl
);
3564 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
3567 groktypename (cp_decl_specifier_seq
*type_specifiers
,
3568 const cp_declarator
*declarator
)
3572 attrs
= type_specifiers
->attributes
;
3573 type_specifiers
->attributes
= NULL_TREE
;
3574 type
= grokdeclarator (declarator
, type_specifiers
, TYPENAME
, 0, &attrs
);
3576 cplus_decl_attributes (&type
, attrs
, 0);
3580 /* Decode a declarator in an ordinary declaration or data definition.
3581 This is called as soon as the type information and variable name
3582 have been parsed, before parsing the initializer if any.
3583 Here we create the ..._DECL node, fill in its type,
3584 and put it on the list of decls for the current context.
3585 The ..._DECL node is returned as the value.
3587 Exception: for arrays where the length is not specified,
3588 the type is left null, to be filled in by `cp_finish_decl'.
3590 Function definitions do not come here; they go to start_function
3591 instead. However, external and forward declarations of functions
3592 do go through here. Structure field declarations are done by
3593 grokfield and not through here. */
3596 start_decl (const cp_declarator
*declarator
,
3597 cp_decl_specifier_seq
*declspecs
,
3600 tree prefix_attributes
,
3607 /* This should only be done once on the top most decl. */
3608 if (have_extern_spec
)
3610 declspecs
->storage_class
= sc_extern
;
3611 have_extern_spec
= false;
3614 /* An object declared as __attribute__((deprecated)) suppresses
3615 warnings of uses of other deprecated items. */
3616 if (lookup_attribute ("deprecated", attributes
))
3617 deprecated_state
= DEPRECATED_SUPPRESS
;
3619 attributes
= chainon (attributes
, prefix_attributes
);
3621 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
3624 deprecated_state
= DEPRECATED_NORMAL
;
3626 if (decl
== NULL_TREE
|| TREE_CODE (decl
) == VOID_TYPE
)
3629 type
= TREE_TYPE (decl
);
3631 if (type
== error_mark_node
)
3634 context
= DECL_CONTEXT (decl
);
3637 *pop_scope_p
= push_scope (context
);
3639 *pop_scope_p
= false;
3641 /* We are only interested in class contexts, later. */
3642 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
3643 context
= NULL_TREE
;
3646 /* Is it valid for this decl to have an initializer at all?
3647 If not, set INITIALIZED to zero, which will indirectly
3648 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
3649 switch (TREE_CODE (decl
))
3652 error ("typedef `%D' is initialized (use __typeof__ instead)", decl
);
3657 error ("function `%#D' is initialized like a variable", decl
);
3667 if (! toplevel_bindings_p ()
3668 && DECL_EXTERNAL (decl
))
3669 warning ("declaration of `%#D' has `extern' and is initialized",
3671 DECL_EXTERNAL (decl
) = 0;
3672 if (toplevel_bindings_p ())
3673 TREE_STATIC (decl
) = 1;
3675 /* Tell `pushdecl' this is an initialized decl
3676 even though we don't yet have the initializer expression.
3677 Also tell `cp_finish_decl' it may store the real initializer. */
3678 DECL_INITIAL (decl
) = error_mark_node
;
3681 /* Set attributes here so if duplicate decl, will have proper attributes. */
3682 cplus_decl_attributes (&decl
, attributes
, 0);
3684 /* If #pragma weak was used, mark the decl weak now. */
3685 if (global_scope_p (current_binding_level
))
3686 maybe_apply_pragma_weak (decl
);
3688 if (TREE_CODE (decl
) == FUNCTION_DECL
3689 && DECL_DECLARED_INLINE_P (decl
)
3690 && DECL_UNINLINABLE (decl
)
3691 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
3692 warning ("%Jinline function '%D' given attribute noinline", decl
, decl
);
3694 if (context
&& COMPLETE_TYPE_P (complete_type (context
)))
3696 if (TREE_CODE (decl
) == VAR_DECL
)
3698 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, false);
3699 if (field
== NULL_TREE
|| TREE_CODE (field
) != VAR_DECL
)
3700 error ("`%#D' is not a static member of `%#T'", decl
, context
);
3703 if (DECL_CONTEXT (field
) != context
)
3705 if (!same_type_p (DECL_CONTEXT (field
), context
))
3706 pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
3707 DECL_CONTEXT (field
), DECL_NAME (decl
),
3708 context
, DECL_NAME (decl
));
3709 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
3711 /* Static data member are tricky; an in-class initialization
3712 still doesn't provide a definition, so the in-class
3713 declaration will have DECL_EXTERNAL set, but will have an
3714 initialization. Thus, duplicate_decls won't warn
3715 about this situation, and so we check here. */
3716 if (DECL_INITIAL (decl
) && DECL_INITIAL (field
))
3717 error ("duplicate initialization of %D", decl
);
3718 if (duplicate_decls (decl
, field
))
3724 tree field
= check_classfn (context
, decl
,
3725 (processing_template_decl
3726 > template_class_depth (context
))
3727 ? current_template_parms
3729 if (field
&& duplicate_decls (decl
, field
))
3733 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
3734 DECL_IN_AGGR_P (decl
) = 0;
3735 if ((DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
3736 || CLASSTYPE_TEMPLATE_INSTANTIATION (context
))
3738 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
3739 /* [temp.expl.spec] An explicit specialization of a static data
3740 member of a template is a definition if the declaration
3741 includes an initializer; otherwise, it is a declaration.
3743 We check for processing_specialization so this only applies
3744 to the new specialization syntax. */
3745 if (DECL_INITIAL (decl
) == NULL_TREE
&& processing_specialization
)
3746 DECL_EXTERNAL (decl
) = 1;
3749 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
))
3750 pedwarn ("declaration of `%#D' outside of class is not definition",
3754 /* Enter this declaration into the symbol table. */
3755 tem
= maybe_push_decl (decl
);
3757 if (processing_template_decl
)
3758 tem
= push_template_decl (tem
);
3759 if (tem
== error_mark_node
)
3760 return error_mark_node
;
3762 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
3763 /* Tell the back-end to use or not use .common as appropriate. If we say
3764 -fconserve-space, we want this to save .data space, at the expense of
3765 wrong semantics. If we say -fno-conserve-space, we want this to
3766 produce errors about redefs; to do this we force variables into the
3768 DECL_COMMON (tem
) = ((TREE_CODE (tem
) != VAR_DECL
3769 || !DECL_THREAD_LOCAL (tem
))
3770 && (flag_conserve_space
|| ! TREE_PUBLIC (tem
)));
3773 if (! processing_template_decl
)
3780 start_decl_1 (tree decl
)
3782 tree type
= TREE_TYPE (decl
);
3783 int initialized
= (DECL_INITIAL (decl
) != NULL_TREE
);
3785 if (type
== error_mark_node
)
3789 /* Is it valid for this decl to have an initializer at all?
3790 If not, set INITIALIZED to zero, which will indirectly
3791 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
3793 /* Don't allow initializations for incomplete types except for
3794 arrays which might be completed by the initialization. */
3795 if (COMPLETE_TYPE_P (complete_type (type
)))
3796 ; /* A complete type is ok. */
3797 else if (TREE_CODE (type
) != ARRAY_TYPE
)
3799 error ("variable `%#D' has initializer but incomplete type",
3802 type
= TREE_TYPE (decl
) = error_mark_node
;
3804 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
3806 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
3807 error ("elements of array `%#D' have incomplete type", decl
);
3808 /* else we already gave an error in start_decl. */
3814 && TREE_CODE (decl
) != TYPE_DECL
3815 && TREE_CODE (decl
) != TEMPLATE_DECL
3816 && type
!= error_mark_node
3817 && IS_AGGR_TYPE (type
)
3818 && ! DECL_EXTERNAL (decl
))
3820 if ((! processing_template_decl
|| ! uses_template_parms (type
))
3821 && !COMPLETE_TYPE_P (complete_type (type
)))
3823 error ("aggregate `%#D' has incomplete type and cannot be defined",
3825 /* Change the type so that assemble_variable will give
3826 DECL an rtl we can live with: (mem (const_int 0)). */
3827 type
= TREE_TYPE (decl
) = error_mark_node
;
3831 /* If any base type in the hierarchy of TYPE needs a constructor,
3832 then we set initialized to 1. This way any nodes which are
3833 created for the purposes of initializing this aggregate
3834 will live as long as it does. This is necessary for global
3835 aggregates which do not have their initializers processed until
3836 the end of the file. */
3837 initialized
= TYPE_NEEDS_CONSTRUCTING (type
);
3842 DECL_INITIAL (decl
) = NULL_TREE
;
3844 /* Create a new scope to hold this declaration if necessary.
3845 Whether or not a new scope is necessary cannot be determined
3846 until after the type has been completed; if the type is a
3847 specialization of a class template it is not until after
3848 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
3849 will be set correctly. */
3850 maybe_push_cleanup_level (type
);
3853 /* Handle initialization of references. DECL, TYPE, and INIT have the
3854 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
3855 but will be set to a new CLEANUP_STMT if a temporary is created
3856 that must be destroyed subsequently.
3858 Returns an initializer expression to use to initialize DECL, or
3859 NULL if the initialization can be performed statically.
3861 Quotes on semantics can be found in ARM 8.4.3. */
3864 grok_reference_init (tree decl
, tree type
, tree init
, tree
*cleanup
)
3868 if (init
== NULL_TREE
)
3870 if ((DECL_LANG_SPECIFIC (decl
) == 0
3871 || DECL_IN_AGGR_P (decl
) == 0)
3872 && ! DECL_THIS_EXTERN (decl
))
3873 error ("`%D' declared as reference but not initialized", decl
);
3877 if (TREE_CODE (init
) == CONSTRUCTOR
)
3879 error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl
);
3883 if (TREE_CODE (init
) == TREE_LIST
)
3884 init
= build_x_compound_expr_from_list (init
, "initializer");
3886 if (TREE_CODE (TREE_TYPE (init
)) == REFERENCE_TYPE
)
3887 init
= convert_from_reference (init
);
3889 if (TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
3890 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
3891 /* Note: default conversion is only called in very special cases. */
3892 init
= decay_conversion (init
);
3894 /* Convert INIT to the reference type TYPE. This may involve the
3895 creation of a temporary, whose lifetime must be the same as that
3896 of the reference. If so, a DECL_EXPR for the temporary will be
3897 added just after the DECL_EXPR for DECL. That's why we don't set
3898 DECL_INITIAL for local references (instead assigning to them
3899 explicitly); we need to allow the temporary to be initialized
3901 tmp
= initialize_reference (type
, init
, decl
, cleanup
);
3903 if (tmp
== error_mark_node
)
3905 else if (tmp
== NULL_TREE
)
3907 error ("cannot initialize `%T' from `%T'", type
, TREE_TYPE (init
));
3911 if (TREE_STATIC (decl
) && !TREE_CONSTANT (tmp
))
3914 DECL_INITIAL (decl
) = tmp
;
3919 /* When parsing `int a[] = {1, 2};' we don't know the size of the
3920 array until we finish parsing the initializer. If that's the
3921 situation we're in, update DECL accordingly. */
3924 maybe_deduce_size_from_array_init (tree decl
, tree init
)
3926 tree type
= TREE_TYPE (decl
);
3928 if (TREE_CODE (type
) == ARRAY_TYPE
3929 && TYPE_DOMAIN (type
) == NULL_TREE
3930 && TREE_CODE (decl
) != TYPE_DECL
)
3932 /* do_default is really a C-ism to deal with tentative definitions.
3933 But let's leave it here to ease the eventual merge. */
3934 int do_default
= !DECL_EXTERNAL (decl
);
3935 tree initializer
= init
? init
: DECL_INITIAL (decl
);
3936 int failure
= complete_array_type (type
, initializer
, do_default
);
3939 error ("initializer fails to determine size of `%D'", decl
);
3944 error ("array size missing in `%D'", decl
);
3945 /* If a `static' var's size isn't known, make it extern as
3946 well as static, so it does not get allocated. If it's not
3947 `static', then don't mark it extern; finish_incomplete_decl
3948 will give it a default size and it will get allocated. */
3949 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
3950 DECL_EXTERNAL (decl
) = 1;
3953 if (pedantic
&& TYPE_DOMAIN (type
) != NULL_TREE
3954 && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)),
3956 error ("zero-size array `%D'", decl
);
3958 layout_decl (decl
, 0);
3962 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
3963 any appropriate error messages regarding the layout. */
3966 layout_var_decl (tree decl
)
3968 tree type
= TREE_TYPE (decl
);
3970 tree ttype
= target_type (type
);
3973 /* If we haven't already layed out this declaration, do so now.
3974 Note that we must not call complete type for an external object
3975 because it's type might involve templates that we are not
3976 supposed to instantiate yet. (And it's perfectly valid to say
3977 `extern X x' for some incomplete type `X'.) */
3978 if (!DECL_EXTERNAL (decl
))
3979 complete_type (type
);
3980 if (!DECL_SIZE (decl
)
3981 && TREE_TYPE (decl
) != error_mark_node
3982 && (COMPLETE_TYPE_P (type
)
3983 || (TREE_CODE (type
) == ARRAY_TYPE
3984 && !TYPE_DOMAIN (type
)
3985 && COMPLETE_TYPE_P (TREE_TYPE (type
)))))
3986 layout_decl (decl
, 0);
3988 if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
3990 /* An automatic variable with an incomplete type: that is an error.
3991 Don't talk about array types here, since we took care of that
3992 message in grokdeclarator. */
3993 error ("storage size of `%D' isn't known", decl
);
3994 TREE_TYPE (decl
) = error_mark_node
;
3997 /* Keep this code around in case we later want to control debug info
3998 based on whether a type is "used". (jason 1999-11-11) */
4000 else if (!DECL_EXTERNAL (decl
) && IS_AGGR_TYPE (ttype
))
4001 /* Let debugger know it should output info for this type. */
4002 note_debug_info_needed (ttype
);
4004 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
4005 note_debug_info_needed (DECL_CONTEXT (decl
));
4008 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
4009 && DECL_SIZE (decl
) != NULL_TREE
4010 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
4012 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
4013 constant_expression_warning (DECL_SIZE (decl
));
4015 error ("storage size of `%D' isn't constant", decl
);
4018 if (TREE_STATIC (decl
)
4019 && !DECL_ARTIFICIAL (decl
)
4020 && current_function_decl
4021 && DECL_CONTEXT (decl
) == current_function_decl
)
4022 push_local_name (decl
);
4025 /* If a local static variable is declared in an inline function, or if
4026 we have a weak definition, we must endeavor to create only one
4027 instance of the variable at link-time. */
4030 maybe_commonize_var (tree decl
)
4032 /* Static data in a function with comdat linkage also has comdat
4034 if (TREE_STATIC (decl
)
4035 /* Don't mess with __FUNCTION__. */
4036 && ! DECL_ARTIFICIAL (decl
)
4037 && DECL_FUNCTION_SCOPE_P (decl
)
4038 /* Unfortunately, import_export_decl has not always been called
4039 before the function is processed, so we cannot simply check
4041 && (DECL_COMDAT (DECL_CONTEXT (decl
))
4042 || ((DECL_DECLARED_INLINE_P (DECL_CONTEXT (decl
))
4043 || DECL_TEMPLATE_INSTANTIATION (DECL_CONTEXT (decl
)))
4044 && TREE_PUBLIC (DECL_CONTEXT (decl
)))))
4048 /* With weak symbols, we simply make the variable COMDAT;
4049 that will cause copies in multiple translations units to
4051 comdat_linkage (decl
);
4055 if (DECL_INITIAL (decl
) == NULL_TREE
4056 || DECL_INITIAL (decl
) == error_mark_node
)
4058 /* Without weak symbols, we can use COMMON to merge
4059 uninitialized variables. */
4060 TREE_PUBLIC (decl
) = 1;
4061 DECL_COMMON (decl
) = 1;
4065 /* While for initialized variables, we must use internal
4066 linkage -- which means that multiple copies will not
4068 TREE_PUBLIC (decl
) = 0;
4069 DECL_COMMON (decl
) = 0;
4070 cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl
);
4071 warning ("%J you can work around this by removing the initializer",
4076 else if (DECL_LANG_SPECIFIC (decl
) && DECL_COMDAT (decl
))
4077 /* Set it up again; we might have set DECL_INITIAL since the last
4079 comdat_linkage (decl
);
4082 /* Issue an error message if DECL is an uninitialized const variable. */
4085 check_for_uninitialized_const_var (tree decl
)
4087 tree type
= TREE_TYPE (decl
);
4089 /* ``Unless explicitly declared extern, a const object does not have
4090 external linkage and must be initialized. ($8.4; $12.1)'' ARM
4092 if (TREE_CODE (decl
) == VAR_DECL
4093 && TREE_CODE (type
) != REFERENCE_TYPE
4094 && CP_TYPE_CONST_P (type
)
4095 && !TYPE_NEEDS_CONSTRUCTING (type
)
4096 && !DECL_INITIAL (decl
))
4097 error ("uninitialized const `%D'", decl
);
4100 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
4101 returned is the next FIELD_DECL (possibly FIELD itself) that can be
4102 initialized. If there are no more such fields, the return value
4106 next_initializable_field (tree field
)
4109 && (TREE_CODE (field
) != FIELD_DECL
4110 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
4111 || DECL_ARTIFICIAL (field
)))
4112 field
= TREE_CHAIN (field
);
4117 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
4118 brace-enclosed aggregate initializer.
4120 *INITP is one of a list of initializers describing a brace-enclosed
4121 initializer for an entity of the indicated aggregate TYPE. It may
4122 not presently match the shape of the TYPE; for example:
4124 struct S { int a; int b; };
4125 struct S a[] = { 1, 2, 3, 4 };
4127 Here *INITP will point to TREE_LIST of four elements, rather than a
4128 list of two elements, each itself a list of two elements. This
4129 routine transforms INIT from the former form into the latter. The
4130 revised initializer is returned. */
4133 reshape_init (tree type
, tree
*initp
)
4137 tree old_init_value
;
4139 bool brace_enclosed_p
;
4142 old_init_value
= (TREE_CODE (*initp
) == TREE_LIST
4143 ? TREE_VALUE (*initp
) : old_init
);
4145 my_friendly_assert (old_init_value
, 20030723);
4147 /* If the initializer is brace-enclosed, pull initializers from the
4148 enclosed elements. Advance past the brace-enclosed initializer
4150 if (TREE_CODE (old_init_value
) == CONSTRUCTOR
4151 && BRACE_ENCLOSED_INITIALIZER_P (old_init_value
))
4153 *initp
= TREE_CHAIN (old_init
);
4154 TREE_CHAIN (old_init
) = NULL_TREE
;
4155 inits
= CONSTRUCTOR_ELTS (old_init_value
);
4157 brace_enclosed_p
= true;
4162 brace_enclosed_p
= false;
4165 /* A non-aggregate type is always initialized with a single
4167 if (!CP_AGGREGATE_TYPE_P (type
))
4169 *initp
= TREE_CHAIN (old_init
);
4170 TREE_CHAIN (old_init
) = NULL_TREE
;
4171 /* It is invalid to initialize a non-aggregate type with a
4172 brace-enclosed initializer. */
4173 if (brace_enclosed_p
)
4175 error ("brace-enclosed initializer used to initialize `%T'",
4177 if (TREE_CODE (old_init
) == TREE_LIST
)
4178 TREE_VALUE (old_init
) = error_mark_node
;
4180 old_init
= error_mark_node
;
4188 All implicit type conversions (clause _conv_) are considered when
4189 initializing the aggregate member with an initializer from an
4190 initializer-list. If the initializer can initialize a member,
4191 the member is initialized. Otherwise, if the member is itself a
4192 non-empty subaggregate, brace elision is assumed and the
4193 initializer is considered for the initialization of the first
4194 member of the subaggregate. */
4195 if (!brace_enclosed_p
4196 && can_convert_arg (type
, TREE_TYPE (old_init_value
), old_init_value
))
4198 *initp
= TREE_CHAIN (old_init
);
4199 TREE_CHAIN (old_init
) = NULL_TREE
;
4203 if (TREE_CODE (old_init_value
) == STRING_CST
4204 && TREE_CODE (type
) == ARRAY_TYPE
4205 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type
))))
4207 /* [dcl.init.string]
4209 A char array (whether plain char, signed char, or unsigned char)
4210 can be initialized by a string-literal (optionally enclosed in
4211 braces); a wchar_t array can be initialized by a wide
4212 string-literal (optionally enclosed in braces). */
4213 new_init
= old_init
;
4214 /* Move past the initializer. */
4215 *initp
= TREE_CHAIN (old_init
);
4216 TREE_CHAIN (old_init
) = NULL_TREE
;
4220 /* Build a CONSTRUCTOR to hold the contents of the aggregate. */
4221 new_init
= build_constructor (NULL_TREE
, NULL_TREE
);
4223 if (CLASS_TYPE_P (type
))
4227 field
= next_initializable_field (TYPE_FIELDS (type
));
4233 An initializer for an aggregate member that is an
4234 empty class shall have the form of an empty
4235 initializer-list {}. */
4236 if (!brace_enclosed_p
)
4238 error ("initializer for `%T' must be brace-enclosed",
4240 return error_mark_node
;
4245 /* Loop through the initializable fields, gathering
4251 /* Handle designated initializers, as an extension. */
4252 if (TREE_PURPOSE (*initp
))
4255 pedwarn ("ISO C++ does not allow designated initializers");
4256 field
= lookup_field_1 (type
, TREE_PURPOSE (*initp
),
4257 /*want_type=*/false);
4258 if (!field
|| TREE_CODE (field
) != FIELD_DECL
)
4259 error ("`%T' has no non-static data member named `%D'",
4260 type
, TREE_PURPOSE (*initp
));
4265 field_init
= reshape_init (TREE_TYPE (field
), initp
);
4266 if (field_init
== error_mark_node
)
4267 return error_mark_node
;
4268 TREE_CHAIN (field_init
) = CONSTRUCTOR_ELTS (new_init
);
4269 CONSTRUCTOR_ELTS (new_init
) = field_init
;
4272 When a union is initialized with a brace-enclosed
4273 initializer, the braces shall only contain an
4274 initializer for the first member of the union. */
4275 if (TREE_CODE (type
) == UNION_TYPE
)
4277 field
= next_initializable_field (TREE_CHAIN (field
));
4281 else if (TREE_CODE (type
) == ARRAY_TYPE
4282 || TREE_CODE (type
) == VECTOR_TYPE
)
4287 /* If the bound of the array is known, take no more initializers
4288 than are allowed. */
4289 max_index
= NULL_TREE
;
4290 if (TREE_CODE (type
) == ARRAY_TYPE
)
4292 if (TYPE_DOMAIN (type
))
4293 max_index
= array_type_nelts (type
);
4297 /* For a vector, the representation type is a struct
4298 containing a single member which is an array of the
4299 appropriate size. */
4300 tree rtype
= TYPE_DEBUG_REPRESENTATION_TYPE (type
);
4301 if (rtype
&& TYPE_DOMAIN (TREE_TYPE (TYPE_FIELDS (rtype
))))
4302 max_index
= array_type_nelts (TREE_TYPE (TYPE_FIELDS (rtype
)));
4305 /* Loop through the array elements, gathering initializers. */
4306 for (index
= size_zero_node
;
4307 *initp
&& (!max_index
|| !tree_int_cst_lt (max_index
, index
));
4308 index
= size_binop (PLUS_EXPR
, index
, size_one_node
))
4312 element_init
= reshape_init (TREE_TYPE (type
), initp
);
4313 if (element_init
== error_mark_node
)
4314 return error_mark_node
;
4315 TREE_CHAIN (element_init
) = CONSTRUCTOR_ELTS (new_init
);
4316 CONSTRUCTOR_ELTS (new_init
) = element_init
;
4317 if (TREE_PURPOSE (element_init
))
4319 tree next_index
= TREE_PURPOSE (element_init
);
4320 if (TREE_CODE (next_index
) == IDENTIFIER_NODE
)
4322 error ("name `%D' used in a GNU-style designated "
4323 "initializer for an array", next_index
);
4324 TREE_PURPOSE (element_init
) = NULL_TREE
;
4334 /* The initializers were placed in reverse order in the
4336 CONSTRUCTOR_ELTS (new_init
) = nreverse (CONSTRUCTOR_ELTS (new_init
));
4338 if (TREE_CODE (old_init
) == TREE_LIST
)
4339 new_init
= build_tree_list (TREE_PURPOSE (old_init
), new_init
);
4342 /* If this was a brace-enclosed initializer and all of the
4343 initializers were not used up, there is a problem. */
4344 if (brace_enclosed_p
&& *initp
)
4345 error ("too many initializers for `%T'", type
);
4350 /* Verify INIT (the initializer for DECL), and record the
4351 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
4352 grok_reference_init.
4354 If the return value is non-NULL, it is an expression that must be
4355 evaluated dynamically to initialize DECL. */
4358 check_initializer (tree decl
, tree init
, int flags
, tree
*cleanup
)
4360 tree type
= TREE_TYPE (decl
);
4361 tree init_code
= NULL
;
4363 /* If `start_decl' didn't like having an initialization, ignore it now. */
4364 if (init
!= NULL_TREE
&& DECL_INITIAL (decl
) == NULL_TREE
)
4367 /* If an initializer is present, DECL_INITIAL has been
4368 error_mark_node, to indicate that an as-of-yet unevaluated
4369 initialization will occur. From now on, DECL_INITIAL reflects
4370 the static initialization -- if any -- of DECL. */
4371 DECL_INITIAL (decl
) = NULL_TREE
;
4373 /* Things that are going to be initialized need to have complete
4375 TREE_TYPE (decl
) = type
= complete_type (TREE_TYPE (decl
));
4377 if (type
== error_mark_node
)
4378 /* We will have already complained. */
4380 else if (init
&& COMPLETE_TYPE_P (type
)
4381 && !TREE_CONSTANT (TYPE_SIZE (type
)))
4383 error ("variable-sized object `%D' may not be initialized", decl
);
4386 else if (TREE_CODE (type
) == ARRAY_TYPE
4387 && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
4389 error ("elements of array `%#D' have incomplete type", decl
);
4392 else if (TREE_CODE (type
) != ARRAY_TYPE
&& !COMPLETE_TYPE_P (type
))
4394 error ("`%D' has incomplete type", decl
);
4395 TREE_TYPE (decl
) = error_mark_node
;
4399 if (TREE_CODE (decl
) == CONST_DECL
)
4401 my_friendly_assert (TREE_CODE (decl
) != REFERENCE_TYPE
, 148);
4403 DECL_INITIAL (decl
) = init
;
4405 my_friendly_assert (init
!= NULL_TREE
, 149);
4408 else if (!DECL_EXTERNAL (decl
) && TREE_CODE (type
) == REFERENCE_TYPE
)
4409 init
= grok_reference_init (decl
, type
, init
, cleanup
);
4412 if (TREE_CODE (init
) == CONSTRUCTOR
4413 && BRACE_ENCLOSED_INITIALIZER_P (init
))
4415 /* [dcl.init] paragraph 13,
4416 If T is a scalar type, then a declaration of the form
4421 reshape_init will complain about the extra braces,
4422 and doesn't do anything useful in the case where TYPE is
4423 scalar, so just don't call it. */
4424 if (CP_AGGREGATE_TYPE_P (type
))
4425 init
= reshape_init (type
, &init
);
4427 if ((*targetm
.vector_opaque_p
) (type
))
4429 error ("opaque vector types cannot be initialized");
4430 init
= error_mark_node
;
4434 /* If DECL has an array type without a specific bound, deduce the
4435 array size from the initializer. */
4436 maybe_deduce_size_from_array_init (decl
, init
);
4437 type
= TREE_TYPE (decl
);
4439 if (TYPE_HAS_CONSTRUCTOR (type
) || TYPE_NEEDS_CONSTRUCTING (type
))
4441 if (TREE_CODE (type
) == ARRAY_TYPE
)
4442 goto initialize_aggr
;
4443 else if (TREE_CODE (init
) == CONSTRUCTOR
4444 && BRACE_ENCLOSED_INITIALIZER_P (init
))
4446 if (TYPE_NON_AGGREGATE_CLASS (type
))
4448 error ("`%D' must be initialized by constructor, not by `{...}'",
4450 init
= error_mark_node
;
4453 goto dont_use_constructor
;
4457 int saved_stmts_are_full_exprs_p
;
4460 saved_stmts_are_full_exprs_p
= 0;
4461 if (building_stmt_tree ())
4463 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
4464 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
4466 init
= build_aggr_init (decl
, init
, flags
);
4467 if (building_stmt_tree ())
4468 current_stmt_tree ()->stmts_are_full_exprs_p
=
4469 saved_stmts_are_full_exprs_p
;
4475 dont_use_constructor
:
4476 if (TREE_CODE (init
) != TREE_VEC
)
4478 init_code
= store_init_value (decl
, init
);
4483 else if (DECL_EXTERNAL (decl
))
4485 else if (TYPE_P (type
) && TYPE_NEEDS_CONSTRUCTING (type
))
4486 goto initialize_aggr
;
4487 else if (IS_AGGR_TYPE (type
))
4489 tree core_type
= strip_array_types (type
);
4491 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
))
4492 error ("structure `%D' with uninitialized const members", decl
);
4493 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
))
4494 error ("structure `%D' with uninitialized reference members",
4497 check_for_uninitialized_const_var (decl
);
4500 check_for_uninitialized_const_var (decl
);
4502 if (init
&& init
!= error_mark_node
)
4503 init_code
= build (INIT_EXPR
, type
, decl
, init
);
4508 /* If DECL is not a local variable, give it RTL. */
4511 make_rtl_for_nonlocal_decl (tree decl
, tree init
, const char* asmspec
)
4513 int toplev
= toplevel_bindings_p ();
4516 /* Handle non-variables up front. */
4517 if (TREE_CODE (decl
) != VAR_DECL
)
4519 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
4523 /* If we see a class member here, it should be a static data
4525 if (DECL_LANG_SPECIFIC (decl
) && DECL_IN_AGGR_P (decl
))
4527 my_friendly_assert (TREE_STATIC (decl
), 19990828);
4528 /* An in-class declaration of a static data member should be
4529 external; it is only a declaration, and not a definition. */
4530 if (init
== NULL_TREE
)
4531 my_friendly_assert (DECL_EXTERNAL (decl
), 20000723);
4534 /* Set the DECL_ASSEMBLER_NAME for the variable. */
4537 change_decl_assembler_name (decl
, get_identifier (asmspec
));
4538 /* The `register' keyword, when used together with an
4539 asm-specification, indicates that the variable should be
4540 placed in a particular register. */
4541 if (DECL_REGISTER (decl
))
4542 DECL_HARD_REGISTER (decl
) = 1;
4545 /* We don't create any RTL for local variables. */
4546 if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
4549 /* We defer emission of local statics until the corresponding
4550 DECL_EXPR is expanded. */
4551 defer_p
= DECL_FUNCTION_SCOPE_P (decl
) || DECL_VIRTUAL_P (decl
);
4553 /* We try to defer namespace-scope static constants so that they are
4554 not emitted into the object file unnecessarily. */
4555 if (!DECL_VIRTUAL_P (decl
)
4556 && TREE_READONLY (decl
)
4557 && DECL_INITIAL (decl
) != NULL_TREE
4558 && DECL_INITIAL (decl
) != error_mark_node
4559 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
))
4561 && !TREE_PUBLIC (decl
))
4563 /* Fool with the linkage of static consts according to #pragma
4565 if (!interface_unknown
&& !TREE_PUBLIC (decl
))
4567 TREE_PUBLIC (decl
) = 1;
4568 DECL_EXTERNAL (decl
) = interface_only
;
4573 /* Likewise for template instantiations. */
4574 else if (DECL_LANG_SPECIFIC (decl
)
4575 && DECL_IMPLICIT_INSTANTIATION (decl
))
4578 /* If we're deferring the variable, we only need to make RTL if
4579 there's an ASMSPEC. Otherwise, we'll lazily create it later when
4580 we need it. (There's no way to lazily create RTL for things that
4581 have assembly specs because the information about the specifier
4582 isn't stored in the tree, yet) */
4583 if (defer_p
&& asmspec
)
4584 make_decl_rtl (decl
, asmspec
);
4585 /* If we're not deferring, go ahead and assemble the variable. */
4587 rest_of_decl_compilation (decl
, asmspec
, toplev
, at_eof
);
4590 /* Generate code to initialize DECL (a local variable). */
4593 initialize_local_var (tree decl
, tree init
)
4595 tree type
= TREE_TYPE (decl
);
4598 my_friendly_assert (TREE_CODE (decl
) == VAR_DECL
4599 || TREE_CODE (decl
) == RESULT_DECL
,
4601 my_friendly_assert (!TREE_STATIC (decl
), 20021010);
4603 if (DECL_SIZE (decl
) == NULL_TREE
)
4605 /* If we used it already as memory, it must stay in memory. */
4606 DECL_INITIAL (decl
) = NULL_TREE
;
4607 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
4610 if (DECL_SIZE (decl
) && type
!= error_mark_node
)
4614 /* Compute and store the initial value. */
4615 already_used
= TREE_USED (decl
) || TREE_USED (type
);
4617 /* Perform the initialization. */
4620 int saved_stmts_are_full_exprs_p
;
4622 my_friendly_assert (building_stmt_tree (), 20000906);
4623 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
4624 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
4625 finish_expr_stmt (init
);
4626 current_stmt_tree ()->stmts_are_full_exprs_p
=
4627 saved_stmts_are_full_exprs_p
;
4630 /* Set this to 0 so we can tell whether an aggregate which was
4631 initialized was ever used. Don't do this if it has a
4632 destructor, so we don't complain about the 'resource
4633 allocation is initialization' idiom. Now set
4634 attribute((unused)) on types so decls of that type will be
4635 marked used. (see TREE_USED, above.) */
4636 if (TYPE_NEEDS_CONSTRUCTING (type
)
4638 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type
)
4639 && DECL_NAME (decl
))
4640 TREE_USED (decl
) = 0;
4641 else if (already_used
)
4642 TREE_USED (decl
) = 1;
4645 /* Generate a cleanup, if necessary. */
4646 cleanup
= cxx_maybe_build_cleanup (decl
);
4647 if (DECL_SIZE (decl
) && cleanup
)
4648 finish_decl_cleanup (decl
, cleanup
);
4651 /* Finish processing of a declaration;
4652 install its line number and initial value.
4653 If the length of an array type is not known before,
4654 it must be determined now, from the initial value, or it is an error.
4656 INIT holds the value of an initializer that should be allowed to escape
4659 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
4660 if the (init) syntax was used. */
4663 cp_finish_decl (tree decl
, tree init
, tree asmspec_tree
, int flags
)
4666 tree ttype
= NULL_TREE
;
4668 const char *asmspec
= NULL
;
4669 int was_readonly
= 0;
4671 if (decl
== error_mark_node
)
4676 error ("assignment (not initialization) in declaration");
4680 my_friendly_assert (TREE_CODE (decl
) != RESULT_DECL
, 20030619);
4682 /* Assume no cleanup is required. */
4683 cleanup
= NULL_TREE
;
4685 /* If a name was specified, get the string. */
4686 if (global_scope_p (current_binding_level
))
4687 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
4689 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
4691 if (init
&& TREE_CODE (init
) == NAMESPACE_DECL
)
4693 error ("cannot initialize `%D' to namespace `%D'",
4698 if (current_class_type
4699 && CP_DECL_CONTEXT (decl
) == current_class_type
4700 && TYPE_BEING_DEFINED (current_class_type
)
4701 && (DECL_INITIAL (decl
) || init
))
4702 DECL_INITIALIZED_IN_CLASS_P (decl
) = 1;
4704 type
= TREE_TYPE (decl
);
4706 if (type
== error_mark_node
)
4709 if (TYPE_HAS_MUTABLE_P (type
))
4710 TREE_READONLY (decl
) = 0;
4712 if (processing_template_decl
)
4714 /* Add this declaration to the statement-tree. */
4715 if (at_function_scope_p ())
4716 add_decl_expr (decl
);
4718 if (init
&& DECL_INITIAL (decl
))
4719 DECL_INITIAL (decl
) = init
;
4720 if (TREE_CODE (decl
) == VAR_DECL
4721 && !DECL_PRETTY_FUNCTION_P (decl
)
4722 && !dependent_type_p (TREE_TYPE (decl
)))
4723 maybe_deduce_size_from_array_init (decl
, init
);
4727 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
4728 my_friendly_assert (TREE_CODE (decl
) != PARM_DECL
, 19990828);
4730 /* Take care of TYPE_DECLs up front. */
4731 if (TREE_CODE (decl
) == TYPE_DECL
)
4733 if (type
!= error_mark_node
4734 && IS_AGGR_TYPE (type
) && DECL_NAME (decl
))
4736 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
4737 warning ("shadowing previous type declaration of `%#D'", decl
);
4738 set_identifier_type_value (DECL_NAME (decl
), decl
);
4741 /* If we have installed this as the canonical typedef for this
4742 type, and that type has not been defined yet, delay emitting
4743 the debug information for it, as we will emit it later. */
4744 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
4745 && !COMPLETE_TYPE_P (TREE_TYPE (decl
)))
4746 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
4748 rest_of_decl_compilation (decl
, NULL
,
4749 DECL_CONTEXT (decl
) == NULL_TREE
, at_eof
);
4753 if (TREE_CODE (decl
) != FUNCTION_DECL
)
4754 ttype
= target_type (type
);
4757 /* Currently, GNU C++ puts constants in text space, making them
4758 impossible to initialize. In the future, one would hope for
4759 an operating system which understood the difference between
4760 initialization and the running of a program. */
4761 if (! DECL_EXTERNAL (decl
) && TREE_READONLY (decl
))
4764 if (TYPE_NEEDS_CONSTRUCTING (type
)
4765 || TREE_CODE (type
) == REFERENCE_TYPE
)
4766 TREE_READONLY (decl
) = 0;
4769 if (TREE_CODE (decl
) == VAR_DECL
)
4771 /* Only PODs can have thread-local storage. Other types may require
4772 various kinds of non-trivial initialization. */
4773 if (DECL_THREAD_LOCAL (decl
) && !pod_type_p (TREE_TYPE (decl
)))
4774 error ("`%D' cannot be thread-local because it has non-POD type `%T'",
4775 decl
, TREE_TYPE (decl
));
4776 /* Convert the initializer to the type of DECL, if we have not
4777 already initialized DECL. */
4778 if (!DECL_INITIALIZED_P (decl
)
4779 /* If !DECL_EXTERNAL then DECL is being defined. In the
4780 case of a static data member initialized inside the
4781 class-specifier, there can be an initializer even if DECL
4782 is *not* defined. */
4783 && (!DECL_EXTERNAL (decl
) || init
))
4785 init
= check_initializer (decl
, init
, flags
, &cleanup
);
4786 /* Thread-local storage cannot be dynamically initialized. */
4787 if (DECL_THREAD_LOCAL (decl
) && init
)
4789 error ("`%D' is thread-local and so cannot be dynamically "
4790 "initialized", decl
);
4797 The memory occupied by any object of static storage
4798 duration is zero-initialized at program startup before
4799 any other initialization takes place.
4801 We cannot create an appropriate initializer until after
4802 the type of DECL is finalized. If DECL_INITIAL is set,
4803 then the DECL is statically initialized, and any
4804 necessary zero-initialization has already been performed. */
4805 if (TREE_STATIC (decl
) && !DECL_INITIAL (decl
))
4806 DECL_INITIAL (decl
) = build_zero_init (TREE_TYPE (decl
),
4807 /*nelts=*/NULL_TREE
,
4808 /*static_storage_p=*/true);
4809 /* Remember that the initialization for this variable has
4811 DECL_INITIALIZED_P (decl
) = 1;
4812 /* The variable is being defined, so determine its
4814 determine_visibility (decl
);
4816 /* If the variable has an array type, lay out the type, even if
4817 there is no initializer. It is valid to index through the
4818 array, and we must get TYPE_ALIGN set correctly on the array
4820 else if (TREE_CODE (type
) == ARRAY_TYPE
)
4824 /* Add this declaration to the statement-tree. This needs to happen
4825 after the call to check_initializer so that the DECL_EXPR for a
4826 reference temp is added before the DECL_EXPR for the reference itself. */
4827 if (at_function_scope_p ())
4828 add_decl_expr (decl
);
4830 if (TREE_CODE (decl
) == VAR_DECL
)
4831 layout_var_decl (decl
);
4833 /* Output the assembler code and/or RTL code for variables and functions,
4834 unless the type is an undefined structure or union.
4835 If not, it will get done when the type is completed. */
4836 if (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == FUNCTION_DECL
)
4838 if (TREE_CODE (decl
) == VAR_DECL
)
4839 maybe_commonize_var (decl
);
4841 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
);
4843 /* Check for abstractness of the type. Notice that there is no
4844 need to strip array types here since the check for those types
4845 is already done within create_array_type_for_decl. */
4846 if (TREE_CODE (type
) == FUNCTION_TYPE
4847 || TREE_CODE (type
) == METHOD_TYPE
)
4848 abstract_virtuals_error (decl
, TREE_TYPE (type
));
4850 abstract_virtuals_error (decl
, type
);
4852 if (TREE_CODE (decl
) == FUNCTION_DECL
4853 || TREE_TYPE (decl
) == error_mark_node
)
4854 /* No initialization required. */
4856 else if (DECL_EXTERNAL (decl
)
4857 && ! (DECL_LANG_SPECIFIC (decl
)
4858 && DECL_NOT_REALLY_EXTERN (decl
)))
4861 DECL_INITIAL (decl
) = init
;
4865 /* A variable definition. */
4866 if (DECL_FUNCTION_SCOPE_P (decl
))
4868 /* Initialize the local variable. */
4869 if (processing_template_decl
)
4871 if (init
|| DECL_INITIAL (decl
) == error_mark_node
)
4872 DECL_INITIAL (decl
) = init
;
4874 else if (!TREE_STATIC (decl
))
4875 initialize_local_var (decl
, init
);
4878 if (TREE_STATIC (decl
))
4879 expand_static_init (decl
, init
);
4883 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
4884 reference, insert it in the statement-tree now. */
4886 push_cleanup (decl
, cleanup
, false);
4891 TREE_READONLY (decl
) = 1;
4893 /* If this was marked 'used', be sure it will be output. */
4894 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl
)))
4895 mark_decl_referenced (decl
);
4898 /* This is here for a midend callback from c-common.c. */
4901 finish_decl (tree decl
, tree init
, tree asmspec_tree
)
4903 cp_finish_decl (decl
, init
, asmspec_tree
, 0);
4906 /* Returns a declaration for a VAR_DECL as if:
4908 extern "C" TYPE NAME;
4910 had been seen. Used to create compiler-generated global
4914 declare_global_var (tree name
, tree type
)
4918 push_to_top_level ();
4919 decl
= build_decl (VAR_DECL
, name
, type
);
4920 TREE_PUBLIC (decl
) = 1;
4921 DECL_EXTERNAL (decl
) = 1;
4922 DECL_ARTIFICIAL (decl
) = 1;
4924 cp_finish_decl (decl
, NULL_TREE
, NULL_TREE
, 0);
4925 pop_from_top_level ();
4930 /* Returns a pointer to the `atexit' function. Note that if
4931 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
4932 `__cxa_atexit' function specified in the IA64 C++ ABI. */
4935 get_atexit_node (void)
4946 if (flag_use_cxa_atexit
)
4948 /* The declaration for `__cxa_atexit' is:
4950 int __cxa_atexit (void (*)(void *), void *, void *)
4952 We build up the argument types and then then function type
4955 /* First, build the pointer-to-function type for the first
4957 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, void_list_node
);
4958 fn_type
= build_function_type (void_type_node
, arg_types
);
4959 fn_ptr_type
= build_pointer_type (fn_type
);
4960 /* Then, build the rest of the argument types. */
4961 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, void_list_node
);
4962 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, arg_types
);
4963 arg_types
= tree_cons (NULL_TREE
, fn_ptr_type
, arg_types
);
4964 /* And the final __cxa_atexit type. */
4965 fn_type
= build_function_type (integer_type_node
, arg_types
);
4966 fn_ptr_type
= build_pointer_type (fn_type
);
4967 name
= "__cxa_atexit";
4971 /* The declaration for `atexit' is:
4973 int atexit (void (*)());
4975 We build up the argument types and then then function type
4977 fn_type
= build_function_type (void_type_node
, void_list_node
);
4978 fn_ptr_type
= build_pointer_type (fn_type
);
4979 arg_types
= tree_cons (NULL_TREE
, fn_ptr_type
, void_list_node
);
4980 /* Build the final atexit type. */
4981 fn_type
= build_function_type (integer_type_node
, arg_types
);
4985 /* Now, build the function declaration. */
4986 push_lang_context (lang_name_c
);
4987 atexit_fndecl
= build_library_fn_ptr (name
, fn_type
);
4988 mark_used (atexit_fndecl
);
4989 pop_lang_context ();
4990 atexit_node
= decay_conversion (atexit_fndecl
);
4995 /* Returns the __dso_handle VAR_DECL. */
4998 get_dso_handle_node (void)
5000 if (dso_handle_node
)
5001 return dso_handle_node
;
5003 /* Declare the variable. */
5004 dso_handle_node
= declare_global_var (get_identifier ("__dso_handle"),
5007 return dso_handle_node
;
5010 /* Begin a new function with internal linkage whose job will be simply
5011 to destroy some particular variable. */
5013 static GTY(()) int start_cleanup_cnt
;
5016 start_cleanup_fn (void)
5018 int old_interface_only
= interface_only
;
5019 int old_interface_unknown
= interface_unknown
;
5025 push_to_top_level ();
5027 /* No need to mangle this. */
5028 push_lang_context (lang_name_c
);
5031 interface_unknown
= 1;
5033 /* Build the parameter-types. */
5034 parmtypes
= void_list_node
;
5035 /* Functions passed to __cxa_atexit take an additional parameter.
5036 We'll just ignore it. After we implement the new calling
5037 convention for destructors, we can eliminate the use of
5038 additional cleanup functions entirely in the -fnew-abi case. */
5039 if (flag_use_cxa_atexit
)
5040 parmtypes
= tree_cons (NULL_TREE
, ptr_type_node
, parmtypes
);
5041 /* Build the function type itself. */
5042 fntype
= build_function_type (void_type_node
, parmtypes
);
5043 /* Build the name of the function. */
5044 sprintf (name
, "__tcf_%d", start_cleanup_cnt
++);
5045 /* Build the function declaration. */
5046 fndecl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), fntype
);
5047 /* It's a function with internal linkage, generated by the
5049 TREE_PUBLIC (fndecl
) = 0;
5050 DECL_ARTIFICIAL (fndecl
) = 1;
5051 /* Make the function `inline' so that it is only emitted if it is
5052 actually needed. It is unlikely that it will be inlined, since
5053 it is only called via a function pointer, but we avoid unnecessary
5054 emissions this way. */
5055 DECL_INLINE (fndecl
) = 1;
5056 DECL_DECLARED_INLINE_P (fndecl
) = 1;
5057 DECL_INTERFACE_KNOWN (fndecl
) = 1;
5058 /* Build the parameter. */
5059 if (flag_use_cxa_atexit
)
5063 parmdecl
= cp_build_parm_decl (NULL_TREE
, ptr_type_node
);
5064 DECL_CONTEXT (parmdecl
) = fndecl
;
5065 TREE_USED (parmdecl
) = 1;
5066 DECL_ARGUMENTS (fndecl
) = parmdecl
;
5070 start_preparsed_function (fndecl
, NULL_TREE
, SF_PRE_PARSED
);
5072 interface_unknown
= old_interface_unknown
;
5073 interface_only
= old_interface_only
;
5075 pop_lang_context ();
5077 return current_function_decl
;
5080 /* Finish the cleanup function begun by start_cleanup_fn. */
5083 end_cleanup_fn (void)
5085 expand_or_defer_fn (finish_function (0));
5087 pop_from_top_level ();
5090 /* Generate code to handle the destruction of DECL, an object with
5091 static storage duration. */
5094 register_dtor_fn (tree decl
)
5101 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
5104 /* Call build_cleanup before we enter the anonymous function so that
5105 any access checks will be done relative to the current scope,
5106 rather than the scope of the anonymous function. */
5107 build_cleanup (decl
);
5109 /* Now start the function. */
5110 cleanup
= start_cleanup_fn ();
5112 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
5113 to the original function, rather than the anonymous one. That
5114 will make the back-end think that nested functions are in use,
5115 which causes confusion. */
5117 push_deferring_access_checks (dk_no_check
);
5118 fcall
= build_cleanup (decl
);
5119 pop_deferring_access_checks ();
5121 /* Create the body of the anonymous function. */
5122 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
5123 finish_expr_stmt (fcall
);
5124 finish_compound_stmt (compound_stmt
);
5127 /* Call atexit with the cleanup function. */
5128 cxx_mark_addressable (cleanup
);
5129 mark_used (cleanup
);
5130 cleanup
= build_unary_op (ADDR_EXPR
, cleanup
, 0);
5131 if (flag_use_cxa_atexit
)
5133 args
= tree_cons (NULL_TREE
,
5134 build_unary_op (ADDR_EXPR
, get_dso_handle_node (), 0),
5136 args
= tree_cons (NULL_TREE
, null_pointer_node
, args
);
5137 args
= tree_cons (NULL_TREE
, cleanup
, args
);
5140 args
= tree_cons (NULL_TREE
, cleanup
, NULL_TREE
);
5141 finish_expr_stmt (build_function_call (get_atexit_node (), args
));
5144 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
5145 is its initializer. Generate code to handle the construction
5146 and destruction of DECL. */
5149 expand_static_init (tree decl
, tree init
)
5151 my_friendly_assert (TREE_CODE (decl
) == VAR_DECL
, 20021010);
5152 my_friendly_assert (TREE_STATIC (decl
), 20021010);
5154 /* Some variables require no initialization. */
5156 && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
))
5157 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
5160 if (! toplevel_bindings_p ())
5162 /* Emit code to perform this initialization but once. */
5169 /* Emit code to perform this initialization but once. This code
5172 static int guard = 0;
5174 // Do initialization.
5176 // Register variable for destruction at end of program.
5179 Note that the `temp' variable is only set to 1 *after* the
5180 initialization is complete. This ensures that an exception,
5181 thrown during the construction, will cause the variable to
5182 reinitialized when we pass through this code again, as per:
5186 If the initialization exits by throwing an exception, the
5187 initialization is not complete, so it will be tried again
5188 the next time control enters the declaration.
5190 In theory, this process should be thread-safe, too; multiple
5191 threads should not be able to initialize the variable more
5192 than once. We don't yet attempt to ensure thread-safety. */
5194 /* Create the guard variable. */
5195 guard
= get_guard (decl
);
5197 /* Begin the conditional initialization. */
5198 if_stmt
= begin_if_stmt ();
5199 finish_if_stmt_cond (get_guard_cond (guard
), if_stmt
);
5200 then_clause
= begin_compound_stmt (0);
5202 /* Do the initialization itself. */
5203 assignment
= init
? init
: NULL_TREE
;
5205 /* Once the assignment is complete, set TEMP to 1. Since the
5206 construction of the static object is complete at this point,
5207 we want to make sure TEMP is set to 1 even if a temporary
5208 constructed during the initialization throws an exception
5209 when it is destroyed. So, we combine the initialization and
5210 the assignment to TEMP into a single expression, ensuring
5211 that when we call finish_expr_stmt the cleanups will not be
5212 run until after TEMP is set to 1. */
5213 guard_init
= set_guard (guard
);
5215 assignment
= build_compound_expr (assignment
, guard_init
);
5217 assignment
= guard_init
;
5218 finish_expr_stmt (assignment
);
5220 /* Use atexit to register a function for destroying this static
5222 register_dtor_fn (decl
);
5224 finish_compound_stmt (then_clause
);
5225 finish_then_clause (if_stmt
);
5226 finish_if_stmt (if_stmt
);
5229 static_aggregates
= tree_cons (init
, decl
, static_aggregates
);
5233 /* Make TYPE a complete type based on INITIAL_VALUE.
5234 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
5235 2 if there was no information (in which case assume 0 if DO_DEFAULT). */
5238 complete_array_type (tree type
, tree initial_value
, int do_default
)
5240 tree maxindex
= NULL_TREE
;
5245 /* An array of character type can be initialized from a
5246 brace-enclosed string constant. */
5247 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type
)))
5248 && TREE_CODE (initial_value
) == CONSTRUCTOR
5249 && CONSTRUCTOR_ELTS (initial_value
)
5250 && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value
)))
5252 && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value
)) == NULL_TREE
)
5253 initial_value
= TREE_VALUE (CONSTRUCTOR_ELTS (initial_value
));
5255 /* Note MAXINDEX is really the maximum index, one less than the
5257 if (TREE_CODE (initial_value
) == STRING_CST
)
5260 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value
)));
5261 maxindex
= build_int_2 ((TREE_STRING_LENGTH (initial_value
)
5264 else if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
5266 tree elts
= CONSTRUCTOR_ELTS (initial_value
);
5268 maxindex
= ssize_int (-1);
5269 for (; elts
; elts
= TREE_CHAIN (elts
))
5271 if (TREE_PURPOSE (elts
))
5272 maxindex
= TREE_PURPOSE (elts
);
5274 maxindex
= size_binop (PLUS_EXPR
, maxindex
, ssize_int (1));
5276 maxindex
= copy_node (maxindex
);
5280 /* Make an error message unless that happened already. */
5281 if (initial_value
!= error_mark_node
)
5284 initial_value
= NULL_TREE
;
5286 /* Prevent further error messages. */
5287 maxindex
= build_int_2 (0, 0);
5294 maxindex
= build_int_2 (0, 0);
5304 domain
= build_index_type (maxindex
);
5305 TYPE_DOMAIN (type
) = domain
;
5307 if (! TREE_TYPE (maxindex
))
5308 TREE_TYPE (maxindex
) = domain
;
5310 itype
= TREE_TYPE (initial_value
);
5313 if (itype
&& !TYPE_DOMAIN (itype
))
5314 TYPE_DOMAIN (itype
) = domain
;
5315 /* The type of the main variant should never be used for arrays
5316 of different sizes. It should only ever be completed with the
5317 size of the array. */
5318 if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)))
5319 TYPE_DOMAIN (TYPE_MAIN_VARIANT (type
)) = domain
;
5321 elt_type
= TREE_TYPE (type
);
5322 TYPE_NEEDS_CONSTRUCTING (type
)
5323 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type
));
5324 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
5325 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type
));
5328 /* Lay out the type now that we can get the real answer. */
5335 /* Return zero if something is declared to be a member of type
5336 CTYPE when in the context of CUR_TYPE. STRING is the error
5337 message to print in that case. Otherwise, quietly return 1. */
5340 member_function_or_else (tree ctype
, tree cur_type
, enum overload_flags flags
)
5342 if (ctype
&& ctype
!= cur_type
)
5344 if (flags
== DTOR_FLAG
)
5345 error ("destructor for alien class `%T' cannot be a member",
5348 error ("constructor for alien class `%T' cannot be a member",
5355 /* Subroutine of `grokdeclarator'. */
5357 /* Generate errors possibly applicable for a given set of specifiers.
5358 This is for ARM $7.1.2. */
5361 bad_specifiers (tree object
,
5370 error ("`%D' declared as a `virtual' %s", object
, type
);
5372 error ("`%D' declared as an `inline' %s", object
, type
);
5374 error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
5377 cp_error_at ("`%D' declared as a friend", object
);
5379 && (TREE_CODE (object
) == TYPE_DECL
5380 || (!TYPE_PTRFN_P (TREE_TYPE (object
))
5381 && !TYPE_REFFN_P (TREE_TYPE (object
))
5382 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object
)))))
5383 cp_error_at ("`%D' declared with an exception specification", object
);
5386 /* CTYPE is class type, or null if non-class.
5387 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
5389 DECLARATOR is the function's name.
5390 PARMS is a chain of PARM_DECLs for the function.
5391 VIRTUALP is truthvalue of whether the function is virtual or not.
5392 FLAGS are to be passed through to `grokclassfn'.
5393 QUALS are qualifiers indicating whether the function is `const'
5395 RAISES is a list of exceptions that this function can raise.
5396 CHECK is 1 if we must find this method in CTYPE, 0 if we should
5397 not look, and -1 if we should not call `grokclassfn' at all.
5399 Returns `NULL_TREE' if something goes wrong, after issuing
5400 applicable error messages. */
5403 grokfndecl (tree ctype
,
5407 tree orig_declarator
,
5409 enum overload_flags flags
,
5421 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
5422 int has_default_arg
= 0;
5426 type
= build_exception_variant (type
, raises
);
5428 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
5429 DECL_ARGUMENTS (decl
) = parms
;
5430 /* Propagate volatile out from type to decl. */
5431 if (TYPE_VOLATILE (type
))
5432 TREE_THIS_VOLATILE (decl
) = 1;
5434 /* If this decl has namespace scope, set that up. */
5436 set_decl_namespace (decl
, in_namespace
, friendp
);
5438 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
5440 /* `main' and builtins have implicit 'C' linkage. */
5441 if ((MAIN_NAME_P (declarator
)
5442 || (IDENTIFIER_LENGTH (declarator
) > 10
5443 && IDENTIFIER_POINTER (declarator
)[0] == '_'
5444 && IDENTIFIER_POINTER (declarator
)[1] == '_'
5445 && strncmp (IDENTIFIER_POINTER (declarator
)+2, "builtin_", 8) == 0))
5446 && current_lang_name
== lang_name_cplusplus
5447 && ctype
== NULL_TREE
5448 /* NULL_TREE means global namespace. */
5449 && DECL_CONTEXT (decl
) == NULL_TREE
)
5450 SET_DECL_LANGUAGE (decl
, lang_c
);
5452 /* Should probably propagate const out from type to decl I bet (mrs). */
5455 DECL_STATIC_FUNCTION_P (decl
) = 1;
5456 DECL_CONTEXT (decl
) = ctype
;
5460 DECL_CONTEXT (decl
) = ctype
;
5462 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
5464 if (processing_template_decl
)
5465 error ("cannot declare `::main' to be a template");
5467 error ("cannot declare `::main' to be inline");
5469 error ("cannot declare `::main' to be static");
5470 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
5472 error ("`main' must return `int'");
5477 /* Members of anonymous types and local classes have no linkage; make
5478 them internal. If a typedef is made later, this will be changed. */
5479 if (ctype
&& (TYPE_ANONYMOUS_P (ctype
)
5480 || decl_function_context (TYPE_MAIN_DECL (ctype
))))
5485 /* [basic.link]: A name with no linkage (notably, the name of a class
5486 or enumeration declared in a local scope) shall not be used to
5487 declare an entity with linkage.
5489 Only check this for public decls for now. See core 319, 389. */
5490 t
= no_linkage_check (TREE_TYPE (decl
),
5491 /*relaxed_p=*/false);
5494 if (TYPE_ANONYMOUS_P (t
))
5496 if (DECL_EXTERN_C_P (decl
))
5497 /* Allow this; it's pretty common in C. */;
5500 pedwarn ("non-local function `%#D' uses anonymous type",
5502 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
5504 `%#D' does not refer to the unqualified type, so it is not used for linkage",
5509 pedwarn ("non-local function `%#D' uses local type `%T'",
5514 TREE_PUBLIC (decl
) = publicp
;
5517 DECL_INTERFACE_KNOWN (decl
) = 1;
5518 DECL_NOT_REALLY_EXTERN (decl
) = 1;
5521 /* If the declaration was declared inline, mark it as such. */
5523 DECL_DECLARED_INLINE_P (decl
) = 1;
5524 /* We inline functions that are explicitly declared inline, or, when
5525 the user explicitly asks us to, all functions. */
5526 if (DECL_DECLARED_INLINE_P (decl
)
5527 || (flag_inline_trees
== 2 && !DECL_INLINE (decl
) && funcdef_flag
))
5528 DECL_INLINE (decl
) = 1;
5530 DECL_EXTERNAL (decl
) = 1;
5531 if (quals
&& TREE_CODE (type
) == FUNCTION_TYPE
)
5533 error ("%smember function `%D' cannot have cv-qualifier",
5534 (ctype
? "static " : "non-"), decl
);
5535 quals
= TYPE_UNQUALIFIED
;
5538 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
)))
5539 grok_op_properties (decl
, friendp
, /*complain=*/true);
5541 if (ctype
&& decl_function_context (decl
))
5542 DECL_NO_STATIC_CHAIN (decl
) = 1;
5544 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
5545 if (TREE_PURPOSE (t
)
5546 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
5548 has_default_arg
= 1;
5553 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
5557 ("defining explicit specialization `%D' in friend declaration",
5561 tree fns
= TREE_OPERAND (orig_declarator
, 0);
5562 tree args
= TREE_OPERAND (orig_declarator
, 1);
5564 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
5566 /* Something like `template <class T> friend void f<T>()'. */
5567 error ("invalid use of template-id `%D' in declaration of primary template",
5573 /* A friend declaration of the form friend void f<>(). Record
5574 the information in the TEMPLATE_ID_EXPR. */
5575 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
5577 if (TREE_CODE (fns
) == COMPONENT_REF
)
5579 /* Due to bison parser ickiness, we will have already looked
5580 up an operator_name or PFUNCNAME within the current class
5581 (see template_id in parse.y). If the current class contains
5582 such a name, we'll get a COMPONENT_REF here. Undo that. */
5584 my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns
, 0))
5585 == current_class_type
, 20001120);
5586 fns
= TREE_OPERAND (fns
, 1);
5588 my_friendly_assert (TREE_CODE (fns
) == IDENTIFIER_NODE
5589 || TREE_CODE (fns
) == OVERLOAD
, 20001120);
5590 DECL_TEMPLATE_INFO (decl
) = tree_cons (fns
, args
, NULL_TREE
);
5592 if (has_default_arg
)
5594 error ("default arguments are not allowed in declaration of friend template specialization `%D'",
5601 error ("`inline' is not allowed in declaration of friend template specialization `%D'",
5609 /* Make the init_value nonzero so pushdecl knows this is not
5610 tentative. error_mark_node is replaced later with the BLOCK. */
5611 DECL_INITIAL (decl
) = error_mark_node
;
5613 if (TYPE_NOTHROW_P (type
) || nothrow_libfn_p (decl
))
5614 TREE_NOTHROW (decl
) = 1;
5616 /* Caller will do the rest of this. */
5620 if (flags
== NO_SPECIAL
&& ctype
&& constructor_name_p (declarator
, ctype
))
5621 DECL_CONSTRUCTOR_P (decl
) = 1;
5623 /* Function gets the ugly name, field gets the nice one. This call
5624 may change the type of the function (because of default
5626 if (ctype
!= NULL_TREE
)
5627 grokclassfn (ctype
, decl
, flags
, quals
);
5629 decl
= check_explicit_specialization (orig_declarator
, decl
,
5631 2 * (funcdef_flag
!= 0) +
5632 4 * (friendp
!= 0));
5633 if (decl
== error_mark_node
)
5636 if (ctype
!= NULL_TREE
5637 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
5642 old_decl
= check_classfn (ctype
, decl
,
5643 (processing_template_decl
5644 > template_class_depth (ctype
))
5645 ? current_template_parms
5648 if (old_decl
&& TREE_CODE (old_decl
) == TEMPLATE_DECL
)
5649 /* Because grokfndecl is always supposed to return a
5650 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
5651 here. We depend on our callers to figure out that its
5652 really a template that's being returned. */
5653 old_decl
= DECL_TEMPLATE_RESULT (old_decl
);
5655 if (old_decl
&& DECL_STATIC_FUNCTION_P (old_decl
)
5656 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
5657 /* Remove the `this' parm added by grokclassfn.
5658 XXX Isn't this done in start_function, too? */
5659 revert_static_member_fn (decl
);
5660 if (old_decl
&& DECL_ARTIFICIAL (old_decl
))
5661 error ("definition of implicitly-declared `%D'", old_decl
);
5668 /* Since we've smashed OLD_DECL to its
5669 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
5670 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
5671 decl
= DECL_TEMPLATE_RESULT (decl
);
5673 /* Attempt to merge the declarations. This can fail, in
5674 the case of some invalid specialization declarations. */
5675 pop_p
= push_scope (ctype
);
5676 ok
= duplicate_decls (decl
, old_decl
);
5681 error ("no `%#D' member function declared in class `%T'",
5689 if (DECL_CONSTRUCTOR_P (decl
) && !grok_ctor_properties (ctype
, decl
))
5692 if (ctype
== NULL_TREE
|| check
)
5696 DECL_VIRTUAL_P (decl
) = 1;
5701 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
5702 the linkage that DECL will receive in the object file. */
5705 set_linkage_for_static_data_member (tree decl
)
5707 /* A static data member always has static storage duration and
5708 external linkage. Note that static data members are forbidden in
5709 local classes -- the only situation in which a class has
5710 non-external linkage. */
5711 TREE_PUBLIC (decl
) = 1;
5712 TREE_STATIC (decl
) = 1;
5713 /* For non-template classes, static data members are always put
5714 out in exactly those files where they are defined, just as
5715 with ordinarly namespace-scope variables. */
5716 if (!processing_template_decl
)
5717 DECL_INTERFACE_KNOWN (decl
) = 1;
5720 /* Create a VAR_DECL named NAME with the indicated TYPE.
5722 If SCOPE is non-NULL, it is the class type or namespace containing
5723 the variable. If SCOPE is NULL, the variable should is created in
5724 the innermost enclosings scope. */
5727 grokvardecl (tree type
,
5729 const cp_decl_specifier_seq
*declspecs
,
5736 my_friendly_assert (!name
|| TREE_CODE (name
) == IDENTIFIER_NODE
,
5739 /* Compute the scope in which to place the variable. */
5742 /* An explicit "extern" specifier indicates a namespace-scope
5744 if (declspecs
->storage_class
== sc_extern
)
5745 scope
= current_namespace
;
5746 else if (!at_function_scope_p ())
5748 scope
= current_scope ();
5750 scope
= current_namespace
;
5755 && (/* If the variable is a namespace-scope variable declared in a
5756 template, we need DECL_LANG_SPECIFIC. */
5757 (TREE_CODE (scope
) == NAMESPACE_DECL
&& processing_template_decl
)
5758 /* Similarly for namespace-scope variables with language linkage
5760 || (TREE_CODE (scope
) == NAMESPACE_DECL
5761 && current_lang_name
!= lang_name_cplusplus
)
5762 /* Similarly for static data members. */
5764 decl
= build_lang_decl (VAR_DECL
, name
, type
);
5766 decl
= build_decl (VAR_DECL
, name
, type
);
5768 if (scope
&& TREE_CODE (scope
) == NAMESPACE_DECL
)
5769 set_decl_namespace (decl
, scope
, 0);
5771 DECL_CONTEXT (decl
) = scope
;
5773 if (declspecs
->storage_class
== sc_extern
)
5775 DECL_THIS_EXTERN (decl
) = 1;
5776 DECL_EXTERNAL (decl
) = !initialized
;
5779 if (DECL_CLASS_SCOPE_P (decl
))
5781 set_linkage_for_static_data_member (decl
);
5782 /* This function is only called with out-of-class definitions. */
5783 DECL_EXTERNAL (decl
) = 0;
5785 /* At top level, either `static' or no s.c. makes a definition
5786 (perhaps tentative), and absence of `static' makes it public. */
5787 else if (toplevel_bindings_p ())
5789 TREE_PUBLIC (decl
) = (declspecs
->storage_class
!= sc_static
5790 && (DECL_THIS_EXTERN (decl
) || ! constp
));
5791 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
5793 /* Not at top level, only `static' makes a static definition. */
5796 TREE_STATIC (decl
) = declspecs
->storage_class
== sc_static
;
5797 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
5800 if (declspecs
->specs
[(int)ds_thread
])
5802 if (targetm
.have_tls
)
5803 DECL_THREAD_LOCAL (decl
) = 1;
5805 /* A mere warning is sure to result in improper semantics
5806 at runtime. Don't bother to allow this to compile. */
5807 error ("thread-local storage not supported for this target");
5810 if (TREE_PUBLIC (decl
))
5812 /* [basic.link]: A name with no linkage (notably, the name of a class
5813 or enumeration declared in a local scope) shall not be used to
5814 declare an entity with linkage.
5816 Only check this for public decls for now. */
5817 tree t
= no_linkage_check (TREE_TYPE (decl
),
5818 /*relaxed_p=*/false);
5821 if (TYPE_ANONYMOUS_P (t
))
5823 if (DECL_EXTERN_C_P (decl
))
5824 /* Allow this; it's pretty common in C. */;
5827 pedwarn ("non-local variable `%#D' uses anonymous type",
5829 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
5831 `%#D' does not refer to the unqualified type, so it is not used for linkage",
5836 pedwarn ("non-local variable `%#D' uses local type `%T'",
5844 /* Create and return a canonical pointer to member function type, for
5845 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
5848 build_ptrmemfunc_type (tree type
)
5852 tree unqualified_variant
= NULL_TREE
;
5854 if (type
== error_mark_node
)
5857 /* If a canonical type already exists for this type, use it. We use
5858 this method instead of type_hash_canon, because it only does a
5859 simple equality check on the list of field members. */
5861 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
5864 /* Make sure that we always have the unqualified pointer-to-member
5866 if (cp_type_quals (type
) != TYPE_UNQUALIFIED
)
5868 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type
));
5870 t
= make_aggr_type (RECORD_TYPE
);
5871 xref_basetypes (t
, NULL_TREE
);
5873 /* Let the front-end know this is a pointer to member function... */
5874 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
5875 /* ... and not really an aggregate. */
5876 SET_IS_AGGR_TYPE (t
, 0);
5878 field
= build_decl (FIELD_DECL
, pfn_identifier
, type
);
5881 field
= build_decl (FIELD_DECL
, delta_identifier
, delta_type_node
);
5882 TREE_CHAIN (field
) = fields
;
5885 finish_builtin_struct (t
, "__ptrmemfunc_type", fields
, ptr_type_node
);
5887 /* Zap out the name so that the back-end will give us the debugging
5888 information for this anonymous RECORD_TYPE. */
5889 TYPE_NAME (t
) = NULL_TREE
;
5891 /* If this is not the unqualified form of this pointer-to-member
5892 type, set the TYPE_MAIN_VARIANT for this type to be the
5893 unqualified type. Since they are actually RECORD_TYPEs that are
5894 not variants of each other, we must do this manually. */
5895 if (cp_type_quals (type
) != TYPE_UNQUALIFIED
)
5897 t
= build_qualified_type (t
, cp_type_quals (type
));
5898 TYPE_MAIN_VARIANT (t
) = unqualified_variant
;
5899 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (unqualified_variant
);
5900 TYPE_NEXT_VARIANT (unqualified_variant
) = t
;
5903 /* Cache this pointer-to-member type so that we can find it again
5905 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
5910 /* Create and return a pointer to data member type. */
5913 build_ptrmem_type (tree class_type
, tree member_type
)
5915 if (TREE_CODE (member_type
) == METHOD_TYPE
)
5919 arg_types
= TYPE_ARG_TYPES (member_type
);
5920 class_type
= (cp_build_qualified_type
5922 cp_type_quals (TREE_TYPE (TREE_VALUE (arg_types
)))));
5924 = build_method_type_directly (class_type
,
5925 TREE_TYPE (member_type
),
5926 TREE_CHAIN (arg_types
));
5927 return build_ptrmemfunc_type (build_pointer_type (member_type
));
5931 my_friendly_assert (TREE_CODE (member_type
) != FUNCTION_TYPE
,
5933 return build_offset_type (class_type
, member_type
);
5937 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
5938 Check to see that the definition is valid. Issue appropriate error
5939 messages. Return 1 if the definition is particularly bad, or 0
5943 check_static_variable_definition (tree decl
, tree type
)
5945 /* Motion 10 at San Diego: If a static const integral data member is
5946 initialized with an integral constant expression, the initializer
5947 may appear either in the declaration (within the class), or in
5948 the definition, but not both. If it appears in the class, the
5949 member is a member constant. The file-scope definition is always
5951 if (!ARITHMETIC_TYPE_P (type
) && TREE_CODE (type
) != ENUMERAL_TYPE
)
5953 error ("invalid in-class initialization of static data member of non-integral type `%T'",
5955 /* If we just return the declaration, crashes will sometimes
5956 occur. We therefore return void_type_node, as if this were a
5957 friend declaration, to cause callers to completely ignore
5958 this declaration. */
5961 else if (!CP_TYPE_CONST_P (type
))
5962 error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
5964 else if (pedantic
&& !INTEGRAL_TYPE_P (type
))
5965 pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl
, type
);
5970 /* Given the SIZE (i.e., number of elements) in an array, compute an
5971 appropriate index type for the array. If non-NULL, NAME is the
5972 name of the thing being declared. */
5975 compute_array_index_type (tree name
, tree size
)
5977 tree type
= TREE_TYPE (size
);
5980 /* The array bound must be an integer type. */
5981 if (!dependent_type_p (type
) && !INTEGRAL_TYPE_P (type
))
5984 error ("size of array `%D' has non-integral type `%T'", name
, type
);
5986 error ("size of array has non-integral type `%T'", type
);
5987 size
= integer_one_node
;
5988 type
= TREE_TYPE (size
);
5991 if (abi_version_at_least (2)
5992 /* We should only handle value dependent expressions specially. */
5993 ? value_dependent_expression_p (size
)
5994 /* But for abi-1, we handled all instances in templates. This
5995 effects the manglings produced. */
5996 : processing_template_decl
)
5997 return build_index_type (build_min (MINUS_EXPR
, sizetype
,
5998 size
, integer_one_node
));
6000 /* The size might be the result of a cast. */
6001 STRIP_TYPE_NOPS (size
);
6003 /* It might be a const variable or enumeration constant. */
6004 size
= decl_constant_value (size
);
6006 /* Normally, the array-bound will be a constant. */
6007 if (TREE_CODE (size
) == INTEGER_CST
)
6009 /* Check to see if the array bound overflowed. Make that an
6010 error, no matter how generous we're being. */
6011 int old_flag_pedantic_errors
= flag_pedantic_errors
;
6012 int old_pedantic
= pedantic
;
6013 pedantic
= flag_pedantic_errors
= 1;
6014 constant_expression_warning (size
);
6015 pedantic
= old_pedantic
;
6016 flag_pedantic_errors
= old_flag_pedantic_errors
;
6018 /* An array must have a positive number of elements. */
6019 if (INT_CST_LT (size
, integer_zero_node
))
6022 error ("size of array `%D' is negative", name
);
6024 error ("size of array is negative");
6025 size
= integer_one_node
;
6027 /* As an extension we allow zero-sized arrays. We always allow
6028 them in system headers because glibc uses them. */
6029 else if (integer_zerop (size
) && pedantic
&& !in_system_header
)
6032 pedwarn ("ISO C++ forbids zero-size array `%D'", name
);
6034 pedwarn ("ISO C++ forbids zero-size array");
6037 else if (TREE_CONSTANT (size
))
6039 /* `(int) &fn' is not a valid array bound. */
6041 error ("size of array `%D' is not an integral constant-expression",
6044 error ("size of array is not an integral constant-expression");
6049 pedwarn ("ISO C++ forbids variable-size array `%D'", name
);
6051 pedwarn ("ISO C++ forbids variable-size array");
6054 if (processing_template_decl
&& !TREE_CONSTANT (size
))
6055 /* A variable sized array. */
6056 itype
= build_min (MINUS_EXPR
, sizetype
, size
, integer_one_node
);
6059 /* Compute the index of the largest element in the array. It is
6060 one less than the number of elements in the array. */
6062 = fold (cp_build_binary_op (MINUS_EXPR
,
6063 cp_convert (ssizetype
, size
),
6064 cp_convert (ssizetype
, integer_one_node
)));
6065 if (!TREE_CONSTANT (itype
))
6066 /* A variable sized array. */
6067 itype
= variable_size (itype
);
6068 /* Make sure that there was no overflow when creating to a signed
6069 index type. (For example, on a 32-bit machine, an array with
6070 size 2^32 - 1 is too big.) */
6071 else if (TREE_OVERFLOW (itype
))
6073 error ("overflow in array dimension");
6074 TREE_OVERFLOW (itype
) = 0;
6078 /* Create and return the appropriate index type. */
6079 return build_index_type (itype
);
6082 /* Returns the scope (if any) in which the entity declared by
6083 DECLARATOR will be located. If the entity was declared with an
6084 unqualified name, NULL_TREE is returned. */
6087 get_scope_of_declarator (const cp_declarator
*declarator
)
6089 while (declarator
&& declarator
->kind
!= cdk_id
)
6090 declarator
= declarator
->declarator
;
6092 /* If the declarator-id is a SCOPE_REF, the scope in which the
6093 declaration occurs is the first operand. */
6095 && declarator
->u
.id
.name
6096 && TREE_CODE (declarator
->u
.id
.name
) == SCOPE_REF
)
6097 return TREE_OPERAND (declarator
->u
.id
.name
, 0);
6099 /* Otherwise, the declarator is not a quablified name; the entity will
6100 be declared in the current scope. */
6104 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
6105 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
6109 create_array_type_for_decl (tree name
, tree type
, tree size
)
6111 tree itype
= NULL_TREE
;
6112 const char* error_msg
;
6114 /* If things have already gone awry, bail now. */
6115 if (type
== error_mark_node
|| size
== error_mark_node
)
6116 return error_mark_node
;
6118 /* Assume that everything will go OK. */
6121 /* There are some types which cannot be array elements. */
6122 switch (TREE_CODE (type
))
6125 error_msg
= "array of void";
6129 error_msg
= "array of functions";
6132 case REFERENCE_TYPE
:
6133 error_msg
= "array of references";
6137 error_msg
= "array of function members";
6144 /* If something went wrong, issue an error-message and return. */
6148 error ("declaration of `%D' as %s", name
, error_msg
);
6150 error ("creating %s", error_msg
);
6152 return error_mark_node
;
6157 The constant expressions that specify the bounds of the arrays
6158 can be omitted only for the first member of the sequence. */
6159 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
6162 error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
6165 error ("multidimensional array must have bounds for all dimensions except the first");
6167 return error_mark_node
;
6170 /* Figure out the index type for the array. */
6172 itype
= compute_array_index_type (name
, size
);
6175 T is called the array element type; this type shall not be [...] an
6176 abstract class type. */
6177 abstract_virtuals_error (name
, type
);
6179 return build_cplus_array_type (type
, itype
);
6182 /* Check that it's OK to declare a function with the indicated TYPE.
6183 SFK indicates the kind of special function (if any) that this
6184 function is. OPTYPE is the type given in a conversion operator
6185 declaration. Returns the actual return type of the function; that
6186 may be different than TYPE if an error occurs, or for certain
6187 special functions. */
6190 check_special_function_return_type (special_function_kind sfk
,
6196 case sfk_constructor
:
6198 error ("return type specification for constructor invalid");
6200 type
= void_type_node
;
6203 case sfk_destructor
:
6205 error ("return type specification for destructor invalid");
6206 type
= void_type_node
;
6209 case sfk_conversion
:
6210 if (type
&& !same_type_p (type
, optype
))
6211 error ("operator `%T' declared to return `%T'", optype
, type
);
6213 pedwarn ("return type specified for `operator %T'", optype
);
6225 /* Given declspecs and a declarator (abstract or otherwise), determine
6226 the name and type of the object declared and construct a DECL node
6229 DECLSPECS is a chain of tree_list nodes whose value fields
6230 are the storage classes and type specifiers.
6232 DECL_CONTEXT says which syntactic context this declaration is in:
6233 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
6234 FUNCDEF for a function definition. Like NORMAL but a few different
6235 error messages in each case. Return value may be zero meaning
6236 this definition is too screwy to try to parse.
6237 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
6238 handle member functions (which have FIELD context).
6239 Return value may be zero meaning this definition is too screwy to
6241 PARM for a parameter declaration (either within a function prototype
6242 or before a function body). Make a PARM_DECL, or return void_type_node.
6243 CATCHPARM for a parameter declaration before a catch clause.
6244 TYPENAME if for a typename (in a cast or sizeof).
6245 Don't make a DECL node; just return the ..._TYPE node.
6246 FIELD for a struct or union field; make a FIELD_DECL.
6247 BITFIELD for a field with specified width.
6248 INITIALIZED is 1 if the decl has an initializer.
6250 ATTRLIST is a pointer to the list of attributes, which may be NULL
6251 if there are none; *ATTRLIST may be modified if attributes from inside
6252 the declarator should be applied to the declaration.
6254 When this function is called, scoping variables (such as
6255 CURRENT_CLASS_TYPE) should reflect the scope in which the
6256 declaration occurs, not the scope in which the new declaration will
6257 be placed. For example, on:
6261 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
6262 should not be `S'. */
6265 grokdeclarator (const cp_declarator
*declarator
,
6266 const cp_decl_specifier_seq
*declspecs
,
6267 enum decl_context decl_context
,
6271 tree type
= NULL_TREE
;
6274 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
6275 int explicit_int
= 0;
6276 int explicit_char
= 0;
6277 int defaulted_int
= 0;
6278 tree dependant_name
= NULL_TREE
;
6280 tree typedef_decl
= NULL_TREE
;
6281 const char *name
= NULL
;
6282 tree typedef_type
= NULL_TREE
;
6283 int funcdef_flag
= 0;
6284 cp_declarator_kind innermost_code
= cdk_error
;
6287 /* See the code below that used this. */
6288 tree decl_attr
= NULL_TREE
;
6291 /* Keep track of what sort of function is being processed
6292 so that we can warn about default return values, or explicit
6293 return values which do not match prescribed defaults. */
6294 special_function_kind sfk
= sfk_none
;
6296 tree dname
= NULL_TREE
;
6297 tree ctor_return_type
= NULL_TREE
;
6298 enum overload_flags flags
= NO_SPECIAL
;
6299 cp_cv_quals quals
= TYPE_UNQUALIFIED
;
6300 tree raises
= NULL_TREE
;
6301 int template_count
= 0;
6302 tree returned_attrs
= NULL_TREE
;
6303 tree parms
= NULL_TREE
;
6304 const cp_declarator
*id_declarator
;
6305 /* The unqualified name of the declarator; either an
6306 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
6307 tree unqualified_id
;
6308 /* The class type, if any, in which this entity is located,
6309 or NULL_TREE if none. Note that this value may be different from
6310 the current class type; for example if an attempt is made to declare
6311 "A::f" inside "B", this value will be "A". */
6312 tree ctype
= current_class_type
;
6313 /* The NAMESPACE_DECL for the namespace in which this entity is
6314 located. If an unqualified name is used to declare the entity,
6315 this value will be NULL_TREE, even if the entity is located at
6317 tree in_namespace
= NULL_TREE
;
6319 cp_storage_class storage_class
;
6320 bool unsigned_p
, signed_p
, short_p
, long_p
, thread_p
;
6322 signed_p
= declspecs
->specs
[(int)ds_signed
];
6323 unsigned_p
= declspecs
->specs
[(int)ds_unsigned
];
6324 short_p
= declspecs
->specs
[(int)ds_short
];
6325 long_p
= declspecs
->specs
[(int)ds_long
];
6326 thread_p
= declspecs
->specs
[(int)ds_thread
];
6328 if (decl_context
== FUNCDEF
)
6329 funcdef_flag
= 1, decl_context
= NORMAL
;
6330 else if (decl_context
== MEMFUNCDEF
)
6331 funcdef_flag
= -1, decl_context
= FIELD
;
6332 else if (decl_context
== BITFIELD
)
6333 bitfield
= 1, decl_context
= FIELD
;
6335 /* Look inside a declarator for the name being declared
6336 and get it as a string, for an error message. */
6337 for (id_declarator
= declarator
;
6339 id_declarator
= id_declarator
->declarator
)
6341 if (id_declarator
->kind
!= cdk_id
)
6342 innermost_code
= id_declarator
->kind
;
6344 switch (id_declarator
->kind
)
6347 if (id_declarator
->declarator
6348 && id_declarator
->declarator
->kind
== cdk_id
)
6350 sfk
= id_declarator
->declarator
->u
.id
.sfk
;
6351 if (sfk
== sfk_destructor
)
6358 tree decl
= id_declarator
->u
.id
.name
;
6361 if (TREE_CODE (decl
) == SCOPE_REF
)
6363 tree qualifying_scope
= TREE_OPERAND (decl
, 0);
6365 /* It is valid to write:
6367 class C { void f(); };
6371 The standard is not clear about whether `typedef const C D' is
6372 legal; as of 2002-09-15 the committee is considering
6373 that question. EDG 3.0 allows that syntax.
6374 Therefore, we do as well. */
6375 if (qualifying_scope
&& TYPE_P (qualifying_scope
))
6377 ctype
= TYPE_MAIN_VARIANT (qualifying_scope
);
6378 if (innermost_code
!= cdk_function
6379 && current_class_type
6380 && !UNIQUELY_DERIVED_FROM_P (ctype
,
6381 current_class_type
))
6383 error ("type `%T' is not derived from type `%T'",
6384 ctype
, current_class_type
);
6387 TREE_OPERAND (decl
, 0) = ctype
;
6389 else if (TREE_CODE (qualifying_scope
) == NAMESPACE_DECL
)
6390 in_namespace
= qualifying_scope
;
6391 decl
= TREE_OPERAND (decl
, 1);
6393 if (TREE_CODE (decl
) == BASELINK
)
6394 decl
= BASELINK_FUNCTIONS (decl
);
6395 if (decl
== error_mark_node
)
6396 return error_mark_node
;
6397 switch (TREE_CODE (decl
))
6401 tree type
= TREE_OPERAND (decl
, 0);
6402 type
= constructor_name (type
);
6403 name
= IDENTIFIER_POINTER (type
);
6407 case TEMPLATE_ID_EXPR
:
6409 tree fns
= TREE_OPERAND (decl
, 0);
6412 if (TREE_CODE (dname
) == COMPONENT_REF
)
6413 dname
= TREE_OPERAND (dname
, 1);
6414 if (TREE_CODE (dname
) != IDENTIFIER_NODE
)
6416 my_friendly_assert (is_overloaded_fn (dname
),
6418 dname
= DECL_NAME (get_first_fn (dname
));
6423 case IDENTIFIER_NODE
:
6424 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
6427 if (C_IS_RESERVED_WORD (dname
))
6429 error ("declarator-id missing; using reserved word `%D'",
6431 name
= IDENTIFIER_POINTER (dname
);
6433 else if (!IDENTIFIER_TYPENAME_P (dname
))
6434 name
= IDENTIFIER_POINTER (dname
);
6437 my_friendly_assert (flags
== NO_SPECIAL
, 154);
6438 flags
= TYPENAME_FLAG
;
6439 ctor_return_type
= TREE_TYPE (dname
);
6440 sfk
= sfk_conversion
;
6441 if (is_typename_at_global_scope (dname
))
6442 name
= IDENTIFIER_POINTER (dname
);
6444 name
= "<invalid operator>";
6449 dname
= constructor_name (TREE_TYPE (decl
));
6450 name
= IDENTIFIER_POINTER (dname
);
6471 if (id_declarator
->kind
== cdk_id
)
6475 /* A function definition's declarator must have the form of
6476 a function declarator. */
6478 if (funcdef_flag
&& innermost_code
!= cdk_function
)
6481 if (((dname
&& IDENTIFIER_OPNAME_P (dname
)) || flags
== TYPENAME_FLAG
)
6482 && innermost_code
!= cdk_function
6483 && ! (ctype
&& !declspecs
->any_specifiers_p
))
6485 error ("declaration of `%D' as non-function", dname
);
6486 return void_type_node
;
6489 /* Anything declared one level down from the top level
6490 must be one of the parameters of a function
6491 (because the body is at least two levels down). */
6493 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
6494 by not allowing C++ class definitions to specify their parameters
6495 with xdecls (must be spec.d in the parmlist).
6497 Since we now wait to push a class scope until we are sure that
6498 we are in a legitimate method context, we must set oldcname
6499 explicitly (since current_class_name is not yet alive).
6501 We also want to avoid calling this a PARM if it is in a namespace. */
6503 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
6505 struct cp_binding_level
*b
= current_binding_level
;
6506 current_binding_level
= b
->level_chain
;
6507 if (current_binding_level
!= 0 && toplevel_bindings_p ())
6508 decl_context
= PARM
;
6509 current_binding_level
= b
;
6513 name
= decl_context
== PARM
? "parameter" : "type name";
6515 /* If there were multiple types specified in the decl-specifier-seq,
6516 issue an error message. */
6517 if (declspecs
->multiple_types_p
)
6518 error ("two or more data types in declaration of `%s'", name
);
6519 /* Extract the basic type from the decl-specifier-seq. */
6520 type
= declspecs
->type
;
6521 if (type
== error_mark_node
)
6523 /* If the entire declaration is itself tagged as deprecated then
6524 suppress reports of deprecated items. */
6525 if (type
&& TREE_DEPRECATED (type
)
6526 && deprecated_state
!= DEPRECATED_SUPPRESS
)
6527 warn_deprecated_use (type
);
6528 if (type
&& TREE_CODE (type
) == TYPE_DECL
)
6530 typedef_decl
= type
;
6531 type
= TREE_TYPE (typedef_decl
);
6533 /* No type at all: default to `int', and set DEFAULTED_INT
6534 because it was not a user-defined typedef. */
6535 if (type
== NULL_TREE
&& (signed_p
|| unsigned_p
|| long_p
|| short_p
))
6537 /* These imply 'int'. */
6538 type
= integer_type_node
;
6542 explicit_int
= declspecs
->explicit_int_p
;
6543 explicit_char
= declspecs
->explicit_char_p
;
6545 /* Check for repeated decl-specifiers. */
6546 for (ds
= ds_first
; ds
!= ds_last
; ++ds
)
6548 unsigned count
= declspecs
->specs
[(int)ds
];
6551 /* The "long" specifier is a special case because of
6556 error ("`long long long' is too long for GCC");
6557 else if (pedantic
&& !in_system_header
&& warn_long_long
)
6558 pedwarn ("ISO C++ does not support `long long'");
6562 else if (declspecs
->specs
[(int)ds
] > 1)
6564 static const char *const decl_spec_names
[] = {
6580 error ("duplicate `%s'", decl_spec_names
[(int)ds
]);
6585 /* See the code below that used this. */
6587 decl_attr
= DECL_ATTRIBUTES (typedef_decl
);
6589 typedef_type
= type
;
6592 if (sfk
!= sfk_none
)
6593 type
= check_special_function_return_type (sfk
, type
,
6595 else if (type
== NULL_TREE
)
6601 /* We handle `main' specially here, because 'main () { }' is so
6602 common. With no options, it is allowed. With -Wreturn-type,
6603 it is a warning. It is only an error with -pedantic-errors. */
6604 is_main
= (funcdef_flag
6605 && dname
&& MAIN_NAME_P (dname
)
6606 && ctype
== NULL_TREE
6607 && in_namespace
== NULL_TREE
6608 && current_namespace
== global_namespace
);
6610 if (in_system_header
|| flag_ms_extensions
)
6611 /* Allow it, sigh. */;
6612 else if (pedantic
|| ! is_main
)
6613 pedwarn ("ISO C++ forbids declaration of `%s' with no type",
6615 else if (warn_return_type
)
6616 warning ("ISO C++ forbids declaration of `%s' with no type",
6619 type
= integer_type_node
;
6624 /* Now process the modifiers that were specified
6625 and check for invalid combinations. */
6627 /* Long double is a special combination. */
6628 if (long_p
&& TYPE_MAIN_VARIANT (type
) == double_type_node
)
6631 type
= build_qualified_type (long_double_type_node
,
6632 cp_type_quals (type
));
6635 /* Check all other uses of type modifiers. */
6637 if (unsigned_p
|| signed_p
|| long_p
|| short_p
)
6641 if (TREE_CODE (type
) == REAL_TYPE
)
6642 error ("short, signed or unsigned invalid for `%s'", name
);
6643 else if (TREE_CODE (type
) != INTEGER_TYPE
)
6644 error ("long, short, signed or unsigned invalid for `%s'", name
);
6645 else if (long_p
&& short_p
)
6646 error ("long and short specified together for `%s'", name
);
6647 else if ((long_p
|| short_p
) && explicit_char
)
6648 error ("long or short specified with char for `%s'", name
);
6649 else if ((long_p
|| short_p
) && TREE_CODE (type
) == REAL_TYPE
)
6650 error ("long or short specified with floating type for `%s'", name
);
6651 else if (signed_p
&& unsigned_p
)
6652 error ("signed and unsigned given together for `%s'", name
);
6656 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& pedantic
)
6658 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
6660 if (flag_pedantic_errors
)
6665 /* Discard the type modifiers if they are invalid. */
6676 /* Decide whether an integer type is signed or not.
6677 Optionally treat bitfields as signed by default. */
6681 It is implementation-defined whether a plain (neither
6682 explicitly signed or unsigned) char, short, int, or long
6683 bit-field is signed or unsigned.
6685 Naturally, we extend this to long long as well. Note that
6686 this does not include wchar_t. */
6687 || (bitfield
&& !flag_signed_bitfields
6689 /* A typedef for plain `int' without `signed' can be
6690 controlled just like plain `int', but a typedef for
6691 `signed int' cannot be so controlled. */
6693 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
6694 && (TREE_CODE (type
) == INTEGER_TYPE
6695 || TREE_CODE (type
) == CHAR_TYPE
)
6696 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
6699 type
= long_long_unsigned_type_node
;
6701 type
= long_unsigned_type_node
;
6703 type
= short_unsigned_type_node
;
6704 else if (type
== char_type_node
)
6705 type
= unsigned_char_type_node
;
6706 else if (typedef_decl
)
6707 type
= c_common_unsigned_type (type
);
6709 type
= unsigned_type_node
;
6711 else if (signed_p
&& type
== char_type_node
)
6712 type
= signed_char_type_node
;
6714 type
= long_long_integer_type_node
;
6716 type
= long_integer_type_node
;
6718 type
= short_integer_type_node
;
6720 if (declspecs
->specs
[(int)ds_complex
])
6722 if (TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
6723 error ("complex invalid for `%s'", name
);
6724 /* If we just have "complex", it is equivalent to
6725 "complex double", but if any modifiers at all are specified it is
6726 the complex form of TYPE. E.g, "complex short" is
6727 "complex short int". */
6729 else if (defaulted_int
&& ! longlong
6730 && ! (long_p
|| short_p
|| signed_p
|| unsigned_p
))
6731 type
= complex_double_type_node
;
6732 else if (type
== integer_type_node
)
6733 type
= complex_integer_type_node
;
6734 else if (type
== float_type_node
)
6735 type
= complex_float_type_node
;
6736 else if (type
== double_type_node
)
6737 type
= complex_double_type_node
;
6738 else if (type
== long_double_type_node
)
6739 type
= complex_long_double_type_node
;
6741 type
= build_complex_type (type
);
6744 type_quals
= TYPE_UNQUALIFIED
;
6745 if (declspecs
->specs
[(int)ds_const
])
6746 type_quals
|= TYPE_QUAL_CONST
;
6747 if (declspecs
->specs
[(int)ds_volatile
])
6748 type_quals
|= TYPE_QUAL_VOLATILE
;
6749 if (declspecs
->specs
[(int)ds_restrict
])
6750 type_quals
|= TYPE_QUAL_RESTRICT
;
6751 if (sfk
== sfk_conversion
&& type_quals
!= TYPE_UNQUALIFIED
)
6752 error ("qualifiers are not allowed on declaration of `operator %T'",
6755 type_quals
|= cp_type_quals (type
);
6756 type
= cp_build_qualified_type_real
6757 (type
, type_quals
, ((typedef_decl
&& !DECL_ARTIFICIAL (typedef_decl
)
6758 ? tf_ignore_bad_quals
: 0) | tf_error
| tf_warning
));
6759 /* We might have ignored or rejected some of the qualifiers. */
6760 type_quals
= cp_type_quals (type
);
6763 inlinep
= !! declspecs
->specs
[(int)ds_inline
];
6764 virtualp
= !! declspecs
->specs
[(int)ds_virtual
];
6765 explicitp
= !! declspecs
->specs
[(int)ds_explicit
];
6767 storage_class
= declspecs
->storage_class
;
6768 if (storage_class
== sc_static
)
6769 staticp
= 1 + (decl_context
== FIELD
);
6771 if (virtualp
&& staticp
== 2)
6773 error ("member `%D' cannot be declared both virtual and static",
6777 friendp
= !! declspecs
->specs
[(int)ds_friend
];
6779 if (dependant_name
&& !friendp
)
6781 error ("`%T::%D' is not a valid declarator", ctype
, dependant_name
);
6782 return void_type_node
;
6785 /* Issue errors about use of storage classes for parameters. */
6786 if (decl_context
== PARM
)
6788 if (declspecs
->specs
[(int)ds_typedef
])
6789 error ("typedef declaration invalid in parameter declaration");
6790 else if (storage_class
== sc_static
6791 || storage_class
== sc_extern
6793 error ("storage class specifiers invalid in parameter declarations");
6796 /* Give error if `virtual' is used outside of class declaration. */
6798 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
6800 error ("virtual outside class declaration");
6804 /* Static anonymous unions are dealt with here. */
6805 if (staticp
&& decl_context
== TYPENAME
6807 && ANON_AGGR_TYPE_P (declspecs
->type
))
6808 decl_context
= FIELD
;
6810 /* Warn about storage classes that are invalid for certain
6811 kinds of declarations (parameters, typenames, etc.). */
6812 if (declspecs
->multiple_storage_classes_p
)
6813 error ("multiple storage classes in declaration of `%s'", name
);
6816 && storage_class
!= sc_extern
6817 && storage_class
!= sc_static
)
6818 || declspecs
->specs
[(int)ds_typedef
]))
6820 error ("multiple storage classes in declaration of `%s'", name
);
6823 else if (decl_context
!= NORMAL
6824 && ((storage_class
!= sc_none
6825 && storage_class
!= sc_mutable
)
6828 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
6829 && (storage_class
== sc_register
6830 || storage_class
== sc_auto
))
6832 else if (declspecs
->specs
[(int)ds_typedef
])
6834 else if (decl_context
== FIELD
6835 /* C++ allows static class elements. */
6836 && storage_class
== sc_static
)
6837 /* C++ also allows inlines and signed and unsigned elements,
6838 but in those cases we don't come in here. */
6842 if (decl_context
== FIELD
)
6844 tree tmp
= NULL_TREE
;
6849 /* Avoid trying to get an operand off an identifier node. */
6850 if (declarator
->kind
!= cdk_id
)
6851 tmp
= declarator
->declarator
->u
.id
.name
;
6853 tmp
= declarator
->u
.id
.name
;
6854 op
= IDENTIFIER_OPNAME_P (tmp
);
6855 if (IDENTIFIER_TYPENAME_P (tmp
))
6857 if (is_typename_at_global_scope (tmp
))
6858 name
= IDENTIFIER_POINTER (tmp
);
6860 name
= "<invalid operator>";
6863 error ("storage class specified for %s `%s'",
6864 op
? "member operator" : "field",
6869 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
6870 error ("storage class specified for parameter `%s'", name
);
6872 error ("storage class specified for typename");
6874 if (storage_class
== sc_register
6875 || storage_class
== sc_auto
6876 || storage_class
== sc_extern
6878 storage_class
= sc_none
;
6881 else if (storage_class
== sc_extern
&& initialized
6884 if (toplevel_bindings_p ())
6886 /* It's common practice (and completely valid) to have a const
6887 be initialized and declared extern. */
6888 if (!(type_quals
& TYPE_QUAL_CONST
))
6889 warning ("`%s' initialized and declared `extern'", name
);
6892 error ("`%s' has both `extern' and initializer", name
);
6894 else if (storage_class
== sc_extern
&& funcdef_flag
6895 && ! toplevel_bindings_p ())
6896 error ("nested function `%s' declared `extern'", name
);
6897 else if (toplevel_bindings_p ())
6899 if (storage_class
== sc_auto
)
6900 error ("top-level declaration of `%s' specifies `auto'", name
);
6903 && storage_class
!= sc_extern
6904 && storage_class
!= sc_static
)
6906 error ("function-scope `%s' implicitly auto and declared `__thread'",
6911 if (storage_class
&& friendp
)
6912 error ("storage class specifiers invalid in friend function declarations");
6915 unqualified_id
= NULL_TREE
;
6918 unqualified_id
= id_declarator
->u
.id
.name
;
6919 if (TREE_CODE (unqualified_id
) == SCOPE_REF
)
6920 unqualified_id
= TREE_OPERAND (unqualified_id
, 1);
6921 if (TREE_CODE (unqualified_id
) == BASELINK
)
6922 unqualified_id
= BASELINK_FUNCTIONS (unqualified_id
);
6923 switch (TREE_CODE (unqualified_id
))
6927 = constructor_name (TREE_OPERAND (unqualified_id
, 0));
6932 = constructor_name (TREE_TYPE (unqualified_id
));
6935 case IDENTIFIER_NODE
:
6936 case TEMPLATE_ID_EXPR
:
6944 /* Determine the type of the entity declared by recurring on the
6947 declarator
&& declarator
->kind
!= cdk_id
;
6948 declarator
= declarator
->declarator
)
6950 const cp_declarator
*inner_declarator
;
6953 if (type
== error_mark_node
)
6954 return error_mark_node
;
6956 inner_declarator
= declarator
->declarator
;
6958 attrs
= declarator
->attributes
;
6964 if (declarator
== NULL
|| declarator
->kind
== cdk_id
)
6965 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
6966 if (declarator
->kind
== cdk_function
)
6967 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
6968 if (declarator
->kind
== cdk_array
)
6969 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
6970 returned_attrs
= decl_attributes (&type
,
6971 chainon (returned_attrs
, attrs
),
6975 switch (declarator
->kind
)
6978 type
= create_array_type_for_decl (dname
, type
,
6979 declarator
->u
.array
.bounds
);
6980 if (inner_declarator
6981 && (inner_declarator
->kind
== cdk_pointer
6982 || inner_declarator
->kind
== cdk_reference
6983 || inner_declarator
->kind
== cdk_ptrmem
))
6984 /* We can never complete an array type which is the
6985 target of a pointer, so go ahead and lay it out. */
6994 /* Declaring a function type.
6995 Make sure we have a valid type for the function to return. */
6997 /* We now know that the TYPE_QUALS don't apply to the
6998 decl, but to its return type. */
6999 type_quals
= TYPE_UNQUALIFIED
;
7001 /* Warn about some types functions can't return. */
7003 if (TREE_CODE (type
) == FUNCTION_TYPE
)
7005 error ("`%s' declared as function returning a function", name
);
7006 type
= integer_type_node
;
7008 if (TREE_CODE (type
) == ARRAY_TYPE
)
7010 error ("`%s' declared as function returning an array", name
);
7011 type
= integer_type_node
;
7014 /* Pick up type qualifiers which should be applied to `this'. */
7015 quals
= declarator
->u
.function
.qualifiers
;
7017 /* Pick up the exception specifications. */
7018 raises
= declarator
->u
.function
.exception_specification
;
7020 /* Say it's a definition only for the CALL_EXPR
7021 closest to the identifier. */
7022 funcdecl_p
= inner_declarator
&& inner_declarator
->kind
== cdk_id
;
7024 if (ctype
== NULL_TREE
7025 && decl_context
== FIELD
7027 && (friendp
== 0 || dname
== current_class_name
))
7028 ctype
= current_class_type
;
7030 if (ctype
&& sfk
== sfk_conversion
)
7031 TYPE_HAS_CONVERSION (ctype
) = 1;
7032 if (ctype
&& (sfk
== sfk_constructor
7033 || sfk
== sfk_destructor
))
7035 /* We are within a class's scope. If our declarator name
7036 is the same as the class name, and we are defining
7037 a function, then it is a constructor/destructor, and
7038 therefore returns a void type. */
7040 if (flags
== DTOR_FLAG
)
7042 /* ISO C++ 12.4/2. A destructor may not be
7043 declared const or volatile. A destructor may
7046 error ("destructor cannot be static member function");
7049 error ("destructors may not be cv-qualified");
7050 quals
= TYPE_UNQUALIFIED
;
7052 if (decl_context
== FIELD
)
7054 if (! member_function_or_else (ctype
,
7057 return void_type_node
;
7060 else /* It's a constructor. */
7064 /* ISO C++ 12.1. A constructor may not be
7065 declared const or volatile. A constructor may
7066 not be virtual. A constructor may not be
7069 error ("constructor cannot be static member function");
7072 pedwarn ("constructors cannot be declared virtual");
7077 error ("constructors may not be cv-qualified");
7078 quals
= TYPE_UNQUALIFIED
;
7080 if (decl_context
== FIELD
)
7082 if (! member_function_or_else (ctype
,
7085 return void_type_node
;
7086 TYPE_HAS_CONSTRUCTOR (ctype
) = 1;
7087 if (sfk
!= sfk_constructor
)
7091 if (decl_context
== FIELD
)
7097 error ("can't initialize friend function `%s'", name
);
7100 /* Cannot be both friend and virtual. */
7101 error ("virtual functions cannot be friends");
7104 if (decl_context
== NORMAL
)
7105 error ("friend declaration not in class definition");
7106 if (current_function_decl
&& funcdef_flag
)
7107 error ("can't define friend function `%s' in a local class definition",
7111 arg_types
= grokparms (declarator
->u
.function
.parameters
,
7114 if (inner_declarator
7115 && inner_declarator
->kind
== cdk_id
7116 && inner_declarator
->u
.id
.sfk
== sfk_destructor
7117 && arg_types
!= void_list_node
)
7119 error ("destructors may not have parameters");
7120 arg_types
= void_list_node
;
7124 type
= build_function_type (type
, arg_types
);
7131 /* Filter out pointers-to-references and references-to-references.
7132 We can get these if a TYPE_DECL is used. */
7134 if (TREE_CODE (type
) == REFERENCE_TYPE
)
7136 error (declarator
->kind
== cdk_reference
7137 ? "cannot declare reference to `%#T'"
7138 : "cannot declare pointer to `%#T'", type
);
7139 type
= TREE_TYPE (type
);
7141 else if (VOID_TYPE_P (type
))
7143 if (declarator
->kind
== cdk_reference
)
7144 error ("cannot declare reference to `%#T'", type
);
7145 else if (declarator
->kind
== cdk_ptrmem
)
7146 error ("cannot declare pointer to `%#T' member", type
);
7149 /* We now know that the TYPE_QUALS don't apply to the decl,
7150 but to the target of the pointer. */
7151 type_quals
= TYPE_UNQUALIFIED
;
7153 if (declarator
->kind
== cdk_ptrmem
7154 && (TREE_CODE (type
) == FUNCTION_TYPE
7155 || (quals
&& TREE_CODE (type
) == METHOD_TYPE
)))
7157 tree dummy
= build_decl (TYPE_DECL
, NULL_TREE
, type
);
7158 grok_method_quals (declarator
->u
.pointer
.class_type
,
7160 type
= TREE_TYPE (dummy
);
7161 quals
= TYPE_UNQUALIFIED
;
7164 if (declarator
->kind
== cdk_reference
)
7166 if (!VOID_TYPE_P (type
))
7167 type
= build_reference_type (type
);
7169 else if (TREE_CODE (type
) == METHOD_TYPE
)
7170 type
= build_ptrmemfunc_type (build_pointer_type (type
));
7171 else if (declarator
->kind
== cdk_ptrmem
)
7172 type
= build_ptrmem_type (declarator
->u
.pointer
.class_type
,
7175 type
= build_pointer_type (type
);
7177 /* Process a list of type modifier keywords (such as
7178 const or volatile) that were given inside the `*' or `&'. */
7180 if (declarator
->u
.pointer
.qualifiers
)
7183 = cp_build_qualified_type (type
,
7184 declarator
->u
.pointer
.qualifiers
);
7185 type_quals
= cp_type_quals (type
);
7198 if (unqualified_id
&& TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
7199 && TREE_CODE (type
) != FUNCTION_TYPE
7200 && TREE_CODE (type
) != METHOD_TYPE
)
7202 error ("template-id `%D' used as a declarator",
7204 unqualified_id
= dname
;
7207 /* If DECLARATOR is non-NULL, we know it is a cdk_id declarator;
7208 otherwise, we would not have exited the loop above. */
7210 && TREE_CODE (declarator
->u
.id
.name
) == SCOPE_REF
7211 /* If the qualifying scope was invalid, it will have been set to
7213 && TREE_OPERAND (declarator
->u
.id
.name
, 0)
7214 && TYPE_P (TREE_OPERAND (declarator
->u
.id
.name
, 0)))
7218 ctype
= TREE_OPERAND (declarator
->u
.id
.name
, 0);
7220 ctype
= TYPE_MAIN_VARIANT (ctype
);
7222 while (t
!= NULL_TREE
&& CLASS_TYPE_P (t
))
7224 /* You're supposed to have one `template <...>' for every
7225 template class, but you don't need one for a full
7226 specialization. For example:
7228 template <class T> struct S{};
7229 template <> struct S<int> { void f(); };
7230 void S<int>::f () {}
7232 is correct; there shouldn't be a `template <>' for the
7233 definition of `S<int>::f'. */
7234 if (CLASSTYPE_TEMPLATE_INFO (t
)
7235 && (CLASSTYPE_TEMPLATE_INSTANTIATION (t
)
7236 || uses_template_parms (CLASSTYPE_TI_ARGS (t
)))
7237 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)))
7238 template_count
+= 1;
7240 t
= TYPE_MAIN_DECL (t
);
7241 t
= DECL_CONTEXT (t
);
7244 if (ctype
== current_class_type
)
7250 Is this ill-formed? */
7253 pedwarn ("extra qualification `%T::' on member `%s' ignored",
7256 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
7258 tree sname
= TREE_OPERAND (declarator
->u
.id
.name
, 1);
7260 if (TREE_CODE (sname
) == IDENTIFIER_NODE
7261 && NEW_DELETE_OPNAME_P (sname
))
7262 /* Overloaded operator new and operator delete
7263 are always static functions. */
7265 else if (current_class_type
== NULL_TREE
|| friendp
)
7267 = build_method_type_directly (ctype
,
7269 TYPE_ARG_TYPES (type
));
7272 error ("cannot declare member function `%T::%s' within `%T'",
7273 ctype
, name
, current_class_type
);
7274 return error_mark_node
;
7277 else if (declspecs
->specs
[(int)ds_typedef
]
7278 || COMPLETE_TYPE_P (complete_type (ctype
)))
7280 /* Have to move this code elsewhere in this function.
7281 this code is used for i.e., typedef int A::M; M *pm;
7283 It is? How? jason 10/2/94 */
7285 if (current_class_type
)
7287 error ("cannot declare member `%T::%s' within `%T'",
7288 ctype
, name
, current_class_type
);
7289 return void_type_node
;
7294 cxx_incomplete_type_error (NULL_TREE
, ctype
);
7295 return error_mark_node
;
7302 *attrlist
= chainon (returned_attrs
, *attrlist
);
7304 attrlist
= &returned_attrs
;
7307 /* Now TYPE has the actual type. */
7309 /* Did array size calculations overflow? */
7311 if (TREE_CODE (type
) == ARRAY_TYPE
7312 && COMPLETE_TYPE_P (type
)
7313 && TREE_OVERFLOW (TYPE_SIZE (type
)))
7315 error ("size of array `%s' is too large", name
);
7316 /* If we proceed with the array type as it is, we'll eventually
7317 crash in tree_low_cst(). */
7318 type
= error_mark_node
;
7321 if ((decl_context
== FIELD
|| decl_context
== PARM
)
7322 && !processing_template_decl
7323 && variably_modified_type_p (type
, NULL_TREE
))
7325 if (decl_context
== FIELD
)
7326 error ("data member may not have variably modified type `%T'", type
);
7328 error ("parameter may not have variably modified type `%T'", type
);
7329 type
= error_mark_node
;
7332 if (explicitp
== 1 || (explicitp
&& friendp
))
7334 /* [dcl.fct.spec] The explicit specifier shall only be used in
7335 declarations of constructors within a class definition. */
7336 error ("only declarations of constructors can be `explicit'");
7340 if (storage_class
== sc_mutable
)
7342 if (decl_context
!= FIELD
|| friendp
)
7344 error ("non-member `%s' cannot be declared `mutable'", name
);
7345 storage_class
= sc_none
;
7347 else if (decl_context
== TYPENAME
|| declspecs
->specs
[(int)ds_typedef
])
7349 error ("non-object member `%s' cannot be declared `mutable'", name
);
7350 storage_class
= sc_none
;
7352 else if (TREE_CODE (type
) == FUNCTION_TYPE
7353 || TREE_CODE (type
) == METHOD_TYPE
)
7355 error ("function `%s' cannot be declared `mutable'", name
);
7356 storage_class
= sc_none
;
7360 error ("static `%s' cannot be declared `mutable'", name
);
7361 storage_class
= sc_none
;
7363 else if (type_quals
& TYPE_QUAL_CONST
)
7365 error ("const `%s' cannot be declared `mutable'", name
);
7366 storage_class
= sc_none
;
7370 /* If this is declaring a typedef name, return a TYPE_DECL. */
7371 if (declspecs
->specs
[(int)ds_typedef
] && decl_context
!= TYPENAME
)
7375 /* Note that the grammar rejects storage classes
7376 in typenames, fields or parameters. */
7377 if (current_lang_name
== lang_name_java
)
7378 TYPE_FOR_JAVA (type
) = 1;
7380 if (decl_context
== FIELD
)
7382 if (constructor_name_p (unqualified_id
, current_class_type
))
7383 pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
7385 decl
= build_lang_decl (TYPE_DECL
, unqualified_id
, type
);
7389 decl
= build_decl (TYPE_DECL
, unqualified_id
, type
);
7390 if (in_namespace
|| ctype
)
7391 error ("%Jtypedef name may not be a nested-name-specifier", decl
);
7392 if (!current_function_decl
)
7393 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
7396 /* If the user declares "typedef struct {...} foo" then the
7397 struct will have an anonymous name. Fill that name in now.
7398 Nothing can refer to it, so nothing needs know about the name
7400 if (type
!= error_mark_node
7403 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
7404 && TYPE_ANONYMOUS_P (type
)
7405 /* Don't do this if there are attributes. */
7406 && (!attrlist
|| !*attrlist
)
7407 && cp_type_quals (type
) == TYPE_UNQUALIFIED
)
7409 tree oldname
= TYPE_NAME (type
);
7412 /* Replace the anonymous name with the real name everywhere. */
7413 lookup_tag_reverse (type
, unqualified_id
);
7414 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
7415 if (TYPE_NAME (t
) == oldname
)
7416 TYPE_NAME (t
) = decl
;
7418 if (TYPE_LANG_SPECIFIC (type
))
7419 TYPE_WAS_ANONYMOUS (type
) = 1;
7421 /* If this is a typedef within a template class, the nested
7422 type is a (non-primary) template. The name for the
7423 template needs updating as well. */
7424 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
7425 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
7426 = TYPE_IDENTIFIER (type
);
7428 /* FIXME remangle member functions; member functions of a
7429 type with external linkage have external linkage. */
7434 if (ctype
== NULL_TREE
)
7436 if (TREE_CODE (type
) != METHOD_TYPE
)
7437 error ("%Jinvalid type qualifier for non-member function type",
7440 ctype
= TYPE_METHOD_BASETYPE (type
);
7442 if (ctype
!= NULL_TREE
)
7443 grok_method_quals (ctype
, decl
, quals
);
7447 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
7448 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
7450 bad_specifiers (decl
, "type", virtualp
, quals
!= TYPE_UNQUALIFIED
,
7451 inlinep
, friendp
, raises
!= NULL_TREE
);
7456 /* Detect the case of an array type of unspecified size
7457 which came, as such, direct from a typedef name.
7458 We must copy the type, so that the array's domain can be
7459 individually set by the object's initializer. */
7461 if (type
&& typedef_type
7462 && TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
7463 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (typedef_type
))
7464 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
7466 /* Detect where we're using a typedef of function type to declare a
7467 function. PARMS will not be set, so we must create it now. */
7469 if (type
== typedef_type
&& TREE_CODE (type
) == FUNCTION_TYPE
)
7471 tree decls
= NULL_TREE
;
7474 for (args
= TYPE_ARG_TYPES (type
); args
; args
= TREE_CHAIN (args
))
7476 tree decl
= cp_build_parm_decl (NULL_TREE
, TREE_VALUE (args
));
7478 TREE_CHAIN (decl
) = decls
;
7482 parms
= nreverse (decls
);
7485 /* If this is a type name (such as, in a cast or sizeof),
7486 compute the type and return it now. */
7488 if (decl_context
== TYPENAME
)
7490 /* Note that the grammar rejects storage classes
7491 in typenames, fields or parameters. */
7492 if (type_quals
!= TYPE_UNQUALIFIED
)
7493 type_quals
= TYPE_UNQUALIFIED
;
7495 /* Special case: "friend class foo" looks like a TYPENAME context. */
7498 if (type_quals
!= TYPE_UNQUALIFIED
)
7500 error ("type qualifiers specified for friend class declaration");
7501 type_quals
= TYPE_UNQUALIFIED
;
7505 error ("`inline' specified for friend class declaration");
7511 /* Don't allow friend declaration without a class-key. */
7512 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
7513 pedwarn ("template parameters cannot be friends");
7514 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
7515 pedwarn ("friend declaration requires class-key, "
7516 "i.e. `friend class %T::%D'",
7517 TYPE_CONTEXT (type
), TYPENAME_TYPE_FULLNAME (type
));
7519 pedwarn ("friend declaration requires class-key, "
7520 "i.e. `friend %#T'",
7524 /* Only try to do this stuff if we didn't already give up. */
7525 if (type
!= integer_type_node
)
7527 /* A friendly class? */
7528 if (current_class_type
)
7529 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
),
7532 error ("trying to make class `%T' a friend of global scope",
7535 type
= void_type_node
;
7540 if (ctype
== NULL_TREE
)
7542 if (TREE_CODE (type
) != METHOD_TYPE
)
7543 error ("invalid qualifiers on non-member function type");
7545 ctype
= TYPE_METHOD_BASETYPE (type
);
7549 tree dummy
= build_decl (TYPE_DECL
, unqualified_id
, type
);
7550 grok_method_quals (ctype
, dummy
, quals
);
7551 type
= TREE_TYPE (dummy
);
7557 else if (unqualified_id
== NULL_TREE
&& decl_context
!= PARM
7558 && decl_context
!= CATCHPARM
7559 && TREE_CODE (type
) != UNION_TYPE
7562 error ("abstract declarator `%T' used as declaration", type
);
7563 unqualified_id
= make_anon_name ();
7566 /* `void' at top level (not within pointer)
7567 is allowed only in typedefs or type names.
7568 We don't complain about parms either, but that is because
7569 a better error message can be made later. */
7571 if (TREE_CODE (type
) == VOID_TYPE
&& decl_context
!= PARM
)
7573 if (! unqualified_id
)
7574 error ("unnamed variable or field declared void");
7575 else if (TREE_CODE (unqualified_id
) == IDENTIFIER_NODE
)
7577 if (IDENTIFIER_OPNAME_P (unqualified_id
))
7580 error ("variable or field `%s' declared void", name
);
7583 error ("variable or field declared void");
7584 type
= integer_type_node
;
7587 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
7588 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
7590 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
7592 if (ctype
|| in_namespace
)
7593 error ("cannot use `::' in parameter declaration");
7595 /* A parameter declared as an array of T is really a pointer to T.
7596 One declared as a function is really a pointer to a function.
7597 One declared as a member is really a pointer to member. */
7599 if (TREE_CODE (type
) == ARRAY_TYPE
)
7601 /* Transfer const-ness of array into that of type pointed to. */
7602 type
= build_pointer_type (TREE_TYPE (type
));
7603 type_quals
= TYPE_UNQUALIFIED
;
7605 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
7606 type
= build_pointer_type (type
);
7612 if (decl_context
== PARM
)
7614 decl
= cp_build_parm_decl (unqualified_id
, type
);
7616 bad_specifiers (decl
, "parameter", virtualp
, quals
!= TYPE_UNQUALIFIED
,
7617 inlinep
, friendp
, raises
!= NULL_TREE
);
7619 else if (decl_context
== FIELD
)
7621 /* The C99 flexible array extension. */
7622 if (!staticp
&& TREE_CODE (type
) == ARRAY_TYPE
7623 && TYPE_DOMAIN (type
) == NULL_TREE
)
7625 tree itype
= compute_array_index_type (dname
, integer_zero_node
);
7626 type
= build_cplus_array_type (TREE_TYPE (type
), itype
);
7629 if (type
== error_mark_node
)
7631 /* Happens when declaring arrays of sizes which
7632 are error_mark_node, for example. */
7635 else if (in_namespace
&& !friendp
)
7637 /* Something like struct S { int N::j; }; */
7638 error ("invalid use of `::'");
7641 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
7644 tree function_context
;
7646 /* We catch the others as conflicts with the builtin
7648 if (friendp
&& unqualified_id
== ridpointers
[(int) RID_SIGNED
])
7650 error ("function `%D' cannot be declared friend",
7657 if (ctype
== NULL_TREE
)
7658 ctype
= current_class_type
;
7660 if (ctype
== NULL_TREE
)
7662 error ("can't make `%D' into a method -- not in a class",
7664 return void_type_node
;
7667 /* ``A union may [ ... ] not [ have ] virtual functions.''
7669 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
7671 error ("function `%D' declared virtual inside a union",
7673 return void_type_node
;
7676 if (NEW_DELETE_OPNAME_P (unqualified_id
))
7680 error ("`%D' cannot be declared virtual, since it is always static",
7685 else if (staticp
< 2)
7686 type
= build_method_type_directly (ctype
,
7688 TYPE_ARG_TYPES (type
));
7691 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
7692 function_context
= (ctype
!= NULL_TREE
) ?
7693 decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
7694 publicp
= (! friendp
|| ! staticp
)
7695 && function_context
== NULL_TREE
;
7696 decl
= grokfndecl (ctype
, type
,
7697 TREE_CODE (unqualified_id
) != TEMPLATE_ID_EXPR
7698 ? unqualified_id
: dname
,
7701 virtualp
, flags
, quals
, raises
,
7702 friendp
? -1 : 0, friendp
, publicp
, inlinep
,
7703 funcdef_flag
, template_count
, in_namespace
);
7704 if (decl
== NULL_TREE
)
7707 /* This clobbers the attrs stored in `decl' from `attrlist'. */
7708 /* The decl and setting of decl_attr is also turned off. */
7709 decl
= build_decl_attribute_variant (decl
, decl_attr
);
7712 /* [class.conv.ctor]
7714 A constructor declared without the function-specifier
7715 explicit that can be called with a single parameter
7716 specifies a conversion from the type of its first
7717 parameter to the type of its class. Such a constructor
7718 is called a converting constructor. */
7720 DECL_NONCONVERTING_P (decl
) = 1;
7721 else if (DECL_CONSTRUCTOR_P (decl
))
7723 /* The constructor can be called with exactly one
7724 parameter if there is at least one parameter, and
7725 any subsequent parameters have default arguments.
7726 Ignore any compiler-added parms. */
7727 tree arg_types
= FUNCTION_FIRST_USER_PARMTYPE (decl
);
7729 if (arg_types
== void_list_node
7731 && TREE_CHAIN (arg_types
)
7732 && TREE_CHAIN (arg_types
) != void_list_node
7733 && !TREE_PURPOSE (TREE_CHAIN (arg_types
))))
7734 DECL_NONCONVERTING_P (decl
) = 1;
7737 else if (TREE_CODE (type
) == METHOD_TYPE
)
7739 /* We only get here for friend declarations of
7740 members of other classes. */
7741 /* All method decls are public, so tell grokfndecl to set
7742 TREE_PUBLIC, also. */
7743 decl
= grokfndecl (ctype
, type
,
7744 TREE_CODE (unqualified_id
) != TEMPLATE_ID_EXPR
7745 ? unqualified_id
: dname
,
7748 virtualp
, flags
, quals
, raises
,
7749 friendp
? -1 : 0, friendp
, 1, 0, funcdef_flag
,
7750 template_count
, in_namespace
);
7751 if (decl
== NULL_TREE
)
7754 else if (!staticp
&& !dependent_type_p (type
)
7755 && !COMPLETE_TYPE_P (complete_type (type
))
7756 && (TREE_CODE (type
) != ARRAY_TYPE
|| initialized
== 0))
7759 error ("field `%D' has incomplete type", unqualified_id
);
7761 error ("name `%T' has incomplete type", type
);
7763 /* If we're instantiating a template, tell them which
7764 instantiation made the field's type be incomplete. */
7765 if (current_class_type
7766 && TYPE_NAME (current_class_type
)
7767 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type
))
7769 && declspecs
->type
== type
)
7770 error (" in instantiation of template `%T'",
7771 current_class_type
);
7773 type
= error_mark_node
;
7780 error ("`%E' is neither function nor member function; "
7781 "cannot be declared friend", unqualified_id
);
7789 /* Friends are treated specially. */
7790 if (ctype
== current_class_type
)
7791 warning ("member functions are implicitly friends of their class");
7792 else if (decl
&& DECL_NAME (decl
))
7794 if (template_class_depth (current_class_type
) == 0)
7796 decl
= check_explicit_specialization
7797 (unqualified_id
, decl
, template_count
,
7798 2 * (funcdef_flag
!= 0) + 4);
7799 if (decl
== error_mark_node
)
7800 return error_mark_node
;
7803 decl
= do_friend (ctype
, unqualified_id
, decl
,
7804 *attrlist
, flags
, quals
, funcdef_flag
);
7808 return void_type_node
;
7811 /* Structure field. It may not be a function, except for C++. */
7813 if (decl
== NULL_TREE
)
7819 /* An attempt is being made to initialize a non-static
7820 member. But, from [class.mem]:
7822 4 A member-declarator can contain a
7823 constant-initializer only if it declares a static
7824 member (_class.static_) of integral or enumeration
7825 type, see _class.static.data_.
7827 This used to be relatively common practice, but
7828 the rest of the compiler does not correctly
7829 handle the initialization unless the member is
7830 static so we make it static below. */
7831 pedwarn ("ISO C++ forbids initialization of member `%D'",
7833 pedwarn ("making `%D' static", unqualified_id
);
7837 if (uses_template_parms (type
))
7838 /* We'll check at instantiation time. */
7840 else if (check_static_variable_definition (unqualified_id
,
7842 /* If we just return the declaration, crashes
7843 will sometimes occur. We therefore return
7844 void_type_node, as if this was a friend
7845 declaration, to cause callers to completely
7846 ignore this declaration. */
7847 return void_type_node
;
7852 /* C++ allows static class members. All other work
7853 for this is done by grokfield. */
7854 decl
= build_lang_decl (VAR_DECL
, unqualified_id
, type
);
7855 set_linkage_for_static_data_member (decl
);
7856 /* Even if there is an in-class initialization, DECL
7857 is considered undefined until an out-of-class
7858 definition is provided. */
7859 DECL_EXTERNAL (decl
) = 1;
7863 decl
= build_decl (FIELD_DECL
, unqualified_id
, type
);
7864 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
7865 if (storage_class
== sc_mutable
)
7867 DECL_MUTABLE_P (decl
) = 1;
7868 storage_class
= sc_none
;
7872 bad_specifiers (decl
, "field", virtualp
, quals
!= TYPE_UNQUALIFIED
,
7873 inlinep
, friendp
, raises
!= NULL_TREE
);
7876 else if (TREE_CODE (type
) == FUNCTION_TYPE
7877 || TREE_CODE (type
) == METHOD_TYPE
)
7882 if (!unqualified_id
)
7885 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
7886 original_name
= dname
;
7888 original_name
= unqualified_id
;
7890 if (storage_class
== sc_auto
)
7891 error ("storage class `auto' invalid for function `%s'", name
);
7892 else if (storage_class
== sc_register
)
7893 error ("storage class `register' invalid for function `%s'", name
);
7895 error ("storage class `__thread' invalid for function `%s'", name
);
7897 /* Function declaration not at top level.
7898 Storage classes other than `extern' are not allowed
7899 and `extern' makes no difference. */
7900 if (! toplevel_bindings_p ()
7901 && (storage_class
== sc_static
7902 || declspecs
->specs
[(int)ds_inline
])
7905 if (storage_class
== sc_static
)
7906 pedwarn ("`static' specified invalid for function `%s' declared out of global scope", name
);
7908 pedwarn ("`inline' specifier invalid for function `%s' declared out of global scope", name
);
7911 if (ctype
== NULL_TREE
)
7915 error ("virtual non-class function `%s'", name
);
7919 else if (TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2
7920 && !NEW_DELETE_OPNAME_P (original_name
))
7921 type
= build_method_type_directly (ctype
,
7923 TYPE_ARG_TYPES (type
));
7925 /* Record presence of `static'. */
7926 publicp
= (ctype
!= NULL_TREE
7927 || storage_class
== sc_extern
7928 || storage_class
!= sc_static
);
7930 decl
= grokfndecl (ctype
, type
, original_name
, parms
, unqualified_id
,
7931 virtualp
, flags
, quals
, raises
,
7933 publicp
, inlinep
, funcdef_flag
,
7934 template_count
, in_namespace
);
7935 if (decl
== NULL_TREE
)
7940 int invalid_static
= 0;
7942 /* Don't allow a static member function in a class, and forbid
7943 declaring main to be static. */
7944 if (TREE_CODE (type
) == METHOD_TYPE
)
7946 pedwarn ("cannot declare member function `%D' to have static linkage", decl
);
7949 else if (current_function_decl
)
7951 /* FIXME need arm citation */
7952 error ("cannot declare static function inside another function");
7959 storage_class
= sc_none
;
7965 /* It's a variable. */
7967 /* An uninitialized decl with `extern' is a reference. */
7968 decl
= grokvardecl (type
, unqualified_id
,
7971 (type_quals
& TYPE_QUAL_CONST
) != 0,
7972 ctype
? ctype
: in_namespace
);
7973 bad_specifiers (decl
, "variable", virtualp
, quals
!= TYPE_UNQUALIFIED
,
7974 inlinep
, friendp
, raises
!= NULL_TREE
);
7978 DECL_CONTEXT (decl
) = ctype
;
7981 pedwarn ("`static' may not be used when defining (as opposed to declaring) a static data member");
7983 storage_class
= sc_none
;
7985 if (storage_class
== sc_register
&& TREE_STATIC (decl
))
7987 error ("static member `%D' declared `register'", decl
);
7988 storage_class
= sc_none
;
7990 if (storage_class
== sc_extern
&& pedantic
)
7992 pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
7994 storage_class
= sc_none
;
7999 /* Record `register' declaration for warnings on &
8000 and in case doing stupid register allocation. */
8002 if (storage_class
== sc_register
)
8003 DECL_REGISTER (decl
) = 1;
8004 else if (storage_class
== sc_extern
)
8005 DECL_THIS_EXTERN (decl
) = 1;
8006 else if (storage_class
== sc_static
)
8007 DECL_THIS_STATIC (decl
) = 1;
8009 /* Record constancy and volatility. There's no need to do this
8010 when processing a template; we'll do this for the instantiated
8011 declaration based on the type of DECL. */
8012 if (!processing_template_decl
)
8013 c_apply_type_quals_to_decl (type_quals
, decl
);
8019 /* Subroutine of start_function. Ensure that each of the parameter
8020 types (as listed in PARMS) is complete, as is required for a
8021 function definition. */
8024 require_complete_types_for_parms (tree parms
)
8026 for (; parms
; parms
= TREE_CHAIN (parms
))
8028 if (VOID_TYPE_P (TREE_TYPE (parms
)))
8029 /* grokparms will have already issued an error. */
8030 TREE_TYPE (parms
) = error_mark_node
;
8031 else if (complete_type_or_else (TREE_TYPE (parms
), parms
))
8033 layout_decl (parms
, 0);
8034 DECL_ARG_TYPE (parms
) = type_passed_as (TREE_TYPE (parms
));
8039 /* Returns nonzero if T is a local variable. */
8042 local_variable_p (tree t
)
8044 if ((TREE_CODE (t
) == VAR_DECL
8045 /* A VAR_DECL with a context that is a _TYPE is a static data
8047 && !TYPE_P (CP_DECL_CONTEXT (t
))
8048 /* Any other non-local variable must be at namespace scope. */
8049 && !DECL_NAMESPACE_SCOPE_P (t
))
8050 || (TREE_CODE (t
) == PARM_DECL
))
8056 /* Returns nonzero if T is an automatic local variable or a label.
8057 (These are the declarations that need to be remapped when the code
8058 containing them is duplicated.) */
8061 nonstatic_local_decl_p (tree t
)
8063 return ((local_variable_p (t
) && !TREE_STATIC (t
))
8064 || TREE_CODE (t
) == LABEL_DECL
8065 || TREE_CODE (t
) == RESULT_DECL
);
8068 /* Like local_variable_p, but suitable for use as a tree-walking
8072 local_variable_p_walkfn (tree
*tp
, int *walk_subtrees
,
8073 void *data ATTRIBUTE_UNUSED
)
8075 if (local_variable_p (*tp
) && !DECL_ARTIFICIAL (*tp
))
8077 else if (TYPE_P (*tp
))
8084 /* Check that ARG, which is a default-argument expression for a
8085 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
8086 something goes wrong. DECL may also be a _TYPE node, rather than a
8087 DECL, if there is no DECL available. */
8090 check_default_argument (tree decl
, tree arg
)
8095 if (TREE_CODE (arg
) == DEFAULT_ARG
)
8096 /* We get a DEFAULT_ARG when looking at an in-class declaration
8097 with a default argument. Ignore the argument for now; we'll
8098 deal with it after the class is complete. */
8101 if (processing_template_decl
|| uses_template_parms (arg
))
8102 /* We don't do anything checking until instantiation-time. Note
8103 that there may be uninstantiated arguments even for an
8104 instantiated function, since default arguments are not
8105 instantiated until they are needed. */
8114 decl_type
= TREE_TYPE (decl
);
8116 if (arg
== error_mark_node
8117 || decl
== error_mark_node
8118 || TREE_TYPE (arg
) == error_mark_node
8119 || decl_type
== error_mark_node
)
8120 /* Something already went wrong. There's no need to check
8122 return error_mark_node
;
8124 /* [dcl.fct.default]
8126 A default argument expression is implicitly converted to the
8128 if (!TREE_TYPE (arg
)
8129 || !can_convert_arg (decl_type
, TREE_TYPE (arg
), arg
))
8132 error ("default argument for `%#D' has type `%T'",
8133 decl
, TREE_TYPE (arg
));
8135 error ("default argument for parameter of type `%T' has type `%T'",
8136 decl_type
, TREE_TYPE (arg
));
8138 return error_mark_node
;
8141 /* [dcl.fct.default]
8143 Local variables shall not be used in default argument
8146 The keyword `this' shall not be used in a default argument of a
8148 var
= walk_tree_without_duplicates (&arg
, local_variable_p_walkfn
,
8152 error ("default argument `%E' uses local variable `%D'",
8154 return error_mark_node
;
8161 /* Decode the list of parameter types for a function type.
8162 Given the list of things declared inside the parens,
8163 return a list of types.
8165 If this parameter does not end with an ellipsis, we append
8168 *PARMS is set to the chain of PARM_DECLs created. */
8171 grokparms (cp_parameter_declarator
*first_parm
, tree
*parms
)
8173 tree result
= NULL_TREE
;
8174 tree decls
= NULL_TREE
;
8175 int ellipsis
= !first_parm
|| first_parm
->ellipsis_p
;
8176 cp_parameter_declarator
*parm
;
8179 for (parm
= first_parm
; parm
!= NULL
; parm
= parm
->next
)
8181 tree type
= NULL_TREE
;
8182 tree init
= parm
->default_argument
;
8186 if (parm
== no_parameters
)
8189 attrs
= parm
->decl_specifiers
.attributes
;
8190 parm
->decl_specifiers
.attributes
= NULL_TREE
;
8191 decl
= grokdeclarator (parm
->declarator
, &parm
->decl_specifiers
,
8192 PARM
, init
!= NULL_TREE
, &attrs
);
8193 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
8197 cplus_decl_attributes (&decl
, attrs
, 0);
8199 type
= TREE_TYPE (decl
);
8200 if (VOID_TYPE_P (type
))
8202 if (same_type_p (type
, void_type_node
)
8203 && !DECL_NAME (decl
) && !result
&& !parm
->next
&& !ellipsis
)
8204 /* this is a parmlist of `(void)', which is ok. */
8206 cxx_incomplete_type_error (decl
, type
);
8207 /* It's not a good idea to actually create parameters of
8208 type `void'; other parts of the compiler assume that a
8209 void type terminates the parameter list. */
8210 type
= error_mark_node
;
8211 TREE_TYPE (decl
) = error_mark_node
;
8214 if (type
!= error_mark_node
)
8216 /* Top-level qualifiers on the parameters are
8217 ignored for function types. */
8218 type
= cp_build_qualified_type (type
, 0);
8219 if (TREE_CODE (type
) == METHOD_TYPE
)
8221 error ("parameter `%D' invalidly declared method type", decl
);
8222 type
= build_pointer_type (type
);
8223 TREE_TYPE (decl
) = type
;
8225 else if (abstract_virtuals_error (decl
, type
))
8226 any_error
= 1; /* Seems like a good idea. */
8227 else if (POINTER_TYPE_P (type
))
8229 /* [dcl.fct]/6, parameter types cannot contain pointers
8230 (references) to arrays of unknown bound. */
8231 tree t
= TREE_TYPE (type
);
8232 int ptr
= TYPE_PTR_P (type
);
8238 else if (TREE_CODE (t
) != ARRAY_TYPE
)
8240 else if (!TYPE_DOMAIN (t
))
8244 if (TREE_CODE (t
) == ARRAY_TYPE
)
8245 error ("parameter `%D' includes %s to array of unknown bound `%T'",
8246 decl
, ptr
? "pointer" : "reference", t
);
8249 if (!any_error
&& init
)
8250 init
= check_default_argument (decl
, init
);
8255 TREE_CHAIN (decl
) = decls
;
8257 result
= tree_cons (init
, type
, result
);
8259 decls
= nreverse (decls
);
8260 result
= nreverse (result
);
8262 result
= chainon (result
, void_list_node
);
8269 /* D is a constructor or overloaded `operator='.
8271 Let T be the class in which D is declared. Then, this function
8274 -1 if D's is an ill-formed constructor or copy assignment operator
8275 whose first parameter is of type `T'.
8276 0 if D is not a copy constructor or copy assignment
8278 1 if D is a copy constructor or copy assignment operator whose
8279 first parameter is a reference to const qualified T.
8280 2 if D is a copy constructor or copy assignment operator whose
8281 first parameter is a reference to non-const qualified T.
8283 This function can be used as a predicate. Positive values indicate
8284 a copy constructor and nonzero values indicate a copy assignment
8294 my_friendly_assert (DECL_FUNCTION_MEMBER_P (d
), 20011208);
8296 if (DECL_TEMPLATE_INFO (d
) && is_member_template (DECL_TI_TEMPLATE (d
)))
8297 /* Instantiations of template member functions are never copy
8298 functions. Note that member functions of templated classes are
8299 represented as template functions internally, and we must
8300 accept those as copy functions. */
8303 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
8307 arg_type
= TREE_VALUE (args
);
8309 if (TYPE_MAIN_VARIANT (arg_type
) == DECL_CONTEXT (d
))
8311 /* Pass by value copy assignment operator. */
8314 else if (TREE_CODE (arg_type
) == REFERENCE_TYPE
8315 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)) == DECL_CONTEXT (d
))
8317 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type
)))
8323 args
= TREE_CHAIN (args
);
8325 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
8326 /* There are more non-optional args. */
8332 /* Remember any special properties of member function DECL. */
8334 void grok_special_member_properties (tree decl
)
8336 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P(decl
))
8337 ; /* Not special. */
8338 else if (DECL_CONSTRUCTOR_P (decl
))
8340 int ctor
= copy_fn_p (decl
);
8346 A non-template constructor for class X is a copy
8347 constructor if its first parameter is of type X&, const
8348 X&, volatile X& or const volatile X&, and either there
8349 are no other parameters or else all other parameters have
8350 default arguments. */
8351 TYPE_HAS_INIT_REF (DECL_CONTEXT (decl
)) = 1;
8353 TYPE_HAS_CONST_INIT_REF (DECL_CONTEXT (decl
)) = 1;
8355 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl
)))
8356 TYPE_HAS_DEFAULT_CONSTRUCTOR (DECL_CONTEXT (decl
)) = 1;
8358 else if (DECL_OVERLOADED_OPERATOR_P (decl
) == NOP_EXPR
)
8362 A non-template assignment operator for class X is a copy
8363 assignment operator if its parameter is of type X, X&, const
8364 X&, volatile X& or const volatile X&. */
8366 int assop
= copy_fn_p (decl
);
8370 TYPE_HAS_ASSIGN_REF (DECL_CONTEXT (decl
)) = 1;
8372 TYPE_HAS_CONST_ASSIGN_REF (DECL_CONTEXT (decl
)) = 1;
8377 /* Check a constructor DECL has the correct form. Complains
8378 if the class has a constructor of the form X(X). */
8381 grok_ctor_properties (tree ctype
, tree decl
)
8383 int ctor_parm
= copy_fn_p (decl
);
8389 A declaration of a constructor for a class X is ill-formed if
8390 its first parameter is of type (optionally cv-qualified) X
8391 and either there are no other parameters or else all other
8392 parameters have default arguments.
8394 We *don't* complain about member template instantiations that
8395 have this form, though; they can occur as we try to decide
8396 what constructor to use during overload resolution. Since
8397 overload resolution will never prefer such a constructor to
8398 the non-template copy constructor (which is either explicitly
8399 or implicitly defined), there's no need to worry about their
8400 existence. Theoretically, they should never even be
8401 instantiated, but that's hard to forestall. */
8402 error ("invalid constructor; you probably meant `%T (const %T&)'",
8410 /* An operator with this code is unary, but can also be binary. */
8413 ambi_op_p (enum tree_code code
)
8415 return (code
== INDIRECT_REF
8416 || code
== ADDR_EXPR
8417 || code
== CONVERT_EXPR
8418 || code
== NEGATE_EXPR
8419 || code
== PREINCREMENT_EXPR
8420 || code
== PREDECREMENT_EXPR
);
8423 /* An operator with this name can only be unary. */
8426 unary_op_p (enum tree_code code
)
8428 return (code
== TRUTH_NOT_EXPR
8429 || code
== BIT_NOT_EXPR
8430 || code
== COMPONENT_REF
8431 || code
== TYPE_EXPR
);
8434 /* DECL is a declaration for an overloaded operator. Returns true if
8435 the declaration is valid; false otherwise. If COMPLAIN is true,
8436 errors are issued for invalid declarations. */
8439 grok_op_properties (tree decl
, int friendp
, bool complain
)
8441 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
8443 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
8444 tree name
= DECL_NAME (decl
);
8445 enum tree_code operator_code
;
8449 /* Assume that the declaration is valid. */
8452 /* Count the number of arguments. */
8453 for (argtype
= argtypes
, arity
= 0;
8454 argtype
&& argtype
!= void_list_node
;
8455 argtype
= TREE_CHAIN (argtype
))
8458 if (current_class_type
== NULL_TREE
)
8461 if (DECL_CONV_FN_P (decl
))
8462 operator_code
= TYPE_EXPR
;
8466 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
8467 if (ansi_opname (CODE) == name) \
8469 operator_code = (CODE); \
8472 else if (ansi_assopname (CODE) == name) \
8474 operator_code = (CODE); \
8475 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
8479 #include "operators.def"
8485 my_friendly_assert (operator_code
!= LAST_CPLUS_TREE_CODE
, 20000526);
8486 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
8490 switch (operator_code
)
8493 TYPE_HAS_NEW_OPERATOR (current_class_type
) = 1;
8497 TYPE_GETS_DELETE (current_class_type
) |= 1;
8501 TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type
) = 1;
8504 case VEC_DELETE_EXPR
:
8505 TYPE_GETS_DELETE (current_class_type
) |= 2;
8513 /* [basic.std.dynamic.allocation]/1:
8515 A program is ill-formed if an allocation function is declared
8516 in a namespace scope other than global scope or declared static
8519 The same also holds true for deallocation functions. */
8520 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
8521 || operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
8523 if (DECL_NAMESPACE_SCOPE_P (decl
))
8525 if (CP_DECL_CONTEXT (decl
) != global_namespace
)
8526 error ("`%D' may not be declared within a namespace", decl
);
8527 else if (!TREE_PUBLIC (decl
))
8528 error ("`%D' may not be declared as static", decl
);
8532 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
)
8533 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
8534 else if (operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
8535 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
8538 /* An operator function must either be a non-static member function
8539 or have at least one parameter of a class, a reference to a class,
8540 an enumeration, or a reference to an enumeration. 13.4.0.6 */
8541 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
8543 if (operator_code
== TYPE_EXPR
8544 || operator_code
== CALL_EXPR
8545 || operator_code
== COMPONENT_REF
8546 || operator_code
== ARRAY_REF
8547 || operator_code
== NOP_EXPR
)
8548 error ("`%D' must be a nonstatic member function", decl
);
8553 if (DECL_STATIC_FUNCTION_P (decl
))
8554 error ("`%D' must be either a non-static member function or a non-member function", decl
);
8556 for (p
= argtypes
; p
&& p
!= void_list_node
; p
= TREE_CHAIN (p
))
8558 tree arg
= non_reference (TREE_VALUE (p
));
8559 /* IS_AGGR_TYPE, rather than CLASS_TYPE_P, is used
8560 because these checks are performed even on
8561 template functions. */
8562 if (IS_AGGR_TYPE (arg
) || TREE_CODE (arg
) == ENUMERAL_TYPE
)
8566 if (!p
|| p
== void_list_node
)
8571 error ("`%D' must have an argument of class or "
8579 /* There are no restrictions on the arguments to an overloaded
8581 if (operator_code
== CALL_EXPR
)
8584 if (IDENTIFIER_TYPENAME_P (name
) && ! DECL_TEMPLATE_INFO (decl
))
8586 tree t
= TREE_TYPE (name
);
8589 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
8590 const char *what
= 0;
8593 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
8595 if (TREE_CODE (t
) == VOID_TYPE
)
8597 else if (t
== current_class_type
)
8598 what
= "the same type";
8599 /* Don't force t to be complete here. */
8600 else if (IS_AGGR_TYPE (t
)
8601 && COMPLETE_TYPE_P (t
)
8602 && DERIVED_FROM_P (t
, current_class_type
))
8603 what
= "a base class";
8605 if (what
&& warn_conversion
)
8606 warning ("conversion to %s%s will never use a type conversion operator",
8607 ref
? "a reference to " : "", what
);
8610 if (operator_code
== COND_EXPR
)
8613 error ("ISO C++ prohibits overloading operator ?:");
8615 else if (ambi_op_p (operator_code
))
8618 /* We pick the one-argument operator codes by default, so
8619 we don't have to change anything. */
8621 else if (arity
== 2)
8623 /* If we thought this was a unary operator, we now know
8624 it to be a binary operator. */
8625 switch (operator_code
)
8628 operator_code
= MULT_EXPR
;
8632 operator_code
= BIT_AND_EXPR
;
8636 operator_code
= PLUS_EXPR
;
8640 operator_code
= MINUS_EXPR
;
8643 case PREINCREMENT_EXPR
:
8644 operator_code
= POSTINCREMENT_EXPR
;
8647 case PREDECREMENT_EXPR
:
8648 operator_code
= POSTDECREMENT_EXPR
;
8655 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
8657 if ((operator_code
== POSTINCREMENT_EXPR
8658 || operator_code
== POSTDECREMENT_EXPR
)
8659 && ! processing_template_decl
8660 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)), integer_type_node
))
8663 error ("postfix `%D' must take `int' as its argument",
8667 ("postfix `%D' must take `int' as its second argument",
8674 error ("`%D' must take either zero or one argument", decl
);
8676 error ("`%D' must take either one or two arguments", decl
);
8679 /* More Effective C++ rule 6. */
8681 && (operator_code
== POSTINCREMENT_EXPR
8682 || operator_code
== POSTDECREMENT_EXPR
8683 || operator_code
== PREINCREMENT_EXPR
8684 || operator_code
== PREDECREMENT_EXPR
))
8686 tree arg
= TREE_VALUE (argtypes
);
8687 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
8688 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
8689 arg
= TREE_TYPE (arg
);
8690 arg
= TYPE_MAIN_VARIANT (arg
);
8691 if (operator_code
== PREINCREMENT_EXPR
8692 || operator_code
== PREDECREMENT_EXPR
)
8694 if (TREE_CODE (ret
) != REFERENCE_TYPE
8695 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
8697 warning ("prefix `%D' should return `%T'", decl
,
8698 build_reference_type (arg
));
8702 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
8703 warning ("postfix `%D' should return `%T'", decl
, arg
);
8707 else if (unary_op_p (operator_code
))
8712 error ("`%D' must take `void'", decl
);
8714 error ("`%D' must take exactly one argument", decl
);
8717 else /* if (binary_op_p (operator_code)) */
8722 error ("`%D' must take exactly one argument", decl
);
8724 error ("`%D' must take exactly two arguments", decl
);
8727 /* More Effective C++ rule 7. */
8729 && (operator_code
== TRUTH_ANDIF_EXPR
8730 || operator_code
== TRUTH_ORIF_EXPR
8731 || operator_code
== COMPOUND_EXPR
))
8732 warning ("user-defined `%D' always evaluates both arguments",
8736 /* Effective C++ rule 23. */
8739 && !DECL_ASSIGNMENT_OPERATOR_P (decl
)
8740 && (operator_code
== PLUS_EXPR
8741 || operator_code
== MINUS_EXPR
8742 || operator_code
== TRUNC_DIV_EXPR
8743 || operator_code
== MULT_EXPR
8744 || operator_code
== TRUNC_MOD_EXPR
)
8745 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
8746 warning ("`%D' should return by value", decl
);
8749 for (; argtypes
&& argtypes
!= void_list_node
;
8750 argtypes
= TREE_CHAIN (argtypes
))
8751 if (TREE_PURPOSE (argtypes
))
8753 TREE_PURPOSE (argtypes
) = NULL_TREE
;
8754 if (operator_code
== POSTINCREMENT_EXPR
8755 || operator_code
== POSTDECREMENT_EXPR
)
8758 pedwarn ("`%D' cannot have default arguments", decl
);
8761 error ("`%D' cannot have default arguments", decl
);
8770 tag_name (enum tag_types code
)
8787 /* Name lookup in an elaborated-type-specifier (after the keyword
8788 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
8789 elaborated-type-specifier is invalid, issue a diagnostic and return
8790 error_mark_node; otherwise, return the *_TYPE to which it referred.
8791 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
8794 check_elaborated_type_specifier (enum tag_types tag_code
,
8796 bool allow_template_p
)
8802 struct S { struct S *p; };
8804 name lookup will find the TYPE_DECL for the implicit "S::S"
8805 typedef. Adjust for that here. */
8806 if (DECL_SELF_REFERENCE_P (decl
))
8807 decl
= TYPE_NAME (TREE_TYPE (decl
));
8809 type
= TREE_TYPE (decl
);
8813 If the identifier resolves to a typedef-name or a template
8814 type-parameter, the elaborated-type-specifier is ill-formed.
8816 In other words, the only legitimate declaration to use in the
8817 elaborated type specifier is the implicit typedef created when
8818 the type is declared. */
8819 if (!DECL_IMPLICIT_TYPEDEF_P (decl
))
8821 error ("using typedef-name `%D' after `%s'", decl
, tag_name (tag_code
));
8822 return IS_AGGR_TYPE (type
) ? type
: error_mark_node
;
8825 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
8827 error ("using template type parameter `%T' after `%s'",
8828 type
, tag_name (tag_code
));
8829 return error_mark_node
;
8831 else if (TREE_CODE (type
) != RECORD_TYPE
8832 && TREE_CODE (type
) != UNION_TYPE
8833 && tag_code
!= enum_type
)
8835 error ("`%T' referred to as `%s'", type
, tag_name (tag_code
));
8836 return error_mark_node
;
8838 else if (TREE_CODE (type
) != ENUMERAL_TYPE
8839 && tag_code
== enum_type
)
8841 error ("`%T' referred to as enum", type
);
8842 return error_mark_node
;
8844 else if (!allow_template_p
8845 && TREE_CODE (type
) == RECORD_TYPE
8846 && CLASSTYPE_IS_TEMPLATE (type
))
8848 /* If a class template appears as elaborated type specifier
8849 without a template header such as:
8851 template <class T> class C {};
8852 void f(class C); // No template header here
8854 then the required template argument is missing. */
8856 error ("template argument required for `%s %T'",
8857 tag_name (tag_code
),
8858 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
)));
8859 return error_mark_node
;
8865 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
8866 Define the tag as a forward-reference if it is not defined.
8868 If a declaration is given, process it here, and report an error if
8869 multiple declarations are not identical.
8871 GLOBALIZE is false when this is also a definition. Only look in
8872 the current frame for the name (since C++ allows new names in any
8875 TEMPLATE_HEADER_P is true when this declaration is preceded by
8876 a set of template parameters. */
8879 xref_tag (enum tag_types tag_code
, tree name
,
8880 bool globalize
, bool template_header_p
)
8882 enum tree_code code
;
8884 struct cp_binding_level
*b
= current_binding_level
;
8885 tree context
= NULL_TREE
;
8887 timevar_push (TV_NAME_LOOKUP
);
8889 my_friendly_assert (TREE_CODE (name
) == IDENTIFIER_NODE
, 0);
8901 code
= ENUMERAL_TYPE
;
8909 /* If we know we are defining this tag, only look it up in
8910 this scope and don't try to find it as a type. */
8911 t
= lookup_tag (code
, name
, b
, 1);
8915 tree decl
= lookup_name (name
, 2);
8917 if (decl
&& DECL_CLASS_TEMPLATE_P (decl
))
8918 decl
= DECL_TEMPLATE_RESULT (decl
);
8920 if (decl
&& TREE_CODE (decl
) == TYPE_DECL
)
8922 /* Two cases we need to consider when deciding if a class
8923 template is allowed as an elaborated type specifier:
8924 1. It is a self reference to its own class.
8925 2. It comes with a template header.
8929 template <class T> class C {
8930 class C *c1; // DECL_SELF_REFERENCE_P is true
8933 template <class U> class C; // template_header_p is true
8934 template <class T> class C<T>::D {
8935 class C *c2; // DECL_SELF_REFERENCE_P is true
8938 t
= check_elaborated_type_specifier (tag_code
,
8941 | DECL_SELF_REFERENCE_P (decl
));
8942 if (t
== error_mark_node
)
8943 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
8948 if (t
&& current_class_type
8949 && template_class_depth (current_class_type
)
8950 && template_header_p
)
8952 /* Since GLOBALIZE is nonzero, we are not looking at a
8953 definition of this tag. Since, in addition, we are currently
8954 processing a (member) template declaration of a template
8955 class, we must be very careful; consider:
8962 { template <class V>
8963 friend struct S1; };
8965 Here, the S2::S1 declaration should not be confused with the
8966 outer declaration. In particular, the inner version should
8967 have a template parameter of level 2, not level 1. This
8968 would be particularly important if the member declaration
8971 template <class V = U> friend struct S1;
8973 say, when we should tsubst into `U' when instantiating
8974 S2. On the other hand, when presented with:
8984 we must find the inner binding eventually. We
8985 accomplish this by making sure that the new type we
8986 create to represent this declaration has the right
8988 context
= TYPE_CONTEXT (t
);
8995 /* If no such tag is yet defined, create a forward-reference node
8996 and record it as the "definition".
8997 When a real declaration of this type is found,
8998 the forward-reference will be altered into a real type. */
8999 if (code
== ENUMERAL_TYPE
)
9001 error ("use of enum `%#D' without previous declaration", name
);
9002 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
9006 t
= make_aggr_type (code
);
9007 TYPE_CONTEXT (t
) = context
;
9008 pushtag (name
, t
, globalize
);
9013 if (!globalize
&& processing_template_decl
&& IS_AGGR_TYPE (t
))
9014 redeclare_class_template (t
, current_template_parms
);
9015 else if (!processing_template_decl
9017 && CLASSTYPE_IS_TEMPLATE (t
))
9019 error ("redeclaration of `%T' as a non-template", t
);
9020 t
= error_mark_node
;
9024 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
9028 xref_tag_from_type (tree old
, tree id
, int globalize
)
9030 enum tag_types tag_kind
;
9032 if (TREE_CODE (old
) == RECORD_TYPE
)
9033 tag_kind
= (CLASSTYPE_DECLARED_CLASS (old
) ? class_type
: record_type
);
9035 tag_kind
= union_type
;
9037 if (id
== NULL_TREE
)
9038 id
= TYPE_IDENTIFIER (old
);
9040 return xref_tag (tag_kind
, id
, globalize
, false);
9043 /* Create the binfo hierarchy for REF with (possibly NULL) base list
9044 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
9045 access_* node, and the TREE_VALUE is the type of the base-class.
9046 Non-NULL TREE_TYPE indicates virtual inheritance. */
9049 xref_basetypes (tree ref
, tree base_list
)
9052 tree binfo
, base_binfo
;
9053 unsigned max_vbases
= 0; /* Maxium direct & indirect virtual bases. */
9054 unsigned max_bases
= 0; /* Maxium direct bases. */
9056 tree default_access
;
9057 tree igo_prev
; /* Track Inheritance Graph Order. */
9059 if (ref
== error_mark_node
)
9062 /* The base of a derived class is private by default, all others are
9064 default_access
= (TREE_CODE (ref
) == RECORD_TYPE
9065 && CLASSTYPE_DECLARED_CLASS (ref
)
9066 ? access_private_node
: access_public_node
);
9068 /* First, make sure that any templates in base-classes are
9069 instantiated. This ensures that if we call ourselves recursively
9070 we do not get confused about which classes are marked and which
9075 tree basetype
= TREE_VALUE (*basep
);
9077 if (!(processing_template_decl
&& uses_template_parms (basetype
))
9078 && !complete_type_or_else (basetype
, NULL
))
9079 /* An incomplete type. Remove it from the list. */
9080 *basep
= TREE_CHAIN (*basep
);
9084 if (TREE_TYPE (*basep
))
9086 if (CLASS_TYPE_P (basetype
))
9087 max_vbases
+= VEC_length (tree
, CLASSTYPE_VBASECLASSES (basetype
));
9088 basep
= &TREE_CHAIN (*basep
);
9092 SET_CLASSTYPE_MARKED (ref
);
9094 /* The binfo slot should be empty, unless this is an (ill-formed)
9096 my_friendly_assert (!TYPE_BINFO (ref
) || TYPE_SIZE (ref
), 20040706);
9097 my_friendly_assert (TYPE_MAIN_VARIANT (ref
) == ref
, 20040712);
9099 binfo
= make_tree_binfo (max_bases
);
9101 TYPE_BINFO (ref
) = binfo
;
9102 BINFO_OFFSET (binfo
) = size_zero_node
;
9103 BINFO_TYPE (binfo
) = ref
;
9107 BINFO_BASE_ACCESSES (binfo
) = VEC_alloc (tree
, max_bases
);
9108 /* An aggregate cannot have baseclasses. */
9109 CLASSTYPE_NON_AGGREGATE (ref
) = 1;
9111 if (TREE_CODE (ref
) == UNION_TYPE
)
9112 error ("derived union `%T' invalid", ref
);
9117 TYPE_USES_MULTIPLE_INHERITANCE (ref
) = 1;
9118 /* If there is more than one non-empty they cannot be at the
9120 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref
) = 1;
9122 if (TYPE_FOR_JAVA (ref
))
9123 error ("Java class '%T' cannot have multiple bases", ref
);
9128 CLASSTYPE_VBASECLASSES (ref
) = VEC_alloc (tree
, max_vbases
);
9129 TYPE_USES_VIRTUAL_BASECLASSES (ref
) = 1;
9130 /* Converting to a virtual base class requires looking up the
9131 offset of the virtual base. */
9132 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref
) = 1;
9134 if (TYPE_FOR_JAVA (ref
))
9135 error ("Java class '%T' cannot have virtual bases", ref
);
9138 for (igo_prev
= binfo
; base_list
; base_list
= TREE_CHAIN (base_list
))
9140 tree access
= TREE_PURPOSE (base_list
);
9141 int via_virtual
= TREE_TYPE (base_list
) != NULL_TREE
;
9142 tree basetype
= TREE_VALUE (base_list
);
9144 if (access
== access_default_node
)
9145 access
= default_access
;
9147 if (TREE_CODE (basetype
) == TYPE_DECL
)
9148 basetype
= TREE_TYPE (basetype
);
9149 if (TREE_CODE (basetype
) != RECORD_TYPE
9150 && TREE_CODE (basetype
) != TYPENAME_TYPE
9151 && TREE_CODE (basetype
) != TEMPLATE_TYPE_PARM
9152 && TREE_CODE (basetype
) != BOUND_TEMPLATE_TEMPLATE_PARM
)
9154 error ("base type `%T' fails to be a struct or class type",
9159 if (CLASSTYPE_MARKED (basetype
))
9161 if (basetype
== ref
)
9162 error ("recursive type `%T' undefined", basetype
);
9164 error ("duplicate base type `%T' invalid", basetype
);
9167 SET_CLASSTYPE_MARKED (basetype
);
9169 if (TYPE_FOR_JAVA (basetype
) && (current_lang_depth () == 0))
9170 TYPE_FOR_JAVA (ref
) = 1;
9172 base_binfo
= NULL_TREE
;
9173 if (CLASS_TYPE_P (basetype
) && !dependent_type_p (basetype
))
9175 base_binfo
= TYPE_BINFO (basetype
);
9176 /* The orignal basetype could have been a typedef'd type. */
9177 basetype
= BINFO_TYPE (base_binfo
);
9179 /* Inherit flags from the base. */
9180 TYPE_HAS_NEW_OPERATOR (ref
)
9181 |= TYPE_HAS_NEW_OPERATOR (basetype
);
9182 TYPE_HAS_ARRAY_NEW_OPERATOR (ref
)
9183 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype
);
9184 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
9185 TYPE_USES_MULTIPLE_INHERITANCE (ref
)
9186 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype
);
9187 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref
)
9188 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype
);
9189 TYPE_HAS_CONVERSION (ref
) |= TYPE_HAS_CONVERSION (basetype
);
9192 base_binfo
= copy_binfo (base_binfo
, basetype
, ref
,
9193 &igo_prev
, via_virtual
);
9194 if (!BINFO_INHERITANCE_CHAIN (base_binfo
))
9195 BINFO_INHERITANCE_CHAIN (base_binfo
) = binfo
;
9197 BINFO_BASE_APPEND (binfo
, base_binfo
);
9198 BINFO_BASE_ACCESS_APPEND (binfo
, access
);
9201 /* Unmark all the types. */
9202 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
9203 CLEAR_CLASSTYPE_MARKED (BINFO_TYPE (base_binfo
));
9204 CLEAR_CLASSTYPE_MARKED (ref
);
9208 /* Begin compiling the definition of an enumeration type.
9209 NAME is its name (or null if anonymous).
9210 Returns the type object, as yet incomplete.
9211 Also records info about it so that build_enumerator
9212 may be used to declare the individual values as they are read. */
9215 start_enum (tree name
)
9217 tree enumtype
= NULL_TREE
;
9218 struct cp_binding_level
*b
= current_binding_level
;
9220 /* If this is the real definition for a previous forward reference,
9221 fill in the contents in the same object that used to be the
9222 forward reference. */
9224 if (name
!= NULL_TREE
)
9225 enumtype
= lookup_tag (ENUMERAL_TYPE
, name
, b
, 1);
9227 if (enumtype
!= NULL_TREE
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
9229 error ("multiple definition of `%#T'", enumtype
);
9230 error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype
));
9231 /* Clear out TYPE_VALUES, and start again. */
9232 TYPE_VALUES (enumtype
) = NULL_TREE
;
9236 enumtype
= make_node (ENUMERAL_TYPE
);
9237 pushtag (name
, enumtype
, 0);
9243 /* After processing and defining all the values of an enumeration type,
9244 install their decls in the enumeration type and finish it off.
9245 ENUMTYPE is the type object and VALUES a list of name-value pairs. */
9248 finish_enum (tree enumtype
)
9260 integer_type_kind itk
;
9261 tree underlying_type
= NULL_TREE
;
9263 /* We built up the VALUES in reverse order. */
9264 TYPE_VALUES (enumtype
) = nreverse (TYPE_VALUES (enumtype
));
9266 /* For an enum defined in a template, just set the type of the values;
9267 all further processing is postponed until the template is
9268 instantiated. We need to set the type so that tsubst of a CONST_DECL
9270 if (processing_template_decl
)
9272 for (values
= TYPE_VALUES (enumtype
);
9274 values
= TREE_CHAIN (values
))
9275 TREE_TYPE (TREE_VALUE (values
)) = enumtype
;
9276 if (at_function_scope_p ())
9277 add_stmt (build_min (TAG_DEFN
, enumtype
));
9281 /* Determine the minimum and maximum values of the enumerators. */
9282 if (TYPE_VALUES (enumtype
))
9284 minnode
= maxnode
= NULL_TREE
;
9286 for (values
= TYPE_VALUES (enumtype
);
9288 values
= TREE_CHAIN (values
))
9290 decl
= TREE_VALUE (values
);
9292 /* [dcl.enum]: Following the closing brace of an enum-specifier,
9293 each enumerator has the type of its enumeration. Prior to the
9294 closing brace, the type of each enumerator is the type of its
9295 initializing value. */
9296 TREE_TYPE (decl
) = enumtype
;
9298 /* Update the minimum and maximum values, if appropriate. */
9299 value
= DECL_INITIAL (decl
);
9300 /* Figure out what the minimum and maximum values of the
9303 minnode
= maxnode
= value
;
9304 else if (tree_int_cst_lt (maxnode
, value
))
9306 else if (tree_int_cst_lt (value
, minnode
))
9309 /* Set the TREE_TYPE for the values as well. That's so that when
9310 we call decl_constant_value we get an entity of the right type
9311 (but with the constant value). But first make a copy so we
9312 don't clobber shared INTEGER_CSTs. */
9313 if (TREE_TYPE (value
) != enumtype
)
9315 value
= DECL_INITIAL (decl
) = copy_node (value
);
9316 TREE_TYPE (value
) = enumtype
;
9323 If the enumerator-list is empty, the underlying type is as if
9324 the enumeration had a single enumerator with value 0. */
9325 minnode
= maxnode
= integer_zero_node
;
9327 /* Compute the number of bits require to represent all values of the
9328 enumeration. We must do this before the type of MINNODE and
9329 MAXNODE are transformed, since min_precision relies on the
9330 TREE_TYPE of the value it is passed. */
9331 unsignedp
= tree_int_cst_sgn (minnode
) >= 0;
9332 lowprec
= min_precision (minnode
, unsignedp
);
9333 highprec
= min_precision (maxnode
, unsignedp
);
9334 precision
= MAX (lowprec
, highprec
);
9336 /* Determine the underlying type of the enumeration.
9340 The underlying type of an enumeration is an integral type that
9341 can represent all the enumerator values defined in the
9342 enumeration. It is implementation-defined which integral type is
9343 used as the underlying type for an enumeration except that the
9344 underlying type shall not be larger than int unless the value of
9345 an enumerator cannot fit in an int or unsigned int.
9347 We use "int" or an "unsigned int" as the underlying type, even if
9348 a smaller integral type would work, unless the user has
9349 explicitly requested that we use the smallest possible type. */
9350 for (itk
= (flag_short_enums
? itk_char
: itk_int
);
9354 underlying_type
= integer_types
[itk
];
9355 if (TYPE_PRECISION (underlying_type
) >= precision
9356 && TYPE_UNSIGNED (underlying_type
) == unsignedp
)
9359 if (itk
== itk_none
)
9363 IF no integral type can represent all the enumerator values, the
9364 enumeration is ill-formed. */
9365 error ("no integral type can represent all of the enumerator values "
9366 "for `%T'", enumtype
);
9367 precision
= TYPE_PRECISION (long_long_integer_type_node
);
9368 underlying_type
= integer_types
[itk_unsigned_long_long
];
9371 /* Compute the minium and maximum values for the type.
9375 For an enumeration where emin is the smallest enumerator and emax
9376 is the largest, the values of the enumeration are the values of the
9377 underlying type in the range bmin to bmax, where bmin and bmax are,
9378 respectively, the smallest and largest values of the smallest bit-
9379 field that can store emin and emax. */
9380 TYPE_PRECISION (enumtype
) = precision
;
9381 set_min_and_max_values_for_integral_type (enumtype
, precision
, unsignedp
);
9385 The value of sizeof() applied to an enumeration type, an object
9386 of an enumeration type, or an enumerator, is the value of sizeof()
9387 applied to the underlying type. */
9388 TYPE_SIZE (enumtype
) = TYPE_SIZE (underlying_type
);
9389 TYPE_SIZE_UNIT (enumtype
) = TYPE_SIZE_UNIT (underlying_type
);
9390 TYPE_MODE (enumtype
) = TYPE_MODE (underlying_type
);
9391 TYPE_ALIGN (enumtype
) = TYPE_ALIGN (underlying_type
);
9392 TYPE_USER_ALIGN (enumtype
) = TYPE_USER_ALIGN (underlying_type
);
9393 TYPE_UNSIGNED (enumtype
) = TYPE_UNSIGNED (underlying_type
);
9395 /* Convert each of the enumerators to the type of the underlying
9396 type of the enumeration. */
9397 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
9399 decl
= TREE_VALUE (values
);
9400 value
= perform_implicit_conversion (underlying_type
,
9401 DECL_INITIAL (decl
));
9402 TREE_TYPE (value
) = enumtype
;
9403 DECL_INITIAL (decl
) = value
;
9404 TREE_VALUE (values
) = value
;
9407 /* Fix up all variant types of this enum type. */
9408 for (t
= TYPE_MAIN_VARIANT (enumtype
); t
; t
= TYPE_NEXT_VARIANT (t
))
9410 TYPE_VALUES (t
) = TYPE_VALUES (enumtype
);
9411 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (enumtype
);
9412 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (enumtype
);
9413 TYPE_SIZE (t
) = TYPE_SIZE (enumtype
);
9414 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (enumtype
);
9415 TYPE_MODE (t
) = TYPE_MODE (enumtype
);
9416 TYPE_PRECISION (t
) = TYPE_PRECISION (enumtype
);
9417 TYPE_ALIGN (t
) = TYPE_ALIGN (enumtype
);
9418 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (enumtype
);
9419 TYPE_UNSIGNED (t
) = TYPE_UNSIGNED (enumtype
);
9422 /* Finish debugging output for this type. */
9423 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
9426 /* Build and install a CONST_DECL for an enumeration constant of the
9427 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
9428 Assignment of sequential values by default is handled here. */
9431 build_enumerator (tree name
, tree value
, tree enumtype
)
9437 /* Remove no-op casts from the value. */
9439 STRIP_TYPE_NOPS (value
);
9441 if (! processing_template_decl
)
9443 /* Validate and default VALUE. */
9444 if (value
!= NULL_TREE
)
9446 value
= decl_constant_value (value
);
9448 if (TREE_CODE (value
) == INTEGER_CST
)
9450 value
= perform_integral_promotions (value
);
9451 constant_expression_warning (value
);
9455 error ("enumerator value for `%D' not integer constant", name
);
9460 /* Default based on previous value. */
9461 if (value
== NULL_TREE
)
9465 if (TYPE_VALUES (enumtype
))
9467 /* The next value is the previous value ... */
9468 prev_value
= DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype
)));
9470 value
= cp_build_binary_op (PLUS_EXPR
,
9474 if (tree_int_cst_lt (value
, prev_value
))
9475 error ("overflow in enumeration values at `%D'", name
);
9478 value
= integer_zero_node
;
9481 /* Remove no-op casts from the value. */
9482 STRIP_TYPE_NOPS (value
);
9485 /* C++ associates enums with global, function, or class declarations. */
9486 context
= current_scope ();
9488 context
= current_namespace
;
9490 /* Build the actual enumeration constant. Note that the enumeration
9491 constants have the type of their initializers until the
9492 enumeration is complete:
9496 Following the closing brace of an enum-specifier, each enumer-
9497 ator has the type of its enumeration. Prior to the closing
9498 brace, the type of each enumerator is the type of its
9501 In finish_enum we will reset the type. Of course, if we're
9502 processing a template, there may be no value. */
9503 type
= value
? TREE_TYPE (value
) : NULL_TREE
;
9505 if (context
&& context
== current_class_type
)
9506 /* This enum declaration is local to the class. We need the full
9507 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
9508 decl
= build_lang_decl (CONST_DECL
, name
, type
);
9510 /* It's a global enum, or it's local to a function. (Note local to
9511 a function could mean local to a class method. */
9512 decl
= build_decl (CONST_DECL
, name
, type
);
9514 DECL_CONTEXT (decl
) = FROB_CONTEXT (context
);
9515 TREE_CONSTANT (decl
) = 1;
9516 TREE_INVARIANT (decl
) = 1;
9517 TREE_READONLY (decl
) = 1;
9518 DECL_INITIAL (decl
) = value
;
9520 if (context
&& context
== current_class_type
)
9521 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
9522 on the TYPE_FIELDS list for `S'. (That's so that you can say
9523 things like `S::i' later.) */
9524 finish_member_declaration (decl
);
9528 /* Add this enumeration constant to the list for this type. */
9529 TYPE_VALUES (enumtype
) = tree_cons (name
, decl
, TYPE_VALUES (enumtype
));
9533 /* We're defining DECL. Make sure that it's type is OK. */
9536 check_function_type (tree decl
, tree current_function_parms
)
9538 tree fntype
= TREE_TYPE (decl
);
9539 tree return_type
= complete_type (TREE_TYPE (fntype
));
9541 /* In a function definition, arg types must be complete. */
9542 require_complete_types_for_parms (current_function_parms
);
9544 if (!COMPLETE_OR_VOID_TYPE_P (return_type
))
9546 error ("return type `%#T' is incomplete", TREE_TYPE (fntype
));
9548 /* Make it return void instead, but don't change the
9549 type of the DECL_RESULT, in case we have a named return value. */
9550 if (TREE_CODE (fntype
) == METHOD_TYPE
)
9552 tree ctype
= TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype
)));
9554 = build_method_type_directly (ctype
,
9556 FUNCTION_ARG_CHAIN (decl
));
9560 = build_function_type (void_type_node
,
9561 TYPE_ARG_TYPES (TREE_TYPE (decl
)));
9563 = build_exception_variant (fntype
,
9564 TYPE_RAISES_EXCEPTIONS (fntype
));
9567 abstract_virtuals_error (decl
, TREE_TYPE (fntype
));
9570 /* Create the FUNCTION_DECL for a function definition.
9571 DECLSPECS and DECLARATOR are the parts of the declaration;
9572 they describe the function's name and the type it returns,
9573 but twisted together in a fashion that parallels the syntax of C.
9575 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
9576 DECLARATOR is really the DECL for the function we are about to
9577 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
9578 indicating that the function is an inline defined in-class.
9580 This function creates a binding context for the function body
9581 as well as setting up the FUNCTION_DECL in current_function_decl.
9583 For C++, we must first check whether that datum makes any sense.
9584 For example, "class A local_a(1,2);" means that variable local_a
9585 is an aggregate of type A, which should have a constructor
9586 applied to it with the argument list [1, 2]. */
9589 start_preparsed_function (tree decl1
, tree attrs
, int flags
)
9591 tree ctype
= NULL_TREE
;
9594 int doing_friend
= 0;
9595 struct cp_binding_level
*bl
;
9596 tree current_function_parms
;
9599 my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node
)) == VOID_TYPE
, 160);
9600 my_friendly_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
, 161);
9602 fntype
= TREE_TYPE (decl1
);
9603 if (TREE_CODE (fntype
) == METHOD_TYPE
)
9604 ctype
= TYPE_METHOD_BASETYPE (fntype
);
9606 /* ISO C++ 11.4/5. A friend function defined in a class is in
9607 the (lexical) scope of the class in which it is defined. */
9608 if (!ctype
&& DECL_FRIEND_P (decl1
))
9610 ctype
= DECL_FRIEND_CONTEXT (decl1
);
9612 /* CTYPE could be null here if we're dealing with a template;
9613 for example, `inline friend float foo()' inside a template
9614 will have no CTYPE set. */
9615 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
9621 if (DECL_DECLARED_INLINE_P (decl1
)
9622 && lookup_attribute ("noinline", attrs
))
9623 warning ("%Jinline function '%D' given attribute noinline", decl1
, decl1
);
9625 /* Determine the ELF visibility attribute for the function. */
9626 determine_visibility (decl1
);
9628 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1
))
9629 /* This is a constructor, we must ensure that any default args
9630 introduced by this definition are propagated to the clones
9631 now. The clones are used directly in overload resolution. */
9632 adjust_clone_args (decl1
);
9634 /* Sometimes we don't notice that a function is a static member, and
9635 build a METHOD_TYPE for it. Fix that up now. */
9636 if (ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
)
9637 && TREE_CODE (TREE_TYPE (decl1
)) == METHOD_TYPE
)
9639 revert_static_member_fn (decl1
);
9643 /* Set up current_class_type, and enter the scope of the class, if
9646 push_nested_class (ctype
);
9647 else if (DECL_STATIC_FUNCTION_P (decl1
))
9648 push_nested_class (DECL_CONTEXT (decl1
));
9650 /* Now that we have entered the scope of the class, we must restore
9651 the bindings for any template parameters surrounding DECL1, if it
9652 is an inline member template. (Order is important; consider the
9653 case where a template parameter has the same name as a field of
9654 the class.) It is not until after this point that
9655 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
9656 if (flags
& SF_INCLASS_INLINE
)
9657 maybe_begin_member_template_processing (decl1
);
9659 /* Effective C++ rule 15. */
9661 && DECL_OVERLOADED_OPERATOR_P (decl1
) == NOP_EXPR
9662 && TREE_CODE (TREE_TYPE (fntype
)) == VOID_TYPE
)
9663 warning ("`operator=' should return a reference to `*this'");
9665 /* Make the init_value nonzero so pushdecl knows this is not tentative.
9666 error_mark_node is replaced below (in poplevel) with the BLOCK. */
9667 if (!DECL_INITIAL (decl1
))
9668 DECL_INITIAL (decl1
) = error_mark_node
;
9670 /* This function exists in static storage.
9671 (This does not mean `static' in the C sense!) */
9672 TREE_STATIC (decl1
) = 1;
9674 /* We must call push_template_decl after current_class_type is set
9675 up. (If we are processing inline definitions after exiting a
9676 class scope, current_class_type will be NULL_TREE until set above
9677 by push_nested_class.) */
9678 if (processing_template_decl
)
9679 decl1
= push_template_decl (decl1
);
9681 /* We are now in the scope of the function being defined. */
9682 current_function_decl
= decl1
;
9684 /* Save the parm names or decls from this function's declarator
9685 where store_parm_decls will find them. */
9686 current_function_parms
= DECL_ARGUMENTS (decl1
);
9688 /* Make sure the parameter and return types are reasonable. When
9689 you declare a function, these types can be incomplete, but they
9690 must be complete when you define the function. */
9691 if (! processing_template_decl
)
9692 check_function_type (decl1
, current_function_parms
);
9694 /* Build the return declaration for the function. */
9695 restype
= TREE_TYPE (fntype
);
9696 /* Promote the value to int before returning it. */
9697 if (c_promoting_integer_type_p (restype
))
9698 restype
= type_promotes_to (restype
);
9699 if (DECL_RESULT (decl1
) == NULL_TREE
)
9703 resdecl
= build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (restype
));
9704 DECL_ARTIFICIAL (resdecl
) = 1;
9705 DECL_IGNORED_P (resdecl
) = 1;
9706 DECL_RESULT (decl1
) = resdecl
;
9708 c_apply_type_quals_to_decl (cp_type_quals (restype
), resdecl
);
9711 /* Initialize RTL machinery. We cannot do this until
9712 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
9713 even when processing a template; this is how we get
9714 CFUN set up, and our per-function variables initialized.
9715 FIXME factor out the non-RTL stuff. */
9716 bl
= current_binding_level
;
9717 allocate_struct_function (decl1
);
9718 current_binding_level
= bl
;
9720 /* Even though we're inside a function body, we still don't want to
9721 call expand_expr to calculate the size of a variable-sized array.
9722 We haven't necessarily assigned RTL to all variables yet, so it's
9723 not safe to try to expand expressions involving them. */
9724 cfun
->x_dont_save_pending_sizes_p
= 1;
9726 /* Start the statement-tree, start the tree now. */
9727 DECL_SAVED_TREE (decl1
) = push_stmt_list ();
9729 /* Let the user know we're compiling this function. */
9730 announce_function (decl1
);
9732 /* Record the decl so that the function name is defined.
9733 If we already have a decl for this name, and it is a FUNCTION_DECL,
9734 use the old decl. */
9735 if (!processing_template_decl
&& !(flags
& SF_PRE_PARSED
))
9737 /* A specialization is not used to guide overload resolution. */
9738 if (!DECL_FUNCTION_MEMBER_P (decl1
)
9739 && !(DECL_USE_TEMPLATE (decl1
) &&
9740 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1
))))
9742 tree olddecl
= pushdecl (decl1
);
9744 if (olddecl
== error_mark_node
)
9745 /* If something went wrong when registering the declaration,
9746 use DECL1; we have to have a FUNCTION_DECL to use when
9747 parsing the body of the function. */
9750 /* Otherwise, OLDDECL is either a previous declaration of
9751 the same function or DECL1 itself. */
9756 /* We need to set the DECL_CONTEXT. */
9757 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
9758 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
9759 /* And make sure we have enough default args. */
9760 check_default_args (decl1
);
9762 fntype
= TREE_TYPE (decl1
);
9765 /* Reset these in case the call to pushdecl changed them. */
9766 current_function_decl
= decl1
;
9769 /* If we are (erroneously) defining a function that we have already
9770 defined before, wipe out what we knew before. */
9771 if (!DECL_PENDING_INLINE_P (decl1
))
9772 DECL_SAVED_FUNCTION_DATA (decl1
) = NULL
;
9774 if (ctype
&& !doing_friend
&& !DECL_STATIC_FUNCTION_P (decl1
))
9776 /* We know that this was set up by `grokclassfn'. We do not
9777 wait until `store_parm_decls', since evil parse errors may
9778 never get us to that point. Here we keep the consistency
9779 between `current_class_type' and `current_class_ptr'. */
9780 tree t
= DECL_ARGUMENTS (decl1
);
9782 my_friendly_assert (t
!= NULL_TREE
&& TREE_CODE (t
) == PARM_DECL
,
9784 my_friendly_assert (TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
,
9787 cp_function_chain
->x_current_class_ref
9788 = build_indirect_ref (t
, NULL
);
9789 cp_function_chain
->x_current_class_ptr
= t
;
9791 /* Constructors and destructors need to know whether they're "in
9792 charge" of initializing virtual base classes. */
9794 if (DECL_HAS_IN_CHARGE_PARM_P (decl1
))
9796 current_in_charge_parm
= t
;
9799 if (DECL_HAS_VTT_PARM_P (decl1
))
9801 if (DECL_NAME (t
) != vtt_parm_identifier
)
9803 current_vtt_parm
= t
;
9807 if (DECL_INTERFACE_KNOWN (decl1
))
9809 tree ctx
= decl_function_context (decl1
);
9811 if (DECL_NOT_REALLY_EXTERN (decl1
))
9812 DECL_EXTERNAL (decl1
) = 0;
9814 if (ctx
!= NULL_TREE
&& DECL_DECLARED_INLINE_P (ctx
)
9815 && TREE_PUBLIC (ctx
))
9816 /* This is a function in a local class in an extern inline
9818 comdat_linkage (decl1
);
9820 /* If this function belongs to an interface, it is public.
9821 If it belongs to someone else's interface, it is also external.
9822 This only affects inlines and template instantiations. */
9823 else if (interface_unknown
== 0
9824 && ! DECL_TEMPLATE_INSTANTIATION (decl1
))
9826 if (DECL_DECLARED_INLINE_P (decl1
)
9827 || DECL_TEMPLATE_INSTANTIATION (decl1
)
9828 || processing_template_decl
)
9830 DECL_EXTERNAL (decl1
)
9832 || (DECL_DECLARED_INLINE_P (decl1
)
9833 && ! flag_implement_inlines
9834 && !DECL_VINDEX (decl1
)));
9836 /* For WIN32 we also want to put these in linkonce sections. */
9837 maybe_make_one_only (decl1
);
9840 DECL_EXTERNAL (decl1
) = 0;
9841 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
9842 DECL_INTERFACE_KNOWN (decl1
) = 1;
9843 /* If this function is in an interface implemented in this file,
9844 make sure that the backend knows to emit this function
9846 if (!DECL_EXTERNAL (decl1
))
9847 mark_needed (decl1
);
9849 else if (interface_unknown
&& interface_only
9850 && ! DECL_TEMPLATE_INSTANTIATION (decl1
))
9852 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
9853 interface, we will have interface_only set but not
9854 interface_known. In that case, we don't want to use the normal
9855 heuristics because someone will supply a #pragma implementation
9856 elsewhere, and deducing it here would produce a conflict. */
9857 comdat_linkage (decl1
);
9858 DECL_EXTERNAL (decl1
) = 0;
9859 DECL_INTERFACE_KNOWN (decl1
) = 1;
9860 DECL_DEFER_OUTPUT (decl1
) = 1;
9864 /* This is a definition, not a reference.
9865 So clear DECL_EXTERNAL. */
9866 DECL_EXTERNAL (decl1
) = 0;
9868 if ((DECL_DECLARED_INLINE_P (decl1
)
9869 || DECL_TEMPLATE_INSTANTIATION (decl1
))
9870 && ! DECL_INTERFACE_KNOWN (decl1
)
9871 /* Don't try to defer nested functions for now. */
9872 && ! decl_function_context (decl1
))
9873 DECL_DEFER_OUTPUT (decl1
) = 1;
9875 DECL_INTERFACE_KNOWN (decl1
) = 1;
9878 begin_scope (sk_function_parms
, decl1
);
9882 if (DECL_DESTRUCTOR_P (decl1
))
9884 dtor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
9885 DECL_CONTEXT (dtor_label
) = current_function_decl
;
9888 start_fname_decls ();
9890 store_parm_decls (current_function_parms
);
9894 /* Like start_preparsed_function, except that instead of a
9895 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
9897 Returns 1 on success. If the DECLARATOR is not suitable for a function
9898 (it defines a datum instead), we return 0, which tells
9899 yyparse to report a parse error. */
9902 start_function (cp_decl_specifier_seq
*declspecs
,
9903 const cp_declarator
*declarator
,
9908 if (have_extern_spec
)
9910 declspecs
->storage_class
= sc_extern
;
9911 /* This should only be done once on the outermost decl. */
9912 have_extern_spec
= false;
9915 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, &attrs
);
9916 /* If the declarator is not suitable for a function definition,
9917 cause a syntax error. */
9918 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
)
9921 cplus_decl_attributes (&decl1
, attrs
, 0);
9923 /* If #pragma weak was used, mark the decl weak now. */
9924 if (global_scope_p (current_binding_level
))
9925 maybe_apply_pragma_weak (decl1
);
9927 if (DECL_MAIN_P (decl1
))
9929 /* If this doesn't return integer_type, or a typedef to
9930 integer_type, complain. */
9931 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl1
)), integer_type_node
))
9933 if (pedantic
|| warn_return_type
)
9934 pedwarn ("return type for `main' changed to `int'");
9935 TREE_TYPE (decl1
) = default_function_type
;
9939 start_preparsed_function (decl1
, attrs
, /*flags=*/SF_DEFAULT
);
9944 /* Store the parameter declarations into the current function declaration.
9945 This is called after parsing the parameter declarations, before
9946 digesting the body of the function.
9948 Also install to binding contour return value identifier, if any. */
9951 store_parm_decls (tree current_function_parms
)
9953 tree fndecl
= current_function_decl
;
9956 /* This is a chain of any other decls that came in among the parm
9957 declarations. If a parm is declared with enum {foo, bar} x;
9958 then CONST_DECLs for foo and bar are put here. */
9959 tree nonparms
= NULL_TREE
;
9961 if (current_function_parms
)
9963 /* This case is when the function was defined with an ANSI prototype.
9964 The parms already have decls, so we need not do anything here
9965 except record them as in effect
9966 and complain if any redundant old-style parm decls were written. */
9968 tree specparms
= current_function_parms
;
9971 /* Must clear this because it might contain TYPE_DECLs declared
9973 current_binding_level
->names
= NULL
;
9975 /* If we're doing semantic analysis, then we'll call pushdecl
9976 for each of these. We must do them in reverse order so that
9977 they end in the correct forward order. */
9978 specparms
= nreverse (specparms
);
9980 for (parm
= specparms
; parm
; parm
= next
)
9982 next
= TREE_CHAIN (parm
);
9983 if (TREE_CODE (parm
) == PARM_DECL
)
9985 if (DECL_NAME (parm
) == NULL_TREE
9986 || TREE_CODE (parm
) != VOID_TYPE
)
9989 error ("parameter `%D' declared void", parm
);
9993 /* If we find an enum constant or a type tag,
9994 put it aside for the moment. */
9995 TREE_CHAIN (parm
) = NULL_TREE
;
9996 nonparms
= chainon (nonparms
, parm
);
10000 /* Get the decls in their original chain order and record in the
10001 function. This is all and only the PARM_DECLs that were
10002 pushed into scope by the loop above. */
10003 DECL_ARGUMENTS (fndecl
) = getdecls ();
10006 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
10008 /* Now store the final chain of decls for the arguments
10009 as the decl-chain of the current lexical scope.
10010 Put the enumerators in as well, at the front so that
10011 DECL_ARGUMENTS is not modified. */
10012 current_binding_level
->names
= chainon (nonparms
, DECL_ARGUMENTS (fndecl
));
10014 /* For a cloned function, we've already got all the code we need;
10015 there's no need to add any extra bits. */
10016 if (!DECL_CLONED_FUNCTION_P (fndecl
))
10018 /* Do the starting of the exception specifications, if we have any. */
10019 if (flag_exceptions
&& !processing_template_decl
10020 && flag_enforce_eh_specs
10021 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl
)))
10022 current_eh_spec_block
= begin_eh_spec_block ();
10027 /* We have finished doing semantic analysis on DECL, but have not yet
10028 generated RTL for its body. Save away our current state, so that
10029 when we want to generate RTL later we know what to do. */
10032 save_function_data (tree decl
)
10034 struct language_function
*f
;
10036 /* Save the language-specific per-function data so that we can
10037 get it back when we really expand this function. */
10038 my_friendly_assert (!DECL_PENDING_INLINE_P (decl
),
10042 f
= GGC_NEW (struct language_function
);
10043 memcpy (f
, cp_function_chain
, sizeof (struct language_function
));
10044 DECL_SAVED_FUNCTION_DATA (decl
) = f
;
10046 /* Clear out the bits we don't need. */
10047 f
->base
.x_stmt_tree
.x_cur_stmt_list
= NULL_TREE
;
10048 f
->x_named_label_uses
= NULL
;
10049 f
->bindings
= NULL
;
10050 f
->x_local_names
= NULL
;
10053 /* Add a note to mark the beginning of the main body of the constructor.
10054 This is used to set up the data structures for the cleanup regions for
10055 fully-constructed bases and members. */
10058 begin_constructor_body (void)
10062 /* Add a note to mark the end of the main body of the constructor. This is
10063 used to end the cleanup regions for fully-constructed bases and
10067 finish_constructor_body (void)
10071 /* Do all the processing for the beginning of a destructor; set up the
10072 vtable pointers and cleanups for bases and members. */
10075 begin_destructor_body (void)
10078 tree compound_stmt
;
10080 /* If the dtor is empty, and we know there is not any possible
10081 way we could use any vtable entries, before they are possibly
10082 set by a base class dtor, we don't have to setup the vtables,
10083 as we know that any base class dtor will set up any vtables
10084 it needs. We avoid MI, because one base class dtor can do a
10085 virtual dispatch to an overridden function that would need to
10086 have a non-related vtable set up, we cannot avoid setting up
10087 vtables in that case. We could change this to see if there
10088 is just one vtable.
10090 ??? In the destructor for a class, the vtables are set
10091 appropriately for that class. There will be no non-related
10092 vtables. jason 2001-12-11. */
10093 if_stmt
= begin_if_stmt ();
10095 /* If it is not safe to avoid setting up the vtables, then
10096 someone will change the condition to be boolean_true_node.
10097 (Actually, for now, we do not have code to set the condition
10098 appropriately, so we just assume that we always need to
10099 initialize the vtables.) */
10100 finish_if_stmt_cond (boolean_true_node
, if_stmt
);
10102 compound_stmt
= begin_compound_stmt (0);
10104 /* Make all virtual function table pointers in non-virtual base
10105 classes point to CURRENT_CLASS_TYPE's virtual function
10107 initialize_vtbl_ptrs (current_class_ptr
);
10109 finish_compound_stmt (compound_stmt
);
10110 finish_then_clause (if_stmt
);
10111 finish_if_stmt (if_stmt
);
10113 /* And insert cleanups for our bases and members so that they
10114 will be properly destroyed if we throw. */
10115 push_base_cleanups ();
10118 /* At the end of every destructor we generate code to delete the object if
10119 necessary. Do that now. */
10122 finish_destructor_body (void)
10126 /* Any return from a destructor will end up here; that way all base
10127 and member cleanups will be run when the function returns. */
10128 add_stmt (build_stmt (LABEL_EXPR
, dtor_label
));
10130 /* In a virtual destructor, we must call delete. */
10131 if (DECL_VIRTUAL_P (current_function_decl
))
10134 tree virtual_size
= cxx_sizeof (current_class_type
);
10138 At the point of definition of a virtual destructor (including
10139 an implicit definition), non-placement operator delete shall
10140 be looked up in the scope of the destructor's class and if
10141 found shall be accessible and unambiguous. */
10142 exprstmt
= build_op_delete_call
10143 (DELETE_EXPR
, current_class_ptr
, virtual_size
,
10144 /*global_p=*/false, NULL_TREE
);
10146 if_stmt
= begin_if_stmt ();
10147 finish_if_stmt_cond (build (BIT_AND_EXPR
, integer_type_node
,
10148 current_in_charge_parm
,
10151 finish_expr_stmt (exprstmt
);
10152 finish_then_clause (if_stmt
);
10153 finish_if_stmt (if_stmt
);
10157 /* Do the necessary processing for the beginning of a function body, which
10158 in this case includes member-initializers, but not the catch clauses of
10159 a function-try-block. Currently, this means opening a binding level
10160 for the member-initializers (in a ctor) and member cleanups (in a dtor).
10161 In other functions, this isn't necessary, but it doesn't hurt. */
10164 begin_function_body (void)
10168 if (processing_template_decl
)
10169 /* Do nothing now. */;
10171 /* Always keep the BLOCK node associated with the outermost pair of
10172 curly braces of a function. These are needed for correct
10173 operation of dwarfout.c. */
10174 keep_next_level (true);
10176 stmt
= begin_compound_stmt (BCS_FN_BODY
);
10178 if (processing_template_decl
)
10179 /* Do nothing now. */;
10180 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
10181 begin_constructor_body ();
10182 else if (DECL_DESTRUCTOR_P (current_function_decl
))
10183 begin_destructor_body ();
10188 /* Do the processing for the end of a function body. Currently, this means
10189 closing out the cleanups for fully-constructed bases and members, and in
10190 the case of the destructor, deleting the object if desired. Again, this
10191 is only meaningful for [cd]tors, since they are the only functions where
10192 there is a significant distinction between the main body and any
10193 function catch clauses. Handling, say, main() return semantics here
10194 would be wrong, as flowing off the end of a function catch clause for
10195 main() would also need to return 0. */
10198 finish_function_body (tree compstmt
)
10200 /* Close the block. */
10201 finish_compound_stmt (compstmt
);
10203 if (processing_template_decl
)
10204 /* Do nothing now. */;
10205 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
10206 finish_constructor_body ();
10207 else if (DECL_DESTRUCTOR_P (current_function_decl
))
10208 finish_destructor_body ();
10211 /* Finish up a function declaration and compile that function
10212 all the way to assembler language output. The free the storage
10213 for the function definition.
10215 FLAGS is a bitwise or of the following values:
10217 We just finished processing the body of an in-class inline
10218 function definition. (This processing will have taken place
10219 after the class definition is complete.) */
10222 finish_function (int flags
)
10224 tree fndecl
= current_function_decl
;
10225 tree fntype
, ctype
= NULL_TREE
;
10226 int inclass_inline
= (flags
& 2) != 0;
10229 /* When we get some parse errors, we can end up without a
10230 current_function_decl, so cope. */
10231 if (fndecl
== NULL_TREE
)
10232 return error_mark_node
;
10234 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl
)
10235 && DECL_VIRTUAL_P (fndecl
)
10236 && !processing_template_decl
)
10238 tree fnclass
= DECL_CONTEXT (fndecl
);
10239 if (fndecl
== CLASSTYPE_KEY_METHOD (fnclass
))
10240 keyed_classes
= tree_cons (NULL_TREE
, fnclass
, keyed_classes
);
10243 nested
= function_depth
> 1;
10244 fntype
= TREE_TYPE (fndecl
);
10246 /* TREE_READONLY (fndecl) = 1;
10247 This caused &foo to be of type ptr-to-const-function
10248 which then got a warning when stored in a ptr-to-function variable. */
10250 my_friendly_assert (building_stmt_tree (), 20000911);
10252 /* For a cloned function, we've already got all the code we need;
10253 there's no need to add any extra bits. */
10254 if (!DECL_CLONED_FUNCTION_P (fndecl
))
10256 if (DECL_MAIN_P (current_function_decl
))
10258 /* Make it so that `main' always returns 0 by default. */
10260 finish_return_stmt (integer_one_node
);
10262 finish_return_stmt (integer_zero_node
);
10266 /* Finish dealing with exception specifiers. */
10267 if (flag_exceptions
&& !processing_template_decl
10268 && flag_enforce_eh_specs
10269 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl
)))
10270 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
10271 (TREE_TYPE (current_function_decl
)),
10272 current_eh_spec_block
);
10275 /* If we're saving up tree structure, tie off the function now. */
10276 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
10278 finish_fname_decls ();
10280 /* If this function can't throw any exceptions, remember that. */
10281 if (!processing_template_decl
10282 && !cp_function_chain
->can_throw
10283 && !flag_non_call_exceptions
)
10284 TREE_NOTHROW (fndecl
) = 1;
10286 /* This must come after expand_function_end because cleanups might
10287 have declarations (from inline functions) that need to go into
10288 this function's blocks. */
10290 /* If the current binding level isn't the outermost binding level
10291 for this function, either there is a bug, or we have experienced
10292 syntax errors and the statement tree is malformed. */
10293 if (current_binding_level
->kind
!= sk_function_parms
)
10295 /* Make sure we have already experienced errors. */
10296 if (errorcount
== 0)
10299 /* Throw away the broken statement tree and extra binding
10301 DECL_SAVED_TREE (fndecl
) = alloc_stmt_list ();
10303 while (current_binding_level
->kind
!= sk_function_parms
)
10305 if (current_binding_level
->kind
== sk_class
)
10306 pop_nested_class ();
10308 poplevel (0, 0, 0);
10311 poplevel (1, 0, 1);
10313 /* Statements should always be full-expressions at the outermost set
10314 of curly braces for a function. */
10315 my_friendly_assert (stmts_are_full_exprs_p (), 19990831);
10317 /* Set up the named return value optimization, if we can. Candidate
10318 variables are selected in check_return_value. */
10319 if (current_function_return_value
)
10321 tree r
= current_function_return_value
;
10324 if (r
!= error_mark_node
10325 /* This is only worth doing for fns that return in memory--and
10326 simpler, since we don't have to worry about promoted modes. */
10327 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl
)), fndecl
)
10328 /* Only allow this for variables declared in the outer scope of
10329 the function so we know that their lifetime always ends with a
10330 return; see g++.dg/opt/nrv6.C. We could be more flexible if
10331 we were to do this optimization in tree-ssa. */
10332 && (outer
= BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl
)))
10333 /* Skip the artificial function body block. */
10334 && (outer
= BLOCK_SUBBLOCKS (outer
))
10335 && chain_member (r
, BLOCK_VARS (outer
)))
10336 finalize_nrv (&DECL_SAVED_TREE (fndecl
), r
, DECL_RESULT (fndecl
));
10338 current_function_return_value
= NULL_TREE
;
10341 /* Remember that we were in class scope. */
10342 if (current_class_name
)
10343 ctype
= current_class_type
;
10345 /* Must mark the RESULT_DECL as being in this function. */
10346 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
10348 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
10349 to the FUNCTION_DECL node itself. */
10350 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
10352 /* Save away current state, if appropriate. */
10353 if (!processing_template_decl
)
10354 save_function_data (fndecl
);
10356 /* Complain if there's just no return statement. */
10357 if (warn_return_type
10358 && TREE_CODE (TREE_TYPE (fntype
)) != VOID_TYPE
10359 && !dependent_type_p (TREE_TYPE (fntype
))
10360 && !current_function_returns_value
&& !current_function_returns_null
10361 /* Don't complain if we abort or throw. */
10362 && !current_function_returns_abnormally
10363 && !DECL_NAME (DECL_RESULT (fndecl
))
10364 /* Normally, with -Wreturn-type, flow will complain. Unless we're an
10365 inline function, as we might never be compiled separately. */
10366 && (DECL_INLINE (fndecl
) || processing_template_decl
))
10367 warning ("no return statement in function returning non-void");
10369 /* Store the end of the function, so that we get good line number
10370 info for the epilogue. */
10371 cfun
->function_end_locus
= input_location
;
10373 /* Genericize before inlining. */
10374 if (!processing_template_decl
)
10376 cp_genericize (fndecl
);
10378 /* Handle attribute((warn_unused_result)). Relies on gimple input. */
10379 c_warn_unused_result (&DECL_SAVED_TREE (fndecl
));
10382 /* We're leaving the context of this function, so zap cfun. It's still in
10383 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
10385 current_function_decl
= NULL
;
10387 /* If this is an in-class inline definition, we may have to pop the
10388 bindings for the template parameters that we added in
10389 maybe_begin_member_template_processing when start_function was
10391 if (inclass_inline
)
10392 maybe_end_member_template_processing ();
10394 /* Leave the scope of the class. */
10396 pop_nested_class ();
10402 /* Let the error reporting routines know that we're outside a
10403 function. For a nested function, this value is used in
10404 cxx_pop_function_context and then reset via pop_function_context. */
10405 current_function_decl
= NULL_TREE
;
10410 /* Create the FUNCTION_DECL for a function definition.
10411 DECLSPECS and DECLARATOR are the parts of the declaration;
10412 they describe the return type and the name of the function,
10413 but twisted together in a fashion that parallels the syntax of C.
10415 This function creates a binding context for the function body
10416 as well as setting up the FUNCTION_DECL in current_function_decl.
10418 Returns a FUNCTION_DECL on success.
10420 If the DECLARATOR is not suitable for a function (it defines a datum
10421 instead), we return 0, which tells yyparse to report a parse error.
10423 May return void_type_node indicating that this method is actually
10424 a friend. See grokfield for more details.
10426 Came here with a `.pushlevel' .
10428 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
10429 CHANGES TO CODE IN `grokfield'. */
10432 start_method (cp_decl_specifier_seq
*declspecs
,
10433 const cp_declarator
*declarator
, tree attrlist
)
10435 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
10438 if (fndecl
== error_mark_node
)
10439 return error_mark_node
;
10441 if (fndecl
== NULL
|| TREE_CODE (fndecl
) != FUNCTION_DECL
)
10443 error ("invalid member function declaration");
10444 return error_mark_node
;
10448 cplus_decl_attributes (&fndecl
, attrlist
, 0);
10450 /* Pass friends other than inline friend functions back. */
10451 if (fndecl
== void_type_node
)
10454 if (DECL_IN_AGGR_P (fndecl
))
10456 if (DECL_CONTEXT (fndecl
)
10457 && TREE_CODE( DECL_CONTEXT (fndecl
)) != NAMESPACE_DECL
)
10458 error ("`%D' is already defined in class `%T'", fndecl
,
10459 DECL_CONTEXT (fndecl
));
10460 return void_type_node
;
10463 check_template_shadow (fndecl
);
10465 DECL_DECLARED_INLINE_P (fndecl
) = 1;
10466 if (flag_default_inline
)
10467 DECL_INLINE (fndecl
) = 1;
10469 /* We process method specializations in finish_struct_1. */
10470 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
10472 fndecl
= push_template_decl (fndecl
);
10473 if (fndecl
== error_mark_node
)
10477 if (! DECL_FRIEND_P (fndecl
))
10479 if (TREE_CHAIN (fndecl
))
10481 fndecl
= copy_node (fndecl
);
10482 TREE_CHAIN (fndecl
) = NULL_TREE
;
10484 grok_special_member_properties (fndecl
);
10487 cp_finish_decl (fndecl
, NULL_TREE
, NULL_TREE
, 0);
10489 /* Make a place for the parms. */
10490 begin_scope (sk_function_parms
, fndecl
);
10492 DECL_IN_AGGR_P (fndecl
) = 1;
10496 /* Go through the motions of finishing a function definition.
10497 We don't compile this method until after the whole class has
10500 FINISH_METHOD must return something that looks as though it
10501 came from GROKFIELD (since we are defining a method, after all).
10503 This is called after parsing the body of the function definition.
10504 STMTS is the chain of statements that makes up the function body.
10506 DECL is the ..._DECL that `start_method' provided. */
10509 finish_method (tree decl
)
10511 tree fndecl
= decl
;
10516 if (decl
== void_type_node
)
10519 old_initial
= DECL_INITIAL (fndecl
);
10521 /* Undo the level for the parms (from start_method).
10522 This is like poplevel, but it causes nothing to be
10523 saved. Saving information here confuses symbol-table
10524 output routines. Besides, this information will
10525 be correctly output when this method is actually
10528 /* Clear out the meanings of the local variables of this level;
10529 also record in each decl which block it belongs to. */
10531 for (link
= current_binding_level
->names
; link
; link
= TREE_CHAIN (link
))
10533 if (DECL_NAME (link
) != NULL_TREE
)
10534 pop_binding (DECL_NAME (link
), link
);
10535 my_friendly_assert (TREE_CODE (link
) != FUNCTION_DECL
, 163);
10536 DECL_CONTEXT (link
) = NULL_TREE
;
10539 poplevel (0, 0, 0);
10541 DECL_INITIAL (fndecl
) = old_initial
;
10543 /* We used to check if the context of FNDECL was different from
10544 current_class_type as another way to get inside here. This didn't work
10545 for String.cc in libg++. */
10546 if (DECL_FRIEND_P (fndecl
))
10548 CLASSTYPE_INLINE_FRIENDS (current_class_type
)
10549 = tree_cons (NULL_TREE
, fndecl
, CLASSTYPE_INLINE_FRIENDS (current_class_type
));
10550 decl
= void_type_node
;
10557 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
10558 we can lay it out later, when and if its type becomes complete. */
10561 maybe_register_incomplete_var (tree var
)
10563 my_friendly_assert (TREE_CODE (var
) == VAR_DECL
, 20020406);
10565 /* Keep track of variables with incomplete types. */
10566 if (!processing_template_decl
&& TREE_TYPE (var
) != error_mark_node
10567 && DECL_EXTERNAL (var
))
10569 tree inner_type
= TREE_TYPE (var
);
10571 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
10572 inner_type
= TREE_TYPE (inner_type
);
10573 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
10575 if ((!COMPLETE_TYPE_P (inner_type
) && CLASS_TYPE_P (inner_type
))
10576 /* RTTI TD entries are created while defining the type_info. */
10577 || (TYPE_LANG_SPECIFIC (inner_type
)
10578 && TYPE_BEING_DEFINED (inner_type
)))
10579 incomplete_vars
= tree_cons (inner_type
, var
, incomplete_vars
);
10583 /* Called when a class type (given by TYPE) is defined. If there are
10584 any existing VAR_DECLs whose type hsa been completed by this
10585 declaration, update them now. */
10588 complete_vars (tree type
)
10590 tree
*list
= &incomplete_vars
;
10592 my_friendly_assert (CLASS_TYPE_P (type
), 20020406);
10595 if (same_type_p (type
, TREE_PURPOSE (*list
)))
10597 tree var
= TREE_VALUE (*list
);
10598 /* Complete the type of the variable. The VAR_DECL itself
10599 will be laid out in expand_expr. */
10600 complete_type (TREE_TYPE (var
));
10601 /* Remove this entry from the list. */
10602 *list
= TREE_CHAIN (*list
);
10605 list
= &TREE_CHAIN (*list
);
10608 /* Check for pending declarations which may have abstract type. */
10609 complete_type_check_abstract (type
);
10612 /* If DECL is of a type which needs a cleanup, build that cleanup
10616 cxx_maybe_build_cleanup (tree decl
)
10618 tree type
= TREE_TYPE (decl
);
10620 if (type
!= error_mark_node
&& TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
10622 int flags
= LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
;
10625 if (TREE_CODE (type
) == ARRAY_TYPE
)
10629 cxx_mark_addressable (decl
);
10630 rval
= build_unary_op (ADDR_EXPR
, decl
, 0);
10633 /* Optimize for space over speed here. */
10634 if (! TYPE_USES_VIRTUAL_BASECLASSES (type
)
10635 || flag_expensive_optimizations
)
10636 flags
|= LOOKUP_NONVIRTUAL
;
10638 rval
= build_delete (TREE_TYPE (rval
), rval
,
10639 sfk_complete_destructor
, flags
, 0);
10641 if (TYPE_USES_VIRTUAL_BASECLASSES (type
)
10642 && ! TYPE_HAS_DESTRUCTOR (type
))
10643 rval
= build_compound_expr (rval
, build_vbase_delete (type
, decl
));
10650 /* When a stmt has been parsed, this function is called. */
10657 /* DECL was originally constructed as a non-static member function,
10658 but turned out to be static. Update it accordingly. */
10661 revert_static_member_fn (tree decl
)
10664 tree function
= TREE_TYPE (decl
);
10665 tree args
= TYPE_ARG_TYPES (function
);
10667 if (cp_type_quals (TREE_TYPE (TREE_VALUE (args
)))
10668 != TYPE_UNQUALIFIED
)
10669 error ("static member function `%#D' declared with type qualifiers",
10672 args
= TREE_CHAIN (args
);
10673 tmp
= build_function_type (TREE_TYPE (function
), args
);
10674 tmp
= build_qualified_type (tmp
, cp_type_quals (function
));
10675 tmp
= build_exception_variant (tmp
,
10676 TYPE_RAISES_EXCEPTIONS (function
));
10677 TREE_TYPE (decl
) = tmp
;
10678 if (DECL_ARGUMENTS (decl
))
10679 DECL_ARGUMENTS (decl
) = TREE_CHAIN (DECL_ARGUMENTS (decl
));
10680 DECL_STATIC_FUNCTION_P (decl
) = 1;
10683 /* Initialize the variables used during compilation of a C++
10687 cxx_push_function_context (struct function
* f
)
10689 struct language_function
*p
= GGC_CNEW (struct language_function
);
10692 /* Whenever we start a new function, we destroy temporaries in the
10694 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
10700 if (DECL_SAVED_FUNCTION_DATA (fn
))
10702 /* If we already parsed this function, and we're just expanding it
10703 now, restore saved state. */
10704 *cp_function_chain
= *DECL_SAVED_FUNCTION_DATA (fn
);
10706 /* We don't need the saved data anymore. Unless this is an inline
10707 function; we need the named return value info for
10708 declare_return_variable. */
10709 if (! DECL_INLINE (fn
))
10710 DECL_SAVED_FUNCTION_DATA (fn
) = NULL
;
10715 /* Free the language-specific parts of F, now that we've finished
10716 compiling the function. */
10719 cxx_pop_function_context (struct function
* f
)
10724 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
10725 one of the language-independent trees. */
10727 enum cp_tree_node_structure_enum
10728 cp_tree_node_structure (union lang_tree_node
* t
)
10730 switch (TREE_CODE (&t
->generic
))
10732 case DEFAULT_ARG
: return TS_CP_DEFAULT_ARG
;
10733 case IDENTIFIER_NODE
: return TS_CP_IDENTIFIER
;
10734 case OVERLOAD
: return TS_CP_OVERLOAD
;
10735 case TEMPLATE_PARM_INDEX
: return TS_CP_TPI
;
10736 case TINST_LEVEL
: return TS_CP_TINST_LEVEL
;
10737 case PTRMEM_CST
: return TS_CP_PTRMEM
;
10738 case BASELINK
: return TS_CP_BASELINK
;
10739 default: return TS_CP_GENERIC
;
10743 /* Build the void_list_node (void_type_node having been created). */
10745 build_void_list_node (void)
10747 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
10752 cp_missing_noreturn_ok_p (tree decl
)
10754 /* A missing noreturn is ok for the `main' function. */
10755 return DECL_MAIN_P (decl
);
10758 #include "gt-cp-decl.h"
10759 #include "gtype-cp.h"