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"
51 #include "diagnostic.h"
55 static tree grokparms (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, int,
65 enum overload_flags, tree,
66 tree, int, int, int, int, int, int, tree);
67 static tree grokvardecl (tree, tree, RID_BIT_TYPE *, int, int, tree);
68 static void record_unknown_type (tree, const char *);
69 static tree builtin_function_1 (const char *, tree, tree, int,
70 enum built_in_class, const char *,
72 static tree build_library_fn_1 (tree, enum tree_code, tree);
73 static int member_function_or_else (tree, tree, enum overload_flags);
74 static void bad_specifiers (tree, const char *, int, int, int, int,
76 static void check_for_uninitialized_const_var (tree);
77 static hashval_t typename_hash (const void *);
78 static int typename_compare (const void *, const void *);
79 static tree local_variable_p_walkfn (tree *, int *, void *);
80 static tree record_builtin_java_type (const char *, int);
81 static const char *tag_name (enum tag_types code);
82 static int walk_namespaces_r (tree, walk_namespaces_fn, void *);
83 static int walk_globals_r (tree, void*);
84 static int walk_vtables_r (tree, void*);
85 static tree make_label_decl (tree, int);
86 static void use_label (tree);
87 static void check_previous_goto_1 (tree, struct cp_binding_level *, tree,
89 static void check_previous_goto (struct named_label_use_list *);
90 static void check_switch_goto (struct cp_binding_level *);
91 static void check_previous_gotos (tree);
92 static void pop_label (tree, tree);
93 static void pop_labels (tree);
94 static void maybe_deduce_size_from_array_init (tree, tree);
95 static void layout_var_decl (tree);
96 static void maybe_commonize_var (tree);
97 static tree check_initializer (tree, tree, int, tree *);
98 static void make_rtl_for_nonlocal_decl (tree, tree, const char *);
99 static void save_function_data (tree);
100 static void check_function_type (tree, tree);
101 static void begin_constructor_body (void);
102 static void finish_constructor_body (void);
103 static void begin_destructor_body (void);
104 static void finish_destructor_body (void);
105 static tree create_array_type_for_decl (tree, tree, tree);
106 static tree get_atexit_node (void);
107 static tree get_dso_handle_node (void);
108 static tree start_cleanup_fn (void);
109 static void end_cleanup_fn (void);
110 static tree cp_make_fname_decl (tree, int);
111 static void initialize_predefined_identifiers (void);
112 static tree check_special_function_return_type
113 (special_function_kind, tree, tree);
114 static tree push_cp_library_fn (enum tree_code, tree);
115 static tree build_cp_library_fn (tree, enum tree_code, tree);
116 static void store_parm_decls (tree);
117 static int cp_missing_noreturn_ok_p (tree);
118 static void initialize_local_var (tree, tree);
119 static void expand_static_init (tree, tree);
120 static tree next_initializable_field (tree);
121 static tree reshape_init (tree, tree *);
122 static tree build_typename_type (tree, tree, tree);
124 /* Erroneous argument lists can use this *IFF* they do not modify it. */
125 tree error_mark_list;
127 /* The following symbols are subsumed in the cp_global_trees array, and
128 listed here individually for documentation purposes.
131 tree wchar_decl_node;
133 tree vtable_entry_type;
134 tree delta_type_node;
135 tree __t_desc_type_node;
136 tree ti_desc_type_node;
137 tree bltn_desc_type_node, ptr_desc_type_node;
138 tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
139 tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
140 tree ptm_desc_type_node;
141 tree base_desc_type_node;
143 tree class_type_node;
144 tree unknown_type_node;
146 Array type `vtable_entry_type[]'
149 tree vtbl_ptr_type_node;
156 A FUNCTION_DECL which can call `abort'. Not necessarily the
157 one that the user will declare, but sufficient to be called
158 by routines that want to abort the program.
162 The FUNCTION_DECL for the default `::operator delete'.
164 tree global_delete_fndecl;
167 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
172 tree cp_global_trees[CPTI_MAX];
174 /* Indicates that there is a type value in some namespace, although
175 that is not necessarily in scope at the moment. */
177 tree global_type_node;
179 /* The node that holds the "name" of the global scope. */
180 tree global_scope_name;
182 /* Used only for jumps to as-yet undefined labels, since jumps to
183 defined labels can have their validity checked immediately. */
185 struct named_label_use_list GTY(())
187 struct cp_binding_level *binding_level;
190 location_t o_goto_locus;
191 struct named_label_use_list *next;
194 #define named_label_uses cp_function_chain->x_named_label_uses
196 #define local_names cp_function_chain->x_local_names
198 /* A list of objects which have constructors or destructors
199 which reside in the global scope. The decl is stored in
200 the TREE_VALUE slot and the initializer is stored
201 in the TREE_PURPOSE slot. */
202 tree static_aggregates;
206 /* A node for the integer constants 2, and 3. */
208 tree integer_two_node, integer_three_node;
210 /* Similar, for last_function_parm_tags. */
211 tree last_function_parms;
213 /* A list of all LABEL_DECLs in the function that have names. Here so
214 we can clear out their names' definitions at the end of the
215 function, and so we can check the validity of jumps to these labels. */
217 struct named_label_list GTY(())
219 struct cp_binding_level *binding_level;
224 struct named_label_list *next;
225 unsigned int in_try_scope : 1;
226 unsigned int in_catch_scope : 1;
229 #define named_labels cp_function_chain->x_named_labels
231 /* The number of function bodies which we are currently processing.
232 (Zero if we are at namespace scope, one inside the body of a
233 function, two inside the body of a function in a local class, etc.) */
236 /* States indicating how grokdeclarator() should handle declspecs marked
237 with __attribute__((deprecated)). An object declared as
238 __attribute__((deprecated)) suppresses warnings of uses of other
241 enum deprecated_states {
246 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
248 /* Set by add_implicitly_declared_members() to keep those members from
249 being flagged as deprecated or reported as using deprecated
251 int adding_implicit_members = 0;
253 /* True if a declaration with an `extern' linkage specifier is being
255 bool have_extern_spec;
258 /* A TREE_LIST of VAR_DECLs. The TREE_PURPOSE is a RECORD_TYPE or
259 UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type. At the
260 time the VAR_DECL was declared, the type was incomplete. */
262 static GTY(()) tree incomplete_vars;
264 /* Returns the kind of template specialization we are currently
265 processing, given that it's declaration contained N_CLASS_SCOPES
266 explicit scope qualifications. */
269 current_tmpl_spec_kind (int n_class_scopes)
271 int n_template_parm_scopes = 0;
272 int seen_specialization_p = 0;
273 int innermost_specialization_p = 0;
274 struct cp_binding_level *b;
276 /* Scan through the template parameter scopes. */
277 for (b = current_binding_level;
278 b->kind == sk_template_parms;
281 /* If we see a specialization scope inside a parameter scope,
282 then something is wrong. That corresponds to a declaration
285 template <class T> template <> ...
287 which is always invalid since [temp.expl.spec] forbids the
288 specialization of a class member template if the enclosing
289 class templates are not explicitly specialized as well. */
290 if (b->explicit_spec_p)
292 if (n_template_parm_scopes == 0)
293 innermost_specialization_p = 1;
295 seen_specialization_p = 1;
297 else if (seen_specialization_p == 1)
298 return tsk_invalid_member_spec;
300 ++n_template_parm_scopes;
303 /* Handle explicit instantiations. */
304 if (processing_explicit_instantiation)
306 if (n_template_parm_scopes != 0)
307 /* We've seen a template parameter list during an explicit
308 instantiation. For example:
310 template <class T> template void f(int);
312 This is erroneous. */
313 return tsk_invalid_expl_inst;
315 return tsk_expl_inst;
318 if (n_template_parm_scopes < n_class_scopes)
319 /* We've not seen enough template headers to match all the
320 specialized classes present. For example:
322 template <class T> void R<T>::S<T>::f(int);
324 This is invalid; there needs to be one set of template
325 parameters for each class. */
326 return tsk_insufficient_parms;
327 else if (n_template_parm_scopes == n_class_scopes)
328 /* We're processing a non-template declaration (even though it may
329 be a member of a template class.) For example:
331 template <class T> void S<T>::f(int);
333 The `class T' maches the `S<T>', leaving no template headers
334 corresponding to the `f'. */
336 else if (n_template_parm_scopes > n_class_scopes + 1)
337 /* We've got too many template headers. For example:
339 template <> template <class T> void f (T);
341 There need to be more enclosing classes. */
342 return tsk_excessive_parms;
344 /* This must be a template. It's of the form:
346 template <class T> template <class U> void S<T>::f(U);
348 This is a specialization if the innermost level was a
349 specialization; otherwise it's just a definition of the
351 return innermost_specialization_p ? tsk_expl_spec : tsk_template;
354 /* Exit the current scope. */
362 /* When a label goes out of scope, check to see if that label was used
363 in a valid manner, and issue any appropriate warnings or errors. */
366 pop_label (tree label, tree old_value)
368 if (!processing_template_decl)
370 if (DECL_INITIAL (label) == NULL_TREE)
374 cp_error_at ("label `%D' used but not defined", label);
375 location.file = input_filename;
377 /* Avoid crashing later. */
378 define_label (location, DECL_NAME (label));
380 else if (warn_unused_label && !TREE_USED (label))
381 cp_warning_at ("label `%D' defined but not used", label);
384 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
387 /* At the end of a function, all labels declared within the function
388 go out of scope. BLOCK is the top-level block for the
392 pop_labels (tree block)
394 struct named_label_list *link;
396 /* Clear out the definitions of all label names, since their scopes
398 for (link = named_labels; link; link = link->next)
400 pop_label (link->label_decl, link->old_value);
401 /* Put the labels into the "variables" of the top-level block,
402 so debugger can see them. */
403 TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
404 BLOCK_VARS (block) = link->label_decl;
410 /* Exit a binding level.
411 Pop the level off, and restore the state of the identifier-decl mappings
412 that were in effect when this level was entered.
414 If KEEP == 1, this level had explicit declarations, so
415 and create a "block" (a BLOCK node) for the level
416 to record its declarations and subblocks for symbol table output.
418 If FUNCTIONBODY is nonzero, this level is the body of a function,
419 so create a block as if KEEP were set and also clear out all
422 If REVERSE is nonzero, reverse the order of decls before putting
423 them into the BLOCK. */
426 poplevel (int keep, int reverse, int functionbody)
429 /* The chain of decls was accumulated in reverse order.
430 Put it into forward order, just for cleanliness. */
432 int tmp = functionbody;
433 int real_functionbody;
435 tree block = NULL_TREE;
437 int leaving_for_scope;
440 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 (!current_binding_level->class_shadowed,
451 /* We used to use KEEP == 2 to indicate that the new block should go
452 at the beginning of the list of blocks at this binding level,
453 rather than the end. This hack is no longer used. */
454 my_friendly_assert (keep == 0 || keep == 1, 0);
456 if (current_binding_level->keep)
459 /* Any uses of undefined labels, and any defined labels, now operate
460 under constraints of next binding contour. */
461 if (cfun && !functionbody)
463 struct cp_binding_level *level_chain;
464 level_chain = current_binding_level->level_chain;
467 struct named_label_use_list *uses;
468 struct named_label_list *labels;
469 for (labels = named_labels; labels; labels = labels->next)
470 if (labels->binding_level == current_binding_level)
473 if (current_binding_level->kind == sk_try)
474 labels->in_try_scope = 1;
475 if (current_binding_level->kind == sk_catch)
476 labels->in_catch_scope = 1;
477 for (decl = labels->names_in_scope; decl;
478 decl = TREE_CHAIN (decl))
479 if (decl_jump_unsafe (decl))
480 labels->bad_decls = tree_cons (NULL_TREE, decl,
482 labels->binding_level = level_chain;
483 labels->names_in_scope = level_chain->names;
486 for (uses = named_label_uses; uses; uses = uses->next)
487 if (uses->binding_level == current_binding_level)
489 uses->binding_level = level_chain;
490 uses->names_in_scope = level_chain->names;
495 /* Get the decls in the order they were written.
496 Usually current_binding_level->names is in reverse order.
497 But parameter decls were previously put in forward order. */
500 current_binding_level->names
501 = decls = nreverse (current_binding_level->names);
503 decls = current_binding_level->names;
505 /* Output any nested inline functions within this block
506 if they weren't already output. */
507 for (decl = decls; decl; decl = TREE_CHAIN (decl))
508 if (TREE_CODE (decl) == FUNCTION_DECL
509 && ! TREE_ASM_WRITTEN (decl)
510 && DECL_INITIAL (decl) != NULL_TREE
511 && TREE_ADDRESSABLE (decl)
512 && decl_function_context (decl) == current_function_decl)
514 /* If this decl was copied from a file-scope decl
515 on account of a block-scope extern decl,
516 propagate TREE_ADDRESSABLE to the file-scope decl. */
517 if (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
518 TREE_ADDRESSABLE (DECL_ABSTRACT_ORIGIN (decl)) = 1;
521 push_function_context ();
522 output_inline_function (decl);
523 pop_function_context ();
527 /* When not in function-at-a-time mode, expand_end_bindings will
528 warn about unused variables. But, in function-at-a-time mode
529 expand_end_bindings is not passed the list of variables in the
530 current scope, and therefore no warning is emitted. So, we
531 explicitly warn here. */
532 if (!processing_template_decl)
533 warn_about_unused_variables (getdecls ());
535 /* If there were any declarations or structure tags in that level,
536 or if this level is a function body,
537 create a BLOCK to record them for the life of this function. */
539 if (keep == 1 || functionbody)
540 block = make_node (BLOCK);
541 if (block != NULL_TREE)
543 BLOCK_VARS (block) = decls;
544 BLOCK_SUBBLOCKS (block) = subblocks;
547 /* In each subblock, record that this is its superior. */
549 for (link = subblocks; link; link = TREE_CHAIN (link))
550 BLOCK_SUPERCONTEXT (link) = block;
552 /* We still support the old for-scope rules, whereby the variables
553 in a for-init statement were in scope after the for-statement
554 ended. We only use the new rules if flag_new_for_scope is
557 = current_binding_level->kind == sk_for && flag_new_for_scope == 1;
559 /* Remove declarations for all the DECLs in this level. */
560 for (link = decls; link; link = TREE_CHAIN (link))
562 if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
565 cxx_binding *outer_binding
566 = IDENTIFIER_BINDING (DECL_NAME (link))->previous;
570 ns_binding = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (link));
572 ns_binding = NULL_TREE;
575 && outer_binding->scope == current_binding_level->level_chain)
576 /* We have something like:
581 and we are leaving the `for' scope. There's no reason to
582 keep the binding of the inner `i' in this case. */
583 pop_binding (DECL_NAME (link), link);
584 else if ((outer_binding
585 && (TREE_CODE (outer_binding->value) == TYPE_DECL))
586 || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL))
587 /* Here, we have something like:
595 We must pop the for-scope binding so we know what's a
596 type and what isn't. */
597 pop_binding (DECL_NAME (link), link);
600 /* Mark this VAR_DECL as dead so that we can tell we left it
601 there only for backward compatibility. */
602 DECL_DEAD_FOR_LOCAL (link) = 1;
604 /* Keep track of what should have happened when we
605 popped the binding. */
606 if (outer_binding && outer_binding->value)
607 DECL_SHADOWED_FOR_VAR (link) = outer_binding->value;
609 /* Add it to the list of dead variables in the next
610 outermost binding to that we can remove these when we
611 leave that binding. */
612 current_binding_level->level_chain->dead_vars_from_for
613 = tree_cons (NULL_TREE, link,
614 current_binding_level->level_chain->
617 /* Although we don't pop the cxx_binding, we do clear
618 its SCOPE since the scope is going away now. */
619 IDENTIFIER_BINDING (DECL_NAME (link))->scope = NULL;
624 /* Remove the binding. */
626 if (TREE_CODE (decl) == TREE_LIST)
627 decl = TREE_VALUE (decl);
629 pop_binding (DECL_NAME (decl), decl);
630 else if (TREE_CODE (decl) == OVERLOAD)
631 pop_binding (DECL_NAME (OVL_FUNCTION (decl)), decl);
637 /* Remove declarations for any `for' variables from inner scopes
638 that we kept around. */
639 for (link = current_binding_level->dead_vars_from_for;
640 link; link = TREE_CHAIN (link))
641 pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
643 /* Restore the IDENTIFIER_TYPE_VALUEs. */
644 for (link = current_binding_level->type_shadowed;
645 link; link = TREE_CHAIN (link))
646 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
648 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
649 for (link = current_binding_level->shadowed_labels;
651 link = TREE_CHAIN (link))
652 pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
654 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
655 list if a `using' declaration put them there. The debugging
656 back-ends won't understand OVERLOAD, so we remove them here.
657 Because the BLOCK_VARS are (temporarily) shared with
658 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
659 popped all the bindings. */
664 for (d = &BLOCK_VARS (block); *d; )
666 if (TREE_CODE (*d) == TREE_LIST)
667 *d = TREE_CHAIN (*d);
669 d = &TREE_CHAIN (*d);
673 /* If the level being exited is the top level of a function,
674 check over all the labels. */
677 /* Since this is the top level block of a function, the vars are
678 the function's parameters. Don't leave them in the BLOCK
679 because they are found in the FUNCTION_DECL instead. */
680 BLOCK_VARS (block) = 0;
684 kind = current_binding_level->kind;
688 DECL_INITIAL (current_function_decl) = block;
690 current_binding_level->blocks
691 = chainon (current_binding_level->blocks, block);
693 /* If we did not make a block for the level just exited,
694 any blocks made for inner levels
695 (since they cannot be recorded as subblocks in that level)
696 must be carried forward so they will later become subblocks
697 of something else. */
699 current_binding_level->blocks
700 = chainon (current_binding_level->blocks, subblocks);
702 /* Each and every BLOCK node created here in `poplevel' is important
703 (e.g. for proper debugging information) so if we created one
704 earlier, mark it as "used". */
706 TREE_USED (block) = 1;
708 /* Take care of compiler's internal binding structures. */
709 if (kind == sk_cleanup)
714 = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/1);
717 SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmts)) = block;
718 SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmts)) = block;
721 block = poplevel (keep, reverse, functionbody);
724 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, block);
727 /* Delete the node BLOCK from the current binding level.
728 This is used for the block inside a stmt expr ({...})
729 so that the block can be reinserted where appropriate. */
732 delete_block (tree block)
735 if (current_binding_level->blocks == block)
736 current_binding_level->blocks = TREE_CHAIN (block);
737 for (t = current_binding_level->blocks; t;)
739 if (TREE_CHAIN (t) == block)
740 TREE_CHAIN (t) = TREE_CHAIN (block);
744 TREE_CHAIN (block) = NULL_TREE;
745 /* Clear TREE_USED which is always set by poplevel.
746 The flag is set again if insert_block is called. */
747 TREE_USED (block) = 0;
750 /* Insert BLOCK at the end of the list of subblocks of the
751 current binding level. This is used when a BIND_EXPR is expanded,
752 to handle the BLOCK node inside the BIND_EXPR. */
755 insert_block (tree block)
757 TREE_USED (block) = 1;
758 current_binding_level->blocks
759 = chainon (current_binding_level->blocks, block);
762 /* Set the BLOCK node for the innermost scope
763 (the one we are currently in). */
766 set_block (tree block ATTRIBUTE_UNUSED )
768 /* The RTL expansion machinery requires us to provide this callback,
769 but it is not applicable in function-at-a-time mode. */
772 /* Returns nonzero if T is a virtual function table. */
775 vtable_decl_p (tree t, void* data ATTRIBUTE_UNUSED )
777 return (TREE_CODE (t) == VAR_DECL && DECL_VIRTUAL_P (t));
780 /* Returns nonzero if T is a TYPE_DECL for a type with virtual
784 vtype_decl_p (tree t, void *data ATTRIBUTE_UNUSED )
786 return (TREE_CODE (t) == TYPE_DECL
787 && TREE_CODE (TREE_TYPE (t)) == RECORD_TYPE
788 && TYPE_POLYMORPHIC_P (TREE_TYPE (t)));
791 struct walk_globals_data {
797 /* Walk the vtable declarations in NAMESPACE. Whenever one is found
798 for which P returns nonzero, call F with its address. If any call
799 to F returns a nonzero value, return a nonzero value. */
802 walk_vtables_r (tree namespace, void* data)
804 struct walk_globals_data* wgd = (struct walk_globals_data *) data;
805 walk_globals_fn f = wgd->f;
807 tree decl = NAMESPACE_LEVEL (namespace)->vtables;
810 for (; decl ; decl = TREE_CHAIN (decl))
811 result |= (*f) (&decl, d);
816 /* Walk the vtable declarations. Whenever one is found for which P
817 returns nonzero, call F with its address. If any call to F
818 returns a nonzero value, return a nonzero value. */
820 walk_vtables (walk_globals_pred p, walk_globals_fn f, void *data)
822 struct walk_globals_data wgd;
827 return walk_namespaces (walk_vtables_r, &wgd);
830 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
831 itself, calling F for each. The DATA is passed to F as well. */
834 walk_namespaces_r (tree namespace, walk_namespaces_fn f, void* data)
837 tree current = NAMESPACE_LEVEL (namespace)->namespaces;
839 result |= (*f) (namespace, data);
841 for (; current; current = TREE_CHAIN (current))
842 result |= walk_namespaces_r (current, f, data);
847 /* Walk all the namespaces, calling F for each. The DATA is passed to
851 walk_namespaces (walk_namespaces_fn f, void* data)
853 return walk_namespaces_r (global_namespace, f, data);
856 /* Walk the global declarations in NAMESPACE. Whenever one is found
857 for which P returns nonzero, call F with its address. If any call
858 to F returns a nonzero value, return a nonzero value. */
861 walk_globals_r (tree namespace, void* data)
863 struct walk_globals_data* wgd = (struct walk_globals_data *) data;
864 walk_globals_pred p = wgd->p;
865 walk_globals_fn f = wgd->f;
870 t = &NAMESPACE_LEVEL (namespace)->names;
877 result |= (*f) (t, d);
879 /* If F changed *T, then *T still points at the next item to
882 t = &TREE_CHAIN (*t);
888 /* Walk the global declarations. Whenever one is found for which P
889 returns true, call F with its address. If any call to F
890 returns true, return true. */
893 walk_globals (walk_globals_pred p, walk_globals_fn f, void *data)
895 struct walk_globals_data wgd;
900 return walk_namespaces (walk_globals_r, &wgd);
903 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
904 DATA is non-NULL, this is the last time we will call
905 wrapup_global_declarations for this NAMESPACE. */
908 wrapup_globals_for_namespace (tree namespace, void* data)
910 struct cp_binding_level *level = NAMESPACE_LEVEL (namespace);
911 varray_type statics = level->static_decls;
912 tree *vec = &VARRAY_TREE (statics, 0);
913 int len = VARRAY_ACTIVE_SIZE (statics);
914 int last_time = (data != 0);
918 check_global_declarations (vec, len);
922 /* Write out any globals that need to be output. */
923 return wrapup_global_declarations (vec, len);
927 /* In C++, you don't have to write `struct S' to refer to `S'; you
928 can just use `S'. We accomplish this by creating a TYPE_DECL as
929 if the user had written `typedef struct S S'. Create and return
930 the TYPE_DECL for TYPE. */
933 create_implicit_typedef (tree name, tree type)
937 decl = build_decl (TYPE_DECL, name, type);
938 DECL_ARTIFICIAL (decl) = 1;
939 /* There are other implicit type declarations, like the one *within*
940 a class that allows you to write `S::S'. We must distinguish
942 SET_DECL_IMPLICIT_TYPEDEF_P (decl);
943 TYPE_NAME (type) = decl;
948 /* Remember a local name for name-mangling purposes. */
951 push_local_name (tree decl)
956 timevar_push (TV_NAME_LOOKUP);
958 VARRAY_TREE_INIT (local_names, 8, "local_names");
960 name = DECL_NAME (decl);
962 nelts = VARRAY_ACTIVE_SIZE (local_names);
963 for (i = 0; i < nelts; i++)
965 t = VARRAY_TREE (local_names, i);
966 if (DECL_NAME (t) == name)
968 if (!DECL_LANG_SPECIFIC (decl))
969 retrofit_lang_decl (decl);
970 DECL_LANG_SPECIFIC (decl)->decl_flags.u2sel = 1;
971 if (DECL_LANG_SPECIFIC (t))
972 DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
974 DECL_DISCRIMINATOR (decl) = 1;
976 VARRAY_TREE (local_names, i) = decl;
977 timevar_pop (TV_NAME_LOOKUP);
982 VARRAY_PUSH_TREE (local_names, decl);
983 timevar_pop (TV_NAME_LOOKUP);
986 /* Subroutine of duplicate_decls: return truthvalue of whether
987 or not types of these decls match.
989 For C++, we must compare the parameter list so that `int' can match
990 `int&' in a parameter position, but `int&' is not confused with
994 decls_match (tree newdecl, tree olddecl)
998 if (newdecl == olddecl)
1001 if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
1002 /* If the two DECLs are not even the same kind of thing, we're not
1003 interested in their types. */
1006 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1008 tree f1 = TREE_TYPE (newdecl);
1009 tree f2 = TREE_TYPE (olddecl);
1010 tree p1 = TYPE_ARG_TYPES (f1);
1011 tree p2 = TYPE_ARG_TYPES (f2);
1013 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
1014 && ! (DECL_EXTERN_C_P (newdecl)
1015 && DECL_EXTERN_C_P (olddecl)))
1018 if (TREE_CODE (f1) != TREE_CODE (f2))
1021 if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
1023 if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
1024 && (DECL_BUILT_IN (olddecl)
1025 #ifndef NO_IMPLICIT_EXTERN_C
1026 || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
1027 || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
1031 types_match = self_promoting_args_p (p1);
1032 if (p1 == void_list_node)
1033 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
1035 #ifndef NO_IMPLICIT_EXTERN_C
1036 else if (p1 == NULL_TREE
1037 && (DECL_EXTERN_C_P (olddecl)
1038 && DECL_IN_SYSTEM_HEADER (olddecl)
1039 && !DECL_CLASS_SCOPE_P (olddecl))
1040 && (DECL_EXTERN_C_P (newdecl)
1041 && DECL_IN_SYSTEM_HEADER (newdecl)
1042 && !DECL_CLASS_SCOPE_P (newdecl)))
1044 types_match = self_promoting_args_p (p2);
1045 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
1049 types_match = compparms (p1, p2);
1054 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1056 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
1057 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
1060 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1061 DECL_TEMPLATE_PARMS (olddecl)))
1064 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1065 types_match = same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)),
1066 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl)));
1068 types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
1069 DECL_TEMPLATE_RESULT (newdecl));
1073 if (TREE_TYPE (newdecl) == error_mark_node)
1074 types_match = TREE_TYPE (olddecl) == error_mark_node;
1075 else if (TREE_TYPE (olddecl) == NULL_TREE)
1076 types_match = TREE_TYPE (newdecl) == NULL_TREE;
1077 else if (TREE_TYPE (newdecl) == NULL_TREE)
1080 types_match = comptypes (TREE_TYPE (newdecl),
1081 TREE_TYPE (olddecl),
1082 COMPARE_REDECLARATION);
1088 /* If NEWDECL is `static' and an `extern' was seen previously,
1089 warn about it. OLDDECL is the previous declaration.
1091 Note that this does not apply to the C++ case of declaring
1092 a variable `extern const' and then later `const'.
1094 Don't complain about built-in functions, since they are beyond
1095 the user's control. */
1098 warn_extern_redeclared_static (tree newdecl, tree olddecl)
1100 static const char *const explicit_extern_static_warning
1101 = "`%D' was declared `extern' and later `static'";
1102 static const char *const implicit_extern_static_warning
1103 = "`%D' was declared implicitly `extern' and later `static'";
1107 if (TREE_CODE (newdecl) == TYPE_DECL
1108 || TREE_CODE (newdecl) == TEMPLATE_DECL
1109 || TREE_CODE (newdecl) == CONST_DECL
1110 || TREE_CODE (newdecl) == NAMESPACE_DECL)
1113 /* Don't get confused by static member functions; that's a different
1115 if (TREE_CODE (newdecl) == FUNCTION_DECL
1116 && DECL_STATIC_FUNCTION_P (newdecl))
1119 /* If the old declaration was `static', or the new one isn't, then
1120 then everything is OK. */
1121 if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
1124 /* It's OK to declare a builtin function as `static'. */
1125 if (TREE_CODE (olddecl) == FUNCTION_DECL
1126 && DECL_ARTIFICIAL (olddecl))
1129 name = DECL_ASSEMBLER_NAME (newdecl);
1130 pedwarn (IDENTIFIER_IMPLICIT_DECL (name)
1131 ? implicit_extern_static_warning
1132 : explicit_extern_static_warning, newdecl);
1133 cp_pedwarn_at ("previous declaration of `%D'", olddecl);
1136 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1137 If the redeclaration is invalid, a diagnostic is issued, and the
1138 error_mark_node is returned. Otherwise, OLDDECL is returned.
1140 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1144 duplicate_decls (tree newdecl, tree olddecl)
1146 unsigned olddecl_uid = DECL_UID (olddecl);
1147 int olddecl_friend = 0, types_match = 0;
1148 int new_defines_function = 0;
1150 if (newdecl == olddecl)
1153 types_match = decls_match (newdecl, olddecl);
1155 /* If either the type of the new decl or the type of the old decl is an
1156 error_mark_node, then that implies that we have already issued an
1157 error (earlier) for some bogus type specification, and in that case,
1158 it is rather pointless to harass the user with yet more error message
1159 about the same declaration, so just pretend the types match here. */
1160 if (TREE_TYPE (newdecl) == error_mark_node
1161 || TREE_TYPE (olddecl) == error_mark_node)
1164 if (DECL_P (olddecl)
1165 && TREE_CODE (newdecl) == FUNCTION_DECL
1166 && TREE_CODE (olddecl) == FUNCTION_DECL
1167 && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
1169 if (DECL_DECLARED_INLINE_P (newdecl)
1170 && DECL_UNINLINABLE (newdecl)
1171 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1172 /* Already warned elsewhere. */;
1173 else if (DECL_DECLARED_INLINE_P (olddecl)
1174 && DECL_UNINLINABLE (olddecl)
1175 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1176 /* Already warned. */;
1177 else if (DECL_DECLARED_INLINE_P (newdecl)
1178 && DECL_UNINLINABLE (olddecl)
1179 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1181 warning ("%Jfunction '%D' redeclared as inline", newdecl, newdecl);
1182 warning ("%Jprevious declaration of '%D' with attribute noinline",
1185 else if (DECL_DECLARED_INLINE_P (olddecl)
1186 && DECL_UNINLINABLE (newdecl)
1187 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1189 warning ("%Jfunction '%D' redeclared with attribute noinline",
1191 warning ("%Jprevious declaration of '%D' was inline",
1196 /* Check for redeclaration and other discrepancies. */
1197 if (TREE_CODE (olddecl) == FUNCTION_DECL
1198 && DECL_ARTIFICIAL (olddecl))
1200 if (TREE_CODE (newdecl) != FUNCTION_DECL)
1202 /* Avoid warnings redeclaring anticipated built-ins. */
1203 if (DECL_ANTICIPATED (olddecl))
1206 /* If you declare a built-in or predefined function name as static,
1207 the old definition is overridden, but optionally warn this was a
1208 bad choice of name. */
1209 if (! TREE_PUBLIC (newdecl))
1212 warning ("shadowing %s function `%#D'",
1213 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
1215 /* Discard the old built-in function. */
1218 /* If the built-in is not ansi, then programs can override
1219 it even globally without an error. */
1220 else if (! DECL_BUILT_IN (olddecl))
1221 warning ("library function `%#D' redeclared as non-function `%#D'",
1225 error ("declaration of `%#D'", newdecl);
1226 error ("conflicts with built-in declaration `%#D'",
1231 else if (!types_match)
1233 /* Avoid warnings redeclaring anticipated built-ins. */
1234 if (DECL_ANTICIPATED (olddecl))
1235 ; /* Do nothing yet. */
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 SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
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 = 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 SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
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 /* New decl is completely inconsistent with the old one =>
1323 tell caller to replace the old one. */
1327 else if (!types_match)
1329 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
1330 /* These are certainly not duplicate declarations; they're
1331 from different scopes. */
1334 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1336 /* The name of a class template may not be declared to refer to
1337 any other template, class, function, object, namespace, value,
1338 or type in the same scope. */
1339 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
1340 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1342 error ("declaration of template `%#D'", newdecl);
1343 cp_error_at ("conflicts with previous declaration `%#D'",
1346 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
1347 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
1348 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
1349 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
1350 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1351 DECL_TEMPLATE_PARMS (olddecl))
1352 /* Template functions can be disambiguated by
1354 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
1355 TREE_TYPE (TREE_TYPE (olddecl))))
1357 error ("new declaration `%#D'", newdecl);
1358 cp_error_at ("ambiguates old declaration `%#D'", olddecl);
1362 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1364 if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
1366 error ("declaration of C function `%#D' conflicts with",
1368 cp_error_at ("previous declaration `%#D' here", olddecl);
1370 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1371 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1373 error ("new declaration `%#D'", newdecl);
1374 cp_error_at ("ambiguates old declaration `%#D'", olddecl);
1380 /* Already complained about this, so don't do so again. */
1381 else if (current_class_type == NULL_TREE
1382 || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type)
1384 error ("conflicting declaration '%#D'", newdecl);
1385 cp_error_at ("'%D' has a previous declaration as `%#D'",
1390 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1391 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
1392 && (!DECL_TEMPLATE_INFO (newdecl)
1393 || (DECL_TI_TEMPLATE (newdecl)
1394 != DECL_TI_TEMPLATE (olddecl))))
1395 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
1396 && (!DECL_TEMPLATE_INFO (olddecl)
1397 || (DECL_TI_TEMPLATE (olddecl)
1398 != DECL_TI_TEMPLATE (newdecl))))))
1399 /* It's OK to have a template specialization and a non-template
1400 with the same type, or to have specializations of two
1401 different templates with the same type. Note that if one is a
1402 specialization, and the other is an instantiation of the same
1403 template, that we do not exit at this point. That situation
1404 can occur if we instantiate a template class, and then
1405 specialize one of its methods. This situation is valid, but
1406 the declarations must be merged in the usual way. */
1408 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1409 && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
1410 && !DECL_USE_TEMPLATE (newdecl))
1411 || (DECL_TEMPLATE_INSTANTIATION (newdecl)
1412 && !DECL_USE_TEMPLATE (olddecl))))
1413 /* One of the declarations is a template instantiation, and the
1414 other is not a template at all. That's OK. */
1416 else if (TREE_CODE (newdecl) == NAMESPACE_DECL
1417 && DECL_NAMESPACE_ALIAS (newdecl)
1418 && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
1419 /* In [namespace.alias] we have:
1421 In a declarative region, a namespace-alias-definition can be
1422 used to redefine a namespace-alias declared in that declarative
1423 region to refer only to the namespace to which it already
1426 Therefore, if we encounter a second alias directive for the same
1427 alias, we can just ignore the second directive. */
1431 const char *errmsg = redeclaration_error_message (newdecl, olddecl);
1434 error (errmsg, newdecl);
1435 if (DECL_NAME (olddecl) != NULL_TREE)
1436 cp_error_at ((DECL_INITIAL (olddecl)
1437 && namespace_bindings_p ())
1438 ? "`%#D' previously defined here"
1439 : "`%#D' previously declared here", olddecl);
1440 return error_mark_node;
1442 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1443 && DECL_INITIAL (olddecl) != NULL_TREE
1444 && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
1445 && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
1447 /* Prototype decl follows defn w/o prototype. */
1448 cp_warning_at ("prototype for `%#D'", newdecl);
1449 warning ("%Jfollows non-prototype definition here", olddecl);
1451 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1452 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
1454 /* extern "C" int foo ();
1455 int foo () { bar (); }
1457 if (current_lang_depth () == 0)
1458 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1461 cp_error_at ("previous declaration of `%#D' with %L linkage",
1462 olddecl, DECL_LANGUAGE (olddecl));
1463 error ("conflicts with new declaration with %L linkage",
1464 DECL_LANGUAGE (newdecl));
1468 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
1470 else if (TREE_CODE (olddecl) == FUNCTION_DECL)
1472 tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1473 tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1476 if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
1477 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
1479 for (; t1 && t1 != void_list_node;
1480 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
1481 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
1483 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
1486 pedwarn ("default argument given for parameter %d of `%#D'",
1488 cp_pedwarn_at ("after previous specification in `%#D'",
1493 error ("default argument given for parameter %d of `%#D'",
1495 cp_error_at ("after previous specification in `%#D'",
1500 if (DECL_DECLARED_INLINE_P (newdecl)
1501 && ! DECL_DECLARED_INLINE_P (olddecl)
1502 && TREE_ADDRESSABLE (olddecl) && warn_inline)
1504 warning ("`%#D' was used before it was declared inline", newdecl);
1505 warning ("%Jprevious non-inline declaration here", olddecl);
1510 /* Do not merge an implicit typedef with an explicit one. In:
1514 typedef class A A __attribute__ ((foo));
1516 the attribute should apply only to the typedef. */
1517 if (TREE_CODE (olddecl) == TYPE_DECL
1518 && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
1519 || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
1522 /* If new decl is `static' and an `extern' was seen previously,
1524 warn_extern_redeclared_static (newdecl, olddecl);
1526 /* We have committed to returning 1 at this point. */
1527 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1529 /* Now that functions must hold information normally held
1530 by field decls, there is extra work to do so that
1531 declaration information does not get destroyed during
1533 if (DECL_VINDEX (olddecl))
1534 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
1535 if (DECL_CONTEXT (olddecl))
1536 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1537 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
1538 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1539 DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
1540 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
1541 DECL_NEEDS_FINAL_OVERRIDER_P (newdecl) |= DECL_NEEDS_FINAL_OVERRIDER_P (olddecl);
1542 DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
1543 if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
1544 SET_OVERLOADED_OPERATOR_CODE
1545 (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
1546 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
1548 /* Optionally warn about more than one declaration for the same
1549 name, but don't warn about a function declaration followed by a
1551 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
1552 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
1553 /* Don't warn about extern decl followed by definition. */
1554 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
1555 /* Don't warn about friends, let add_friend take care of it. */
1556 && ! (DECL_FRIEND_P (newdecl) || DECL_FRIEND_P (olddecl)))
1558 warning ("redundant redeclaration of `%D' in same scope", newdecl);
1559 cp_warning_at ("previous declaration of `%D'", olddecl);
1563 /* Deal with C++: must preserve virtual function table size. */
1564 if (TREE_CODE (olddecl) == TYPE_DECL)
1566 tree newtype = TREE_TYPE (newdecl);
1567 tree oldtype = TREE_TYPE (olddecl);
1569 if (newtype != error_mark_node && oldtype != error_mark_node
1570 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
1571 CLASSTYPE_FRIEND_CLASSES (newtype)
1572 = CLASSTYPE_FRIEND_CLASSES (oldtype);
1574 DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
1577 /* Copy all the DECL_... slots specified in the new decl
1578 except for any that we copy here from the old type. */
1579 DECL_ATTRIBUTES (newdecl)
1580 = (*targetm.merge_decl_attributes) (olddecl, newdecl);
1582 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1584 TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
1585 DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
1586 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
1587 DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
1589 /* If the new declaration is a definition, update the file and
1590 line information on the declaration. */
1591 if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)) == NULL_TREE
1592 && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl)) != NULL_TREE)
1594 DECL_SOURCE_LOCATION (olddecl)
1595 = DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (olddecl))
1596 = DECL_SOURCE_LOCATION (newdecl);
1599 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1601 DECL_INLINE (DECL_TEMPLATE_RESULT (olddecl))
1602 |= DECL_INLINE (DECL_TEMPLATE_RESULT (newdecl));
1603 DECL_DECLARED_INLINE_P (DECL_TEMPLATE_RESULT (olddecl))
1604 |= DECL_DECLARED_INLINE_P (DECL_TEMPLATE_RESULT (newdecl));
1612 /* Automatically handles default parameters. */
1613 tree oldtype = TREE_TYPE (olddecl);
1616 /* Merge the data types specified in the two decls. */
1617 newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1619 /* If merge_types produces a non-typedef type, just use the old type. */
1620 if (TREE_CODE (newdecl) == TYPE_DECL
1621 && newtype == DECL_ORIGINAL_TYPE (newdecl))
1624 if (TREE_CODE (newdecl) == VAR_DECL)
1626 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
1627 DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
1628 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl)
1629 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl);
1632 /* Do this after calling `merge_types' so that default
1633 parameters don't confuse us. */
1634 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1635 && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
1636 != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
1638 TREE_TYPE (newdecl) = build_exception_variant (newtype,
1639 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
1640 TREE_TYPE (olddecl) = build_exception_variant (newtype,
1641 TYPE_RAISES_EXCEPTIONS (oldtype));
1643 if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
1644 && DECL_SOURCE_LINE (olddecl) != 0
1646 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
1647 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
1649 error ("declaration of `%F' throws different exceptions",
1651 cp_error_at ("than previous declaration `%F'", olddecl);
1654 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
1656 /* Lay the type out, unless already done. */
1657 if (! same_type_p (newtype, oldtype)
1658 && TREE_TYPE (newdecl) != error_mark_node
1659 && !(processing_template_decl && uses_template_parms (newdecl)))
1660 layout_type (TREE_TYPE (newdecl));
1662 if ((TREE_CODE (newdecl) == VAR_DECL
1663 || TREE_CODE (newdecl) == PARM_DECL
1664 || TREE_CODE (newdecl) == RESULT_DECL
1665 || TREE_CODE (newdecl) == FIELD_DECL
1666 || TREE_CODE (newdecl) == TYPE_DECL)
1667 && !(processing_template_decl && uses_template_parms (newdecl)))
1668 layout_decl (newdecl, 0);
1670 /* Merge the type qualifiers. */
1671 if (TREE_READONLY (newdecl))
1672 TREE_READONLY (olddecl) = 1;
1673 if (TREE_THIS_VOLATILE (newdecl))
1674 TREE_THIS_VOLATILE (olddecl) = 1;
1676 /* Merge the initialization information. */
1677 if (DECL_INITIAL (newdecl) == NULL_TREE
1678 && DECL_INITIAL (olddecl) != NULL_TREE)
1680 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1681 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
1682 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
1683 && DECL_LANG_SPECIFIC (newdecl)
1684 && DECL_LANG_SPECIFIC (olddecl))
1686 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1687 DECL_SAVED_INSNS (newdecl) = DECL_SAVED_INSNS (olddecl);
1691 /* Merge the section attribute.
1692 We want to issue an error if the sections conflict but that must be
1693 done later in decl_attributes since we are called before attributes
1695 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1696 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1698 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1700 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1701 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1702 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1703 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1704 TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
1705 TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl);
1706 DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
1707 DECL_IS_PURE (newdecl) |= DECL_IS_PURE (olddecl);
1708 /* Keep the old RTL. */
1709 COPY_DECL_RTL (olddecl, newdecl);
1711 else if (TREE_CODE (newdecl) == VAR_DECL
1712 && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
1714 /* Keep the old RTL. We cannot keep the old RTL if the old
1715 declaration was for an incomplete object and the new
1716 declaration is not since many attributes of the RTL will
1718 COPY_DECL_RTL (olddecl, newdecl);
1721 /* If cannot merge, then use the new type and qualifiers,
1722 and don't preserve the old rtl. */
1725 /* Clean out any memory we had of the old declaration. */
1726 tree oldstatic = value_member (olddecl, static_aggregates);
1728 TREE_VALUE (oldstatic) = error_mark_node;
1730 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1731 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1732 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1733 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1736 /* Merge the storage class information. */
1737 merge_weak (newdecl, olddecl);
1739 DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
1740 DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
1741 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1742 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
1743 if (! DECL_EXTERNAL (olddecl))
1744 DECL_EXTERNAL (newdecl) = 0;
1746 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
1748 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
1749 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
1750 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
1751 DECL_TEMPLATE_INSTANTIATED (newdecl)
1752 |= DECL_TEMPLATE_INSTANTIATED (olddecl);
1753 /* Don't really know how much of the language-specific
1754 values we should copy from old to new. */
1755 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
1756 DECL_LANG_SPECIFIC (newdecl)->decl_flags.u2 =
1757 DECL_LANG_SPECIFIC (olddecl)->decl_flags.u2;
1758 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
1759 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
1760 DECL_INITIALIZED_IN_CLASS_P (newdecl)
1761 |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
1762 olddecl_friend = DECL_FRIEND_P (olddecl);
1764 /* Only functions have DECL_BEFRIENDING_CLASSES. */
1765 if (TREE_CODE (newdecl) == FUNCTION_DECL
1766 || DECL_FUNCTION_TEMPLATE_P (newdecl))
1768 DECL_BEFRIENDING_CLASSES (newdecl)
1769 = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
1770 DECL_BEFRIENDING_CLASSES (olddecl));
1771 /* DECL_THUNKS is only valid for virtual functions,
1772 otherwise it is a DECL_FRIEND_CONTEXT. */
1773 if (DECL_VIRTUAL_P (newdecl))
1774 DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl);
1778 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1780 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
1781 && !DECL_TEMPLATE_INSTANTIATION (newdecl))
1783 /* If newdecl is not a specialization, then it is not a
1784 template-related function at all. And that means that we
1785 should have exited above, returning 0. */
1786 my_friendly_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl),
1789 if (TREE_USED (olddecl))
1790 /* From [temp.expl.spec]:
1792 If a template, a member template or the member of a class
1793 template is explicitly specialized then that
1794 specialization shall be declared before the first use of
1795 that specialization that would cause an implicit
1796 instantiation to take place, in every translation unit in
1797 which such a use occurs. */
1798 error ("explicit specialization of %D after first use",
1801 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
1803 /* [temp.expl.spec/14] We don't inline explicit specialization
1804 just because the primary template says so. */
1808 if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
1809 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
1811 DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
1813 /* If either decl says `inline', this fn is inline, unless
1814 its definition was passed already. */
1815 if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
1816 DECL_INLINE (olddecl) = 1;
1817 DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
1819 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
1820 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
1823 /* Preserve abstractness on cloned [cd]tors. */
1824 DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
1828 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1829 COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
1830 SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
1832 if (! types_match || new_defines_function)
1834 /* These need to be copied so that the names are available.
1835 Note that if the types do match, we'll preserve inline
1836 info and other bits, but if not, we won't. */
1837 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
1838 DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
1840 if (new_defines_function)
1841 /* If defining a function declared with other language
1842 linkage, use the previously declared language linkage. */
1843 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1844 else if (types_match)
1846 /* If redeclaring a builtin function, and not a definition,
1847 it stays built in. */
1848 if (DECL_BUILT_IN (olddecl))
1850 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
1851 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
1852 /* If we're keeping the built-in definition, keep the rtl,
1853 regardless of declaration matches. */
1854 SET_DECL_RTL (newdecl, DECL_RTL (olddecl));
1857 DECL_ESTIMATED_INSNS (newdecl) = DECL_ESTIMATED_INSNS (olddecl);
1859 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
1860 /* Don't clear out the arguments if we're redefining a function. */
1861 if (DECL_ARGUMENTS (olddecl))
1862 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
1865 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1866 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
1868 /* Now preserve various other info from the definition. */
1869 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
1870 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
1871 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
1872 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
1874 /* If either declaration has a nondefault visibility, use it. */
1875 if (DECL_VISIBILITY (olddecl) != VISIBILITY_DEFAULT)
1877 if (DECL_VISIBILITY (newdecl) != VISIBILITY_DEFAULT
1878 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
1880 warning ("%J'%D': visibility attribute ignored because it",
1882 warning ("%Jconflicts with previous declaration here", olddecl);
1884 DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
1887 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1891 function_size = sizeof (struct tree_decl);
1893 memcpy ((char *) olddecl + sizeof (struct tree_common),
1894 (char *) newdecl + sizeof (struct tree_common),
1895 function_size - sizeof (struct tree_common));
1897 if (DECL_TEMPLATE_INSTANTIATION (newdecl))
1898 /* If newdecl is a template instantiation, it is possible that
1899 the following sequence of events has occurred:
1901 o A friend function was declared in a class template. The
1902 class template was instantiated.
1904 o The instantiation of the friend declaration was
1905 recorded on the instantiation list, and is newdecl.
1907 o Later, however, instantiate_class_template called pushdecl
1908 on the newdecl to perform name injection. But, pushdecl in
1909 turn called duplicate_decls when it discovered that another
1910 declaration of a global function with the same name already
1913 o Here, in duplicate_decls, we decided to clobber newdecl.
1915 If we're going to do that, we'd better make sure that
1916 olddecl, and not newdecl, is on the list of
1917 instantiations so that if we try to do the instantiation
1918 again we won't get the clobbered declaration. */
1919 reregister_specialization (newdecl,
1920 DECL_TI_TEMPLATE (newdecl),
1925 memcpy ((char *) olddecl + sizeof (struct tree_common),
1926 (char *) newdecl + sizeof (struct tree_common),
1927 sizeof (struct tree_decl) - sizeof (struct tree_common)
1928 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
1931 DECL_UID (olddecl) = olddecl_uid;
1933 DECL_FRIEND_P (olddecl) = 1;
1935 /* NEWDECL contains the merged attribute lists.
1936 Update OLDDECL to be the same. */
1937 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
1939 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
1940 so that encode_section_info has a chance to look at the new decl
1941 flags and attributes. */
1942 if (DECL_RTL_SET_P (olddecl)
1943 && (TREE_CODE (olddecl) == FUNCTION_DECL
1944 || (TREE_CODE (olddecl) == VAR_DECL
1945 && TREE_STATIC (olddecl))))
1946 make_decl_rtl (olddecl, NULL);
1951 /* Generate an implicit declaration for identifier FUNCTIONID
1952 as a function of type int (). Print a warning if appropriate. */
1955 implicitly_declare (tree functionid)
1959 /* We used to reuse an old implicit decl here,
1960 but this loses with inline functions because it can clobber
1961 the saved decl chains. */
1962 decl = build_lang_decl (FUNCTION_DECL, functionid, default_function_type);
1964 DECL_EXTERNAL (decl) = 1;
1965 TREE_PUBLIC (decl) = 1;
1967 /* ISO standard says implicit declarations are in the innermost block.
1968 So we record the decl in the standard fashion. */
1970 rest_of_decl_compilation (decl, NULL, 0, 0);
1973 /* Only one warning per identifier. */
1974 && IDENTIFIER_IMPLICIT_DECL (functionid) == NULL_TREE)
1976 pedwarn ("implicit declaration of function `%#D'", decl);
1979 SET_IDENTIFIER_IMPLICIT_DECL (functionid, decl);
1984 /* Return zero if the declaration NEWDECL is valid
1985 when the declaration OLDDECL (assumed to be for the same name)
1986 has already been seen.
1987 Otherwise return an error message format string with a %s
1988 where the identifier should go. */
1991 redeclaration_error_message (tree newdecl, tree olddecl)
1993 if (TREE_CODE (newdecl) == TYPE_DECL)
1995 /* Because C++ can put things into name space for free,
1996 constructs like "typedef struct foo { ... } foo"
1997 would look like an erroneous redeclaration. */
1998 if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
2001 return "redefinition of `%#D'";
2003 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
2005 /* If this is a pure function, its olddecl will actually be
2006 the original initialization to `0' (which we force to call
2007 abort()). Don't complain about redefinition in this case. */
2008 if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl))
2011 /* If both functions come from different namespaces, this is not
2012 a redeclaration - this is a conflict with a used function. */
2013 if (DECL_NAMESPACE_SCOPE_P (olddecl)
2014 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
2015 return "`%D' conflicts with used function";
2017 /* We'll complain about linkage mismatches in
2018 warn_extern_redeclared_static. */
2020 /* Defining the same name twice is no good. */
2021 if (DECL_INITIAL (olddecl) != NULL_TREE
2022 && DECL_INITIAL (newdecl) != NULL_TREE)
2024 if (DECL_NAME (olddecl) == NULL_TREE)
2025 return "`%#D' not declared in class";
2027 return "redefinition of `%#D'";
2031 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2033 if ((TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
2034 && (DECL_TEMPLATE_RESULT (newdecl)
2035 != DECL_TEMPLATE_RESULT (olddecl))
2036 && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl))
2037 && DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)))
2038 || (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL
2039 && COMPLETE_TYPE_P (TREE_TYPE (newdecl))
2040 && COMPLETE_TYPE_P (TREE_TYPE (olddecl))))
2041 return "redefinition of `%#D'";
2044 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
2046 /* Objects declared at top level: */
2047 /* If at least one is a reference, it's ok. */
2048 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2050 /* Reject two definitions. */
2051 return "redefinition of `%#D'";
2055 /* Objects declared with block scope: */
2056 /* Reject two definitions, and reject a definition
2057 together with an external reference. */
2058 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
2059 return "redeclaration of `%#D'";
2064 /* Create a new label, named ID. */
2067 make_label_decl (tree id, int local_p)
2071 decl = build_decl (LABEL_DECL, id, void_type_node);
2073 DECL_CONTEXT (decl) = current_function_decl;
2074 DECL_MODE (decl) = VOIDmode;
2075 C_DECLARED_LABEL_FLAG (decl) = local_p;
2077 /* Say where one reference is to the label, for the sake of the
2078 error if it is not defined. */
2079 DECL_SOURCE_LOCATION (decl) = input_location;
2081 /* Record the fact that this identifier is bound to this label. */
2082 SET_IDENTIFIER_LABEL_VALUE (id, decl);
2087 /* Record this label on the list of used labels so that we can check
2088 at the end of the function to see whether or not the label was
2089 actually defined, and so we can check when the label is defined whether
2090 this use is valid. */
2093 use_label (tree decl)
2095 if (named_label_uses == NULL
2096 || named_label_uses->names_in_scope != current_binding_level->names
2097 || named_label_uses->label_decl != decl)
2099 struct named_label_use_list *new_ent;
2100 new_ent = ggc_alloc (sizeof (struct named_label_use_list));
2101 new_ent->label_decl = decl;
2102 new_ent->names_in_scope = current_binding_level->names;
2103 new_ent->binding_level = current_binding_level;
2104 new_ent->o_goto_locus = input_location;
2105 new_ent->next = named_label_uses;
2106 named_label_uses = new_ent;
2110 /* Look for a label named ID in the current function. If one cannot
2111 be found, create one. (We keep track of used, but undefined,
2112 labels, and complain about them at the end of a function.) */
2115 lookup_label (tree id)
2118 struct named_label_list *ent;
2120 timevar_push (TV_NAME_LOOKUP);
2121 /* You can't use labels at global scope. */
2122 if (current_function_decl == NULL_TREE)
2124 error ("label `%s' referenced outside of any function",
2125 IDENTIFIER_POINTER (id));
2126 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2129 /* See if we've already got this label. */
2130 decl = IDENTIFIER_LABEL_VALUE (id);
2131 if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
2132 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2134 /* Record this label on the list of labels used in this function.
2135 We do this before calling make_label_decl so that we get the
2136 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2137 ent = ggc_alloc_cleared (sizeof (struct named_label_list));
2138 ent->old_value = IDENTIFIER_LABEL_VALUE (id);
2139 ent->next = named_labels;
2142 /* We need a new label. */
2143 decl = make_label_decl (id, /*local_p=*/0);
2145 /* Now fill in the information we didn't have before. */
2146 ent->label_decl = decl;
2148 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2151 /* Declare a local label named ID. */
2154 declare_local_label (tree id)
2158 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2159 this scope we can restore the old value of
2160 IDENTIFIER_TYPE_VALUE. */
2161 current_binding_level->shadowed_labels
2162 = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
2163 current_binding_level->shadowed_labels);
2164 /* Look for the label. */
2165 decl = make_label_decl (id, /*local_p=*/1);
2166 /* Now fill in the information we didn't have before. */
2167 TREE_VALUE (current_binding_level->shadowed_labels) = decl;
2172 /* Returns nonzero if it is ill-formed to jump past the declaration of
2173 DECL. Returns 2 if it's also a real problem. */
2176 decl_jump_unsafe (tree decl)
2178 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
2181 if (DECL_INITIAL (decl) == NULL_TREE
2182 && pod_type_p (TREE_TYPE (decl)))
2185 /* This is really only important if we're crossing an initialization.
2186 The POD stuff is just pedantry; why should it matter if the class
2187 contains a field of pointer to member type? */
2188 if (DECL_INITIAL (decl)
2189 || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
2194 /* Check that a single previously seen jump to a newly defined label
2195 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2196 the jump context; NAMES are the names in scope in LEVEL at the jump
2197 context; FILE and LINE are the source position of the jump or 0. */
2200 check_previous_goto_1 (tree decl,
2201 struct cp_binding_level* level,
2202 tree names, const location_t *locus)
2206 struct cp_binding_level *b = current_binding_level;
2207 for (; b; b = b->level_chain)
2209 tree new_decls = b->names;
2210 tree old_decls = (b == level ? names : NULL_TREE);
2211 for (; new_decls != old_decls;
2212 new_decls = TREE_CHAIN (new_decls))
2214 int problem = decl_jump_unsafe (new_decls);
2221 pedwarn ("jump to label `%D'", decl);
2223 pedwarn ("jump to case label");
2226 pedwarn ("%H from here", locus);
2231 cp_error_at (" crosses initialization of `%#D'",
2234 cp_pedwarn_at (" enters scope of non-POD `%#D'",
2240 if ((b->kind == sk_try || b->kind == sk_catch) && ! saw_eh)
2245 pedwarn ("jump to label `%D'", decl);
2247 pedwarn ("jump to case label");
2250 pedwarn ("%H from here", locus);
2253 if (b->kind == sk_try)
2254 error (" enters try block");
2256 error (" enters catch block");
2263 check_previous_goto (struct named_label_use_list* use)
2265 check_previous_goto_1 (use->label_decl, use->binding_level,
2266 use->names_in_scope, &use->o_goto_locus);
2270 check_switch_goto (struct cp_binding_level* level)
2272 check_previous_goto_1 (NULL_TREE, level, level->names, NULL);
2275 /* Check that any previously seen jumps to a newly defined label DECL
2276 are OK. Called by define_label. */
2279 check_previous_gotos (tree decl)
2281 struct named_label_use_list **usep;
2283 if (! TREE_USED (decl))
2286 for (usep = &named_label_uses; *usep; )
2288 struct named_label_use_list *use = *usep;
2289 if (use->label_decl == decl)
2291 check_previous_goto (use);
2295 usep = &(use->next);
2299 /* Check that a new jump to a label DECL is OK. Called by
2300 finish_goto_stmt. */
2303 check_goto (tree decl)
2307 struct named_label_list *lab;
2309 /* We can't know where a computed goto is jumping. So we assume
2311 if (! DECL_P (decl))
2314 /* If the label hasn't been defined yet, defer checking. */
2315 if (! DECL_INITIAL (decl))
2321 for (lab = named_labels; lab; lab = lab->next)
2322 if (decl == lab->label_decl)
2325 /* If the label is not on named_labels it's a gcc local label, so
2326 it must be in an outer scope, so jumping to it is always OK. */
2330 if ((lab->in_try_scope || lab->in_catch_scope || lab->bad_decls)
2333 cp_pedwarn_at ("jump to label `%D'", decl);
2334 pedwarn (" from here");
2338 for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
2340 tree b = TREE_VALUE (bad);
2341 int u = decl_jump_unsafe (b);
2343 if (u > 1 && DECL_ARTIFICIAL (b))
2344 /* Can't skip init of __exception_info. */
2345 error ("%J enters catch block", b);
2347 cp_error_at (" skips initialization of `%#D'", b);
2349 cp_pedwarn_at (" enters scope of non-POD `%#D'", b);
2352 if (lab->in_try_scope)
2353 error (" enters try block");
2354 else if (lab->in_catch_scope)
2355 error (" enters catch block");
2358 /* Define a label, specifying the location in the source file.
2359 Return the LABEL_DECL node for the label. */
2362 define_label (location_t location, tree name)
2364 tree decl = lookup_label (name);
2365 struct named_label_list *ent;
2366 struct cp_binding_level *p;
2368 timevar_push (TV_NAME_LOOKUP);
2369 for (ent = named_labels; ent; ent = ent->next)
2370 if (ent->label_decl == decl)
2373 /* After labels, make any new cleanups in the function go into their
2374 own new (temporary) binding contour. */
2375 for (p = current_binding_level;
2376 p->kind != sk_function_parms;
2378 p->more_cleanups_ok = 0;
2380 if (name == get_identifier ("wchar_t"))
2381 pedwarn ("label named wchar_t");
2383 if (DECL_INITIAL (decl) != NULL_TREE)
2384 error ("duplicate label `%D'", decl);
2387 /* Mark label as having been defined. */
2388 DECL_INITIAL (decl) = error_mark_node;
2389 /* Say where in the source. */
2390 DECL_SOURCE_LOCATION (decl) = location;
2393 ent->names_in_scope = current_binding_level->names;
2394 ent->binding_level = current_binding_level;
2396 check_previous_gotos (decl);
2399 timevar_pop (TV_NAME_LOOKUP);
2405 struct cp_binding_level *level;
2406 struct cp_switch *next;
2407 /* The SWITCH_STMT being built. */
2409 /* A splay-tree mapping the low element of a case range to the high
2410 element, or NULL_TREE if there is no high element. Used to
2411 determine whether or not a new case label duplicates an old case
2412 label. We need a tree, rather than simply a hash table, because
2413 of the GNU case range extension. */
2417 /* A stack of the currently active switch statements. The innermost
2418 switch statement is on the top of the stack. There is no need to
2419 mark the stack for garbage collection because it is only active
2420 during the processing of the body of a function, and we never
2421 collect at that point. */
2423 static struct cp_switch *switch_stack;
2425 /* Called right after a switch-statement condition is parsed.
2426 SWITCH_STMT is the switch statement being parsed. */
2429 push_switch (tree switch_stmt)
2431 struct cp_switch *p = xmalloc (sizeof (struct cp_switch));
2432 p->level = current_binding_level;
2433 p->next = switch_stack;
2434 p->switch_stmt = switch_stmt;
2435 p->cases = splay_tree_new (case_compare, NULL, NULL);
2442 struct cp_switch *cs;
2445 splay_tree_delete (cs->cases);
2446 switch_stack = switch_stack->next;
2450 /* Note that we've seen a definition of a case label, and complain if this
2451 is a bad place for one. */
2454 finish_case_label (tree low_value, tree high_value)
2457 struct cp_binding_level *p;
2459 if (processing_template_decl)
2463 /* For templates, just add the case label; we'll do semantic
2464 analysis at instantiation-time. */
2465 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
2466 return add_stmt (build_case_label (low_value, high_value, label));
2469 /* Find the condition on which this switch statement depends. */
2470 cond = SWITCH_COND (switch_stack->switch_stmt);
2471 if (cond && TREE_CODE (cond) == TREE_LIST)
2472 cond = TREE_VALUE (cond);
2474 r = c_add_case_label (switch_stack->cases, cond, low_value, high_value);
2476 check_switch_goto (switch_stack->level);
2478 /* After labels, make any new cleanups in the function go into their
2479 own new (temporary) binding contour. */
2480 for (p = current_binding_level;
2481 p->kind != sk_function_parms;
2483 p->more_cleanups_ok = 0;
2488 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
2491 typename_hash (const void* k)
2496 hash = (htab_hash_pointer (TYPE_CONTEXT (t))
2497 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));
2502 /* Compare two TYPENAME_TYPEs. K1 and K2 are really of type `tree'. */
2505 typename_compare (const void * k1, const void * k2)
2514 d1 = TYPE_NAME (t1);
2515 d2 = TYPE_NAME (t2);
2517 return (DECL_NAME (d1) == DECL_NAME (d2)
2518 && TYPE_CONTEXT (t1) == TYPE_CONTEXT (t2)
2519 && ((TREE_TYPE (t1) != NULL_TREE)
2520 == (TREE_TYPE (t2) != NULL_TREE))
2521 && same_type_p (TREE_TYPE (t1), TREE_TYPE (t2))
2522 && TYPENAME_TYPE_FULLNAME (t1) == TYPENAME_TYPE_FULLNAME (t2));
2525 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
2526 the type of `T', NAME is the IDENTIFIER_NODE for `t'. If BASE_TYPE
2527 is non-NULL, this type is being created by the implicit typename
2528 extension, and BASE_TYPE is a type named `t' in some base class of
2529 `T' which depends on template parameters.
2531 Returns the new TYPENAME_TYPE. */
2533 static GTY ((param_is (union tree_node))) htab_t typename_htab;
2536 build_typename_type (tree context, tree name, tree fullname)
2542 if (typename_htab == NULL)
2544 typename_htab = htab_create_ggc (61, &typename_hash,
2545 &typename_compare, NULL);
2548 /* Build the TYPENAME_TYPE. */
2549 t = make_aggr_type (TYPENAME_TYPE);
2550 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
2551 TYPENAME_TYPE_FULLNAME (t) = fullname;
2553 /* Build the corresponding TYPE_DECL. */
2554 d = build_decl (TYPE_DECL, name, t);
2555 TYPE_NAME (TREE_TYPE (d)) = d;
2556 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2557 DECL_CONTEXT (d) = FROB_CONTEXT (context);
2558 DECL_ARTIFICIAL (d) = 1;
2560 /* See if we already have this type. */
2561 e = htab_find_slot (typename_htab, t, INSERT);
2570 /* Resolve `typename CONTEXT::NAME'. Returns an appropriate type,
2571 unless an error occurs, in which case error_mark_node is returned.
2572 If we locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is
2573 set, we return that, rather than the _TYPE it corresponds to, in
2574 other cases we look through the type decl. If TF_ERROR is set,
2575 complain about errors, otherwise be quiet. */
2578 make_typename_type (tree context, tree name, tsubst_flags_t complain)
2582 if (name == error_mark_node
2583 || context == NULL_TREE
2584 || context == error_mark_node)
2585 return error_mark_node;
2589 if (!(TYPE_LANG_SPECIFIC (name)
2590 && (CLASSTYPE_IS_TEMPLATE (name)
2591 || CLASSTYPE_USE_TEMPLATE (name))))
2592 name = TYPE_IDENTIFIER (name);
2594 /* Create a TEMPLATE_ID_EXPR for the type. */
2595 name = build_nt (TEMPLATE_ID_EXPR,
2596 CLASSTYPE_TI_TEMPLATE (name),
2597 CLASSTYPE_TI_ARGS (name));
2599 else if (TREE_CODE (name) == TYPE_DECL)
2600 name = DECL_NAME (name);
2604 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
2606 name = TREE_OPERAND (name, 0);
2607 if (TREE_CODE (name) == TEMPLATE_DECL)
2608 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
2610 if (TREE_CODE (name) == TEMPLATE_DECL)
2612 error ("`%D' used without template parameters", name);
2613 return error_mark_node;
2615 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 20030802);
2617 if (TREE_CODE (context) == NAMESPACE_DECL)
2619 /* We can get here from typename_sub0 in the explicit_template_type
2620 expansion. Just fail. */
2621 if (complain & tf_error)
2622 error ("no class template named `%#T' in `%#T'",
2624 return error_mark_node;
2627 if (!dependent_type_p (context)
2628 || currently_open_class (context))
2630 if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
2632 tree tmpl = NULL_TREE;
2633 if (IS_AGGR_TYPE (context))
2634 tmpl = lookup_field (context, name, 0, false);
2635 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
2637 if (complain & tf_error)
2638 error ("no class template named `%#T' in `%#T'",
2640 return error_mark_node;
2643 if (complain & tf_error)
2644 perform_or_defer_access_check (TYPE_BINFO (context), tmpl);
2646 return lookup_template_class (tmpl,
2647 TREE_OPERAND (fullname, 1),
2649 /*entering_scope=*/0,
2650 tf_error | tf_warning | tf_user);
2656 if (!IS_AGGR_TYPE (context))
2658 if (complain & tf_error)
2659 error ("no type named `%#T' in `%#T'", name, context);
2660 return error_mark_node;
2663 t = lookup_field (context, name, 0, true);
2666 if (TREE_CODE (t) != TYPE_DECL)
2668 if (complain & tf_error)
2669 error ("no type named `%#T' in `%#T'", name, context);
2670 return error_mark_node;
2673 if (complain & tf_error)
2674 perform_or_defer_access_check (TYPE_BINFO (context), t);
2676 if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
2684 /* If the CONTEXT is not a template type, then either the field is
2685 there now or its never going to be. */
2686 if (!dependent_type_p (context))
2688 if (complain & tf_error)
2689 error ("no type named `%#T' in `%#T'", name, context);
2690 return error_mark_node;
2693 return build_typename_type (context, name, fullname);
2696 /* Resolve `CONTEXT::template NAME'. Returns an appropriate type,
2697 unless an error occurs, in which case error_mark_node is returned.
2698 If we locate a TYPE_DECL, we return that, rather than the _TYPE it
2699 corresponds to. If COMPLAIN zero, don't complain about any errors
2703 make_unbound_class_template (tree context, tree name, tsubst_flags_t complain)
2709 name = TYPE_IDENTIFIER (name);
2710 else if (DECL_P (name))
2711 name = DECL_NAME (name);
2712 if (TREE_CODE (name) != IDENTIFIER_NODE)
2715 if (!dependent_type_p (context)
2716 || currently_open_class (context))
2718 tree tmpl = NULL_TREE;
2720 if (IS_AGGR_TYPE (context))
2721 tmpl = lookup_field (context, name, 0, false);
2723 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
2725 if (complain & tf_error)
2726 error ("no class template named `%#T' in `%#T'", name, context);
2727 return error_mark_node;
2730 if (complain & tf_error)
2731 perform_or_defer_access_check (TYPE_BINFO (context), tmpl);
2736 /* Build the UNBOUND_CLASS_TEMPLATE. */
2737 t = make_aggr_type (UNBOUND_CLASS_TEMPLATE);
2738 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
2739 TREE_TYPE (t) = NULL_TREE;
2741 /* Build the corresponding TEMPLATE_DECL. */
2742 d = build_decl (TEMPLATE_DECL, name, t);
2743 TYPE_NAME (TREE_TYPE (d)) = d;
2744 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2745 DECL_CONTEXT (d) = FROB_CONTEXT (context);
2746 DECL_ARTIFICIAL (d) = 1;
2753 /* A chain of TYPE_DECLs for the builtin types. */
2755 static GTY(()) tree builtin_type_decls;
2757 /* Return a chain of TYPE_DECLs for the builtin types. */
2760 cxx_builtin_type_decls (void)
2762 return builtin_type_decls;
2765 /* Push the declarations of builtin types into the namespace.
2766 RID_INDEX is the index of the builtin type in the array
2767 RID_POINTERS. NAME is the name used when looking up the builtin
2768 type. TYPE is the _TYPE node for the builtin type. */
2771 record_builtin_type (enum rid rid_index,
2775 tree rname = NULL_TREE, tname = NULL_TREE;
2776 tree tdecl = NULL_TREE;
2778 if ((int) rid_index < (int) RID_MAX)
2779 rname = ridpointers[(int) rid_index];
2781 tname = get_identifier (name);
2783 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
2784 eliminated. Built-in types should not be looked up name; their
2785 names are keywords that the parser can recognize. However, there
2786 is code in c-common.c that uses identifier_global_value to look
2787 up built-in types by name. */
2790 tdecl = build_decl (TYPE_DECL, tname, type);
2791 DECL_ARTIFICIAL (tdecl) = 1;
2792 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
2798 tdecl = build_decl (TYPE_DECL, rname, type);
2799 DECL_ARTIFICIAL (tdecl) = 1;
2801 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
2804 if (!TYPE_NAME (type))
2805 TYPE_NAME (type) = tdecl;
2809 TREE_CHAIN (tdecl) = builtin_type_decls;
2810 builtin_type_decls = tdecl;
2814 /* Record one of the standard Java types.
2815 * Declare it as having the given NAME.
2816 * If SIZE > 0, it is the size of one of the integral types;
2817 * otherwise it is the negative of the size of one of the other types. */
2820 record_builtin_java_type (const char* name, int size)
2824 type = make_signed_type (size);
2825 else if (size > -32)
2826 { /* "__java_char" or ""__java_boolean". */
2827 type = make_unsigned_type (-size);
2828 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
2831 { /* "__java_float" or ""__java_double". */
2832 type = make_node (REAL_TYPE);
2833 TYPE_PRECISION (type) = - size;
2836 record_builtin_type (RID_MAX, name, type);
2837 decl = TYPE_NAME (type);
2839 /* Suppress generate debug symbol entries for these types,
2840 since for normal C++ they are just clutter.
2841 However, push_lang_context undoes this if extern "Java" is seen. */
2842 DECL_IGNORED_P (decl) = 1;
2844 TYPE_FOR_JAVA (type) = 1;
2848 /* Push a type into the namespace so that the back-ends ignore it. */
2851 record_unknown_type (tree type, const char* name)
2853 tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
2854 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
2855 DECL_IGNORED_P (decl) = 1;
2856 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
2857 TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
2858 TYPE_ALIGN (type) = 1;
2859 TYPE_USER_ALIGN (type) = 0;
2860 TYPE_MODE (type) = TYPE_MODE (void_type_node);
2863 /* An string for which we should create an IDENTIFIER_NODE at
2866 typedef struct predefined_identifier
2868 /* The name of the identifier. */
2869 const char *const name;
2870 /* The place where the IDENTIFIER_NODE should be stored. */
2872 /* Nonzero if this is the name of a constructor or destructor. */
2873 const int ctor_or_dtor_p;
2874 } predefined_identifier;
2876 /* Create all the predefined identifiers. */
2879 initialize_predefined_identifiers (void)
2881 const predefined_identifier *pid;
2883 /* A table of identifiers to create at startup. */
2884 static const predefined_identifier predefined_identifiers[] = {
2885 { "C++", &lang_name_cplusplus, 0 },
2886 { "C", &lang_name_c, 0 },
2887 { "Java", &lang_name_java, 0 },
2888 { CTOR_NAME, &ctor_identifier, 1 },
2889 { "__base_ctor", &base_ctor_identifier, 1 },
2890 { "__comp_ctor", &complete_ctor_identifier, 1 },
2891 { DTOR_NAME, &dtor_identifier, 1 },
2892 { "__comp_dtor", &complete_dtor_identifier, 1 },
2893 { "__base_dtor", &base_dtor_identifier, 1 },
2894 { "__deleting_dtor", &deleting_dtor_identifier, 1 },
2895 { IN_CHARGE_NAME, &in_charge_identifier, 0 },
2896 { "nelts", &nelts_identifier, 0 },
2897 { THIS_NAME, &this_identifier, 0 },
2898 { VTABLE_DELTA_NAME, &delta_identifier, 0 },
2899 { VTABLE_PFN_NAME, &pfn_identifier, 0 },
2900 { "_vptr", &vptr_identifier, 0 },
2901 { "__vtt_parm", &vtt_parm_identifier, 0 },
2902 { "::", &global_scope_name, 0 },
2903 { "std", &std_identifier, 0 },
2907 for (pid = predefined_identifiers; pid->name; ++pid)
2909 *pid->node = get_identifier (pid->name);
2910 if (pid->ctor_or_dtor_p)
2911 IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
2915 /* Create the predefined scalar types of C,
2916 and some nodes representing standard constants (0, 1, (void *)0).
2917 Initialize the global binding level.
2918 Make definitions for built-in primitive functions. */
2921 cxx_init_decl_processing (void)
2924 tree void_ftype_ptr;
2926 /* Create all the identifiers we need. */
2927 initialize_predefined_identifiers ();
2929 /* Fill in back-end hooks. */
2930 lang_missing_noreturn_ok_p = &cp_missing_noreturn_ok_p;
2932 /* Create the global variables. */
2933 push_to_top_level ();
2935 current_function_decl = NULL_TREE;
2936 current_binding_level = NULL;
2937 /* Enter the global namespace. */
2938 my_friendly_assert (global_namespace == NULL_TREE, 375);
2939 global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name,
2941 begin_scope (sk_namespace, global_namespace);
2943 current_lang_name = NULL_TREE;
2945 /* Adjust various flags based on command-line settings. */
2946 if (!flag_permissive)
2947 flag_pedantic_errors = 1;
2948 if (!flag_no_inline)
2950 flag_inline_trees = 1;
2953 if (flag_inline_functions)
2955 flag_inline_trees = 2;
2956 flag_inline_functions = 0;
2959 /* Force minimum function alignment if using the least significant
2960 bit of function pointers to store the virtual bit. */
2961 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
2962 && force_align_functions_log < 1)
2963 force_align_functions_log = 1;
2966 current_lang_name = lang_name_c;
2968 build_common_tree_nodes (flag_signed_char);
2970 error_mark_list = build_tree_list (error_mark_node, error_mark_node);
2971 TREE_TYPE (error_mark_list) = error_mark_node;
2973 /* Create the `std' namespace. */
2974 push_namespace (std_identifier);
2975 std_node = current_namespace;
2978 c_common_nodes_and_builtins ();
2980 java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
2981 java_short_type_node = record_builtin_java_type ("__java_short", 16);
2982 java_int_type_node = record_builtin_java_type ("__java_int", 32);
2983 java_long_type_node = record_builtin_java_type ("__java_long", 64);
2984 java_float_type_node = record_builtin_java_type ("__java_float", -32);
2985 java_double_type_node = record_builtin_java_type ("__java_double", -64);
2986 java_char_type_node = record_builtin_java_type ("__java_char", -16);
2987 java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
2989 integer_two_node = build_int_2 (2, 0);
2990 TREE_TYPE (integer_two_node) = integer_type_node;
2991 integer_three_node = build_int_2 (3, 0);
2992 TREE_TYPE (integer_three_node) = integer_type_node;
2994 record_builtin_type (RID_BOOL, "bool", boolean_type_node);
2995 truthvalue_type_node = boolean_type_node;
2996 truthvalue_false_node = boolean_false_node;
2997 truthvalue_true_node = boolean_true_node;
2999 empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
3002 record_builtin_type (RID_MAX, NULL, string_type_node);
3005 delta_type_node = ptrdiff_type_node;
3006 vtable_index_type = ptrdiff_type_node;
3008 vtt_parm_type = build_pointer_type (const_ptr_type_node);
3009 void_ftype = build_function_type (void_type_node, void_list_node);
3010 void_ftype_ptr = build_function_type (void_type_node,
3011 tree_cons (NULL_TREE,
3015 = build_exception_variant (void_ftype_ptr, empty_except_spec);
3017 /* C++ extensions */
3019 unknown_type_node = make_node (UNKNOWN_TYPE);
3020 record_unknown_type (unknown_type_node, "unknown type");
3022 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3023 TREE_TYPE (unknown_type_node) = unknown_type_node;
3025 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3027 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
3028 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
3031 /* Make sure we get a unique function type, so we can give
3032 its pointer type a name. (This wins for gdb.) */
3033 tree vfunc_type = make_node (FUNCTION_TYPE);
3034 TREE_TYPE (vfunc_type) = integer_type_node;
3035 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
3036 layout_type (vfunc_type);
3038 vtable_entry_type = build_pointer_type (vfunc_type);
3040 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
3043 = build_cplus_array_type (vtable_entry_type, NULL_TREE);
3044 layout_type (vtbl_type_node);
3045 vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
3046 record_builtin_type (RID_MAX, NULL, vtbl_type_node);
3047 vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
3048 layout_type (vtbl_ptr_type_node);
3049 record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
3051 push_namespace (get_identifier ("__cxxabiv1"));
3052 abi_node = current_namespace;
3055 global_type_node = make_node (LANG_TYPE);
3056 record_unknown_type (global_type_node, "global type");
3059 current_lang_name = lang_name_cplusplus;
3063 tree bad_alloc_type_node;
3064 tree bad_alloc_decl;
3065 tree newtype, deltype;
3066 tree ptr_ftype_sizetype;
3068 push_namespace (std_identifier);
3069 bad_alloc_id = get_identifier ("bad_alloc");
3070 bad_alloc_type_node = make_aggr_type (RECORD_TYPE);
3071 TYPE_CONTEXT (bad_alloc_type_node) = current_namespace;
3073 = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node);
3074 DECL_CONTEXT (bad_alloc_decl) = current_namespace;
3075 TYPE_STUB_DECL (bad_alloc_type_node) = bad_alloc_decl;
3079 = build_function_type (ptr_type_node,
3080 tree_cons (NULL_TREE,
3083 newtype = build_exception_variant
3084 (ptr_ftype_sizetype, add_exception_specifier
3085 (NULL_TREE, bad_alloc_type_node, -1));
3086 deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
3087 push_cp_library_fn (NEW_EXPR, newtype);
3088 push_cp_library_fn (VEC_NEW_EXPR, newtype);
3089 global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
3090 push_cp_library_fn (VEC_DELETE_EXPR, deltype);
3094 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
3096 /* Perform other language dependent initializations. */
3097 init_class_processing ();
3098 init_search_processing ();
3099 init_rtti_processing ();
3101 if (flag_exceptions)
3102 init_exception_processing ();
3104 if (! supports_one_only ())
3107 make_fname_decl = cp_make_fname_decl;
3108 start_fname_decls ();
3110 /* Show we use EH for cleanups. */
3111 using_eh_for_cleanups ();
3113 /* Maintain consistency. Perhaps we should just complain if they
3114 say -fwritable-strings? */
3115 if (flag_writable_strings)
3116 flag_const_strings = 0;
3119 /* Generate an initializer for a function naming variable from
3120 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3121 filled in with the type of the init. */
3124 cp_fname_init (const char* name, tree *type_p)
3126 tree domain = NULL_TREE;
3128 tree init = NULL_TREE;
3133 length = strlen (name);
3134 domain = build_index_type (size_int (length));
3135 init = build_string (length + 1, name);
3138 type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
3139 type = build_cplus_array_type (type, domain);
3144 TREE_TYPE (init) = type;
3146 init = error_mark_node;
3151 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
3152 decl, NAME is the initialization string and TYPE_DEP indicates whether
3153 NAME depended on the type of the function. We make use of that to detect
3154 __PRETTY_FUNCTION__ inside a template fn. This is being done
3155 lazily at the point of first use, so we musn't push the decl now. */
3158 cp_make_fname_decl (tree id, int type_dep)
3160 const char *const name = (type_dep && processing_template_decl
3161 ? NULL : fname_as_string (type_dep));
3163 tree init = cp_fname_init (name, &type);
3164 tree decl = build_decl (VAR_DECL, id, type);
3166 /* As we're using pushdecl_with_scope, we must set the context. */
3167 DECL_CONTEXT (decl) = current_function_decl;
3168 DECL_PRETTY_FUNCTION_P (decl) = type_dep;
3170 TREE_STATIC (decl) = 1;
3171 TREE_READONLY (decl) = 1;
3172 DECL_ARTIFICIAL (decl) = 1;
3173 DECL_INITIAL (decl) = init;
3175 TREE_USED (decl) = 1;
3177 if (current_function_decl)
3179 struct cp_binding_level *b = current_binding_level;
3180 while (b->level_chain->kind != sk_function_parms)
3182 pushdecl_with_scope (decl, b);
3183 cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
3186 pushdecl_top_level_and_finish (decl, init);
3191 /* Make a definition for a builtin function named NAME in the current
3192 namespace, whose data type is TYPE and whose context is CONTEXT.
3193 TYPE should be a function type with argument types.
3195 CLASS and CODE tell later passes how to compile calls to this function.
3196 See tree.h for possible values.
3198 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3199 the name to be called if we can't opencode the function.
3200 If ATTRS is nonzero, use that for the function's attribute
3204 builtin_function_1 (const char* name,
3208 enum built_in_class class,
3209 const char* libname,
3212 tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
3213 DECL_BUILT_IN_CLASS (decl) = class;
3214 DECL_FUNCTION_CODE (decl) = code;
3215 DECL_CONTEXT (decl) = context;
3219 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
3220 we cannot change DECL_ASSEMBLER_NAME until we have installed this
3221 function in the namespace. */
3223 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
3224 make_decl_rtl (decl, NULL);
3226 /* Warn if a function in the namespace for users
3227 is used without an occasion to consider it declared. */
3228 if (name[0] != '_' || name[1] != '_')
3229 DECL_ANTICIPATED (decl) = 1;
3231 /* Possibly apply some default attributes to this built-in function. */
3233 decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
3235 decl_attributes (&decl, NULL_TREE, 0);
3240 /* Entry point for the benefit of c_common_nodes_and_builtins.
3242 Make a definition for a builtin function named NAME and whose data type
3243 is TYPE. TYPE should be a function type with argument types. This
3244 function places the anticipated declaration in the global namespace
3245 and additionally in the std namespace if appropriate.
3247 CLASS and CODE tell later passes how to compile calls to this function.
3248 See tree.h for possible values.
3250 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3251 the name to be called if we can't opencode the function.
3253 If ATTRS is nonzero, use that for the function's attribute
3257 builtin_function (const char* name,
3260 enum built_in_class class,
3261 const char* libname,
3264 /* All builtins that don't begin with an '_' should additionally
3265 go in the 'std' namespace. */
3268 push_namespace (std_identifier);
3269 builtin_function_1 (name, type, std_node, code, class, libname, attrs);
3273 return builtin_function_1 (name, type, NULL_TREE, code,
3274 class, libname, attrs);
3277 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
3278 function. Not called directly. */
3281 build_library_fn_1 (tree name, enum tree_code operator_code, tree type)
3283 tree fn = build_lang_decl (FUNCTION_DECL, name, type);
3284 DECL_EXTERNAL (fn) = 1;
3285 TREE_PUBLIC (fn) = 1;
3286 DECL_ARTIFICIAL (fn) = 1;
3287 TREE_NOTHROW (fn) = 1;
3288 SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
3289 SET_DECL_LANGUAGE (fn, lang_c);
3293 /* Returns the _DECL for a library function with C linkage.
3294 We assume that such functions never throw; if this is incorrect,
3295 callers should unset TREE_NOTHROW. */
3298 build_library_fn (tree name, tree type)
3300 return build_library_fn_1 (name, ERROR_MARK, type);
3303 /* Returns the _DECL for a library function with C++ linkage. */
3306 build_cp_library_fn (tree name, enum tree_code operator_code, tree type)
3308 tree fn = build_library_fn_1 (name, operator_code, type);
3309 TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
3310 DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
3311 SET_DECL_LANGUAGE (fn, lang_cplusplus);
3312 set_mangled_name_for_decl (fn);
3316 /* Like build_library_fn, but takes a C string instead of an
3320 build_library_fn_ptr (const char* name, tree type)
3322 return build_library_fn (get_identifier (name), type);
3325 /* Like build_cp_library_fn, but takes a C string instead of an
3329 build_cp_library_fn_ptr (const char* name, tree type)
3331 return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
3334 /* Like build_library_fn, but also pushes the function so that we will
3335 be able to find it via IDENTIFIER_GLOBAL_VALUE. */
3338 push_library_fn (tree name, tree type)
3340 tree fn = build_library_fn (name, type);
3341 pushdecl_top_level (fn);
3345 /* Like build_cp_library_fn, but also pushes the function so that it
3346 will be found by normal lookup. */
3349 push_cp_library_fn (enum tree_code operator_code, tree type)
3351 tree fn = build_cp_library_fn (ansi_opname (operator_code),
3358 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
3362 push_void_library_fn (tree name, tree parmtypes)
3364 tree type = build_function_type (void_type_node, parmtypes);
3365 return push_library_fn (name, type);
3368 /* Like push_library_fn, but also note that this function throws
3369 and does not return. Used for __throw_foo and the like. */
3372 push_throw_library_fn (tree name, tree type)
3374 tree fn = push_library_fn (name, type);
3375 TREE_THIS_VOLATILE (fn) = 1;
3376 TREE_NOTHROW (fn) = 0;
3380 /* When we call finish_struct for an anonymous union, we create
3381 default copy constructors and such. But, an anonymous union
3382 shouldn't have such things; this function undoes the damage to the
3383 anonymous union type T.
3385 (The reason that we create the synthesized methods is that we don't
3386 distinguish `union { int i; }' from `typedef union { int i; } U'.
3387 The first is an anonymous union; the second is just an ordinary
3391 fixup_anonymous_aggr (tree t)
3395 /* Wipe out memory of synthesized methods. */
3396 TYPE_HAS_CONSTRUCTOR (t) = 0;
3397 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
3398 TYPE_HAS_INIT_REF (t) = 0;
3399 TYPE_HAS_CONST_INIT_REF (t) = 0;
3400 TYPE_HAS_ASSIGN_REF (t) = 0;
3401 TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
3403 /* Splice the implicitly generated functions out of the TYPE_METHODS
3405 q = &TYPE_METHODS (t);
3408 if (DECL_ARTIFICIAL (*q))
3409 *q = TREE_CHAIN (*q);
3411 q = &TREE_CHAIN (*q);
3414 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
3415 if (TYPE_METHODS (t))
3416 error ("%Jan anonymous union cannot have function members",
3417 TYPE_MAIN_DECL (t));
3419 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
3420 assignment operators (because they cannot have these methods themselves).
3421 For anonymous unions this is already checked because they are not allowed
3422 in any union, otherwise we have to check it. */
3423 if (TREE_CODE (t) != UNION_TYPE)
3427 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
3428 if (TREE_CODE (field) == FIELD_DECL)
3430 type = TREE_TYPE (field);
3431 if (CLASS_TYPE_P (type))
3433 if (TYPE_NEEDS_CONSTRUCTING (type))
3434 cp_error_at ("member %#D' with constructor not allowed in anonymous aggregate",
3436 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
3437 cp_error_at ("member %#D' with destructor not allowed in anonymous aggregate",
3439 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
3440 cp_error_at ("member %#D' with copy assignment operator not allowed in anonymous aggregate",
3447 /* Make sure that a declaration with no declarator is well-formed, i.e.
3448 just declares a tagged type or anonymous union.
3450 Returns the type declared; or NULL_TREE if none. */
3453 check_tag_decl (tree declspecs)
3457 int saw_typedef = 0;
3458 tree ob_modifier = NULL_TREE;
3460 /* If a class, struct, or enum type is declared by the DECLSPECS
3461 (i.e, if a class-specifier, enum-specifier, or non-typename
3462 elaborated-type-specifier appears in the DECLSPECS),
3463 DECLARED_TYPE is set to the corresponding type. */
3464 tree declared_type = NULL_TREE;
3465 bool error_p = false;
3467 for (link = declspecs; link; link = TREE_CHAIN (link))
3469 tree value = TREE_VALUE (link);
3471 if (TYPE_P (value) || TREE_CODE (value) == TYPE_DECL
3472 || (TREE_CODE (value) == IDENTIFIER_NODE
3473 && is_typename_at_global_scope (value)))
3477 if (found_type == 2 && TREE_CODE (value) == IDENTIFIER_NODE)
3479 if (! in_system_header)
3480 pedwarn ("redeclaration of C++ built-in type `%T'", value);
3485 && ((TREE_CODE (value) != TYPENAME_TYPE && IS_AGGR_TYPE (value))
3486 || TREE_CODE (value) == ENUMERAL_TYPE))
3488 my_friendly_assert (TYPE_MAIN_DECL (value) != NULL_TREE, 261);
3489 declared_type = value;
3492 else if (value == ridpointers[(int) RID_TYPEDEF])
3494 else if (value == ridpointers[(int) RID_FRIEND])
3496 if (current_class_type == NULL_TREE
3497 || current_scope () != current_class_type)
3498 ob_modifier = value;
3502 else if (value == ridpointers[(int) RID_STATIC]
3503 || value == ridpointers[(int) RID_EXTERN]
3504 || value == ridpointers[(int) RID_AUTO]
3505 || value == ridpointers[(int) RID_REGISTER]
3506 || value == ridpointers[(int) RID_INLINE]
3507 || value == ridpointers[(int) RID_VIRTUAL]
3508 || value == ridpointers[(int) RID_CONST]
3509 || value == ridpointers[(int) RID_VOLATILE]
3510 || value == ridpointers[(int) RID_EXPLICIT]
3511 || value == ridpointers[(int) RID_THREAD])
3512 ob_modifier = value;
3513 else if (value == error_mark_node)
3518 error ("multiple types in one declaration");
3520 if (declared_type == NULL_TREE && ! saw_friend && !error_p)
3521 pedwarn ("declaration does not declare anything");
3522 /* Check for an anonymous union. */
3523 else if (declared_type && IS_AGGR_TYPE_CODE (TREE_CODE (declared_type))
3524 && TYPE_ANONYMOUS_P (declared_type))
3526 /* 7/3 In a simple-declaration, the optional init-declarator-list
3527 can be omitted only when declaring a class (clause 9) or
3528 enumeration (7.2), that is, when the decl-specifier-seq contains
3529 either a class-specifier, an elaborated-type-specifier with
3530 a class-key (9.1), or an enum-specifier. In these cases and
3531 whenever a class-specifier or enum-specifier is present in the
3532 decl-specifier-seq, the identifiers in these specifiers are among
3533 the names being declared by the declaration (as class-name,
3534 enum-names, or enumerators, depending on the syntax). In such
3535 cases, and except for the declaration of an unnamed bit-field (9.6),
3536 the decl-specifier-seq shall introduce one or more names into the
3537 program, or shall redeclare a name introduced by a previous
3538 declaration. [Example:
3539 enum { }; // ill-formed
3540 typedef class { }; // ill-formed
3544 error ("missing type-name in typedef-declaration");
3547 /* Anonymous unions are objects, so they can have specifiers. */;
3548 SET_ANON_AGGR_TYPE_P (declared_type);
3550 if (TREE_CODE (declared_type) != UNION_TYPE && pedantic
3551 && !in_system_header)
3552 pedwarn ("ISO C++ prohibits anonymous structs");
3555 else if (ob_modifier)
3557 if (ob_modifier == ridpointers[(int) RID_INLINE]
3558 || ob_modifier == ridpointers[(int) RID_VIRTUAL])
3559 error ("`%D' can only be specified for functions", ob_modifier);
3560 else if (ob_modifier == ridpointers[(int) RID_FRIEND])
3561 error ("`%D' can only be specified inside a class", ob_modifier);
3562 else if (ob_modifier == ridpointers[(int) RID_EXPLICIT])
3563 error ("`%D' can only be specified for constructors",
3566 error ("`%D' can only be specified for objects and functions",
3570 return declared_type;
3573 /* Called when a declaration is seen that contains no names to declare.
3574 If its type is a reference to a structure, union or enum inherited
3575 from a containing scope, shadow that tag name for the current scope
3576 with a forward reference.
3577 If its type defines a new named structure or union
3578 or defines an enum, it is valid but we need not do anything here.
3579 Otherwise, it is an error.
3581 C++: may have to grok the declspecs to learn about static,
3582 complain for anonymous unions.
3584 Returns the TYPE declared -- or NULL_TREE if none. */
3587 shadow_tag (tree declspecs)
3589 tree t = check_tag_decl (declspecs);
3594 maybe_process_partial_specialization (t);
3596 /* This is where the variables in an anonymous union are
3597 declared. An anonymous union declaration looks like:
3599 because there is no declarator after the union, the parser
3600 sends that declaration here. */
3601 if (ANON_AGGR_TYPE_P (t))
3603 fixup_anonymous_aggr (t);
3605 if (TYPE_FIELDS (t))
3607 tree decl = grokdeclarator (NULL_TREE, declspecs, NORMAL, 0,
3609 finish_anon_union (decl);
3616 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
3619 groktypename (tree typename)
3623 if (TREE_CODE (typename) != TREE_LIST)
3625 split_specs_attrs (TREE_PURPOSE (typename), &specs, &attrs);
3626 type = grokdeclarator (TREE_VALUE (typename), specs,
3627 TYPENAME, 0, &attrs);
3629 cplus_decl_attributes (&type, attrs, 0);
3633 /* Decode a declarator in an ordinary declaration or data definition.
3634 This is called as soon as the type information and variable name
3635 have been parsed, before parsing the initializer if any.
3636 Here we create the ..._DECL node, fill in its type,
3637 and put it on the list of decls for the current context.
3638 The ..._DECL node is returned as the value.
3640 Exception: for arrays where the length is not specified,
3641 the type is left null, to be filled in by `cp_finish_decl'.
3643 Function definitions do not come here; they go to start_function
3644 instead. However, external and forward declarations of functions
3645 do go through here. Structure field declarations are done by
3646 grokfield and not through here. */
3649 start_decl (tree declarator,
3653 tree prefix_attributes)
3659 /* This should only be done once on the top most decl. */
3660 if (have_extern_spec)
3662 declspecs = tree_cons (NULL_TREE, get_identifier ("extern"),
3664 have_extern_spec = false;
3667 /* An object declared as __attribute__((deprecated)) suppresses
3668 warnings of uses of other deprecated items. */
3669 if (lookup_attribute ("deprecated", attributes))
3670 deprecated_state = DEPRECATED_SUPPRESS;
3672 attributes = chainon (attributes, prefix_attributes);
3674 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
3677 deprecated_state = DEPRECATED_NORMAL;
3679 if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
3682 type = TREE_TYPE (decl);
3684 if (type == error_mark_node)
3687 context = DECL_CONTEXT (decl);
3689 if (initialized && context && TREE_CODE (context) == NAMESPACE_DECL
3690 && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
3692 /* When parsing the initializer, lookup should use the object's
3694 push_decl_namespace (context);
3697 /* We are only interested in class contexts, later. */
3698 if (context && TREE_CODE (context) == NAMESPACE_DECL)
3699 context = NULL_TREE;
3702 /* Is it valid for this decl to have an initializer at all?
3703 If not, set INITIALIZED to zero, which will indirectly
3704 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
3705 switch (TREE_CODE (decl))
3708 error ("typedef `%D' is initialized (use __typeof__ instead)", decl);
3713 error ("function `%#D' is initialized like a variable", decl);
3723 if (! toplevel_bindings_p ()
3724 && DECL_EXTERNAL (decl))
3725 warning ("declaration of `%#D' has `extern' and is initialized",
3727 DECL_EXTERNAL (decl) = 0;
3728 if (toplevel_bindings_p ())
3729 TREE_STATIC (decl) = 1;
3731 /* Tell `pushdecl' this is an initialized decl
3732 even though we don't yet have the initializer expression.
3733 Also tell `cp_finish_decl' it may store the real initializer. */
3734 DECL_INITIAL (decl) = error_mark_node;
3737 /* Set attributes here so if duplicate decl, will have proper attributes. */
3738 cplus_decl_attributes (&decl, attributes, 0);
3740 /* If #pragma weak was used, mark the decl weak now. */
3741 if (global_scope_p (current_binding_level))
3742 maybe_apply_pragma_weak (decl);
3744 if (TREE_CODE (decl) == FUNCTION_DECL
3745 && DECL_DECLARED_INLINE_P (decl)
3746 && DECL_UNINLINABLE (decl)
3747 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
3748 warning ("%Jinline function '%D' given attribute noinline", decl, decl);
3750 if (context && COMPLETE_TYPE_P (complete_type (context)))
3752 push_nested_class (context);
3754 if (TREE_CODE (decl) == VAR_DECL)
3756 tree field = lookup_field (context, DECL_NAME (decl), 0, false);
3757 if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
3758 error ("`%#D' is not a static member of `%#T'", decl, context);
3761 if (DECL_CONTEXT (field) != context)
3763 if (!same_type_p (DECL_CONTEXT (field), context))
3764 pedwarn ("ISO C++ does not permit `%T::%D' to be defined as `%T::%D'",
3765 DECL_CONTEXT (field), DECL_NAME (decl),
3766 context, DECL_NAME (decl));
3767 DECL_CONTEXT (decl) = DECL_CONTEXT (field);
3769 /* Static data member are tricky; an in-class initialization
3770 still doesn't provide a definition, so the in-class
3771 declaration will have DECL_EXTERNAL set, but will have an
3772 initialization. Thus, duplicate_decls won't warn
3773 about this situation, and so we check here. */
3774 if (DECL_INITIAL (decl) && DECL_INITIAL (field))
3775 error ("duplicate initialization of %D", decl);
3776 if (duplicate_decls (decl, field))
3782 tree field = check_classfn (context, decl,
3783 processing_template_decl
3784 > template_class_depth (context));
3785 if (field && duplicate_decls (decl, field))
3789 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
3790 DECL_IN_AGGR_P (decl) = 0;
3791 if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
3792 || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
3794 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
3795 /* [temp.expl.spec] An explicit specialization of a static data
3796 member of a template is a definition if the declaration
3797 includes an initializer; otherwise, it is a declaration.
3799 We check for processing_specialization so this only applies
3800 to the new specialization syntax. */
3801 if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
3802 DECL_EXTERNAL (decl) = 1;
3805 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
3806 pedwarn ("declaration of `%#D' outside of class is not definition",
3810 /* Enter this declaration into the symbol table. */
3811 tem = maybe_push_decl (decl);
3813 if (processing_template_decl)
3814 tem = push_template_decl (tem);
3815 if (tem == error_mark_node)
3816 return error_mark_node;
3818 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
3819 /* Tell the back-end to use or not use .common as appropriate. If we say
3820 -fconserve-space, we want this to save .data space, at the expense of
3821 wrong semantics. If we say -fno-conserve-space, we want this to
3822 produce errors about redefs; to do this we force variables into the
3824 DECL_COMMON (tem) = ((TREE_CODE (tem) != VAR_DECL
3825 || !DECL_THREAD_LOCAL (tem))
3826 && (flag_conserve_space || ! TREE_PUBLIC (tem)));
3829 if (! processing_template_decl)
3836 start_decl_1 (tree decl)
3838 tree type = TREE_TYPE (decl);
3839 int initialized = (DECL_INITIAL (decl) != NULL_TREE);
3841 if (type == error_mark_node)
3844 maybe_push_cleanup_level (type);
3847 /* Is it valid for this decl to have an initializer at all?
3848 If not, set INITIALIZED to zero, which will indirectly
3849 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
3851 /* Don't allow initializations for incomplete types except for
3852 arrays which might be completed by the initialization. */
3853 if (COMPLETE_TYPE_P (complete_type (type)))
3854 ; /* A complete type is ok. */
3855 else if (TREE_CODE (type) != ARRAY_TYPE)
3857 error ("variable `%#D' has initializer but incomplete type",
3860 type = TREE_TYPE (decl) = error_mark_node;
3862 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
3864 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
3865 error ("elements of array `%#D' have incomplete type", decl);
3866 /* else we already gave an error in start_decl. */
3872 && TREE_CODE (decl) != TYPE_DECL
3873 && TREE_CODE (decl) != TEMPLATE_DECL
3874 && type != error_mark_node
3875 && IS_AGGR_TYPE (type)
3876 && ! DECL_EXTERNAL (decl))
3878 if ((! processing_template_decl || ! uses_template_parms (type))
3879 && !COMPLETE_TYPE_P (complete_type (type)))
3881 error ("aggregate `%#D' has incomplete type and cannot be defined",
3883 /* Change the type so that assemble_variable will give
3884 DECL an rtl we can live with: (mem (const_int 0)). */
3885 type = TREE_TYPE (decl) = error_mark_node;
3889 /* If any base type in the hierarchy of TYPE needs a constructor,
3890 then we set initialized to 1. This way any nodes which are
3891 created for the purposes of initializing this aggregate
3892 will live as long as it does. This is necessary for global
3893 aggregates which do not have their initializers processed until
3894 the end of the file. */
3895 initialized = TYPE_NEEDS_CONSTRUCTING (type);
3900 DECL_INITIAL (decl) = NULL_TREE;
3903 /* Handle initialization of references. DECL, TYPE, and INIT have the
3904 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
3905 but will be set to a new CLEANUP_STMT if a temporary is created
3906 that must be destroyed subsequently.
3908 Returns an initializer expression to use to initialize DECL, or
3909 NULL if the initialization can be performed statically.
3911 Quotes on semantics can be found in ARM 8.4.3. */
3914 grok_reference_init (tree decl, tree type, tree init, tree *cleanup)
3918 if (init == NULL_TREE)
3920 if ((DECL_LANG_SPECIFIC (decl) == 0
3921 || DECL_IN_AGGR_P (decl) == 0)
3922 && ! DECL_THIS_EXTERN (decl))
3923 error ("`%D' declared as reference but not initialized", decl);
3927 if (TREE_CODE (init) == CONSTRUCTOR)
3929 error ("ISO C++ forbids use of initializer list to initialize reference `%D'", decl);
3933 if (TREE_CODE (init) == TREE_LIST)
3934 init = build_x_compound_expr_from_list (init, "initializer");
3936 if (TREE_CODE (TREE_TYPE (init)) == REFERENCE_TYPE)
3937 init = convert_from_reference (init);
3939 if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
3940 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
3941 /* Note: default conversion is only called in very special cases. */
3942 init = decay_conversion (init);
3944 /* Convert INIT to the reference type TYPE. This may involve the
3945 creation of a temporary, whose lifetime must be the same as that
3946 of the reference. If so, a DECL_STMT for the temporary will be
3947 added just after the DECL_STMT for DECL. That's why we don't set
3948 DECL_INITIAL for local references (instead assigning to them
3949 explicitly); we need to allow the temporary to be initialized
3951 tmp = initialize_reference (type, init, decl, cleanup);
3953 if (tmp == error_mark_node)
3955 else if (tmp == NULL_TREE)
3957 error ("cannot initialize `%T' from `%T'", type, TREE_TYPE (init));
3961 if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
3964 DECL_INITIAL (decl) = tmp;
3969 /* When parsing `int a[] = {1, 2};' we don't know the size of the
3970 array until we finish parsing the initializer. If that's the
3971 situation we're in, update DECL accordingly. */
3974 maybe_deduce_size_from_array_init (tree decl, tree init)
3976 tree type = TREE_TYPE (decl);
3978 if (TREE_CODE (type) == ARRAY_TYPE
3979 && TYPE_DOMAIN (type) == NULL_TREE
3980 && TREE_CODE (decl) != TYPE_DECL)
3982 /* do_default is really a C-ism to deal with tentative definitions.
3983 But let's leave it here to ease the eventual merge. */
3984 int do_default = !DECL_EXTERNAL (decl);
3985 tree initializer = init ? init : DECL_INITIAL (decl);
3986 int failure = complete_array_type (type, initializer, do_default);
3989 error ("initializer fails to determine size of `%D'", decl);
3994 error ("array size missing in `%D'", decl);
3995 /* If a `static' var's size isn't known, make it extern as
3996 well as static, so it does not get allocated. If it's not
3997 `static', then don't mark it extern; finish_incomplete_decl
3998 will give it a default size and it will get allocated. */
3999 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
4000 DECL_EXTERNAL (decl) = 1;
4003 if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
4004 && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
4006 error ("zero-size array `%D'", decl);
4008 layout_decl (decl, 0);
4012 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
4013 any appropriate error messages regarding the layout. */
4016 layout_var_decl (tree decl)
4018 tree type = TREE_TYPE (decl);
4020 tree ttype = target_type (type);
4023 /* If we haven't already layed out this declaration, do so now.
4024 Note that we must not call complete type for an external object
4025 because it's type might involve templates that we are not
4026 supposed to instantiate yet. (And it's perfectly valid to say
4027 `extern X x' for some incomplete type `X'.) */
4028 if (!DECL_EXTERNAL (decl))
4029 complete_type (type);
4030 if (!DECL_SIZE (decl)
4031 && TREE_TYPE (decl) != error_mark_node
4032 && (COMPLETE_TYPE_P (type)
4033 || (TREE_CODE (type) == ARRAY_TYPE
4034 && !TYPE_DOMAIN (type)
4035 && COMPLETE_TYPE_P (TREE_TYPE (type)))))
4036 layout_decl (decl, 0);
4038 if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
4040 /* An automatic variable with an incomplete type: that is an error.
4041 Don't talk about array types here, since we took care of that
4042 message in grokdeclarator. */
4043 error ("storage size of `%D' isn't known", decl);
4044 TREE_TYPE (decl) = error_mark_node;
4047 /* Keep this code around in case we later want to control debug info
4048 based on whether a type is "used". (jason 1999-11-11) */
4050 else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
4051 /* Let debugger know it should output info for this type. */
4052 note_debug_info_needed (ttype);
4054 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
4055 note_debug_info_needed (DECL_CONTEXT (decl));
4058 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
4059 && DECL_SIZE (decl) != NULL_TREE
4060 && ! TREE_CONSTANT (DECL_SIZE (decl)))
4062 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
4063 constant_expression_warning (DECL_SIZE (decl));
4065 error ("storage size of `%D' isn't constant", decl);
4068 if (TREE_STATIC (decl)
4069 && !DECL_ARTIFICIAL (decl)
4070 && current_function_decl
4071 && DECL_CONTEXT (decl) == current_function_decl)
4072 push_local_name (decl);
4075 /* If a local static variable is declared in an inline function, or if
4076 we have a weak definition, we must endeavor to create only one
4077 instance of the variable at link-time. */
4080 maybe_commonize_var (tree decl)
4082 /* Static data in a function with comdat linkage also has comdat
4084 if (TREE_STATIC (decl)
4085 /* Don't mess with __FUNCTION__. */
4086 && ! DECL_ARTIFICIAL (decl)
4087 && DECL_FUNCTION_SCOPE_P (decl)
4088 /* Unfortunately, import_export_decl has not always been called
4089 before the function is processed, so we cannot simply check
4091 && (DECL_COMDAT (DECL_CONTEXT (decl))
4092 || ((DECL_DECLARED_INLINE_P (DECL_CONTEXT (decl))
4093 || DECL_TEMPLATE_INSTANTIATION (DECL_CONTEXT (decl)))
4094 && TREE_PUBLIC (DECL_CONTEXT (decl)))))
4098 /* With weak symbols, we simply make the variable COMDAT;
4099 that will cause copies in multiple translations units to
4101 comdat_linkage (decl);
4105 if (DECL_INITIAL (decl) == NULL_TREE
4106 || DECL_INITIAL (decl) == error_mark_node)
4108 /* Without weak symbols, we can use COMMON to merge
4109 uninitialized variables. */
4110 TREE_PUBLIC (decl) = 1;
4111 DECL_COMMON (decl) = 1;
4115 /* While for initialized variables, we must use internal
4116 linkage -- which means that multiple copies will not
4118 TREE_PUBLIC (decl) = 0;
4119 DECL_COMMON (decl) = 0;
4120 cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
4121 warning ("%J you can work around this by removing the initializer",
4126 else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
4127 /* Set it up again; we might have set DECL_INITIAL since the last
4129 comdat_linkage (decl);
4132 /* Issue an error message if DECL is an uninitialized const variable. */
4135 check_for_uninitialized_const_var (tree decl)
4137 tree type = TREE_TYPE (decl);
4139 /* ``Unless explicitly declared extern, a const object does not have
4140 external linkage and must be initialized. ($8.4; $12.1)'' ARM
4142 if (TREE_CODE (decl) == VAR_DECL
4143 && TREE_CODE (type) != REFERENCE_TYPE
4144 && CP_TYPE_CONST_P (type)
4145 && !TYPE_NEEDS_CONSTRUCTING (type)
4146 && !DECL_INITIAL (decl))
4147 error ("uninitialized const `%D'", decl);
4150 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
4151 returned is the next FIELD_DECL (possibly FIELD itself) that can be
4152 initialized. If there are no more such fields, the return value
4156 next_initializable_field (tree field)
4159 && (TREE_CODE (field) != FIELD_DECL
4160 || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
4161 || DECL_ARTIFICIAL (field)))
4162 field = TREE_CHAIN (field);
4167 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
4168 brace-enclosed aggregate initializer.
4170 *INITP is one of a list of initializers describing a brace-enclosed
4171 initializer for an entity of the indicated aggregate TYPE. It may
4172 not presently match the shape of the TYPE; for example:
4174 struct S { int a; int b; };
4175 struct S a[] = { 1, 2, 3, 4 };
4177 Here *INITP will point to TREE_LIST of four elements, rather than a
4178 list of two elements, each itself a list of two elements. This
4179 routine transforms INIT from the former form into the latter. The
4180 revised initializer is returned. */
4183 reshape_init (tree type, tree *initp)
4187 tree old_init_value;
4189 bool brace_enclosed_p;
4192 old_init_value = (TREE_CODE (*initp) == TREE_LIST
4193 ? TREE_VALUE (*initp) : old_init);
4195 my_friendly_assert (old_init_value, 20030723);
4197 /* If the initializer is brace-enclosed, pull initializers from the
4198 enclosed elements. Advance past the brace-enclosed initializer
4200 if (TREE_CODE (old_init_value) == CONSTRUCTOR
4201 && TREE_TYPE (old_init_value) == NULL_TREE
4202 && TREE_HAS_CONSTRUCTOR (old_init_value))
4204 *initp = TREE_CHAIN (old_init);
4205 TREE_CHAIN (old_init) = NULL_TREE;
4206 inits = CONSTRUCTOR_ELTS (old_init_value);
4208 brace_enclosed_p = true;
4213 brace_enclosed_p = false;
4216 /* A non-aggregate type is always initialized with a single
4218 if (!CP_AGGREGATE_TYPE_P (type))
4220 *initp = TREE_CHAIN (old_init);
4221 TREE_CHAIN (old_init) = NULL_TREE;
4222 /* It is invalid to initialize a non-aggregate type with a
4223 brace-enclosed initializer. */
4224 if (brace_enclosed_p)
4226 error ("brace-enclosed initializer used to initialize `%T'",
4228 if (TREE_CODE (old_init) == TREE_LIST)
4229 TREE_VALUE (old_init) = error_mark_node;
4231 old_init = error_mark_node;
4239 All implicit type conversions (clause _conv_) are considered when
4240 initializing the aggregate member with an initializer from an
4241 initializer-list. If the initializer can initialize a member,
4242 the member is initialized. Otherwise, if the member is itself a
4243 non-empty subaggregate, brace elision is assumed and the
4244 initializer is considered for the initialization of the first
4245 member of the subaggregate. */
4246 if (!brace_enclosed_p
4247 && can_convert_arg (type, TREE_TYPE (old_init_value), old_init_value))
4249 *initp = TREE_CHAIN (old_init);
4250 TREE_CHAIN (old_init) = NULL_TREE;
4254 if (TREE_CODE (old_init_value) == STRING_CST
4255 && TREE_CODE (type) == ARRAY_TYPE
4256 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
4258 /* [dcl.init.string]
4260 A char array (whether plain char, signed char, or unsigned char)
4261 can be initialized by a string-literal (optionally enclosed in
4262 braces); a wchar_t array can be initialized by a wide
4263 string-literal (optionally enclosed in braces). */
4264 new_init = old_init;
4265 /* Move past the initializer. */
4266 *initp = TREE_CHAIN (old_init);
4267 TREE_CHAIN (old_init) = NULL_TREE;
4271 /* Build a CONSTRUCTOR to hold the contents of the aggregate. */
4272 new_init = build_constructor (type, NULL_TREE);
4273 TREE_HAS_CONSTRUCTOR (new_init) = 1;
4275 if (CLASS_TYPE_P (type))
4279 field = next_initializable_field (TYPE_FIELDS (type));
4285 An initializer for an aggregate member that is an
4286 empty class shall have the form of an empty
4287 initializer-list {}. */
4288 if (!brace_enclosed_p)
4290 error ("initializer for `%T' must be brace-enclosed",
4292 return error_mark_node;
4297 /* Loop through the initializable fields, gathering
4303 /* Handle designated initializers, as an extension. */
4304 if (TREE_PURPOSE (*initp))
4307 pedwarn ("ISO C++ does not allow designated initializers");
4308 field = lookup_field_1 (type, TREE_PURPOSE (*initp),
4309 /*want_type=*/false);
4310 if (!field || TREE_CODE (field) != FIELD_DECL)
4311 error ("`%T' has no non-static data member named `%D'",
4312 type, TREE_PURPOSE (*initp));
4317 field_init = reshape_init (TREE_TYPE (field), initp);
4318 if (field_init == error_mark_node)
4319 return error_mark_node;
4320 TREE_CHAIN (field_init) = CONSTRUCTOR_ELTS (new_init);
4321 CONSTRUCTOR_ELTS (new_init) = field_init;
4324 When a union is initialized with a brace-enclosed
4325 initializer, the braces shall only contain an
4326 initializer for the first member of the union. */
4327 if (TREE_CODE (type) == UNION_TYPE)
4329 field = next_initializable_field (TREE_CHAIN (field));
4333 else if ((TREE_CODE (type) == ARRAY_TYPE)|| (TREE_CODE (type) == VECTOR_TYPE))
4338 /* If the bound of the array is known, take no more initializers
4339 than are allowed. */
4340 max_index = ((TYPE_DOMAIN (type) && (TREE_CODE (type) == ARRAY_TYPE))
4341 ? array_type_nelts (type) : NULL_TREE);
4342 /* Loop through the array elements, gathering initializers. */
4343 for (index = size_zero_node;
4344 *initp && (!max_index || !tree_int_cst_lt (max_index, index));
4345 index = size_binop (PLUS_EXPR, index, size_one_node))
4349 element_init = reshape_init (TREE_TYPE (type), initp);
4350 if (element_init == error_mark_node)
4351 return error_mark_node;
4352 TREE_CHAIN (element_init) = CONSTRUCTOR_ELTS (new_init);
4353 CONSTRUCTOR_ELTS (new_init) = element_init;
4354 if (TREE_PURPOSE (element_init))
4356 tree next_index = TREE_PURPOSE (element_init);
4357 if (TREE_CODE (next_index) == IDENTIFIER_NODE)
4359 error ("name `%D' used in a GNU-style designated "
4360 "initializer for an array", next_index);
4361 TREE_PURPOSE (element_init) = NULL_TREE;
4371 /* The initializers were placed in reverse order in the
4373 CONSTRUCTOR_ELTS (new_init) = nreverse (CONSTRUCTOR_ELTS (new_init));
4375 if (TREE_CODE (old_init) == TREE_LIST)
4376 new_init = build_tree_list (TREE_PURPOSE (old_init), new_init);
4379 /* If this was a brace-enclosed initializer and all of the
4380 initializers were not used up, there is a problem. */
4381 if (brace_enclosed_p && *initp)
4382 error ("too many initializers for `%T'", type);
4387 /* Verify INIT (the initializer for DECL), and record the
4388 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
4389 grok_reference_init.
4391 If the return value is non-NULL, it is an expression that must be
4392 evaluated dynamically to initialize DECL. */
4395 check_initializer (tree decl, tree init, int flags, tree *cleanup)
4397 tree type = TREE_TYPE (decl);
4398 tree init_code = NULL;
4400 /* If `start_decl' didn't like having an initialization, ignore it now. */
4401 if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
4404 /* If an initializer is present, DECL_INITIAL has been
4405 error_mark_node, to indicate that an as-of-yet unevaluated
4406 initialization will occur. From now on, DECL_INITIAL reflects
4407 the static initialization -- if any -- of DECL. */
4408 DECL_INITIAL (decl) = NULL_TREE;
4410 /* Things that are going to be initialized need to have complete
4412 TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
4414 if (type == error_mark_node)
4415 /* We will have already complained. */
4417 else if (init && COMPLETE_TYPE_P (type)
4418 && !TREE_CONSTANT (TYPE_SIZE (type)))
4420 error ("variable-sized object `%D' may not be initialized", decl);
4423 else if (TREE_CODE (type) == ARRAY_TYPE
4424 && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
4426 error ("elements of array `%#D' have incomplete type", decl);
4429 else if (TREE_CODE (type) != ARRAY_TYPE && !COMPLETE_TYPE_P (type))
4431 error ("`%D' has incomplete type", decl);
4432 TREE_TYPE (decl) = error_mark_node;
4436 if (TREE_CODE (decl) == CONST_DECL)
4438 my_friendly_assert (TREE_CODE (decl) != REFERENCE_TYPE, 148);
4440 DECL_INITIAL (decl) = init;
4442 my_friendly_assert (init != NULL_TREE, 149);
4445 else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
4446 init = grok_reference_init (decl, type, init, cleanup);
4449 if (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (init))
4451 /* [dcl.init] paragraph 13,
4452 If T is a scalar type, then a declaration of the form
4457 reshape_init will complain about the extra braces,
4458 and doesn't do anything useful in the case where TYPE is
4459 scalar, so just don't call it. */
4460 if (CP_AGGREGATE_TYPE_P (type))
4461 init = reshape_init (type, &init);
4463 if ((*targetm.vector_opaque_p) (type))
4465 error ("opaque vector types cannot be initialized");
4466 init = error_mark_node;
4470 /* If DECL has an array type without a specific bound, deduce the
4471 array size from the initializer. */
4472 maybe_deduce_size_from_array_init (decl, init);
4473 type = TREE_TYPE (decl);
4474 if (TREE_CODE (init) == CONSTRUCTOR && TREE_HAS_CONSTRUCTOR (init))
4475 TREE_TYPE (init) = type;
4477 if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
4479 if (TREE_CODE (type) == ARRAY_TYPE)
4480 goto initialize_aggr;
4481 else if (TREE_CODE (init) == CONSTRUCTOR
4482 && TREE_HAS_CONSTRUCTOR (init))
4484 if (TYPE_NON_AGGREGATE_CLASS (type))
4486 error ("`%D' must be initialized by constructor, not by `{...}'",
4488 init = error_mark_node;
4491 goto dont_use_constructor;
4495 int saved_stmts_are_full_exprs_p;
4498 saved_stmts_are_full_exprs_p = 0;
4499 if (building_stmt_tree ())
4501 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
4502 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
4504 init = build_aggr_init (decl, init, flags);
4505 if (building_stmt_tree ())
4506 current_stmt_tree ()->stmts_are_full_exprs_p =
4507 saved_stmts_are_full_exprs_p;
4513 dont_use_constructor:
4514 if (TREE_CODE (init) != TREE_VEC)
4516 init_code = store_init_value (decl, init);
4521 else if (DECL_EXTERNAL (decl))
4523 else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
4524 goto initialize_aggr;
4525 else if (IS_AGGR_TYPE (type))
4527 tree core_type = strip_array_types (type);
4529 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
4530 error ("structure `%D' with uninitialized const members", decl);
4531 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
4532 error ("structure `%D' with uninitialized reference members",
4535 check_for_uninitialized_const_var (decl);
4538 check_for_uninitialized_const_var (decl);
4540 if (init && init != error_mark_node)
4541 init_code = build (INIT_EXPR, type, decl, init);
4546 /* If DECL is not a local variable, give it RTL. */
4549 make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
4551 int toplev = toplevel_bindings_p ();
4554 /* Handle non-variables up front. */
4555 if (TREE_CODE (decl) != VAR_DECL)
4557 rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
4561 /* If we see a class member here, it should be a static data
4563 if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
4565 my_friendly_assert (TREE_STATIC (decl), 19990828);
4566 /* An in-class declaration of a static data member should be
4567 external; it is only a declaration, and not a definition. */
4568 if (init == NULL_TREE)
4569 my_friendly_assert (DECL_EXTERNAL (decl), 20000723);
4572 /* Set the DECL_ASSEMBLER_NAME for the variable. */
4575 change_decl_assembler_name (decl, get_identifier (asmspec));
4576 /* The `register' keyword, when used together with an
4577 asm-specification, indicates that the variable should be
4578 placed in a particular register. */
4579 if (DECL_REGISTER (decl))
4580 DECL_C_HARD_REGISTER (decl) = 1;
4583 /* We don't create any RTL for local variables. */
4584 if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
4587 /* We defer emission of local statics until the corresponding
4588 DECL_STMT is expanded. */
4589 defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
4591 /* We try to defer namespace-scope static constants so that they are
4592 not emitted into the object file unnecessarily. */
4593 if (!DECL_VIRTUAL_P (decl)
4594 && TREE_READONLY (decl)
4595 && DECL_INITIAL (decl) != NULL_TREE
4596 && DECL_INITIAL (decl) != error_mark_node
4597 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
4599 && !TREE_PUBLIC (decl))
4601 /* Fool with the linkage of static consts according to #pragma
4603 if (!interface_unknown && !TREE_PUBLIC (decl))
4605 TREE_PUBLIC (decl) = 1;
4606 DECL_EXTERNAL (decl) = interface_only;
4611 /* Likewise for template instantiations. */
4612 else if (DECL_COMDAT (decl))
4615 /* If we're deferring the variable, we only need to make RTL if
4616 there's an ASMSPEC. Otherwise, we'll lazily create it later when
4617 we need it. (There's no way to lazily create RTL for things that
4618 have assembly specs because the information about the specifier
4619 isn't stored in the tree, yet) */
4620 if (defer_p && asmspec)
4621 make_decl_rtl (decl, asmspec);
4622 /* If we're not deferring, go ahead and assemble the variable. */
4624 rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
4627 /* Generate code to initialize DECL (a local variable). */
4630 initialize_local_var (tree decl, tree init)
4632 tree type = TREE_TYPE (decl);
4635 my_friendly_assert (TREE_CODE (decl) == VAR_DECL
4636 || TREE_CODE (decl) == RESULT_DECL,
4638 my_friendly_assert (!TREE_STATIC (decl), 20021010);
4640 if (DECL_SIZE (decl) == NULL_TREE)
4642 /* If we used it already as memory, it must stay in memory. */
4643 DECL_INITIAL (decl) = NULL_TREE;
4644 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
4647 if (DECL_SIZE (decl) && type != error_mark_node)
4651 /* Compute and store the initial value. */
4652 already_used = TREE_USED (decl) || TREE_USED (type);
4654 /* Perform the initialization. */
4657 int saved_stmts_are_full_exprs_p;
4659 my_friendly_assert (building_stmt_tree (), 20000906);
4660 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
4661 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
4662 finish_expr_stmt (init);
4663 current_stmt_tree ()->stmts_are_full_exprs_p =
4664 saved_stmts_are_full_exprs_p;
4667 /* Set this to 0 so we can tell whether an aggregate which was
4668 initialized was ever used. Don't do this if it has a
4669 destructor, so we don't complain about the 'resource
4670 allocation is initialization' idiom. Now set
4671 attribute((unused)) on types so decls of that type will be
4672 marked used. (see TREE_USED, above.) */
4673 if (TYPE_NEEDS_CONSTRUCTING (type)
4675 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
4676 && DECL_NAME (decl))
4677 TREE_USED (decl) = 0;
4678 else if (already_used)
4679 TREE_USED (decl) = 1;
4682 /* Generate a cleanup, if necessary. */
4683 cleanup = cxx_maybe_build_cleanup (decl);
4684 if (DECL_SIZE (decl) && cleanup)
4685 finish_decl_cleanup (decl, cleanup);
4688 /* Finish processing of a declaration;
4689 install its line number and initial value.
4690 If the length of an array type is not known before,
4691 it must be determined now, from the initial value, or it is an error.
4693 INIT holds the value of an initializer that should be allowed to escape
4696 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
4697 if the (init) syntax was used. */
4700 cp_finish_decl (tree decl, tree init, tree asmspec_tree, int flags)
4703 tree ttype = NULL_TREE;
4705 const char *asmspec = NULL;
4706 int was_readonly = 0;
4708 if (decl == error_mark_node)
4713 error ("assignment (not initialization) in declaration");
4717 my_friendly_assert (TREE_CODE (decl) != RESULT_DECL, 20030619);
4719 /* Assume no cleanup is required. */
4720 cleanup = NULL_TREE;
4722 /* If a name was specified, get the string. */
4723 if (global_scope_p (current_binding_level))
4724 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
4726 asmspec = TREE_STRING_POINTER (asmspec_tree);
4728 if (init && TREE_CODE (init) == NAMESPACE_DECL)
4730 error ("cannot initialize `%D' to namespace `%D'",
4735 if (current_class_type
4736 && CP_DECL_CONTEXT (decl) == current_class_type
4737 && TYPE_BEING_DEFINED (current_class_type)
4738 && (DECL_INITIAL (decl) || init))
4739 DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
4741 if (TREE_CODE (decl) == VAR_DECL
4742 && DECL_CONTEXT (decl)
4743 && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL
4744 && DECL_CONTEXT (decl) != current_namespace
4747 /* Leave the namespace of the object. */
4748 pop_decl_namespace ();
4751 type = TREE_TYPE (decl);
4753 if (type == error_mark_node)
4756 if (TYPE_HAS_MUTABLE_P (type))
4757 TREE_READONLY (decl) = 0;
4759 if (processing_template_decl)
4761 /* Add this declaration to the statement-tree. */
4762 if (at_function_scope_p ())
4763 add_decl_stmt (decl);
4765 if (init && DECL_INITIAL (decl))
4766 DECL_INITIAL (decl) = init;
4770 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
4771 my_friendly_assert (TREE_CODE (decl) != PARM_DECL, 19990828);
4773 /* Take care of TYPE_DECLs up front. */
4774 if (TREE_CODE (decl) == TYPE_DECL)
4776 if (type != error_mark_node
4777 && IS_AGGR_TYPE (type) && DECL_NAME (decl))
4779 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
4780 warning ("shadowing previous type declaration of `%#D'", decl);
4781 set_identifier_type_value (DECL_NAME (decl), decl);
4784 /* If we have installed this as the canonical typedef for this
4785 type, and that type has not been defined yet, delay emitting
4786 the debug information for it, as we will emit it later. */
4787 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
4788 && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
4789 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
4791 rest_of_decl_compilation (decl, NULL,
4792 DECL_CONTEXT (decl) == NULL_TREE, at_eof);
4796 if (TREE_CODE (decl) != FUNCTION_DECL)
4797 ttype = target_type (type);
4799 if (! DECL_EXTERNAL (decl) && TREE_READONLY (decl)
4800 && (TYPE_NEEDS_CONSTRUCTING (type)
4801 || TREE_CODE (type) == REFERENCE_TYPE))
4803 /* Currently, GNU C++ puts constants in text space, making them
4804 impossible to initialize. In the future, one would hope for
4805 an operating system which understood the difference between
4806 initialization and the running of a program. */
4808 TREE_READONLY (decl) = 0;
4811 if (TREE_CODE (decl) == VAR_DECL)
4813 /* Only PODs can have thread-local storage. Other types may require
4814 various kinds of non-trivial initialization. */
4815 if (DECL_THREAD_LOCAL (decl) && !pod_type_p (TREE_TYPE (decl)))
4816 error ("`%D' cannot be thread-local because it has non-POD type `%T'",
4817 decl, TREE_TYPE (decl));
4818 /* Convert the initializer to the type of DECL, if we have not
4819 already initialized DECL. */
4820 if (!DECL_INITIALIZED_P (decl)
4821 /* If !DECL_EXTERNAL then DECL is being defined. In the
4822 case of a static data member initialized inside the
4823 class-specifier, there can be an initializer even if DECL
4824 is *not* defined. */
4825 && (!DECL_EXTERNAL (decl) || init))
4827 init = check_initializer (decl, init, flags, &cleanup);
4828 /* Thread-local storage cannot be dynamically initialized. */
4829 if (DECL_THREAD_LOCAL (decl) && init)
4831 error ("`%D' is thread-local and so cannot be dynamically "
4832 "initialized", decl);
4839 The memory occupied by any object of static storage
4840 duration is zero-initialized at program startup before
4841 any other initialization takes place.
4843 We cannot create an appropriate initializer until after
4844 the type of DECL is finalized. If DECL_INITIAL is set,
4845 then the DECL is statically initialized, and any
4846 necessary zero-initialization has already been performed. */
4847 if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
4848 DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
4849 /*nelts=*/NULL_TREE,
4850 /*static_storage_p=*/true);
4851 /* Remember that the initialization for this variable has
4853 DECL_INITIALIZED_P (decl) = 1;
4855 /* If the variable has an array type, lay out the type, even if
4856 there is no initializer. It is valid to index through the
4857 array, and we must get TYPE_ALIGN set correctly on the array
4859 else if (TREE_CODE (type) == ARRAY_TYPE)
4863 /* Add this declaration to the statement-tree. This needs to happen
4864 after the call to check_initializer so that the DECL_STMT for a
4865 reference temp is added before the DECL_STMT for the reference itself. */
4866 if (at_function_scope_p ())
4867 add_decl_stmt (decl);
4869 if (TREE_CODE (decl) == VAR_DECL)
4870 layout_var_decl (decl);
4872 /* Output the assembler code and/or RTL code for variables and functions,
4873 unless the type is an undefined structure or union.
4874 If not, it will get done when the type is completed. */
4875 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
4877 if (TREE_CODE (decl) == VAR_DECL)
4878 maybe_commonize_var (decl);
4880 make_rtl_for_nonlocal_decl (decl, init, asmspec);
4882 if (TREE_CODE (type) == FUNCTION_TYPE
4883 || TREE_CODE (type) == METHOD_TYPE)
4884 abstract_virtuals_error (decl,
4885 strip_array_types (TREE_TYPE (type)));
4886 else if (POINTER_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE)
4888 /* If it's either a pointer or an array type, strip through all
4889 of them but the last one. If the last is an array type, issue
4890 an error if the element type is abstract. */
4891 while (POINTER_TYPE_P (TREE_TYPE (type))
4892 || TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE)
4893 type = TREE_TYPE (type);
4894 if (TREE_CODE (type) == ARRAY_TYPE)
4895 abstract_virtuals_error (decl, TREE_TYPE (type));
4898 abstract_virtuals_error (decl, type);
4900 if (TREE_CODE (decl) == FUNCTION_DECL
4901 || TREE_TYPE (decl) == error_mark_node)
4902 /* No initialization required. */
4904 else if (DECL_EXTERNAL (decl)
4905 && ! (DECL_LANG_SPECIFIC (decl)
4906 && DECL_NOT_REALLY_EXTERN (decl)))
4909 DECL_INITIAL (decl) = init;
4913 /* A variable definition. */
4914 if (DECL_FUNCTION_SCOPE_P (decl))
4916 /* This is a local declaration. */
4917 maybe_inject_for_scope_var (decl);
4918 /* Initialize the local variable. */
4919 if (processing_template_decl)
4921 if (init || DECL_INITIAL (decl) == error_mark_node)
4922 DECL_INITIAL (decl) = init;
4924 else if (!TREE_STATIC (decl))
4925 initialize_local_var (decl, init);
4928 if (TREE_STATIC (decl))
4929 expand_static_init (decl, init);
4933 /* Undo call to `pushclass' that was done in `start_decl'
4934 due to initialization of qualified member variable.
4935 I.e., Foo::x = 10; */
4937 tree context = CP_DECL_CONTEXT (decl);
4940 && (TREE_CODE (decl) == VAR_DECL
4941 /* We also have a pushclass done that we need to undo here
4942 if we're at top level and declare a method. */
4943 || TREE_CODE (decl) == FUNCTION_DECL)
4944 /* If size hasn't been set, we're still defining it,
4945 and therefore inside the class body; don't pop
4946 the binding level.. */
4947 && COMPLETE_TYPE_P (context)
4948 && context == current_class_type)
4949 pop_nested_class ();
4953 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
4954 reference, insert it in the statement-tree now. */
4961 TREE_READONLY (decl) = 1;
4963 /* If this was marked 'used', be sure it will be output. */
4964 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
4965 mark_referenced (DECL_ASSEMBLER_NAME (decl));
4968 /* This is here for a midend callback from c-common.c. */
4971 finish_decl (tree decl, tree init, tree asmspec_tree)
4973 cp_finish_decl (decl, init, asmspec_tree, 0);
4976 /* Returns a declaration for a VAR_DECL as if:
4978 extern "C" TYPE NAME;
4980 had been seen. Used to create compiler-generated global
4984 declare_global_var (tree name, tree type)
4988 push_to_top_level ();
4989 decl = build_decl (VAR_DECL, name, type);
4990 TREE_PUBLIC (decl) = 1;
4991 DECL_EXTERNAL (decl) = 1;
4992 DECL_ARTIFICIAL (decl) = 1;
4994 cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
4995 pop_from_top_level ();
5000 /* Returns a pointer to the `atexit' function. Note that if
5001 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
5002 `__cxa_atexit' function specified in the IA64 C++ ABI. */
5005 get_atexit_node (void)
5016 if (flag_use_cxa_atexit)
5018 /* The declaration for `__cxa_atexit' is:
5020 int __cxa_atexit (void (*)(void *), void *, void *)
5022 We build up the argument types and then then function type
5025 /* First, build the pointer-to-function type for the first
5027 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5028 fn_type = build_function_type (void_type_node, arg_types);
5029 fn_ptr_type = build_pointer_type (fn_type);
5030 /* Then, build the rest of the argument types. */
5031 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5032 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
5033 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
5034 /* And the final __cxa_atexit type. */
5035 fn_type = build_function_type (integer_type_node, arg_types);
5036 fn_ptr_type = build_pointer_type (fn_type);
5037 name = "__cxa_atexit";
5041 /* The declaration for `atexit' is:
5043 int atexit (void (*)());
5045 We build up the argument types and then then function type
5047 fn_type = build_function_type (void_type_node, void_list_node);
5048 fn_ptr_type = build_pointer_type (fn_type);
5049 arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
5050 /* Build the final atexit type. */
5051 fn_type = build_function_type (integer_type_node, arg_types);
5055 /* Now, build the function declaration. */
5056 push_lang_context (lang_name_c);
5057 atexit_fndecl = build_library_fn_ptr (name, fn_type);
5058 mark_used (atexit_fndecl);
5059 pop_lang_context ();
5060 atexit_node = decay_conversion (atexit_fndecl);
5065 /* Returns the __dso_handle VAR_DECL. */
5068 get_dso_handle_node (void)
5070 if (dso_handle_node)
5071 return dso_handle_node;
5073 /* Declare the variable. */
5074 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
5077 return dso_handle_node;
5080 /* Begin a new function with internal linkage whose job will be simply
5081 to destroy some particular variable. */
5083 static GTY(()) int start_cleanup_cnt;
5086 start_cleanup_fn (void)
5088 int old_interface_only = interface_only;
5089 int old_interface_unknown = interface_unknown;
5095 push_to_top_level ();
5097 /* No need to mangle this. */
5098 push_lang_context (lang_name_c);
5101 interface_unknown = 1;
5103 /* Build the parameter-types. */
5104 parmtypes = void_list_node;
5105 /* Functions passed to __cxa_atexit take an additional parameter.
5106 We'll just ignore it. After we implement the new calling
5107 convention for destructors, we can eliminate the use of
5108 additional cleanup functions entirely in the -fnew-abi case. */
5109 if (flag_use_cxa_atexit)
5110 parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
5111 /* Build the function type itself. */
5112 fntype = build_function_type (void_type_node, parmtypes);
5113 /* Build the name of the function. */
5114 sprintf (name, "__tcf_%d", start_cleanup_cnt++);
5115 /* Build the function declaration. */
5116 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
5117 /* It's a function with internal linkage, generated by the
5119 TREE_PUBLIC (fndecl) = 0;
5120 DECL_ARTIFICIAL (fndecl) = 1;
5121 /* Make the function `inline' so that it is only emitted if it is
5122 actually needed. It is unlikely that it will be inlined, since
5123 it is only called via a function pointer, but we avoid unnecessary
5124 emissions this way. */
5125 DECL_INLINE (fndecl) = 1;
5126 DECL_DECLARED_INLINE_P (fndecl) = 1;
5127 DECL_INTERFACE_KNOWN (fndecl) = 1;
5128 /* Build the parameter. */
5129 if (flag_use_cxa_atexit)
5133 parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
5134 DECL_CONTEXT (parmdecl) = fndecl;
5135 TREE_USED (parmdecl) = 1;
5136 DECL_ARGUMENTS (fndecl) = parmdecl;
5140 start_function (/*specs=*/NULL_TREE, fndecl, NULL_TREE, SF_PRE_PARSED);
5142 interface_unknown = old_interface_unknown;
5143 interface_only = old_interface_only;
5145 pop_lang_context ();
5147 return current_function_decl;
5150 /* Finish the cleanup function begun by start_cleanup_fn. */
5153 end_cleanup_fn (void)
5155 expand_or_defer_fn (finish_function (0));
5157 pop_from_top_level ();
5160 /* Generate code to handle the destruction of DECL, an object with
5161 static storage duration. */
5164 register_dtor_fn (tree decl)
5171 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
5174 /* Call build_cleanup before we enter the anonymous function so that
5175 any access checks will be done relative to the current scope,
5176 rather than the scope of the anonymous function. */
5177 build_cleanup (decl);
5179 /* Now start the function. */
5180 cleanup = start_cleanup_fn ();
5182 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
5183 to the original function, rather than the anonymous one. That
5184 will make the back-end think that nested functions are in use,
5185 which causes confusion. */
5187 push_deferring_access_checks (dk_no_check);
5188 fcall = build_cleanup (decl);
5189 pop_deferring_access_checks ();
5191 /* Create the body of the anonymous function. */
5192 compound_stmt = begin_compound_stmt (/*has_no_scope=*/false);
5193 finish_expr_stmt (fcall);
5194 finish_compound_stmt (compound_stmt);
5197 /* Call atexit with the cleanup function. */
5198 cxx_mark_addressable (cleanup);
5199 mark_used (cleanup);
5200 cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
5201 if (flag_use_cxa_atexit)
5203 args = tree_cons (NULL_TREE,
5204 build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0),
5206 args = tree_cons (NULL_TREE, null_pointer_node, args);
5207 args = tree_cons (NULL_TREE, cleanup, args);
5210 args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
5211 finish_expr_stmt (build_function_call (get_atexit_node (), args));
5214 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
5215 is its initializer. Generate code to handle the construction
5216 and destruction of DECL. */
5219 expand_static_init (tree decl, tree init)
5221 my_friendly_assert (TREE_CODE (decl) == VAR_DECL, 20021010);
5222 my_friendly_assert (TREE_STATIC (decl), 20021010);
5224 /* Some variables require no initialization. */
5226 && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
5227 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
5230 if (! toplevel_bindings_p ())
5232 /* Emit code to perform this initialization but once. */
5239 /* Emit code to perform this initialization but once. This code
5242 static int guard = 0;
5244 // Do initialization.
5246 // Register variable for destruction at end of program.
5249 Note that the `temp' variable is only set to 1 *after* the
5250 initialization is complete. This ensures that an exception,
5251 thrown during the construction, will cause the variable to
5252 reinitialized when we pass through this code again, as per:
5256 If the initialization exits by throwing an exception, the
5257 initialization is not complete, so it will be tried again
5258 the next time control enters the declaration.
5260 In theory, this process should be thread-safe, too; multiple
5261 threads should not be able to initialize the variable more
5262 than once. We don't yet attempt to ensure thread-safety. */
5264 /* Create the guard variable. */
5265 guard = get_guard (decl);
5267 /* Begin the conditional initialization. */
5268 if_stmt = begin_if_stmt ();
5269 finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
5270 then_clause = begin_compound_stmt (/*has_no_scope=*/false);
5272 /* Do the initialization itself. */
5273 assignment = init ? init : NULL_TREE;
5275 /* Once the assignment is complete, set TEMP to 1. Since the
5276 construction of the static object is complete at this point,
5277 we want to make sure TEMP is set to 1 even if a temporary
5278 constructed during the initialization throws an exception
5279 when it is destroyed. So, we combine the initialization and
5280 the assignment to TEMP into a single expression, ensuring
5281 that when we call finish_expr_stmt the cleanups will not be
5282 run until after TEMP is set to 1. */
5283 guard_init = set_guard (guard);
5285 assignment = build_compound_expr (assignment, guard_init);
5287 assignment = guard_init;
5288 finish_expr_stmt (assignment);
5290 /* Use atexit to register a function for destroying this static
5292 register_dtor_fn (decl);
5294 finish_compound_stmt (then_clause);
5295 finish_then_clause (if_stmt);
5299 static_aggregates = tree_cons (init, decl, static_aggregates);
5302 /* Finish the declaration of a catch-parameter. */
5305 start_handler_parms (tree declspecs, tree declarator)
5310 decl = grokdeclarator (declarator, declspecs, CATCHPARM,
5312 if (decl == NULL_TREE)
5313 error ("invalid catch parameter");
5322 /* Make TYPE a complete type based on INITIAL_VALUE.
5323 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
5324 2 if there was no information (in which case assume 0 if DO_DEFAULT). */
5327 complete_array_type (tree type, tree initial_value, int do_default)
5329 tree maxindex = NULL_TREE;
5334 /* An array of character type can be initialized from a
5335 brace-enclosed string constant. */
5336 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
5337 && TREE_CODE (initial_value) == CONSTRUCTOR
5338 && CONSTRUCTOR_ELTS (initial_value)
5339 && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
5341 && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
5342 initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
5344 /* Note MAXINDEX is really the maximum index, one less than the
5346 if (TREE_CODE (initial_value) == STRING_CST)
5349 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
5350 maxindex = build_int_2 ((TREE_STRING_LENGTH (initial_value)
5353 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
5355 tree elts = CONSTRUCTOR_ELTS (initial_value);
5357 maxindex = ssize_int (-1);
5358 for (; elts; elts = TREE_CHAIN (elts))
5360 if (TREE_PURPOSE (elts))
5361 maxindex = TREE_PURPOSE (elts);
5363 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
5365 maxindex = copy_node (maxindex);
5369 /* Make an error message unless that happened already. */
5370 if (initial_value != error_mark_node)
5373 initial_value = NULL_TREE;
5375 /* Prevent further error messages. */
5376 maxindex = build_int_2 (0, 0);
5383 maxindex = build_int_2 (0, 0);
5392 domain = build_index_type (maxindex);
5393 TYPE_DOMAIN (type) = domain;
5395 if (! TREE_TYPE (maxindex))
5396 TREE_TYPE (maxindex) = domain;
5398 itype = TREE_TYPE (initial_value);
5401 if (itype && !TYPE_DOMAIN (itype))
5402 TYPE_DOMAIN (itype) = domain;
5403 /* The type of the main variant should never be used for arrays
5404 of different sizes. It should only ever be completed with the
5405 size of the array. */
5406 if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
5407 TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
5410 /* Lay out the type now that we can get the real answer. */
5417 /* Return zero if something is declared to be a member of type
5418 CTYPE when in the context of CUR_TYPE. STRING is the error
5419 message to print in that case. Otherwise, quietly return 1. */
5422 member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
5424 if (ctype && ctype != cur_type)
5426 if (flags == DTOR_FLAG)
5427 error ("destructor for alien class `%T' cannot be a member",
5430 error ("constructor for alien class `%T' cannot be a member",
5437 /* Subroutine of `grokdeclarator'. */
5439 /* Generate errors possibly applicable for a given set of specifiers.
5440 This is for ARM $7.1.2. */
5443 bad_specifiers (tree object,
5452 error ("`%D' declared as a `virtual' %s", object, type);
5454 error ("`%D' declared as an `inline' %s", object, type);
5456 error ("`const' and `volatile' function specifiers on `%D' invalid in %s declaration",
5459 cp_error_at ("`%D' declared as a friend", object);
5461 && (TREE_CODE (object) == TYPE_DECL
5462 || (!TYPE_PTRFN_P (TREE_TYPE (object))
5463 && !TYPE_REFFN_P (TREE_TYPE (object))
5464 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
5465 cp_error_at ("`%D' declared with an exception specification", object);
5468 /* CTYPE is class type, or null if non-class.
5469 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
5471 DECLARATOR is the function's name.
5472 VIRTUALP is truthvalue of whether the function is virtual or not.
5473 FLAGS are to be passed through to `grokclassfn'.
5474 QUALS are qualifiers indicating whether the function is `const'
5476 RAISES is a list of exceptions that this function can raise.
5477 CHECK is 1 if we must find this method in CTYPE, 0 if we should
5478 not look, and -1 if we should not call `grokclassfn' at all.
5480 Returns `NULL_TREE' if something goes wrong, after issuing
5481 applicable error messages. */
5484 grokfndecl (tree ctype,
5487 tree orig_declarator,
5489 enum overload_flags flags,
5501 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
5502 int has_default_arg = 0;
5506 type = build_exception_variant (type, raises);
5508 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
5509 /* Propagate volatile out from type to decl. */
5510 if (TYPE_VOLATILE (type))
5511 TREE_THIS_VOLATILE (decl) = 1;
5513 /* If this decl has namespace scope, set that up. */
5515 set_decl_namespace (decl, in_namespace, friendp);
5517 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
5519 /* `main' and builtins have implicit 'C' linkage. */
5520 if ((MAIN_NAME_P (declarator)
5521 || (IDENTIFIER_LENGTH (declarator) > 10
5522 && IDENTIFIER_POINTER (declarator)[0] == '_'
5523 && IDENTIFIER_POINTER (declarator)[1] == '_'
5524 && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
5525 && current_lang_name == lang_name_cplusplus
5526 && ctype == NULL_TREE
5527 /* NULL_TREE means global namespace. */
5528 && DECL_CONTEXT (decl) == NULL_TREE)
5529 SET_DECL_LANGUAGE (decl, lang_c);
5531 /* Should probably propagate const out from type to decl I bet (mrs). */
5534 DECL_STATIC_FUNCTION_P (decl) = 1;
5535 DECL_CONTEXT (decl) = ctype;
5539 DECL_CONTEXT (decl) = ctype;
5541 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
5543 if (processing_template_decl)
5544 error ("cannot declare `::main' to be a template");
5546 error ("cannot declare `::main' to be inline");
5548 error ("cannot declare `::main' to be static");
5549 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
5551 error ("`main' must return `int'");
5556 /* Members of anonymous types and local classes have no linkage; make
5558 /* FIXME what if it gets a name from typedef? */
5559 if (ctype && (TYPE_ANONYMOUS_P (ctype)
5560 || decl_function_context (TYPE_MAIN_DECL (ctype))))
5565 /* [basic.link]: A name with no linkage (notably, the name of a class
5566 or enumeration declared in a local scope) shall not be used to
5567 declare an entity with linkage.
5569 Only check this for public decls for now. See core 319, 389. */
5570 t = no_linkage_check (TREE_TYPE (decl));
5573 if (TYPE_ANONYMOUS_P (t))
5575 if (DECL_EXTERN_C_P (decl))
5576 /* Allow this; it's pretty common in C. */;
5579 pedwarn ("non-local function `%#D' uses anonymous type",
5581 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
5583 `%#D' does not refer to the unqualified type, so it is not used for linkage",
5588 pedwarn ("non-local function `%#D' uses local type `%T'",
5593 TREE_PUBLIC (decl) = publicp;
5596 DECL_INTERFACE_KNOWN (decl) = 1;
5597 DECL_NOT_REALLY_EXTERN (decl) = 1;
5600 /* If the declaration was declared inline, mark it as such. */
5602 DECL_DECLARED_INLINE_P (decl) = 1;
5603 /* We inline functions that are explicitly declared inline, or, when
5604 the user explicitly asks us to, all functions. */
5605 if (DECL_DECLARED_INLINE_P (decl)
5606 || (flag_inline_trees == 2 && !DECL_INLINE (decl) && funcdef_flag))
5607 DECL_INLINE (decl) = 1;
5609 DECL_EXTERNAL (decl) = 1;
5610 if (quals != NULL_TREE && TREE_CODE (type) == FUNCTION_TYPE)
5612 error ("%smember function `%D' cannot have `%T' method qualifier",
5613 (ctype ? "static " : "non-"), decl, TREE_VALUE (quals));
5617 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
5618 grok_op_properties (decl, friendp, /*complain=*/true);
5620 if (ctype && decl_function_context (decl))
5621 DECL_NO_STATIC_CHAIN (decl) = 1;
5623 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
5624 if (TREE_PURPOSE (t)
5625 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
5627 has_default_arg = 1;
5632 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
5636 ("defining explicit specialization `%D' in friend declaration",
5640 tree fns = TREE_OPERAND (orig_declarator, 0);
5641 tree args = TREE_OPERAND (orig_declarator, 1);
5643 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
5645 /* Something like `template <class T> friend void f<T>()'. */
5646 error ("invalid use of template-id `%D' in declaration of primary template",
5652 /* A friend declaration of the form friend void f<>(). Record
5653 the information in the TEMPLATE_ID_EXPR. */
5654 SET_DECL_IMPLICIT_INSTANTIATION (decl);
5656 if (TREE_CODE (fns) == COMPONENT_REF)
5658 /* Due to bison parser ickiness, we will have already looked
5659 up an operator_name or PFUNCNAME within the current class
5660 (see template_id in parse.y). If the current class contains
5661 such a name, we'll get a COMPONENT_REF here. Undo that. */
5663 my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
5664 == current_class_type, 20001120);
5665 fns = TREE_OPERAND (fns, 1);
5667 my_friendly_assert (TREE_CODE (fns) == IDENTIFIER_NODE
5668 || TREE_CODE (fns) == OVERLOAD, 20001120);
5669 DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
5671 if (has_default_arg)
5673 error ("default arguments are not allowed in declaration of friend template specialization `%D'",
5680 error ("`inline' is not allowed in declaration of friend template specialization `%D'",
5688 /* Make the init_value nonzero so pushdecl knows this is not
5689 tentative. error_mark_node is replaced later with the BLOCK. */
5690 DECL_INITIAL (decl) = error_mark_node;
5692 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
5693 TREE_NOTHROW (decl) = 1;
5695 /* Caller will do the rest of this. */
5699 if (flags == NO_SPECIAL && ctype && constructor_name_p (declarator, ctype))
5700 DECL_CONSTRUCTOR_P (decl) = 1;
5702 /* Function gets the ugly name, field gets the nice one. This call
5703 may change the type of the function (because of default
5705 if (ctype != NULL_TREE)
5706 grokclassfn (ctype, decl, flags, quals);
5708 decl = check_explicit_specialization (orig_declarator, decl,
5710 2 * (funcdef_flag != 0) +
5711 4 * (friendp != 0));
5712 if (decl == error_mark_node)
5715 if (ctype != NULL_TREE
5716 && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
5721 old_decl = check_classfn (ctype, decl,
5722 processing_template_decl
5723 > template_class_depth (ctype));
5725 if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
5726 /* Because grokfndecl is always supposed to return a
5727 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
5728 here. We depend on our callers to figure out that its
5729 really a template that's being returned. */
5730 old_decl = DECL_TEMPLATE_RESULT (old_decl);
5732 if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
5733 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
5735 /* Remove the `this' parm added by grokclassfn.
5736 XXX Isn't this done in start_function, too? */
5737 revert_static_member_fn (decl);
5738 last_function_parms = TREE_CHAIN (last_function_parms);
5740 if (old_decl && DECL_ARTIFICIAL (old_decl))
5741 error ("definition of implicitly-declared `%D'", old_decl);
5747 /* Since we've smashed OLD_DECL to its
5748 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
5749 if (TREE_CODE (decl) == TEMPLATE_DECL)
5750 decl = DECL_TEMPLATE_RESULT (decl);
5752 /* Attempt to merge the declarations. This can fail, in
5753 the case of some invalid specialization declarations. */
5755 ok = duplicate_decls (decl, old_decl);
5759 error ("no `%#D' member function declared in class `%T'",
5767 if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
5770 if (ctype == NULL_TREE || check)
5774 DECL_VIRTUAL_P (decl) = 1;
5779 /* Create a VAR_DECL named NAME with the indicated TYPE.
5781 If SCOPE is non-NULL, it is the class type or namespace containing
5782 the variable. If SCOPE is NULL, the variable should is created in
5783 the innermost enclosings scope. */
5786 grokvardecl (tree type,
5788 RID_BIT_TYPE * specbits_in,
5794 RID_BIT_TYPE specbits;
5796 my_friendly_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE,
5799 specbits = *specbits_in;
5801 /* Compute the scope in which to place the variable. */
5804 /* An explicit "extern" specifier indicates a namespace-scope
5806 if (RIDBIT_SETP (RID_EXTERN, specbits))
5807 scope = current_namespace;
5808 else if (!at_function_scope_p ())
5810 scope = current_scope ();
5812 scope = current_namespace;
5817 && (/* If the variable is a namespace-scope variable declared in a
5818 template, we need DECL_LANG_SPECIFIC. */
5819 (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
5820 /* Similarly for namespace-scope variables with language linkage
5822 || (TREE_CODE (scope) == NAMESPACE_DECL
5823 && current_lang_name != lang_name_cplusplus)
5824 /* Similarly for static data members. */
5826 decl = build_lang_decl (VAR_DECL, name, type);
5828 decl = build_decl (VAR_DECL, name, type);
5830 if (scope && TREE_CODE (scope) == NAMESPACE_DECL)
5831 set_decl_namespace (decl, scope, 0);
5833 DECL_CONTEXT (decl) = scope;
5835 if (name && scope && current_lang_name != lang_name_c)
5836 /* We can't mangle lazily here because we don't have any
5837 way to recover whether or not a variable was `extern
5841 if (RIDBIT_SETP (RID_EXTERN, specbits))
5843 DECL_THIS_EXTERN (decl) = 1;
5844 DECL_EXTERNAL (decl) = !initialized;
5847 /* In class context, static means one per class,
5848 public access, and static storage. */
5849 if (DECL_CLASS_SCOPE_P (decl))
5851 TREE_PUBLIC (decl) = 1;
5852 TREE_STATIC (decl) = 1;
5853 DECL_EXTERNAL (decl) = 0;
5855 /* At top level, either `static' or no s.c. makes a definition
5856 (perhaps tentative), and absence of `static' makes it public. */
5857 else if (toplevel_bindings_p ())
5859 TREE_PUBLIC (decl) = (RIDBIT_NOTSETP (RID_STATIC, specbits)
5860 && (DECL_THIS_EXTERN (decl) || ! constp));
5861 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
5863 /* Not at top level, only `static' makes a static definition. */
5866 TREE_STATIC (decl) = !! RIDBIT_SETP (RID_STATIC, specbits);
5867 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
5870 if (RIDBIT_SETP (RID_THREAD, specbits))
5872 if (targetm.have_tls)
5873 DECL_THREAD_LOCAL (decl) = 1;
5875 /* A mere warning is sure to result in improper semantics
5876 at runtime. Don't bother to allow this to compile. */
5877 error ("thread-local storage not supported for this target");
5880 if (TREE_PUBLIC (decl))
5882 /* [basic.link]: A name with no linkage (notably, the name of a class
5883 or enumeration declared in a local scope) shall not be used to
5884 declare an entity with linkage.
5886 Only check this for public decls for now. */
5887 tree t = no_linkage_check (TREE_TYPE (decl));
5890 if (TYPE_ANONYMOUS_P (t))
5891 /* Ignore for now; `enum { foo } e' is pretty common. */;
5893 pedwarn ("non-local variable `%#D' uses local type `%T'",
5901 /* Create and return a canonical pointer to member function type, for
5902 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
5905 build_ptrmemfunc_type (tree type)
5909 tree unqualified_variant = NULL_TREE;
5911 if (type == error_mark_node)
5914 /* If a canonical type already exists for this type, use it. We use
5915 this method instead of type_hash_canon, because it only does a
5916 simple equality check on the list of field members. */
5918 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
5921 /* Make sure that we always have the unqualified pointer-to-member
5923 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
5925 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
5927 t = make_aggr_type (RECORD_TYPE);
5928 /* Let the front-end know this is a pointer to member function... */
5929 TYPE_PTRMEMFUNC_FLAG (t) = 1;
5930 /* ... and not really an aggregate. */
5931 SET_IS_AGGR_TYPE (t, 0);
5933 field = build_decl (FIELD_DECL, pfn_identifier, type);
5936 field = build_decl (FIELD_DECL, delta_identifier, delta_type_node);
5937 TREE_CHAIN (field) = fields;
5940 finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
5942 /* Zap out the name so that the back-end will give us the debugging
5943 information for this anonymous RECORD_TYPE. */
5944 TYPE_NAME (t) = NULL_TREE;
5946 /* If this is not the unqualified form of this pointer-to-member
5947 type, set the TYPE_MAIN_VARIANT for this type to be the
5948 unqualified type. Since they are actually RECORD_TYPEs that are
5949 not variants of each other, we must do this manually. */
5950 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
5952 t = build_qualified_type (t, cp_type_quals (type));
5953 TYPE_MAIN_VARIANT (t) = unqualified_variant;
5954 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
5955 TYPE_NEXT_VARIANT (unqualified_variant) = t;
5958 /* Cache this pointer-to-member type so that we can find it again
5960 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
5965 /* Create and return a pointer to data member type. */
5968 build_ptrmem_type (tree class_type, tree member_type)
5970 if (TREE_CODE (member_type) == METHOD_TYPE)
5974 arg_types = TYPE_ARG_TYPES (member_type);
5975 class_type = (cp_build_qualified_type
5977 cp_type_quals (TREE_TYPE (TREE_VALUE (arg_types)))));
5979 = build_method_type_directly (class_type,
5980 TREE_TYPE (member_type),
5981 TREE_CHAIN (arg_types));
5982 return build_ptrmemfunc_type (build_pointer_type (member_type));
5986 my_friendly_assert (TREE_CODE (member_type) != FUNCTION_TYPE,
5988 return build_offset_type (class_type, member_type);
5992 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
5993 Check to see that the definition is valid. Issue appropriate error
5994 messages. Return 1 if the definition is particularly bad, or 0
5998 check_static_variable_definition (tree decl, tree type)
6000 /* Motion 10 at San Diego: If a static const integral data member is
6001 initialized with an integral constant expression, the initializer
6002 may appear either in the declaration (within the class), or in
6003 the definition, but not both. If it appears in the class, the
6004 member is a member constant. The file-scope definition is always
6006 if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
6008 error ("invalid in-class initialization of static data member of non-integral type `%T'",
6010 /* If we just return the declaration, crashes will sometimes
6011 occur. We therefore return void_type_node, as if this were a
6012 friend declaration, to cause callers to completely ignore
6013 this declaration. */
6016 else if (!CP_TYPE_CONST_P (type))
6017 error ("ISO C++ forbids in-class initialization of non-const static member `%D'",
6019 else if (pedantic && !INTEGRAL_TYPE_P (type))
6020 pedwarn ("ISO C++ forbids initialization of member constant `%D' of non-integral type `%T'", decl, type);
6025 /* Given the SIZE (i.e., number of elements) in an array, compute an
6026 appropriate index type for the array. If non-NULL, NAME is the
6027 name of the thing being declared. */
6030 compute_array_index_type (tree name, tree size)
6032 tree type = TREE_TYPE (size);
6035 /* The array bound must be an integer type. */
6036 if (!dependent_type_p (type) && !INTEGRAL_TYPE_P (type))
6039 error ("size of array `%D' has non-integral type `%T'", name, type);
6041 error ("size of array has non-integral type `%T'", type);
6042 size = integer_one_node;
6043 type = TREE_TYPE (size);
6046 if (abi_version_at_least (2)
6047 /* We should only handle value dependent expressions specially. */
6048 ? value_dependent_expression_p (size)
6049 /* But for abi-1, we handled all instances in templates. This
6050 effects the manglings produced. */
6051 : processing_template_decl)
6052 return build_index_type (build_min (MINUS_EXPR, sizetype,
6053 size, integer_one_node));
6055 /* The size might be the result of a cast. */
6056 STRIP_TYPE_NOPS (size);
6058 /* It might be a const variable or enumeration constant. */
6059 size = decl_constant_value (size);
6061 /* Normally, the array-bound will be a constant. */
6062 if (TREE_CODE (size) == INTEGER_CST)
6064 /* Check to see if the array bound overflowed. Make that an
6065 error, no matter how generous we're being. */
6066 int old_flag_pedantic_errors = flag_pedantic_errors;
6067 int old_pedantic = pedantic;
6068 pedantic = flag_pedantic_errors = 1;
6069 constant_expression_warning (size);
6070 pedantic = old_pedantic;
6071 flag_pedantic_errors = old_flag_pedantic_errors;
6073 /* An array must have a positive number of elements. */
6074 if (INT_CST_LT (size, integer_zero_node))
6077 error ("size of array `%D' is negative", name);
6079 error ("size of array is negative");
6080 size = integer_one_node;
6082 /* As an extension we allow zero-sized arrays. We always allow
6083 them in system headers because glibc uses them. */
6084 else if (integer_zerop (size) && pedantic && !in_system_header)
6087 pedwarn ("ISO C++ forbids zero-size array `%D'", name);
6089 pedwarn ("ISO C++ forbids zero-size array");
6092 else if (TREE_CONSTANT (size))
6094 /* `(int) &fn' is not a valid array bound. */
6096 error ("size of array `%D' is not an integral constant-expression",
6099 error ("size of array is not an integral constant-expression");
6104 pedwarn ("ISO C++ forbids variable-size array `%D'", name);
6106 pedwarn ("ISO C++ forbids variable-size array");
6109 if (processing_template_decl && !TREE_CONSTANT (size))
6110 /* A variable sized array. */
6111 itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node);
6114 /* Compute the index of the largest element in the array. It is
6115 one less than the number of elements in the array. */
6117 = fold (cp_build_binary_op (MINUS_EXPR,
6118 cp_convert (ssizetype, size),
6119 cp_convert (ssizetype, integer_one_node)));
6120 if (!TREE_CONSTANT (itype))
6121 /* A variable sized array. */
6122 itype = variable_size (itype);
6123 /* Make sure that there was no overflow when creating to a signed
6124 index type. (For example, on a 32-bit machine, an array with
6125 size 2^32 - 1 is too big.) */
6126 else if (TREE_OVERFLOW (itype))
6128 error ("overflow in array dimension");
6129 TREE_OVERFLOW (itype) = 0;
6133 /* Create and return the appropriate index type. */
6134 return build_index_type (itype);
6137 /* Returns the scope (if any) in which the entity declared by
6138 DECLARATOR will be located. If the entity was declared with an
6139 unqualified name, NULL_TREE is returned. */
6142 get_scope_of_declarator (tree declarator)
6147 switch (TREE_CODE (declarator))
6153 /* For any of these, the main declarator is the first operand. */
6154 return get_scope_of_declarator (TREE_OPERAND
6158 /* For a pointer-to-member, continue descending. */
6159 if (TREE_CODE (TREE_OPERAND (declarator, 1))
6161 return get_scope_of_declarator (TREE_OPERAND
6163 /* Otherwise, if the declarator-id is a SCOPE_REF, the scope in
6164 which the declaration occurs is the first operand. */
6165 return TREE_OPERAND (declarator, 0);
6168 /* Attributes to be applied. The declarator is TREE_VALUE. */
6169 return get_scope_of_declarator (TREE_VALUE (declarator));
6172 /* Otherwise, we have a declarator-id which is not a qualified
6173 name; the entity will be declared in the current scope. */
6178 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
6179 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
6183 create_array_type_for_decl (tree name, tree type, tree size)
6185 tree itype = NULL_TREE;
6186 const char* error_msg;
6188 /* If things have already gone awry, bail now. */
6189 if (type == error_mark_node || size == error_mark_node)
6190 return error_mark_node;
6192 /* Assume that everything will go OK. */
6195 /* There are some types which cannot be array elements. */
6196 switch (TREE_CODE (type))
6199 error_msg = "array of void";
6203 error_msg = "array of functions";
6206 case REFERENCE_TYPE:
6207 error_msg = "array of references";
6211 error_msg = "array of function members";
6218 /* If something went wrong, issue an error-message and return. */
6222 error ("declaration of `%D' as %s", name, error_msg);
6224 error ("creating %s", error_msg);
6226 return error_mark_node;
6231 The constant expressions that specify the bounds of the arrays
6232 can be omitted only for the first member of the sequence. */
6233 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
6236 error ("declaration of `%D' as multidimensional array must have bounds for all dimensions except the first",
6239 error ("multidimensional array must have bounds for all dimensions except the first");
6241 return error_mark_node;
6244 /* Figure out the index type for the array. */
6246 itype = compute_array_index_type (name, size);
6248 return build_cplus_array_type (type, itype);
6251 /* Check that it's OK to declare a function with the indicated TYPE.
6252 SFK indicates the kind of special function (if any) that this
6253 function is. OPTYPE is the type given in a conversion operator
6254 declaration. Returns the actual return type of the function; that
6255 may be different than TYPE if an error occurs, or for certain
6256 special functions. */
6259 check_special_function_return_type (special_function_kind sfk,
6265 case sfk_constructor:
6267 error ("return type specification for constructor invalid");
6269 type = void_type_node;
6272 case sfk_destructor:
6274 error ("return type specification for destructor invalid");
6275 type = void_type_node;
6278 case sfk_conversion:
6279 if (type && !same_type_p (type, optype))
6280 error ("operator `%T' declared to return `%T'", optype, type);
6282 pedwarn ("return type specified for `operator %T'", optype);
6294 /* Given declspecs and a declarator (abstract or otherwise), determine
6295 the name and type of the object declared and construct a DECL node
6298 DECLSPECS is a chain of tree_list nodes whose value fields
6299 are the storage classes and type specifiers.
6301 DECL_CONTEXT says which syntactic context this declaration is in:
6302 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
6303 FUNCDEF for a function definition. Like NORMAL but a few different
6304 error messages in each case. Return value may be zero meaning
6305 this definition is too screwy to try to parse.
6306 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
6307 handle member functions (which have FIELD context).
6308 Return value may be zero meaning this definition is too screwy to
6310 PARM for a parameter declaration (either within a function prototype
6311 or before a function body). Make a PARM_DECL, or return void_type_node.
6312 CATCHPARM for a parameter declaration before a catch clause.
6313 TYPENAME if for a typename (in a cast or sizeof).
6314 Don't make a DECL node; just return the ..._TYPE node.
6315 FIELD for a struct or union field; make a FIELD_DECL.
6316 BITFIELD for a field with specified width.
6317 INITIALIZED is 1 if the decl has an initializer.
6319 ATTRLIST is a pointer to the list of attributes, which may be NULL
6320 if there are none; *ATTRLIST may be modified if attributes from inside
6321 the declarator should be applied to the declaration.
6323 When this function is called, scoping variables (such as
6324 CURRENT_CLASS_TYPE) should reflect the scope in which the
6325 declaration occurs, not the scope in which the new declaration will
6326 be placed. For example, on:
6330 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
6331 should not be `S'. */
6334 grokdeclarator (tree declarator,
6336 enum decl_context decl_context,
6340 RID_BIT_TYPE specbits;
6343 tree type = NULL_TREE;
6346 int virtualp, explicitp, friendp, inlinep, staticp;
6347 int explicit_int = 0;
6348 int explicit_char = 0;
6349 int defaulted_int = 0;
6350 int extern_langp = 0;
6351 tree dependant_name = NULL_TREE;
6353 tree typedef_decl = NULL_TREE;
6355 tree typedef_type = NULL_TREE;
6356 int funcdef_flag = 0;
6357 enum tree_code innermost_code = ERROR_MARK;
6360 /* See the code below that used this. */
6361 tree decl_attr = NULL_TREE;
6364 /* Keep track of what sort of function is being processed
6365 so that we can warn about default return values, or explicit
6366 return values which do not match prescribed defaults. */
6367 special_function_kind sfk = sfk_none;
6369 tree dname = NULL_TREE;
6370 tree ctype = current_class_type;
6371 tree ctor_return_type = NULL_TREE;
6372 enum overload_flags flags = NO_SPECIAL;
6373 tree quals = NULL_TREE;
6374 tree raises = NULL_TREE;
6375 int template_count = 0;
6376 tree in_namespace = NULL_TREE;
6377 tree returned_attrs = NULL_TREE;
6378 tree scope = NULL_TREE;
6380 RIDBIT_RESET_ALL (specbits);
6381 if (decl_context == FUNCDEF)
6382 funcdef_flag = 1, decl_context = NORMAL;
6383 else if (decl_context == MEMFUNCDEF)
6384 funcdef_flag = -1, decl_context = FIELD;
6385 else if (decl_context == BITFIELD)
6386 bitfield = 1, decl_context = FIELD;
6388 /* Look inside a declarator for the name being declared
6389 and get it as a string, for an error message. */
6391 tree *next = &declarator;
6395 while (next && *next)
6398 switch (TREE_CODE (decl))
6401 /* For attributes. */
6402 next = &TREE_VALUE (decl);
6407 next = &TREE_OPERAND (decl, 0);
6410 case BIT_NOT_EXPR: /* For C++ destructors! */
6412 tree name = TREE_OPERAND (decl, 0);
6413 tree rename = NULL_TREE;
6415 my_friendly_assert (flags == NO_SPECIAL, 152);
6417 sfk = sfk_destructor;
6419 TREE_OPERAND (decl, 0) = name = constructor_name (name);
6420 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 153);
6421 if (ctype == NULL_TREE)
6423 if (current_class_type == NULL_TREE)
6425 error ("destructors must be member functions");
6430 tree t = constructor_name (current_class_type);
6437 tree t = constructor_name (ctype);
6444 error ("destructor `%T' must match class name `%T'",
6446 TREE_OPERAND (decl, 0) = rename;
6452 case ADDR_EXPR: /* C++ reference declaration */
6457 innermost_code = TREE_CODE (decl);
6458 next = &TREE_OPERAND (decl, 0);
6462 innermost_code = TREE_CODE (decl);
6463 if (decl_context == FIELD && ctype == NULL_TREE)
6464 ctype = current_class_type;
6466 && TREE_OPERAND (decl, 0)
6467 && (TREE_CODE (TREE_OPERAND (decl, 0)) == TYPE_DECL
6468 && constructor_name_p (DECL_NAME (TREE_OPERAND (decl, 0)),
6470 TREE_OPERAND (decl, 0) = constructor_name (ctype);
6471 next = &TREE_OPERAND (decl, 0);
6473 if (ctype != NULL_TREE
6474 && decl != NULL_TREE && flags != DTOR_FLAG
6475 && constructor_name_p (decl, ctype))
6477 sfk = sfk_constructor;
6478 ctor_return_type = ctype;
6483 case TEMPLATE_ID_EXPR:
6485 tree fns = TREE_OPERAND (decl, 0);
6488 if (TREE_CODE (dname) == COMPONENT_REF)
6489 dname = TREE_OPERAND (dname, 1);
6490 if (TREE_CODE (dname) != IDENTIFIER_NODE)
6492 my_friendly_assert (is_overloaded_fn (dname),
6494 dname = DECL_NAME (get_first_fn (dname));
6499 case IDENTIFIER_NODE:
6500 if (TREE_CODE (decl) == IDENTIFIER_NODE)
6505 if (C_IS_RESERVED_WORD (dname))
6507 error ("declarator-id missing; using reserved word `%D'",
6509 name = IDENTIFIER_POINTER (dname);
6511 else if (!IDENTIFIER_TYPENAME_P (dname))
6512 name = IDENTIFIER_POINTER (dname);
6515 my_friendly_assert (flags == NO_SPECIAL, 154);
6516 flags = TYPENAME_FLAG;
6517 ctor_return_type = TREE_TYPE (dname);
6518 sfk = sfk_conversion;
6519 if (is_typename_at_global_scope (dname))
6520 name = IDENTIFIER_POINTER (dname);
6522 name = "<invalid operator>";
6529 /* Perform error checking, and decide on a ctype. */
6530 tree cname = TREE_OPERAND (decl, 0);
6531 if (cname == NULL_TREE)
6533 else if (TREE_CODE (cname) == NAMESPACE_DECL)
6536 in_namespace = TREE_OPERAND (decl, 0);
6538 else if (! is_aggr_type (cname, 1))
6540 /* Must test TREE_OPERAND (decl, 1), in case user gives
6541 us `typedef (class::memfunc)(int); memfunc *memfuncptr;' */
6542 else if (TREE_OPERAND (decl, 1)
6543 && TREE_CODE (TREE_OPERAND (decl, 1)) == INDIRECT_REF)
6545 else if (TREE_CODE (cname) == TEMPLATE_TYPE_PARM
6546 || TREE_CODE (cname) == BOUND_TEMPLATE_TEMPLATE_PARM)
6548 /* This might be declaring a member of a template
6549 parm to be a friend. */
6551 dependant_name = TREE_OPERAND (decl, 1);
6553 else if (ctype == NULL_TREE)
6555 else if (TREE_COMPLEXITY (decl) == current_class_depth)
6559 if (! UNIQUELY_DERIVED_FROM_P (cname, ctype))
6561 error ("type `%T' is not derived from type `%T'",
6569 /* It is valid to write:
6571 class C { void f(); };
6575 The standard is not clear about whether `typedef const C D' is
6576 legal; as of 2002-09-15 the committee is considering
6577 that question. EDG 3.0 allows that syntax.
6578 Therefore, we do as well. */
6580 ctype = TYPE_MAIN_VARIANT (ctype);
6581 /* Update the declarator so that when we process it
6582 again the correct type is present. */
6583 TREE_OPERAND (decl, 0) = ctype;
6585 if (ctype && TREE_CODE (TREE_OPERAND (decl, 1)) == TYPE_DECL
6586 && constructor_name_p (DECL_NAME (TREE_OPERAND (decl, 1)),
6588 TREE_OPERAND (decl, 1) = constructor_name (ctype);
6589 next = &TREE_OPERAND (decl, 1);
6595 if (TREE_CODE (name) == BIT_NOT_EXPR)
6596 name = TREE_OPERAND (name, 0);
6598 if (!constructor_name_p (decl, ctype))
6600 else if (decl == name)
6602 sfk = sfk_constructor;
6603 ctor_return_type = ctype;
6607 sfk = sfk_destructor;
6608 ctor_return_type = ctype;
6610 TREE_OPERAND (decl, 0) = constructor_name (ctype);
6611 next = &TREE_OPERAND (decl, 0);
6622 /* Parse error puts this typespec where
6623 a declarator should go. */
6624 error ("`%T' specified as declarator-id", DECL_NAME (decl));
6625 if (TREE_TYPE (decl) == current_class_type)
6626 error (" perhaps you want `%T' for a constructor",
6627 current_class_name);
6628 dname = DECL_NAME (decl);
6629 name = IDENTIFIER_POINTER (dname);
6631 /* Avoid giving two errors for this. */
6632 IDENTIFIER_CLASS_VALUE (dname) = NULL_TREE;
6634 declspecs = tree_cons (NULL_TREE, integer_type_node, declspecs);
6640 next = &BASELINK_FUNCTIONS (decl);
6644 /* Sometimes, we see a template-name used as part of a
6645 decl-specifier like in
6646 std::allocator alloc;
6647 Handle that gracefully. */
6648 error ("invalid use of template-name '%E' in a declarator", decl);
6649 return error_mark_node;
6653 my_friendly_assert (0, 20020917);
6658 /* A function definition's declarator must have the form of
6659 a function declarator. */
6661 if (funcdef_flag && innermost_code != CALL_EXPR)
6664 if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
6665 && innermost_code != CALL_EXPR
6666 && ! (ctype && declspecs == NULL_TREE))
6668 error ("declaration of `%D' as non-function", dname);
6669 return void_type_node;
6672 /* Anything declared one level down from the top level
6673 must be one of the parameters of a function
6674 (because the body is at least two levels down). */
6676 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
6677 by not allowing C++ class definitions to specify their parameters
6678 with xdecls (must be spec.d in the parmlist).
6680 Since we now wait to push a class scope until we are sure that
6681 we are in a legitimate method context, we must set oldcname
6682 explicitly (since current_class_name is not yet alive).
6684 We also want to avoid calling this a PARM if it is in a namespace. */
6686 if (decl_context == NORMAL && !toplevel_bindings_p ())
6688 struct cp_binding_level *b = current_binding_level;
6689 current_binding_level = b->level_chain;
6690 if (current_binding_level != 0 && toplevel_bindings_p ())
6691 decl_context = PARM;
6692 current_binding_level = b;
6696 name = decl_context == PARM ? "parameter" : "type name";
6698 /* Look through the decl specs and record which ones appear.
6699 Some typespecs are defined as built-in typenames.
6700 Others, the ones that are modifiers of other types,
6701 are represented by bits in SPECBITS: set the bits for
6702 the modifiers that appear. Storage class keywords are also in SPECBITS.
6704 If there is a typedef name or a type, store the type in TYPE.
6705 This includes builtin typedefs such as `int'.
6707 Set EXPLICIT_INT if the type is `int' or `char' and did not
6708 come from a user typedef.
6710 Set LONGLONG if `long' is mentioned twice.
6712 For C++, constructors and destructors have their own fast treatment. */
6714 for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
6719 /* Certain parse errors slip through. For example,
6720 `int class;' is not caught by the parser. Try
6721 weakly to recover here. */
6722 if (TREE_CODE (spec) != TREE_LIST)
6725 id = TREE_VALUE (spec);
6727 /* If the entire declaration is itself tagged as deprecated then
6728 suppress reports of deprecated items. */
6729 if (!adding_implicit_members && id && TREE_DEPRECATED (id))
6731 if (deprecated_state != DEPRECATED_SUPPRESS)
6732 warn_deprecated_use (id);
6735 if (TREE_CODE (id) == IDENTIFIER_NODE)
6737 if (id == ridpointers[(int) RID_INT]
6738 || id == ridpointers[(int) RID_CHAR]
6739 || id == ridpointers[(int) RID_BOOL]
6740 || id == ridpointers[(int) RID_WCHAR])
6744 if (id == ridpointers[(int) RID_BOOL])
6745 error ("`bool' is now a keyword");
6747 error ("extraneous `%T' ignored", id);
6751 if (id == ridpointers[(int) RID_INT])
6753 else if (id == ridpointers[(int) RID_CHAR])
6755 type = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (id));
6759 /* C++ aggregate types. */
6760 if (IDENTIFIER_HAS_TYPE_VALUE (id))
6763 error ("multiple declarations `%T' and `%T'", type, id);
6765 type = IDENTIFIER_TYPE_VALUE (id);
6769 for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++)
6771 if (ridpointers[i] == id)
6773 if (i == (int) RID_LONG && RIDBIT_SETP (i, specbits))
6775 if (pedantic && ! in_system_header && warn_long_long)
6776 pedwarn ("ISO C++ does not support `long long'");
6778 error ("`long long long' is too long for GCC");
6782 else if (RIDBIT_SETP (i, specbits))
6783 pedwarn ("duplicate `%s'", IDENTIFIER_POINTER (id));
6785 /* Diagnose "__thread extern" or "__thread static". */
6786 if (RIDBIT_SETP (RID_THREAD, specbits))
6788 if (i == (int)RID_EXTERN)
6789 error ("`__thread' before `extern'");
6790 else if (i == (int)RID_STATIC)
6791 error ("`__thread' before `static'");
6794 if (i == (int)RID_EXTERN
6795 && TREE_PURPOSE (spec) == error_mark_node)
6796 /* This extern was part of a language linkage. */
6799 RIDBIT_SET (i, specbits);
6804 else if (TREE_CODE (id) == TYPE_DECL)
6807 error ("multiple declarations `%T' and `%T'", type,
6811 type = TREE_TYPE (id);
6812 TREE_VALUE (spec) = type;
6818 error ("two or more data types in declaration of `%s'", name);
6819 else if (TREE_CODE (id) == IDENTIFIER_NODE)
6821 tree t = lookup_name (id, 1);
6822 if (!t || TREE_CODE (t) != TYPE_DECL)
6823 error ("`%s' fails to be a typedef or built in type",
6824 IDENTIFIER_POINTER (id));
6827 type = TREE_TYPE (t);
6831 else if (id != error_mark_node)
6832 /* Can't change CLASS nodes into RECORD nodes here! */
6839 /* See the code below that used this. */
6841 decl_attr = DECL_ATTRIBUTES (typedef_decl);
6843 typedef_type = type;
6845 /* No type at all: default to `int', and set DEFAULTED_INT
6846 because it was not a user-defined typedef. */
6848 if (type == NULL_TREE
6849 && (RIDBIT_SETP (RID_SIGNED, specbits)
6850 || RIDBIT_SETP (RID_UNSIGNED, specbits)
6851 || RIDBIT_SETP (RID_LONG, specbits)
6852 || RIDBIT_SETP (RID_SHORT, specbits)))
6854 /* These imply 'int'. */
6855 type = integer_type_node;
6859 if (sfk != sfk_none)
6860 type = check_special_function_return_type (sfk, type,
6862 else if (type == NULL_TREE)
6868 /* We handle `main' specially here, because 'main () { }' is so
6869 common. With no options, it is allowed. With -Wreturn-type,
6870 it is a warning. It is only an error with -pedantic-errors. */
6871 is_main = (funcdef_flag
6872 && dname && MAIN_NAME_P (dname)
6873 && ctype == NULL_TREE
6874 && in_namespace == NULL_TREE
6875 && current_namespace == global_namespace);
6877 if (in_system_header || flag_ms_extensions)
6878 /* Allow it, sigh. */;
6879 else if (pedantic || ! is_main)
6880 pedwarn ("ISO C++ forbids declaration of `%s' with no type",
6882 else if (warn_return_type)
6883 warning ("ISO C++ forbids declaration of `%s' with no type",
6886 type = integer_type_node;
6891 /* Now process the modifiers that were specified
6892 and check for invalid combinations. */
6894 /* Long double is a special combination. */
6896 if (RIDBIT_SETP (RID_LONG, specbits)
6897 && TYPE_MAIN_VARIANT (type) == double_type_node)
6899 RIDBIT_RESET (RID_LONG, specbits);
6900 type = build_qualified_type (long_double_type_node,
6901 cp_type_quals (type));
6904 /* Check all other uses of type modifiers. */
6906 if (RIDBIT_SETP (RID_UNSIGNED, specbits)
6907 || RIDBIT_SETP (RID_SIGNED, specbits)
6908 || RIDBIT_SETP (RID_LONG, specbits)
6909 || RIDBIT_SETP (RID_SHORT, specbits))
6913 if (TREE_CODE (type) == REAL_TYPE)
6914 error ("short, signed or unsigned invalid for `%s'", name);
6915 else if (TREE_CODE (type) != INTEGER_TYPE)
6916 error ("long, short, signed or unsigned invalid for `%s'", name);
6917 else if (RIDBIT_SETP (RID_LONG, specbits)
6918 && RIDBIT_SETP (RID_SHORT, specbits))
6919 error ("long and short specified together for `%s'", name);
6920 else if ((RIDBIT_SETP (RID_LONG, specbits)
6921 || RIDBIT_SETP (RID_SHORT, specbits))
6923 error ("long or short specified with char for `%s'", name);
6924 else if ((RIDBIT_SETP (RID_LONG, specbits)
6925 || RIDBIT_SETP (RID_SHORT, specbits))
6926 && TREE_CODE (type) == REAL_TYPE)
6927 error ("long or short specified with floating type for `%s'", name);
6928 else if (RIDBIT_SETP (RID_SIGNED, specbits)
6929 && RIDBIT_SETP (RID_UNSIGNED, specbits))
6930 error ("signed and unsigned given together for `%s'", name);
6934 if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
6936 pedwarn ("long, short, signed or unsigned used invalidly for `%s'",
6938 if (flag_pedantic_errors)
6943 /* Discard the type modifiers if they are invalid. */
6946 RIDBIT_RESET (RID_UNSIGNED, specbits);
6947 RIDBIT_RESET (RID_SIGNED, specbits);
6948 RIDBIT_RESET (RID_LONG, specbits);
6949 RIDBIT_RESET (RID_SHORT, specbits);
6954 if (RIDBIT_SETP (RID_COMPLEX, specbits)
6955 && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
6957 error ("complex invalid for `%s'", name);
6958 RIDBIT_RESET (RID_COMPLEX, specbits);
6961 /* Decide whether an integer type is signed or not.
6962 Optionally treat bitfields as signed by default. */
6963 if (RIDBIT_SETP (RID_UNSIGNED, specbits)
6966 It is implementation-defined whether a plain (neither
6967 explicitly signed or unsigned) char, short, int, or long
6968 bit-field is signed or unsigned.
6970 Naturally, we extend this to long long as well. Note that
6971 this does not include wchar_t. */
6972 || (bitfield && !flag_signed_bitfields
6973 && RIDBIT_NOTSETP (RID_SIGNED, specbits)
6974 /* A typedef for plain `int' without `signed' can be
6975 controlled just like plain `int', but a typedef for
6976 `signed int' cannot be so controlled. */
6978 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
6979 && (TREE_CODE (type) == INTEGER_TYPE
6980 || TREE_CODE (type) == CHAR_TYPE)
6981 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
6984 type = long_long_unsigned_type_node;
6985 else if (RIDBIT_SETP (RID_LONG, specbits))
6986 type = long_unsigned_type_node;
6987 else if (RIDBIT_SETP (RID_SHORT, specbits))
6988 type = short_unsigned_type_node;
6989 else if (type == char_type_node)
6990 type = unsigned_char_type_node;
6991 else if (typedef_decl)
6992 type = c_common_unsigned_type (type);
6994 type = unsigned_type_node;
6996 else if (RIDBIT_SETP (RID_SIGNED, specbits)
6997 && type == char_type_node)
6998 type = signed_char_type_node;
7000 type = long_long_integer_type_node;
7001 else if (RIDBIT_SETP (RID_LONG, specbits))
7002 type = long_integer_type_node;
7003 else if (RIDBIT_SETP (RID_SHORT, specbits))
7004 type = short_integer_type_node;
7006 if (RIDBIT_SETP (RID_COMPLEX, specbits))
7008 /* If we just have "complex", it is equivalent to
7009 "complex double", but if any modifiers at all are specified it is
7010 the complex form of TYPE. E.g, "complex short" is
7011 "complex short int". */
7013 if (defaulted_int && ! longlong
7014 && ! (RIDBIT_SETP (RID_LONG, specbits)
7015 || RIDBIT_SETP (RID_SHORT, specbits)
7016 || RIDBIT_SETP (RID_SIGNED, specbits)
7017 || RIDBIT_SETP (RID_UNSIGNED, specbits)))
7018 type = complex_double_type_node;
7019 else if (type == integer_type_node)
7020 type = complex_integer_type_node;
7021 else if (type == float_type_node)
7022 type = complex_float_type_node;
7023 else if (type == double_type_node)
7024 type = complex_double_type_node;
7025 else if (type == long_double_type_node)
7026 type = complex_long_double_type_node;
7028 type = build_complex_type (type);
7031 type_quals = TYPE_UNQUALIFIED;
7032 if (RIDBIT_SETP (RID_CONST, specbits))
7033 type_quals |= TYPE_QUAL_CONST;
7034 if (RIDBIT_SETP (RID_VOLATILE, specbits))
7035 type_quals |= TYPE_QUAL_VOLATILE;
7036 if (RIDBIT_SETP (RID_RESTRICT, specbits))
7037 type_quals |= TYPE_QUAL_RESTRICT;
7038 if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
7039 error ("qualifiers are not allowed on declaration of `operator %T'",
7042 type_quals |= cp_type_quals (type);
7043 type = cp_build_qualified_type_real
7044 (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
7045 ? tf_ignore_bad_quals : 0) | tf_error | tf_warning));
7046 /* We might have ignored or rejected some of the qualifiers. */
7047 type_quals = cp_type_quals (type);
7050 inlinep = !! RIDBIT_SETP (RID_INLINE, specbits);
7051 virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits);
7052 RIDBIT_RESET (RID_VIRTUAL, specbits);
7053 explicitp = RIDBIT_SETP (RID_EXPLICIT, specbits) != 0;
7054 RIDBIT_RESET (RID_EXPLICIT, specbits);
7056 if (RIDBIT_SETP (RID_STATIC, specbits))
7057 staticp = 1 + (decl_context == FIELD);
7059 if (virtualp && staticp == 2)
7061 error ("member `%D' cannot be declared both virtual and static",
7065 friendp = RIDBIT_SETP (RID_FRIEND, specbits);
7066 RIDBIT_RESET (RID_FRIEND, specbits);
7068 if (dependant_name && !friendp)
7070 error ("`%T::%D' is not a valid declarator", ctype, dependant_name);
7071 return void_type_node;
7074 /* Warn if two storage classes are given. Default to `auto'. */
7076 if (RIDBIT_ANY_SET (specbits))
7078 if (RIDBIT_SETP (RID_STATIC, specbits)) nclasses++;
7079 if (RIDBIT_SETP (RID_EXTERN, specbits) && !extern_langp) nclasses++;
7080 if (RIDBIT_SETP (RID_THREAD, specbits)) nclasses++;
7081 if (decl_context == PARM && nclasses > 0)
7082 error ("storage class specifiers invalid in parameter declarations");
7083 if (RIDBIT_SETP (RID_TYPEDEF, specbits))
7085 if (decl_context == PARM)
7086 error ("typedef declaration invalid in parameter declaration");
7089 if (RIDBIT_SETP (RID_AUTO, specbits)) nclasses++;
7090 if (RIDBIT_SETP (RID_REGISTER, specbits)) nclasses++;
7091 if (!nclasses && !friendp && extern_langp)
7095 /* Give error if `virtual' is used outside of class declaration. */
7097 && (current_class_name == NULL_TREE || decl_context != FIELD))
7099 error ("virtual outside class declaration");
7103 /* Static anonymous unions are dealt with here. */
7104 if (staticp && decl_context == TYPENAME
7105 && TREE_CODE (declspecs) == TREE_LIST
7106 && ANON_AGGR_TYPE_P (TREE_VALUE (declspecs)))
7107 decl_context = FIELD;
7109 /* Warn about storage classes that are invalid for certain
7110 kinds of declarations (parameters, typenames, etc.). */
7112 /* "static __thread" and "extern __thread" are allowed. */
7114 && RIDBIT_SETP (RID_THREAD, specbits)
7115 && (RIDBIT_SETP (RID_EXTERN, specbits)
7116 || RIDBIT_SETP (RID_STATIC, specbits)))
7120 error ("multiple storage classes in declaration of `%s'", name);
7121 else if (decl_context != NORMAL && nclasses > 0)
7123 if ((decl_context == PARM || decl_context == CATCHPARM)
7124 && (RIDBIT_SETP (RID_REGISTER, specbits)
7125 || RIDBIT_SETP (RID_AUTO, specbits)))
7127 else if (RIDBIT_SETP (RID_TYPEDEF, specbits))
7129 else if (decl_context == FIELD
7130 /* C++ allows static class elements. */
7131 && RIDBIT_SETP (RID_STATIC, specbits))
7132 /* C++ also allows inlines and signed and unsigned elements,
7133 but in those cases we don't come in here. */
7137 if (decl_context == FIELD)
7139 tree tmp = NULL_TREE;
7144 /* Avoid trying to get an operand off an identifier node. */
7145 if (TREE_CODE (declarator) == IDENTIFIER_NODE)
7148 tmp = TREE_OPERAND (declarator, 0);
7149 op = IDENTIFIER_OPNAME_P (tmp);
7150 if (IDENTIFIER_TYPENAME_P (tmp))
7152 if (is_typename_at_global_scope (tmp))
7153 name = IDENTIFIER_POINTER (tmp);
7155 name = "<invalid operator>";
7158 error ("storage class specified for %s `%s'",
7159 op ? "member operator" : "field",
7164 if (decl_context == PARM || decl_context == CATCHPARM)
7165 error ("storage class specified for parameter `%s'", name);
7167 error ("storage class specified for typename");
7169 RIDBIT_RESET (RID_REGISTER, specbits);
7170 RIDBIT_RESET (RID_AUTO, specbits);
7171 RIDBIT_RESET (RID_EXTERN, specbits);
7172 RIDBIT_RESET (RID_THREAD, specbits);
7175 else if (RIDBIT_SETP (RID_EXTERN, specbits) && initialized && !funcdef_flag)
7177 if (toplevel_bindings_p ())
7179 /* It's common practice (and completely valid) to have a const
7180 be initialized and declared extern. */
7181 if (!(type_quals & TYPE_QUAL_CONST))
7182 warning ("`%s' initialized and declared `extern'", name);
7185 error ("`%s' has both `extern' and initializer", name);
7187 else if (RIDBIT_SETP (RID_EXTERN, specbits) && funcdef_flag
7188 && ! toplevel_bindings_p ())
7189 error ("nested function `%s' declared `extern'", name);
7190 else if (toplevel_bindings_p ())
7192 if (RIDBIT_SETP (RID_AUTO, specbits))
7193 error ("top-level declaration of `%s' specifies `auto'", name);
7195 else if (RIDBIT_SETP (RID_THREAD, specbits)
7196 && !RIDBIT_SETP (RID_EXTERN, specbits)
7197 && !RIDBIT_SETP (RID_STATIC, specbits))
7199 error ("function-scope `%s' implicitly auto and declared `__thread'",
7201 RIDBIT_RESET (RID_THREAD, specbits);
7204 if (nclasses > 0 && friendp)
7205 error ("storage class specifiers invalid in friend function declarations");
7207 scope = get_scope_of_declarator (declarator);
7209 /* Now figure out the structure of the declarator proper.
7210 Descend through it, creating more complex types, until we reach
7211 the declared identifier (or NULL_TREE, in an abstract declarator). */
7213 while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE
7214 && TREE_CODE (declarator) != TEMPLATE_ID_EXPR)
7216 /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
7217 an INDIRECT_REF (for *...),
7218 a CALL_EXPR (for ...(...)),
7219 an identifier (for the name being declared)
7220 or a null pointer (for the place in an absolute declarator
7221 where the name was omitted).
7222 For the last two cases, we have just exited the loop.
7224 For C++ it could also be
7225 a SCOPE_REF (for class :: ...). In this case, we have converted
7226 sensible names to types, and those are the values we use to
7227 qualify the member name.
7228 an ADDR_EXPR (for &...),
7229 a BIT_NOT_EXPR (for destructors)
7231 At this point, TYPE is the type of elements of an array,
7232 or for a function to return, or for a pointer to point to.
7233 After this sequence of ifs, TYPE is the type of the
7234 array or function or pointer, and DECLARATOR has had its
7235 outermost layer removed. */
7237 if (type == error_mark_node)
7239 if (declarator == error_mark_node)
7240 return error_mark_node;
7241 else if (TREE_CODE (declarator) == SCOPE_REF)
7242 declarator = TREE_OPERAND (declarator, 1);
7244 declarator = TREE_OPERAND (declarator, 0);
7247 if (quals != NULL_TREE
7248 && (declarator == NULL_TREE
7249 || TREE_CODE (declarator) != SCOPE_REF))
7251 if (ctype == NULL_TREE && TREE_CODE (type) == METHOD_TYPE)
7252 ctype = TYPE_METHOD_BASETYPE (type);
7253 if (ctype != NULL_TREE)
7255 tree dummy = build_decl (TYPE_DECL, NULL_TREE, type);
7256 grok_method_quals (ctype, dummy, quals);
7257 type = TREE_TYPE (dummy);
7262 switch (TREE_CODE (declarator))
7266 /* We encode a declarator with embedded attributes using
7268 tree attrs = TREE_PURPOSE (declarator);
7272 declarator = TREE_VALUE (declarator);
7273 inner_decl = declarator;
7274 while (inner_decl != NULL_TREE
7275 && TREE_CODE (inner_decl) == TREE_LIST)
7276 inner_decl = TREE_VALUE (inner_decl);
7278 if (inner_decl == NULL_TREE
7279 || TREE_CODE (inner_decl) == IDENTIFIER_NODE)
7280 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
7281 if (TREE_CODE (inner_decl) == CALL_EXPR)
7282 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
7283 if (TREE_CODE (inner_decl) == ARRAY_REF)
7284 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
7285 returned_attrs = decl_attributes (&type,
7286 chainon (returned_attrs, attrs),
7293 tree size = TREE_OPERAND (declarator, 1);
7294 declarator = TREE_OPERAND (declarator, 0);
7296 type = create_array_type_for_decl (dname, type, size);
7306 tree inner_parms = CALL_DECLARATOR_PARMS (declarator);
7307 tree inner_decl = TREE_OPERAND (declarator, 0);
7309 /* Declaring a function type.
7310 Make sure we have a valid type for the function to return. */
7312 /* We now know that the TYPE_QUALS don't apply to the
7313 decl, but to its return type. */
7314 type_quals = TYPE_UNQUALIFIED;
7316 /* Warn about some types functions can't return. */
7318 if (TREE_CODE (type) == FUNCTION_TYPE)
7320 error ("`%s' declared as function returning a function", name);
7321 type = integer_type_node;
7323 if (TREE_CODE (type) == ARRAY_TYPE)
7325 error ("`%s' declared as function returning an array", name);
7326 type = integer_type_node;
7329 if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF)
7330 inner_decl = TREE_OPERAND (inner_decl, 1);
7332 if (inner_decl && TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR)
7335 /* Pick up type qualifiers which should be applied to `this'. */
7336 quals = CALL_DECLARATOR_QUALS (declarator);
7338 /* Pick up the exception specifications. */
7339 raises = CALL_DECLARATOR_EXCEPTION_SPEC (declarator);
7341 /* Say it's a definition only for the CALL_EXPR
7342 closest to the identifier. */
7345 && (TREE_CODE (inner_decl) == IDENTIFIER_NODE
7346 || TREE_CODE (inner_decl) == TEMPLATE_ID_EXPR
7347 || TREE_CODE (inner_decl) == BIT_NOT_EXPR);
7349 if (ctype == NULL_TREE
7350 && decl_context == FIELD
7352 && (friendp == 0 || dname == current_class_name))
7353 ctype = current_class_type;
7355 if (ctype && sfk == sfk_conversion)
7356 TYPE_HAS_CONVERSION (ctype) = 1;
7357 if (ctype && constructor_name_p (dname, ctype))
7359 /* We are within a class's scope. If our declarator name
7360 is the same as the class name, and we are defining
7361 a function, then it is a constructor/destructor, and
7362 therefore returns a void type. */
7364 if (flags == DTOR_FLAG)
7366 /* ISO C++ 12.4/2. A destructor may not be
7367 declared const or volatile. A destructor may
7370 error ("destructor cannot be static member function");
7373 error ("destructors may not be `%s'",
7374 IDENTIFIER_POINTER (TREE_VALUE (quals)));
7377 if (decl_context == FIELD)
7379 if (! member_function_or_else (ctype,
7382 return void_type_node;
7385 else /* It's a constructor. */
7389 /* ISO C++ 12.1. A constructor may not be
7390 declared const or volatile. A constructor may
7391 not be virtual. A constructor may not be
7394 error ("constructor cannot be static member function");
7397 pedwarn ("constructors cannot be declared virtual");
7402 error ("constructors may not be `%s'",
7403 IDENTIFIER_POINTER (TREE_VALUE (quals)));
7407 RID_BIT_TYPE tmp_bits;
7408 memcpy (&tmp_bits, &specbits, sizeof (RID_BIT_TYPE));
7409 RIDBIT_RESET (RID_INLINE, tmp_bits);
7410 RIDBIT_RESET (RID_STATIC, tmp_bits);
7411 if (RIDBIT_ANY_SET (tmp_bits))
7412 error ("return value type specifier for constructor ignored");
7414 if (decl_context == FIELD)
7416 if (! member_function_or_else (ctype,
7419 return void_type_node;
7420 TYPE_HAS_CONSTRUCTOR (ctype) = 1;
7421 if (sfk != sfk_constructor)
7425 if (decl_context == FIELD)
7431 error ("can't initialize friend function `%s'", name);
7434 /* Cannot be both friend and virtual. */
7435 error ("virtual functions cannot be friends");
7436 RIDBIT_RESET (RID_FRIEND, specbits);
7439 if (decl_context == NORMAL)
7440 error ("friend declaration not in class definition");
7441 if (current_function_decl && funcdef_flag)
7442 error ("can't define friend function `%s' in a local class definition",
7446 /* Construct the function type and go to the next
7447 inner layer of declarator. */
7449 declarator = TREE_OPERAND (declarator, 0);
7451 arg_types = grokparms (inner_parms);
7453 if (declarator && flags == DTOR_FLAG)
7455 /* A destructor declared in the body of a class will
7456 be represented as a BIT_NOT_EXPR. But, we just
7457 want the underlying IDENTIFIER. */
7458 if (TREE_CODE (declarator) == BIT_NOT_EXPR)
7459 declarator = TREE_OPERAND (declarator, 0);
7461 if (arg_types != void_list_node)
7463 error ("destructors may not have parameters");
7464 arg_types = void_list_node;
7465 last_function_parms = NULL_TREE;
7469 /* ANSI says that `const int foo ();'
7470 does not make the function foo const. */
7471 type = build_function_type (type, arg_types);
7477 /* Filter out pointers-to-references and references-to-references.
7478 We can get these if a TYPE_DECL is used. */
7480 if (TREE_CODE (type) == REFERENCE_TYPE)
7482 error (TREE_CODE (declarator) == ADDR_EXPR
7483 ? "cannot declare reference to `%#T'"
7484 : "cannot declare pointer to `%#T'", type);
7485 type = TREE_TYPE (type);
7487 else if (VOID_TYPE_P (type)
7488 && (ctype || TREE_CODE (declarator) == ADDR_EXPR))
7489 error (ctype ? "cannot declare pointer to `%#T' member"
7490 : "cannot declare reference to `%#T'", type);
7492 /* Merge any constancy or volatility into the target type
7495 /* We now know that the TYPE_QUALS don't apply to the decl,
7496 but to the target of the pointer. */
7497 type_quals = TYPE_UNQUALIFIED;
7499 if (TREE_CODE (declarator) == ADDR_EXPR)
7501 if (!VOID_TYPE_P (type))
7502 type = build_reference_type (type);
7504 else if (TREE_CODE (type) == METHOD_TYPE)
7505 type = build_ptrmemfunc_type (build_pointer_type (type));
7507 type = build_ptrmem_type (ctype, type);
7509 type = build_pointer_type (type);
7511 /* Process a list of type modifier keywords (such as
7512 const or volatile) that were given inside the `*' or `&'. */
7514 if (TREE_TYPE (declarator))
7522 for (typemodlist = TREE_TYPE (declarator); typemodlist;
7523 typemodlist = TREE_CHAIN (typemodlist))
7525 tree qualifier = TREE_VALUE (typemodlist);
7527 if (qualifier == ridpointers[(int) RID_CONST])
7530 type_quals |= TYPE_QUAL_CONST;
7532 else if (qualifier == ridpointers[(int) RID_VOLATILE])
7535 type_quals |= TYPE_QUAL_VOLATILE;
7537 else if (qualifier == ridpointers[(int) RID_RESTRICT])
7540 type_quals |= TYPE_QUAL_RESTRICT;
7545 error ("invalid type modifier within pointer declarator");
7549 pedwarn ("duplicate `const'");
7551 pedwarn ("duplicate `volatile'");
7553 pedwarn ("duplicate `restrict'");
7554 type = cp_build_qualified_type (type, type_quals);
7555 type_quals = cp_type_quals (type);
7557 declarator = TREE_OPERAND (declarator, 0);
7563 /* We have converted type names to NULL_TREE if the
7564 name was bogus, or to a _TYPE node, if not.
7566 The variable CTYPE holds the type we will ultimately
7567 resolve to. The code here just needs to build
7568 up appropriate member types. */
7569 tree sname = TREE_OPERAND (declarator, 1);
7572 /* Destructors can have their visibilities changed as well. */
7573 if (TREE_CODE (sname) == BIT_NOT_EXPR)
7574 sname = TREE_OPERAND (sname, 0);
7576 if (TREE_OPERAND (declarator, 0) == NULL_TREE)
7578 /* We had a reference to a global decl, or
7579 perhaps we were given a non-aggregate typedef,
7580 in which case we cleared this out, and should just
7581 keep going as though it wasn't there. */
7585 ctype = TREE_OPERAND (declarator, 0);
7588 while (t != NULL_TREE && CLASS_TYPE_P (t))
7590 /* You're supposed to have one `template <...>'
7591 for every template class, but you don't need one
7592 for a full specialization. For example:
7594 template <class T> struct S{};
7595 template <> struct S<int> { void f(); };
7596 void S<int>::f () {}
7598 is correct; there shouldn't be a `template <>' for
7599 the definition of `S<int>::f'. */
7600 if (CLASSTYPE_TEMPLATE_INFO (t)
7601 && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
7602 || uses_template_parms (CLASSTYPE_TI_ARGS (t)))
7603 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
7604 template_count += 1;
7606 t = TYPE_MAIN_DECL (t);
7607 t = DECL_CONTEXT (t);
7610 if (sname == NULL_TREE)
7613 if (TREE_CODE (sname) == IDENTIFIER_NODE)
7615 /* This is the `standard' use of the scoping operator:
7616 basetype :: member . */
7618 if (ctype == current_class_type)
7624 Is this ill-formed? */
7627 pedwarn ("extra qualification `%T::' on member `%s' ignored",
7630 else if (TREE_CODE (type) == FUNCTION_TYPE)
7632 if (current_class_type == NULL_TREE || friendp)
7634 = build_method_type_directly (ctype,
7636 TYPE_ARG_TYPES (type));
7639 error ("cannot declare member function `%T::%s' within `%T'",
7640 ctype, name, current_class_type);
7641 return error_mark_node;
7644 else if (RIDBIT_SETP (RID_TYPEDEF, specbits)
7645 || COMPLETE_TYPE_P (complete_type (ctype)))
7647 /* Have to move this code elsewhere in this function.
7648 this code is used for i.e., typedef int A::M; M *pm;
7650 It is? How? jason 10/2/94 */
7652 if (current_class_type)
7654 error ("cannot declare member `%T::%s' within `%T'",
7655 ctype, name, current_class_type);
7656 return void_type_node;
7661 cxx_incomplete_type_error (NULL_TREE, ctype);
7662 return error_mark_node;
7667 else if (TREE_CODE (sname) == SCOPE_REF)
7672 declarator = TREE_OPERAND (declarator, 1);
7673 if (declarator && TREE_CODE (declarator) == CALL_EXPR)
7674 /* In this case, we will deal with it later. */
7676 else if (TREE_CODE (type) == FUNCTION_TYPE)
7677 type = build_method_type_directly (ctype,
7679 TYPE_ARG_TYPES (type));
7685 declarator = TREE_OPERAND (declarator, 0);
7689 declarator = BASELINK_FUNCTIONS (declarator);
7695 declarator = NULL_TREE;
7699 declarator = NULL_TREE;
7710 *attrlist = chainon (returned_attrs, *attrlist);
7712 attrlist = &returned_attrs;
7715 /* Now TYPE has the actual type. */
7717 /* Did array size calculations overflow? */
7719 if (TREE_CODE (type) == ARRAY_TYPE
7720 && COMPLETE_TYPE_P (type)
7721 && TREE_OVERFLOW (TYPE_SIZE (type)))
7723 error ("size of array `%s' is too large", name);
7724 /* If we proceed with the array type as it is, we'll eventually
7725 crash in tree_low_cst(). */
7726 type = error_mark_node;
7729 if ((decl_context == FIELD || decl_context == PARM)
7730 && !processing_template_decl
7731 && variably_modified_type_p (type))
7733 if (decl_context == FIELD)
7734 error ("data member may not have variably modified type `%T'", type);
7736 error ("parameter may not have variably modified type `%T'", type);
7737 type = error_mark_node;
7740 if (explicitp == 1 || (explicitp && friendp))
7742 /* [dcl.fct.spec] The explicit specifier shall only be used in
7743 declarations of constructors within a class definition. */
7744 error ("only declarations of constructors can be `explicit'");
7748 if (RIDBIT_SETP (RID_MUTABLE, specbits))
7750 if (decl_context != FIELD || friendp)
7752 error ("non-member `%s' cannot be declared `mutable'", name);
7753 RIDBIT_RESET (RID_MUTABLE, specbits);
7755 else if (decl_context == TYPENAME || RIDBIT_SETP (RID_TYPEDEF, specbits))
7757 error ("non-object member `%s' cannot be declared `mutable'", name);
7758 RIDBIT_RESET (RID_MUTABLE, specbits);
7760 else if (TREE_CODE (type) == FUNCTION_TYPE
7761 || TREE_CODE (type) == METHOD_TYPE)
7763 error ("function `%s' cannot be declared `mutable'", name);
7764 RIDBIT_RESET (RID_MUTABLE, specbits);
7768 error ("static `%s' cannot be declared `mutable'", name);
7769 RIDBIT_RESET (RID_MUTABLE, specbits);
7771 else if (type_quals & TYPE_QUAL_CONST)
7773 error ("const `%s' cannot be declared `mutable'", name);
7774 RIDBIT_RESET (RID_MUTABLE, specbits);
7778 if (declarator == NULL_TREE
7779 || TREE_CODE (declarator) == IDENTIFIER_NODE
7780 || (TREE_CODE (declarator) == TEMPLATE_ID_EXPR
7781 && (TREE_CODE (type) == FUNCTION_TYPE
7782 || TREE_CODE (type) == METHOD_TYPE)))
7784 else if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
7786 error ("template-id `%D' used as a declarator", declarator);
7790 /* Unexpected declarator format. */
7793 /* If this is declaring a typedef name, return a TYPE_DECL. */
7795 if (RIDBIT_SETP (RID_TYPEDEF, specbits) && decl_context != TYPENAME)
7799 /* Note that the grammar rejects storage classes
7800 in typenames, fields or parameters. */
7801 if (current_lang_name == lang_name_java)
7802 TYPE_FOR_JAVA (type) = 1;
7804 if (decl_context == FIELD)
7806 if (constructor_name_p (declarator, current_class_type))
7807 pedwarn ("ISO C++ forbids nested type `%D' with same name as enclosing class",
7809 decl = build_lang_decl (TYPE_DECL, declarator, type);
7813 decl = build_decl (TYPE_DECL, declarator, type);
7814 if (in_namespace || ctype)
7815 error ("%Jtypedef name may not be a nested-name-specifier", decl);
7816 if (!current_function_decl)
7817 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
7820 /* If the user declares "typedef struct {...} foo" then the
7821 struct will have an anonymous name. Fill that name in now.
7822 Nothing can refer to it, so nothing needs know about the name
7824 if (type != error_mark_node
7827 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7828 && TYPE_ANONYMOUS_P (type)
7829 /* Don't do this if there are attributes. */
7830 && (!attrlist || !*attrlist)
7831 && cp_type_quals (type) == TYPE_UNQUALIFIED)
7833 tree oldname = TYPE_NAME (type);
7836 /* Replace the anonymous name with the real name everywhere. */
7837 lookup_tag_reverse (type, declarator);
7838 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
7839 if (TYPE_NAME (t) == oldname)
7840 TYPE_NAME (t) = decl;
7842 if (TYPE_LANG_SPECIFIC (type))
7843 TYPE_WAS_ANONYMOUS (type) = 1;
7845 /* If this is a typedef within a template class, the nested
7846 type is a (non-primary) template. The name for the
7847 template needs updating as well. */
7848 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
7849 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
7850 = TYPE_IDENTIFIER (type);
7852 /* FIXME remangle member functions; member functions of a
7853 type with external linkage have external linkage. */
7858 if (ctype == NULL_TREE)
7860 if (TREE_CODE (type) != METHOD_TYPE)
7861 error ("%Jinvalid type qualifier for non-member function type",
7864 ctype = TYPE_METHOD_BASETYPE (type);
7866 if (ctype != NULL_TREE)
7867 grok_method_quals (ctype, decl, quals);
7870 if (RIDBIT_SETP (RID_SIGNED, specbits)
7871 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
7872 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
7874 bad_specifiers (decl, "type", virtualp, quals != NULL_TREE,
7875 inlinep, friendp, raises != NULL_TREE);
7880 /* Detect the case of an array type of unspecified size
7881 which came, as such, direct from a typedef name.
7882 We must copy the type, so that the array's domain can be
7883 individually set by the object's initializer. */
7885 if (type && typedef_type
7886 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
7887 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
7888 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
7890 /* Detect where we're using a typedef of function type to declare a
7891 function. last_function_parms will not be set, so we must create
7894 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
7896 tree decls = NULL_TREE;
7899 for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
7901 tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
7903 TREE_CHAIN (decl) = decls;
7907 last_function_parms = nreverse (decls);
7910 /* If this is a type name (such as, in a cast or sizeof),
7911 compute the type and return it now. */
7913 if (decl_context == TYPENAME)
7915 /* Note that the grammar rejects storage classes
7916 in typenames, fields or parameters. */
7917 if (type_quals != TYPE_UNQUALIFIED)
7918 type_quals = TYPE_UNQUALIFIED;
7920 /* Special case: "friend class foo" looks like a TYPENAME context. */
7923 if (type_quals != TYPE_UNQUALIFIED)
7925 error ("type qualifiers specified for friend class declaration");
7926 type_quals = TYPE_UNQUALIFIED;
7930 error ("`inline' specified for friend class declaration");
7936 /* Don't allow friend declaration without a class-key. */
7937 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
7938 pedwarn ("template parameters cannot be friends");
7939 else if (TREE_CODE (type) == TYPENAME_TYPE)
7940 pedwarn ("friend declaration requires class-key, "
7941 "i.e. `friend class %T::%D'",
7942 TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
7944 pedwarn ("friend declaration requires class-key, "
7945 "i.e. `friend %#T'",
7949 /* Only try to do this stuff if we didn't already give up. */
7950 if (type != integer_type_node)
7952 /* A friendly class? */
7953 if (current_class_type)
7954 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
7957 error ("trying to make class `%T' a friend of global scope",
7960 type = void_type_node;
7965 if (ctype == NULL_TREE)
7967 if (TREE_CODE (type) != METHOD_TYPE)
7968 error ("invalid qualifiers on non-member function type");
7970 ctype = TYPE_METHOD_BASETYPE (type);
7974 tree dummy = build_decl (TYPE_DECL, declarator, type);
7975 grok_method_quals (ctype, dummy, quals);
7976 type = TREE_TYPE (dummy);
7982 else if (declarator == NULL_TREE && decl_context != PARM
7983 && decl_context != CATCHPARM
7984 && TREE_CODE (type) != UNION_TYPE
7987 error ("abstract declarator `%T' used as declaration", type);
7988 declarator = make_anon_name ();
7991 /* `void' at top level (not within pointer)
7992 is allowed only in typedefs or type names.
7993 We don't complain about parms either, but that is because
7994 a better error message can be made later. */
7996 if (TREE_CODE (type) == VOID_TYPE && decl_context != PARM)
7999 error ("unnamed variable or field declared void");
8000 else if (TREE_CODE (declarator) == IDENTIFIER_NODE)
8002 if (IDENTIFIER_OPNAME_P (declarator))
8005 error ("variable or field `%s' declared void", name);
8008 error ("variable or field declared void");
8009 type = integer_type_node;
8012 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
8013 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
8015 if (decl_context == PARM || decl_context == CATCHPARM)
8017 if (ctype || in_namespace)
8018 error ("cannot use `::' in parameter declaration");
8020 /* A parameter declared as an array of T is really a pointer to T.
8021 One declared as a function is really a pointer to a function.
8022 One declared as a member is really a pointer to member. */
8024 if (TREE_CODE (type) == ARRAY_TYPE)
8026 /* Transfer const-ness of array into that of type pointed to. */
8027 type = build_pointer_type (TREE_TYPE (type));
8028 type_quals = TYPE_UNQUALIFIED;
8030 else if (TREE_CODE (type) == FUNCTION_TYPE)
8031 type = build_pointer_type (type);
8037 if (decl_context == PARM)
8039 decl = cp_build_parm_decl (declarator, type);
8041 bad_specifiers (decl, "parameter", virtualp, quals != NULL_TREE,
8042 inlinep, friendp, raises != NULL_TREE);
8044 else if (decl_context == FIELD)
8046 /* The C99 flexible array extension. */
8047 if (!staticp && TREE_CODE (type) == ARRAY_TYPE
8048 && TYPE_DOMAIN (type) == NULL_TREE)
8050 tree itype = compute_array_index_type (dname, integer_zero_node);
8051 type = build_cplus_array_type (TREE_TYPE (type), itype);
8054 if (type == error_mark_node)
8056 /* Happens when declaring arrays of sizes which
8057 are error_mark_node, for example. */
8060 else if (in_namespace && !friendp)
8062 /* Something like struct S { int N::j; }; */
8063 error ("invalid use of `::'");
8066 else if (TREE_CODE (type) == FUNCTION_TYPE)
8069 tree function_context;
8071 /* We catch the others as conflicts with the builtin
8073 if (friendp && declarator == ridpointers[(int) RID_SIGNED])
8075 error ("function `%D' cannot be declared friend",
8082 if (ctype == NULL_TREE)
8083 ctype = current_class_type;
8085 if (ctype == NULL_TREE)
8087 error ("can't make `%D' into a method -- not in a class",
8089 return void_type_node;
8092 /* ``A union may [ ... ] not [ have ] virtual functions.''
8094 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
8096 error ("function `%D' declared virtual inside a union",
8098 return void_type_node;
8101 if (declarator == ansi_opname (NEW_EXPR)
8102 || declarator == ansi_opname (VEC_NEW_EXPR)
8103 || declarator == ansi_opname (DELETE_EXPR)
8104 || declarator == ansi_opname (VEC_DELETE_EXPR))
8108 error ("`%D' cannot be declared virtual, since it is always static",
8113 else if (staticp < 2)
8114 type = build_method_type_directly (ctype,
8116 TYPE_ARG_TYPES (type));
8119 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
8120 function_context = (ctype != NULL_TREE) ?
8121 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
8122 publicp = (! friendp || ! staticp)
8123 && function_context == NULL_TREE;
8124 decl = grokfndecl (ctype, type,
8125 TREE_CODE (declarator) != TEMPLATE_ID_EXPR
8126 ? declarator : dname,
8128 virtualp, flags, quals, raises,
8129 friendp ? -1 : 0, friendp, publicp, inlinep,
8130 funcdef_flag, template_count, in_namespace);
8131 if (decl == NULL_TREE)
8134 /* This clobbers the attrs stored in `decl' from `attrlist'. */
8135 /* The decl and setting of decl_attr is also turned off. */
8136 decl = build_decl_attribute_variant (decl, decl_attr);
8139 /* [class.conv.ctor]
8141 A constructor declared without the function-specifier
8142 explicit that can be called with a single parameter
8143 specifies a conversion from the type of its first
8144 parameter to the type of its class. Such a constructor
8145 is called a converting constructor. */
8147 DECL_NONCONVERTING_P (decl) = 1;
8148 else if (DECL_CONSTRUCTOR_P (decl))
8150 /* The constructor can be called with exactly one
8151 parameter if there is at least one parameter, and
8152 any subsequent parameters have default arguments.
8153 Ignore any compiler-added parms. */
8154 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
8156 if (arg_types == void_list_node
8158 && TREE_CHAIN (arg_types)
8159 && TREE_CHAIN (arg_types) != void_list_node
8160 && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
8161 DECL_NONCONVERTING_P (decl) = 1;
8164 else if (TREE_CODE (type) == METHOD_TYPE)
8166 /* We only get here for friend declarations of
8167 members of other classes. */
8168 /* All method decls are public, so tell grokfndecl to set
8169 TREE_PUBLIC, also. */
8170 decl = grokfndecl (ctype, type,
8171 TREE_CODE (declarator) != TEMPLATE_ID_EXPR
8172 ? declarator : dname,
8174 virtualp, flags, quals, raises,
8175 friendp ? -1 : 0, friendp, 1, 0, funcdef_flag,
8176 template_count, in_namespace);
8177 if (decl == NULL_TREE)
8180 else if (!staticp && !dependent_type_p (type)
8181 && !COMPLETE_TYPE_P (complete_type (type))
8182 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
8185 error ("field `%D' has incomplete type", declarator);
8187 error ("name `%T' has incomplete type", type);
8189 /* If we're instantiating a template, tell them which
8190 instantiation made the field's type be incomplete. */
8191 if (current_class_type
8192 && TYPE_NAME (current_class_type)
8193 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
8194 && declspecs && TREE_VALUE (declspecs)
8195 && TREE_TYPE (TREE_VALUE (declspecs)) == type)
8196 error (" in instantiation of template `%T'",
8197 current_class_type);
8199 type = error_mark_node;
8206 error ("`%s' is neither function nor member function; cannot be declared friend",
8207 IDENTIFIER_POINTER (declarator));
8215 /* Friends are treated specially. */
8216 if (ctype == current_class_type)
8217 warning ("member functions are implicitly friends of their class");
8218 else if (decl && DECL_NAME (decl))
8220 if (template_class_depth (current_class_type) == 0)
8222 decl = check_explicit_specialization
8223 (declarator, decl, template_count,
8224 2 * (funcdef_flag != 0) + 4);
8225 if (decl == error_mark_node)
8226 return error_mark_node;
8229 decl = do_friend (ctype, declarator, decl,
8230 last_function_parms, *attrlist,
8231 flags, quals, funcdef_flag);
8235 return void_type_node;
8238 /* Structure field. It may not be a function, except for C++. */
8240 if (decl == NULL_TREE)
8246 /* An attempt is being made to initialize a non-static
8247 member. But, from [class.mem]:
8249 4 A member-declarator can contain a
8250 constant-initializer only if it declares a static
8251 member (_class.static_) of integral or enumeration
8252 type, see _class.static.data_.
8254 This used to be relatively common practice, but
8255 the rest of the compiler does not correctly
8256 handle the initialization unless the member is
8257 static so we make it static below. */
8258 pedwarn ("ISO C++ forbids initialization of member `%D'",
8260 pedwarn ("making `%D' static", declarator);
8264 if (uses_template_parms (type))
8265 /* We'll check at instantiation time. */
8267 else if (check_static_variable_definition (declarator,
8269 /* If we just return the declaration, crashes
8270 will sometimes occur. We therefore return
8271 void_type_node, as if this was a friend
8272 declaration, to cause callers to completely
8273 ignore this declaration. */
8274 return void_type_node;
8279 /* [class.mem] forbids static data members with the
8280 same name as the enclosing class. Non-static data
8281 members are checked in check_field_decls. */
8282 if (constructor_name_p (declarator, current_class_type))
8283 pedwarn ("ISO C++ forbids static data member `%D' with same name as enclosing class",
8286 /* C++ allows static class members. All other work
8287 for this is done by grokfield. */
8288 decl = build_lang_decl (VAR_DECL, declarator, type);
8289 TREE_STATIC (decl) = 1;
8290 /* In class context, 'static' means public access. */
8291 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl) = 1;
8295 decl = build_decl (FIELD_DECL, declarator, type);
8296 DECL_NONADDRESSABLE_P (decl) = bitfield;
8297 if (RIDBIT_SETP (RID_MUTABLE, specbits))
8299 DECL_MUTABLE_P (decl) = 1;
8300 RIDBIT_RESET (RID_MUTABLE, specbits);
8304 bad_specifiers (decl, "field", virtualp, quals != NULL_TREE,
8305 inlinep, friendp, raises != NULL_TREE);
8308 else if (TREE_CODE (type) == FUNCTION_TYPE
8309 || TREE_CODE (type) == METHOD_TYPE)
8317 if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
8318 original_name = dname;
8320 original_name = declarator;
8322 if (RIDBIT_SETP (RID_AUTO, specbits))
8323 error ("storage class `auto' invalid for function `%s'", name);
8324 else if (RIDBIT_SETP (RID_REGISTER, specbits))
8325 error ("storage class `register' invalid for function `%s'", name);
8326 else if (RIDBIT_SETP (RID_THREAD, specbits))
8327 error ("storage class `__thread' invalid for function `%s'", name);
8329 /* Function declaration not at top level.
8330 Storage classes other than `extern' are not allowed
8331 and `extern' makes no difference. */
8332 if (! toplevel_bindings_p ()
8333 && (RIDBIT_SETP (RID_STATIC, specbits)
8334 || RIDBIT_SETP (RID_INLINE, specbits))
8337 if (RIDBIT_SETP (RID_STATIC, specbits))
8338 pedwarn ("storage class `static' invalid for function `%s' declared out of global scope", name);
8340 pedwarn ("storage class `inline' invalid for function `%s' declared out of global scope", name);
8343 if (ctype == NULL_TREE)
8347 error ("virtual non-class function `%s'", name);
8351 else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2)
8352 type = build_method_type_directly (ctype,
8354 TYPE_ARG_TYPES (type));
8356 /* Record presence of `static'. */
8357 publicp = (ctype != NULL_TREE
8358 || RIDBIT_SETP (RID_EXTERN, specbits)
8359 || !RIDBIT_SETP (RID_STATIC, specbits));
8361 decl = grokfndecl (ctype, type, original_name, declarator,
8362 virtualp, flags, quals, raises,
8364 publicp, inlinep, funcdef_flag,
8365 template_count, in_namespace);
8366 if (decl == NULL_TREE)
8371 int invalid_static = 0;
8373 /* Don't allow a static member function in a class, and forbid
8374 declaring main to be static. */
8375 if (TREE_CODE (type) == METHOD_TYPE)
8377 pedwarn ("cannot declare member function `%D' to have static linkage", decl);
8380 else if (current_function_decl)
8382 /* FIXME need arm citation */
8383 error ("cannot declare static function inside another function");
8390 RIDBIT_RESET (RID_STATIC, specbits);
8396 /* It's a variable. */
8398 /* An uninitialized decl with `extern' is a reference. */
8399 decl = grokvardecl (type, declarator, &specbits,
8401 (type_quals & TYPE_QUAL_CONST) != 0,
8402 ctype ? ctype : in_namespace);
8403 bad_specifiers (decl, "variable", virtualp, quals != NULL_TREE,
8404 inlinep, friendp, raises != NULL_TREE);
8408 DECL_CONTEXT (decl) = ctype;
8411 pedwarn ("`static' may not be used when defining (as opposed to declaring) a static data member");
8413 RIDBIT_RESET (RID_STATIC, specbits);
8415 if (RIDBIT_SETP (RID_REGISTER, specbits) && TREE_STATIC (decl))
8417 error ("static member `%D' declared `register'", decl);
8418 RIDBIT_RESET (RID_REGISTER, specbits);
8420 if (RIDBIT_SETP (RID_EXTERN, specbits) && pedantic)
8422 pedwarn ("cannot explicitly declare member `%#D' to have extern linkage",
8424 RIDBIT_RESET (RID_EXTERN, specbits);
8429 my_friendly_assert (!RIDBIT_SETP (RID_MUTABLE, specbits), 19990927);
8431 /* Record `register' declaration for warnings on &
8432 and in case doing stupid register allocation. */
8434 if (RIDBIT_SETP (RID_REGISTER, specbits))
8435 DECL_REGISTER (decl) = 1;
8437 if (RIDBIT_SETP (RID_EXTERN, specbits))
8438 DECL_THIS_EXTERN (decl) = 1;
8440 if (RIDBIT_SETP (RID_STATIC, specbits))
8441 DECL_THIS_STATIC (decl) = 1;
8443 /* Record constancy and volatility. There's no need to do this
8444 when processing a template; we'll do this for the instantiated
8445 declaration based on the type of DECL. */
8446 if (!processing_template_decl)
8447 c_apply_type_quals_to_decl (type_quals, decl);
8453 /* Subroutine of start_function. Ensure that each of the parameter
8454 types (as listed in PARMS) is complete, as is required for a
8455 function definition. */
8458 require_complete_types_for_parms (tree parms)
8460 for (; parms; parms = TREE_CHAIN (parms))
8462 if (VOID_TYPE_P (TREE_TYPE (parms)))
8463 /* grokparms will have already issued an error. */
8464 TREE_TYPE (parms) = error_mark_node;
8465 else if (complete_type_or_else (TREE_TYPE (parms), parms))
8467 layout_decl (parms, 0);
8468 DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
8471 TREE_TYPE (parms) = error_mark_node;
8475 /* Returns nonzero if T is a local variable. */
8478 local_variable_p (tree t)
8480 if ((TREE_CODE (t) == VAR_DECL
8481 /* A VAR_DECL with a context that is a _TYPE is a static data
8483 && !TYPE_P (CP_DECL_CONTEXT (t))
8484 /* Any other non-local variable must be at namespace scope. */
8485 && !DECL_NAMESPACE_SCOPE_P (t))
8486 || (TREE_CODE (t) == PARM_DECL))
8492 /* Returns nonzero if T is an automatic local variable or a label.
8493 (These are the declarations that need to be remapped when the code
8494 containing them is duplicated.) */
8497 nonstatic_local_decl_p (tree t)
8499 return ((local_variable_p (t) && !TREE_STATIC (t))
8500 || TREE_CODE (t) == LABEL_DECL
8501 || TREE_CODE (t) == RESULT_DECL);
8504 /* Like local_variable_p, but suitable for use as a tree-walking
8508 local_variable_p_walkfn (tree* tp,
8509 int* walk_subtrees ATTRIBUTE_UNUSED ,
8510 void* data ATTRIBUTE_UNUSED )
8512 return ((local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
8516 /* Check that ARG, which is a default-argument expression for a
8517 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
8518 something goes wrong. DECL may also be a _TYPE node, rather than a
8519 DECL, if there is no DECL available. */
8522 check_default_argument (tree decl, tree arg)
8527 if (TREE_CODE (arg) == DEFAULT_ARG)
8528 /* We get a DEFAULT_ARG when looking at an in-class declaration
8529 with a default argument. Ignore the argument for now; we'll
8530 deal with it after the class is complete. */
8533 if (processing_template_decl || uses_template_parms (arg))
8534 /* We don't do anything checking until instantiation-time. Note
8535 that there may be uninstantiated arguments even for an
8536 instantiated function, since default arguments are not
8537 instantiated until they are needed. */
8546 decl_type = TREE_TYPE (decl);
8548 if (arg == error_mark_node
8549 || decl == error_mark_node
8550 || TREE_TYPE (arg) == error_mark_node
8551 || decl_type == error_mark_node)
8552 /* Something already went wrong. There's no need to check
8554 return error_mark_node;
8556 /* [dcl.fct.default]
8558 A default argument expression is implicitly converted to the
8560 if (!TREE_TYPE (arg)
8561 || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
8564 error ("default argument for `%#D' has type `%T'",
8565 decl, TREE_TYPE (arg));
8567 error ("default argument for parameter of type `%T' has type `%T'",
8568 decl_type, TREE_TYPE (arg));
8570 return error_mark_node;
8573 /* [dcl.fct.default]
8575 Local variables shall not be used in default argument
8578 The keyword `this' shall not be used in a default argument of a
8580 var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
8584 error ("default argument `%E' uses local variable `%D'",
8586 return error_mark_node;
8593 /* Decode the list of parameter types for a function type.
8594 Given the list of things declared inside the parens,
8595 return a list of types.
8597 We determine whether ellipsis parms are used by PARMLIST_ELLIPSIS_P
8598 flag. If unset, we append void_list_node. A parmlist declared
8599 as `(void)' is accepted as the empty parmlist.
8601 Also set last_function_parms to the chain of PARM_DECLs. */
8604 grokparms (tree first_parm)
8606 tree result = NULL_TREE;
8607 tree decls = NULL_TREE;
8608 int ellipsis = !first_parm || PARMLIST_ELLIPSIS_P (first_parm);
8612 my_friendly_assert (!first_parm || TREE_PARMLIST (first_parm), 20001115);
8614 for (parm = first_parm; parm != NULL_TREE; parm = chain)
8616 tree type = NULL_TREE;
8617 tree decl = TREE_VALUE (parm);
8618 tree init = TREE_PURPOSE (parm);
8621 chain = TREE_CHAIN (parm);
8622 /* @@ weak defense against parse errors. */
8623 if (TREE_CODE (decl) != VOID_TYPE
8624 && TREE_CODE (decl) != TREE_LIST)
8626 /* Give various messages as the need arises. */
8627 if (TREE_CODE (decl) == STRING_CST)
8628 error ("invalid string constant `%E'", decl);
8629 else if (TREE_CODE (decl) == INTEGER_CST)
8630 error ("invalid integer constant in parameter list, did you forget to give parameter name?");
8634 if (parm == void_list_node)
8637 split_specs_attrs (TREE_PURPOSE (decl), &specs, &attrs);
8638 decl = grokdeclarator (TREE_VALUE (decl), specs,
8639 PARM, init != NULL_TREE, &attrs);
8640 if (! decl || TREE_TYPE (decl) == error_mark_node)
8644 cplus_decl_attributes (&decl, attrs, 0);
8646 type = TREE_TYPE (decl);
8647 if (VOID_TYPE_P (type))
8649 if (same_type_p (type, void_type_node)
8650 && !DECL_NAME (decl) && !result && !chain && !ellipsis)
8651 /* this is a parmlist of `(void)', which is ok. */
8653 cxx_incomplete_type_error (decl, type);
8654 /* It's not a good idea to actually create parameters of
8655 type `void'; other parts of the compiler assume that a
8656 void type terminates the parameter list. */
8657 type = error_mark_node;
8658 TREE_TYPE (decl) = error_mark_node;
8661 if (type != error_mark_node)
8663 /* Top-level qualifiers on the parameters are
8664 ignored for function types. */
8665 type = cp_build_qualified_type (type, 0);
8666 if (TREE_CODE (type) == METHOD_TYPE)
8668 error ("parameter `%D' invalidly declared method type", decl);
8669 type = build_pointer_type (type);
8670 TREE_TYPE (decl) = type;
8672 else if (abstract_virtuals_error (decl, type))
8673 any_error = 1; /* Seems like a good idea. */
8674 else if (POINTER_TYPE_P (type))
8676 /* [dcl.fct]/6, parameter types cannot contain pointers
8677 (references) to arrays of unknown bound. */
8678 tree t = TREE_TYPE (type);
8679 int ptr = TYPE_PTR_P (type);
8685 else if (TREE_CODE (t) != ARRAY_TYPE)
8687 else if (!TYPE_DOMAIN (t))
8691 if (TREE_CODE (t) == ARRAY_TYPE)
8692 error ("parameter `%D' includes %s to array of unknown bound `%T'",
8693 decl, ptr ? "pointer" : "reference", t);
8696 if (!any_error && init)
8697 init = check_default_argument (decl, init);
8702 TREE_CHAIN (decl) = decls;
8704 result = tree_cons (init, type, result);
8706 decls = nreverse (decls);
8707 result = nreverse (result);
8709 result = chainon (result, void_list_node);
8710 last_function_parms = decls;
8716 /* D is a constructor or overloaded `operator='.
8718 Let T be the class in which D is declared. Then, this function
8721 -1 if D's is an ill-formed constructor or copy assignment operator
8722 whose first parameter is of type `T'.
8723 0 if D is not a copy constructor or copy assignment
8725 1 if D is a copy constructor or copy assignment operator whose
8726 first parameter is a reference to const qualified T.
8727 2 if D is a copy constructor or copy assignment operator whose
8728 first parameter is a reference to non-const qualified T.
8730 This function can be used as a predicate. Positive values indicate
8731 a copy constructor and nonzero values indicate a copy assignment
8741 my_friendly_assert (DECL_FUNCTION_MEMBER_P (d), 20011208);
8743 if (DECL_TEMPLATE_INFO (d) && is_member_template (DECL_TI_TEMPLATE (d)))
8744 /* Instantiations of template member functions are never copy
8745 functions. Note that member functions of templated classes are
8746 represented as template functions internally, and we must
8747 accept those as copy functions. */
8750 args = FUNCTION_FIRST_USER_PARMTYPE (d);
8754 arg_type = TREE_VALUE (args);
8756 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
8758 /* Pass by value copy assignment operator. */
8761 else if (TREE_CODE (arg_type) == REFERENCE_TYPE
8762 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
8764 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
8770 args = TREE_CHAIN (args);
8772 if (args && args != void_list_node && !TREE_PURPOSE (args))
8773 /* There are more non-optional args. */
8779 /* Remember any special properties of member function DECL. */
8781 void grok_special_member_properties (tree decl)
8783 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P(decl))
8784 ; /* Not special. */
8785 else if (DECL_CONSTRUCTOR_P (decl))
8787 int ctor = copy_fn_p (decl);
8793 A non-template constructor for class X is a copy
8794 constructor if its first parameter is of type X&, const
8795 X&, volatile X& or const volatile X&, and either there
8796 are no other parameters or else all other parameters have
8797 default arguments. */
8798 TYPE_HAS_INIT_REF (DECL_CONTEXT (decl)) = 1;
8800 TYPE_HAS_CONST_INIT_REF (DECL_CONTEXT (decl)) = 1;
8802 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
8803 TYPE_HAS_DEFAULT_CONSTRUCTOR (DECL_CONTEXT (decl)) = 1;
8805 else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
8809 A non-template assignment operator for class X is a copy
8810 assignment operator if its parameter is of type X, X&, const
8811 X&, volatile X& or const volatile X&. */
8813 int assop = copy_fn_p (decl);
8817 TYPE_HAS_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
8819 TYPE_HAS_CONST_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
8820 if (DECL_PURE_VIRTUAL_P (decl))
8821 TYPE_HAS_ABSTRACT_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
8826 /* Check a constructor DECL has the correct form. Complains
8827 if the class has a constructor of the form X(X). */
8830 grok_ctor_properties (tree ctype, tree decl)
8832 int ctor_parm = copy_fn_p (decl);
8838 A declaration of a constructor for a class X is ill-formed if
8839 its first parameter is of type (optionally cv-qualified) X
8840 and either there are no other parameters or else all other
8841 parameters have default arguments.
8843 We *don't* complain about member template instantiations that
8844 have this form, though; they can occur as we try to decide
8845 what constructor to use during overload resolution. Since
8846 overload resolution will never prefer such a constructor to
8847 the non-template copy constructor (which is either explicitly
8848 or implicitly defined), there's no need to worry about their
8849 existence. Theoretically, they should never even be
8850 instantiated, but that's hard to forestall. */
8851 error ("invalid constructor; you probably meant `%T (const %T&)'",
8853 SET_IDENTIFIER_ERROR_LOCUS (DECL_NAME (decl), ctype);
8860 /* An operator with this code is unary, but can also be binary. */
8863 ambi_op_p (enum tree_code code)
8865 return (code == INDIRECT_REF
8866 || code == ADDR_EXPR
8867 || code == CONVERT_EXPR
8868 || code == NEGATE_EXPR
8869 || code == PREINCREMENT_EXPR
8870 || code == PREDECREMENT_EXPR);
8873 /* An operator with this name can only be unary. */
8876 unary_op_p (enum tree_code code)
8878 return (code == TRUTH_NOT_EXPR
8879 || code == BIT_NOT_EXPR
8880 || code == COMPONENT_REF
8881 || code == TYPE_EXPR);
8884 /* DECL is a declaration for an overloaded operator. Returns true if
8885 the declaration is valid; false otherwise. If COMPLAIN is true,
8886 errors are issued for invalid declarations. */
8889 grok_op_properties (tree decl, int friendp, bool complain)
8891 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
8893 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
8894 tree name = DECL_NAME (decl);
8895 enum tree_code operator_code;
8899 /* Assume that the declaration is valid. */
8902 /* Count the number of arguments. */
8903 for (argtype = argtypes, arity = 0;
8904 argtype && argtype != void_list_node;
8905 argtype = TREE_CHAIN (argtype))
8908 if (current_class_type == NULL_TREE)
8911 if (DECL_CONV_FN_P (decl))
8912 operator_code = TYPE_EXPR;
8916 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
8917 if (ansi_opname (CODE) == name) \
8919 operator_code = (CODE); \
8922 else if (ansi_assopname (CODE) == name) \
8924 operator_code = (CODE); \
8925 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
8929 #include "operators.def"
8935 my_friendly_assert (operator_code != LAST_CPLUS_TREE_CODE, 20000526);
8936 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
8940 switch (operator_code)
8943 TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
8947 TYPE_GETS_DELETE (current_class_type) |= 1;
8951 TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
8954 case VEC_DELETE_EXPR:
8955 TYPE_GETS_DELETE (current_class_type) |= 2;
8963 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
8965 /* When the compiler encounters the definition of A::operator new, it
8966 doesn't look at the class declaration to find out if it's static. */
8968 revert_static_member_fn (decl);
8970 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
8972 else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
8975 revert_static_member_fn (decl);
8977 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
8981 /* An operator function must either be a non-static member function
8982 or have at least one parameter of a class, a reference to a class,
8983 an enumeration, or a reference to an enumeration. 13.4.0.6 */
8984 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
8986 if (operator_code == TYPE_EXPR
8987 || operator_code == CALL_EXPR
8988 || operator_code == COMPONENT_REF
8989 || operator_code == ARRAY_REF
8990 || operator_code == NOP_EXPR)
8991 error ("`%D' must be a nonstatic member function", decl);
8996 if (DECL_STATIC_FUNCTION_P (decl))
8997 error ("`%D' must be either a non-static member function or a non-member function", decl);
8999 for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
9001 tree arg = non_reference (TREE_VALUE (p));
9002 /* IS_AGGR_TYPE, rather than CLASS_TYPE_P, is used
9003 because these checks are performed even on
9004 template functions. */
9005 if (IS_AGGR_TYPE (arg) || TREE_CODE (arg) == ENUMERAL_TYPE)
9009 if (!p || p == void_list_node)
9014 error ("`%D' must have an argument of class or "
9022 /* There are no restrictions on the arguments to an overloaded
9024 if (operator_code == CALL_EXPR)
9027 if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
9029 tree t = TREE_TYPE (name);
9032 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
9033 const char *what = 0;
9036 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
9038 if (TREE_CODE (t) == VOID_TYPE)
9040 else if (t == current_class_type)
9041 what = "the same type";
9042 /* Don't force t to be complete here. */
9043 else if (IS_AGGR_TYPE (t)
9044 && COMPLETE_TYPE_P (t)
9045 && DERIVED_FROM_P (t, current_class_type))
9046 what = "a base class";
9048 if (what && warn_conversion)
9049 warning ("conversion to %s%s will never use a type conversion operator",
9050 ref ? "a reference to " : "", what);
9053 if (operator_code == COND_EXPR)
9056 error ("ISO C++ prohibits overloading operator ?:");
9058 else if (ambi_op_p (operator_code))
9061 /* We pick the one-argument operator codes by default, so
9062 we don't have to change anything. */
9064 else if (arity == 2)
9066 /* If we thought this was a unary operator, we now know
9067 it to be a binary operator. */
9068 switch (operator_code)
9071 operator_code = MULT_EXPR;
9075 operator_code = BIT_AND_EXPR;
9079 operator_code = PLUS_EXPR;
9083 operator_code = MINUS_EXPR;
9086 case PREINCREMENT_EXPR:
9087 operator_code = POSTINCREMENT_EXPR;
9090 case PREDECREMENT_EXPR:
9091 operator_code = POSTDECREMENT_EXPR;
9098 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
9100 if ((operator_code == POSTINCREMENT_EXPR
9101 || operator_code == POSTDECREMENT_EXPR)
9102 && ! processing_template_decl
9103 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
9106 error ("postfix `%D' must take `int' as its argument",
9110 ("postfix `%D' must take `int' as its second argument",
9117 error ("`%D' must take either zero or one argument", decl);
9119 error ("`%D' must take either one or two arguments", decl);
9122 /* More Effective C++ rule 6. */
9124 && (operator_code == POSTINCREMENT_EXPR
9125 || operator_code == POSTDECREMENT_EXPR
9126 || operator_code == PREINCREMENT_EXPR
9127 || operator_code == PREDECREMENT_EXPR))
9129 tree arg = TREE_VALUE (argtypes);
9130 tree ret = TREE_TYPE (TREE_TYPE (decl));
9131 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
9132 arg = TREE_TYPE (arg);
9133 arg = TYPE_MAIN_VARIANT (arg);
9134 if (operator_code == PREINCREMENT_EXPR
9135 || operator_code == PREDECREMENT_EXPR)
9137 if (TREE_CODE (ret) != REFERENCE_TYPE
9138 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
9140 warning ("prefix `%D' should return `%T'", decl,
9141 build_reference_type (arg));
9145 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
9146 warning ("postfix `%D' should return `%T'", decl, arg);
9150 else if (unary_op_p (operator_code))
9155 error ("`%D' must take `void'", decl);
9157 error ("`%D' must take exactly one argument", decl);
9160 else /* if (binary_op_p (operator_code)) */
9165 error ("`%D' must take exactly one argument", decl);
9167 error ("`%D' must take exactly two arguments", decl);
9170 /* More Effective C++ rule 7. */
9172 && (operator_code == TRUTH_ANDIF_EXPR
9173 || operator_code == TRUTH_ORIF_EXPR
9174 || operator_code == COMPOUND_EXPR))
9175 warning ("user-defined `%D' always evaluates both arguments",
9179 /* Effective C++ rule 23. */
9182 && !DECL_ASSIGNMENT_OPERATOR_P (decl)
9183 && (operator_code == PLUS_EXPR
9184 || operator_code == MINUS_EXPR
9185 || operator_code == TRUNC_DIV_EXPR
9186 || operator_code == MULT_EXPR
9187 || operator_code == TRUNC_MOD_EXPR)
9188 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
9189 warning ("`%D' should return by value", decl);
9192 for (; argtypes && argtypes != void_list_node;
9193 argtypes = TREE_CHAIN (argtypes))
9194 if (TREE_PURPOSE (argtypes))
9196 TREE_PURPOSE (argtypes) = NULL_TREE;
9197 if (operator_code == POSTINCREMENT_EXPR
9198 || operator_code == POSTDECREMENT_EXPR)
9201 pedwarn ("`%D' cannot have default arguments", decl);
9204 error ("`%D' cannot have default arguments", decl);
9213 tag_name (enum tag_types code)
9230 /* Name lookup in an elaborated-type-specifier (after the keyword
9231 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
9232 elaborated-type-specifier is invalid, issue a diagnostic and return
9233 error_mark_node; otherwise, return the *_TYPE to which it referred.
9234 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
9237 check_elaborated_type_specifier (enum tag_types tag_code,
9239 bool allow_template_p)
9245 struct S { struct S *p; };
9247 name lookup will find the TYPE_DECL for the implicit "S::S"
9248 typedef. Adjust for that here. */
9249 if (DECL_SELF_REFERENCE_P (decl))
9250 decl = TYPE_NAME (TREE_TYPE (decl));
9252 type = TREE_TYPE (decl);
9256 If the identifier resolves to a typedef-name or a template
9257 type-parameter, the elaborated-type-specifier is ill-formed.
9259 In other words, the only legitimate declaration to use in the
9260 elaborated type specifier is the implicit typedef created when
9261 the type is declared. */
9262 if (!DECL_IMPLICIT_TYPEDEF_P (decl))
9264 error ("using typedef-name `%D' after `%s'", decl, tag_name (tag_code));
9265 return IS_AGGR_TYPE (type) ? type : error_mark_node;
9268 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
9270 error ("using template type parameter `%T' after `%s'",
9271 type, tag_name (tag_code));
9272 return error_mark_node;
9274 else if (TREE_CODE (type) != RECORD_TYPE
9275 && TREE_CODE (type) != UNION_TYPE
9276 && tag_code != enum_type)
9278 error ("`%T' referred to as `%s'", type, tag_name (tag_code));
9279 return error_mark_node;
9281 else if (TREE_CODE (type) != ENUMERAL_TYPE
9282 && tag_code == enum_type)
9284 error ("`%T' referred to as enum", type);
9285 return error_mark_node;
9287 else if (!allow_template_p
9288 && TREE_CODE (type) == RECORD_TYPE
9289 && CLASSTYPE_IS_TEMPLATE (type))
9291 /* If a class template appears as elaborated type specifier
9292 without a template header such as:
9294 template <class T> class C {};
9295 void f(class C); // No template header here
9297 then the required template argument is missing. */
9299 error ("template argument required for `%s %T'",
9300 tag_name (tag_code),
9301 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
9302 return error_mark_node;
9308 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
9309 Define the tag as a forward-reference if it is not defined.
9311 If a declaration is given, process it here, and report an error if
9312 multiple declarations are not identical. ATTRIBUTE is the attribute
9313 appeared in this declaration.
9315 GLOBALIZE is false when this is also a definition. Only look in
9316 the current frame for the name (since C++ allows new names in any
9319 TEMPLATE_HEADER_P is true when this declaration is preceded by
9320 a set of template parameters. */
9323 xref_tag (enum tag_types tag_code, tree name, tree attributes,
9324 bool globalize, bool template_header_p)
9326 enum tree_code code;
9328 struct cp_binding_level *b = current_binding_level;
9329 tree context = NULL_TREE;
9331 timevar_push (TV_NAME_LOOKUP);
9333 my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 0);
9345 code = ENUMERAL_TYPE;
9353 /* If we know we are defining this tag, only look it up in
9354 this scope and don't try to find it as a type. */
9355 t = lookup_tag (code, name, b, 1);
9359 tree decl = lookup_name (name, 1);
9361 if (decl && DECL_CLASS_TEMPLATE_P (decl))
9362 decl = DECL_TEMPLATE_RESULT (decl);
9364 if (decl && TREE_CODE (decl) == TYPE_DECL)
9366 /* Two cases we need to consider when deciding if a class
9367 template is allowed as an elaborated type specifier:
9368 1. It is a self reference to its own class.
9369 2. It comes with a template header.
9373 template <class T> class C {
9374 class C *c1; // DECL_SELF_REFERENCE_P is true
9377 template <class U> class C; // template_header_p is true
9378 template <class T> class C<T>::D {
9379 class C *c2; // DECL_SELF_REFERENCE_P is true
9382 t = check_elaborated_type_specifier (tag_code,
9385 | DECL_SELF_REFERENCE_P (decl));
9386 if (t == error_mark_node)
9387 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
9392 if (t && current_class_type
9393 && template_class_depth (current_class_type)
9394 && template_header_p)
9396 /* Since GLOBALIZE is nonzero, we are not looking at a
9397 definition of this tag. Since, in addition, we are currently
9398 processing a (member) template declaration of a template
9399 class, we must be very careful; consider:
9406 { template <class V>
9407 friend struct S1; };
9409 Here, the S2::S1 declaration should not be confused with the
9410 outer declaration. In particular, the inner version should
9411 have a template parameter of level 2, not level 1. This
9412 would be particularly important if the member declaration
9415 template <class V = U> friend struct S1;
9417 say, when we should tsubst into `U' when instantiating
9418 S2. On the other hand, when presented with:
9428 we must find the inner binding eventually. We
9429 accomplish this by making sure that the new type we
9430 create to represent this declaration has the right
9432 context = TYPE_CONTEXT (t);
9439 /* If no such tag is yet defined, create a forward-reference node
9440 and record it as the "definition".
9441 When a real declaration of this type is found,
9442 the forward-reference will be altered into a real type. */
9443 if (code == ENUMERAL_TYPE)
9445 error ("use of enum `%#D' without previous declaration", name);
9447 t = make_node (ENUMERAL_TYPE);
9449 /* Give the type a default layout like unsigned int
9450 to avoid crashing if it does not get defined. */
9451 TYPE_MODE (t) = TYPE_MODE (unsigned_type_node);
9452 TYPE_ALIGN (t) = TYPE_ALIGN (unsigned_type_node);
9453 TYPE_USER_ALIGN (t) = 0;
9454 TREE_UNSIGNED (t) = 1;
9455 TYPE_PRECISION (t) = TYPE_PRECISION (unsigned_type_node);
9456 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (unsigned_type_node);
9457 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (unsigned_type_node);
9459 /* Enable us to recognize when a type is created in class context.
9460 To do nested classes correctly, this should probably be cleared
9461 out when we leave this classes scope. Currently this in only
9462 done in `start_enum'. */
9464 pushtag (name, t, globalize);
9468 t = make_aggr_type (code);
9469 TYPE_CONTEXT (t) = context;
9470 pushtag (name, t, globalize);
9475 if (!globalize && processing_template_decl && IS_AGGR_TYPE (t))
9476 redeclare_class_template (t, current_template_parms);
9479 /* Add attributes only when defining a class. */
9482 /* The only place that xref_tag is called with non-null
9483 attributes is in cp_parser_class_head(), when defining a
9485 my_friendly_assert (TYPE_ATTRIBUTES (t) == NULL_TREE, 20040113);
9486 TYPE_ATTRIBUTES (t) = attributes;
9489 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
9493 xref_tag_from_type (tree old, tree id, int globalize)
9495 enum tag_types tag_kind;
9497 if (TREE_CODE (old) == RECORD_TYPE)
9498 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
9500 tag_kind = union_type;
9502 if (id == NULL_TREE)
9503 id = TYPE_IDENTIFIER (old);
9505 return xref_tag (tag_kind, id, /*attributes=*/NULL_TREE, globalize, false);
9508 /* REF is a type (named NAME), for which we have just seen some
9509 baseclasses. BASE_LIST is a list of those baseclasses; the
9510 TREE_PURPOSE is an access_* node, and the TREE_VALUE is the type of
9511 the base-class. TREE_VIA_VIRTUAL indicates virtual
9512 inheritance. CODE_TYPE_NODE indicates whether REF is a class,
9513 struct, or union. */
9516 xref_basetypes (tree ref, tree base_list)
9518 /* In the declaration `A : X, Y, ... Z' we mark all the types
9519 (A, X, Y, ..., Z) so we can check for duplicates. */
9523 enum tag_types tag_code;
9525 if (ref == error_mark_node)
9528 if (TREE_CODE (ref) == UNION_TYPE)
9530 error ("derived union `%T' invalid", ref);
9534 tag_code = (CLASSTYPE_DECLARED_CLASS (ref) ? class_type : record_type);
9536 /* First, make sure that any templates in base-classes are
9537 instantiated. This ensures that if we call ourselves recursively
9538 we do not get confused about which classes are marked and which
9543 tree basetype = TREE_VALUE (*basep);
9544 if (!(processing_template_decl && uses_template_parms (basetype))
9545 && !complete_type_or_else (basetype, NULL))
9546 /* An incomplete type. Remove it from the list. */
9547 *basep = TREE_CHAIN (*basep);
9549 basep = &TREE_CHAIN (*basep);
9552 SET_CLASSTYPE_MARKED (ref);
9553 i = list_length (base_list);
9556 tree binfo = TYPE_BINFO (ref);
9557 tree binfos = make_tree_vec (i);
9558 tree accesses = make_tree_vec (i);
9560 BINFO_BASETYPES (binfo) = binfos;
9561 BINFO_BASEACCESSES (binfo) = accesses;
9563 for (i = 0; base_list; base_list = TREE_CHAIN (base_list))
9565 tree access = TREE_PURPOSE (base_list);
9566 int via_virtual = TREE_VIA_VIRTUAL (base_list);
9567 tree basetype = TREE_VALUE (base_list);
9570 if (access == access_default_node)
9571 /* The base of a derived struct is public by default. */
9572 access = (tag_code == class_type
9573 ? access_private_node : access_public_node);
9575 if (basetype && TREE_CODE (basetype) == TYPE_DECL)
9576 basetype = TREE_TYPE (basetype);
9578 || (TREE_CODE (basetype) != RECORD_TYPE
9579 && TREE_CODE (basetype) != TYPENAME_TYPE
9580 && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
9581 && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))
9583 error ("base type `%T' fails to be a struct or class type",
9588 if (CLASSTYPE_MARKED (basetype))
9590 if (basetype == ref)
9591 error ("recursive type `%T' undefined", basetype);
9593 error ("duplicate base type `%T' invalid", basetype);
9597 if (TYPE_FOR_JAVA (basetype)
9598 && (current_lang_depth () == 0))
9599 TYPE_FOR_JAVA (ref) = 1;
9601 if (CLASS_TYPE_P (basetype))
9603 base_binfo = TYPE_BINFO (basetype);
9604 /* This flag will be in the binfo of the base type, we must
9605 clear it after copying the base binfos. */
9606 BINFO_DEPENDENT_BASE_P (base_binfo)
9607 = dependent_type_p (basetype);
9610 base_binfo = make_binfo (size_zero_node, basetype,
9611 NULL_TREE, NULL_TREE);
9613 TREE_VEC_ELT (binfos, i) = base_binfo;
9614 TREE_VEC_ELT (accesses, i) = access;
9615 /* This flag will be in the binfo of the base type, we must
9616 clear it after copying the base binfos. */
9617 TREE_VIA_VIRTUAL (base_binfo) = via_virtual;
9619 SET_CLASSTYPE_MARKED (basetype);
9621 /* We are free to modify these bits because they are meaningless
9622 at top level, and BASETYPE is a top-level type. */
9623 if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))
9625 TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;
9626 /* Converting to a virtual base class requires looking
9627 up the offset of the virtual base. */
9628 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
9631 if (CLASS_TYPE_P (basetype))
9633 TYPE_HAS_NEW_OPERATOR (ref)
9634 |= TYPE_HAS_NEW_OPERATOR (basetype);
9635 TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
9636 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
9637 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
9638 /* If the base-class uses multiple inheritance, so do we. */
9639 TYPE_USES_MULTIPLE_INHERITANCE (ref)
9640 |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);
9641 /* Likewise, if converting to a base of the base may require
9642 code, then we may need to generate code to convert to a
9644 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)
9645 |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);
9650 TREE_VEC_LENGTH (accesses) = TREE_VEC_LENGTH (binfos) = i;
9652 BINFO_BASEACCESSES (binfo) = BINFO_BASETYPES (binfo) = NULL_TREE;
9656 TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;
9657 /* If there is more than one non-empty they cannot be at the same
9659 TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;
9663 /* Copy the base binfos, collect the virtual bases and set the
9664 inheritance order chain. */
9665 copy_base_binfos (TYPE_BINFO (ref), ref, NULL_TREE);
9666 CLASSTYPE_VBASECLASSES (ref) = nreverse (CLASSTYPE_VBASECLASSES (ref));
9668 if (TYPE_FOR_JAVA (ref))
9670 if (TYPE_USES_MULTIPLE_INHERITANCE (ref))
9671 error ("Java class '%T' cannot have multiple bases", ref);
9672 if (CLASSTYPE_VBASECLASSES (ref))
9673 error ("Java class '%T' cannot have virtual bases", ref);
9676 /* Unmark all the types. */
9679 tree basetype = BINFO_TYPE (BINFO_BASETYPE (TYPE_BINFO (ref), i));
9681 CLEAR_CLASSTYPE_MARKED (basetype);
9682 if (CLASS_TYPE_P (basetype))
9684 TREE_VIA_VIRTUAL (TYPE_BINFO (basetype)) = 0;
9685 BINFO_DEPENDENT_BASE_P (TYPE_BINFO (basetype)) = 0;
9688 CLEAR_CLASSTYPE_MARKED (ref);
9692 /* Begin compiling the definition of an enumeration type.
9693 NAME is its name (or null if anonymous).
9694 Returns the type object, as yet incomplete.
9695 Also records info about it so that build_enumerator
9696 may be used to declare the individual values as they are read. */
9699 start_enum (tree name)
9701 tree enumtype = NULL_TREE;
9702 struct cp_binding_level *b = current_binding_level;
9704 /* If this is the real definition for a previous forward reference,
9705 fill in the contents in the same object that used to be the
9706 forward reference. */
9708 if (name != NULL_TREE)
9709 enumtype = lookup_tag (ENUMERAL_TYPE, name, b, 1);
9711 if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
9713 error ("multiple definition of `%#T'", enumtype);
9714 error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype));
9715 /* Clear out TYPE_VALUES, and start again. */
9716 TYPE_VALUES (enumtype) = NULL_TREE;
9720 enumtype = make_node (ENUMERAL_TYPE);
9721 pushtag (name, enumtype, 0);
9727 /* After processing and defining all the values of an enumeration type,
9728 install their decls in the enumeration type and finish it off.
9729 ENUMTYPE is the type object and VALUES a list of name-value pairs. */
9732 finish_enum (tree enumtype)
9744 integer_type_kind itk;
9745 tree underlying_type = NULL_TREE;
9747 /* We built up the VALUES in reverse order. */
9748 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
9750 /* For an enum defined in a template, just set the type of the values;
9751 all further processing is postponed until the template is
9752 instantiated. We need to set the type so that tsubst of a CONST_DECL
9754 if (processing_template_decl)
9756 for (values = TYPE_VALUES (enumtype);
9758 values = TREE_CHAIN (values))
9759 TREE_TYPE (TREE_VALUE (values)) = enumtype;
9760 if (at_function_scope_p ())
9761 add_stmt (build_min (TAG_DEFN, enumtype));
9765 /* Determine the minimum and maximum values of the enumerators. */
9766 if (TYPE_VALUES (enumtype))
9768 minnode = maxnode = NULL_TREE;
9770 for (values = TYPE_VALUES (enumtype);
9772 values = TREE_CHAIN (values))
9774 decl = TREE_VALUE (values);
9776 /* [dcl.enum]: Following the closing brace of an enum-specifier,
9777 each enumerator has the type of its enumeration. Prior to the
9778 closing brace, the type of each enumerator is the type of its
9779 initializing value. */
9780 TREE_TYPE (decl) = enumtype;
9782 /* Update the minimum and maximum values, if appropriate. */
9783 value = DECL_INITIAL (decl);
9784 /* Figure out what the minimum and maximum values of the
9787 minnode = maxnode = value;
9788 else if (tree_int_cst_lt (maxnode, value))
9790 else if (tree_int_cst_lt (value, minnode))
9793 /* Set the TREE_TYPE for the values as well. That's so that when
9794 we call decl_constant_value we get an entity of the right type
9795 (but with the constant value). But first make a copy so we
9796 don't clobber shared INTEGER_CSTs. */
9797 if (TREE_TYPE (value) != enumtype)
9799 value = DECL_INITIAL (decl) = copy_node (value);
9800 TREE_TYPE (value) = enumtype;
9807 If the enumerator-list is empty, the underlying type is as if
9808 the enumeration had a single enumerator with value 0. */
9809 minnode = maxnode = integer_zero_node;
9811 /* Compute the number of bits require to represent all values of the
9812 enumeration. We must do this before the type of MINNODE and
9813 MAXNODE are transformed, since min_precision relies on the
9814 TREE_TYPE of the value it is passed. */
9815 unsignedp = tree_int_cst_sgn (minnode) >= 0;
9816 lowprec = min_precision (minnode, unsignedp);
9817 highprec = min_precision (maxnode, unsignedp);
9818 precision = MAX (lowprec, highprec);
9820 /* Determine the underlying type of the enumeration.
9824 The underlying type of an enumeration is an integral type that
9825 can represent all the enumerator values defined in the
9826 enumeration. It is implementation-defined which integral type is
9827 used as the underlying type for an enumeration except that the
9828 underlying type shall not be larger than int unless the value of
9829 an enumerator cannot fit in an int or unsigned int.
9831 We use "int" or an "unsigned int" as the underlying type, even if
9832 a smaller integral type would work, unless the user has
9833 explicitly requested that we use the smallest possible type. */
9834 for (itk = (flag_short_enums ? itk_char : itk_int);
9838 underlying_type = integer_types[itk];
9839 if (TYPE_PRECISION (underlying_type) >= precision
9840 && TREE_UNSIGNED (underlying_type) == unsignedp)
9843 if (itk == itk_none)
9847 IF no integral type can represent all the enumerator values, the
9848 enumeration is ill-formed. */
9849 error ("no integral type can represent all of the enumerator values "
9850 "for `%T'", enumtype);
9851 precision = TYPE_PRECISION (long_long_integer_type_node);
9852 underlying_type = integer_types[itk_unsigned_long_long];
9855 /* Compute the minium and maximum values for the type.
9859 For an enumeration where emin is the smallest enumerator and emax
9860 is the largest, the values of the enumeration are the values of the
9861 underlying type in the range bmin to bmax, where bmin and bmax are,
9862 respectively, the smallest and largest values of the smallest bit-
9863 field that can store emin and emax. */
9864 TYPE_PRECISION (enumtype) = precision;
9865 set_min_and_max_values_for_integral_type (enumtype, precision, unsignedp);
9869 The value of sizeof() applied to an enumeration type, an object
9870 of an enumeration type, or an enumerator, is the value of sizeof()
9871 applied to the underlying type. */
9872 TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
9873 TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
9874 TYPE_MODE (enumtype) = TYPE_MODE (underlying_type);
9875 TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
9876 TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
9877 TREE_UNSIGNED (enumtype) = TREE_UNSIGNED (underlying_type);
9879 /* Convert each of the enumerators to the type of the underlying
9880 type of the enumeration. */
9881 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
9883 decl = TREE_VALUE (values);
9884 value = perform_implicit_conversion (underlying_type,
9885 DECL_INITIAL (decl));
9886 TREE_TYPE (value) = enumtype;
9887 DECL_INITIAL (decl) = value;
9888 TREE_VALUE (values) = value;
9891 /* Fix up all variant types of this enum type. */
9892 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
9894 TYPE_VALUES (t) = TYPE_VALUES (enumtype);
9895 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
9896 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
9897 TYPE_SIZE (t) = TYPE_SIZE (enumtype);
9898 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
9899 TYPE_MODE (t) = TYPE_MODE (enumtype);
9900 TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
9901 TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
9902 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
9903 TREE_UNSIGNED (t) = TREE_UNSIGNED (enumtype);
9906 /* Finish debugging output for this type. */
9907 rest_of_type_compilation (enumtype, namespace_bindings_p ());
9910 /* Build and install a CONST_DECL for an enumeration constant of the
9911 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
9912 Assignment of sequential values by default is handled here. */
9915 build_enumerator (tree name, tree value, tree enumtype)
9921 /* Remove no-op casts from the value. */
9923 STRIP_TYPE_NOPS (value);
9925 if (! processing_template_decl)
9927 /* Validate and default VALUE. */
9928 if (value != NULL_TREE)
9930 value = decl_constant_value (value);
9932 if (TREE_CODE (value) == INTEGER_CST)
9934 value = perform_integral_promotions (value);
9935 constant_expression_warning (value);
9939 error ("enumerator value for `%D' not integer constant", name);
9944 /* Default based on previous value. */
9945 if (value == NULL_TREE)
9949 if (TYPE_VALUES (enumtype))
9951 /* The next value is the previous value ... */
9952 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
9954 value = cp_build_binary_op (PLUS_EXPR,
9958 if (tree_int_cst_lt (value, prev_value))
9959 error ("overflow in enumeration values at `%D'", name);
9962 value = integer_zero_node;
9965 /* Remove no-op casts from the value. */
9966 STRIP_TYPE_NOPS (value);
9969 /* C++ associates enums with global, function, or class declarations. */
9970 context = current_scope ();
9972 context = current_namespace;
9974 /* Build the actual enumeration constant. Note that the enumeration
9975 constants have the type of their initializers until the
9976 enumeration is complete:
9980 Following the closing brace of an enum-specifier, each enumer-
9981 ator has the type of its enumeration. Prior to the closing
9982 brace, the type of each enumerator is the type of its
9985 In finish_enum we will reset the type. Of course, if we're
9986 processing a template, there may be no value. */
9987 type = value ? TREE_TYPE (value) : NULL_TREE;
9989 if (context && context == current_class_type)
9990 /* This enum declaration is local to the class. We need the full
9991 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
9992 decl = build_lang_decl (CONST_DECL, name, type);
9994 /* It's a global enum, or it's local to a function. (Note local to
9995 a function could mean local to a class method. */
9996 decl = build_decl (CONST_DECL, name, type);
9998 DECL_CONTEXT (decl) = FROB_CONTEXT (context);
9999 TREE_CONSTANT (decl) = TREE_READONLY (decl) = 1;
10000 DECL_INITIAL (decl) = value;
10002 if (context && context == current_class_type)
10003 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
10004 on the TYPE_FIELDS list for `S'. (That's so that you can say
10005 things like `S::i' later.) */
10006 finish_member_declaration (decl);
10010 /* Add this enumeration constant to the list for this type. */
10011 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
10015 /* We're defining DECL. Make sure that it's type is OK. */
10018 check_function_type (tree decl, tree current_function_parms)
10020 tree fntype = TREE_TYPE (decl);
10021 tree return_type = complete_type (TREE_TYPE (fntype));
10023 /* In a function definition, arg types must be complete. */
10024 require_complete_types_for_parms (current_function_parms);
10026 if (!COMPLETE_OR_VOID_TYPE_P (return_type))
10028 error ("return type `%#T' is incomplete", TREE_TYPE (fntype));
10030 /* Make it return void instead, but don't change the
10031 type of the DECL_RESULT, in case we have a named return value. */
10032 if (TREE_CODE (fntype) == METHOD_TYPE)
10034 tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
10036 = build_method_type_directly (ctype,
10038 FUNCTION_ARG_CHAIN (decl));
10042 = build_function_type (void_type_node,
10043 TYPE_ARG_TYPES (TREE_TYPE (decl)));
10045 = build_exception_variant (fntype,
10046 TYPE_RAISES_EXCEPTIONS (fntype));
10049 abstract_virtuals_error (decl, TREE_TYPE (fntype));
10052 /* Create the FUNCTION_DECL for a function definition.
10053 DECLSPECS and DECLARATOR are the parts of the declaration;
10054 they describe the function's name and the type it returns,
10055 but twisted together in a fashion that parallels the syntax of C.
10057 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
10058 DECLARATOR is really the DECL for the function we are about to
10059 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
10060 indicating that the function is an inline defined in-class.
10062 This function creates a binding context for the function body
10063 as well as setting up the FUNCTION_DECL in current_function_decl.
10065 Returns 1 on success. If the DECLARATOR is not suitable for a function
10066 (it defines a datum instead), we return 0, which tells
10067 yyparse to report a parse error.
10069 For C++, we must first check whether that datum makes any sense.
10070 For example, "class A local_a(1,2);" means that variable local_a
10071 is an aggregate of type A, which should have a constructor
10072 applied to it with the argument list [1, 2]. */
10075 start_function (tree declspecs, tree declarator, tree attrs, int flags)
10078 tree ctype = NULL_TREE;
10081 int doing_friend = 0;
10082 struct cp_binding_level *bl;
10083 tree current_function_parms;
10085 /* Sanity check. */
10086 my_friendly_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE, 160);
10087 my_friendly_assert (TREE_CHAIN (void_list_node) == NULL_TREE, 161);
10089 /* This should only be done once on the top most decl. */
10090 if (have_extern_spec)
10092 declspecs = tree_cons (NULL_TREE, get_identifier ("extern"), declspecs);
10093 have_extern_spec = false;
10096 if (flags & SF_PRE_PARSED)
10098 decl1 = declarator;
10100 fntype = TREE_TYPE (decl1);
10101 if (TREE_CODE (fntype) == METHOD_TYPE)
10102 ctype = TYPE_METHOD_BASETYPE (fntype);
10104 /* ISO C++ 11.4/5. A friend function defined in a class is in
10105 the (lexical) scope of the class in which it is defined. */
10106 if (!ctype && DECL_FRIEND_P (decl1))
10108 ctype = DECL_FRIEND_CONTEXT (decl1);
10110 /* CTYPE could be null here if we're dealing with a template;
10111 for example, `inline friend float foo()' inside a template
10112 will have no CTYPE set. */
10113 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
10119 last_function_parms = DECL_ARGUMENTS (decl1);
10123 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
10124 /* If the declarator is not suitable for a function definition,
10125 cause a syntax error. */
10126 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
10129 cplus_decl_attributes (&decl1, attrs, 0);
10131 /* If #pragma weak was used, mark the decl weak now. */
10132 if (global_scope_p (current_binding_level))
10133 maybe_apply_pragma_weak (decl1);
10135 fntype = TREE_TYPE (decl1);
10137 restype = TREE_TYPE (fntype);
10139 if (TREE_CODE (fntype) == METHOD_TYPE)
10140 ctype = TYPE_METHOD_BASETYPE (fntype);
10141 else if (DECL_MAIN_P (decl1))
10143 /* If this doesn't return integer_type, or a typedef to
10144 integer_type, complain. */
10145 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl1)), integer_type_node))
10147 if (pedantic || warn_return_type)
10148 pedwarn ("return type for `main' changed to `int'");
10149 TREE_TYPE (decl1) = fntype = default_function_type;
10154 if (DECL_DECLARED_INLINE_P (decl1)
10155 && lookup_attribute ("noinline", attrs))
10156 warning ("%Jinline function '%D' given attribute noinline", decl1, decl1);
10158 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
10159 /* This is a constructor, we must ensure that any default args
10160 introduced by this definition are propagated to the clones
10161 now. The clones are used directly in overload resolution. */
10162 adjust_clone_args (decl1);
10164 /* Sometimes we don't notice that a function is a static member, and
10165 build a METHOD_TYPE for it. Fix that up now. */
10166 if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
10167 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
10169 revert_static_member_fn (decl1);
10170 last_function_parms = TREE_CHAIN (last_function_parms);
10174 /* Warn if function was previously implicitly declared
10175 (but not if we warned then). */
10176 if (! warn_implicit
10177 && IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)) != NULL_TREE)
10178 cp_warning_at ("`%D' implicitly declared before its definition", IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)));
10180 /* Set up current_class_type, and enter the scope of the class, if
10183 push_nested_class (ctype);
10184 else if (DECL_STATIC_FUNCTION_P (decl1))
10185 push_nested_class (DECL_CONTEXT (decl1));
10187 /* Now that we have entered the scope of the class, we must restore
10188 the bindings for any template parameters surrounding DECL1, if it
10189 is an inline member template. (Order is important; consider the
10190 case where a template parameter has the same name as a field of
10191 the class.) It is not until after this point that
10192 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
10193 if (flags & SF_INCLASS_INLINE)
10194 maybe_begin_member_template_processing (decl1);
10196 /* Effective C++ rule 15. */
10198 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
10199 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
10200 warning ("`operator=' should return a reference to `*this'");
10202 /* Make the init_value nonzero so pushdecl knows this is not tentative.
10203 error_mark_node is replaced below (in poplevel) with the BLOCK. */
10204 if (!DECL_INITIAL (decl1))
10205 DECL_INITIAL (decl1) = error_mark_node;
10207 /* This function exists in static storage.
10208 (This does not mean `static' in the C sense!) */
10209 TREE_STATIC (decl1) = 1;
10211 /* We must call push_template_decl after current_class_type is set
10212 up. (If we are processing inline definitions after exiting a
10213 class scope, current_class_type will be NULL_TREE until set above
10214 by push_nested_class.) */
10215 if (processing_template_decl)
10216 decl1 = push_template_decl (decl1);
10218 /* We are now in the scope of the function being defined. */
10219 current_function_decl = decl1;
10221 /* Save the parm names or decls from this function's declarator
10222 where store_parm_decls will find them. */
10223 current_function_parms = last_function_parms;
10225 /* Make sure the parameter and return types are reasonable. When
10226 you declare a function, these types can be incomplete, but they
10227 must be complete when you define the function. */
10228 if (! processing_template_decl)
10229 check_function_type (decl1, current_function_parms);
10231 /* Build the return declaration for the function. */
10232 restype = TREE_TYPE (fntype);
10233 /* Promote the value to int before returning it. */
10234 if (c_promoting_integer_type_p (restype))
10235 restype = type_promotes_to (restype);
10236 if (DECL_RESULT (decl1) == NULL_TREE)
10238 DECL_RESULT (decl1)
10239 = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
10240 c_apply_type_quals_to_decl (cp_type_quals (restype),
10241 DECL_RESULT (decl1));
10244 /* Initialize RTL machinery. We cannot do this until
10245 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
10246 even when processing a template; this is how we get
10247 CFUN set up, and our per-function variables initialized.
10248 FIXME factor out the non-RTL stuff. */
10249 bl = current_binding_level;
10250 allocate_struct_function (decl1);
10251 current_binding_level = bl;
10253 /* Even though we're inside a function body, we still don't want to
10254 call expand_expr to calculate the size of a variable-sized array.
10255 We haven't necessarily assigned RTL to all variables yet, so it's
10256 not safe to try to expand expressions involving them. */
10257 immediate_size_expand = 0;
10258 cfun->x_dont_save_pending_sizes_p = 1;
10260 /* Start the statement-tree, start the tree now. */
10261 begin_stmt_tree (&DECL_SAVED_TREE (decl1));
10263 /* Don't double-count statements in templates. */
10264 DECL_ESTIMATED_INSNS (decl1) = 0;
10266 /* Let the user know we're compiling this function. */
10267 announce_function (decl1);
10269 /* Record the decl so that the function name is defined.
10270 If we already have a decl for this name, and it is a FUNCTION_DECL,
10271 use the old decl. */
10272 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
10274 /* A specialization is not used to guide overload resolution. */
10275 if (!DECL_TEMPLATE_SPECIALIZATION (decl1)
10276 && ! DECL_FUNCTION_MEMBER_P (decl1))
10278 tree olddecl = pushdecl (decl1);
10280 if (olddecl == error_mark_node)
10281 /* If something went wrong when registering the declaration,
10282 use DECL1; we have to have a FUNCTION_DECL to use when
10283 parsing the body of the function. */
10286 /* Otherwise, OLDDECL is either a previous declaration of
10287 the same function or DECL1 itself. */
10292 /* We need to set the DECL_CONTEXT. */
10293 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
10294 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
10295 /* And make sure we have enough default args. */
10296 check_default_args (decl1);
10298 fntype = TREE_TYPE (decl1);
10301 /* Reset these in case the call to pushdecl changed them. */
10302 current_function_decl = decl1;
10303 cfun->decl = decl1;
10305 /* If we are (erroneously) defining a function that we have already
10306 defined before, wipe out what we knew before. */
10307 if (!DECL_PENDING_INLINE_P (decl1))
10308 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
10310 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
10312 /* We know that this was set up by `grokclassfn'. We do not
10313 wait until `store_parm_decls', since evil parse errors may
10314 never get us to that point. Here we keep the consistency
10315 between `current_class_type' and `current_class_ptr'. */
10316 tree t = DECL_ARGUMENTS (decl1);
10318 my_friendly_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL,
10320 my_friendly_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE,
10323 cp_function_chain->x_current_class_ref
10324 = build_indirect_ref (t, NULL);
10325 cp_function_chain->x_current_class_ptr = t;
10327 /* Constructors and destructors need to know whether they're "in
10328 charge" of initializing virtual base classes. */
10329 t = TREE_CHAIN (t);
10330 if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
10332 current_in_charge_parm = t;
10333 t = TREE_CHAIN (t);
10335 if (DECL_HAS_VTT_PARM_P (decl1))
10337 if (DECL_NAME (t) != vtt_parm_identifier)
10339 current_vtt_parm = t;
10343 if (DECL_INTERFACE_KNOWN (decl1))
10345 tree ctx = decl_function_context (decl1);
10347 if (DECL_NOT_REALLY_EXTERN (decl1))
10348 DECL_EXTERNAL (decl1) = 0;
10350 if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
10351 && TREE_PUBLIC (ctx))
10352 /* This is a function in a local class in an extern inline
10354 comdat_linkage (decl1);
10356 /* If this function belongs to an interface, it is public.
10357 If it belongs to someone else's interface, it is also external.
10358 This only affects inlines and template instantiations. */
10359 else if (interface_unknown == 0
10360 && ! DECL_TEMPLATE_INSTANTIATION (decl1))
10362 if (DECL_DECLARED_INLINE_P (decl1)
10363 || DECL_TEMPLATE_INSTANTIATION (decl1)
10364 || processing_template_decl)
10366 DECL_EXTERNAL (decl1)
10368 || (DECL_DECLARED_INLINE_P (decl1)
10369 && ! flag_implement_inlines
10370 && !DECL_VINDEX (decl1)));
10372 /* For WIN32 we also want to put these in linkonce sections. */
10373 maybe_make_one_only (decl1);
10376 DECL_EXTERNAL (decl1) = 0;
10377 DECL_NOT_REALLY_EXTERN (decl1) = 0;
10378 DECL_INTERFACE_KNOWN (decl1) = 1;
10380 else if (interface_unknown && interface_only
10381 && ! DECL_TEMPLATE_INSTANTIATION (decl1))
10383 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
10384 interface, we will have interface_only set but not
10385 interface_known. In that case, we don't want to use the normal
10386 heuristics because someone will supply a #pragma implementation
10387 elsewhere, and deducing it here would produce a conflict. */
10388 comdat_linkage (decl1);
10389 DECL_EXTERNAL (decl1) = 0;
10390 DECL_INTERFACE_KNOWN (decl1) = 1;
10391 DECL_DEFER_OUTPUT (decl1) = 1;
10395 /* This is a definition, not a reference.
10396 So clear DECL_EXTERNAL. */
10397 DECL_EXTERNAL (decl1) = 0;
10399 if ((DECL_DECLARED_INLINE_P (decl1)
10400 || DECL_TEMPLATE_INSTANTIATION (decl1))
10401 && ! DECL_INTERFACE_KNOWN (decl1)
10402 /* Don't try to defer nested functions for now. */
10403 && ! decl_function_context (decl1))
10404 DECL_DEFER_OUTPUT (decl1) = 1;
10406 DECL_INTERFACE_KNOWN (decl1) = 1;
10409 begin_scope (sk_function_parms, decl1);
10413 if (DECL_DESTRUCTOR_P (decl1))
10415 dtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
10416 DECL_CONTEXT (dtor_label) = current_function_decl;
10419 start_fname_decls ();
10421 store_parm_decls (current_function_parms);
10426 /* Store the parameter declarations into the current function declaration.
10427 This is called after parsing the parameter declarations, before
10428 digesting the body of the function.
10430 Also install to binding contour return value identifier, if any. */
10433 store_parm_decls (tree current_function_parms)
10435 tree fndecl = current_function_decl;
10438 /* This is a chain of any other decls that came in among the parm
10439 declarations. If a parm is declared with enum {foo, bar} x;
10440 then CONST_DECLs for foo and bar are put here. */
10441 tree nonparms = NULL_TREE;
10443 if (current_function_parms)
10445 /* This case is when the function was defined with an ANSI prototype.
10446 The parms already have decls, so we need not do anything here
10447 except record them as in effect
10448 and complain if any redundant old-style parm decls were written. */
10450 tree specparms = current_function_parms;
10453 /* Must clear this because it might contain TYPE_DECLs declared
10455 current_binding_level->names = NULL;
10457 /* If we're doing semantic analysis, then we'll call pushdecl
10458 for each of these. We must do them in reverse order so that
10459 they end in the correct forward order. */
10460 specparms = nreverse (specparms);
10462 for (parm = specparms; parm; parm = next)
10464 next = TREE_CHAIN (parm);
10465 if (TREE_CODE (parm) == PARM_DECL)
10467 if (DECL_NAME (parm) == NULL_TREE
10468 || TREE_CODE (parm) != VOID_TYPE)
10471 error ("parameter `%D' declared void", parm);
10475 /* If we find an enum constant or a type tag,
10476 put it aside for the moment. */
10477 TREE_CHAIN (parm) = NULL_TREE;
10478 nonparms = chainon (nonparms, parm);
10482 /* Get the decls in their original chain order and record in the
10483 function. This is all and only the PARM_DECLs that were
10484 pushed into scope by the loop above. */
10485 DECL_ARGUMENTS (fndecl) = getdecls ();
10488 DECL_ARGUMENTS (fndecl) = NULL_TREE;
10490 /* Now store the final chain of decls for the arguments
10491 as the decl-chain of the current lexical scope.
10492 Put the enumerators in as well, at the front so that
10493 DECL_ARGUMENTS is not modified. */
10494 current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));
10496 /* Do the starting of the exception specifications, if we have any. */
10497 if (flag_exceptions && !processing_template_decl
10498 && flag_enforce_eh_specs
10499 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
10500 current_eh_spec_block = begin_eh_spec_block ();
10504 /* We have finished doing semantic analysis on DECL, but have not yet
10505 generated RTL for its body. Save away our current state, so that
10506 when we want to generate RTL later we know what to do. */
10509 save_function_data (tree decl)
10511 struct language_function *f;
10513 /* Save the language-specific per-function data so that we can
10514 get it back when we really expand this function. */
10515 my_friendly_assert (!DECL_PENDING_INLINE_P (decl),
10519 f = ggc_alloc (sizeof (struct language_function));
10520 memcpy (f, cp_function_chain, sizeof (struct language_function));
10521 DECL_SAVED_FUNCTION_DATA (decl) = f;
10523 /* Clear out the bits we don't need. */
10524 f->base.x_stmt_tree.x_last_stmt = NULL_TREE;
10525 f->base.x_stmt_tree.x_last_expr_type = NULL_TREE;
10526 f->x_named_label_uses = NULL;
10527 f->bindings = NULL;
10528 f->x_local_names = NULL;
10530 /* If we've already decided that we cannot inline this function, we
10531 must remember that fact when we actually go to expand the
10533 if (current_function_cannot_inline)
10535 f->cannot_inline = current_function_cannot_inline;
10536 DECL_INLINE (decl) = 0;
10540 /* Add a note to mark the beginning of the main body of the constructor.
10541 This is used to set up the data structures for the cleanup regions for
10542 fully-constructed bases and members. */
10545 begin_constructor_body (void)
10549 /* Add a note to mark the end of the main body of the constructor. This is
10550 used to end the cleanup regions for fully-constructed bases and
10554 finish_constructor_body (void)
10558 /* Do all the processing for the beginning of a destructor; set up the
10559 vtable pointers and cleanups for bases and members. */
10562 begin_destructor_body (void)
10565 tree compound_stmt;
10567 /* If the dtor is empty, and we know there is not any possible
10568 way we could use any vtable entries, before they are possibly
10569 set by a base class dtor, we don't have to setup the vtables,
10570 as we know that any base class dtor will set up any vtables
10571 it needs. We avoid MI, because one base class dtor can do a
10572 virtual dispatch to an overridden function that would need to
10573 have a non-related vtable set up, we cannot avoid setting up
10574 vtables in that case. We could change this to see if there
10575 is just one vtable.
10577 ??? In the destructor for a class, the vtables are set
10578 appropriately for that class. There will be no non-related
10579 vtables. jason 2001-12-11. */
10580 if_stmt = begin_if_stmt ();
10582 /* If it is not safe to avoid setting up the vtables, then
10583 someone will change the condition to be boolean_true_node.
10584 (Actually, for now, we do not have code to set the condition
10585 appropriately, so we just assume that we always need to
10586 initialize the vtables.) */
10587 finish_if_stmt_cond (boolean_true_node, if_stmt);
10589 compound_stmt = begin_compound_stmt (/*has_no_scope=*/false);
10591 /* Make all virtual function table pointers in non-virtual base
10592 classes point to CURRENT_CLASS_TYPE's virtual function
10594 initialize_vtbl_ptrs (current_class_ptr);
10596 finish_compound_stmt (compound_stmt);
10597 finish_then_clause (if_stmt);
10600 /* And insert cleanups for our bases and members so that they
10601 will be properly destroyed if we throw. */
10602 push_base_cleanups ();
10605 /* At the end of every destructor we generate code to delete the object if
10606 necessary. Do that now. */
10609 finish_destructor_body (void)
10613 /* Any return from a destructor will end up here; that way all base
10614 and member cleanups will be run when the function returns. */
10615 add_stmt (build_stmt (LABEL_STMT, dtor_label));
10617 /* In a virtual destructor, we must call delete. */
10618 if (DECL_VIRTUAL_P (current_function_decl))
10621 tree virtual_size = cxx_sizeof (current_class_type);
10625 At the point of definition of a virtual destructor (including
10626 an implicit definition), non-placement operator delete shall
10627 be looked up in the scope of the destructor's class and if
10628 found shall be accessible and unambiguous. */
10629 exprstmt = build_op_delete_call
10630 (DELETE_EXPR, current_class_ptr, virtual_size,
10631 LOOKUP_NORMAL | LOOKUP_SPECULATIVELY, NULL_TREE);
10633 if_stmt = begin_if_stmt ();
10634 finish_if_stmt_cond (build (BIT_AND_EXPR, integer_type_node,
10635 current_in_charge_parm,
10638 finish_expr_stmt (exprstmt);
10639 finish_then_clause (if_stmt);
10644 /* Do the necessary processing for the beginning of a function body, which
10645 in this case includes member-initializers, but not the catch clauses of
10646 a function-try-block. Currently, this means opening a binding level
10647 for the member-initializers (in a ctor) and member cleanups (in a dtor).
10648 In other functions, this isn't necessary, but it doesn't hurt. */
10651 begin_function_body (void)
10655 if (processing_template_decl)
10656 /* Do nothing now. */;
10658 /* Always keep the BLOCK node associated with the outermost pair of
10659 curly braces of a function. These are needed for correct
10660 operation of dwarfout.c. */
10661 keep_next_level (true);
10663 stmt = begin_compound_stmt (/*has_no_scope=*/false);
10664 COMPOUND_STMT_BODY_BLOCK (stmt) = 1;
10666 if (processing_template_decl)
10667 /* Do nothing now. */;
10668 else if (DECL_CONSTRUCTOR_P (current_function_decl))
10669 begin_constructor_body ();
10670 else if (DECL_DESTRUCTOR_P (current_function_decl))
10671 begin_destructor_body ();
10676 /* Do the processing for the end of a function body. Currently, this means
10677 closing out the cleanups for fully-constructed bases and members, and in
10678 the case of the destructor, deleting the object if desired. Again, this
10679 is only meaningful for [cd]tors, since they are the only functions where
10680 there is a significant distinction between the main body and any
10681 function catch clauses. Handling, say, main() return semantics here
10682 would be wrong, as flowing off the end of a function catch clause for
10683 main() would also need to return 0. */
10686 finish_function_body (tree compstmt)
10688 /* Close the block. */
10689 finish_compound_stmt (compstmt);
10691 if (processing_template_decl)
10692 /* Do nothing now. */;
10693 else if (DECL_CONSTRUCTOR_P (current_function_decl))
10694 finish_constructor_body ();
10695 else if (DECL_DESTRUCTOR_P (current_function_decl))
10696 finish_destructor_body ();
10699 /* Finish up a function declaration and compile that function
10700 all the way to assembler language output. The free the storage
10701 for the function definition.
10703 FLAGS is a bitwise or of the following values:
10705 We just finished processing the body of an in-class inline
10706 function definition. (This processing will have taken place
10707 after the class definition is complete.) */
10710 finish_function (int flags)
10712 tree fndecl = current_function_decl;
10713 tree fntype, ctype = NULL_TREE;
10714 int inclass_inline = (flags & 2) != 0;
10717 /* When we get some parse errors, we can end up without a
10718 current_function_decl, so cope. */
10719 if (fndecl == NULL_TREE)
10720 return error_mark_node;
10722 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
10723 && DECL_VIRTUAL_P (fndecl)
10724 && !processing_template_decl)
10726 tree fnclass = DECL_CONTEXT (fndecl);
10727 if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
10728 keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
10731 nested = function_depth > 1;
10732 fntype = TREE_TYPE (fndecl);
10734 /* TREE_READONLY (fndecl) = 1;
10735 This caused &foo to be of type ptr-to-const-function
10736 which then got a warning when stored in a ptr-to-function variable. */
10738 my_friendly_assert (building_stmt_tree (), 20000911);
10740 /* For a cloned function, we've already got all the code we need;
10741 there's no need to add any extra bits. */
10742 if (!DECL_CLONED_FUNCTION_P (fndecl))
10744 if (DECL_MAIN_P (current_function_decl))
10746 /* Make it so that `main' always returns 0 by default. */
10748 finish_return_stmt (integer_one_node);
10750 finish_return_stmt (integer_zero_node);
10754 /* Finish dealing with exception specifiers. */
10755 if (flag_exceptions && !processing_template_decl
10756 && flag_enforce_eh_specs
10757 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
10758 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
10759 (TREE_TYPE (current_function_decl)),
10760 current_eh_spec_block);
10763 finish_fname_decls ();
10765 /* If we're saving up tree structure, tie off the function now. */
10766 finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
10768 /* If this function can't throw any exceptions, remember that. */
10769 if (!processing_template_decl
10770 && !cp_function_chain->can_throw
10771 && !flag_non_call_exceptions)
10772 TREE_NOTHROW (fndecl) = 1;
10774 /* This must come after expand_function_end because cleanups might
10775 have declarations (from inline functions) that need to go into
10776 this function's blocks. */
10778 /* If the current binding level isn't the outermost binding level
10779 for this function, either there is a bug, or we have experienced
10780 syntax errors and the statement tree is malformed. */
10781 if (current_binding_level->kind != sk_function_parms)
10783 /* Make sure we have already experienced errors. */
10784 if (errorcount == 0)
10787 /* Throw away the broken statement tree and extra binding
10789 DECL_SAVED_TREE (fndecl) = build_stmt (COMPOUND_STMT, NULL_TREE);
10791 while (current_binding_level->kind != sk_function_parms)
10793 if (current_binding_level->kind == sk_class)
10794 pop_nested_class ();
10796 poplevel (0, 0, 0);
10799 poplevel (1, 0, 1);
10801 /* Statements should always be full-expressions at the outermost set
10802 of curly braces for a function. */
10803 my_friendly_assert (stmts_are_full_exprs_p (), 19990831);
10805 /* Set up the named return value optimization, if we can. Here, we
10806 eliminate the copy from the nrv into the RESULT_DECL and any cleanup
10807 for the nrv. genrtl_start_function and declare_return_variable
10808 handle making the nrv and RESULT_DECL share space. */
10809 if (current_function_return_value)
10811 tree r = current_function_return_value;
10814 if (r != error_mark_node
10815 /* This is only worth doing for fns that return in memory--and
10816 simpler, since we don't have to worry about promoted modes. */
10817 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
10818 /* Only allow this for variables declared in the outer scope of
10819 the function so we know that their lifetime always ends with a
10820 return; see g++.dg/opt/nrv6.C. We could be more flexible if
10821 we were to do this optimization in tree-ssa. */
10822 /* Skip the artificial function body block. */
10823 && (outer = BLOCK_SUBBLOCKS (BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl))),
10824 chain_member (r, BLOCK_VARS (outer))))
10827 DECL_ALIGN (r) = DECL_ALIGN (DECL_RESULT (fndecl));
10828 walk_tree_without_duplicates (&DECL_SAVED_TREE (fndecl),
10829 nullify_returns_r, r);
10832 /* Clear it so genrtl_start_function and declare_return_variable
10833 know we're not optimizing. */
10834 current_function_return_value = NULL_TREE;
10837 /* Remember that we were in class scope. */
10838 if (current_class_name)
10839 ctype = current_class_type;
10841 /* Must mark the RESULT_DECL as being in this function. */
10842 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
10844 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
10845 to the FUNCTION_DECL node itself. */
10846 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
10848 /* Save away current state, if appropriate. */
10849 if (!processing_template_decl)
10850 save_function_data (fndecl);
10852 /* If this function calls `setjmp' it cannot be inlined. When
10853 `longjmp' is called it is not guaranteed to restore the value of
10854 local variables that have been modified since the call to
10855 `setjmp'. So, if were to inline this function into some caller
10856 `c', then when we `longjmp', we might not restore all variables
10857 in `c'. (It might seem, at first blush, that there's no way for
10858 this function to modify local variables in `c', but their
10859 addresses may have been stored somewhere accessible to this
10861 if (!processing_template_decl && calls_setjmp_p (fndecl))
10862 DECL_UNINLINABLE (fndecl) = 1;
10864 /* Complain if there's just no return statement. */
10865 if (warn_return_type
10866 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
10867 && !dependent_type_p (TREE_TYPE (fntype))
10868 && !current_function_returns_value && !current_function_returns_null
10869 /* Don't complain if we abort or throw. */
10870 && !current_function_returns_abnormally
10871 && !DECL_NAME (DECL_RESULT (fndecl))
10872 /* Normally, with -Wreturn-type, flow will complain. Unless we're an
10873 inline function, as we might never be compiled separately. */
10874 && (DECL_INLINE (fndecl) || processing_template_decl))
10875 warning ("no return statement in function returning non-void");
10877 /* We're leaving the context of this function, so zap cfun. It's still in
10878 DECL_SAVED_INSNS, and we'll restore it in tree_rest_of_compilation. */
10880 current_function_decl = NULL;
10882 /* If this is an in-class inline definition, we may have to pop the
10883 bindings for the template parameters that we added in
10884 maybe_begin_member_template_processing when start_function was
10886 if (inclass_inline)
10887 maybe_end_member_template_processing ();
10889 /* Leave the scope of the class. */
10891 pop_nested_class ();
10897 /* Let the error reporting routines know that we're outside a
10898 function. For a nested function, this value is used in
10899 cxx_pop_function_context and then reset via pop_function_context. */
10900 current_function_decl = NULL_TREE;
10905 /* Create the FUNCTION_DECL for a function definition.
10906 DECLSPECS and DECLARATOR are the parts of the declaration;
10907 they describe the return type and the name of the function,
10908 but twisted together in a fashion that parallels the syntax of C.
10910 This function creates a binding context for the function body
10911 as well as setting up the FUNCTION_DECL in current_function_decl.
10913 Returns a FUNCTION_DECL on success.
10915 If the DECLARATOR is not suitable for a function (it defines a datum
10916 instead), we return 0, which tells yyparse to report a parse error.
10918 May return void_type_node indicating that this method is actually
10919 a friend. See grokfield for more details.
10921 Came here with a `.pushlevel' .
10923 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
10924 CHANGES TO CODE IN `grokfield'. */
10927 start_method (tree declspecs, tree declarator, tree attrlist)
10929 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
10932 if (fndecl == error_mark_node)
10933 return error_mark_node;
10935 if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
10937 error ("invalid member function declaration");
10938 return error_mark_node;
10942 cplus_decl_attributes (&fndecl, attrlist, 0);
10944 /* Pass friends other than inline friend functions back. */
10945 if (fndecl == void_type_node)
10948 if (DECL_IN_AGGR_P (fndecl))
10950 if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (fndecl)) != current_class_type)
10952 if (DECL_CONTEXT (fndecl)
10953 && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
10954 error ("`%D' is already defined in class `%T'", fndecl,
10955 DECL_CONTEXT (fndecl));
10957 return void_type_node;
10960 check_template_shadow (fndecl);
10962 DECL_DECLARED_INLINE_P (fndecl) = 1;
10963 if (flag_default_inline)
10964 DECL_INLINE (fndecl) = 1;
10966 /* We process method specializations in finish_struct_1. */
10967 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
10969 fndecl = push_template_decl (fndecl);
10970 if (fndecl == error_mark_node)
10974 if (! DECL_FRIEND_P (fndecl))
10976 if (TREE_CHAIN (fndecl))
10978 fndecl = copy_node (fndecl);
10979 TREE_CHAIN (fndecl) = NULL_TREE;
10981 grok_special_member_properties (fndecl);
10984 cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
10986 /* Make a place for the parms. */
10987 begin_scope (sk_function_parms, fndecl);
10989 DECL_IN_AGGR_P (fndecl) = 1;
10993 /* Go through the motions of finishing a function definition.
10994 We don't compile this method until after the whole class has
10997 FINISH_METHOD must return something that looks as though it
10998 came from GROKFIELD (since we are defining a method, after all).
11000 This is called after parsing the body of the function definition.
11001 STMTS is the chain of statements that makes up the function body.
11003 DECL is the ..._DECL that `start_method' provided. */
11006 finish_method (tree decl)
11008 tree fndecl = decl;
11013 if (decl == void_type_node)
11016 old_initial = DECL_INITIAL (fndecl);
11018 /* Undo the level for the parms (from start_method).
11019 This is like poplevel, but it causes nothing to be
11020 saved. Saving information here confuses symbol-table
11021 output routines. Besides, this information will
11022 be correctly output when this method is actually
11025 /* Clear out the meanings of the local variables of this level;
11026 also record in each decl which block it belongs to. */
11028 for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
11030 if (DECL_NAME (link) != NULL_TREE)
11031 pop_binding (DECL_NAME (link), link);
11032 my_friendly_assert (TREE_CODE (link) != FUNCTION_DECL, 163);
11033 DECL_CONTEXT (link) = NULL_TREE;
11036 poplevel (0, 0, 0);
11038 DECL_INITIAL (fndecl) = old_initial;
11040 /* We used to check if the context of FNDECL was different from
11041 current_class_type as another way to get inside here. This didn't work
11042 for String.cc in libg++. */
11043 if (DECL_FRIEND_P (fndecl))
11045 CLASSTYPE_INLINE_FRIENDS (current_class_type)
11046 = tree_cons (NULL_TREE, fndecl, CLASSTYPE_INLINE_FRIENDS (current_class_type));
11047 decl = void_type_node;
11054 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
11055 we can lay it out later, when and if its type becomes complete. */
11058 maybe_register_incomplete_var (tree var)
11060 my_friendly_assert (TREE_CODE (var) == VAR_DECL, 20020406);
11062 /* Keep track of variables with incomplete types. */
11063 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
11064 && DECL_EXTERNAL (var))
11066 tree inner_type = TREE_TYPE (var);
11068 while (TREE_CODE (inner_type) == ARRAY_TYPE)
11069 inner_type = TREE_TYPE (inner_type);
11070 inner_type = TYPE_MAIN_VARIANT (inner_type);
11072 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
11073 /* RTTI TD entries are created while defining the type_info. */
11074 || (TYPE_LANG_SPECIFIC (inner_type)
11075 && TYPE_BEING_DEFINED (inner_type)))
11076 incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
11080 /* Called when a class type (given by TYPE) is defined. If there are
11081 any existing VAR_DECLs whose type hsa been completed by this
11082 declaration, update them now. */
11085 complete_vars (tree type)
11087 tree *list = &incomplete_vars;
11089 my_friendly_assert (CLASS_TYPE_P (type), 20020406);
11092 if (same_type_p (type, TREE_PURPOSE (*list)))
11094 tree var = TREE_VALUE (*list);
11095 /* Complete the type of the variable. The VAR_DECL itself
11096 will be laid out in expand_expr. */
11097 complete_type (TREE_TYPE (var));
11098 /* Remove this entry from the list. */
11099 *list = TREE_CHAIN (*list);
11102 list = &TREE_CHAIN (*list);
11106 /* If DECL is of a type which needs a cleanup, build that cleanup
11110 cxx_maybe_build_cleanup (tree decl)
11112 tree type = TREE_TYPE (decl);
11114 if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
11116 int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
11119 if (TREE_CODE (type) == ARRAY_TYPE)
11123 cxx_mark_addressable (decl);
11124 rval = build_unary_op (ADDR_EXPR, decl, 0);
11127 /* Optimize for space over speed here. */
11128 if (! TYPE_USES_VIRTUAL_BASECLASSES (type)
11129 || flag_expensive_optimizations)
11130 flags |= LOOKUP_NONVIRTUAL;
11132 rval = build_delete (TREE_TYPE (rval), rval,
11133 sfk_complete_destructor, flags, 0);
11135 if (TYPE_USES_VIRTUAL_BASECLASSES (type)
11136 && ! TYPE_HAS_DESTRUCTOR (type))
11137 rval = build_compound_expr (rval, build_vbase_delete (type, decl));
11144 /* When a stmt has been parsed, this function is called. */
11149 /* Always assume this statement was not an expression statement. If
11150 it actually was an expression statement, its our callers
11151 responsibility to fix this up. */
11152 last_expr_type = NULL_TREE;
11155 /* DECL was originally constructed as a non-static member function,
11156 but turned out to be static. Update it accordingly. */
11159 revert_static_member_fn (tree decl)
11162 tree function = TREE_TYPE (decl);
11163 tree args = TYPE_ARG_TYPES (function);
11165 if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
11166 != TYPE_UNQUALIFIED)
11167 error ("static member function `%#D' declared with type qualifiers",
11170 args = TREE_CHAIN (args);
11171 tmp = build_function_type (TREE_TYPE (function), args);
11172 tmp = build_qualified_type (tmp, cp_type_quals (function));
11173 tmp = build_exception_variant (tmp,
11174 TYPE_RAISES_EXCEPTIONS (function));
11175 TREE_TYPE (decl) = tmp;
11176 if (DECL_ARGUMENTS (decl))
11177 DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
11178 DECL_STATIC_FUNCTION_P (decl) = 1;
11181 /* Initialize the variables used during compilation of a C++
11185 cxx_push_function_context (struct function * f)
11187 struct language_function *p
11188 = ggc_alloc_cleared (sizeof (struct language_function));
11191 /* Whenever we start a new function, we destroy temporaries in the
11193 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
11199 current_function_is_thunk = DECL_THUNK_P (fn);
11201 if (DECL_SAVED_FUNCTION_DATA (fn))
11203 /* If we already parsed this function, and we're just expanding it
11204 now, restore saved state. */
11205 *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (fn);
11207 /* If we decided that we didn't want to inline this function,
11208 make sure the back-end knows that. */
11209 if (!current_function_cannot_inline)
11210 current_function_cannot_inline = cp_function_chain->cannot_inline;
11212 /* We don't need the saved data anymore. Unless this is an inline
11213 function; we need the named return value info for
11214 cp_copy_res_decl_for_inlining. */
11215 if (! DECL_INLINE (fn))
11216 DECL_SAVED_FUNCTION_DATA (fn) = NULL;
11221 /* Free the language-specific parts of F, now that we've finished
11222 compiling the function. */
11225 cxx_pop_function_context (struct function * f)
11230 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
11231 one of the language-independent trees. */
11233 enum cp_tree_node_structure_enum
11234 cp_tree_node_structure (union lang_tree_node * t)
11236 switch (TREE_CODE (&t->generic))
11238 case DEFAULT_ARG: return TS_CP_DEFAULT_ARG;
11239 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER;
11240 case OVERLOAD: return TS_CP_OVERLOAD;
11241 case TEMPLATE_PARM_INDEX: return TS_CP_TPI;
11242 case PTRMEM_CST: return TS_CP_PTRMEM;
11243 case BASELINK: return TS_CP_BASELINK;
11244 case WRAPPER: return TS_CP_WRAPPER;
11245 default: return TS_CP_GENERIC;
11249 /* Build the void_list_node (void_type_node having been created). */
11251 build_void_list_node (void)
11253 tree t = build_tree_list (NULL_TREE, void_type_node);
11254 TREE_PARMLIST (t) = 1;
11259 cp_missing_noreturn_ok_p (tree decl)
11261 /* A missing noreturn is ok for the `main' function. */
11262 return DECL_MAIN_P (decl);
11265 #include "gt-cp-decl.h"
11266 #include "gtype-cp.h"