1 /* Process declarations and variables for C++ compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 /* Process declarations and symbol lookup for C++ front end.
25 Also constructs types; the standard scalar types at initialization,
26 and structure, union, array and enum types when they are declared. */
28 /* ??? not all decl nodes are given the most useful possible
29 line numbers. For example, the CONST_DECLs for enum values. */
33 #include "coretypes.h"
40 #include "tree-inline.h"
50 #include "diagnostic.h"
53 #include "tree-flow.h"
55 static tree grokparms (cp_parameter_declarator *, tree *);
56 static const char *redeclaration_error_message (tree, tree);
58 static int decl_jump_unsafe (tree);
59 static void require_complete_types_for_parms (tree);
60 static int ambi_op_p (enum tree_code);
61 static int unary_op_p (enum tree_code);
62 static void push_local_name (tree);
63 static tree grok_reference_init (tree, tree, tree, tree *);
64 static tree grokvardecl (tree, tree, const cp_decl_specifier_seq *,
66 static void record_unknown_type (tree, const char *);
67 static tree builtin_function_1 (const char *, tree, tree,
68 enum built_in_function code,
69 enum built_in_class cl, const char *,
71 static tree build_library_fn_1 (tree, enum tree_code, tree);
72 static int member_function_or_else (tree, tree, enum overload_flags);
73 static void bad_specifiers (tree, const char *, int, int, int, int,
75 static void check_for_uninitialized_const_var (tree);
76 static hashval_t typename_hash (const void *);
77 static int typename_compare (const void *, const void *);
78 static tree local_variable_p_walkfn (tree *, int *, void *);
79 static tree record_builtin_java_type (const char *, int);
80 static const char *tag_name (enum tag_types);
81 static tree lookup_and_check_tag (enum tag_types, tree, tag_scope, bool);
82 static int walk_namespaces_r (tree, walk_namespaces_fn, void *);
83 static tree make_label_decl (tree, int);
84 static void use_label (tree);
85 static void check_previous_goto_1 (tree, struct cp_binding_level *, tree,
87 static void check_previous_goto (struct named_label_use_list *);
88 static void check_switch_goto (struct cp_binding_level *);
89 static void check_previous_gotos (tree);
90 static void pop_label (tree, tree);
91 static void pop_labels (tree);
92 static void maybe_deduce_size_from_array_init (tree, tree);
93 static void layout_var_decl (tree);
94 static void maybe_commonize_var (tree);
95 static tree check_initializer (tree, tree, int, tree *);
96 static void make_rtl_for_nonlocal_decl (tree, tree, const char *);
97 static void save_function_data (tree);
98 static void check_function_type (tree, tree);
99 static void finish_constructor_body (void);
100 static void begin_destructor_body (void);
101 static void finish_destructor_body (void);
102 static tree create_array_type_for_decl (tree, tree, tree);
103 static tree get_atexit_node (void);
104 static tree get_dso_handle_node (void);
105 static tree start_cleanup_fn (void);
106 static void end_cleanup_fn (void);
107 static tree cp_make_fname_decl (tree, int);
108 static void initialize_predefined_identifiers (void);
109 static tree check_special_function_return_type
110 (special_function_kind, tree, tree);
111 static tree push_cp_library_fn (enum tree_code, tree);
112 static tree build_cp_library_fn (tree, enum tree_code, tree);
113 static void store_parm_decls (tree);
114 static void initialize_local_var (tree, tree);
115 static void expand_static_init (tree, tree);
116 static tree next_initializable_field (tree);
117 static tree reshape_init (tree, tree *);
119 /* Erroneous argument lists can use this *IFF* they do not modify it. */
120 tree error_mark_list;
122 /* The following symbols are subsumed in the cp_global_trees array, and
123 listed here individually for documentation purposes.
126 tree wchar_decl_node;
128 tree vtable_entry_type;
129 tree delta_type_node;
130 tree __t_desc_type_node;
131 tree ti_desc_type_node;
132 tree bltn_desc_type_node, ptr_desc_type_node;
133 tree ary_desc_type_node, func_desc_type_node, enum_desc_type_node;
134 tree class_desc_type_node, si_class_desc_type_node, vmi_class_desc_type_node;
135 tree ptm_desc_type_node;
136 tree base_desc_type_node;
138 tree class_type_node;
139 tree unknown_type_node;
141 Array type `vtable_entry_type[]'
144 tree vtbl_ptr_type_node;
151 A FUNCTION_DECL which can call `abort'. Not necessarily the
152 one that the user will declare, but sufficient to be called
153 by routines that want to abort the program.
157 The FUNCTION_DECL for the default `::operator delete'.
159 tree global_delete_fndecl;
162 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
167 tree cp_global_trees[CPTI_MAX];
169 /* Indicates that there is a type value in some namespace, although
170 that is not necessarily in scope at the moment. */
172 tree global_type_node;
174 /* The node that holds the "name" of the global scope. */
175 tree global_scope_name;
177 /* Used only for jumps to as-yet undefined labels, since jumps to
178 defined labels can have their validity checked immediately. */
180 struct named_label_use_list GTY(())
182 struct cp_binding_level *binding_level;
185 location_t o_goto_locus;
186 struct named_label_use_list *next;
189 #define named_label_uses cp_function_chain->x_named_label_uses
191 #define local_names cp_function_chain->x_local_names
193 /* A list of objects which have constructors or destructors
194 which reside in the global scope. The decl is stored in
195 the TREE_VALUE slot and the initializer is stored
196 in the TREE_PURPOSE slot. */
197 tree static_aggregates;
201 /* A node for the integer constants 2, and 3. */
203 tree integer_two_node, integer_three_node;
205 /* A list of all LABEL_DECLs in the function that have names. Here so
206 we can clear out their names' definitions at the end of the
207 function, and so we can check the validity of jumps to these labels. */
209 struct named_label_list GTY(())
211 struct cp_binding_level *binding_level;
216 struct named_label_list *next;
217 unsigned int in_try_scope : 1;
218 unsigned int in_catch_scope : 1;
221 #define named_labels cp_function_chain->x_named_labels
223 /* The number of function bodies which we are currently processing.
224 (Zero if we are at namespace scope, one inside the body of a
225 function, two inside the body of a function in a local class, etc.) */
228 /* States indicating how grokdeclarator() should handle declspecs marked
229 with __attribute__((deprecated)). An object declared as
230 __attribute__((deprecated)) suppresses warnings of uses of other
233 enum deprecated_states {
238 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
240 /* True if a declaration with an `extern' linkage specifier is being
242 bool have_extern_spec;
245 /* A TREE_LIST of VAR_DECLs. The TREE_PURPOSE is a RECORD_TYPE or
246 UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type. At the
247 time the VAR_DECL was declared, the type was incomplete. */
249 static GTY(()) tree incomplete_vars;
251 /* Returns the kind of template specialization we are currently
252 processing, given that it's declaration contained N_CLASS_SCOPES
253 explicit scope qualifications. */
256 current_tmpl_spec_kind (int n_class_scopes)
258 int n_template_parm_scopes = 0;
259 int seen_specialization_p = 0;
260 int innermost_specialization_p = 0;
261 struct cp_binding_level *b;
263 /* Scan through the template parameter scopes. */
264 for (b = current_binding_level;
265 b->kind == sk_template_parms;
268 /* If we see a specialization scope inside a parameter scope,
269 then something is wrong. That corresponds to a declaration
272 template <class T> template <> ...
274 which is always invalid since [temp.expl.spec] forbids the
275 specialization of a class member template if the enclosing
276 class templates are not explicitly specialized as well. */
277 if (b->explicit_spec_p)
279 if (n_template_parm_scopes == 0)
280 innermost_specialization_p = 1;
282 seen_specialization_p = 1;
284 else if (seen_specialization_p == 1)
285 return tsk_invalid_member_spec;
287 ++n_template_parm_scopes;
290 /* Handle explicit instantiations. */
291 if (processing_explicit_instantiation)
293 if (n_template_parm_scopes != 0)
294 /* We've seen a template parameter list during an explicit
295 instantiation. For example:
297 template <class T> template void f(int);
299 This is erroneous. */
300 return tsk_invalid_expl_inst;
302 return tsk_expl_inst;
305 if (n_template_parm_scopes < n_class_scopes)
306 /* We've not seen enough template headers to match all the
307 specialized classes present. For example:
309 template <class T> void R<T>::S<T>::f(int);
311 This is invalid; there needs to be one set of template
312 parameters for each class. */
313 return tsk_insufficient_parms;
314 else if (n_template_parm_scopes == n_class_scopes)
315 /* We're processing a non-template declaration (even though it may
316 be a member of a template class.) For example:
318 template <class T> void S<T>::f(int);
320 The `class T' maches the `S<T>', leaving no template headers
321 corresponding to the `f'. */
323 else if (n_template_parm_scopes > n_class_scopes + 1)
324 /* We've got too many template headers. For example:
326 template <> template <class T> void f (T);
328 There need to be more enclosing classes. */
329 return tsk_excessive_parms;
331 /* This must be a template. It's of the form:
333 template <class T> template <class U> void S<T>::f(U);
335 This is a specialization if the innermost level was a
336 specialization; otherwise it's just a definition of the
338 return innermost_specialization_p ? tsk_expl_spec : tsk_template;
341 /* Exit the current scope. */
349 /* When a label goes out of scope, check to see if that label was used
350 in a valid manner, and issue any appropriate warnings or errors. */
353 pop_label (tree label, tree old_value)
355 if (!processing_template_decl)
357 if (DECL_INITIAL (label) == NULL_TREE)
361 cp_error_at ("label %qD used but not defined", label);
362 #ifdef USE_MAPPED_LOCATION
363 location = input_location; /* FIXME want (input_filename, (line)0) */
365 location.file = input_filename;
368 /* Avoid crashing later. */
369 define_label (location, DECL_NAME (label));
371 else if (warn_unused_label && !TREE_USED (label))
372 cp_warning_at ("label %qD defined but not used", label);
375 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
378 /* At the end of a function, all labels declared within the function
379 go out of scope. BLOCK is the top-level block for the
383 pop_labels (tree block)
385 struct named_label_list *link;
387 /* Clear out the definitions of all label names, since their scopes
389 for (link = named_labels; link; link = link->next)
391 pop_label (link->label_decl, link->old_value);
392 /* Put the labels into the "variables" of the top-level block,
393 so debugger can see them. */
394 TREE_CHAIN (link->label_decl) = BLOCK_VARS (block);
395 BLOCK_VARS (block) = link->label_decl;
401 /* The following two routines are used to interface to Objective-C++.
402 The binding level is purposely treated as an opaque type. */
405 objc_get_current_scope (void)
407 return current_binding_level;
410 /* The following routine is used by the NeXT-style SJLJ exceptions;
411 variables get marked 'volatile' so as to not be clobbered by
412 _setjmp()/_longjmp() calls. All variables in the current scope,
413 as well as parent scopes up to (but not including) ENCLOSING_BLK
414 shall be thusly marked. */
417 objc_mark_locals_volatile (void *enclosing_blk)
419 struct cp_binding_level *scope;
421 for (scope = current_binding_level;
422 scope && scope != enclosing_blk && scope->kind == sk_block;
423 scope = scope->level_chain)
427 for (decl = scope->names; decl; decl = TREE_CHAIN (decl))
429 if (TREE_CODE (decl) == VAR_DECL)
431 DECL_REGISTER (decl) = 0;
432 TREE_THIS_VOLATILE (decl) = 1;
438 /* Exit a binding level.
439 Pop the level off, and restore the state of the identifier-decl mappings
440 that were in effect when this level was entered.
442 If KEEP == 1, this level had explicit declarations, so
443 and create a "block" (a BLOCK node) for the level
444 to record its declarations and subblocks for symbol table output.
446 If FUNCTIONBODY is nonzero, this level is the body of a function,
447 so create a block as if KEEP were set and also clear out all
450 If REVERSE is nonzero, reverse the order of decls before putting
451 them into the BLOCK. */
454 poplevel (int keep, int reverse, int functionbody)
457 /* The chain of decls was accumulated in reverse order.
458 Put it into forward order, just for cleanliness. */
460 int tmp = functionbody;
461 int real_functionbody;
465 int leaving_for_scope;
468 timevar_push (TV_NAME_LOOKUP);
473 gcc_assert (current_binding_level->kind != sk_class);
475 real_functionbody = (current_binding_level->kind == sk_cleanup
476 ? ((functionbody = 0), tmp) : functionbody);
477 subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
479 gcc_assert (!VEC_length(cp_class_binding,
480 current_binding_level->class_shadowed));
482 /* We used to use KEEP == 2 to indicate that the new block should go
483 at the beginning of the list of blocks at this binding level,
484 rather than the end. This hack is no longer used. */
485 gcc_assert (keep == 0 || keep == 1);
487 if (current_binding_level->keep)
490 /* Any uses of undefined labels, and any defined labels, now operate
491 under constraints of next binding contour. */
492 if (cfun && !functionbody)
494 struct cp_binding_level *level_chain;
495 level_chain = current_binding_level->level_chain;
498 struct named_label_use_list *uses;
499 struct named_label_list *labels;
500 for (labels = named_labels; labels; labels = labels->next)
501 if (labels->binding_level == current_binding_level)
504 if (current_binding_level->kind == sk_try)
505 labels->in_try_scope = 1;
506 if (current_binding_level->kind == sk_catch)
507 labels->in_catch_scope = 1;
508 for (decl = labels->names_in_scope; decl;
509 decl = TREE_CHAIN (decl))
510 if (decl_jump_unsafe (decl))
511 labels->bad_decls = tree_cons (NULL_TREE, decl,
513 labels->binding_level = level_chain;
514 labels->names_in_scope = level_chain->names;
517 for (uses = named_label_uses; uses; uses = uses->next)
518 if (uses->binding_level == current_binding_level)
520 uses->binding_level = level_chain;
521 uses->names_in_scope = level_chain->names;
526 /* Get the decls in the order they were written.
527 Usually current_binding_level->names is in reverse order.
528 But parameter decls were previously put in forward order. */
531 current_binding_level->names
532 = decls = nreverse (current_binding_level->names);
534 decls = current_binding_level->names;
536 /* If there were any declarations or structure tags in that level,
537 or if this level is a function body,
538 create a BLOCK to record them for the life of this function. */
540 if (keep == 1 || functionbody)
541 block = make_node (BLOCK);
542 if (block != NULL_TREE)
544 BLOCK_VARS (block) = decls;
545 BLOCK_SUBBLOCKS (block) = subblocks;
548 /* In each subblock, record that this is its superior. */
550 for (link = subblocks; link; link = TREE_CHAIN (link))
551 BLOCK_SUPERCONTEXT (link) = block;
553 /* We still support the old for-scope rules, whereby the variables
554 in a for-init statement were in scope after the for-statement
555 ended. We only use the new rules if flag_new_for_scope is
558 = current_binding_level->kind == sk_for && flag_new_for_scope == 1;
560 /* Before we remove the declarations first check for unused variables. */
561 if (warn_unused_variable
562 && !processing_template_decl)
563 for (decl = getdecls (); decl; decl = TREE_CHAIN (decl))
564 if (TREE_CODE (decl) == VAR_DECL
565 && ! TREE_USED (decl)
566 && ! DECL_IN_SYSTEM_HEADER (decl)
567 && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl))
568 warning ("%Junused variable %qD", decl, decl);
570 /* Remove declarations for all the DECLs in this level. */
571 for (link = decls; link; link = TREE_CHAIN (link))
573 if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
576 tree name = DECL_NAME (link);
580 ob = outer_binding (name,
581 IDENTIFIER_BINDING (name),
584 ns_binding = IDENTIFIER_NAMESPACE_VALUE (name);
586 ns_binding = NULL_TREE;
588 if (ob && ob->scope == current_binding_level->level_chain)
589 /* We have something like:
594 and we are leaving the `for' scope. There's no reason to
595 keep the binding of the inner `i' in this case. */
596 pop_binding (name, link);
597 else if ((ob && (TREE_CODE (ob->value) == TYPE_DECL))
598 || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL))
599 /* Here, we have something like:
607 We must pop the for-scope binding so we know what's a
608 type and what isn't. */
609 pop_binding (name, link);
612 /* Mark this VAR_DECL as dead so that we can tell we left it
613 there only for backward compatibility. */
614 DECL_DEAD_FOR_LOCAL (link) = 1;
616 /* Keep track of what should have happened when we
617 popped the binding. */
619 DECL_SHADOWED_FOR_VAR (link) = ob->value;
621 /* Add it to the list of dead variables in the next
622 outermost binding to that we can remove these when we
623 leave that binding. */
624 current_binding_level->level_chain->dead_vars_from_for
625 = tree_cons (NULL_TREE, link,
626 current_binding_level->level_chain->
629 /* Although we don't pop the cxx_binding, we do clear
630 its SCOPE since the scope is going away now. */
631 IDENTIFIER_BINDING (name)->scope
632 = current_binding_level->level_chain;
639 /* Remove the binding. */
642 if (TREE_CODE (decl) == TREE_LIST)
643 decl = TREE_VALUE (decl);
646 if (TREE_CODE (name) == OVERLOAD)
647 name = OVL_FUNCTION (name);
649 gcc_assert (DECL_P (name));
650 pop_binding (DECL_NAME (name), decl);
654 /* Remove declarations for any `for' variables from inner scopes
655 that we kept around. */
656 for (link = current_binding_level->dead_vars_from_for;
657 link; link = TREE_CHAIN (link))
658 pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
660 /* Restore the IDENTIFIER_TYPE_VALUEs. */
661 for (link = current_binding_level->type_shadowed;
662 link; link = TREE_CHAIN (link))
663 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
665 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
666 for (link = current_binding_level->shadowed_labels;
668 link = TREE_CHAIN (link))
669 pop_label (TREE_VALUE (link), TREE_PURPOSE (link));
671 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
672 list if a `using' declaration put them there. The debugging
673 back-ends won't understand OVERLOAD, so we remove them here.
674 Because the BLOCK_VARS are (temporarily) shared with
675 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
676 popped all the bindings. */
681 for (d = &BLOCK_VARS (block); *d; )
683 if (TREE_CODE (*d) == TREE_LIST)
684 *d = TREE_CHAIN (*d);
686 d = &TREE_CHAIN (*d);
690 /* If the level being exited is the top level of a function,
691 check over all the labels. */
694 /* Since this is the top level block of a function, the vars are
695 the function's parameters. Don't leave them in the BLOCK
696 because they are found in the FUNCTION_DECL instead. */
697 BLOCK_VARS (block) = 0;
701 kind = current_binding_level->kind;
702 if (kind == sk_cleanup)
706 /* If this is a temporary binding created for a cleanup, then we'll
707 have pushed a statement list level. Pop that, create a new
708 BIND_EXPR for the block, and insert it into the stream. */
709 stmt = pop_stmt_list (current_binding_level->statement_list);
710 stmt = c_build_bind_expr (block, stmt);
716 DECL_INITIAL (current_function_decl) = block;
718 current_binding_level->blocks
719 = chainon (current_binding_level->blocks, block);
721 /* If we did not make a block for the level just exited,
722 any blocks made for inner levels
723 (since they cannot be recorded as subblocks in that level)
724 must be carried forward so they will later become subblocks
725 of something else. */
727 current_binding_level->blocks
728 = chainon (current_binding_level->blocks, subblocks);
730 /* Each and every BLOCK node created here in `poplevel' is important
731 (e.g. for proper debugging information) so if we created one
732 earlier, mark it as "used". */
734 TREE_USED (block) = 1;
736 /* All temporary bindings created for cleanups are popped silently. */
737 if (kind == sk_cleanup)
740 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, block);
743 /* Insert BLOCK at the end of the list of subblocks of the
744 current binding level. This is used when a BIND_EXPR is expanded,
745 to handle the BLOCK node inside the BIND_EXPR. */
748 insert_block (tree block)
750 TREE_USED (block) = 1;
751 current_binding_level->blocks
752 = chainon (current_binding_level->blocks, block);
755 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
756 itself, calling F for each. The DATA is passed to F as well. */
759 walk_namespaces_r (tree namespace, walk_namespaces_fn f, void* data)
762 tree current = NAMESPACE_LEVEL (namespace)->namespaces;
764 result |= (*f) (namespace, data);
766 for (; current; current = TREE_CHAIN (current))
767 result |= walk_namespaces_r (current, f, data);
772 /* Walk all the namespaces, calling F for each. The DATA is passed to
776 walk_namespaces (walk_namespaces_fn f, void* data)
778 return walk_namespaces_r (global_namespace, f, data);
781 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
782 DATA is non-NULL, this is the last time we will call
783 wrapup_global_declarations for this NAMESPACE. */
786 wrapup_globals_for_namespace (tree namespace, void* data)
788 struct cp_binding_level *level = NAMESPACE_LEVEL (namespace);
789 varray_type statics = level->static_decls;
790 tree *vec = &VARRAY_TREE (statics, 0);
791 int len = VARRAY_ACTIVE_SIZE (statics);
792 int last_time = (data != 0);
796 check_global_declarations (vec, len);
800 /* Write out any globals that need to be output. */
801 return wrapup_global_declarations (vec, len);
805 /* In C++, you don't have to write `struct S' to refer to `S'; you
806 can just use `S'. We accomplish this by creating a TYPE_DECL as
807 if the user had written `typedef struct S S'. Create and return
808 the TYPE_DECL for TYPE. */
811 create_implicit_typedef (tree name, tree type)
815 decl = build_decl (TYPE_DECL, name, type);
816 DECL_ARTIFICIAL (decl) = 1;
817 /* There are other implicit type declarations, like the one *within*
818 a class that allows you to write `S::S'. We must distinguish
820 SET_DECL_IMPLICIT_TYPEDEF_P (decl);
821 TYPE_NAME (type) = decl;
826 /* Remember a local name for name-mangling purposes. */
829 push_local_name (tree decl)
834 timevar_push (TV_NAME_LOOKUP);
836 VARRAY_TREE_INIT (local_names, 8, "local_names");
838 name = DECL_NAME (decl);
840 nelts = VARRAY_ACTIVE_SIZE (local_names);
841 for (i = 0; i < nelts; i++)
843 t = VARRAY_TREE (local_names, i);
844 if (DECL_NAME (t) == name)
846 if (!DECL_LANG_SPECIFIC (decl))
847 retrofit_lang_decl (decl);
848 DECL_LANG_SPECIFIC (decl)->decl_flags.u2sel = 1;
849 if (DECL_LANG_SPECIFIC (t))
850 DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
852 DECL_DISCRIMINATOR (decl) = 1;
854 VARRAY_TREE (local_names, i) = decl;
855 timevar_pop (TV_NAME_LOOKUP);
860 VARRAY_PUSH_TREE (local_names, decl);
861 timevar_pop (TV_NAME_LOOKUP);
864 /* Subroutine of duplicate_decls: return truthvalue of whether
865 or not types of these decls match.
867 For C++, we must compare the parameter list so that `int' can match
868 `int&' in a parameter position, but `int&' is not confused with
872 decls_match (tree newdecl, tree olddecl)
876 if (newdecl == olddecl)
879 if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
880 /* If the two DECLs are not even the same kind of thing, we're not
881 interested in their types. */
884 if (TREE_CODE (newdecl) == FUNCTION_DECL)
886 tree f1 = TREE_TYPE (newdecl);
887 tree f2 = TREE_TYPE (olddecl);
888 tree p1 = TYPE_ARG_TYPES (f1);
889 tree p2 = TYPE_ARG_TYPES (f2);
891 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
892 && ! (DECL_EXTERN_C_P (newdecl)
893 && DECL_EXTERN_C_P (olddecl)))
896 if (TREE_CODE (f1) != TREE_CODE (f2))
899 if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
901 if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
902 && (DECL_BUILT_IN (olddecl)
903 #ifndef NO_IMPLICIT_EXTERN_C
904 || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
905 || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
909 types_match = self_promoting_args_p (p1);
910 if (p1 == void_list_node)
911 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
913 #ifndef NO_IMPLICIT_EXTERN_C
914 else if (p1 == NULL_TREE
915 && (DECL_EXTERN_C_P (olddecl)
916 && DECL_IN_SYSTEM_HEADER (olddecl)
917 && !DECL_CLASS_SCOPE_P (olddecl))
918 && (DECL_EXTERN_C_P (newdecl)
919 && DECL_IN_SYSTEM_HEADER (newdecl)
920 && !DECL_CLASS_SCOPE_P (newdecl)))
922 types_match = self_promoting_args_p (p2);
923 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
927 types_match = compparms (p1, p2);
932 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
934 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
935 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
938 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
939 DECL_TEMPLATE_PARMS (olddecl)))
942 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
943 types_match = same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)),
944 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl)));
946 types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
947 DECL_TEMPLATE_RESULT (newdecl));
951 if (TREE_TYPE (newdecl) == error_mark_node)
952 types_match = TREE_TYPE (olddecl) == error_mark_node;
953 else if (TREE_TYPE (olddecl) == NULL_TREE)
954 types_match = TREE_TYPE (newdecl) == NULL_TREE;
955 else if (TREE_TYPE (newdecl) == NULL_TREE)
958 types_match = comptypes (TREE_TYPE (newdecl),
960 COMPARE_REDECLARATION);
966 /* If NEWDECL is `static' and an `extern' was seen previously,
967 warn about it. OLDDECL is the previous declaration.
969 Note that this does not apply to the C++ case of declaring
970 a variable `extern const' and then later `const'.
972 Don't complain about built-in functions, since they are beyond
973 the user's control. */
976 warn_extern_redeclared_static (tree newdecl, tree olddecl)
980 if (TREE_CODE (newdecl) == TYPE_DECL
981 || TREE_CODE (newdecl) == TEMPLATE_DECL
982 || TREE_CODE (newdecl) == CONST_DECL
983 || TREE_CODE (newdecl) == NAMESPACE_DECL)
986 /* Don't get confused by static member functions; that's a different
988 if (TREE_CODE (newdecl) == FUNCTION_DECL
989 && DECL_STATIC_FUNCTION_P (newdecl))
992 /* If the old declaration was `static', or the new one isn't, then
993 then everything is OK. */
994 if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
997 /* It's OK to declare a builtin function as `static'. */
998 if (TREE_CODE (olddecl) == FUNCTION_DECL
999 && DECL_ARTIFICIAL (olddecl))
1002 name = DECL_ASSEMBLER_NAME (newdecl);
1003 pedwarn ("%qD was declared %<extern%> and later %<static%>", newdecl);
1004 cp_pedwarn_at ("previous declaration of %qD", olddecl);
1007 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1008 If the redeclaration is invalid, a diagnostic is issued, and the
1009 error_mark_node is returned. Otherwise, OLDDECL is returned.
1011 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1015 duplicate_decls (tree newdecl, tree olddecl)
1017 unsigned olddecl_uid = DECL_UID (olddecl);
1018 int olddecl_friend = 0, types_match = 0;
1019 int new_defines_function = 0;
1021 if (newdecl == olddecl)
1024 types_match = decls_match (newdecl, olddecl);
1026 /* If either the type of the new decl or the type of the old decl is an
1027 error_mark_node, then that implies that we have already issued an
1028 error (earlier) for some bogus type specification, and in that case,
1029 it is rather pointless to harass the user with yet more error message
1030 about the same declaration, so just pretend the types match here. */
1031 if (TREE_TYPE (newdecl) == error_mark_node
1032 || TREE_TYPE (olddecl) == error_mark_node)
1035 if (DECL_P (olddecl)
1036 && TREE_CODE (newdecl) == FUNCTION_DECL
1037 && TREE_CODE (olddecl) == FUNCTION_DECL
1038 && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
1040 if (DECL_DECLARED_INLINE_P (newdecl)
1041 && DECL_UNINLINABLE (newdecl)
1042 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1043 /* Already warned elsewhere. */;
1044 else if (DECL_DECLARED_INLINE_P (olddecl)
1045 && DECL_UNINLINABLE (olddecl)
1046 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1047 /* Already warned. */;
1048 else if (DECL_DECLARED_INLINE_P (newdecl)
1049 && DECL_UNINLINABLE (olddecl)
1050 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1052 warning ("%Jfunction %qD redeclared as inline", newdecl, newdecl);
1053 warning ("%Jprevious declaration of %qD with attribute noinline",
1056 else if (DECL_DECLARED_INLINE_P (olddecl)
1057 && DECL_UNINLINABLE (newdecl)
1058 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1060 warning ("%Jfunction %qD redeclared with attribute noinline",
1062 warning ("%Jprevious declaration of %qD was inline",
1067 /* Check for redeclaration and other discrepancies. */
1068 if (TREE_CODE (olddecl) == FUNCTION_DECL
1069 && DECL_ARTIFICIAL (olddecl))
1071 if (TREE_CODE (newdecl) != FUNCTION_DECL)
1073 /* Avoid warnings redeclaring anticipated built-ins. */
1074 if (DECL_ANTICIPATED (olddecl))
1077 /* If you declare a built-in or predefined function name as static,
1078 the old definition is overridden, but optionally warn this was a
1079 bad choice of name. */
1080 if (! TREE_PUBLIC (newdecl))
1083 warning ("shadowing %s function %q#D",
1084 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
1086 /* Discard the old built-in function. */
1089 /* If the built-in is not ansi, then programs can override
1090 it even globally without an error. */
1091 else if (! DECL_BUILT_IN (olddecl))
1092 warning ("library function %q#D redeclared as non-function %q#D",
1096 error ("declaration of %q#D", newdecl);
1097 error ("conflicts with built-in declaration %q#D",
1102 else if (!types_match)
1104 /* Avoid warnings redeclaring anticipated built-ins. */
1105 if (DECL_ANTICIPATED (olddecl))
1107 /* Deal with fileptr_type_node. FILE type is not known
1108 at the time we create the builtins. */
1111 for (t1 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1112 t2 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1114 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1117 else if (TREE_VALUE (t2) == fileptr_type_node)
1119 tree t = TREE_VALUE (t1);
1121 if (TREE_CODE (t) == POINTER_TYPE
1122 && TYPE_NAME (TREE_TYPE (t))
1123 && DECL_NAME (TYPE_NAME (TREE_TYPE (t)))
1124 == get_identifier ("FILE")
1125 && compparms (TREE_CHAIN (t1), TREE_CHAIN (t2)))
1127 tree oldargs = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1129 TYPE_ARG_TYPES (TREE_TYPE (olddecl))
1130 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1131 types_match = decls_match (newdecl, olddecl);
1133 return duplicate_decls (newdecl, olddecl);
1134 TYPE_ARG_TYPES (TREE_TYPE (olddecl)) = oldargs;
1137 else if (! same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1140 else if ((DECL_EXTERN_C_P (newdecl)
1141 && DECL_EXTERN_C_P (olddecl))
1142 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1143 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1145 /* A near match; override the builtin. */
1147 if (TREE_PUBLIC (newdecl))
1149 warning ("new declaration %q#D", newdecl);
1150 warning ("ambiguates built-in declaration %q#D",
1153 else if (warn_shadow)
1154 warning ("shadowing %s function %q#D",
1155 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
1159 /* Discard the old built-in function. */
1162 /* Replace the old RTL to avoid problems with inlining. */
1163 COPY_DECL_RTL (newdecl, olddecl);
1165 /* Even if the types match, prefer the new declarations type
1166 for anticipated built-ins, for exception lists, etc... */
1167 else if (DECL_ANTICIPATED (olddecl))
1169 tree type = TREE_TYPE (newdecl);
1170 tree attribs = (*targetm.merge_type_attributes)
1171 (TREE_TYPE (olddecl), type);
1173 type = cp_build_type_attribute_variant (type, attribs);
1174 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = type;
1177 /* Whether or not the builtin can throw exceptions has no
1178 bearing on this declarator. */
1179 TREE_NOTHROW (olddecl) = 0;
1181 if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
1183 /* If a builtin function is redeclared as `static', merge
1184 the declarations, but make the original one static. */
1185 DECL_THIS_STATIC (olddecl) = 1;
1186 TREE_PUBLIC (olddecl) = 0;
1188 /* Make the old declaration consistent with the new one so
1189 that all remnants of the builtin-ness of this function
1190 will be banished. */
1191 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1192 COPY_DECL_RTL (newdecl, olddecl);
1195 else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1197 if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
1198 && TREE_CODE (newdecl) != TYPE_DECL
1199 && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
1200 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
1201 || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
1202 && TREE_CODE (olddecl) != TYPE_DECL
1203 && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
1204 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
1207 /* We do nothing special here, because C++ does such nasty
1208 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1209 get shadowed, and know that if we need to find a TYPE_DECL
1210 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1211 slot of the identifier. */
1215 if ((TREE_CODE (newdecl) == FUNCTION_DECL
1216 && DECL_FUNCTION_TEMPLATE_P (olddecl))
1217 || (TREE_CODE (olddecl) == FUNCTION_DECL
1218 && DECL_FUNCTION_TEMPLATE_P (newdecl)))
1221 error ("%q#D redeclared as different kind of symbol", newdecl);
1222 if (TREE_CODE (olddecl) == TREE_LIST)
1223 olddecl = TREE_VALUE (olddecl);
1224 cp_error_at ("previous declaration of %q#D", olddecl);
1226 return error_mark_node;
1228 else if (!types_match)
1230 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
1231 /* These are certainly not duplicate declarations; they're
1232 from different scopes. */
1235 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1237 /* The name of a class template may not be declared to refer to
1238 any other template, class, function, object, namespace, value,
1239 or type in the same scope. */
1240 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
1241 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1243 error ("declaration of template %q#D", newdecl);
1244 cp_error_at ("conflicts with previous declaration %q#D",
1247 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
1248 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
1249 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
1250 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
1251 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1252 DECL_TEMPLATE_PARMS (olddecl))
1253 /* Template functions can be disambiguated by
1255 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
1256 TREE_TYPE (TREE_TYPE (olddecl))))
1258 error ("new declaration %q#D", newdecl);
1259 cp_error_at ("ambiguates old declaration %q#D", olddecl);
1263 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1265 if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
1267 error ("declaration of C function %q#D conflicts with",
1269 cp_error_at ("previous declaration %q#D here", olddecl);
1271 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1272 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1274 error ("new declaration %q#D", newdecl);
1275 cp_error_at ("ambiguates old declaration %q#D", olddecl);
1282 error ("conflicting declaration %q#D", newdecl);
1283 cp_error_at ("%qD has a previous declaration as %q#D",
1285 return error_mark_node;
1288 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1289 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
1290 && (!DECL_TEMPLATE_INFO (newdecl)
1291 || (DECL_TI_TEMPLATE (newdecl)
1292 != DECL_TI_TEMPLATE (olddecl))))
1293 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
1294 && (!DECL_TEMPLATE_INFO (olddecl)
1295 || (DECL_TI_TEMPLATE (olddecl)
1296 != DECL_TI_TEMPLATE (newdecl))))))
1297 /* It's OK to have a template specialization and a non-template
1298 with the same type, or to have specializations of two
1299 different templates with the same type. Note that if one is a
1300 specialization, and the other is an instantiation of the same
1301 template, that we do not exit at this point. That situation
1302 can occur if we instantiate a template class, and then
1303 specialize one of its methods. This situation is valid, but
1304 the declarations must be merged in the usual way. */
1306 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1307 && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
1308 && !DECL_USE_TEMPLATE (newdecl))
1309 || (DECL_TEMPLATE_INSTANTIATION (newdecl)
1310 && !DECL_USE_TEMPLATE (olddecl))))
1311 /* One of the declarations is a template instantiation, and the
1312 other is not a template at all. That's OK. */
1314 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1316 /* In [namespace.alias] we have:
1318 In a declarative region, a namespace-alias-definition can be
1319 used to redefine a namespace-alias declared in that declarative
1320 region to refer only to the namespace to which it already
1323 Therefore, if we encounter a second alias directive for the same
1324 alias, we can just ignore the second directive. */
1325 if (DECL_NAMESPACE_ALIAS (newdecl)
1326 && (DECL_NAMESPACE_ALIAS (newdecl)
1327 == DECL_NAMESPACE_ALIAS (olddecl)))
1329 /* [namespace.alias]
1331 A namespace-name or namespace-alias shall not be declared as
1332 the name of any other entity in the same declarative region.
1333 A namespace-name defined at global scope shall not be
1334 declared as the name of any other entity in any global scope
1336 error ("declaration of namespace %qD conflicts with", newdecl);
1337 cp_error_at ("previous declaration of namespace %qD here", olddecl);
1338 return error_mark_node;
1342 const char *errmsg = redeclaration_error_message (newdecl, olddecl);
1345 error (errmsg, newdecl);
1346 if (DECL_NAME (olddecl) != NULL_TREE)
1347 cp_error_at ((DECL_INITIAL (olddecl)
1348 && namespace_bindings_p ())
1349 ? "%q#D previously defined here"
1350 : "%q#D previously declared here", olddecl);
1351 return error_mark_node;
1353 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1354 && DECL_INITIAL (olddecl) != NULL_TREE
1355 && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
1356 && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
1358 /* Prototype decl follows defn w/o prototype. */
1359 cp_warning_at ("prototype for %q#D", newdecl);
1360 warning ("%Jfollows non-prototype definition here", olddecl);
1362 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1363 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
1365 /* extern "C" int foo ();
1366 int foo () { bar (); }
1368 if (current_lang_depth () == 0)
1369 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1372 cp_error_at ("previous declaration of %q#D with %qL linkage",
1373 olddecl, DECL_LANGUAGE (olddecl));
1374 error ("conflicts with new declaration with %qL linkage",
1375 DECL_LANGUAGE (newdecl));
1379 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
1381 else if (TREE_CODE (olddecl) == FUNCTION_DECL)
1383 tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1384 tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1387 if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
1388 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
1390 for (; t1 && t1 != void_list_node;
1391 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
1392 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
1394 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
1397 pedwarn ("default argument given for parameter %d of %q#D",
1399 cp_pedwarn_at ("after previous specification in %q#D",
1404 error ("default argument given for parameter %d of %q#D",
1406 cp_error_at ("after previous specification in %q#D",
1411 if (DECL_DECLARED_INLINE_P (newdecl)
1412 && ! DECL_DECLARED_INLINE_P (olddecl)
1413 && TREE_ADDRESSABLE (olddecl) && warn_inline)
1415 warning ("%q#D was used before it was declared inline", newdecl);
1416 warning ("%Jprevious non-inline declaration here", olddecl);
1421 /* Do not merge an implicit typedef with an explicit one. In:
1425 typedef class A A __attribute__ ((foo));
1427 the attribute should apply only to the typedef. */
1428 if (TREE_CODE (olddecl) == TYPE_DECL
1429 && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
1430 || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
1433 /* If new decl is `static' and an `extern' was seen previously,
1435 warn_extern_redeclared_static (newdecl, olddecl);
1437 /* We have committed to returning 1 at this point. */
1438 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1440 /* Now that functions must hold information normally held
1441 by field decls, there is extra work to do so that
1442 declaration information does not get destroyed during
1444 if (DECL_VINDEX (olddecl))
1445 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
1446 if (DECL_CONTEXT (olddecl))
1447 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1448 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
1449 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1450 DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
1451 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
1452 DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
1453 if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
1454 SET_OVERLOADED_OPERATOR_CODE
1455 (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
1456 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
1458 /* Optionally warn about more than one declaration for the same
1459 name, but don't warn about a function declaration followed by a
1461 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
1462 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
1463 /* Don't warn about extern decl followed by definition. */
1464 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
1465 /* Don't warn about friends, let add_friend take care of it. */
1466 && ! (DECL_FRIEND_P (newdecl) || DECL_FRIEND_P (olddecl)))
1468 warning ("redundant redeclaration of %qD in same scope", newdecl);
1469 cp_warning_at ("previous declaration of %qD", olddecl);
1473 /* Deal with C++: must preserve virtual function table size. */
1474 if (TREE_CODE (olddecl) == TYPE_DECL)
1476 tree newtype = TREE_TYPE (newdecl);
1477 tree oldtype = TREE_TYPE (olddecl);
1479 if (newtype != error_mark_node && oldtype != error_mark_node
1480 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
1481 CLASSTYPE_FRIEND_CLASSES (newtype)
1482 = CLASSTYPE_FRIEND_CLASSES (oldtype);
1484 DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
1487 /* Copy all the DECL_... slots specified in the new decl
1488 except for any that we copy here from the old type. */
1489 DECL_ATTRIBUTES (newdecl)
1490 = (*targetm.merge_decl_attributes) (olddecl, newdecl);
1492 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1494 TREE_TYPE (olddecl) = TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl));
1495 DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
1496 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
1497 DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
1499 /* If the new declaration is a definition, update the file and
1500 line information on the declaration. */
1501 if (DECL_INITIAL (DECL_TEMPLATE_RESULT (olddecl)) == NULL_TREE
1502 && DECL_INITIAL (DECL_TEMPLATE_RESULT (newdecl)) != NULL_TREE)
1504 DECL_SOURCE_LOCATION (olddecl)
1505 = DECL_SOURCE_LOCATION (DECL_TEMPLATE_RESULT (olddecl))
1506 = DECL_SOURCE_LOCATION (newdecl);
1507 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1508 DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (olddecl))
1509 = DECL_ARGUMENTS (DECL_TEMPLATE_RESULT (newdecl));
1512 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1514 DECL_INLINE (DECL_TEMPLATE_RESULT (olddecl))
1515 |= DECL_INLINE (DECL_TEMPLATE_RESULT (newdecl));
1516 DECL_DECLARED_INLINE_P (DECL_TEMPLATE_RESULT (olddecl))
1517 |= DECL_DECLARED_INLINE_P (DECL_TEMPLATE_RESULT (newdecl));
1525 /* Automatically handles default parameters. */
1526 tree oldtype = TREE_TYPE (olddecl);
1529 /* Merge the data types specified in the two decls. */
1530 newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1532 /* If merge_types produces a non-typedef type, just use the old type. */
1533 if (TREE_CODE (newdecl) == TYPE_DECL
1534 && newtype == DECL_ORIGINAL_TYPE (newdecl))
1537 if (TREE_CODE (newdecl) == VAR_DECL)
1539 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
1540 DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
1541 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl)
1542 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl);
1545 /* Do this after calling `merge_types' so that default
1546 parameters don't confuse us. */
1547 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1548 && (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl))
1549 != TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl))))
1551 TREE_TYPE (newdecl) = build_exception_variant (newtype,
1552 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)));
1553 TREE_TYPE (olddecl) = build_exception_variant (newtype,
1554 TYPE_RAISES_EXCEPTIONS (oldtype));
1556 if ((pedantic || ! DECL_IN_SYSTEM_HEADER (olddecl))
1557 && ! DECL_IS_BUILTIN (olddecl)
1559 && !comp_except_specs (TYPE_RAISES_EXCEPTIONS (TREE_TYPE (newdecl)),
1560 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (olddecl)), 1))
1562 error ("declaration of %qF throws different exceptions",
1564 cp_error_at ("than previous declaration %qF", olddecl);
1567 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
1569 /* Lay the type out, unless already done. */
1570 if (! same_type_p (newtype, oldtype)
1571 && TREE_TYPE (newdecl) != error_mark_node
1572 && !(processing_template_decl && uses_template_parms (newdecl)))
1573 layout_type (TREE_TYPE (newdecl));
1575 if ((TREE_CODE (newdecl) == VAR_DECL
1576 || TREE_CODE (newdecl) == PARM_DECL
1577 || TREE_CODE (newdecl) == RESULT_DECL
1578 || TREE_CODE (newdecl) == FIELD_DECL
1579 || TREE_CODE (newdecl) == TYPE_DECL)
1580 && !(processing_template_decl && uses_template_parms (newdecl)))
1581 layout_decl (newdecl, 0);
1583 /* Merge the type qualifiers. */
1584 if (TREE_READONLY (newdecl))
1585 TREE_READONLY (olddecl) = 1;
1586 if (TREE_THIS_VOLATILE (newdecl))
1587 TREE_THIS_VOLATILE (olddecl) = 1;
1588 if (TREE_NOTHROW (newdecl))
1589 TREE_NOTHROW (olddecl) = 1;
1591 /* Merge deprecatedness. */
1592 if (TREE_DEPRECATED (newdecl))
1593 TREE_DEPRECATED (olddecl) = 1;
1595 /* Merge the initialization information. */
1596 if (DECL_INITIAL (newdecl) == NULL_TREE
1597 && DECL_INITIAL (olddecl) != NULL_TREE)
1599 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1600 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
1601 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
1602 && DECL_LANG_SPECIFIC (newdecl)
1603 && DECL_LANG_SPECIFIC (olddecl))
1605 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1606 DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
1610 /* Merge the section attribute.
1611 We want to issue an error if the sections conflict but that must be
1612 done later in decl_attributes since we are called before attributes
1614 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1615 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1617 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1619 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1620 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1621 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1622 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1623 TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
1624 TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl);
1625 DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
1626 DECL_IS_PURE (newdecl) |= DECL_IS_PURE (olddecl);
1627 /* Keep the old RTL. */
1628 COPY_DECL_RTL (olddecl, newdecl);
1630 else if (TREE_CODE (newdecl) == VAR_DECL
1631 && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
1633 /* Keep the old RTL. We cannot keep the old RTL if the old
1634 declaration was for an incomplete object and the new
1635 declaration is not since many attributes of the RTL will
1637 COPY_DECL_RTL (olddecl, newdecl);
1640 /* If cannot merge, then use the new type and qualifiers,
1641 and don't preserve the old rtl. */
1644 /* Clean out any memory we had of the old declaration. */
1645 tree oldstatic = value_member (olddecl, static_aggregates);
1647 TREE_VALUE (oldstatic) = error_mark_node;
1649 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1650 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1651 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1652 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1655 /* Merge the storage class information. */
1656 merge_weak (newdecl, olddecl);
1658 DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
1659 DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
1660 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1661 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
1662 if (! DECL_EXTERNAL (olddecl))
1663 DECL_EXTERNAL (newdecl) = 0;
1665 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
1667 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
1668 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
1669 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
1670 DECL_TEMPLATE_INSTANTIATED (newdecl)
1671 |= DECL_TEMPLATE_INSTANTIATED (olddecl);
1672 /* If the OLDDECL is an implicit instantiation, then the NEWDECL
1673 must be too. But, it may not yet be marked as such if the
1674 caller has created NEWDECL, but has not yet figured out that
1675 it is a redeclaration. */
1676 if (DECL_IMPLICIT_INSTANTIATION (olddecl)
1677 && !DECL_USE_TEMPLATE (newdecl))
1678 SET_DECL_IMPLICIT_INSTANTIATION (newdecl);
1679 /* Don't really know how much of the language-specific
1680 values we should copy from old to new. */
1681 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
1682 DECL_LANG_SPECIFIC (newdecl)->decl_flags.u2 =
1683 DECL_LANG_SPECIFIC (olddecl)->decl_flags.u2;
1684 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
1685 DECL_REPO_AVAILABLE_P (newdecl) = DECL_REPO_AVAILABLE_P (olddecl);
1686 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
1687 DECL_INITIALIZED_IN_CLASS_P (newdecl)
1688 |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
1689 olddecl_friend = DECL_FRIEND_P (olddecl);
1691 /* Only functions have DECL_BEFRIENDING_CLASSES. */
1692 if (TREE_CODE (newdecl) == FUNCTION_DECL
1693 || DECL_FUNCTION_TEMPLATE_P (newdecl))
1695 DECL_BEFRIENDING_CLASSES (newdecl)
1696 = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
1697 DECL_BEFRIENDING_CLASSES (olddecl));
1698 /* DECL_THUNKS is only valid for virtual functions,
1699 otherwise it is a DECL_FRIEND_CONTEXT. */
1700 if (DECL_VIRTUAL_P (newdecl))
1701 DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl);
1705 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1707 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
1708 && !DECL_TEMPLATE_INSTANTIATION (newdecl))
1710 /* If newdecl is not a specialization, then it is not a
1711 template-related function at all. And that means that we
1712 should have exited above, returning 0. */
1713 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl));
1715 if (TREE_USED (olddecl))
1716 /* From [temp.expl.spec]:
1718 If a template, a member template or the member of a class
1719 template is explicitly specialized then that
1720 specialization shall be declared before the first use of
1721 that specialization that would cause an implicit
1722 instantiation to take place, in every translation unit in
1723 which such a use occurs. */
1724 error ("explicit specialization of %qD after first use",
1727 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
1729 /* [temp.expl.spec/14] We don't inline explicit specialization
1730 just because the primary template says so. */
1734 if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
1735 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
1737 DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
1739 /* If either decl says `inline', this fn is inline, unless
1740 its definition was passed already. */
1741 if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
1742 DECL_INLINE (olddecl) = 1;
1743 DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
1745 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
1746 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
1749 /* Preserve abstractness on cloned [cd]tors. */
1750 DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
1754 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1755 COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
1756 COPY_DECL_RTL (newdecl, olddecl);
1758 if (! types_match || new_defines_function)
1760 /* These need to be copied so that the names are available.
1761 Note that if the types do match, we'll preserve inline
1762 info and other bits, but if not, we won't. */
1763 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
1764 DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
1766 if (new_defines_function)
1767 /* If defining a function declared with other language
1768 linkage, use the previously declared language linkage. */
1769 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1770 else if (types_match)
1772 /* If redeclaring a builtin function, and not a definition,
1773 it stays built in. */
1774 if (DECL_BUILT_IN (olddecl))
1776 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
1777 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
1778 /* If we're keeping the built-in definition, keep the rtl,
1779 regardless of declaration matches. */
1780 COPY_DECL_RTL (olddecl, newdecl);
1783 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
1784 /* Don't clear out the arguments if we're redefining a function. */
1785 if (DECL_ARGUMENTS (olddecl))
1786 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
1789 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1790 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
1792 /* Now preserve various other info from the definition. */
1793 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
1794 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
1795 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
1796 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
1798 /* Warn about conflicting visibility specifications. */
1799 if (DECL_VISIBILITY_SPECIFIED (olddecl)
1800 && DECL_VISIBILITY_SPECIFIED (newdecl)
1801 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
1803 warning ("%J%qD: visibility attribute ignored because it",
1805 warning ("%Jconflicts with previous declaration here", olddecl);
1807 /* Choose the declaration which specified visibility. */
1808 if (DECL_VISIBILITY_SPECIFIED (olddecl))
1810 DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
1811 DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
1814 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
1815 with that from NEWDECL below. */
1816 if (DECL_LANG_SPECIFIC (olddecl))
1818 gcc_assert (DECL_LANG_SPECIFIC (olddecl)
1819 != DECL_LANG_SPECIFIC (newdecl));
1820 ggc_free (DECL_LANG_SPECIFIC (olddecl));
1823 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1827 function_size = sizeof (struct tree_decl);
1829 memcpy ((char *) olddecl + sizeof (struct tree_common),
1830 (char *) newdecl + sizeof (struct tree_common),
1831 function_size - sizeof (struct tree_common));
1833 if (DECL_TEMPLATE_INSTANTIATION (newdecl))
1834 /* If newdecl is a template instantiation, it is possible that
1835 the following sequence of events has occurred:
1837 o A friend function was declared in a class template. The
1838 class template was instantiated.
1840 o The instantiation of the friend declaration was
1841 recorded on the instantiation list, and is newdecl.
1843 o Later, however, instantiate_class_template called pushdecl
1844 on the newdecl to perform name injection. But, pushdecl in
1845 turn called duplicate_decls when it discovered that another
1846 declaration of a global function with the same name already
1849 o Here, in duplicate_decls, we decided to clobber newdecl.
1851 If we're going to do that, we'd better make sure that
1852 olddecl, and not newdecl, is on the list of
1853 instantiations so that if we try to do the instantiation
1854 again we won't get the clobbered declaration. */
1855 reregister_specialization (newdecl,
1856 DECL_TI_TEMPLATE (newdecl),
1861 memcpy ((char *) olddecl + sizeof (struct tree_common),
1862 (char *) newdecl + sizeof (struct tree_common),
1863 sizeof (struct tree_decl) - sizeof (struct tree_common)
1864 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
1867 DECL_UID (olddecl) = olddecl_uid;
1869 DECL_FRIEND_P (olddecl) = 1;
1871 /* NEWDECL contains the merged attribute lists.
1872 Update OLDDECL to be the same. */
1873 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
1875 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
1876 so that encode_section_info has a chance to look at the new decl
1877 flags and attributes. */
1878 if (DECL_RTL_SET_P (olddecl)
1879 && (TREE_CODE (olddecl) == FUNCTION_DECL
1880 || (TREE_CODE (olddecl) == VAR_DECL
1881 && TREE_STATIC (olddecl))))
1882 make_decl_rtl (olddecl);
1884 /* The NEWDECL will no longer be needed. Because every out-of-class
1885 declaration of a member results in a call to duplicate_decls,
1886 freeing these nodes represents in a significant savings. */
1892 /* Return zero if the declaration NEWDECL is valid
1893 when the declaration OLDDECL (assumed to be for the same name)
1894 has already been seen.
1895 Otherwise return an error message format string with a %s
1896 where the identifier should go. */
1899 redeclaration_error_message (tree newdecl, tree olddecl)
1901 if (TREE_CODE (newdecl) == TYPE_DECL)
1903 /* Because C++ can put things into name space for free,
1904 constructs like "typedef struct foo { ... } foo"
1905 would look like an erroneous redeclaration. */
1906 if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
1909 return "redefinition of %q#D";
1911 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1913 /* If this is a pure function, its olddecl will actually be
1914 the original initialization to `0' (which we force to call
1915 abort()). Don't complain about redefinition in this case. */
1916 if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl)
1917 && DECL_INITIAL (olddecl) == NULL_TREE)
1920 /* If both functions come from different namespaces, this is not
1921 a redeclaration - this is a conflict with a used function. */
1922 if (DECL_NAMESPACE_SCOPE_P (olddecl)
1923 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
1924 return "%qD conflicts with used function";
1926 /* We'll complain about linkage mismatches in
1927 warn_extern_redeclared_static. */
1929 /* Defining the same name twice is no good. */
1930 if (DECL_INITIAL (olddecl) != NULL_TREE
1931 && DECL_INITIAL (newdecl) != NULL_TREE)
1933 if (DECL_NAME (olddecl) == NULL_TREE)
1934 return "%q#D not declared in class";
1936 return "redefinition of %q#D";
1940 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1944 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1946 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl))
1947 && COMPLETE_TYPE_P (TREE_TYPE (olddecl)))
1948 return "redefinition of %q#D";
1952 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL
1953 || (DECL_TEMPLATE_RESULT (newdecl)
1954 == DECL_TEMPLATE_RESULT (olddecl)))
1957 nt = DECL_TEMPLATE_RESULT (newdecl);
1958 if (DECL_TEMPLATE_INFO (nt))
1959 nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt));
1960 ot = DECL_TEMPLATE_RESULT (olddecl);
1961 if (DECL_TEMPLATE_INFO (ot))
1962 ot = DECL_TEMPLATE_RESULT (template_for_substitution (ot));
1963 if (DECL_INITIAL (nt) && DECL_INITIAL (ot))
1964 return "redefinition of %q#D";
1968 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
1970 /* Objects declared at top level: */
1971 /* If at least one is a reference, it's ok. */
1972 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
1974 /* Reject two definitions. */
1975 return "redefinition of %q#D";
1979 /* Objects declared with block scope: */
1980 /* Reject two definitions, and reject a definition
1981 together with an external reference. */
1982 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
1983 return "redeclaration of %q#D";
1988 /* Create a new label, named ID. */
1991 make_label_decl (tree id, int local_p)
1995 decl = build_decl (LABEL_DECL, id, void_type_node);
1997 DECL_CONTEXT (decl) = current_function_decl;
1998 DECL_MODE (decl) = VOIDmode;
1999 C_DECLARED_LABEL_FLAG (decl) = local_p;
2001 /* Say where one reference is to the label, for the sake of the
2002 error if it is not defined. */
2003 DECL_SOURCE_LOCATION (decl) = input_location;
2005 /* Record the fact that this identifier is bound to this label. */
2006 SET_IDENTIFIER_LABEL_VALUE (id, decl);
2011 /* Record this label on the list of used labels so that we can check
2012 at the end of the function to see whether or not the label was
2013 actually defined, and so we can check when the label is defined whether
2014 this use is valid. */
2017 use_label (tree decl)
2019 if (named_label_uses == NULL
2020 || named_label_uses->names_in_scope != current_binding_level->names
2021 || named_label_uses->label_decl != decl)
2023 struct named_label_use_list *new_ent;
2024 new_ent = GGC_NEW (struct named_label_use_list);
2025 new_ent->label_decl = decl;
2026 new_ent->names_in_scope = current_binding_level->names;
2027 new_ent->binding_level = current_binding_level;
2028 new_ent->o_goto_locus = input_location;
2029 new_ent->next = named_label_uses;
2030 named_label_uses = new_ent;
2034 /* Look for a label named ID in the current function. If one cannot
2035 be found, create one. (We keep track of used, but undefined,
2036 labels, and complain about them at the end of a function.) */
2039 lookup_label (tree id)
2042 struct named_label_list *ent;
2044 timevar_push (TV_NAME_LOOKUP);
2045 /* You can't use labels at global scope. */
2046 if (current_function_decl == NULL_TREE)
2048 error ("label %qE referenced outside of any function", id);
2049 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2052 /* See if we've already got this label. */
2053 decl = IDENTIFIER_LABEL_VALUE (id);
2054 if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
2055 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2057 /* Record this label on the list of labels used in this function.
2058 We do this before calling make_label_decl so that we get the
2059 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2060 ent = GGC_CNEW (struct named_label_list);
2061 ent->old_value = IDENTIFIER_LABEL_VALUE (id);
2062 ent->next = named_labels;
2065 /* We need a new label. */
2066 decl = make_label_decl (id, /*local_p=*/0);
2068 /* Now fill in the information we didn't have before. */
2069 ent->label_decl = decl;
2071 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2074 /* Declare a local label named ID. */
2077 declare_local_label (tree id)
2081 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2082 this scope we can restore the old value of
2083 IDENTIFIER_TYPE_VALUE. */
2084 current_binding_level->shadowed_labels
2085 = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
2086 current_binding_level->shadowed_labels);
2087 /* Look for the label. */
2088 decl = make_label_decl (id, /*local_p=*/1);
2089 /* Now fill in the information we didn't have before. */
2090 TREE_VALUE (current_binding_level->shadowed_labels) = decl;
2095 /* Returns nonzero if it is ill-formed to jump past the declaration of
2096 DECL. Returns 2 if it's also a real problem. */
2099 decl_jump_unsafe (tree decl)
2101 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
2104 if (DECL_INITIAL (decl) == NULL_TREE
2105 && pod_type_p (TREE_TYPE (decl)))
2108 /* This is really only important if we're crossing an initialization.
2109 The POD stuff is just pedantry; why should it matter if the class
2110 contains a field of pointer to member type? */
2111 if (DECL_INITIAL (decl)
2112 || (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
2117 /* Check that a single previously seen jump to a newly defined label
2118 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2119 the jump context; NAMES are the names in scope in LEVEL at the jump
2120 context; FILE and LINE are the source position of the jump or 0. */
2123 check_previous_goto_1 (tree decl,
2124 struct cp_binding_level* level,
2125 tree names, const location_t *locus)
2129 struct cp_binding_level *b = current_binding_level;
2130 for (; b; b = b->level_chain)
2132 tree new_decls = b->names;
2133 tree old_decls = (b == level ? names : NULL_TREE);
2134 for (; new_decls != old_decls;
2135 new_decls = TREE_CHAIN (new_decls))
2137 int problem = decl_jump_unsafe (new_decls);
2144 pedwarn ("jump to label %qD", decl);
2146 pedwarn ("jump to case label");
2149 pedwarn ("%H from here", locus);
2154 cp_error_at (" crosses initialization of %q#D",
2157 cp_pedwarn_at (" enters scope of non-POD %q#D",
2163 if ((b->kind == sk_try || b->kind == sk_catch) && ! saw_eh)
2168 pedwarn ("jump to label %qD", decl);
2170 pedwarn ("jump to case label");
2173 pedwarn ("%H from here", locus);
2176 if (b->kind == sk_try)
2177 error (" enters try block");
2179 error (" enters catch block");
2186 check_previous_goto (struct named_label_use_list* use)
2188 check_previous_goto_1 (use->label_decl, use->binding_level,
2189 use->names_in_scope, &use->o_goto_locus);
2193 check_switch_goto (struct cp_binding_level* level)
2195 check_previous_goto_1 (NULL_TREE, level, level->names, NULL);
2198 /* Check that any previously seen jumps to a newly defined label DECL
2199 are OK. Called by define_label. */
2202 check_previous_gotos (tree decl)
2204 struct named_label_use_list **usep;
2206 if (! TREE_USED (decl))
2209 for (usep = &named_label_uses; *usep; )
2211 struct named_label_use_list *use = *usep;
2212 if (use->label_decl == decl)
2214 check_previous_goto (use);
2218 usep = &(use->next);
2222 /* Check that a new jump to a label DECL is OK. Called by
2223 finish_goto_stmt. */
2226 check_goto (tree decl)
2230 struct named_label_list *lab;
2232 /* We can't know where a computed goto is jumping. So we assume
2234 if (! DECL_P (decl))
2237 /* If the label hasn't been defined yet, defer checking. */
2238 if (! DECL_INITIAL (decl))
2244 for (lab = named_labels; lab; lab = lab->next)
2245 if (decl == lab->label_decl)
2248 /* If the label is not on named_labels it's a gcc local label, so
2249 it must be in an outer scope, so jumping to it is always OK. */
2253 if ((lab->in_try_scope || lab->in_catch_scope || lab->bad_decls)
2256 cp_pedwarn_at ("jump to label %qD", decl);
2257 pedwarn (" from here");
2261 for (bad = lab->bad_decls; bad; bad = TREE_CHAIN (bad))
2263 tree b = TREE_VALUE (bad);
2264 int u = decl_jump_unsafe (b);
2266 if (u > 1 && DECL_ARTIFICIAL (b))
2267 /* Can't skip init of __exception_info. */
2268 error ("%J enters catch block", b);
2270 cp_error_at (" skips initialization of %q#D", b);
2272 cp_pedwarn_at (" enters scope of non-POD %q#D", b);
2275 if (lab->in_try_scope)
2276 error (" enters try block");
2277 else if (lab->in_catch_scope)
2278 error (" enters catch block");
2281 /* Define a label, specifying the location in the source file.
2282 Return the LABEL_DECL node for the label. */
2285 define_label (location_t location, tree name)
2287 tree decl = lookup_label (name);
2288 struct named_label_list *ent;
2289 struct cp_binding_level *p;
2291 timevar_push (TV_NAME_LOOKUP);
2292 for (ent = named_labels; ent; ent = ent->next)
2293 if (ent->label_decl == decl)
2296 /* After labels, make any new cleanups in the function go into their
2297 own new (temporary) binding contour. */
2298 for (p = current_binding_level;
2299 p->kind != sk_function_parms;
2301 p->more_cleanups_ok = 0;
2303 if (name == get_identifier ("wchar_t"))
2304 pedwarn ("label named wchar_t");
2306 if (DECL_INITIAL (decl) != NULL_TREE)
2307 error ("duplicate label %qD", decl);
2310 /* Mark label as having been defined. */
2311 DECL_INITIAL (decl) = error_mark_node;
2312 /* Say where in the source. */
2313 DECL_SOURCE_LOCATION (decl) = location;
2316 ent->names_in_scope = current_binding_level->names;
2317 ent->binding_level = current_binding_level;
2319 check_previous_gotos (decl);
2322 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2327 struct cp_binding_level *level;
2328 struct cp_switch *next;
2329 /* The SWITCH_STMT being built. */
2331 /* A splay-tree mapping the low element of a case range to the high
2332 element, or NULL_TREE if there is no high element. Used to
2333 determine whether or not a new case label duplicates an old case
2334 label. We need a tree, rather than simply a hash table, because
2335 of the GNU case range extension. */
2339 /* A stack of the currently active switch statements. The innermost
2340 switch statement is on the top of the stack. There is no need to
2341 mark the stack for garbage collection because it is only active
2342 during the processing of the body of a function, and we never
2343 collect at that point. */
2345 static struct cp_switch *switch_stack;
2347 /* Called right after a switch-statement condition is parsed.
2348 SWITCH_STMT is the switch statement being parsed. */
2351 push_switch (tree switch_stmt)
2353 struct cp_switch *p = xmalloc (sizeof (struct cp_switch));
2354 p->level = current_binding_level;
2355 p->next = switch_stack;
2356 p->switch_stmt = switch_stmt;
2357 p->cases = splay_tree_new (case_compare, NULL, NULL);
2364 struct cp_switch *cs = switch_stack;
2366 /* Emit warnings as needed. */
2367 c_do_switch_warnings (cs->cases, cs->switch_stmt);
2369 splay_tree_delete (cs->cases);
2370 switch_stack = switch_stack->next;
2374 /* Note that we've seen a definition of a case label, and complain if this
2375 is a bad place for one. */
2378 finish_case_label (tree low_value, tree high_value)
2381 struct cp_binding_level *p;
2383 if (processing_template_decl)
2387 /* For templates, just add the case label; we'll do semantic
2388 analysis at instantiation-time. */
2389 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
2390 return add_stmt (build_case_label (low_value, high_value, label));
2393 /* Find the condition on which this switch statement depends. */
2394 cond = SWITCH_STMT_COND (switch_stack->switch_stmt);
2395 if (cond && TREE_CODE (cond) == TREE_LIST)
2396 cond = TREE_VALUE (cond);
2398 r = c_add_case_label (switch_stack->cases, cond, TREE_TYPE (cond),
2399 low_value, high_value);
2401 check_switch_goto (switch_stack->level);
2403 /* After labels, make any new cleanups in the function go into their
2404 own new (temporary) binding contour. */
2405 for (p = current_binding_level;
2406 p->kind != sk_function_parms;
2408 p->more_cleanups_ok = 0;
2413 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
2416 typename_hash (const void* k)
2421 hash = (htab_hash_pointer (TYPE_CONTEXT (t))
2422 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));
2427 typedef struct typename_info {
2435 /* Compare two TYPENAME_TYPEs. K1 and K2 are really of type `tree'. */
2438 typename_compare (const void * k1, const void * k2)
2441 const typename_info *t2;
2444 t2 = (const typename_info *) k2;
2446 return (DECL_NAME (TYPE_NAME (t1)) == t2->name
2447 && TYPE_CONTEXT (t1) == t2->scope
2448 && TYPENAME_TYPE_FULLNAME (t1) == t2->template_id
2449 && TYPENAME_IS_ENUM_P (t1) == t2->enum_p
2450 && TYPENAME_IS_CLASS_P (t1) == t2->class_p);
2453 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
2454 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
2456 Returns the new TYPENAME_TYPE. */
2458 static GTY ((param_is (union tree_node))) htab_t typename_htab;
2461 build_typename_type (tree context, tree name, tree fullname,
2462 enum tag_types tag_type)
2470 if (typename_htab == NULL)
2471 typename_htab = htab_create_ggc (61, &typename_hash,
2472 &typename_compare, NULL);
2474 ti.scope = FROB_CONTEXT (context);
2476 ti.template_id = fullname;
2477 ti.enum_p = tag_type == enum_type;
2478 ti.class_p = (tag_type == class_type
2479 || tag_type == record_type
2480 || tag_type == union_type);
2481 hash = (htab_hash_pointer (ti.scope)
2482 ^ htab_hash_pointer (ti.name));
2484 /* See if we already have this type. */
2485 e = htab_find_slot_with_hash (typename_htab, &ti, hash, INSERT);
2490 /* Build the TYPENAME_TYPE. */
2491 t = make_aggr_type (TYPENAME_TYPE);
2492 TYPE_CONTEXT (t) = ti.scope;
2493 TYPENAME_TYPE_FULLNAME (t) = ti.template_id;
2494 TYPENAME_IS_ENUM_P (t) = ti.enum_p;
2495 TYPENAME_IS_CLASS_P (t) = ti.class_p;
2497 /* Build the corresponding TYPE_DECL. */
2498 d = build_decl (TYPE_DECL, name, t);
2499 TYPE_NAME (TREE_TYPE (d)) = d;
2500 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2501 DECL_CONTEXT (d) = FROB_CONTEXT (context);
2502 DECL_ARTIFICIAL (d) = 1;
2504 /* Store it in the hash table. */
2511 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
2512 provided to name the type. Returns an appropriate type, unless an
2513 error occurs, in which case error_mark_node is returned. If we
2514 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
2515 return that, rather than the _TYPE it corresponds to, in other
2516 cases we look through the type decl. If TF_ERROR is set, complain
2517 about errors, otherwise be quiet. */
2520 make_typename_type (tree context, tree name, enum tag_types tag_type,
2521 tsubst_flags_t complain)
2525 if (name == error_mark_node
2526 || context == NULL_TREE
2527 || context == error_mark_node)
2528 return error_mark_node;
2532 if (!(TYPE_LANG_SPECIFIC (name)
2533 && (CLASSTYPE_IS_TEMPLATE (name)
2534 || CLASSTYPE_USE_TEMPLATE (name))))
2535 name = TYPE_IDENTIFIER (name);
2537 /* Create a TEMPLATE_ID_EXPR for the type. */
2538 name = build_nt (TEMPLATE_ID_EXPR,
2539 CLASSTYPE_TI_TEMPLATE (name),
2540 CLASSTYPE_TI_ARGS (name));
2542 else if (TREE_CODE (name) == TYPE_DECL)
2543 name = DECL_NAME (name);
2547 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
2549 name = TREE_OPERAND (name, 0);
2550 if (TREE_CODE (name) == TEMPLATE_DECL)
2551 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
2553 if (TREE_CODE (name) == TEMPLATE_DECL)
2555 error ("%qD used without template parameters", name);
2556 return error_mark_node;
2558 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
2559 gcc_assert (TYPE_P (context));
2561 if (!dependent_type_p (context)
2562 || currently_open_class (context))
2564 if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
2566 tree tmpl = NULL_TREE;
2567 if (IS_AGGR_TYPE (context))
2568 tmpl = lookup_field (context, name, 0, false);
2569 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
2571 if (complain & tf_error)
2572 error ("no class template named %q#T in %q#T",
2574 return error_mark_node;
2577 if (complain & tf_error)
2578 perform_or_defer_access_check (TYPE_BINFO (context), tmpl);
2580 return lookup_template_class (tmpl,
2581 TREE_OPERAND (fullname, 1),
2583 /*entering_scope=*/0,
2584 tf_error | tf_warning | tf_user);
2590 if (!IS_AGGR_TYPE (context))
2592 if (complain & tf_error)
2593 error ("no type named %q#T in %q#T", name, context);
2594 return error_mark_node;
2597 t = lookup_field (context, name, 0, true);
2600 if (TREE_CODE (t) != TYPE_DECL)
2602 if (complain & tf_error)
2603 error ("no type named %q#T in %q#T", name, context);
2604 return error_mark_node;
2607 if (complain & tf_error)
2608 perform_or_defer_access_check (TYPE_BINFO (context), t);
2610 if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
2618 /* If the CONTEXT is not a template type, then either the field is
2619 there now or its never going to be. */
2620 if (!dependent_type_p (context))
2622 if (complain & tf_error)
2623 error ("no type named %q#T in %q#T", name, context);
2624 return error_mark_node;
2627 return build_typename_type (context, name, fullname, tag_type);
2630 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
2631 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
2632 in which case error_mark_node is returned.
2634 If PARM_LIST is non-NULL, also make sure that the template parameter
2635 list of TEMPLATE_DECL matches.
2637 If COMPLAIN zero, don't complain about any errors that occur. */
2640 make_unbound_class_template (tree context, tree name, tree parm_list,
2641 tsubst_flags_t complain)
2647 name = TYPE_IDENTIFIER (name);
2648 else if (DECL_P (name))
2649 name = DECL_NAME (name);
2650 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
2652 if (!dependent_type_p (context)
2653 || currently_open_class (context))
2655 tree tmpl = NULL_TREE;
2657 if (IS_AGGR_TYPE (context))
2658 tmpl = lookup_field (context, name, 0, false);
2660 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
2662 if (complain & tf_error)
2663 error ("no class template named %q#T in %q#T", name, context);
2664 return error_mark_node;
2668 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl), parm_list))
2670 if (complain & tf_error)
2672 error ("template parameters do not match template");
2673 cp_error_at ("%qD declared here", tmpl);
2675 return error_mark_node;
2678 if (complain & tf_error)
2679 perform_or_defer_access_check (TYPE_BINFO (context), tmpl);
2684 /* Build the UNBOUND_CLASS_TEMPLATE. */
2685 t = make_aggr_type (UNBOUND_CLASS_TEMPLATE);
2686 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
2687 TREE_TYPE (t) = NULL_TREE;
2689 /* Build the corresponding TEMPLATE_DECL. */
2690 d = build_decl (TEMPLATE_DECL, name, t);
2691 TYPE_NAME (TREE_TYPE (d)) = d;
2692 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2693 DECL_CONTEXT (d) = FROB_CONTEXT (context);
2694 DECL_ARTIFICIAL (d) = 1;
2695 DECL_TEMPLATE_PARMS (d) = parm_list;
2702 /* Push the declarations of builtin types into the namespace.
2703 RID_INDEX is the index of the builtin type in the array
2704 RID_POINTERS. NAME is the name used when looking up the builtin
2705 type. TYPE is the _TYPE node for the builtin type. */
2708 record_builtin_type (enum rid rid_index,
2712 tree rname = NULL_TREE, tname = NULL_TREE;
2713 tree tdecl = NULL_TREE;
2715 if ((int) rid_index < (int) RID_MAX)
2716 rname = ridpointers[(int) rid_index];
2718 tname = get_identifier (name);
2720 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
2721 eliminated. Built-in types should not be looked up name; their
2722 names are keywords that the parser can recognize. However, there
2723 is code in c-common.c that uses identifier_global_value to look
2724 up built-in types by name. */
2727 tdecl = build_decl (TYPE_DECL, tname, type);
2728 DECL_ARTIFICIAL (tdecl) = 1;
2729 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
2735 tdecl = build_decl (TYPE_DECL, rname, type);
2736 DECL_ARTIFICIAL (tdecl) = 1;
2738 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
2741 if (!TYPE_NAME (type))
2742 TYPE_NAME (type) = tdecl;
2745 debug_hooks->type_decl (tdecl, 0);
2748 /* Record one of the standard Java types.
2749 * Declare it as having the given NAME.
2750 * If SIZE > 0, it is the size of one of the integral types;
2751 * otherwise it is the negative of the size of one of the other types. */
2754 record_builtin_java_type (const char* name, int size)
2758 type = make_signed_type (size);
2759 else if (size > -32)
2760 { /* "__java_char" or ""__java_boolean". */
2761 type = make_unsigned_type (-size);
2762 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
2765 { /* "__java_float" or ""__java_double". */
2766 type = make_node (REAL_TYPE);
2767 TYPE_PRECISION (type) = - size;
2770 record_builtin_type (RID_MAX, name, type);
2771 decl = TYPE_NAME (type);
2773 /* Suppress generate debug symbol entries for these types,
2774 since for normal C++ they are just clutter.
2775 However, push_lang_context undoes this if extern "Java" is seen. */
2776 DECL_IGNORED_P (decl) = 1;
2778 TYPE_FOR_JAVA (type) = 1;
2782 /* Push a type into the namespace so that the back-ends ignore it. */
2785 record_unknown_type (tree type, const char* name)
2787 tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
2788 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
2789 DECL_IGNORED_P (decl) = 1;
2790 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
2791 TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
2792 TYPE_ALIGN (type) = 1;
2793 TYPE_USER_ALIGN (type) = 0;
2794 TYPE_MODE (type) = TYPE_MODE (void_type_node);
2797 /* An string for which we should create an IDENTIFIER_NODE at
2800 typedef struct predefined_identifier
2802 /* The name of the identifier. */
2803 const char *const name;
2804 /* The place where the IDENTIFIER_NODE should be stored. */
2806 /* Nonzero if this is the name of a constructor or destructor. */
2807 const int ctor_or_dtor_p;
2808 } predefined_identifier;
2810 /* Create all the predefined identifiers. */
2813 initialize_predefined_identifiers (void)
2815 const predefined_identifier *pid;
2817 /* A table of identifiers to create at startup. */
2818 static const predefined_identifier predefined_identifiers[] = {
2819 { "C++", &lang_name_cplusplus, 0 },
2820 { "C", &lang_name_c, 0 },
2821 { "Java", &lang_name_java, 0 },
2822 /* Some of these names have a trailing space so that it is
2823 impossible for them to conflict with names written by users. */
2824 { "__ct ", &ctor_identifier, 1 },
2825 { "__base_ctor ", &base_ctor_identifier, 1 },
2826 { "__comp_ctor ", &complete_ctor_identifier, 1 },
2827 { "__dt ", &dtor_identifier, 1 },
2828 { "__comp_dtor ", &complete_dtor_identifier, 1 },
2829 { "__base_dtor ", &base_dtor_identifier, 1 },
2830 { "__deleting_dtor ", &deleting_dtor_identifier, 1 },
2831 { IN_CHARGE_NAME, &in_charge_identifier, 0 },
2832 { "nelts", &nelts_identifier, 0 },
2833 { THIS_NAME, &this_identifier, 0 },
2834 { VTABLE_DELTA_NAME, &delta_identifier, 0 },
2835 { VTABLE_PFN_NAME, &pfn_identifier, 0 },
2836 { "_vptr", &vptr_identifier, 0 },
2837 { "__vtt_parm", &vtt_parm_identifier, 0 },
2838 { "::", &global_scope_name, 0 },
2839 { "std", &std_identifier, 0 },
2843 for (pid = predefined_identifiers; pid->name; ++pid)
2845 *pid->node = get_identifier (pid->name);
2846 if (pid->ctor_or_dtor_p)
2847 IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
2851 /* Create the predefined scalar types of C,
2852 and some nodes representing standard constants (0, 1, (void *)0).
2853 Initialize the global binding level.
2854 Make definitions for built-in primitive functions. */
2857 cxx_init_decl_processing (void)
2860 tree void_ftype_ptr;
2862 build_common_tree_nodes (flag_signed_char, false);
2864 /* Create all the identifiers we need. */
2865 initialize_predefined_identifiers ();
2867 /* Create the global variables. */
2868 push_to_top_level ();
2870 current_function_decl = NULL_TREE;
2871 current_binding_level = NULL;
2872 /* Enter the global namespace. */
2873 gcc_assert (global_namespace == NULL_TREE);
2874 global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name,
2876 begin_scope (sk_namespace, global_namespace);
2878 current_lang_name = NULL_TREE;
2880 /* Adjust various flags based on command-line settings. */
2881 if (!flag_permissive)
2882 flag_pedantic_errors = 1;
2883 if (!flag_no_inline)
2885 flag_inline_trees = 1;
2888 if (flag_inline_functions)
2889 flag_inline_trees = 2;
2891 /* Force minimum function alignment if using the least significant
2892 bit of function pointers to store the virtual bit. */
2893 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
2894 && force_align_functions_log < 1)
2895 force_align_functions_log = 1;
2898 current_lang_name = lang_name_c;
2900 error_mark_list = build_tree_list (error_mark_node, error_mark_node);
2901 TREE_TYPE (error_mark_list) = error_mark_node;
2903 /* Create the `std' namespace. */
2904 push_namespace (std_identifier);
2905 std_node = current_namespace;
2908 c_common_nodes_and_builtins ();
2910 java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
2911 java_short_type_node = record_builtin_java_type ("__java_short", 16);
2912 java_int_type_node = record_builtin_java_type ("__java_int", 32);
2913 java_long_type_node = record_builtin_java_type ("__java_long", 64);
2914 java_float_type_node = record_builtin_java_type ("__java_float", -32);
2915 java_double_type_node = record_builtin_java_type ("__java_double", -64);
2916 java_char_type_node = record_builtin_java_type ("__java_char", -16);
2917 java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
2919 integer_two_node = build_int_cst (NULL_TREE, 2);
2920 integer_three_node = build_int_cst (NULL_TREE, 3);
2922 record_builtin_type (RID_BOOL, "bool", boolean_type_node);
2923 truthvalue_type_node = boolean_type_node;
2924 truthvalue_false_node = boolean_false_node;
2925 truthvalue_true_node = boolean_true_node;
2927 empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
2930 record_builtin_type (RID_MAX, NULL, string_type_node);
2933 delta_type_node = ptrdiff_type_node;
2934 vtable_index_type = ptrdiff_type_node;
2936 vtt_parm_type = build_pointer_type (const_ptr_type_node);
2937 void_ftype = build_function_type (void_type_node, void_list_node);
2938 void_ftype_ptr = build_function_type (void_type_node,
2939 tree_cons (NULL_TREE,
2943 = build_exception_variant (void_ftype_ptr, empty_except_spec);
2945 /* C++ extensions */
2947 unknown_type_node = make_node (UNKNOWN_TYPE);
2948 record_unknown_type (unknown_type_node, "unknown type");
2950 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
2951 TREE_TYPE (unknown_type_node) = unknown_type_node;
2953 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
2955 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
2956 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
2959 /* Make sure we get a unique function type, so we can give
2960 its pointer type a name. (This wins for gdb.) */
2961 tree vfunc_type = make_node (FUNCTION_TYPE);
2962 TREE_TYPE (vfunc_type) = integer_type_node;
2963 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
2964 layout_type (vfunc_type);
2966 vtable_entry_type = build_pointer_type (vfunc_type);
2968 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
2971 = build_cplus_array_type (vtable_entry_type, NULL_TREE);
2972 layout_type (vtbl_type_node);
2973 vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
2974 record_builtin_type (RID_MAX, NULL, vtbl_type_node);
2975 vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
2976 layout_type (vtbl_ptr_type_node);
2977 record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
2979 push_namespace (get_identifier ("__cxxabiv1"));
2980 abi_node = current_namespace;
2983 global_type_node = make_node (LANG_TYPE);
2984 record_unknown_type (global_type_node, "global type");
2987 current_lang_name = lang_name_cplusplus;
2991 tree bad_alloc_type_node;
2992 tree bad_alloc_decl;
2993 tree newtype, deltype;
2994 tree ptr_ftype_sizetype;
2996 push_namespace (std_identifier);
2997 bad_alloc_id = get_identifier ("bad_alloc");
2998 bad_alloc_type_node = make_aggr_type (RECORD_TYPE);
2999 TYPE_CONTEXT (bad_alloc_type_node) = current_namespace;
3001 = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node);
3002 DECL_CONTEXT (bad_alloc_decl) = current_namespace;
3003 TYPE_STUB_DECL (bad_alloc_type_node) = bad_alloc_decl;
3007 = build_function_type (ptr_type_node,
3008 tree_cons (NULL_TREE,
3011 newtype = build_exception_variant
3012 (ptr_ftype_sizetype, add_exception_specifier
3013 (NULL_TREE, bad_alloc_type_node, -1));
3014 deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
3015 push_cp_library_fn (NEW_EXPR, newtype);
3016 push_cp_library_fn (VEC_NEW_EXPR, newtype);
3017 global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
3018 push_cp_library_fn (VEC_DELETE_EXPR, deltype);
3022 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
3024 /* Perform other language dependent initializations. */
3025 init_class_processing ();
3026 init_rtti_processing ();
3028 if (flag_exceptions)
3029 init_exception_processing ();
3031 if (! supports_one_only ())
3034 make_fname_decl = cp_make_fname_decl;
3035 start_fname_decls ();
3037 /* Show we use EH for cleanups. */
3038 if (flag_exceptions)
3039 using_eh_for_cleanups ();
3042 /* Generate an initializer for a function naming variable from
3043 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3044 filled in with the type of the init. */
3047 cp_fname_init (const char* name, tree *type_p)
3049 tree domain = NULL_TREE;
3051 tree init = NULL_TREE;
3056 length = strlen (name);
3057 domain = build_index_type (size_int (length));
3058 init = build_string (length + 1, name);
3061 type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
3062 type = build_cplus_array_type (type, domain);
3067 TREE_TYPE (init) = type;
3069 init = error_mark_node;
3074 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
3075 decl, NAME is the initialization string and TYPE_DEP indicates whether
3076 NAME depended on the type of the function. We make use of that to detect
3077 __PRETTY_FUNCTION__ inside a template fn. This is being done
3078 lazily at the point of first use, so we mustn't push the decl now. */
3081 cp_make_fname_decl (tree id, int type_dep)
3083 const char *const name = (type_dep && processing_template_decl
3084 ? NULL : fname_as_string (type_dep));
3086 tree init = cp_fname_init (name, &type);
3087 tree decl = build_decl (VAR_DECL, id, type);
3090 free ((char *) name);
3092 /* As we're using pushdecl_with_scope, we must set the context. */
3093 DECL_CONTEXT (decl) = current_function_decl;
3094 DECL_PRETTY_FUNCTION_P (decl) = type_dep;
3096 TREE_STATIC (decl) = 1;
3097 TREE_READONLY (decl) = 1;
3098 DECL_ARTIFICIAL (decl) = 1;
3099 DECL_INITIAL (decl) = init;
3101 TREE_USED (decl) = 1;
3103 if (current_function_decl)
3105 struct cp_binding_level *b = current_binding_level;
3106 while (b->level_chain->kind != sk_function_parms)
3108 pushdecl_with_scope (decl, b);
3109 cp_finish_decl (decl, init, NULL_TREE, LOOKUP_ONLYCONVERTING);
3112 pushdecl_top_level_and_finish (decl, init);
3117 /* Make a definition for a builtin function named NAME in the current
3118 namespace, whose data type is TYPE and whose context is CONTEXT.
3119 TYPE should be a function type with argument types.
3121 CLASS and CODE tell later passes how to compile calls to this function.
3122 See tree.h for possible values.
3124 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3125 the name to be called if we can't opencode the function.
3126 If ATTRS is nonzero, use that for the function's attribute
3130 builtin_function_1 (const char* name,
3133 enum built_in_function code,
3134 enum built_in_class class,
3135 const char* libname,
3138 tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
3139 DECL_BUILT_IN_CLASS (decl) = class;
3140 DECL_FUNCTION_CODE (decl) = code;
3141 DECL_CONTEXT (decl) = context;
3145 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
3146 we cannot change DECL_ASSEMBLER_NAME until we have installed this
3147 function in the namespace. */
3149 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
3151 /* Warn if a function in the namespace for users
3152 is used without an occasion to consider it declared. */
3153 if (name[0] != '_' || name[1] != '_')
3154 DECL_ANTICIPATED (decl) = 1;
3156 /* Possibly apply some default attributes to this built-in function. */
3158 decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
3160 decl_attributes (&decl, NULL_TREE, 0);
3165 /* Entry point for the benefit of c_common_nodes_and_builtins.
3167 Make a definition for a builtin function named NAME and whose data type
3168 is TYPE. TYPE should be a function type with argument types. This
3169 function places the anticipated declaration in the global namespace
3170 and additionally in the std namespace if appropriate.
3172 CLASS and CODE tell later passes how to compile calls to this function.
3173 See tree.h for possible values.
3175 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3176 the name to be called if we can't opencode the function.
3178 If ATTRS is nonzero, use that for the function's attribute
3182 builtin_function (const char* name,
3185 enum built_in_class cl,
3186 const char* libname,
3189 /* All builtins that don't begin with an '_' should additionally
3190 go in the 'std' namespace. */
3193 push_namespace (std_identifier);
3194 builtin_function_1 (name, type, std_node, code, cl, libname, attrs);
3198 return builtin_function_1 (name, type, NULL_TREE, code,
3199 cl, libname, attrs);
3202 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
3203 function. Not called directly. */
3206 build_library_fn_1 (tree name, enum tree_code operator_code, tree type)
3208 tree fn = build_lang_decl (FUNCTION_DECL, name, type);
3209 DECL_EXTERNAL (fn) = 1;
3210 TREE_PUBLIC (fn) = 1;
3211 DECL_ARTIFICIAL (fn) = 1;
3212 TREE_NOTHROW (fn) = 1;
3213 SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
3214 SET_DECL_LANGUAGE (fn, lang_c);
3215 /* Runtime library routines are, by definition, available in an
3216 external shared object. */
3217 DECL_VISIBILITY (fn) = VISIBILITY_DEFAULT;
3218 DECL_VISIBILITY_SPECIFIED (fn) = 1;
3222 /* Returns the _DECL for a library function with C linkage.
3223 We assume that such functions never throw; if this is incorrect,
3224 callers should unset TREE_NOTHROW. */
3227 build_library_fn (tree name, tree type)
3229 return build_library_fn_1 (name, ERROR_MARK, type);
3232 /* Returns the _DECL for a library function with C++ linkage. */
3235 build_cp_library_fn (tree name, enum tree_code operator_code, tree type)
3237 tree fn = build_library_fn_1 (name, operator_code, type);
3238 TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
3239 DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
3240 SET_DECL_LANGUAGE (fn, lang_cplusplus);
3244 /* Like build_library_fn, but takes a C string instead of an
3248 build_library_fn_ptr (const char* name, tree type)
3250 return build_library_fn (get_identifier (name), type);
3253 /* Like build_cp_library_fn, but takes a C string instead of an
3257 build_cp_library_fn_ptr (const char* name, tree type)
3259 return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
3262 /* Like build_library_fn, but also pushes the function so that we will
3263 be able to find it via IDENTIFIER_GLOBAL_VALUE. */
3266 push_library_fn (tree name, tree type)
3268 tree fn = build_library_fn (name, type);
3269 pushdecl_top_level (fn);
3273 /* Like build_cp_library_fn, but also pushes the function so that it
3274 will be found by normal lookup. */
3277 push_cp_library_fn (enum tree_code operator_code, tree type)
3279 tree fn = build_cp_library_fn (ansi_opname (operator_code),
3286 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
3290 push_void_library_fn (tree name, tree parmtypes)
3292 tree type = build_function_type (void_type_node, parmtypes);
3293 return push_library_fn (name, type);
3296 /* Like push_library_fn, but also note that this function throws
3297 and does not return. Used for __throw_foo and the like. */
3300 push_throw_library_fn (tree name, tree type)
3302 tree fn = push_library_fn (name, type);
3303 TREE_THIS_VOLATILE (fn) = 1;
3304 TREE_NOTHROW (fn) = 0;
3308 /* When we call finish_struct for an anonymous union, we create
3309 default copy constructors and such. But, an anonymous union
3310 shouldn't have such things; this function undoes the damage to the
3311 anonymous union type T.
3313 (The reason that we create the synthesized methods is that we don't
3314 distinguish `union { int i; }' from `typedef union { int i; } U'.
3315 The first is an anonymous union; the second is just an ordinary
3319 fixup_anonymous_aggr (tree t)
3323 /* Wipe out memory of synthesized methods. */
3324 TYPE_HAS_CONSTRUCTOR (t) = 0;
3325 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
3326 TYPE_HAS_INIT_REF (t) = 0;
3327 TYPE_HAS_CONST_INIT_REF (t) = 0;
3328 TYPE_HAS_ASSIGN_REF (t) = 0;
3329 TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
3331 /* Splice the implicitly generated functions out of the TYPE_METHODS
3333 q = &TYPE_METHODS (t);
3336 if (DECL_ARTIFICIAL (*q))
3337 *q = TREE_CHAIN (*q);
3339 q = &TREE_CHAIN (*q);
3342 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
3343 if (TYPE_METHODS (t))
3344 error ("%Jan anonymous union cannot have function members",
3345 TYPE_MAIN_DECL (t));
3347 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
3348 assignment operators (because they cannot have these methods themselves).
3349 For anonymous unions this is already checked because they are not allowed
3350 in any union, otherwise we have to check it. */
3351 if (TREE_CODE (t) != UNION_TYPE)
3355 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
3356 if (TREE_CODE (field) == FIELD_DECL)
3358 type = TREE_TYPE (field);
3359 if (CLASS_TYPE_P (type))
3361 if (TYPE_NEEDS_CONSTRUCTING (type))
3362 cp_error_at ("member %q#D with constructor not allowed "
3363 "in anonymous aggregate",
3365 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
3366 cp_error_at ("member %q#D with destructor not allowed "
3367 "in anonymous aggregate",
3369 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
3370 cp_error_at ("member %q#D with copy assignment operator "
3371 "not allowed in anonymous aggregate",
3378 /* Make sure that a declaration with no declarator is well-formed, i.e.
3379 just declares a tagged type or anonymous union.
3381 Returns the type declared; or NULL_TREE if none. */
3384 check_tag_decl (cp_decl_specifier_seq *declspecs)
3386 int saw_friend = declspecs->specs[(int)ds_friend] != 0;
3387 int saw_typedef = declspecs->specs[(int)ds_typedef] != 0;
3388 /* If a class, struct, or enum type is declared by the DECLSPECS
3389 (i.e, if a class-specifier, enum-specifier, or non-typename
3390 elaborated-type-specifier appears in the DECLSPECS),
3391 DECLARED_TYPE is set to the corresponding type. */
3392 tree declared_type = NULL_TREE;
3393 bool error_p = false;
3395 if (declspecs->multiple_types_p)
3396 error ("multiple types in one declaration");
3397 else if (declspecs->redefined_builtin_type)
3399 if (!in_system_header)
3400 pedwarn ("redeclaration of C++ built-in type %qT",
3401 declspecs->redefined_builtin_type);
3406 && TYPE_P (declspecs->type)
3407 && ((TREE_CODE (declspecs->type) != TYPENAME_TYPE
3408 && IS_AGGR_TYPE (declspecs->type))
3409 || TREE_CODE (declspecs->type) == ENUMERAL_TYPE))
3410 declared_type = declspecs->type;
3411 else if (declspecs->type == error_mark_node)
3413 if (declared_type == NULL_TREE && ! saw_friend && !error_p)
3414 pedwarn ("declaration does not declare anything");
3415 /* Check for an anonymous union. */
3416 else if (declared_type && IS_AGGR_TYPE_CODE (TREE_CODE (declared_type))
3417 && TYPE_ANONYMOUS_P (declared_type))
3419 /* 7/3 In a simple-declaration, the optional init-declarator-list
3420 can be omitted only when declaring a class (clause 9) or
3421 enumeration (7.2), that is, when the decl-specifier-seq contains
3422 either a class-specifier, an elaborated-type-specifier with
3423 a class-key (9.1), or an enum-specifier. In these cases and
3424 whenever a class-specifier or enum-specifier is present in the
3425 decl-specifier-seq, the identifiers in these specifiers are among
3426 the names being declared by the declaration (as class-name,
3427 enum-names, or enumerators, depending on the syntax). In such
3428 cases, and except for the declaration of an unnamed bit-field (9.6),
3429 the decl-specifier-seq shall introduce one or more names into the
3430 program, or shall redeclare a name introduced by a previous
3431 declaration. [Example:
3432 enum { }; // ill-formed
3433 typedef class { }; // ill-formed
3437 error ("missing type-name in typedef-declaration");
3440 /* Anonymous unions are objects, so they can have specifiers. */;
3441 SET_ANON_AGGR_TYPE_P (declared_type);
3443 if (TREE_CODE (declared_type) != UNION_TYPE && pedantic
3444 && !in_system_header)
3445 pedwarn ("ISO C++ prohibits anonymous structs");
3450 if (declspecs->specs[(int)ds_inline]
3451 || declspecs->specs[(int)ds_virtual])
3452 error ("%qs can only be specified for functions",
3453 declspecs->specs[(int)ds_inline]
3454 ? "inline" : "virtual");
3456 && (!current_class_type
3457 || current_scope () != current_class_type))
3458 error ("%<friend%> can only be specified inside a class");
3459 else if (declspecs->specs[(int)ds_explicit])
3460 error ("%<explicit%> can only be specified for constructors");
3461 else if (declspecs->storage_class)
3462 error ("a storage class can only be specified for objects "
3464 else if (declspecs->specs[(int)ds_const]
3465 || declspecs->specs[(int)ds_volatile]
3466 || declspecs->specs[(int)ds_restrict]
3467 || declspecs->specs[(int)ds_thread])
3468 error ("qualifiers can only be specified for objects "
3472 return declared_type;
3475 /* Called when a declaration is seen that contains no names to declare.
3476 If its type is a reference to a structure, union or enum inherited
3477 from a containing scope, shadow that tag name for the current scope
3478 with a forward reference.
3479 If its type defines a new named structure or union
3480 or defines an enum, it is valid but we need not do anything here.
3481 Otherwise, it is an error.
3483 C++: may have to grok the declspecs to learn about static,
3484 complain for anonymous unions.
3486 Returns the TYPE declared -- or NULL_TREE if none. */
3489 shadow_tag (cp_decl_specifier_seq *declspecs)
3491 tree t = check_tag_decl (declspecs);
3496 if (declspecs->attributes)
3498 cp_warning_at ("attribute ignored in declaration of %q#T", t);
3499 cp_warning_at ("attribute for %q#T must follow the %qs keyword",
3501 class_key_or_enum_as_string (t));
3505 maybe_process_partial_specialization (t);
3507 /* This is where the variables in an anonymous union are
3508 declared. An anonymous union declaration looks like:
3510 because there is no declarator after the union, the parser
3511 sends that declaration here. */
3512 if (ANON_AGGR_TYPE_P (t))
3514 fixup_anonymous_aggr (t);
3516 if (TYPE_FIELDS (t))
3518 tree decl = grokdeclarator (/*declarator=*/NULL,
3519 declspecs, NORMAL, 0, NULL);
3520 finish_anon_union (decl);
3527 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
3530 groktypename (cp_decl_specifier_seq *type_specifiers,
3531 const cp_declarator *declarator)
3535 attrs = type_specifiers->attributes;
3536 type_specifiers->attributes = NULL_TREE;
3537 type = grokdeclarator (declarator, type_specifiers, TYPENAME, 0, &attrs);
3539 cplus_decl_attributes (&type, attrs, 0);
3543 /* Decode a declarator in an ordinary declaration or data definition.
3544 This is called as soon as the type information and variable name
3545 have been parsed, before parsing the initializer if any.
3546 Here we create the ..._DECL node, fill in its type,
3547 and put it on the list of decls for the current context.
3548 The ..._DECL node is returned as the value.
3550 Exception: for arrays where the length is not specified,
3551 the type is left null, to be filled in by `cp_finish_decl'.
3553 Function definitions do not come here; they go to start_function
3554 instead. However, external and forward declarations of functions
3555 do go through here. Structure field declarations are done by
3556 grokfield and not through here. */
3559 start_decl (const cp_declarator *declarator,
3560 cp_decl_specifier_seq *declspecs,
3563 tree prefix_attributes,
3564 tree *pushed_scope_p)
3570 *pushed_scope_p = NULL_TREE;
3572 /* This should only be done once on the top most decl. */
3573 if (have_extern_spec)
3575 declspecs->storage_class = sc_extern;
3576 have_extern_spec = false;
3579 /* An object declared as __attribute__((deprecated)) suppresses
3580 warnings of uses of other deprecated items. */
3581 if (lookup_attribute ("deprecated", attributes))
3582 deprecated_state = DEPRECATED_SUPPRESS;
3584 attributes = chainon (attributes, prefix_attributes);
3586 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
3589 deprecated_state = DEPRECATED_NORMAL;
3591 if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE)
3592 return error_mark_node;
3594 type = TREE_TYPE (decl);
3596 if (type == error_mark_node)
3597 return error_mark_node;
3599 context = DECL_CONTEXT (decl);
3603 *pushed_scope_p = push_scope (context);
3605 /* We are only interested in class contexts, later. */
3606 if (TREE_CODE (context) == NAMESPACE_DECL)
3607 context = NULL_TREE;
3611 /* Is it valid for this decl to have an initializer at all?
3612 If not, set INITIALIZED to zero, which will indirectly
3613 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
3614 switch (TREE_CODE (decl))
3617 error ("typedef %qD is initialized (use __typeof__ instead)", decl);
3622 error ("function %q#D is initialized like a variable", decl);
3632 if (! toplevel_bindings_p ()
3633 && DECL_EXTERNAL (decl))
3634 warning ("declaration of %q#D has %<extern%> and is initialized",
3636 DECL_EXTERNAL (decl) = 0;
3637 if (toplevel_bindings_p ())
3638 TREE_STATIC (decl) = 1;
3640 /* Tell `pushdecl' this is an initialized decl
3641 even though we don't yet have the initializer expression.
3642 Also tell `cp_finish_decl' it may store the real initializer. */
3643 DECL_INITIAL (decl) = error_mark_node;
3646 /* Set attributes here so if duplicate decl, will have proper attributes. */
3647 cplus_decl_attributes (&decl, attributes, 0);
3649 /* If #pragma weak was used, mark the decl weak now. */
3650 if (global_scope_p (current_binding_level))
3651 maybe_apply_pragma_weak (decl);
3653 if (TREE_CODE (decl) == FUNCTION_DECL
3654 && DECL_DECLARED_INLINE_P (decl)
3655 && DECL_UNINLINABLE (decl)
3656 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
3657 warning ("%Jinline function %qD given attribute noinline", decl, decl);
3659 if (context && COMPLETE_TYPE_P (complete_type (context)))
3661 if (TREE_CODE (decl) == VAR_DECL)
3663 tree field = lookup_field (context, DECL_NAME (decl), 0, false);
3664 if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
3665 error ("%q#D is not a static member of %q#T", decl, context);
3668 if (DECL_CONTEXT (field) != context)
3670 if (!same_type_p (DECL_CONTEXT (field), context))
3671 pedwarn ("ISO C++ does not permit %<%T::%D%> "
3672 "to be defined as %<%T::%D%>",
3673 DECL_CONTEXT (field), DECL_NAME (decl),
3674 context, DECL_NAME (decl));
3675 DECL_CONTEXT (decl) = DECL_CONTEXT (field);
3677 if (processing_specialization
3678 && template_class_depth (context) == 0
3679 && CLASSTYPE_TEMPLATE_SPECIALIZATION (context))
3680 error ("template header not allowed in member definition "
3681 "of explicitly specialized class");
3682 /* Static data member are tricky; an in-class initialization
3683 still doesn't provide a definition, so the in-class
3684 declaration will have DECL_EXTERNAL set, but will have an
3685 initialization. Thus, duplicate_decls won't warn
3686 about this situation, and so we check here. */
3687 if (DECL_INITIAL (decl) && DECL_INITIAL (field))
3688 error ("duplicate initialization of %qD", decl);
3689 if (duplicate_decls (decl, field))
3695 tree field = check_classfn (context, decl,
3696 (processing_template_decl
3697 > template_class_depth (context))
3698 ? current_template_parms
3700 if (field && duplicate_decls (decl, field))
3704 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
3705 DECL_IN_AGGR_P (decl) = 0;
3706 if ((DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
3707 || CLASSTYPE_TEMPLATE_INSTANTIATION (context))
3709 /* Do not mark DECL as an explicit specialization if it was
3710 not already marked as an instantiation; a declaration
3711 should never be marked as a specialization unless we know
3712 what template is being specialized. */
3713 if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
3714 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
3715 /* [temp.expl.spec] An explicit specialization of a static data
3716 member of a template is a definition if the declaration
3717 includes an initializer; otherwise, it is a declaration.
3719 We check for processing_specialization so this only applies
3720 to the new specialization syntax. */
3721 if (DECL_INITIAL (decl) == NULL_TREE && processing_specialization)
3722 DECL_EXTERNAL (decl) = 1;
3725 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
3726 pedwarn ("declaration of %q#D outside of class is not definition",
3730 /* Enter this declaration into the symbol table. */
3731 tem = maybe_push_decl (decl);
3733 if (processing_template_decl)
3734 tem = push_template_decl (tem);
3735 if (tem == error_mark_node)
3736 return error_mark_node;
3738 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
3739 /* Tell the back-end to use or not use .common as appropriate. If we say
3740 -fconserve-space, we want this to save .data space, at the expense of
3741 wrong semantics. If we say -fno-conserve-space, we want this to
3742 produce errors about redefs; to do this we force variables into the
3744 DECL_COMMON (tem) = ((TREE_CODE (tem) != VAR_DECL
3745 || !DECL_THREAD_LOCAL (tem))
3746 && (flag_conserve_space || ! TREE_PUBLIC (tem)));
3749 if (! processing_template_decl)
3756 start_decl_1 (tree decl)
3758 tree type = TREE_TYPE (decl);
3759 int initialized = (DECL_INITIAL (decl) != NULL_TREE);
3761 if (type == error_mark_node)
3765 /* Is it valid for this decl to have an initializer at all?
3766 If not, set INITIALIZED to zero, which will indirectly
3767 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
3769 /* Don't allow initializations for incomplete types except for
3770 arrays which might be completed by the initialization. */
3771 if (COMPLETE_TYPE_P (complete_type (type)))
3772 ; /* A complete type is ok. */
3773 else if (TREE_CODE (type) != ARRAY_TYPE)
3775 error ("variable %q#D has initializer but incomplete type", decl);
3777 type = TREE_TYPE (decl) = error_mark_node;
3779 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
3781 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
3782 error ("elements of array %q#D have incomplete type", decl);
3783 /* else we already gave an error in start_decl. */
3789 && TREE_CODE (decl) != TYPE_DECL
3790 && TREE_CODE (decl) != TEMPLATE_DECL
3791 && type != error_mark_node
3792 && IS_AGGR_TYPE (type)
3793 && ! DECL_EXTERNAL (decl))
3795 if ((! processing_template_decl || ! uses_template_parms (type))
3796 && !COMPLETE_TYPE_P (complete_type (type)))
3798 error ("aggregate %q#D has incomplete type and cannot be defined",
3800 /* Change the type so that assemble_variable will give
3801 DECL an rtl we can live with: (mem (const_int 0)). */
3802 type = TREE_TYPE (decl) = error_mark_node;
3806 /* If any base type in the hierarchy of TYPE needs a constructor,
3807 then we set initialized to 1. This way any nodes which are
3808 created for the purposes of initializing this aggregate
3809 will live as long as it does. This is necessary for global
3810 aggregates which do not have their initializers processed until
3811 the end of the file. */
3812 initialized = TYPE_NEEDS_CONSTRUCTING (type);
3817 DECL_INITIAL (decl) = NULL_TREE;
3819 /* Create a new scope to hold this declaration if necessary.
3820 Whether or not a new scope is necessary cannot be determined
3821 until after the type has been completed; if the type is a
3822 specialization of a class template it is not until after
3823 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
3824 will be set correctly. */
3825 maybe_push_cleanup_level (type);
3828 /* Handle initialization of references. DECL, TYPE, and INIT have the
3829 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
3830 but will be set to a new CLEANUP_STMT if a temporary is created
3831 that must be destroyed subsequently.
3833 Returns an initializer expression to use to initialize DECL, or
3834 NULL if the initialization can be performed statically.
3836 Quotes on semantics can be found in ARM 8.4.3. */
3839 grok_reference_init (tree decl, tree type, tree init, tree *cleanup)
3843 if (init == NULL_TREE)
3845 if ((DECL_LANG_SPECIFIC (decl) == 0
3846 || DECL_IN_AGGR_P (decl) == 0)
3847 && ! DECL_THIS_EXTERN (decl))
3848 error ("%qD declared as reference but not initialized", decl);
3852 if (TREE_CODE (init) == CONSTRUCTOR)
3854 error ("ISO C++ forbids use of initializer list to "
3855 "initialize reference %qD", decl);
3859 if (TREE_CODE (init) == TREE_LIST)
3860 init = build_x_compound_expr_from_list (init, "initializer");
3862 if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
3863 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
3864 /* Note: default conversion is only called in very special cases. */
3865 init = decay_conversion (init);
3867 /* Convert INIT to the reference type TYPE. This may involve the
3868 creation of a temporary, whose lifetime must be the same as that
3869 of the reference. If so, a DECL_EXPR for the temporary will be
3870 added just after the DECL_EXPR for DECL. That's why we don't set
3871 DECL_INITIAL for local references (instead assigning to them
3872 explicitly); we need to allow the temporary to be initialized
3874 tmp = initialize_reference (type, init, decl, cleanup);
3876 if (tmp == error_mark_node)
3878 else if (tmp == NULL_TREE)
3880 error ("cannot initialize %qT from %qT", type, TREE_TYPE (init));
3884 if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
3887 DECL_INITIAL (decl) = tmp;
3892 /* When parsing `int a[] = {1, 2};' we don't know the size of the
3893 array until we finish parsing the initializer. If that's the
3894 situation we're in, update DECL accordingly. */
3897 maybe_deduce_size_from_array_init (tree decl, tree init)
3899 tree type = TREE_TYPE (decl);
3901 if (TREE_CODE (type) == ARRAY_TYPE
3902 && TYPE_DOMAIN (type) == NULL_TREE
3903 && TREE_CODE (decl) != TYPE_DECL)
3905 /* do_default is really a C-ism to deal with tentative definitions.
3906 But let's leave it here to ease the eventual merge. */
3907 int do_default = !DECL_EXTERNAL (decl);
3908 tree initializer = init ? init : DECL_INITIAL (decl);
3909 int failure = complete_array_type (type, initializer, do_default);
3912 error ("initializer fails to determine size of %qD", decl);
3917 error ("array size missing in %qD", decl);
3918 /* If a `static' var's size isn't known, make it extern as
3919 well as static, so it does not get allocated. If it's not
3920 `static', then don't mark it extern; finish_incomplete_decl
3921 will give it a default size and it will get allocated. */
3922 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
3923 DECL_EXTERNAL (decl) = 1;
3926 if (pedantic && TYPE_DOMAIN (type) != NULL_TREE
3927 && tree_int_cst_lt (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
3929 error ("zero-size array %qD", decl);
3931 layout_decl (decl, 0);
3935 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
3936 any appropriate error messages regarding the layout. */
3939 layout_var_decl (tree decl)
3941 tree type = TREE_TYPE (decl);
3943 tree ttype = target_type (type);
3946 /* If we haven't already layed out this declaration, do so now.
3947 Note that we must not call complete type for an external object
3948 because it's type might involve templates that we are not
3949 supposed to instantiate yet. (And it's perfectly valid to say
3950 `extern X x' for some incomplete type `X'.) */
3951 if (!DECL_EXTERNAL (decl))
3952 complete_type (type);
3953 if (!DECL_SIZE (decl)
3954 && TREE_TYPE (decl) != error_mark_node
3955 && (COMPLETE_TYPE_P (type)
3956 || (TREE_CODE (type) == ARRAY_TYPE
3957 && !TYPE_DOMAIN (type)
3958 && COMPLETE_TYPE_P (TREE_TYPE (type)))))
3959 layout_decl (decl, 0);
3961 if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
3963 /* An automatic variable with an incomplete type: that is an error.
3964 Don't talk about array types here, since we took care of that
3965 message in grokdeclarator. */
3966 error ("storage size of %qD isn't known", decl);
3967 TREE_TYPE (decl) = error_mark_node;
3970 /* Keep this code around in case we later want to control debug info
3971 based on whether a type is "used". (jason 1999-11-11) */
3973 else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
3974 /* Let debugger know it should output info for this type. */
3975 note_debug_info_needed (ttype);
3977 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
3978 note_debug_info_needed (DECL_CONTEXT (decl));
3981 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
3982 && DECL_SIZE (decl) != NULL_TREE
3983 && ! TREE_CONSTANT (DECL_SIZE (decl)))
3985 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
3986 constant_expression_warning (DECL_SIZE (decl));
3988 error ("storage size of %qD isn't constant", decl);
3991 if (TREE_STATIC (decl)
3992 && !DECL_ARTIFICIAL (decl)
3993 && current_function_decl
3994 && DECL_CONTEXT (decl) == current_function_decl)
3995 push_local_name (decl);
3998 /* If a local static variable is declared in an inline function, or if
3999 we have a weak definition, we must endeavor to create only one
4000 instance of the variable at link-time. */
4003 maybe_commonize_var (tree decl)
4005 /* Static data in a function with comdat linkage also has comdat
4007 if (TREE_STATIC (decl)
4008 /* Don't mess with __FUNCTION__. */
4009 && ! DECL_ARTIFICIAL (decl)
4010 && DECL_FUNCTION_SCOPE_P (decl)
4011 /* Unfortunately, import_export_decl has not always been called
4012 before the function is processed, so we cannot simply check
4014 && (DECL_COMDAT (DECL_CONTEXT (decl))
4015 || ((DECL_DECLARED_INLINE_P (DECL_CONTEXT (decl))
4016 || DECL_TEMPLATE_INSTANTIATION (DECL_CONTEXT (decl)))
4017 && TREE_PUBLIC (DECL_CONTEXT (decl)))))
4021 /* With weak symbols, we simply make the variable COMDAT;
4022 that will cause copies in multiple translations units to
4024 comdat_linkage (decl);
4028 if (DECL_INITIAL (decl) == NULL_TREE
4029 || DECL_INITIAL (decl) == error_mark_node)
4031 /* Without weak symbols, we can use COMMON to merge
4032 uninitialized variables. */
4033 TREE_PUBLIC (decl) = 1;
4034 DECL_COMMON (decl) = 1;
4038 /* While for initialized variables, we must use internal
4039 linkage -- which means that multiple copies will not
4041 TREE_PUBLIC (decl) = 0;
4042 DECL_COMMON (decl) = 0;
4043 cp_warning_at ("sorry: semantics of inline function static "
4044 "data %q#D are wrong (you'll wind up "
4045 "with multiple copies)", decl);
4046 warning ("%J you can work around this by removing "
4052 else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
4053 /* Set it up again; we might have set DECL_INITIAL since the last
4055 comdat_linkage (decl);
4058 /* Issue an error message if DECL is an uninitialized const variable. */
4061 check_for_uninitialized_const_var (tree decl)
4063 tree type = TREE_TYPE (decl);
4065 /* ``Unless explicitly declared extern, a const object does not have
4066 external linkage and must be initialized. ($8.4; $12.1)'' ARM
4068 if (TREE_CODE (decl) == VAR_DECL
4069 && TREE_CODE (type) != REFERENCE_TYPE
4070 && CP_TYPE_CONST_P (type)
4071 && !TYPE_NEEDS_CONSTRUCTING (type)
4072 && !DECL_INITIAL (decl))
4073 error ("uninitialized const %qD", decl);
4076 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
4077 returned is the next FIELD_DECL (possibly FIELD itself) that can be
4078 initialized. If there are no more such fields, the return value
4082 next_initializable_field (tree field)
4085 && (TREE_CODE (field) != FIELD_DECL
4086 || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
4087 || DECL_ARTIFICIAL (field)))
4088 field = TREE_CHAIN (field);
4093 /* Subroutine of reshape_init. Reshape the constructor for an array. INITP
4094 is the pointer to the old constructor list (to the CONSTRUCTOR_ELTS of
4095 the CONSTRUCTOR we are processing), while NEW_INIT is the CONSTRUCTOR we
4097 ELT_TYPE is the element type of the array. MAX_INDEX is an INTEGER_CST
4098 representing the size of the array minus one (the maximum index), or
4099 NULL_TREE if the array was declared without specifying the size. */
4102 reshape_init_array (tree elt_type, tree max_index,
4103 tree *initp, tree new_init)
4105 bool sized_array_p = (max_index != NULL_TREE);
4106 HOST_WIDE_INT max_index_cst = 0;
4107 HOST_WIDE_INT index;
4110 /* HWI is either 32bit or 64bit, so it must be enough to represent the
4112 max_index_cst = tree_low_cst (max_index, 1);
4114 /* Loop until there are no more initializers. */
4116 *initp && (!sized_array_p || index <= max_index_cst);
4120 tree designated_index;
4122 element_init = reshape_init (elt_type, initp);
4123 if (element_init == error_mark_node)
4125 TREE_CHAIN (element_init) = CONSTRUCTOR_ELTS (new_init);
4126 CONSTRUCTOR_ELTS (new_init) = element_init;
4127 designated_index = TREE_PURPOSE (element_init);
4128 if (designated_index)
4130 /* Handle array designated initializers (GNU extension). */
4131 if (TREE_CODE (designated_index) == IDENTIFIER_NODE)
4133 error ("name %qD used in a GNU-style designated "
4134 "initializer for an array", designated_index);
4135 TREE_PURPOSE (element_init) = NULL_TREE;
4139 gcc_assert (TREE_CODE (designated_index) == INTEGER_CST);
4141 && tree_int_cst_lt (max_index, designated_index))
4143 error ("Designated initializer %qE larger than array "
4144 "size", designated_index);
4145 TREE_PURPOSE (element_init) = NULL_TREE;
4148 index = tree_low_cst (designated_index, 1);
4156 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
4157 brace-enclosed aggregate initializer.
4159 *INITP is one of a list of initializers describing a brace-enclosed
4160 initializer for an entity of the indicated aggregate TYPE. It may
4161 not presently match the shape of the TYPE; for example:
4163 struct S { int a; int b; };
4164 struct S a[] = { 1, 2, 3, 4 };
4166 Here *INITP will point to TREE_LIST of four elements, rather than a
4167 list of two elements, each itself a list of two elements. This
4168 routine transforms INIT from the former form into the latter. The
4169 revised initializer is returned. */
4172 reshape_init (tree type, tree *initp)
4176 tree old_init_value;
4178 bool brace_enclosed_p;
4181 old_init_value = (TREE_CODE (*initp) == TREE_LIST
4182 ? TREE_VALUE (*initp) : old_init);
4184 gcc_assert (old_init_value);
4186 /* If the initializer is brace-enclosed, pull initializers from the
4187 enclosed elements. Advance past the brace-enclosed initializer
4189 if (TREE_CODE (old_init_value) == CONSTRUCTOR
4190 && BRACE_ENCLOSED_INITIALIZER_P (old_init_value))
4192 *initp = TREE_CHAIN (old_init);
4193 TREE_CHAIN (old_init) = NULL_TREE;
4194 inits = CONSTRUCTOR_ELTS (old_init_value);
4196 brace_enclosed_p = true;
4201 brace_enclosed_p = false;
4204 /* A non-aggregate type is always initialized with a single
4206 if (!CP_AGGREGATE_TYPE_P (type))
4208 *initp = TREE_CHAIN (old_init);
4209 TREE_CHAIN (old_init) = NULL_TREE;
4210 /* It is invalid to initialize a non-aggregate type with a
4211 brace-enclosed initializer. */
4212 if (brace_enclosed_p)
4214 error ("brace-enclosed initializer used to initialize %qT",
4216 if (TREE_CODE (old_init) == TREE_LIST)
4217 TREE_VALUE (old_init) = error_mark_node;
4219 old_init = error_mark_node;
4227 All implicit type conversions (clause _conv_) are considered when
4228 initializing the aggregate member with an initializer from an
4229 initializer-list. If the initializer can initialize a member,
4230 the member is initialized. Otherwise, if the member is itself a
4231 non-empty subaggregate, brace elision is assumed and the
4232 initializer is considered for the initialization of the first
4233 member of the subaggregate. */
4234 if (!brace_enclosed_p
4235 && can_convert_arg (type, TREE_TYPE (old_init_value), old_init_value))
4237 *initp = TREE_CHAIN (old_init);
4238 TREE_CHAIN (old_init) = NULL_TREE;
4242 if (TREE_CODE (old_init_value) == STRING_CST
4243 && TREE_CODE (type) == ARRAY_TYPE
4244 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
4246 /* [dcl.init.string]
4248 A char array (whether plain char, signed char, or unsigned char)
4249 can be initialized by a string-literal (optionally enclosed in
4250 braces); a wchar_t array can be initialized by a wide
4251 string-literal (optionally enclosed in braces). */
4252 new_init = old_init;
4253 /* Move past the initializer. */
4254 *initp = TREE_CHAIN (old_init);
4255 TREE_CHAIN (old_init) = NULL_TREE;
4259 /* Build a CONSTRUCTOR to hold the contents of the aggregate. */
4260 new_init = build_constructor (NULL_TREE, NULL_TREE);
4262 if (CLASS_TYPE_P (type))
4266 field = next_initializable_field (TYPE_FIELDS (type));
4272 An initializer for an aggregate member that is an
4273 empty class shall have the form of an empty
4274 initializer-list {}. */
4275 if (!brace_enclosed_p)
4277 error ("initializer for %qT must be brace-enclosed", type);
4278 return error_mark_node;
4283 /* Loop through the initializable fields, gathering
4289 /* Handle designated initializers, as an extension. */
4290 if (TREE_PURPOSE (*initp))
4293 pedwarn ("ISO C++ does not allow designated initializers");
4294 field = lookup_field_1 (type, TREE_PURPOSE (*initp),
4295 /*want_type=*/false);
4296 if (!field || TREE_CODE (field) != FIELD_DECL)
4297 error ("%qT has no non-static data member named %qD",
4298 type, TREE_PURPOSE (*initp));
4303 field_init = reshape_init (TREE_TYPE (field), initp);
4304 if (field_init == error_mark_node)
4305 return error_mark_node;
4306 TREE_CHAIN (field_init) = CONSTRUCTOR_ELTS (new_init);
4307 CONSTRUCTOR_ELTS (new_init) = field_init;
4310 When a union is initialized with a brace-enclosed
4311 initializer, the braces shall only contain an
4312 initializer for the first member of the union. */
4313 if (TREE_CODE (type) == UNION_TYPE)
4315 field = next_initializable_field (TREE_CHAIN (field));
4319 else if (TREE_CODE (type) == ARRAY_TYPE
4320 || TREE_CODE (type) == VECTOR_TYPE)
4322 /* If the bound of the array is known, take no more initializers
4323 than are allowed. */
4324 tree max_index = NULL_TREE;
4325 if (TREE_CODE (type) == ARRAY_TYPE)
4327 if (TYPE_DOMAIN (type))
4328 max_index = array_type_nelts (type);
4332 /* For a vector, the representation type is a struct
4333 containing a single member which is an array of the
4334 appropriate size. */
4335 tree rtype = TYPE_DEBUG_REPRESENTATION_TYPE (type);
4336 if (rtype && TYPE_DOMAIN (TREE_TYPE (TYPE_FIELDS (rtype))))
4337 max_index = array_type_nelts (TREE_TYPE (TYPE_FIELDS
4341 if (!reshape_init_array (TREE_TYPE (type), max_index,
4343 return error_mark_node;
4348 /* The initializers were placed in reverse order in the
4350 CONSTRUCTOR_ELTS (new_init) = nreverse (CONSTRUCTOR_ELTS (new_init));
4352 if (TREE_CODE (old_init) == TREE_LIST)
4353 new_init = build_tree_list (TREE_PURPOSE (old_init), new_init);
4356 /* If there are more initializers than necessary, issue a
4360 if (brace_enclosed_p)
4361 error ("too many initializers for %qT", type);
4362 else if (warn_missing_braces)
4363 warning ("missing braces around initializer");
4369 /* Verify INIT (the initializer for DECL), and record the
4370 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
4371 grok_reference_init.
4373 If the return value is non-NULL, it is an expression that must be
4374 evaluated dynamically to initialize DECL. */
4377 check_initializer (tree decl, tree init, int flags, tree *cleanup)
4379 tree type = TREE_TYPE (decl);
4380 tree init_code = NULL;
4382 /* If `start_decl' didn't like having an initialization, ignore it now. */
4383 if (init != NULL_TREE && DECL_INITIAL (decl) == NULL_TREE)
4386 /* If an initializer is present, DECL_INITIAL has been
4387 error_mark_node, to indicate that an as-of-yet unevaluated
4388 initialization will occur. From now on, DECL_INITIAL reflects
4389 the static initialization -- if any -- of DECL. */
4390 DECL_INITIAL (decl) = NULL_TREE;
4392 /* Things that are going to be initialized need to have complete
4394 TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
4396 if (type == error_mark_node)
4397 /* We will have already complained. */
4399 else if (init && COMPLETE_TYPE_P (type)
4400 && !TREE_CONSTANT (TYPE_SIZE (type)))
4402 error ("variable-sized object %qD may not be initialized", decl);
4405 else if (TREE_CODE (type) == ARRAY_TYPE
4406 && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
4408 error ("elements of array %q#D have incomplete type", decl);
4411 else if (TREE_CODE (type) != ARRAY_TYPE && !COMPLETE_TYPE_P (type))
4413 error ("%qD has incomplete type", decl);
4414 TREE_TYPE (decl) = error_mark_node;
4418 if (TREE_CODE (decl) == CONST_DECL)
4420 gcc_assert (TREE_CODE (decl) != REFERENCE_TYPE);
4422 DECL_INITIAL (decl) = init;
4424 gcc_assert (init != NULL_TREE);
4427 else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
4428 init = grok_reference_init (decl, type, init, cleanup);
4431 if (TREE_CODE (init) == CONSTRUCTOR
4432 && BRACE_ENCLOSED_INITIALIZER_P (init))
4434 /* [dcl.init] paragraph 13,
4435 If T is a scalar type, then a declaration of the form
4440 reshape_init will complain about the extra braces,
4441 and doesn't do anything useful in the case where TYPE is
4442 scalar, so just don't call it. */
4443 if (CP_AGGREGATE_TYPE_P (type))
4444 init = reshape_init (type, &init);
4446 if ((*targetm.vector_opaque_p) (type))
4448 error ("opaque vector types cannot be initialized");
4449 init = error_mark_node;
4453 /* If DECL has an array type without a specific bound, deduce the
4454 array size from the initializer. */
4455 maybe_deduce_size_from_array_init (decl, init);
4456 type = TREE_TYPE (decl);
4458 if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
4460 if (TREE_CODE (type) == ARRAY_TYPE)
4461 goto initialize_aggr;
4462 else if (TREE_CODE (init) == CONSTRUCTOR
4463 && BRACE_ENCLOSED_INITIALIZER_P (init))
4465 if (TYPE_NON_AGGREGATE_CLASS (type))
4467 error ("%qD must be initialized by constructor, "
4470 init = error_mark_node;
4473 goto dont_use_constructor;
4477 int saved_stmts_are_full_exprs_p;
4480 saved_stmts_are_full_exprs_p = 0;
4481 if (building_stmt_tree ())
4483 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
4484 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
4486 init = build_aggr_init (decl, init, flags);
4487 if (building_stmt_tree ())
4488 current_stmt_tree ()->stmts_are_full_exprs_p =
4489 saved_stmts_are_full_exprs_p;
4495 dont_use_constructor:
4496 if (TREE_CODE (init) != TREE_VEC)
4498 init_code = store_init_value (decl, init);
4499 if (pedantic && TREE_CODE (type) == ARRAY_TYPE
4500 && DECL_INITIAL (decl)
4501 && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST
4502 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl)))
4503 warning ("array %qD initialized by parenthesized string literal %qE",
4504 decl, DECL_INITIAL (decl));
4509 else if (DECL_EXTERNAL (decl))
4511 else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
4512 goto initialize_aggr;
4513 else if (IS_AGGR_TYPE (type))
4515 tree core_type = strip_array_types (type);
4517 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
4518 error ("structure %qD with uninitialized const members", decl);
4519 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
4520 error ("structure %qD with uninitialized reference members", decl);
4522 check_for_uninitialized_const_var (decl);
4525 check_for_uninitialized_const_var (decl);
4527 if (init && init != error_mark_node)
4528 init_code = build2 (INIT_EXPR, type, decl, init);
4533 /* If DECL is not a local variable, give it RTL. */
4536 make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
4538 int toplev = toplevel_bindings_p ();
4541 /* Set the DECL_ASSEMBLER_NAME for the object. */
4544 /* The `register' keyword, when used together with an
4545 asm-specification, indicates that the variable should be
4546 placed in a particular register. */
4547 if (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
4549 change_decl_assembler_name (decl, get_identifier (asmspec));
4550 DECL_HARD_REGISTER (decl) = 1;
4554 if (TREE_CODE (decl) == FUNCTION_DECL
4555 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
4556 set_builtin_user_assembler_name (decl, asmspec);
4557 set_user_assembler_name (decl, asmspec);
4561 /* Handle non-variables up front. */
4562 if (TREE_CODE (decl) != VAR_DECL)
4564 rest_of_decl_compilation (decl, toplev, at_eof);
4568 /* If we see a class member here, it should be a static data
4570 if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
4572 gcc_assert (TREE_STATIC (decl));
4573 /* An in-class declaration of a static data member should be
4574 external; it is only a declaration, and not a definition. */
4575 if (init == NULL_TREE)
4576 gcc_assert (DECL_EXTERNAL (decl));
4579 /* We don't create any RTL for local variables. */
4580 if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
4583 /* We defer emission of local statics until the corresponding
4584 DECL_EXPR is expanded. */
4585 defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
4587 /* We try to defer namespace-scope static constants so that they are
4588 not emitted into the object file unnecessarily. */
4589 if (!DECL_VIRTUAL_P (decl)
4590 && TREE_READONLY (decl)
4591 && DECL_INITIAL (decl) != NULL_TREE
4592 && DECL_INITIAL (decl) != error_mark_node
4593 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
4595 && !TREE_PUBLIC (decl))
4597 /* Fool with the linkage of static consts according to #pragma
4599 struct c_fileinfo *finfo = get_fileinfo (lbasename (input_filename));
4600 if (!finfo->interface_unknown && !TREE_PUBLIC (decl))
4602 TREE_PUBLIC (decl) = 1;
4603 DECL_EXTERNAL (decl) = finfo->interface_only;
4608 /* Likewise for template instantiations. */
4609 else if (DECL_LANG_SPECIFIC (decl)
4610 && DECL_IMPLICIT_INSTANTIATION (decl))
4613 /* If we're not deferring, go ahead and assemble the variable. */
4615 rest_of_decl_compilation (decl, toplev, at_eof);
4618 /* Generate code to initialize DECL (a local variable). */
4621 initialize_local_var (tree decl, tree init)
4623 tree type = TREE_TYPE (decl);
4626 gcc_assert (TREE_CODE (decl) == VAR_DECL
4627 || TREE_CODE (decl) == RESULT_DECL);
4628 gcc_assert (!TREE_STATIC (decl));
4630 if (DECL_SIZE (decl) == NULL_TREE)
4632 /* If we used it already as memory, it must stay in memory. */
4633 DECL_INITIAL (decl) = NULL_TREE;
4634 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
4637 if (DECL_SIZE (decl) && type != error_mark_node)
4641 /* Compute and store the initial value. */
4642 already_used = TREE_USED (decl) || TREE_USED (type);
4644 /* Perform the initialization. */
4647 int saved_stmts_are_full_exprs_p;
4649 gcc_assert (building_stmt_tree ());
4650 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
4651 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
4652 finish_expr_stmt (init);
4653 current_stmt_tree ()->stmts_are_full_exprs_p =
4654 saved_stmts_are_full_exprs_p;
4657 /* Set this to 0 so we can tell whether an aggregate which was
4658 initialized was ever used. Don't do this if it has a
4659 destructor, so we don't complain about the 'resource
4660 allocation is initialization' idiom. Now set
4661 attribute((unused)) on types so decls of that type will be
4662 marked used. (see TREE_USED, above.) */
4663 if (TYPE_NEEDS_CONSTRUCTING (type)
4665 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
4666 && DECL_NAME (decl))
4667 TREE_USED (decl) = 0;
4668 else if (already_used)
4669 TREE_USED (decl) = 1;
4672 /* Generate a cleanup, if necessary. */
4673 cleanup = cxx_maybe_build_cleanup (decl);
4674 if (DECL_SIZE (decl) && cleanup)
4675 finish_decl_cleanup (decl, cleanup);
4678 /* DECL is a VAR_DECL for a compiler-generated variable with static
4679 storage duration (like a virtual table) whose initializer is a
4680 compile-time constant. Initialize the variable and provide it to
4684 initialize_artificial_var (tree decl, tree init)
4686 DECL_INITIAL (decl) = build_constructor (NULL_TREE, init);
4687 DECL_INITIALIZED_P (decl) = 1;
4688 determine_visibility (decl);
4689 layout_var_decl (decl);
4690 maybe_commonize_var (decl);
4691 make_rtl_for_nonlocal_decl (decl, init, /*asmspec=*/NULL);
4694 /* Finish processing of a declaration;
4695 install its line number and initial value.
4696 If the length of an array type is not known before,
4697 it must be determined now, from the initial value, or it is an error.
4699 INIT holds the value of an initializer that should be allowed to escape
4702 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
4703 if the (init) syntax was used. */
4706 cp_finish_decl (tree decl, tree init, tree asmspec_tree, int flags)
4709 tree ttype = NULL_TREE;
4711 const char *asmspec = NULL;
4712 int was_readonly = 0;
4713 bool var_definition_p = false;
4715 if (decl == error_mark_node)
4720 error ("assignment (not initialization) in declaration");
4724 gcc_assert (TREE_CODE (decl) != RESULT_DECL);
4726 /* Assume no cleanup is required. */
4727 cleanup = NULL_TREE;
4729 /* If a name was specified, get the string. */
4730 if (global_scope_p (current_binding_level))
4731 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
4733 asmspec = TREE_STRING_POINTER (asmspec_tree);
4735 if (init && TREE_CODE (init) == NAMESPACE_DECL)
4737 error ("cannot initialize %qD to namespace %qD", decl, init);
4741 if (current_class_type
4742 && CP_DECL_CONTEXT (decl) == current_class_type
4743 && TYPE_BEING_DEFINED (current_class_type)
4744 && (DECL_INITIAL (decl) || init))
4745 DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
4747 type = TREE_TYPE (decl);
4749 if (type == error_mark_node)
4752 if (processing_template_decl)
4754 /* Add this declaration to the statement-tree. */
4755 if (at_function_scope_p ())
4756 add_decl_expr (decl);
4758 if (init && DECL_INITIAL (decl))
4759 DECL_INITIAL (decl) = init;
4760 if (TREE_CODE (decl) == VAR_DECL
4761 && !DECL_PRETTY_FUNCTION_P (decl)
4762 && !dependent_type_p (TREE_TYPE (decl)))
4763 maybe_deduce_size_from_array_init (decl, init);
4768 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
4769 gcc_assert (TREE_CODE (decl) != PARM_DECL);
4771 /* Take care of TYPE_DECLs up front. */
4772 if (TREE_CODE (decl) == TYPE_DECL)
4774 if (type != error_mark_node
4775 && IS_AGGR_TYPE (type) && DECL_NAME (decl))
4777 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
4778 warning ("shadowing previous type declaration of %q#D", decl);
4779 set_identifier_type_value (DECL_NAME (decl), decl);
4782 /* If we have installed this as the canonical typedef for this
4783 type, and that type has not been defined yet, delay emitting
4784 the debug information for it, as we will emit it later. */
4785 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
4786 && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
4787 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
4789 rest_of_decl_compilation (decl, DECL_CONTEXT (decl) == NULL_TREE,
4794 if (TREE_CODE (decl) != FUNCTION_DECL)
4795 ttype = target_type (type);
4798 /* A reference will be modified here, as it is initialized. */
4799 if (! DECL_EXTERNAL (decl)
4800 && TREE_READONLY (decl)
4801 && TREE_CODE (type) == REFERENCE_TYPE)
4804 TREE_READONLY (decl) = 0;
4807 if (TREE_CODE (decl) == VAR_DECL)
4809 /* Only PODs can have thread-local storage. Other types may require
4810 various kinds of non-trivial initialization. */
4811 if (DECL_THREAD_LOCAL (decl) && !pod_type_p (TREE_TYPE (decl)))
4812 error ("%qD cannot be thread-local because it has non-POD type %qT",
4813 decl, TREE_TYPE (decl));
4814 /* Convert the initializer to the type of DECL, if we have not
4815 already initialized DECL. */
4816 if (!DECL_INITIALIZED_P (decl)
4817 /* If !DECL_EXTERNAL then DECL is being defined. In the
4818 case of a static data member initialized inside the
4819 class-specifier, there can be an initializer even if DECL
4820 is *not* defined. */
4821 && (!DECL_EXTERNAL (decl) || init))
4823 init = check_initializer (decl, init, flags, &cleanup);
4824 /* Thread-local storage cannot be dynamically initialized. */
4825 if (DECL_THREAD_LOCAL (decl) && init)
4827 error ("%qD is thread-local and so cannot be dynamically "
4828 "initialized", decl);
4835 The memory occupied by any object of static storage
4836 duration is zero-initialized at program startup before
4837 any other initialization takes place.
4839 We cannot create an appropriate initializer until after
4840 the type of DECL is finalized. If DECL_INITIAL is set,
4841 then the DECL is statically initialized, and any
4842 necessary zero-initialization has already been performed. */
4843 if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
4844 DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
4845 /*nelts=*/NULL_TREE,
4846 /*static_storage_p=*/true);
4847 /* Remember that the initialization for this variable has
4849 DECL_INITIALIZED_P (decl) = 1;
4850 /* This declaration is the definition of this variable,
4851 unless we are initializing a static data member within
4852 the class specifier. */
4853 if (!DECL_EXTERNAL (decl))
4854 var_definition_p = true;
4855 /* The variable is being defined, so determine its
4857 determine_visibility (decl);
4859 /* If the variable has an array type, lay out the type, even if
4860 there is no initializer. It is valid to index through the
4861 array, and we must get TYPE_ALIGN set correctly on the array
4863 else if (TREE_CODE (type) == ARRAY_TYPE)
4867 /* Add this declaration to the statement-tree. This needs to happen
4868 after the call to check_initializer so that the DECL_EXPR for a
4869 reference temp is added before the DECL_EXPR for the reference itself. */
4870 if (at_function_scope_p ())
4871 add_decl_expr (decl);
4873 if (TREE_CODE (decl) == VAR_DECL)
4874 layout_var_decl (decl);
4876 /* Output the assembler code and/or RTL code for variables and functions,
4877 unless the type is an undefined structure or union.
4878 If not, it will get done when the type is completed. */
4879 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
4881 if (TREE_CODE (decl) == VAR_DECL)
4882 maybe_commonize_var (decl);
4884 make_rtl_for_nonlocal_decl (decl, init, asmspec);
4886 /* Check for abstractness of the type. Notice that there is no
4887 need to strip array types here since the check for those types
4888 is already done within create_array_type_for_decl. */
4889 if (TREE_CODE (type) == FUNCTION_TYPE
4890 || TREE_CODE (type) == METHOD_TYPE)
4891 abstract_virtuals_error (decl, TREE_TYPE (type));
4893 abstract_virtuals_error (decl, type);
4895 if (TREE_CODE (decl) == FUNCTION_DECL
4896 || TREE_TYPE (decl) == error_mark_node)
4897 /* No initialization required. */
4899 else if (DECL_EXTERNAL (decl)
4900 && ! (DECL_LANG_SPECIFIC (decl)
4901 && DECL_NOT_REALLY_EXTERN (decl)))
4904 DECL_INITIAL (decl) = init;
4908 /* A variable definition. */
4909 if (DECL_FUNCTION_SCOPE_P (decl))
4911 /* Initialize the local variable. */
4912 if (processing_template_decl)
4914 if (init || DECL_INITIAL (decl) == error_mark_node)
4915 DECL_INITIAL (decl) = init;
4917 else if (!TREE_STATIC (decl))
4918 initialize_local_var (decl, init);
4921 /* If a variable is defined, and then a subsequent
4922 definition with external linkage is encountered, we will
4923 get here twice for the same variable. We want to avoid
4924 calling expand_static_init more than once. For variables
4925 that are not static data members, we can call
4926 expand_static_init only when we actually process the
4927 initializer. It is not legal to redeclare a static data
4928 member, so this issue does not arise in that case. */
4929 if (var_definition_p && TREE_STATIC (decl))
4930 expand_static_init (decl, init);
4934 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
4935 reference, insert it in the statement-tree now. */
4937 push_cleanup (decl, cleanup, false);
4942 TREE_READONLY (decl) = 1;
4944 /* If this was marked 'used', be sure it will be output. */
4945 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
4946 mark_decl_referenced (decl);
4949 /* This is here for a midend callback from c-common.c. */
4952 finish_decl (tree decl, tree init, tree asmspec_tree)
4954 cp_finish_decl (decl, init, asmspec_tree, 0);
4957 /* Returns a declaration for a VAR_DECL as if:
4959 extern "C" TYPE NAME;
4961 had been seen. Used to create compiler-generated global
4965 declare_global_var (tree name, tree type)
4969 push_to_top_level ();
4970 decl = build_decl (VAR_DECL, name, type);
4971 TREE_PUBLIC (decl) = 1;
4972 DECL_EXTERNAL (decl) = 1;
4973 DECL_ARTIFICIAL (decl) = 1;
4974 /* If the user has explicitly declared this variable (perhaps
4975 because the code we are compiling is part of a low-level runtime
4976 library), then it is possible that our declaration will be merged
4977 with theirs by pushdecl. */
4978 decl = pushdecl (decl);
4979 cp_finish_decl (decl, NULL_TREE, NULL_TREE, 0);
4980 pop_from_top_level ();
4985 /* Returns a pointer to the `atexit' function. Note that if
4986 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
4987 `__cxa_atexit' function specified in the IA64 C++ ABI. */
4990 get_atexit_node (void)
5001 if (flag_use_cxa_atexit)
5003 /* The declaration for `__cxa_atexit' is:
5005 int __cxa_atexit (void (*)(void *), void *, void *)
5007 We build up the argument types and then then function type
5010 /* First, build the pointer-to-function type for the first
5012 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5013 fn_type = build_function_type (void_type_node, arg_types);
5014 fn_ptr_type = build_pointer_type (fn_type);
5015 /* Then, build the rest of the argument types. */
5016 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5017 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
5018 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
5019 /* And the final __cxa_atexit type. */
5020 fn_type = build_function_type (integer_type_node, arg_types);
5021 fn_ptr_type = build_pointer_type (fn_type);
5022 name = "__cxa_atexit";
5026 /* The declaration for `atexit' is:
5028 int atexit (void (*)());
5030 We build up the argument types and then then function type
5032 fn_type = build_function_type (void_type_node, void_list_node);
5033 fn_ptr_type = build_pointer_type (fn_type);
5034 arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
5035 /* Build the final atexit type. */
5036 fn_type = build_function_type (integer_type_node, arg_types);
5040 /* Now, build the function declaration. */
5041 push_lang_context (lang_name_c);
5042 atexit_fndecl = build_library_fn_ptr (name, fn_type);
5043 mark_used (atexit_fndecl);
5044 pop_lang_context ();
5045 atexit_node = decay_conversion (atexit_fndecl);
5050 /* Returns the __dso_handle VAR_DECL. */
5053 get_dso_handle_node (void)
5055 if (dso_handle_node)
5056 return dso_handle_node;
5058 /* Declare the variable. */
5059 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
5062 return dso_handle_node;
5065 /* Begin a new function with internal linkage whose job will be simply
5066 to destroy some particular variable. */
5068 static GTY(()) int start_cleanup_cnt;
5071 start_cleanup_fn (void)
5078 push_to_top_level ();
5080 /* No need to mangle this. */
5081 push_lang_context (lang_name_c);
5083 /* Build the parameter-types. */
5084 parmtypes = void_list_node;
5085 /* Functions passed to __cxa_atexit take an additional parameter.
5086 We'll just ignore it. After we implement the new calling
5087 convention for destructors, we can eliminate the use of
5088 additional cleanup functions entirely in the -fnew-abi case. */
5089 if (flag_use_cxa_atexit)
5090 parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
5091 /* Build the function type itself. */
5092 fntype = build_function_type (void_type_node, parmtypes);
5093 /* Build the name of the function. */
5094 sprintf (name, "__tcf_%d", start_cleanup_cnt++);
5095 /* Build the function declaration. */
5096 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
5097 /* It's a function with internal linkage, generated by the
5099 TREE_PUBLIC (fndecl) = 0;
5100 DECL_ARTIFICIAL (fndecl) = 1;
5101 /* Make the function `inline' so that it is only emitted if it is
5102 actually needed. It is unlikely that it will be inlined, since
5103 it is only called via a function pointer, but we avoid unnecessary
5104 emissions this way. */
5105 DECL_INLINE (fndecl) = 1;
5106 DECL_DECLARED_INLINE_P (fndecl) = 1;
5107 DECL_INTERFACE_KNOWN (fndecl) = 1;
5108 /* Build the parameter. */
5109 if (flag_use_cxa_atexit)
5113 parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
5114 DECL_CONTEXT (parmdecl) = fndecl;
5115 TREE_USED (parmdecl) = 1;
5116 DECL_ARGUMENTS (fndecl) = parmdecl;
5120 start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED);
5122 pop_lang_context ();
5124 return current_function_decl;
5127 /* Finish the cleanup function begun by start_cleanup_fn. */
5130 end_cleanup_fn (void)
5132 expand_or_defer_fn (finish_function (0));
5134 pop_from_top_level ();
5137 /* Generate code to handle the destruction of DECL, an object with
5138 static storage duration. */
5141 register_dtor_fn (tree decl)
5148 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
5149 return void_zero_node;
5151 /* Call build_cleanup before we enter the anonymous function so that
5152 any access checks will be done relative to the current scope,
5153 rather than the scope of the anonymous function. */
5154 build_cleanup (decl);
5156 /* Now start the function. */
5157 cleanup = start_cleanup_fn ();
5159 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
5160 to the original function, rather than the anonymous one. That
5161 will make the back-end think that nested functions are in use,
5162 which causes confusion. */
5164 push_deferring_access_checks (dk_no_check);
5165 fcall = build_cleanup (decl);
5166 pop_deferring_access_checks ();
5168 /* Create the body of the anonymous function. */
5169 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
5170 finish_expr_stmt (fcall);
5171 finish_compound_stmt (compound_stmt);
5174 /* Call atexit with the cleanup function. */
5175 cxx_mark_addressable (cleanup);
5176 mark_used (cleanup);
5177 cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
5178 if (flag_use_cxa_atexit)
5180 args = tree_cons (NULL_TREE,
5181 build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0),
5183 args = tree_cons (NULL_TREE, null_pointer_node, args);
5184 args = tree_cons (NULL_TREE, cleanup, args);
5187 args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
5188 return build_function_call (get_atexit_node (), args);
5191 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
5192 is its initializer. Generate code to handle the construction
5193 and destruction of DECL. */
5196 expand_static_init (tree decl, tree init)
5198 gcc_assert (TREE_CODE (decl) == VAR_DECL);
5199 gcc_assert (TREE_STATIC (decl));
5201 /* Some variables require no initialization. */
5203 && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
5204 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
5207 if (DECL_FUNCTION_SCOPE_P (decl))
5209 /* Emit code to perform this initialization but once. */
5210 tree if_stmt = NULL_TREE, inner_if_stmt = NULL_TREE;
5211 tree then_clause = NULL_TREE, inner_then_clause = NULL_TREE;
5212 tree guard, guard_addr, guard_addr_list;
5213 tree acquire_fn, release_fn, abort_fn;
5216 /* Emit code to perform this initialization but once. This code
5219 static <type> guard;
5220 if (!guard.first_byte) {
5221 if (__cxa_guard_acquire (&guard)) {
5224 // Do initialization.
5225 flag = true; __cxa_guard_release (&guard);
5226 // Register variable for destruction at end of program.
5228 if (!flag) __cxa_guard_abort (&guard);
5232 Note that the `flag' variable is only set to 1 *after* the
5233 initialization is complete. This ensures that an exception,
5234 thrown during the construction, will cause the variable to
5235 reinitialized when we pass through this code again, as per:
5239 If the initialization exits by throwing an exception, the
5240 initialization is not complete, so it will be tried again
5241 the next time control enters the declaration.
5243 This process should be thread-safe, too; multiple threads
5244 should not be able to initialize the variable more than
5247 /* Create the guard variable. */
5248 guard = get_guard (decl);
5250 /* This optimization isn't safe on targets with relaxed memory
5251 consistency. On such targets we force synchronization in
5252 __cxa_guard_acquire. */
5253 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
5255 /* Begin the conditional initialization. */
5256 if_stmt = begin_if_stmt ();
5257 finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
5258 then_clause = begin_compound_stmt (BCS_NO_SCOPE);
5261 if (flag_threadsafe_statics)
5263 guard_addr = build_address (guard);
5264 guard_addr_list = build_tree_list (NULL_TREE, guard_addr);
5266 acquire_fn = get_identifier ("__cxa_guard_acquire");
5267 release_fn = get_identifier ("__cxa_guard_release");
5268 abort_fn = get_identifier ("__cxa_guard_abort");
5269 if (!get_global_value_if_present (acquire_fn, &acquire_fn))
5271 tree argtypes = tree_cons (NULL_TREE, TREE_TYPE (guard_addr),
5273 tree vfntype = build_function_type (void_type_node, argtypes);
5274 acquire_fn = push_library_fn
5275 (acquire_fn, build_function_type (integer_type_node, argtypes));
5276 release_fn = push_library_fn (release_fn, vfntype);
5277 abort_fn = push_library_fn (abort_fn, vfntype);
5281 release_fn = identifier_global_value (release_fn);
5282 abort_fn = identifier_global_value (abort_fn);
5285 inner_if_stmt = begin_if_stmt ();
5286 finish_if_stmt_cond (build_call (acquire_fn, guard_addr_list),
5289 inner_then_clause = begin_compound_stmt (BCS_NO_SCOPE);
5290 begin = get_target_expr (boolean_false_node);
5291 flag = TARGET_EXPR_SLOT (begin);
5293 TARGET_EXPR_CLEANUP (begin)
5294 = build (COND_EXPR, void_type_node, flag,
5296 build_call (abort_fn, guard_addr_list));
5297 CLEANUP_EH_ONLY (begin) = 1;
5299 /* Do the initialization itself. */
5300 init = add_stmt_to_compound (begin, init);
5301 init = add_stmt_to_compound
5302 (init, build (MODIFY_EXPR, void_type_node, flag, boolean_true_node));
5303 init = add_stmt_to_compound
5304 (init, build_call (release_fn, guard_addr_list));
5307 init = add_stmt_to_compound (init, set_guard (guard));
5309 /* Use atexit to register a function for destroying this static
5311 init = add_stmt_to_compound (init, register_dtor_fn (decl));
5313 finish_expr_stmt (init);
5315 if (flag_threadsafe_statics)
5317 finish_compound_stmt (inner_then_clause);
5318 finish_then_clause (inner_if_stmt);
5319 finish_if_stmt (inner_if_stmt);
5322 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
5324 finish_compound_stmt (then_clause);
5325 finish_then_clause (if_stmt);
5326 finish_if_stmt (if_stmt);
5330 static_aggregates = tree_cons (init, decl, static_aggregates);
5334 /* Make TYPE a complete type based on INITIAL_VALUE.
5335 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
5336 2 if there was no information (in which case assume 0 if DO_DEFAULT). */
5339 complete_array_type (tree type, tree initial_value, int do_default)
5341 tree maxindex = NULL_TREE;
5346 /* An array of character type can be initialized from a
5347 brace-enclosed string constant. */
5348 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type)))
5349 && TREE_CODE (initial_value) == CONSTRUCTOR
5350 && CONSTRUCTOR_ELTS (initial_value)
5351 && (TREE_CODE (TREE_VALUE (CONSTRUCTOR_ELTS (initial_value)))
5353 && TREE_CHAIN (CONSTRUCTOR_ELTS (initial_value)) == NULL_TREE)
5354 initial_value = TREE_VALUE (CONSTRUCTOR_ELTS (initial_value));
5356 /* Note MAXINDEX is really the maximum index, one less than the
5358 if (TREE_CODE (initial_value) == STRING_CST)
5361 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
5362 maxindex = build_int_cst (NULL_TREE,
5363 (TREE_STRING_LENGTH (initial_value)
5366 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
5368 tree elts = CONSTRUCTOR_ELTS (initial_value);
5370 maxindex = ssize_int (-1);
5371 for (; elts; elts = TREE_CHAIN (elts))
5373 if (TREE_PURPOSE (elts))
5374 maxindex = TREE_PURPOSE (elts);
5376 maxindex = size_binop (PLUS_EXPR, maxindex, ssize_int (1));
5381 /* Make an error message unless that happened already. */
5382 if (initial_value != error_mark_node)
5385 initial_value = NULL_TREE;
5387 /* Prevent further error messages. */
5388 maxindex = build_int_cst (NULL_TREE, 0);
5395 maxindex = build_int_cst (NULL_TREE, 0);
5405 domain = build_index_type (maxindex);
5406 TYPE_DOMAIN (type) = domain;
5409 itype = TREE_TYPE (initial_value);
5412 if (itype && !TYPE_DOMAIN (itype))
5413 TYPE_DOMAIN (itype) = domain;
5414 /* The type of the main variant should never be used for arrays
5415 of different sizes. It should only ever be completed with the
5416 size of the array. */
5417 if (! TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)))
5418 TYPE_DOMAIN (TYPE_MAIN_VARIANT (type)) = domain;
5420 elt_type = TREE_TYPE (type);
5421 TYPE_NEEDS_CONSTRUCTING (type)
5422 = TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (elt_type));
5423 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
5424 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TYPE_MAIN_VARIANT (elt_type));
5427 /* Lay out the type now that we can get the real answer. */
5434 /* Return zero if something is declared to be a member of type
5435 CTYPE when in the context of CUR_TYPE. STRING is the error
5436 message to print in that case. Otherwise, quietly return 1. */
5439 member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
5441 if (ctype && ctype != cur_type)
5443 if (flags == DTOR_FLAG)
5444 error ("destructor for alien class %qT cannot be a member", ctype);
5446 error ("constructor for alien class %qT cannot be a member", ctype);
5452 /* Subroutine of `grokdeclarator'. */
5454 /* Generate errors possibly applicable for a given set of specifiers.
5455 This is for ARM $7.1.2. */
5458 bad_specifiers (tree object,
5467 error ("%qD declared as a %<virtual%> %s", object, type);
5469 error ("%qD declared as an %<inline%> %s", object, type);
5471 error ("%<const%> and %<volatile%> function specifiers on "
5472 "%qD invalid in %s declaration",
5475 cp_error_at ("%qD declared as a friend", object);
5477 && (TREE_CODE (object) == TYPE_DECL
5478 || (!TYPE_PTRFN_P (TREE_TYPE (object))
5479 && !TYPE_REFFN_P (TREE_TYPE (object))
5480 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
5481 cp_error_at ("%qD declared with an exception specification", object);
5484 /* CTYPE is class type, or null if non-class.
5485 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
5487 DECLARATOR is the function's name.
5488 PARMS is a chain of PARM_DECLs for the function.
5489 VIRTUALP is truthvalue of whether the function is virtual or not.
5490 FLAGS are to be passed through to `grokclassfn'.
5491 QUALS are qualifiers indicating whether the function is `const'
5493 RAISES is a list of exceptions that this function can raise.
5494 CHECK is 1 if we must find this method in CTYPE, 0 if we should
5495 not look, and -1 if we should not call `grokclassfn' at all.
5497 SFK is the kind of special function (if any) for the new function.
5499 Returns `NULL_TREE' if something goes wrong, after issuing
5500 applicable error messages. */
5503 grokfndecl (tree ctype,
5507 tree orig_declarator,
5509 enum overload_flags flags,
5516 special_function_kind sfk,
5523 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
5524 int has_default_arg = 0;
5528 type = build_exception_variant (type, raises);
5530 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
5531 DECL_ARGUMENTS (decl) = parms;
5532 /* Propagate volatile out from type to decl. */
5533 if (TYPE_VOLATILE (type))
5534 TREE_THIS_VOLATILE (decl) = 1;
5536 /* If this decl has namespace scope, set that up. */
5538 set_decl_namespace (decl, in_namespace, friendp);
5540 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
5542 /* `main' and builtins have implicit 'C' linkage. */
5543 if ((MAIN_NAME_P (declarator)
5544 || (IDENTIFIER_LENGTH (declarator) > 10
5545 && IDENTIFIER_POINTER (declarator)[0] == '_'
5546 && IDENTIFIER_POINTER (declarator)[1] == '_'
5547 && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
5548 && current_lang_name == lang_name_cplusplus
5549 && ctype == NULL_TREE
5550 /* NULL_TREE means global namespace. */
5551 && DECL_CONTEXT (decl) == NULL_TREE)
5552 SET_DECL_LANGUAGE (decl, lang_c);
5554 /* Should probably propagate const out from type to decl I bet (mrs). */
5557 DECL_STATIC_FUNCTION_P (decl) = 1;
5558 DECL_CONTEXT (decl) = ctype;
5562 DECL_CONTEXT (decl) = ctype;
5564 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
5566 if (processing_template_decl)
5567 error ("cannot declare %<::main%> to be a template");
5569 error ("cannot declare %<::main%> to be inline");
5571 error ("cannot declare %<::main%> to be static");
5572 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
5575 error ("%<::main%> must return %<int%>");
5576 TREE_TYPE (TREE_TYPE (decl)) = integer_type_node;
5582 /* Members of anonymous types and local classes have no linkage; make
5583 them internal. If a typedef is made later, this will be changed. */
5584 if (ctype && (TYPE_ANONYMOUS_P (ctype)
5585 || decl_function_context (TYPE_MAIN_DECL (ctype))))
5590 /* [basic.link]: A name with no linkage (notably, the name of a class
5591 or enumeration declared in a local scope) shall not be used to
5592 declare an entity with linkage.
5594 Only check this for public decls for now. See core 319, 389. */
5595 t = no_linkage_check (TREE_TYPE (decl),
5596 /*relaxed_p=*/false);
5599 if (TYPE_ANONYMOUS_P (t))
5601 if (DECL_EXTERN_C_P (decl))
5602 /* Allow this; it's pretty common in C. */;
5605 pedwarn ("non-local function %q#D uses anonymous type",
5607 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
5608 cp_pedwarn_at ("%q#D does not refer to the unqualified "
5609 "type, so it is not used for linkage",
5614 pedwarn ("non-local function %q#D uses local type %qT", decl, t);
5618 TREE_PUBLIC (decl) = publicp;
5621 DECL_INTERFACE_KNOWN (decl) = 1;
5622 DECL_NOT_REALLY_EXTERN (decl) = 1;
5625 /* If the declaration was declared inline, mark it as such. */
5627 DECL_DECLARED_INLINE_P (decl) = 1;
5628 /* We inline functions that are explicitly declared inline, or, when
5629 the user explicitly asks us to, all functions. */
5630 if (DECL_DECLARED_INLINE_P (decl)
5631 || (flag_inline_trees == 2 && !DECL_INLINE (decl) && funcdef_flag))
5632 DECL_INLINE (decl) = 1;
5634 DECL_EXTERNAL (decl) = 1;
5635 if (quals && TREE_CODE (type) == FUNCTION_TYPE)
5637 error ("%smember function %qD cannot have cv-qualifier",
5638 (ctype ? "static " : "non-"), decl);
5639 quals = TYPE_UNQUALIFIED;
5642 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
5643 grok_op_properties (decl, friendp, /*complain=*/true);
5645 if (ctype && decl_function_context (decl))
5646 DECL_NO_STATIC_CHAIN (decl) = 1;
5648 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
5649 if (TREE_PURPOSE (t)
5650 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
5652 has_default_arg = 1;
5657 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
5661 ("defining explicit specialization %qD in friend declaration",
5665 tree fns = TREE_OPERAND (orig_declarator, 0);
5666 tree args = TREE_OPERAND (orig_declarator, 1);
5668 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
5670 /* Something like `template <class T> friend void f<T>()'. */
5671 error ("invalid use of template-id %qD in declaration "
5672 "of primary template",
5678 /* A friend declaration of the form friend void f<>(). Record
5679 the information in the TEMPLATE_ID_EXPR. */
5680 SET_DECL_IMPLICIT_INSTANTIATION (decl);
5682 if (TREE_CODE (fns) == COMPONENT_REF)
5684 /* Due to bison parser ickiness, we will have already looked
5685 up an operator_name or PFUNCNAME within the current class
5686 (see template_id in parse.y). If the current class contains
5687 such a name, we'll get a COMPONENT_REF here. Undo that. */
5689 gcc_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
5690 == current_class_type);
5691 fns = TREE_OPERAND (fns, 1);
5693 gcc_assert (TREE_CODE (fns) == IDENTIFIER_NODE
5694 || TREE_CODE (fns) == OVERLOAD);
5695 DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
5697 if (has_default_arg)
5699 error ("default arguments are not allowed in declaration "
5700 "of friend template specialization %qD",
5707 error ("%<inline%> is not allowed in declaration of friend "
5708 "template specialization %qD",
5716 /* Make the init_value nonzero so pushdecl knows this is not
5717 tentative. error_mark_node is replaced later with the BLOCK. */
5718 DECL_INITIAL (decl) = error_mark_node;
5720 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
5721 TREE_NOTHROW (decl) = 1;
5723 /* Caller will do the rest of this. */
5727 if (ctype != NULL_TREE)
5729 if (sfk == sfk_constructor)
5730 DECL_CONSTRUCTOR_P (decl) = 1;
5732 grokclassfn (ctype, decl, flags, quals);
5735 decl = check_explicit_specialization (orig_declarator, decl,
5737 2 * (funcdef_flag != 0) +
5738 4 * (friendp != 0));
5739 if (decl == error_mark_node)
5744 cplus_decl_attributes (&decl, *attrlist, 0);
5745 *attrlist = NULL_TREE;
5748 if (ctype != NULL_TREE
5749 && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
5754 old_decl = check_classfn (ctype, decl,
5755 (processing_template_decl
5756 > template_class_depth (ctype))
5757 ? current_template_parms
5760 if (old_decl && TREE_CODE (old_decl) == TEMPLATE_DECL)
5761 /* Because grokfndecl is always supposed to return a
5762 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
5763 here. We depend on our callers to figure out that its
5764 really a template that's being returned. */
5765 old_decl = DECL_TEMPLATE_RESULT (old_decl);
5767 if (old_decl && DECL_STATIC_FUNCTION_P (old_decl)
5768 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
5769 /* Remove the `this' parm added by grokclassfn.
5770 XXX Isn't this done in start_function, too? */
5771 revert_static_member_fn (decl);
5772 if (old_decl && DECL_ARTIFICIAL (old_decl))
5773 error ("definition of implicitly-declared %qD", old_decl);
5780 /* Since we've smashed OLD_DECL to its
5781 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
5782 if (TREE_CODE (decl) == TEMPLATE_DECL)
5783 decl = DECL_TEMPLATE_RESULT (decl);
5785 /* Attempt to merge the declarations. This can fail, in
5786 the case of some invalid specialization declarations. */
5787 pushed_scope = push_scope (ctype);
5788 ok = duplicate_decls (decl, old_decl);
5790 pop_scope (pushed_scope);
5793 error ("no %q#D member function declared in class %qT",
5801 if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
5804 if (ctype == NULL_TREE || check)
5808 DECL_VIRTUAL_P (decl) = 1;
5813 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
5814 the linkage that DECL will receive in the object file. */
5817 set_linkage_for_static_data_member (tree decl)
5819 /* A static data member always has static storage duration and
5820 external linkage. Note that static data members are forbidden in
5821 local classes -- the only situation in which a class has
5822 non-external linkage. */
5823 TREE_PUBLIC (decl) = 1;
5824 TREE_STATIC (decl) = 1;
5825 /* For non-template classes, static data members are always put
5826 out in exactly those files where they are defined, just as
5827 with ordinary namespace-scope variables. */
5828 if (!processing_template_decl)
5829 DECL_INTERFACE_KNOWN (decl) = 1;
5832 /* Create a VAR_DECL named NAME with the indicated TYPE.
5834 If SCOPE is non-NULL, it is the class type or namespace containing
5835 the variable. If SCOPE is NULL, the variable should is created in
5836 the innermost enclosings scope. */
5839 grokvardecl (tree type,
5841 const cp_decl_specifier_seq *declspecs,
5847 tree explicit_scope;
5849 gcc_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE);
5851 /* Compute the scope in which to place the variable, but remember
5852 whether or not that scope was explicitly specified by the user. */
5853 explicit_scope = scope;
5856 /* An explicit "extern" specifier indicates a namespace-scope
5858 if (declspecs->storage_class == sc_extern)
5859 scope = current_namespace;
5860 else if (!at_function_scope_p ())
5861 scope = current_scope ();
5865 && (/* If the variable is a namespace-scope variable declared in a
5866 template, we need DECL_LANG_SPECIFIC. */
5867 (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
5868 /* Similarly for namespace-scope variables with language linkage
5870 || (TREE_CODE (scope) == NAMESPACE_DECL
5871 && current_lang_name != lang_name_cplusplus)
5872 /* Similarly for static data members. */
5874 decl = build_lang_decl (VAR_DECL, name, type);
5876 decl = build_decl (VAR_DECL, name, type);
5878 if (explicit_scope && TREE_CODE (explicit_scope) == NAMESPACE_DECL)
5879 set_decl_namespace (decl, explicit_scope, 0);
5881 DECL_CONTEXT (decl) = scope;
5883 if (declspecs->storage_class == sc_extern)
5885 DECL_THIS_EXTERN (decl) = 1;
5886 DECL_EXTERNAL (decl) = !initialized;
5889 if (DECL_CLASS_SCOPE_P (decl))
5891 set_linkage_for_static_data_member (decl);
5892 /* This function is only called with out-of-class definitions. */
5893 DECL_EXTERNAL (decl) = 0;
5895 /* At top level, either `static' or no s.c. makes a definition
5896 (perhaps tentative), and absence of `static' makes it public. */
5897 else if (toplevel_bindings_p ())
5899 TREE_PUBLIC (decl) = (declspecs->storage_class != sc_static
5900 && (DECL_THIS_EXTERN (decl) || ! constp));
5901 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
5903 /* Not at top level, only `static' makes a static definition. */
5906 TREE_STATIC (decl) = declspecs->storage_class == sc_static;
5907 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
5910 if (declspecs->specs[(int)ds_thread])
5912 if (targetm.have_tls)
5913 DECL_THREAD_LOCAL (decl) = 1;
5915 /* A mere warning is sure to result in improper semantics
5916 at runtime. Don't bother to allow this to compile. */
5917 error ("thread-local storage not supported for this target");
5920 if (TREE_PUBLIC (decl))
5922 /* [basic.link]: A name with no linkage (notably, the name of a class
5923 or enumeration declared in a local scope) shall not be used to
5924 declare an entity with linkage.
5926 Only check this for public decls for now. */
5927 tree t1 = TREE_TYPE (decl);
5928 tree t = no_linkage_check (t1, /*relaxed_p=*/false);
5931 if (TYPE_ANONYMOUS_P (t))
5933 if (DECL_EXTERN_C_P (decl))
5934 /* Allow this; it's pretty common in C. */
5936 else if (same_type_ignoring_top_level_qualifiers_p(t1, t))
5937 /* This is something like "enum { a = 3 } x;", which is
5938 well formed. The enum doesn't have "a name with no
5939 linkage", because it has no name. See closed CWG issue
5942 Note that while this construct is well formed in C++03
5943 it is likely to become ill formed in C++0x. See open
5944 CWG issue 389 and related issues. */
5948 /* It's a typedef referring to an anonymous type. */
5949 pedwarn ("non-local variable %q#D uses anonymous type",
5951 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
5952 cp_pedwarn_at ("%q#D does not refer to the unqualified "
5953 "type, so it is not used for linkage",
5958 pedwarn ("non-local variable %q#D uses local type %qT", decl, t);
5965 /* Create and return a canonical pointer to member function type, for
5966 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
5969 build_ptrmemfunc_type (tree type)
5973 tree unqualified_variant = NULL_TREE;
5975 if (type == error_mark_node)
5978 /* If a canonical type already exists for this type, use it. We use
5979 this method instead of type_hash_canon, because it only does a
5980 simple equality check on the list of field members. */
5982 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
5985 /* Make sure that we always have the unqualified pointer-to-member
5987 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
5989 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
5991 t = make_aggr_type (RECORD_TYPE);
5992 xref_basetypes (t, NULL_TREE);
5994 /* Let the front-end know this is a pointer to member function... */
5995 TYPE_PTRMEMFUNC_FLAG (t) = 1;
5996 /* ... and not really an aggregate. */
5997 SET_IS_AGGR_TYPE (t, 0);
5999 field = build_decl (FIELD_DECL, pfn_identifier, type);
6002 field = build_decl (FIELD_DECL, delta_identifier, delta_type_node);
6003 TREE_CHAIN (field) = fields;
6006 finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
6008 /* Zap out the name so that the back-end will give us the debugging
6009 information for this anonymous RECORD_TYPE. */
6010 TYPE_NAME (t) = NULL_TREE;
6012 /* If this is not the unqualified form of this pointer-to-member
6013 type, set the TYPE_MAIN_VARIANT for this type to be the
6014 unqualified type. Since they are actually RECORD_TYPEs that are
6015 not variants of each other, we must do this manually. */
6016 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
6018 t = build_qualified_type (t, cp_type_quals (type));
6019 TYPE_MAIN_VARIANT (t) = unqualified_variant;
6020 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
6021 TYPE_NEXT_VARIANT (unqualified_variant) = t;
6024 /* Cache this pointer-to-member type so that we can find it again
6026 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
6031 /* Create and return a pointer to data member type. */
6034 build_ptrmem_type (tree class_type, tree member_type)
6036 if (TREE_CODE (member_type) == METHOD_TYPE)
6040 arg_types = TYPE_ARG_TYPES (member_type);
6041 class_type = (cp_build_qualified_type
6043 cp_type_quals (TREE_TYPE (TREE_VALUE (arg_types)))));
6045 = build_method_type_directly (class_type,
6046 TREE_TYPE (member_type),
6047 TREE_CHAIN (arg_types));
6048 return build_ptrmemfunc_type (build_pointer_type (member_type));
6052 gcc_assert (TREE_CODE (member_type) != FUNCTION_TYPE);
6053 return build_offset_type (class_type, member_type);
6057 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
6058 Check to see that the definition is valid. Issue appropriate error
6059 messages. Return 1 if the definition is particularly bad, or 0
6063 check_static_variable_definition (tree decl, tree type)
6065 /* Motion 10 at San Diego: If a static const integral data member is
6066 initialized with an integral constant expression, the initializer
6067 may appear either in the declaration (within the class), or in
6068 the definition, but not both. If it appears in the class, the
6069 member is a member constant. The file-scope definition is always
6071 if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
6073 error ("invalid in-class initialization of static data member "
6074 "of non-integral type %qT",
6076 /* If we just return the declaration, crashes will sometimes
6077 occur. We therefore return void_type_node, as if this were a
6078 friend declaration, to cause callers to completely ignore
6079 this declaration. */
6082 else if (!CP_TYPE_CONST_P (type))
6083 error ("ISO C++ forbids in-class initialization of non-const "
6084 "static member %qD",
6086 else if (pedantic && !INTEGRAL_TYPE_P (type))
6087 pedwarn ("ISO C++ forbids initialization of member constant "
6088 "%qD of non-integral type %qT", decl, type);
6093 /* Given the SIZE (i.e., number of elements) in an array, compute an
6094 appropriate index type for the array. If non-NULL, NAME is the
6095 name of the thing being declared. */
6098 compute_array_index_type (tree name, tree size)
6100 tree type = TREE_TYPE (size);
6103 /* The array bound must be an integer type. */
6104 if (!dependent_type_p (type) && !INTEGRAL_TYPE_P (type))
6107 error ("size of array %qD has non-integral type %qT", name, type);
6109 error ("size of array has non-integral type %qT", type);
6110 size = integer_one_node;
6111 type = TREE_TYPE (size);
6114 if (abi_version_at_least (2)
6115 /* We should only handle value dependent expressions specially. */
6116 ? value_dependent_expression_p (size)
6117 /* But for abi-1, we handled all instances in templates. This
6118 effects the manglings produced. */
6119 : processing_template_decl)
6120 return build_index_type (build_min (MINUS_EXPR, sizetype,
6121 size, integer_one_node));
6123 /* The size might be the result of a cast. */
6124 STRIP_TYPE_NOPS (size);
6126 /* It might be a const variable or enumeration constant. */
6127 size = integral_constant_value (size);
6129 /* Normally, the array-bound will be a constant. */
6130 if (TREE_CODE (size) == INTEGER_CST)
6132 /* Check to see if the array bound overflowed. Make that an
6133 error, no matter how generous we're being. */
6134 int old_flag_pedantic_errors = flag_pedantic_errors;
6135 int old_pedantic = pedantic;
6136 pedantic = flag_pedantic_errors = 1;
6137 constant_expression_warning (size);
6138 pedantic = old_pedantic;
6139 flag_pedantic_errors = old_flag_pedantic_errors;
6141 /* An array must have a positive number of elements. */
6142 if (INT_CST_LT (size, integer_zero_node))
6145 error ("size of array %qD is negative", name);
6147 error ("size of array is negative");
6148 size = integer_one_node;
6150 /* As an extension we allow zero-sized arrays. We always allow
6151 them in system headers because glibc uses them. */
6152 else if (integer_zerop (size) && pedantic && !in_system_header)
6155 pedwarn ("ISO C++ forbids zero-size array %qD", name);
6157 pedwarn ("ISO C++ forbids zero-size array");
6160 else if (TREE_CONSTANT (size))
6162 /* `(int) &fn' is not a valid array bound. */
6164 error ("size of array %qD is not an integral constant-expression",
6167 error ("size of array is not an integral constant-expression");
6172 pedwarn ("ISO C++ forbids variable-size array %qD", name);
6174 pedwarn ("ISO C++ forbids variable-size array");
6177 if (processing_template_decl && !TREE_CONSTANT (size))
6178 /* A variable sized array. */
6179 itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node);
6182 HOST_WIDE_INT saved_processing_template_decl;
6184 /* Compute the index of the largest element in the array. It is
6185 one less than the number of elements in the array. We save
6186 and restore PROCESSING_TEMPLATE_DECL so that computations in
6187 cp_build_binary_op will be appropriately folded. */
6188 saved_processing_template_decl = processing_template_decl;
6189 processing_template_decl = 0;
6190 itype = cp_build_binary_op (MINUS_EXPR,
6191 cp_convert (ssizetype, size),
6192 cp_convert (ssizetype, integer_one_node));
6193 itype = fold (itype);
6194 processing_template_decl = saved_processing_template_decl;
6196 if (!TREE_CONSTANT (itype))
6197 /* A variable sized array. */
6198 itype = variable_size (itype);
6199 /* Make sure that there was no overflow when creating to a signed
6200 index type. (For example, on a 32-bit machine, an array with
6201 size 2^32 - 1 is too big.) */
6202 else if (TREE_OVERFLOW (itype))
6204 error ("overflow in array dimension");
6205 TREE_OVERFLOW (itype) = 0;
6209 /* Create and return the appropriate index type. */
6210 return build_index_type (itype);
6213 /* Returns the scope (if any) in which the entity declared by
6214 DECLARATOR will be located. If the entity was declared with an
6215 unqualified name, NULL_TREE is returned. */
6218 get_scope_of_declarator (const cp_declarator *declarator)
6220 while (declarator && declarator->kind != cdk_id)
6221 declarator = declarator->declarator;
6223 /* If the declarator-id is a SCOPE_REF, the scope in which the
6224 declaration occurs is the first operand. */
6226 && declarator->u.id.qualifying_scope)
6227 return declarator->u.id.qualifying_scope;
6229 /* Otherwise, the declarator is not a qualified name; the entity will
6230 be declared in the current scope. */
6234 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
6235 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
6239 create_array_type_for_decl (tree name, tree type, tree size)
6241 tree itype = NULL_TREE;
6242 const char* error_msg;
6244 /* If things have already gone awry, bail now. */
6245 if (type == error_mark_node || size == error_mark_node)
6246 return error_mark_node;
6248 /* Assume that everything will go OK. */
6251 /* There are some types which cannot be array elements. */
6252 switch (TREE_CODE (type))
6255 error_msg = "array of void";
6259 error_msg = "array of functions";
6262 case REFERENCE_TYPE:
6263 error_msg = "array of references";
6267 error_msg = "array of function members";
6274 /* If something went wrong, issue an error-message and return. */
6278 error ("declaration of %qD as %s", name, error_msg);
6280 error ("creating %s", error_msg);
6282 return error_mark_node;
6287 The constant expressions that specify the bounds of the arrays
6288 can be omitted only for the first member of the sequence. */
6289 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
6292 error ("declaration of %qD as multidimensional array must "
6293 "have bounds for all dimensions except the first",
6296 error ("multidimensional array must have bounds for all "
6297 "dimensions except the first");
6299 return error_mark_node;
6302 /* Figure out the index type for the array. */
6304 itype = compute_array_index_type (name, size);
6307 T is called the array element type; this type shall not be [...] an
6308 abstract class type. */
6309 abstract_virtuals_error (name, type);
6311 return build_cplus_array_type (type, itype);
6314 /* Check that it's OK to declare a function with the indicated TYPE.
6315 SFK indicates the kind of special function (if any) that this
6316 function is. OPTYPE is the type given in a conversion operator
6317 declaration, or the class type for a constructor/destructor.
6318 Returns the actual return type of the function; that
6319 may be different than TYPE if an error occurs, or for certain
6320 special functions. */
6323 check_special_function_return_type (special_function_kind sfk,
6329 case sfk_constructor:
6331 error ("return type specification for constructor invalid");
6333 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
6334 type = build_pointer_type (optype);
6336 type = void_type_node;
6339 case sfk_destructor:
6341 error ("return type specification for destructor invalid");
6342 /* We can't use the proper return type here because we run into
6343 problems with ambiguous bases and covariant returns.
6344 Java classes are left unchanged because (void *) isn't a valid
6345 Java type, and we don't want to change the Java ABI. */
6346 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
6347 type = build_pointer_type (void_type_node);
6349 type = void_type_node;
6352 case sfk_conversion:
6353 if (type && !same_type_p (type, optype))
6354 error ("operator %qT declared to return %qT", optype, type);
6356 pedwarn ("return type specified for %<operator %T%>", optype);
6367 /* A variable or data member (whose unqualified name is IDENTIFIER)
6368 has been declared with the indicated TYPE. If the TYPE is not
6369 acceptable, issue an error message and return a type to use for
6370 error-recovery purposes. */
6373 check_var_type (tree identifier, tree type)
6375 if (VOID_TYPE_P (type))
6378 error ("unnamed variable or field declared void");
6379 else if (TREE_CODE (identifier) == IDENTIFIER_NODE)
6381 gcc_assert (!IDENTIFIER_OPNAME_P (identifier));
6382 error ("variable or field %qE declared void", identifier);
6385 error ("variable or field declared void");
6386 type = integer_type_node;
6392 /* Given declspecs and a declarator (abstract or otherwise), determine
6393 the name and type of the object declared and construct a DECL node
6396 DECLSPECS is a chain of tree_list nodes whose value fields
6397 are the storage classes and type specifiers.
6399 DECL_CONTEXT says which syntactic context this declaration is in:
6400 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
6401 FUNCDEF for a function definition. Like NORMAL but a few different
6402 error messages in each case. Return value may be zero meaning
6403 this definition is too screwy to try to parse.
6404 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
6405 handle member functions (which have FIELD context).
6406 Return value may be zero meaning this definition is too screwy to
6408 PARM for a parameter declaration (either within a function prototype
6409 or before a function body). Make a PARM_DECL, or return void_type_node.
6410 CATCHPARM for a parameter declaration before a catch clause.
6411 TYPENAME if for a typename (in a cast or sizeof).
6412 Don't make a DECL node; just return the ..._TYPE node.
6413 FIELD for a struct or union field; make a FIELD_DECL.
6414 BITFIELD for a field with specified width.
6415 INITIALIZED is 1 if the decl has an initializer.
6417 ATTRLIST is a pointer to the list of attributes, which may be NULL
6418 if there are none; *ATTRLIST may be modified if attributes from inside
6419 the declarator should be applied to the declaration.
6421 When this function is called, scoping variables (such as
6422 CURRENT_CLASS_TYPE) should reflect the scope in which the
6423 declaration occurs, not the scope in which the new declaration will
6424 be placed. For example, on:
6428 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
6429 should not be `S'. */
6432 grokdeclarator (const cp_declarator *declarator,
6433 const cp_decl_specifier_seq *declspecs,
6434 enum decl_context decl_context,
6438 tree type = NULL_TREE;
6441 int virtualp, explicitp, friendp, inlinep, staticp;
6442 int explicit_int = 0;
6443 int explicit_char = 0;
6444 int defaulted_int = 0;
6445 tree dependant_name = NULL_TREE;
6447 tree typedef_decl = NULL_TREE;
6448 const char *name = NULL;
6449 tree typedef_type = NULL_TREE;
6450 int funcdef_flag = 0;
6451 cp_declarator_kind innermost_code = cdk_error;
6454 /* See the code below that used this. */
6455 tree decl_attr = NULL_TREE;
6458 /* Keep track of what sort of function is being processed
6459 so that we can warn about default return values, or explicit
6460 return values which do not match prescribed defaults. */
6461 special_function_kind sfk = sfk_none;
6463 tree dname = NULL_TREE;
6464 tree ctor_return_type = NULL_TREE;
6465 enum overload_flags flags = NO_SPECIAL;
6466 cp_cv_quals quals = TYPE_UNQUALIFIED;
6467 tree raises = NULL_TREE;
6468 int template_count = 0;
6469 tree returned_attrs = NULL_TREE;
6470 tree parms = NULL_TREE;
6471 const cp_declarator *id_declarator;
6472 /* The unqualified name of the declarator; either an
6473 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
6474 tree unqualified_id;
6475 /* The class type, if any, in which this entity is located,
6476 or NULL_TREE if none. Note that this value may be different from
6477 the current class type; for example if an attempt is made to declare
6478 "A::f" inside "B", this value will be "A". */
6479 tree ctype = current_class_type;
6480 /* The NAMESPACE_DECL for the namespace in which this entity is
6481 located. If an unqualified name is used to declare the entity,
6482 this value will be NULL_TREE, even if the entity is located at
6484 tree in_namespace = NULL_TREE;
6486 cp_storage_class storage_class;
6487 bool unsigned_p, signed_p, short_p, long_p, thread_p;
6488 bool type_was_error_mark_node = false;
6490 signed_p = declspecs->specs[(int)ds_signed];
6491 unsigned_p = declspecs->specs[(int)ds_unsigned];
6492 short_p = declspecs->specs[(int)ds_short];
6493 long_p = declspecs->specs[(int)ds_long];
6494 thread_p = declspecs->specs[(int)ds_thread];
6496 if (decl_context == FUNCDEF)
6497 funcdef_flag = 1, decl_context = NORMAL;
6498 else if (decl_context == MEMFUNCDEF)
6499 funcdef_flag = -1, decl_context = FIELD;
6500 else if (decl_context == BITFIELD)
6501 bitfield = 1, decl_context = FIELD;
6503 /* Look inside a declarator for the name being declared
6504 and get it as a string, for an error message. */
6505 for (id_declarator = declarator;
6507 id_declarator = id_declarator->declarator)
6509 if (id_declarator->kind != cdk_id)
6510 innermost_code = id_declarator->kind;
6512 switch (id_declarator->kind)
6515 if (id_declarator->declarator
6516 && id_declarator->declarator->kind == cdk_id)
6518 sfk = id_declarator->declarator->u.id.sfk;
6519 if (sfk == sfk_destructor)
6526 tree qualifying_scope = id_declarator->u.id.qualifying_scope;
6527 tree decl = id_declarator->u.id.unqualified_name;
6530 if (qualifying_scope)
6532 if (TYPE_P (qualifying_scope))
6534 ctype = qualifying_scope;
6535 if (innermost_code != cdk_function
6536 && current_class_type
6537 && !UNIQUELY_DERIVED_FROM_P (ctype,
6538 current_class_type))
6540 error ("type %qT is not derived from type %qT",
6541 ctype, current_class_type);
6542 return error_mark_node;
6545 else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL)
6546 in_namespace = qualifying_scope;
6548 if (TREE_CODE (decl) == BASELINK)
6549 decl = BASELINK_FUNCTIONS (decl);
6550 if (decl == error_mark_node)
6551 return error_mark_node;
6552 switch (TREE_CODE (decl))
6558 if (innermost_code != cdk_function)
6560 error ("declaration of %qD as non-function", decl);
6561 return error_mark_node;
6563 else if (!qualifying_scope
6564 && !(current_class_type && at_class_scope_p ()))
6566 error ("declaration of %qD as non-member", decl);
6567 return error_mark_node;
6570 type = TREE_OPERAND (decl, 0);
6571 name = IDENTIFIER_POINTER (constructor_name (type));
6575 case TEMPLATE_ID_EXPR:
6577 tree fns = TREE_OPERAND (decl, 0);
6580 if (TREE_CODE (dname) == COMPONENT_REF)
6581 dname = TREE_OPERAND (dname, 1);
6582 if (TREE_CODE (dname) != IDENTIFIER_NODE)
6584 gcc_assert (is_overloaded_fn (dname));
6585 dname = DECL_NAME (get_first_fn (dname));
6590 case IDENTIFIER_NODE:
6591 if (TREE_CODE (decl) == IDENTIFIER_NODE)
6594 if (C_IS_RESERVED_WORD (dname))
6596 error ("declarator-id missing; using reserved word %qD",
6598 name = IDENTIFIER_POINTER (dname);
6600 else if (!IDENTIFIER_TYPENAME_P (dname))
6601 name = IDENTIFIER_POINTER (dname);
6604 gcc_assert (flags == NO_SPECIAL);
6605 flags = TYPENAME_FLAG;
6606 ctor_return_type = TREE_TYPE (dname);
6607 sfk = sfk_conversion;
6608 if (is_typename_at_global_scope (dname))
6609 name = IDENTIFIER_POINTER (dname);
6611 name = "<invalid operator>";
6616 dname = constructor_name (TREE_TYPE (decl));
6617 name = IDENTIFIER_POINTER (dname);
6638 if (id_declarator->kind == cdk_id)
6642 /* A function definition's declarator must have the form of
6643 a function declarator. */
6645 if (funcdef_flag && innermost_code != cdk_function)
6648 if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
6649 && innermost_code != cdk_function
6650 && ! (ctype && !declspecs->any_specifiers_p))
6652 error ("declaration of %qD as non-function", dname);
6653 return error_mark_node;
6656 /* Anything declared one level down from the top level
6657 must be one of the parameters of a function
6658 (because the body is at least two levels down). */
6660 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
6661 by not allowing C++ class definitions to specify their parameters
6662 with xdecls (must be spec.d in the parmlist).
6664 Since we now wait to push a class scope until we are sure that
6665 we are in a legitimate method context, we must set oldcname
6666 explicitly (since current_class_name is not yet alive).
6668 We also want to avoid calling this a PARM if it is in a namespace. */
6670 if (decl_context == NORMAL && !toplevel_bindings_p ())
6672 struct cp_binding_level *b = current_binding_level;
6673 current_binding_level = b->level_chain;
6674 if (current_binding_level != 0 && toplevel_bindings_p ())
6675 decl_context = PARM;
6676 current_binding_level = b;
6680 name = decl_context == PARM ? "parameter" : "type name";
6682 /* If there were multiple types specified in the decl-specifier-seq,
6683 issue an error message. */
6684 if (declspecs->multiple_types_p)
6685 error ("two or more data types in declaration of %qs", name);
6686 /* Extract the basic type from the decl-specifier-seq. */
6687 type = declspecs->type;
6688 if (type == error_mark_node)
6691 type_was_error_mark_node = true;
6693 /* If the entire declaration is itself tagged as deprecated then
6694 suppress reports of deprecated items. */
6695 if (type && TREE_DEPRECATED (type)
6696 && deprecated_state != DEPRECATED_SUPPRESS)
6697 warn_deprecated_use (type);
6698 if (type && TREE_CODE (type) == TYPE_DECL)
6700 typedef_decl = type;
6701 type = TREE_TYPE (typedef_decl);
6703 /* No type at all: default to `int', and set DEFAULTED_INT
6704 because it was not a user-defined typedef. */
6705 if (type == NULL_TREE && (signed_p || unsigned_p || long_p || short_p))
6707 /* These imply 'int'. */
6708 type = integer_type_node;
6712 explicit_int = declspecs->explicit_int_p;
6713 explicit_char = declspecs->explicit_char_p;
6715 /* Check for repeated decl-specifiers. */
6716 for (ds = ds_first; ds != ds_last; ++ds)
6718 unsigned count = declspecs->specs[(int)ds];
6721 /* The "long" specifier is a special case because of
6726 error ("%<long long long%> is too long for GCC");
6727 else if (pedantic && !in_system_header && warn_long_long)
6728 pedwarn ("ISO C++ does not support %<long long%>");
6732 else if (declspecs->specs[(int)ds] > 1)
6734 static const char *const decl_spec_names[] = {
6750 error ("duplicate %qs", decl_spec_names[(int)ds]);
6755 /* See the code below that used this. */
6757 decl_attr = DECL_ATTRIBUTES (typedef_decl);
6759 typedef_type = type;
6762 if (sfk != sfk_conversion)
6763 ctor_return_type = ctype;
6765 if (sfk != sfk_none)
6766 type = check_special_function_return_type (sfk, type,
6768 else if (type == NULL_TREE)
6774 /* We handle `main' specially here, because 'main () { }' is so
6775 common. With no options, it is allowed. With -Wreturn-type,
6776 it is a warning. It is only an error with -pedantic-errors. */
6777 is_main = (funcdef_flag
6778 && dname && MAIN_NAME_P (dname)
6779 && ctype == NULL_TREE
6780 && in_namespace == NULL_TREE
6781 && current_namespace == global_namespace);
6783 if (type_was_error_mark_node)
6784 /* We've already issued an error, don't complain more. */;
6785 else if (in_system_header || flag_ms_extensions)
6786 /* Allow it, sigh. */;
6787 else if (pedantic || ! is_main)
6788 pedwarn ("ISO C++ forbids declaration of %qs with no type", name);
6789 else if (warn_return_type)
6790 warning ("ISO C++ forbids declaration of %qs with no type", name);
6792 type = integer_type_node;
6797 /* Now process the modifiers that were specified
6798 and check for invalid combinations. */
6800 /* Long double is a special combination. */
6801 if (long_p && TYPE_MAIN_VARIANT (type) == double_type_node)
6804 type = build_qualified_type (long_double_type_node,
6805 cp_type_quals (type));
6808 /* Check all other uses of type modifiers. */
6810 if (unsigned_p || signed_p || long_p || short_p)
6814 if (TREE_CODE (type) == REAL_TYPE)
6815 error ("short, signed or unsigned invalid for %qs", name);
6816 else if (TREE_CODE (type) != INTEGER_TYPE)
6817 error ("long, short, signed or unsigned invalid for %qs", name);
6818 else if (long_p && short_p)
6819 error ("long and short specified together for %qs", name);
6820 else if ((long_p || short_p) && explicit_char)
6821 error ("long or short specified with char for %qs", name);
6822 else if ((long_p|| short_p) && TREE_CODE (type) == REAL_TYPE)
6823 error ("long or short specified with floating type for %qs", name);
6824 else if (signed_p && unsigned_p)
6825 error ("signed and unsigned given together for %qs", name);
6829 if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
6831 pedwarn ("long, short, signed or unsigned used invalidly for %qs",
6833 if (flag_pedantic_errors)
6838 /* Discard the type modifiers if they are invalid. */
6849 /* Decide whether an integer type is signed or not.
6850 Optionally treat bitfields as signed by default. */
6854 It is implementation-defined whether a plain (neither
6855 explicitly signed or unsigned) char, short, int, or long
6856 bit-field is signed or unsigned.
6858 Naturally, we extend this to long long as well. Note that
6859 this does not include wchar_t. */
6860 || (bitfield && !flag_signed_bitfields
6862 /* A typedef for plain `int' without `signed' can be
6863 controlled just like plain `int', but a typedef for
6864 `signed int' cannot be so controlled. */
6866 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
6867 && (TREE_CODE (type) == INTEGER_TYPE
6868 || TREE_CODE (type) == CHAR_TYPE)
6869 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
6872 type = long_long_unsigned_type_node;
6874 type = long_unsigned_type_node;
6876 type = short_unsigned_type_node;
6877 else if (type == char_type_node)
6878 type = unsigned_char_type_node;
6879 else if (typedef_decl)
6880 type = c_common_unsigned_type (type);
6882 type = unsigned_type_node;
6884 else if (signed_p && type == char_type_node)
6885 type = signed_char_type_node;
6887 type = long_long_integer_type_node;
6889 type = long_integer_type_node;
6891 type = short_integer_type_node;
6893 if (declspecs->specs[(int)ds_complex])
6895 if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
6896 error ("complex invalid for %qs", name);
6897 /* If we just have "complex", it is equivalent to
6898 "complex double", but if any modifiers at all are specified it is
6899 the complex form of TYPE. E.g, "complex short" is
6900 "complex short int". */
6902 else if (defaulted_int && ! longlong
6903 && ! (long_p || short_p || signed_p || unsigned_p))
6904 type = complex_double_type_node;
6905 else if (type == integer_type_node)
6906 type = complex_integer_type_node;
6907 else if (type == float_type_node)
6908 type = complex_float_type_node;
6909 else if (type == double_type_node)
6910 type = complex_double_type_node;
6911 else if (type == long_double_type_node)
6912 type = complex_long_double_type_node;
6914 type = build_complex_type (type);
6917 type_quals = TYPE_UNQUALIFIED;
6918 if (declspecs->specs[(int)ds_const])
6919 type_quals |= TYPE_QUAL_CONST;
6920 if (declspecs->specs[(int)ds_volatile])
6921 type_quals |= TYPE_QUAL_VOLATILE;
6922 if (declspecs->specs[(int)ds_restrict])
6923 type_quals |= TYPE_QUAL_RESTRICT;
6924 if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
6925 error ("qualifiers are not allowed on declaration of %<operator %T%>",
6928 if (TREE_CODE (type) == FUNCTION_TYPE
6929 && type_quals != TYPE_UNQUALIFIED)
6931 /* This was an error in C++98 (cv-qualifiers cannot be added to
6932 a function type), but DR 295 makes the code well-formed by
6933 dropping the extra qualifiers. */
6936 tree bad_type = build_qualified_type (type, type_quals);
6937 pedwarn ("ignoring %qV qualifiers added to function type %qT",
6940 type_quals = TYPE_UNQUALIFIED;
6942 type_quals |= cp_type_quals (type);
6943 type = cp_build_qualified_type_real
6944 (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
6945 ? tf_ignore_bad_quals : 0) | tf_error | tf_warning));
6946 /* We might have ignored or rejected some of the qualifiers. */
6947 type_quals = cp_type_quals (type);
6950 inlinep = !! declspecs->specs[(int)ds_inline];
6951 virtualp = !! declspecs->specs[(int)ds_virtual];
6952 explicitp = !! declspecs->specs[(int)ds_explicit];
6954 storage_class = declspecs->storage_class;
6955 if (storage_class == sc_static)
6956 staticp = 1 + (decl_context == FIELD);
6958 if (virtualp && staticp == 2)
6960 error ("member %qD cannot be declared both virtual and static", dname);
6963 friendp = !! declspecs->specs[(int)ds_friend];
6965 if (dependant_name && !friendp)
6967 error ("%<%T::%D%> is not a valid declarator", ctype, dependant_name);
6968 return void_type_node;
6971 /* Issue errors about use of storage classes for parameters. */
6972 if (decl_context == PARM)
6974 if (declspecs->specs[(int)ds_typedef])
6975 error ("typedef declaration invalid in parameter declaration");
6976 else if (storage_class == sc_static
6977 || storage_class == sc_extern
6979 error ("storage class specifiers invalid in parameter declarations");
6982 /* Give error if `virtual' is used outside of class declaration. */
6984 && (current_class_name == NULL_TREE || decl_context != FIELD))
6986 error ("virtual outside class declaration");
6990 /* Static anonymous unions are dealt with here. */
6991 if (staticp && decl_context == TYPENAME
6993 && ANON_AGGR_TYPE_P (declspecs->type))
6994 decl_context = FIELD;
6996 /* Warn about storage classes that are invalid for certain
6997 kinds of declarations (parameters, typenames, etc.). */
6998 if (declspecs->multiple_storage_classes_p)
6999 error ("multiple storage classes in declaration of %qs", name);
7002 && storage_class != sc_extern
7003 && storage_class != sc_static)
7004 || declspecs->specs[(int)ds_typedef]))
7006 error ("multiple storage classes in declaration of %qs", name);
7009 else if (decl_context != NORMAL
7010 && ((storage_class != sc_none
7011 && storage_class != sc_mutable)
7014 if ((decl_context == PARM || decl_context == CATCHPARM)
7015 && (storage_class == sc_register
7016 || storage_class == sc_auto))
7018 else if (declspecs->specs[(int)ds_typedef])
7020 else if (decl_context == FIELD
7021 /* C++ allows static class elements. */
7022 && storage_class == sc_static)
7023 /* C++ also allows inlines and signed and unsigned elements,
7024 but in those cases we don't come in here. */
7028 if (decl_context == FIELD)
7030 tree tmp = NULL_TREE;
7035 /* Avoid trying to get an operand off an identifier node. */
7036 if (declarator->kind != cdk_id)
7037 tmp = declarator->declarator->u.id.unqualified_name;
7039 tmp = declarator->u.id.unqualified_name;
7040 op = IDENTIFIER_OPNAME_P (tmp);
7041 if (IDENTIFIER_TYPENAME_P (tmp))
7043 if (is_typename_at_global_scope (tmp))
7044 name = IDENTIFIER_POINTER (tmp);
7046 name = "<invalid operator>";
7049 error ("storage class specified for %s %qs",
7050 op ? "member operator" : "field",
7055 if (decl_context == PARM || decl_context == CATCHPARM)
7056 error ("storage class specified for parameter %qs", name);
7058 error ("storage class specified for typename");
7060 if (storage_class == sc_register
7061 || storage_class == sc_auto
7062 || storage_class == sc_extern
7064 storage_class = sc_none;
7067 else if (storage_class == sc_extern && initialized
7070 if (toplevel_bindings_p ())
7072 /* It's common practice (and completely valid) to have a const
7073 be initialized and declared extern. */
7074 if (!(type_quals & TYPE_QUAL_CONST))
7075 warning ("%qs initialized and declared %<extern%>", name);
7078 error ("%qs has both %<extern%> and initializer", name);
7080 else if (storage_class == sc_extern && funcdef_flag
7081 && ! toplevel_bindings_p ())
7082 error ("nested function %qs declared %<extern%>", name);
7083 else if (toplevel_bindings_p ())
7085 if (storage_class == sc_auto)
7086 error ("top-level declaration of %qs specifies %<auto%>", name);
7089 && storage_class != sc_extern
7090 && storage_class != sc_static)
7092 error ("function-scope %qs implicitly auto and declared %<__thread%>",
7097 if (storage_class && friendp)
7098 error ("storage class specifiers invalid in friend function declarations");
7101 unqualified_id = NULL_TREE;
7104 unqualified_id = id_declarator->u.id.unqualified_name;
7105 if (TREE_CODE (unqualified_id) == BASELINK)
7106 unqualified_id = BASELINK_FUNCTIONS (unqualified_id);
7107 switch (TREE_CODE (unqualified_id))
7111 = constructor_name (TREE_OPERAND (unqualified_id, 0));
7116 = constructor_name (TREE_TYPE (unqualified_id));
7119 case IDENTIFIER_NODE:
7120 case TEMPLATE_ID_EXPR:
7128 /* Determine the type of the entity declared by recurring on the
7131 declarator && declarator->kind != cdk_id;
7132 declarator = declarator->declarator)
7134 const cp_declarator *inner_declarator;
7137 if (type == error_mark_node)
7138 return error_mark_node;
7140 inner_declarator = declarator->declarator;
7142 attrs = declarator->attributes;
7148 if (declarator == NULL || declarator->kind == cdk_id)
7149 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
7150 if (declarator->kind == cdk_function)
7151 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
7152 if (declarator->kind == cdk_array)
7153 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
7154 returned_attrs = decl_attributes (&type,
7155 chainon (returned_attrs, attrs),
7159 switch (declarator->kind)
7162 type = create_array_type_for_decl (dname, type,
7163 declarator->u.array.bounds);
7171 /* Declaring a function type.
7172 Make sure we have a valid type for the function to return. */
7174 /* We now know that the TYPE_QUALS don't apply to the
7175 decl, but to its return type. */
7176 type_quals = TYPE_UNQUALIFIED;
7178 /* Warn about some types functions can't return. */
7180 if (TREE_CODE (type) == FUNCTION_TYPE)
7182 error ("%qs declared as function returning a function", name);
7183 type = integer_type_node;
7185 if (TREE_CODE (type) == ARRAY_TYPE)
7187 error ("%qs declared as function returning an array", name);
7188 type = integer_type_node;
7191 /* Pick up type qualifiers which should be applied to `this'. */
7192 quals = declarator->u.function.qualifiers;
7194 /* Pick up the exception specifications. */
7195 raises = declarator->u.function.exception_specification;
7197 /* Say it's a definition only for the CALL_EXPR
7198 closest to the identifier. */
7199 funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id;
7201 if (ctype == NULL_TREE
7202 && decl_context == FIELD
7204 && (friendp == 0 || dname == current_class_name))
7205 ctype = current_class_type;
7207 if (ctype && sfk == sfk_conversion)
7208 TYPE_HAS_CONVERSION (ctype) = 1;
7209 if (ctype && (sfk == sfk_constructor
7210 || sfk == sfk_destructor))
7212 /* We are within a class's scope. If our declarator name
7213 is the same as the class name, and we are defining
7214 a function, then it is a constructor/destructor, and
7215 therefore returns a void type. */
7217 if (flags == DTOR_FLAG)
7219 /* ISO C++ 12.4/2. A destructor may not be
7220 declared const or volatile. A destructor may
7223 error ("destructor cannot be static member function");
7226 error ("destructors may not be cv-qualified");
7227 quals = TYPE_UNQUALIFIED;
7229 if (decl_context == FIELD)
7231 if (! member_function_or_else (ctype,
7234 return void_type_node;
7237 else /* It's a constructor. */
7241 /* ISO C++ 12.1. A constructor may not be
7242 declared const or volatile. A constructor may
7243 not be virtual. A constructor may not be
7246 error ("constructor cannot be static member function");
7249 pedwarn ("constructors cannot be declared virtual");
7254 error ("constructors may not be cv-qualified");
7255 quals = TYPE_UNQUALIFIED;
7257 if (decl_context == FIELD)
7259 if (! member_function_or_else (ctype,
7262 return void_type_node;
7263 TYPE_HAS_CONSTRUCTOR (ctype) = 1;
7264 if (sfk != sfk_constructor)
7268 if (decl_context == FIELD)
7274 error ("can't initialize friend function %qs", name);
7277 /* Cannot be both friend and virtual. */
7278 error ("virtual functions cannot be friends");
7281 if (decl_context == NORMAL)
7282 error ("friend declaration not in class definition");
7283 if (current_function_decl && funcdef_flag)
7284 error ("can't define friend function %qs in a local "
7289 arg_types = grokparms (declarator->u.function.parameters,
7292 if (inner_declarator
7293 && inner_declarator->kind == cdk_id
7294 && inner_declarator->u.id.sfk == sfk_destructor
7295 && arg_types != void_list_node)
7297 error ("destructors may not have parameters");
7298 arg_types = void_list_node;
7302 type = build_function_type (type, arg_types);
7303 type = cp_build_qualified_type (type, quals);
7310 /* Filter out pointers-to-references and references-to-references.
7311 We can get these if a TYPE_DECL is used. */
7313 if (TREE_CODE (type) == REFERENCE_TYPE)
7315 error (declarator->kind == cdk_reference
7316 ? "cannot declare reference to %q#T"
7317 : "cannot declare pointer to %q#T", type);
7318 type = TREE_TYPE (type);
7320 else if (VOID_TYPE_P (type))
7322 if (declarator->kind == cdk_reference)
7323 error ("cannot declare reference to %q#T", type);
7324 else if (declarator->kind == cdk_ptrmem)
7325 error ("cannot declare pointer to %q#T member", type);
7328 /* We now know that the TYPE_QUALS don't apply to the decl,
7329 but to the target of the pointer. */
7330 type_quals = TYPE_UNQUALIFIED;
7332 if (declarator->kind == cdk_ptrmem
7333 && (TREE_CODE (type) == FUNCTION_TYPE
7334 || (quals && TREE_CODE (type) == METHOD_TYPE)))
7338 /* If the type is a FUNCTION_TYPE, pick up the
7339 qualifiers from that function type. No other
7340 qualifiers may be supplied. */
7341 if (TREE_CODE (type) == FUNCTION_TYPE)
7342 quals = cp_type_quals (type);
7344 dummy = build_decl (TYPE_DECL, NULL_TREE, type);
7345 grok_method_quals (declarator->u.pointer.class_type,
7347 type = TREE_TYPE (dummy);
7348 quals = TYPE_UNQUALIFIED;
7351 if (declarator->kind == cdk_reference)
7353 if (!VOID_TYPE_P (type))
7354 type = build_reference_type (type);
7356 else if (TREE_CODE (type) == METHOD_TYPE)
7357 type = build_ptrmemfunc_type (build_pointer_type (type));
7358 else if (declarator->kind == cdk_ptrmem)
7360 /* We might have parsed a namespace as the class type. */
7361 if (TREE_CODE (declarator->u.pointer.class_type)
7364 error ("%qD is a namespace",
7365 declarator->u.pointer.class_type);
7366 type = build_pointer_type (type);
7368 else if (declarator->u.pointer.class_type == error_mark_node)
7369 /* We will already have complained. */
7370 type = error_mark_node;
7372 type = build_ptrmem_type (declarator->u.pointer.class_type,
7376 type = build_pointer_type (type);
7378 /* Process a list of type modifier keywords (such as
7379 const or volatile) that were given inside the `*' or `&'. */
7381 if (declarator->u.pointer.qualifiers)
7384 = cp_build_qualified_type (type,
7385 declarator->u.pointer.qualifiers);
7386 type_quals = cp_type_quals (type);
7399 if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR
7400 && TREE_CODE (type) != FUNCTION_TYPE
7401 && TREE_CODE (type) != METHOD_TYPE)
7403 error ("template-id %qD used as a declarator",
7405 unqualified_id = dname;
7408 /* If DECLARATOR is non-NULL, we know it is a cdk_id declarator;
7409 otherwise, we would not have exited the loop above. */
7411 && declarator->u.id.qualifying_scope
7412 && TYPE_P (declarator->u.id.qualifying_scope))
7416 ctype = declarator->u.id.qualifying_scope;
7417 ctype = TYPE_MAIN_VARIANT (ctype);
7419 while (t != NULL_TREE && CLASS_TYPE_P (t))
7421 /* You're supposed to have one `template <...>' for every
7422 template class, but you don't need one for a full
7423 specialization. For example:
7425 template <class T> struct S{};
7426 template <> struct S<int> { void f(); };
7427 void S<int>::f () {}
7429 is correct; there shouldn't be a `template <>' for the
7430 definition of `S<int>::f'. */
7431 if (CLASSTYPE_TEMPLATE_INFO (t)
7432 && (CLASSTYPE_TEMPLATE_INSTANTIATION (t)
7433 || uses_template_parms (CLASSTYPE_TI_ARGS (t)))
7434 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
7435 template_count += 1;
7437 t = TYPE_MAIN_DECL (t);
7438 t = DECL_CONTEXT (t);
7441 if (ctype == current_class_type)
7447 Is this ill-formed? */
7450 pedwarn ("extra qualification %<%T::%> on member %qs ignored",
7453 else if (TREE_CODE (type) == FUNCTION_TYPE)
7455 tree sname = declarator->u.id.unqualified_name;
7457 if (TREE_CODE (sname) == IDENTIFIER_NODE
7458 && NEW_DELETE_OPNAME_P (sname))
7459 /* Overloaded operator new and operator delete
7460 are always static functions. */
7462 else if (current_class_type == NULL_TREE || friendp)
7464 = build_method_type_directly (ctype,
7466 TYPE_ARG_TYPES (type));
7469 error ("cannot declare member function %<%T::%s%> within %<%T%>",
7470 ctype, name, current_class_type);
7471 return error_mark_node;
7474 else if (declspecs->specs[(int)ds_typedef]
7475 || COMPLETE_TYPE_P (complete_type (ctype)))
7477 /* Have to move this code elsewhere in this function.
7478 this code is used for i.e., typedef int A::M; M *pm;
7480 It is? How? jason 10/2/94 */
7482 if (current_class_type)
7484 error ("cannot declare member %<%T::%s%> within %qT",
7485 ctype, name, current_class_type);
7486 return void_type_node;
7491 cxx_incomplete_type_error (NULL_TREE, ctype);
7492 return error_mark_node;
7499 *attrlist = chainon (returned_attrs, *attrlist);
7501 attrlist = &returned_attrs;
7504 /* Now TYPE has the actual type. */
7506 /* Did array size calculations overflow? */
7508 if (TREE_CODE (type) == ARRAY_TYPE
7509 && COMPLETE_TYPE_P (type)
7510 && TREE_OVERFLOW (TYPE_SIZE (type)))
7512 error ("size of array %qs is too large", name);
7513 /* If we proceed with the array type as it is, we'll eventually
7514 crash in tree_low_cst(). */
7515 type = error_mark_node;
7518 if ((decl_context == FIELD || decl_context == PARM)
7519 && !processing_template_decl
7520 && variably_modified_type_p (type, NULL_TREE))
7522 if (decl_context == FIELD)
7523 error ("data member may not have variably modified type %qT", type);
7525 error ("parameter may not have variably modified type %qT", type);
7526 type = error_mark_node;
7529 if (explicitp == 1 || (explicitp && friendp))
7531 /* [dcl.fct.spec] The explicit specifier shall only be used in
7532 declarations of constructors within a class definition. */
7533 error ("only declarations of constructors can be %<explicit%>");
7537 if (storage_class == sc_mutable)
7539 if (decl_context != FIELD || friendp)
7541 error ("non-member %qs cannot be declared %<mutable%>", name);
7542 storage_class = sc_none;
7544 else if (decl_context == TYPENAME || declspecs->specs[(int)ds_typedef])
7546 error ("non-object member %qs cannot be declared %<mutable%>", name);
7547 storage_class = sc_none;
7549 else if (TREE_CODE (type) == FUNCTION_TYPE
7550 || TREE_CODE (type) == METHOD_TYPE)
7552 error ("function %qs cannot be declared %<mutable%>", name);
7553 storage_class = sc_none;
7557 error ("static %qs cannot be declared %<mutable%>", name);
7558 storage_class = sc_none;
7560 else if (type_quals & TYPE_QUAL_CONST)
7562 error ("const %qs cannot be declared %<mutable%>", name);
7563 storage_class = sc_none;
7567 /* If this is declaring a typedef name, return a TYPE_DECL. */
7568 if (declspecs->specs[(int)ds_typedef] && decl_context != TYPENAME)
7572 /* Note that the grammar rejects storage classes
7573 in typenames, fields or parameters. */
7574 if (current_lang_name == lang_name_java)
7575 TYPE_FOR_JAVA (type) = 1;
7577 if (decl_context == FIELD)
7578 decl = build_lang_decl (TYPE_DECL, unqualified_id, type);
7580 decl = build_decl (TYPE_DECL, unqualified_id, type);
7581 if (id_declarator && declarator->u.id.qualifying_scope)
7582 error ("%Jtypedef name may not be a nested-name-specifier", decl);
7584 if (decl_context != FIELD)
7586 if (!current_function_decl)
7587 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
7588 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl)
7589 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
7590 (current_function_decl)))
7591 /* The TYPE_DECL is "abstract" because there will be
7592 clones of this constructor/destructor, and there will
7593 be copies of this TYPE_DECL generated in those
7595 DECL_ABSTRACT (decl) = 1;
7597 else if (constructor_name_p (unqualified_id, current_class_type))
7598 pedwarn ("ISO C++ forbids nested type %qD with same name "
7599 "as enclosing class",
7602 /* If the user declares "typedef struct {...} foo" then the
7603 struct will have an anonymous name. Fill that name in now.
7604 Nothing can refer to it, so nothing needs know about the name
7606 if (type != error_mark_node
7609 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7610 && TYPE_ANONYMOUS_P (type)
7611 /* Don't do this if there are attributes. */
7612 && (!attrlist || !*attrlist)
7613 && cp_type_quals (type) == TYPE_UNQUALIFIED)
7615 tree oldname = TYPE_NAME (type);
7618 /* Replace the anonymous name with the real name everywhere. */
7619 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
7620 if (TYPE_NAME (t) == oldname)
7621 TYPE_NAME (t) = decl;
7623 if (TYPE_LANG_SPECIFIC (type))
7624 TYPE_WAS_ANONYMOUS (type) = 1;
7626 /* If this is a typedef within a template class, the nested
7627 type is a (non-primary) template. The name for the
7628 template needs updating as well. */
7629 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
7630 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
7631 = TYPE_IDENTIFIER (type);
7633 /* FIXME remangle member functions; member functions of a
7634 type with external linkage have external linkage. */
7639 if (ctype == NULL_TREE)
7641 if (TREE_CODE (type) == METHOD_TYPE)
7642 ctype = TYPE_METHOD_BASETYPE (type);
7643 /* Any qualifiers on a function type typedef have
7644 already been dealt with. */
7645 else if (TREE_CODE (type) == FUNCTION_TYPE)
7646 quals = TYPE_UNQUALIFIED;
7648 if (ctype != NULL_TREE)
7649 grok_method_quals (ctype, decl, quals);
7653 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
7654 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
7656 bad_specifiers (decl, "type", virtualp, quals != TYPE_UNQUALIFIED,
7657 inlinep, friendp, raises != NULL_TREE);
7662 /* Detect the case of an array type of unspecified size
7663 which came, as such, direct from a typedef name.
7664 We must copy the type, so that the array's domain can be
7665 individually set by the object's initializer. */
7667 if (type && typedef_type
7668 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
7669 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
7670 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
7672 /* Detect where we're using a typedef of function type to declare a
7673 function. PARMS will not be set, so we must create it now. */
7675 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
7677 tree decls = NULL_TREE;
7680 for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
7682 tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
7684 TREE_CHAIN (decl) = decls;
7688 parms = nreverse (decls);
7690 if (decl_context != TYPENAME)
7692 /* A cv-qualifier-seq shall only be part of the function type
7693 for a non-static member function. [8.3.5/4 dcl.fct] */
7694 if (cp_type_quals (type) != TYPE_UNQUALIFIED
7695 && (current_class_type == NULL_TREE || staticp) )
7697 error ("qualified function types cannot be used to declare %s functions",
7698 (staticp? "static member" : "free"));
7699 type = TYPE_MAIN_VARIANT (type);
7702 /* The qualifiers on the function type become the qualifiers on
7703 the non-static member function. */
7704 quals |= cp_type_quals (type);
7708 /* If this is a type name (such as, in a cast or sizeof),
7709 compute the type and return it now. */
7711 if (decl_context == TYPENAME)
7713 /* Note that the grammar rejects storage classes
7714 in typenames, fields or parameters. */
7715 if (type_quals != TYPE_UNQUALIFIED)
7716 type_quals = TYPE_UNQUALIFIED;
7718 /* Special case: "friend class foo" looks like a TYPENAME context. */
7721 if (type_quals != TYPE_UNQUALIFIED)
7723 error ("type qualifiers specified for friend class declaration");
7724 type_quals = TYPE_UNQUALIFIED;
7728 error ("%<inline%> specified for friend class declaration");
7734 /* Don't allow friend declaration without a class-key. */
7735 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
7736 pedwarn ("template parameters cannot be friends");
7737 else if (TREE_CODE (type) == TYPENAME_TYPE)
7738 pedwarn ("friend declaration requires class-key, "
7739 "i.e. %<friend class %T::%D%>",
7740 TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
7742 pedwarn ("friend declaration requires class-key, "
7743 "i.e. %<friend %#T%>",
7747 /* Only try to do this stuff if we didn't already give up. */
7748 if (type != integer_type_node)
7750 /* A friendly class? */
7751 if (current_class_type)
7752 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
7755 error ("trying to make class %qT a friend of global scope",
7758 type = void_type_node;
7763 if (ctype == NULL_TREE)
7765 if (TREE_CODE (type) != METHOD_TYPE)
7766 error ("invalid qualifiers on non-member function type");
7768 ctype = TYPE_METHOD_BASETYPE (type);
7772 tree dummy = build_decl (TYPE_DECL, unqualified_id, type);
7773 grok_method_quals (ctype, dummy, quals);
7774 type = TREE_TYPE (dummy);
7780 else if (unqualified_id == NULL_TREE && decl_context != PARM
7781 && decl_context != CATCHPARM
7782 && TREE_CODE (type) != UNION_TYPE
7785 error ("abstract declarator %qT used as declaration", type);
7786 return error_mark_node;
7789 /* Only functions may be declared using an operator-function-id. */
7791 && IDENTIFIER_OPNAME_P (unqualified_id)
7792 && TREE_CODE (type) != FUNCTION_TYPE
7793 && TREE_CODE (type) != METHOD_TYPE)
7795 error ("declaration of %qD as non-function", unqualified_id);
7796 return error_mark_node;
7799 /* We don't check parameter types here because we can emit a better
7800 error message later. */
7801 if (decl_context != PARM)
7802 type = check_var_type (unqualified_id, type);
7804 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
7805 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
7807 if (decl_context == PARM || decl_context == CATCHPARM)
7809 if (ctype || in_namespace)
7810 error ("cannot use %<::%> in parameter declaration");
7812 /* A parameter declared as an array of T is really a pointer to T.
7813 One declared as a function is really a pointer to a function.
7814 One declared as a member is really a pointer to member. */
7816 if (TREE_CODE (type) == ARRAY_TYPE)
7818 /* Transfer const-ness of array into that of type pointed to. */
7819 type = build_pointer_type (TREE_TYPE (type));
7820 type_quals = TYPE_UNQUALIFIED;
7822 else if (TREE_CODE (type) == FUNCTION_TYPE)
7823 type = build_pointer_type (type);
7829 if (decl_context == PARM)
7831 decl = cp_build_parm_decl (unqualified_id, type);
7833 bad_specifiers (decl, "parameter", virtualp, quals != TYPE_UNQUALIFIED,
7834 inlinep, friendp, raises != NULL_TREE);
7836 else if (decl_context == FIELD)
7838 /* The C99 flexible array extension. */
7839 if (!staticp && TREE_CODE (type) == ARRAY_TYPE
7840 && TYPE_DOMAIN (type) == NULL_TREE)
7842 tree itype = compute_array_index_type (dname, integer_zero_node);
7843 type = build_cplus_array_type (TREE_TYPE (type), itype);
7846 if (type == error_mark_node)
7848 /* Happens when declaring arrays of sizes which
7849 are error_mark_node, for example. */
7852 else if (in_namespace && !friendp)
7854 /* Something like struct S { int N::j; }; */
7855 error ("invalid use of %<::%>");
7858 else if (TREE_CODE (type) == FUNCTION_TYPE)
7861 tree function_context;
7865 if (ctype == NULL_TREE)
7866 ctype = current_class_type;
7868 if (ctype == NULL_TREE)
7870 error ("can't make %qD into a method -- not in a class",
7872 return void_type_node;
7875 /* ``A union may [ ... ] not [ have ] virtual functions.''
7877 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
7879 error ("function %qD declared virtual inside a union",
7881 return void_type_node;
7884 if (NEW_DELETE_OPNAME_P (unqualified_id))
7888 error ("%qD cannot be declared virtual, since it "
7894 else if (staticp < 2)
7895 type = build_method_type_directly (ctype,
7897 TYPE_ARG_TYPES (type));
7900 /* Check that the name used for a destructor makes sense. */
7901 if (sfk == sfk_destructor
7902 && !same_type_p (TREE_OPERAND
7903 (id_declarator->u.id.unqualified_name, 0),
7906 error ("declaration of %qD as member of %qT",
7907 id_declarator->u.id.unqualified_name,
7909 return error_mark_node;
7912 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
7913 function_context = (ctype != NULL_TREE) ?
7914 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
7915 publicp = (! friendp || ! staticp)
7916 && function_context == NULL_TREE;
7917 decl = grokfndecl (ctype, type,
7918 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
7919 ? unqualified_id : dname,
7922 virtualp, flags, quals, raises,
7923 friendp ? -1 : 0, friendp, publicp, inlinep,
7925 funcdef_flag, template_count, in_namespace, attrlist);
7926 if (decl == NULL_TREE)
7929 /* This clobbers the attrs stored in `decl' from `attrlist'. */
7930 /* The decl and setting of decl_attr is also turned off. */
7931 decl = build_decl_attribute_variant (decl, decl_attr);
7934 /* [class.conv.ctor]
7936 A constructor declared without the function-specifier
7937 explicit that can be called with a single parameter
7938 specifies a conversion from the type of its first
7939 parameter to the type of its class. Such a constructor
7940 is called a converting constructor. */
7942 DECL_NONCONVERTING_P (decl) = 1;
7943 else if (DECL_CONSTRUCTOR_P (decl))
7945 /* The constructor can be called with exactly one
7946 parameter if there is at least one parameter, and
7947 any subsequent parameters have default arguments.
7948 Ignore any compiler-added parms. */
7949 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
7951 if (arg_types == void_list_node
7953 && TREE_CHAIN (arg_types)
7954 && TREE_CHAIN (arg_types) != void_list_node
7955 && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
7956 DECL_NONCONVERTING_P (decl) = 1;
7959 else if (TREE_CODE (type) == METHOD_TYPE)
7961 /* We only get here for friend declarations of
7962 members of other classes. */
7963 /* All method decls are public, so tell grokfndecl to set
7964 TREE_PUBLIC, also. */
7965 decl = grokfndecl (ctype, type,
7966 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
7967 ? unqualified_id : dname,
7970 virtualp, flags, quals, raises,
7971 friendp ? -1 : 0, friendp, 1, 0, sfk,
7972 funcdef_flag, template_count, in_namespace,
7974 if (decl == NULL_TREE)
7977 else if (!staticp && !dependent_type_p (type)
7978 && !COMPLETE_TYPE_P (complete_type (type))
7979 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
7982 error ("field %qD has incomplete type", unqualified_id);
7984 error ("name %qT has incomplete type", type);
7986 /* If we're instantiating a template, tell them which
7987 instantiation made the field's type be incomplete. */
7988 if (current_class_type
7989 && TYPE_NAME (current_class_type)
7990 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
7992 && declspecs->type == type)
7993 error (" in instantiation of template %qT",
7994 current_class_type);
7996 type = error_mark_node;
8003 error ("%qE is neither function nor member function; "
8004 "cannot be declared friend", unqualified_id);
8012 /* Friends are treated specially. */
8013 if (ctype == current_class_type)
8014 warning ("member functions are implicitly friends of their class");
8015 else if (decl && DECL_NAME (decl))
8017 if (template_class_depth (current_class_type) == 0)
8019 decl = check_explicit_specialization
8020 (unqualified_id, decl, template_count,
8021 2 * (funcdef_flag != 0) + 4);
8022 if (decl == error_mark_node)
8023 return error_mark_node;
8026 decl = do_friend (ctype, unqualified_id, decl,
8027 *attrlist, flags, quals, funcdef_flag);
8031 return void_type_node;
8034 /* Structure field. It may not be a function, except for C++. */
8036 if (decl == NULL_TREE)
8042 /* An attempt is being made to initialize a non-static
8043 member. But, from [class.mem]:
8045 4 A member-declarator can contain a
8046 constant-initializer only if it declares a static
8047 member (_class.static_) of integral or enumeration
8048 type, see _class.static.data_.
8050 This used to be relatively common practice, but
8051 the rest of the compiler does not correctly
8052 handle the initialization unless the member is
8053 static so we make it static below. */
8054 pedwarn ("ISO C++ forbids initialization of member %qD",
8056 pedwarn ("making %qD static", unqualified_id);
8060 if (uses_template_parms (type))
8061 /* We'll check at instantiation time. */
8063 else if (check_static_variable_definition (unqualified_id,
8065 /* If we just return the declaration, crashes
8066 will sometimes occur. We therefore return
8067 void_type_node, as if this was a friend
8068 declaration, to cause callers to completely
8069 ignore this declaration. */
8070 return void_type_node;
8075 /* C++ allows static class members. All other work
8076 for this is done by grokfield. */
8077 decl = build_lang_decl (VAR_DECL, unqualified_id, type);
8078 set_linkage_for_static_data_member (decl);
8079 /* Even if there is an in-class initialization, DECL
8080 is considered undefined until an out-of-class
8081 definition is provided. */
8082 DECL_EXTERNAL (decl) = 1;
8086 decl = build_decl (FIELD_DECL, unqualified_id, type);
8087 DECL_NONADDRESSABLE_P (decl) = bitfield;
8088 if (storage_class == sc_mutable)
8090 DECL_MUTABLE_P (decl) = 1;
8091 storage_class = sc_none;
8095 bad_specifiers (decl, "field", virtualp, quals != TYPE_UNQUALIFIED,
8096 inlinep, friendp, raises != NULL_TREE);
8099 else if (TREE_CODE (type) == FUNCTION_TYPE
8100 || TREE_CODE (type) == METHOD_TYPE)
8105 if (!unqualified_id)
8108 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
8109 original_name = dname;
8111 original_name = unqualified_id;
8113 if (storage_class == sc_auto)
8114 error ("storage class %<auto%> invalid for function %qs", name);
8115 else if (storage_class == sc_register)
8116 error ("storage class %<register%> invalid for function %qs", name);
8118 error ("storage class %<__thread%> invalid for function %qs", name);
8120 /* Function declaration not at top level.
8121 Storage classes other than `extern' are not allowed
8122 and `extern' makes no difference. */
8123 if (! toplevel_bindings_p ()
8124 && (storage_class == sc_static
8125 || declspecs->specs[(int)ds_inline])
8128 if (storage_class == sc_static)
8129 pedwarn ("%<static%> specified invalid for function %qs "
8130 "declared out of global scope", name);
8132 pedwarn ("%<inline%> specifier invalid for function %qs "
8133 "declared out of global scope", name);
8136 if (ctype == NULL_TREE)
8140 error ("virtual non-class function %qs", name);
8144 else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2
8145 && !NEW_DELETE_OPNAME_P (original_name))
8146 type = build_method_type_directly (ctype,
8148 TYPE_ARG_TYPES (type));
8150 /* Record presence of `static'. */
8151 publicp = (ctype != NULL_TREE
8152 || storage_class == sc_extern
8153 || storage_class != sc_static);
8155 decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
8156 virtualp, flags, quals, raises,
8158 publicp, inlinep, sfk, funcdef_flag,
8159 template_count, in_namespace, attrlist);
8160 if (decl == NULL_TREE)
8165 int invalid_static = 0;
8167 /* Don't allow a static member function in a class, and forbid
8168 declaring main to be static. */
8169 if (TREE_CODE (type) == METHOD_TYPE)
8171 pedwarn ("cannot declare member function %qD to have "
8172 "static linkage", decl);
8175 else if (current_function_decl)
8177 /* FIXME need arm citation */
8178 error ("cannot declare static function inside another function");
8185 storage_class = sc_none;
8191 /* It's a variable. */
8193 /* An uninitialized decl with `extern' is a reference. */
8194 decl = grokvardecl (type, unqualified_id,
8197 (type_quals & TYPE_QUAL_CONST) != 0,
8198 ctype ? ctype : in_namespace);
8199 bad_specifiers (decl, "variable", virtualp, quals != TYPE_UNQUALIFIED,
8200 inlinep, friendp, raises != NULL_TREE);
8204 DECL_CONTEXT (decl) = ctype;
8207 pedwarn ("%<static%> may not be used when defining "
8208 "(as opposed to declaring) a static data member");
8210 storage_class = sc_none;
8212 if (storage_class == sc_register && TREE_STATIC (decl))
8214 error ("static member %qD declared %<register%>", decl);
8215 storage_class = sc_none;
8217 if (storage_class == sc_extern && pedantic)
8219 pedwarn ("cannot explicitly declare member %q#D to have "
8222 storage_class = sc_none;
8227 /* Record `register' declaration for warnings on &
8228 and in case doing stupid register allocation. */
8230 if (storage_class == sc_register)
8231 DECL_REGISTER (decl) = 1;
8232 else if (storage_class == sc_extern)
8233 DECL_THIS_EXTERN (decl) = 1;
8234 else if (storage_class == sc_static)
8235 DECL_THIS_STATIC (decl) = 1;
8237 /* Record constancy and volatility. There's no need to do this
8238 when processing a template; we'll do this for the instantiated
8239 declaration based on the type of DECL. */
8240 if (!processing_template_decl)
8241 cp_apply_type_quals_to_decl (type_quals, decl);
8247 /* Subroutine of start_function. Ensure that each of the parameter
8248 types (as listed in PARMS) is complete, as is required for a
8249 function definition. */
8252 require_complete_types_for_parms (tree parms)
8254 for (; parms; parms = TREE_CHAIN (parms))
8256 if (dependent_type_p (TREE_TYPE (parms)))
8258 if (VOID_TYPE_P (TREE_TYPE (parms)))
8259 /* grokparms will have already issued an error. */
8260 TREE_TYPE (parms) = error_mark_node;
8261 else if (complete_type_or_else (TREE_TYPE (parms), parms))
8263 layout_decl (parms, 0);
8264 DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
8269 /* Returns nonzero if T is a local variable. */
8272 local_variable_p (tree t)
8274 if ((TREE_CODE (t) == VAR_DECL
8275 /* A VAR_DECL with a context that is a _TYPE is a static data
8277 && !TYPE_P (CP_DECL_CONTEXT (t))
8278 /* Any other non-local variable must be at namespace scope. */
8279 && !DECL_NAMESPACE_SCOPE_P (t))
8280 || (TREE_CODE (t) == PARM_DECL))
8286 /* Returns nonzero if T is an automatic local variable or a label.
8287 (These are the declarations that need to be remapped when the code
8288 containing them is duplicated.) */
8291 nonstatic_local_decl_p (tree t)
8293 return ((local_variable_p (t) && !TREE_STATIC (t))
8294 || TREE_CODE (t) == LABEL_DECL
8295 || TREE_CODE (t) == RESULT_DECL);
8298 /* Like local_variable_p, but suitable for use as a tree-walking
8302 local_variable_p_walkfn (tree *tp, int *walk_subtrees,
8303 void *data ATTRIBUTE_UNUSED)
8305 if (local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
8307 else if (TYPE_P (*tp))
8314 /* Check that ARG, which is a default-argument expression for a
8315 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
8316 something goes wrong. DECL may also be a _TYPE node, rather than a
8317 DECL, if there is no DECL available. */
8320 check_default_argument (tree decl, tree arg)
8325 if (TREE_CODE (arg) == DEFAULT_ARG)
8326 /* We get a DEFAULT_ARG when looking at an in-class declaration
8327 with a default argument. Ignore the argument for now; we'll
8328 deal with it after the class is complete. */
8331 if (processing_template_decl || uses_template_parms (arg))
8332 /* We don't do anything checking until instantiation-time. Note
8333 that there may be uninstantiated arguments even for an
8334 instantiated function, since default arguments are not
8335 instantiated until they are needed. */
8344 decl_type = TREE_TYPE (decl);
8346 if (arg == error_mark_node
8347 || decl == error_mark_node
8348 || TREE_TYPE (arg) == error_mark_node
8349 || decl_type == error_mark_node)
8350 /* Something already went wrong. There's no need to check
8352 return error_mark_node;
8354 /* [dcl.fct.default]
8356 A default argument expression is implicitly converted to the
8358 if (!TREE_TYPE (arg)
8359 || !can_convert_arg (decl_type, TREE_TYPE (arg), arg))
8362 error ("default argument for %q#D has type %qT",
8363 decl, TREE_TYPE (arg));
8365 error ("default argument for parameter of type %qT has type %qT",
8366 decl_type, TREE_TYPE (arg));
8368 return error_mark_node;
8371 /* [dcl.fct.default]
8373 Local variables shall not be used in default argument
8376 The keyword `this' shall not be used in a default argument of a
8378 var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
8382 error ("default argument %qE uses local variable %qD", arg, var);
8383 return error_mark_node;
8390 /* Decode the list of parameter types for a function type.
8391 Given the list of things declared inside the parens,
8392 return a list of types.
8394 If this parameter does not end with an ellipsis, we append
8397 *PARMS is set to the chain of PARM_DECLs created. */
8400 grokparms (cp_parameter_declarator *first_parm, tree *parms)
8402 tree result = NULL_TREE;
8403 tree decls = NULL_TREE;
8404 int ellipsis = !first_parm || first_parm->ellipsis_p;
8405 cp_parameter_declarator *parm;
8408 for (parm = first_parm; parm != NULL; parm = parm->next)
8410 tree type = NULL_TREE;
8411 tree init = parm->default_argument;
8415 if (parm == no_parameters)
8418 attrs = parm->decl_specifiers.attributes;
8419 parm->decl_specifiers.attributes = NULL_TREE;
8420 decl = grokdeclarator (parm->declarator, &parm->decl_specifiers,
8421 PARM, init != NULL_TREE, &attrs);
8422 if (! decl || TREE_TYPE (decl) == error_mark_node)
8426 cplus_decl_attributes (&decl, attrs, 0);
8428 type = TREE_TYPE (decl);
8429 if (VOID_TYPE_P (type))
8431 if (same_type_p (type, void_type_node)
8432 && !DECL_NAME (decl) && !result && !parm->next && !ellipsis)
8433 /* this is a parmlist of `(void)', which is ok. */
8435 cxx_incomplete_type_error (decl, type);
8436 /* It's not a good idea to actually create parameters of
8437 type `void'; other parts of the compiler assume that a
8438 void type terminates the parameter list. */
8439 type = error_mark_node;
8440 TREE_TYPE (decl) = error_mark_node;
8443 if (type != error_mark_node)
8445 /* Top-level qualifiers on the parameters are
8446 ignored for function types. */
8447 type = cp_build_qualified_type (type, 0);
8448 if (TREE_CODE (type) == METHOD_TYPE)
8450 error ("parameter %qD invalidly declared method type", decl);
8451 type = build_pointer_type (type);
8452 TREE_TYPE (decl) = type;
8454 else if (abstract_virtuals_error (decl, type))
8455 any_error = 1; /* Seems like a good idea. */
8456 else if (POINTER_TYPE_P (type))
8458 /* [dcl.fct]/6, parameter types cannot contain pointers
8459 (references) to arrays of unknown bound. */
8460 tree t = TREE_TYPE (type);
8461 int ptr = TYPE_PTR_P (type);
8467 else if (TREE_CODE (t) != ARRAY_TYPE)
8469 else if (!TYPE_DOMAIN (t))
8473 if (TREE_CODE (t) == ARRAY_TYPE)
8474 error ("parameter %qD includes %s to array of unknown "
8476 decl, ptr ? "pointer" : "reference", t);
8479 if (!any_error && init)
8480 init = check_default_argument (decl, init);
8485 TREE_CHAIN (decl) = decls;
8487 result = tree_cons (init, type, result);
8489 decls = nreverse (decls);
8490 result = nreverse (result);
8492 result = chainon (result, void_list_node);
8499 /* D is a constructor or overloaded `operator='.
8501 Let T be the class in which D is declared. Then, this function
8504 -1 if D's is an ill-formed constructor or copy assignment operator
8505 whose first parameter is of type `T'.
8506 0 if D is not a copy constructor or copy assignment
8508 1 if D is a copy constructor or copy assignment operator whose
8509 first parameter is a reference to const qualified T.
8510 2 if D is a copy constructor or copy assignment operator whose
8511 first parameter is a reference to non-const qualified T.
8513 This function can be used as a predicate. Positive values indicate
8514 a copy constructor and nonzero values indicate a copy assignment
8524 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
8526 if (DECL_TEMPLATE_INFO (d)
8527 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d)))
8528 /* Instantiations of template member functions are never copy
8529 functions. Note that member functions of templated classes are
8530 represented as template functions internally, and we must
8531 accept those as copy functions. */
8534 args = FUNCTION_FIRST_USER_PARMTYPE (d);
8538 arg_type = TREE_VALUE (args);
8540 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
8542 /* Pass by value copy assignment operator. */
8545 else if (TREE_CODE (arg_type) == REFERENCE_TYPE
8546 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
8548 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
8554 args = TREE_CHAIN (args);
8556 if (args && args != void_list_node && !TREE_PURPOSE (args))
8557 /* There are more non-optional args. */
8563 /* Remember any special properties of member function DECL. */
8565 void grok_special_member_properties (tree decl)
8567 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P(decl))
8568 ; /* Not special. */
8569 else if (DECL_CONSTRUCTOR_P (decl))
8571 int ctor = copy_fn_p (decl);
8577 A non-template constructor for class X is a copy
8578 constructor if its first parameter is of type X&, const
8579 X&, volatile X& or const volatile X&, and either there
8580 are no other parameters or else all other parameters have
8581 default arguments. */
8582 TYPE_HAS_INIT_REF (DECL_CONTEXT (decl)) = 1;
8584 TYPE_HAS_CONST_INIT_REF (DECL_CONTEXT (decl)) = 1;
8586 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
8587 TYPE_HAS_DEFAULT_CONSTRUCTOR (DECL_CONTEXT (decl)) = 1;
8589 else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
8593 A non-template assignment operator for class X is a copy
8594 assignment operator if its parameter is of type X, X&, const
8595 X&, volatile X& or const volatile X&. */
8597 int assop = copy_fn_p (decl);
8601 TYPE_HAS_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
8603 TYPE_HAS_CONST_ASSIGN_REF (DECL_CONTEXT (decl)) = 1;
8608 /* Check a constructor DECL has the correct form. Complains
8609 if the class has a constructor of the form X(X). */
8612 grok_ctor_properties (tree ctype, tree decl)
8614 int ctor_parm = copy_fn_p (decl);
8620 A declaration of a constructor for a class X is ill-formed if
8621 its first parameter is of type (optionally cv-qualified) X
8622 and either there are no other parameters or else all other
8623 parameters have default arguments.
8625 We *don't* complain about member template instantiations that
8626 have this form, though; they can occur as we try to decide
8627 what constructor to use during overload resolution. Since
8628 overload resolution will never prefer such a constructor to
8629 the non-template copy constructor (which is either explicitly
8630 or implicitly defined), there's no need to worry about their
8631 existence. Theoretically, they should never even be
8632 instantiated, but that's hard to forestall. */
8633 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
8641 /* An operator with this code is unary, but can also be binary. */
8644 ambi_op_p (enum tree_code code)
8646 return (code == INDIRECT_REF
8647 || code == ADDR_EXPR
8648 || code == CONVERT_EXPR
8649 || code == NEGATE_EXPR
8650 || code == PREINCREMENT_EXPR
8651 || code == PREDECREMENT_EXPR);
8654 /* An operator with this name can only be unary. */
8657 unary_op_p (enum tree_code code)
8659 return (code == TRUTH_NOT_EXPR
8660 || code == BIT_NOT_EXPR
8661 || code == COMPONENT_REF
8662 || code == TYPE_EXPR);
8665 /* DECL is a declaration for an overloaded operator. Returns true if
8666 the declaration is valid; false otherwise. If COMPLAIN is true,
8667 errors are issued for invalid declarations. */
8670 grok_op_properties (tree decl, int friendp, bool complain)
8672 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
8674 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
8675 tree name = DECL_NAME (decl);
8676 enum tree_code operator_code;
8680 /* Assume that the declaration is valid. */
8683 /* Count the number of arguments. */
8684 for (argtype = argtypes, arity = 0;
8685 argtype && argtype != void_list_node;
8686 argtype = TREE_CHAIN (argtype))
8689 if (current_class_type == NULL_TREE)
8692 if (DECL_CONV_FN_P (decl))
8693 operator_code = TYPE_EXPR;
8697 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
8698 if (ansi_opname (CODE) == name) \
8700 operator_code = (CODE); \
8703 else if (ansi_assopname (CODE) == name) \
8705 operator_code = (CODE); \
8706 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
8710 #include "operators.def"
8716 gcc_assert (operator_code != LAST_CPLUS_TREE_CODE);
8717 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
8721 switch (operator_code)
8724 TYPE_HAS_NEW_OPERATOR (current_class_type) = 1;
8728 TYPE_GETS_DELETE (current_class_type) |= 1;
8732 TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1;
8735 case VEC_DELETE_EXPR:
8736 TYPE_GETS_DELETE (current_class_type) |= 2;
8744 /* [basic.std.dynamic.allocation]/1:
8746 A program is ill-formed if an allocation function is declared
8747 in a namespace scope other than global scope or declared static
8750 The same also holds true for deallocation functions. */
8751 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR
8752 || operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
8754 if (DECL_NAMESPACE_SCOPE_P (decl))
8756 if (CP_DECL_CONTEXT (decl) != global_namespace)
8757 error ("%qD may not be declared within a namespace", decl);
8758 else if (!TREE_PUBLIC (decl))
8759 error ("%qD may not be declared as static", decl);
8763 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
8764 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
8765 else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
8766 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
8769 /* An operator function must either be a non-static member function
8770 or have at least one parameter of a class, a reference to a class,
8771 an enumeration, or a reference to an enumeration. 13.4.0.6 */
8772 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
8774 if (operator_code == TYPE_EXPR
8775 || operator_code == CALL_EXPR
8776 || operator_code == COMPONENT_REF
8777 || operator_code == ARRAY_REF
8778 || operator_code == NOP_EXPR)
8779 error ("%qD must be a nonstatic member function", decl);
8784 if (DECL_STATIC_FUNCTION_P (decl))
8785 error ("%qD must be either a non-static member "
8786 "function or a non-member function", decl);
8788 for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
8790 tree arg = non_reference (TREE_VALUE (p));
8791 /* IS_AGGR_TYPE, rather than CLASS_TYPE_P, is used
8792 because these checks are performed even on
8793 template functions. */
8794 if (IS_AGGR_TYPE (arg) || TREE_CODE (arg) == ENUMERAL_TYPE)
8798 if (!p || p == void_list_node)
8803 error ("%qD must have an argument of class or "
8811 /* There are no restrictions on the arguments to an overloaded
8813 if (operator_code == CALL_EXPR)
8816 if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
8818 tree t = TREE_TYPE (name);
8821 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
8822 const char *what = 0;
8825 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
8827 if (TREE_CODE (t) == VOID_TYPE)
8829 else if (t == current_class_type)
8830 what = "the same type";
8831 /* Don't force t to be complete here. */
8832 else if (IS_AGGR_TYPE (t)
8833 && COMPLETE_TYPE_P (t)
8834 && DERIVED_FROM_P (t, current_class_type))
8835 what = "a base class";
8837 if (what && warn_conversion)
8838 warning ("conversion to %s%s will never use a type "
8839 "conversion operator",
8840 ref ? "a reference to " : "", what);
8843 if (operator_code == COND_EXPR)
8846 error ("ISO C++ prohibits overloading operator ?:");
8848 else if (ambi_op_p (operator_code))
8851 /* We pick the one-argument operator codes by default, so
8852 we don't have to change anything. */
8854 else if (arity == 2)
8856 /* If we thought this was a unary operator, we now know
8857 it to be a binary operator. */
8858 switch (operator_code)
8861 operator_code = MULT_EXPR;
8865 operator_code = BIT_AND_EXPR;
8869 operator_code = PLUS_EXPR;
8873 operator_code = MINUS_EXPR;
8876 case PREINCREMENT_EXPR:
8877 operator_code = POSTINCREMENT_EXPR;
8880 case PREDECREMENT_EXPR:
8881 operator_code = POSTDECREMENT_EXPR;
8888 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
8890 if ((operator_code == POSTINCREMENT_EXPR
8891 || operator_code == POSTDECREMENT_EXPR)
8892 && ! processing_template_decl
8893 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
8896 error ("postfix %qD must take %<int%> as its argument",
8900 ("postfix %qD must take %<int%> as its second argument",
8907 error ("%qD must take either zero or one argument", decl);
8909 error ("%qD must take either one or two arguments", decl);
8912 /* More Effective C++ rule 6. */
8914 && (operator_code == POSTINCREMENT_EXPR
8915 || operator_code == POSTDECREMENT_EXPR
8916 || operator_code == PREINCREMENT_EXPR
8917 || operator_code == PREDECREMENT_EXPR))
8919 tree arg = TREE_VALUE (argtypes);
8920 tree ret = TREE_TYPE (TREE_TYPE (decl));
8921 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
8922 arg = TREE_TYPE (arg);
8923 arg = TYPE_MAIN_VARIANT (arg);
8924 if (operator_code == PREINCREMENT_EXPR
8925 || operator_code == PREDECREMENT_EXPR)
8927 if (TREE_CODE (ret) != REFERENCE_TYPE
8928 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
8930 warning ("prefix %qD should return %qT", decl,
8931 build_reference_type (arg));
8935 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
8936 warning ("postfix %qD should return %qT", decl, arg);
8940 else if (unary_op_p (operator_code))
8945 error ("%qD must take %<void%>", decl);
8947 error ("%qD must take exactly one argument", decl);
8950 else /* if (binary_op_p (operator_code)) */
8955 error ("%qD must take exactly one argument", decl);
8957 error ("%qD must take exactly two arguments", decl);
8960 /* More Effective C++ rule 7. */
8962 && (operator_code == TRUTH_ANDIF_EXPR
8963 || operator_code == TRUTH_ORIF_EXPR
8964 || operator_code == COMPOUND_EXPR))
8965 warning ("user-defined %qD always evaluates both arguments",
8969 /* Effective C++ rule 23. */
8972 && !DECL_ASSIGNMENT_OPERATOR_P (decl)
8973 && (operator_code == PLUS_EXPR
8974 || operator_code == MINUS_EXPR
8975 || operator_code == TRUNC_DIV_EXPR
8976 || operator_code == MULT_EXPR
8977 || operator_code == TRUNC_MOD_EXPR)
8978 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
8979 warning ("%qD should return by value", decl);
8982 for (; argtypes && argtypes != void_list_node;
8983 argtypes = TREE_CHAIN (argtypes))
8984 if (TREE_PURPOSE (argtypes))
8986 TREE_PURPOSE (argtypes) = NULL_TREE;
8987 if (operator_code == POSTINCREMENT_EXPR
8988 || operator_code == POSTDECREMENT_EXPR)
8991 pedwarn ("%qD cannot have default arguments", decl);
8994 error ("%qD cannot have default arguments", decl);
9002 /* Return a string giving the keyword associate with CODE. */
9005 tag_name (enum tag_types code)
9024 /* Name lookup in an elaborated-type-specifier (after the keyword
9025 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
9026 elaborated-type-specifier is invalid, issue a diagnostic and return
9027 error_mark_node; otherwise, return the *_TYPE to which it referred.
9028 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
9031 check_elaborated_type_specifier (enum tag_types tag_code,
9033 bool allow_template_p)
9039 struct S { struct S *p; };
9041 name lookup will find the TYPE_DECL for the implicit "S::S"
9042 typedef. Adjust for that here. */
9043 if (DECL_SELF_REFERENCE_P (decl))
9044 decl = TYPE_NAME (TREE_TYPE (decl));
9046 type = TREE_TYPE (decl);
9048 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
9049 is false for this case as well. */
9050 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
9052 error ("using template type parameter %qT after %qs",
9053 type, tag_name (tag_code));
9054 return error_mark_node;
9058 If the identifier resolves to a typedef-name or a template
9059 type-parameter, the elaborated-type-specifier is ill-formed.
9061 In other words, the only legitimate declaration to use in the
9062 elaborated type specifier is the implicit typedef created when
9063 the type is declared. */
9064 else if (!DECL_IMPLICIT_TYPEDEF_P (decl)
9065 && tag_code != typename_type)
9067 error ("using typedef-name %qD after %qs", decl, tag_name (tag_code));
9068 cp_error_at ("%qD has a previous declaration here", decl);
9069 return error_mark_node;
9071 else if (TREE_CODE (type) != RECORD_TYPE
9072 && TREE_CODE (type) != UNION_TYPE
9073 && tag_code != enum_type
9074 && tag_code != typename_type)
9076 error ("%qT referred to as %qs", type, tag_name (tag_code));
9077 cp_error_at ("%qT has a previous declaration here", type);
9078 return error_mark_node;
9080 else if (TREE_CODE (type) != ENUMERAL_TYPE
9081 && tag_code == enum_type
9082 && tag_code != typename_type)
9084 error ("%qT referred to as enum", type);
9085 cp_error_at ("%qT has a previous declaration here", type);
9086 return error_mark_node;
9088 else if (!allow_template_p
9089 && TREE_CODE (type) == RECORD_TYPE
9090 && CLASSTYPE_IS_TEMPLATE (type))
9092 /* If a class template appears as elaborated type specifier
9093 without a template header such as:
9095 template <class T> class C {};
9096 void f(class C); // No template header here
9098 then the required template argument is missing. */
9100 error ("template argument required for %<%s %T%>",
9101 tag_name (tag_code),
9102 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
9103 return error_mark_node;
9109 /* Lookup NAME in elaborate type specifier in scope according to
9110 SCOPE and issue diagnostics if necessary.
9111 Return *_TYPE node upon success, NULL_TREE when the NAME is not
9112 found, and ERROR_MARK_NODE for type error. */
9115 lookup_and_check_tag (enum tag_types tag_code, tree name,
9116 tag_scope scope, bool template_header_p)
9120 if (scope == ts_global)
9121 decl = lookup_name (name, 2);
9123 decl = lookup_type_scope (name, scope);
9125 if (decl && DECL_CLASS_TEMPLATE_P (decl))
9126 decl = DECL_TEMPLATE_RESULT (decl);
9128 if (decl && TREE_CODE (decl) == TYPE_DECL)
9130 /* Look for invalid nested type:
9134 if (scope == ts_current && DECL_SELF_REFERENCE_P (decl))
9136 error ("%qD has the same name as the class in which it is "
9139 return error_mark_node;
9142 /* Two cases we need to consider when deciding if a class
9143 template is allowed as an elaborated type specifier:
9144 1. It is a self reference to its own class.
9145 2. It comes with a template header.
9149 template <class T> class C {
9150 class C *c1; // DECL_SELF_REFERENCE_P is true
9153 template <class U> class C; // template_header_p is true
9154 template <class T> class C<T>::D {
9155 class C *c2; // DECL_SELF_REFERENCE_P is true
9158 t = check_elaborated_type_specifier (tag_code,
9161 | DECL_SELF_REFERENCE_P (decl));
9168 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
9169 Define the tag as a forward-reference if it is not defined.
9171 If a declaration is given, process it here, and report an error if
9172 multiple declarations are not identical.
9174 SCOPE is TS_CURRENT when this is also a definition. Only look in
9175 the current frame for the name (since C++ allows new names in any
9176 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
9177 declaration. Only look beginning from the current scope outward up
9178 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
9180 TEMPLATE_HEADER_P is true when this declaration is preceded by
9181 a set of template parameters. */
9184 xref_tag (enum tag_types tag_code, tree name,
9185 tag_scope scope, bool template_header_p)
9187 enum tree_code code;
9189 tree context = NULL_TREE;
9191 timevar_push (TV_NAME_LOOKUP);
9193 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
9205 code = ENUMERAL_TYPE;
9211 /* In case of anonymous name, xref_tag is only called to
9212 make type node and push name. Name lookup is not required. */
9213 if (ANON_AGGRNAME_P (name))
9216 t = lookup_and_check_tag (tag_code, name,
9217 scope, template_header_p);
9219 if (t == error_mark_node)
9220 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
9222 if (scope != ts_current && t && current_class_type
9223 && template_class_depth (current_class_type)
9224 && template_header_p)
9226 /* Since SCOPE is not TS_CURRENT, we are not looking at a
9227 definition of this tag. Since, in addition, we are currently
9228 processing a (member) template declaration of a template
9229 class, we must be very careful; consider:
9236 { template <class V>
9237 friend struct S1; };
9239 Here, the S2::S1 declaration should not be confused with the
9240 outer declaration. In particular, the inner version should
9241 have a template parameter of level 2, not level 1. This
9242 would be particularly important if the member declaration
9245 template <class V = U> friend struct S1;
9247 say, when we should tsubst into `U' when instantiating
9248 S2. On the other hand, when presented with:
9258 we must find the inner binding eventually. We
9259 accomplish this by making sure that the new type we
9260 create to represent this declaration has the right
9262 context = TYPE_CONTEXT (t);
9268 /* If no such tag is yet defined, create a forward-reference node
9269 and record it as the "definition".
9270 When a real declaration of this type is found,
9271 the forward-reference will be altered into a real type. */
9272 if (code == ENUMERAL_TYPE)
9274 error ("use of enum %q#D without previous declaration", name);
9275 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
9279 t = make_aggr_type (code);
9280 TYPE_CONTEXT (t) = context;
9281 /* pushtag only cares whether SCOPE is zero or not. */
9282 t = pushtag (name, t, scope != ts_current);
9287 if (template_header_p && IS_AGGR_TYPE (t))
9288 redeclare_class_template (t, current_template_parms);
9289 else if (!processing_template_decl
9291 && CLASSTYPE_IS_TEMPLATE (t))
9293 error ("redeclaration of %qT as a non-template", t);
9294 t = error_mark_node;
9298 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
9302 xref_tag_from_type (tree old, tree id, tag_scope scope)
9304 enum tag_types tag_kind;
9306 if (TREE_CODE (old) == RECORD_TYPE)
9307 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
9309 tag_kind = union_type;
9311 if (id == NULL_TREE)
9312 id = TYPE_IDENTIFIER (old);
9314 return xref_tag (tag_kind, id, scope, false);
9317 /* Create the binfo hierarchy for REF with (possibly NULL) base list
9318 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
9319 access_* node, and the TREE_VALUE is the type of the base-class.
9320 Non-NULL TREE_TYPE indicates virtual inheritance. */
9323 xref_basetypes (tree ref, tree base_list)
9326 tree binfo, base_binfo;
9327 unsigned max_vbases = 0; /* Maximum direct & indirect virtual bases. */
9328 unsigned max_bases = 0; /* Maximum direct bases. */
9330 tree default_access;
9331 tree igo_prev; /* Track Inheritance Graph Order. */
9333 if (ref == error_mark_node)
9336 /* The base of a derived class is private by default, all others are
9338 default_access = (TREE_CODE (ref) == RECORD_TYPE
9339 && CLASSTYPE_DECLARED_CLASS (ref)
9340 ? access_private_node : access_public_node);
9342 /* First, make sure that any templates in base-classes are
9343 instantiated. This ensures that if we call ourselves recursively
9344 we do not get confused about which classes are marked and which
9349 tree basetype = TREE_VALUE (*basep);
9351 if (!(processing_template_decl && uses_template_parms (basetype))
9352 && !complete_type_or_else (basetype, NULL))
9353 /* An incomplete type. Remove it from the list. */
9354 *basep = TREE_CHAIN (*basep);
9358 if (TREE_TYPE (*basep))
9360 if (CLASS_TYPE_P (basetype))
9361 max_vbases += VEC_length (tree, CLASSTYPE_VBASECLASSES (basetype));
9362 basep = &TREE_CHAIN (*basep);
9366 TYPE_MARKED_P (ref) = 1;
9368 /* The binfo slot should be empty, unless this is an (ill-formed)
9370 gcc_assert (!TYPE_BINFO (ref) || TYPE_SIZE (ref));
9371 gcc_assert (TYPE_MAIN_VARIANT (ref) == ref);
9373 binfo = make_tree_binfo (max_bases);
9375 TYPE_BINFO (ref) = binfo;
9376 BINFO_OFFSET (binfo) = size_zero_node;
9377 BINFO_TYPE (binfo) = ref;
9381 BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, max_bases);
9382 /* An aggregate cannot have baseclasses. */
9383 CLASSTYPE_NON_AGGREGATE (ref) = 1;
9385 if (TREE_CODE (ref) == UNION_TYPE)
9386 error ("derived union %qT invalid", ref);
9391 if (TYPE_FOR_JAVA (ref))
9392 error ("Java class %qT cannot have multiple bases", ref);
9397 CLASSTYPE_VBASECLASSES (ref) = VEC_alloc (tree, max_vbases);
9399 if (TYPE_FOR_JAVA (ref))
9400 error ("Java class %qT cannot have virtual bases", ref);
9403 for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list))
9405 tree access = TREE_PURPOSE (base_list);
9406 int via_virtual = TREE_TYPE (base_list) != NULL_TREE;
9407 tree basetype = TREE_VALUE (base_list);
9409 if (access == access_default_node)
9410 access = default_access;
9412 if (TREE_CODE (basetype) == TYPE_DECL)
9413 basetype = TREE_TYPE (basetype);
9414 if (TREE_CODE (basetype) != RECORD_TYPE
9415 && TREE_CODE (basetype) != TYPENAME_TYPE
9416 && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
9417 && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM)
9419 error ("base type %qT fails to be a struct or class type",
9424 if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0))
9425 TYPE_FOR_JAVA (ref) = 1;
9427 base_binfo = NULL_TREE;
9428 if (CLASS_TYPE_P (basetype) && !dependent_type_p (basetype))
9430 base_binfo = TYPE_BINFO (basetype);
9431 /* The original basetype could have been a typedef'd type. */
9432 basetype = BINFO_TYPE (base_binfo);
9434 /* Inherit flags from the base. */
9435 TYPE_HAS_NEW_OPERATOR (ref)
9436 |= TYPE_HAS_NEW_OPERATOR (basetype);
9437 TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
9438 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
9439 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
9440 TYPE_HAS_CONVERSION (ref) |= TYPE_HAS_CONVERSION (basetype);
9441 CLASSTYPE_DIAMOND_SHAPED_P (ref)
9442 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype);
9443 CLASSTYPE_REPEATED_BASE_P (ref)
9444 |= CLASSTYPE_REPEATED_BASE_P (basetype);
9447 /* We must do this test after we've seen through a typedef
9449 if (TYPE_MARKED_P (basetype))
9451 if (basetype == ref)
9452 error ("recursive type %qT undefined", basetype);
9454 error ("duplicate base type %qT invalid", basetype);
9457 TYPE_MARKED_P (basetype) = 1;
9459 base_binfo = copy_binfo (base_binfo, basetype, ref,
9460 &igo_prev, via_virtual);
9461 if (!BINFO_INHERITANCE_CHAIN (base_binfo))
9462 BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
9464 BINFO_BASE_APPEND (binfo, base_binfo);
9465 BINFO_BASE_ACCESS_APPEND (binfo, access);
9468 if (VEC_space (tree, CLASSTYPE_VBASECLASSES (ref), 1))
9469 /* If we have space in the vbase vector, we must have shared at
9470 least one of them, and are therefore diamond shaped. */
9471 CLASSTYPE_DIAMOND_SHAPED_P (ref) = 1;
9473 /* Unmark all the types. */
9474 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
9475 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
9476 TYPE_MARKED_P (ref) = 0;
9478 /* Now see if we have a repeated base type. */
9479 if (!CLASSTYPE_REPEATED_BASE_P (ref))
9481 for (base_binfo = binfo; base_binfo;
9482 base_binfo = TREE_CHAIN (base_binfo))
9484 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
9486 CLASSTYPE_REPEATED_BASE_P (ref) = 1;
9489 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 1;
9491 for (base_binfo = binfo; base_binfo;
9492 base_binfo = TREE_CHAIN (base_binfo))
9493 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
9494 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
9501 /* Begin compiling the definition of an enumeration type.
9503 Returns the type object, as yet incomplete.
9504 Also records info about it so that build_enumerator
9505 may be used to declare the individual values as they are read. */
9508 start_enum (tree name)
9512 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
9514 /* If this is the real definition for a previous forward reference,
9515 fill in the contents in the same object that used to be the
9516 forward reference. */
9518 enumtype = lookup_and_check_tag (enum_type, name,
9519 /*tag_scope=*/ts_current,
9520 /*template_header_p=*/false);
9522 if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
9524 error ("multiple definition of %q#T", enumtype);
9525 error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype));
9526 /* Clear out TYPE_VALUES, and start again. */
9527 TYPE_VALUES (enumtype) = NULL_TREE;
9531 /* In case of error, make a dummy enum to allow parsing to
9533 if (enumtype == error_mark_node)
9534 name = make_anon_name ();
9536 enumtype = make_node (ENUMERAL_TYPE);
9537 enumtype = pushtag (name, enumtype, 0);
9543 /* After processing and defining all the values of an enumeration type,
9544 install their decls in the enumeration type and finish it off.
9545 ENUMTYPE is the type object and VALUES a list of name-value pairs. */
9548 finish_enum (tree enumtype)
9557 bool use_short_enum;
9561 integer_type_kind itk;
9562 tree underlying_type = NULL_TREE;
9564 /* We built up the VALUES in reverse order. */
9565 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
9567 /* For an enum defined in a template, just set the type of the values;
9568 all further processing is postponed until the template is
9569 instantiated. We need to set the type so that tsubst of a CONST_DECL
9571 if (processing_template_decl)
9573 for (values = TYPE_VALUES (enumtype);
9575 values = TREE_CHAIN (values))
9576 TREE_TYPE (TREE_VALUE (values)) = enumtype;
9577 if (at_function_scope_p ())
9578 add_stmt (build_min (TAG_DEFN, enumtype));
9582 /* Determine the minimum and maximum values of the enumerators. */
9583 if (TYPE_VALUES (enumtype))
9585 minnode = maxnode = NULL_TREE;
9587 for (values = TYPE_VALUES (enumtype);
9589 values = TREE_CHAIN (values))
9591 decl = TREE_VALUE (values);
9593 /* [dcl.enum]: Following the closing brace of an enum-specifier,
9594 each enumerator has the type of its enumeration. Prior to the
9595 closing brace, the type of each enumerator is the type of its
9596 initializing value. */
9597 TREE_TYPE (decl) = enumtype;
9599 /* Update the minimum and maximum values, if appropriate. */
9600 value = DECL_INITIAL (decl);
9601 /* Figure out what the minimum and maximum values of the
9604 minnode = maxnode = value;
9605 else if (tree_int_cst_lt (maxnode, value))
9607 else if (tree_int_cst_lt (value, minnode))
9614 If the enumerator-list is empty, the underlying type is as if
9615 the enumeration had a single enumerator with value 0. */
9616 minnode = maxnode = integer_zero_node;
9618 /* Compute the number of bits require to represent all values of the
9619 enumeration. We must do this before the type of MINNODE and
9620 MAXNODE are transformed, since min_precision relies on the
9621 TREE_TYPE of the value it is passed. */
9622 unsignedp = tree_int_cst_sgn (minnode) >= 0;
9623 lowprec = min_precision (minnode, unsignedp);
9624 highprec = min_precision (maxnode, unsignedp);
9625 precision = MAX (lowprec, highprec);
9627 /* Determine the underlying type of the enumeration.
9631 The underlying type of an enumeration is an integral type that
9632 can represent all the enumerator values defined in the
9633 enumeration. It is implementation-defined which integral type is
9634 used as the underlying type for an enumeration except that the
9635 underlying type shall not be larger than int unless the value of
9636 an enumerator cannot fit in an int or unsigned int.
9638 We use "int" or an "unsigned int" as the underlying type, even if
9639 a smaller integral type would work, unless the user has
9640 explicitly requested that we use the smallest possible type. The
9641 user can request that for all enumerations with a command line
9642 flag, or for just one enumeration with an attribute. */
9644 use_short_enum = flag_short_enums
9645 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype));
9647 for (itk = (use_short_enum ? itk_char : itk_int);
9651 underlying_type = integer_types[itk];
9652 if (TYPE_PRECISION (underlying_type) >= precision
9653 && TYPE_UNSIGNED (underlying_type) == unsignedp)
9656 if (itk == itk_none)
9660 IF no integral type can represent all the enumerator values, the
9661 enumeration is ill-formed. */
9662 error ("no integral type can represent all of the enumerator values "
9663 "for %qT", enumtype);
9664 precision = TYPE_PRECISION (long_long_integer_type_node);
9665 underlying_type = integer_types[itk_unsigned_long_long];
9668 /* Compute the minium and maximum values for the type.
9672 For an enumeration where emin is the smallest enumerator and emax
9673 is the largest, the values of the enumeration are the values of the
9674 underlying type in the range bmin to bmax, where bmin and bmax are,
9675 respectively, the smallest and largest values of the smallest bit-
9676 field that can store emin and emax. */
9678 /* The middle-end currently assumes that types with TYPE_PRECISION
9679 narrower than their underlying type are suitably zero or sign
9680 extended to fill their mode. g++ doesn't make these guarantees.
9681 Until the middle-end can represent such paradoxical types, we
9682 set the TYPE_PRECISION to the width of the underlying type. */
9683 TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type);
9685 set_min_and_max_values_for_integral_type (enumtype, precision, unsignedp);
9689 The value of sizeof() applied to an enumeration type, an object
9690 of an enumeration type, or an enumerator, is the value of sizeof()
9691 applied to the underlying type. */
9692 TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
9693 TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
9694 TYPE_MODE (enumtype) = TYPE_MODE (underlying_type);
9695 TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
9696 TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
9697 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);
9699 /* Convert each of the enumerators to the type of the underlying
9700 type of the enumeration. */
9701 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
9703 decl = TREE_VALUE (values);
9704 value = perform_implicit_conversion (underlying_type,
9705 DECL_INITIAL (decl));
9707 /* Do not clobber shared ints. */
9708 value = copy_node (value);
9710 TREE_TYPE (value) = enumtype;
9711 DECL_INITIAL (decl) = value;
9712 TREE_VALUE (values) = value;
9715 /* Fix up all variant types of this enum type. */
9716 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
9718 TYPE_VALUES (t) = TYPE_VALUES (enumtype);
9719 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
9720 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
9721 TYPE_SIZE (t) = TYPE_SIZE (enumtype);
9722 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
9723 TYPE_MODE (t) = TYPE_MODE (enumtype);
9724 TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
9725 TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
9726 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
9727 TYPE_UNSIGNED (t) = TYPE_UNSIGNED (enumtype);
9730 /* Finish debugging output for this type. */
9731 rest_of_type_compilation (enumtype, namespace_bindings_p ());
9734 /* Build and install a CONST_DECL for an enumeration constant of the
9735 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
9736 Assignment of sequential values by default is handled here. */
9739 build_enumerator (tree name, tree value, tree enumtype)
9745 /* If the VALUE was erroneous, pretend it wasn't there; that will
9746 result in the enum being assigned the next value in sequence. */
9747 if (value == error_mark_node)
9750 /* Remove no-op casts from the value. */
9752 STRIP_TYPE_NOPS (value);
9754 if (! processing_template_decl)
9756 /* Validate and default VALUE. */
9757 if (value != NULL_TREE)
9759 value = integral_constant_value (value);
9761 if (TREE_CODE (value) == INTEGER_CST)
9763 value = perform_integral_promotions (value);
9764 constant_expression_warning (value);
9768 error ("enumerator value for %qD not integer constant", name);
9773 /* Default based on previous value. */
9774 if (value == NULL_TREE)
9776 if (TYPE_VALUES (enumtype))
9779 unsigned HOST_WIDE_INT lo;
9783 /* The next value is the previous value plus one. We can
9784 safely assume that the previous value is an INTEGER_CST.
9785 add_double doesn't know the type of the target expression,
9786 so we must check with int_fits_type_p as well. */
9787 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
9788 overflowed = add_double (TREE_INT_CST_LOW (prev_value),
9789 TREE_INT_CST_HIGH (prev_value),
9791 value = build_int_cst_wide (TREE_TYPE (prev_value), lo, hi);
9792 overflowed |= !int_fits_type_p (value, TREE_TYPE (prev_value));
9795 error ("overflow in enumeration values at %qD", name);
9798 value = integer_zero_node;
9801 /* Remove no-op casts from the value. */
9802 STRIP_TYPE_NOPS (value);
9805 /* C++ associates enums with global, function, or class declarations. */
9806 context = current_scope ();
9808 /* Build the actual enumeration constant. Note that the enumeration
9809 constants have the type of their initializers until the
9810 enumeration is complete:
9814 Following the closing brace of an enum-specifier, each enumer-
9815 ator has the type of its enumeration. Prior to the closing
9816 brace, the type of each enumerator is the type of its
9819 In finish_enum we will reset the type. Of course, if we're
9820 processing a template, there may be no value. */
9821 type = value ? TREE_TYPE (value) : NULL_TREE;
9823 if (context && context == current_class_type)
9824 /* This enum declaration is local to the class. We need the full
9825 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
9826 decl = build_lang_decl (CONST_DECL, name, type);
9828 /* It's a global enum, or it's local to a function. (Note local to
9829 a function could mean local to a class method. */
9830 decl = build_decl (CONST_DECL, name, type);
9832 DECL_CONTEXT (decl) = FROB_CONTEXT (context);
9833 TREE_CONSTANT (decl) = 1;
9834 TREE_INVARIANT (decl) = 1;
9835 TREE_READONLY (decl) = 1;
9836 DECL_INITIAL (decl) = value;
9838 if (context && context == current_class_type)
9839 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
9840 on the TYPE_FIELDS list for `S'. (That's so that you can say
9841 things like `S::i' later.) */
9842 finish_member_declaration (decl);
9846 /* Add this enumeration constant to the list for this type. */
9847 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
9851 /* We're defining DECL. Make sure that it's type is OK. */
9854 check_function_type (tree decl, tree current_function_parms)
9856 tree fntype = TREE_TYPE (decl);
9857 tree return_type = complete_type (TREE_TYPE (fntype));
9859 /* In a function definition, arg types must be complete. */
9860 require_complete_types_for_parms (current_function_parms);
9862 if (dependent_type_p (return_type))
9864 if (!COMPLETE_OR_VOID_TYPE_P (return_type))
9866 error ("return type %q#T is incomplete", TREE_TYPE (fntype));
9868 /* Make it return void instead, but don't change the
9869 type of the DECL_RESULT, in case we have a named return value. */
9870 if (TREE_CODE (fntype) == METHOD_TYPE)
9872 tree ctype = TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype)));
9874 = build_method_type_directly (ctype,
9876 FUNCTION_ARG_CHAIN (decl));
9880 = build_function_type (void_type_node,
9881 TYPE_ARG_TYPES (TREE_TYPE (decl)));
9883 = build_exception_variant (fntype,
9884 TYPE_RAISES_EXCEPTIONS (fntype));
9887 abstract_virtuals_error (decl, TREE_TYPE (fntype));
9890 /* Create the FUNCTION_DECL for a function definition.
9891 DECLSPECS and DECLARATOR are the parts of the declaration;
9892 they describe the function's name and the type it returns,
9893 but twisted together in a fashion that parallels the syntax of C.
9895 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
9896 DECLARATOR is really the DECL for the function we are about to
9897 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
9898 indicating that the function is an inline defined in-class.
9900 This function creates a binding context for the function body
9901 as well as setting up the FUNCTION_DECL in current_function_decl.
9903 For C++, we must first check whether that datum makes any sense.
9904 For example, "class A local_a(1,2);" means that variable local_a
9905 is an aggregate of type A, which should have a constructor
9906 applied to it with the argument list [1, 2]. */
9909 start_preparsed_function (tree decl1, tree attrs, int flags)
9911 tree ctype = NULL_TREE;
9914 int doing_friend = 0;
9915 struct cp_binding_level *bl;
9916 tree current_function_parms;
9917 struct c_fileinfo *finfo = get_fileinfo (lbasename (input_filename));
9920 gcc_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE);
9921 gcc_assert (TREE_CHAIN (void_list_node) == NULL_TREE);
9923 fntype = TREE_TYPE (decl1);
9924 if (TREE_CODE (fntype) == METHOD_TYPE)
9925 ctype = TYPE_METHOD_BASETYPE (fntype);
9927 /* ISO C++ 11.4/5. A friend function defined in a class is in
9928 the (lexical) scope of the class in which it is defined. */
9929 if (!ctype && DECL_FRIEND_P (decl1))
9931 ctype = DECL_FRIEND_CONTEXT (decl1);
9933 /* CTYPE could be null here if we're dealing with a template;
9934 for example, `inline friend float foo()' inside a template
9935 will have no CTYPE set. */
9936 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
9942 if (DECL_DECLARED_INLINE_P (decl1)
9943 && lookup_attribute ("noinline", attrs))
9944 warning ("%Jinline function %qD given attribute noinline", decl1, decl1);
9946 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
9947 /* This is a constructor, we must ensure that any default args
9948 introduced by this definition are propagated to the clones
9949 now. The clones are used directly in overload resolution. */
9950 adjust_clone_args (decl1);
9952 /* Sometimes we don't notice that a function is a static member, and
9953 build a METHOD_TYPE for it. Fix that up now. */
9954 if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
9955 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
9957 revert_static_member_fn (decl1);
9961 /* Set up current_class_type, and enter the scope of the class, if
9964 push_nested_class (ctype);
9965 else if (DECL_STATIC_FUNCTION_P (decl1))
9966 push_nested_class (DECL_CONTEXT (decl1));
9968 /* Now that we have entered the scope of the class, we must restore
9969 the bindings for any template parameters surrounding DECL1, if it
9970 is an inline member template. (Order is important; consider the
9971 case where a template parameter has the same name as a field of
9972 the class.) It is not until after this point that
9973 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
9974 if (flags & SF_INCLASS_INLINE)
9975 maybe_begin_member_template_processing (decl1);
9977 /* Effective C++ rule 15. */
9979 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
9980 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
9981 warning ("%<operator=%> should return a reference to %<*this%>");
9983 /* Make the init_value nonzero so pushdecl knows this is not tentative.
9984 error_mark_node is replaced below (in poplevel) with the BLOCK. */
9985 if (!DECL_INITIAL (decl1))
9986 DECL_INITIAL (decl1) = error_mark_node;
9988 /* This function exists in static storage.
9989 (This does not mean `static' in the C sense!) */
9990 TREE_STATIC (decl1) = 1;
9992 /* We must call push_template_decl after current_class_type is set
9993 up. (If we are processing inline definitions after exiting a
9994 class scope, current_class_type will be NULL_TREE until set above
9995 by push_nested_class.) */
9996 if (processing_template_decl)
9997 decl1 = push_template_decl (decl1);
9999 /* We are now in the scope of the function being defined. */
10000 current_function_decl = decl1;
10002 /* Save the parm names or decls from this function's declarator
10003 where store_parm_decls will find them. */
10004 current_function_parms = DECL_ARGUMENTS (decl1);
10006 /* Make sure the parameter and return types are reasonable. When
10007 you declare a function, these types can be incomplete, but they
10008 must be complete when you define the function. */
10009 check_function_type (decl1, current_function_parms);
10011 /* Build the return declaration for the function. */
10012 restype = TREE_TYPE (fntype);
10013 /* Promote the value to int before returning it. */
10014 if (c_promoting_integer_type_p (restype))
10015 restype = type_promotes_to (restype);
10016 if (DECL_RESULT (decl1) == NULL_TREE)
10020 resdecl = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
10021 DECL_ARTIFICIAL (resdecl) = 1;
10022 DECL_IGNORED_P (resdecl) = 1;
10023 DECL_RESULT (decl1) = resdecl;
10025 cp_apply_type_quals_to_decl (cp_type_quals (restype), resdecl);
10028 /* Initialize RTL machinery. We cannot do this until
10029 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
10030 even when processing a template; this is how we get
10031 CFUN set up, and our per-function variables initialized.
10032 FIXME factor out the non-RTL stuff. */
10033 bl = current_binding_level;
10034 allocate_struct_function (decl1);
10035 current_binding_level = bl;
10037 /* Even though we're inside a function body, we still don't want to
10038 call expand_expr to calculate the size of a variable-sized array.
10039 We haven't necessarily assigned RTL to all variables yet, so it's
10040 not safe to try to expand expressions involving them. */
10041 cfun->x_dont_save_pending_sizes_p = 1;
10043 /* Start the statement-tree, start the tree now. */
10044 DECL_SAVED_TREE (decl1) = push_stmt_list ();
10046 /* Let the user know we're compiling this function. */
10047 announce_function (decl1);
10049 /* Record the decl so that the function name is defined.
10050 If we already have a decl for this name, and it is a FUNCTION_DECL,
10051 use the old decl. */
10052 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
10054 /* A specialization is not used to guide overload resolution. */
10055 if (!DECL_FUNCTION_MEMBER_P (decl1)
10056 && !(DECL_USE_TEMPLATE (decl1) &&
10057 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1))))
10059 tree olddecl = pushdecl (decl1);
10061 if (olddecl == error_mark_node)
10062 /* If something went wrong when registering the declaration,
10063 use DECL1; we have to have a FUNCTION_DECL to use when
10064 parsing the body of the function. */
10067 /* Otherwise, OLDDECL is either a previous declaration of
10068 the same function or DECL1 itself. */
10073 /* We need to set the DECL_CONTEXT. */
10074 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
10075 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
10076 /* And make sure we have enough default args. */
10077 check_default_args (decl1);
10079 fntype = TREE_TYPE (decl1);
10082 /* Determine the ELF visibility attribute for the function. We must
10083 not do this before calling "pushdecl", as we must allow
10084 "duplicate_decls" to merge any attributes appropriately. */
10085 if (!DECL_CLONED_FUNCTION_P (decl1))
10086 determine_visibility (decl1);
10088 /* Reset these in case the call to pushdecl changed them. */
10089 current_function_decl = decl1;
10090 cfun->decl = decl1;
10092 /* If we are (erroneously) defining a function that we have already
10093 defined before, wipe out what we knew before. */
10094 if (!DECL_PENDING_INLINE_P (decl1))
10095 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
10097 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
10099 /* We know that this was set up by `grokclassfn'. We do not
10100 wait until `store_parm_decls', since evil parse errors may
10101 never get us to that point. Here we keep the consistency
10102 between `current_class_type' and `current_class_ptr'. */
10103 tree t = DECL_ARGUMENTS (decl1);
10105 gcc_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL);
10106 gcc_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE);
10108 cp_function_chain->x_current_class_ref
10109 = build_indirect_ref (t, NULL);
10110 cp_function_chain->x_current_class_ptr = t;
10112 /* Constructors and destructors need to know whether they're "in
10113 charge" of initializing virtual base classes. */
10114 t = TREE_CHAIN (t);
10115 if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
10117 current_in_charge_parm = t;
10118 t = TREE_CHAIN (t);
10120 if (DECL_HAS_VTT_PARM_P (decl1))
10122 gcc_assert (DECL_NAME (t) == vtt_parm_identifier);
10123 current_vtt_parm = t;
10127 if (DECL_INTERFACE_KNOWN (decl1))
10129 tree ctx = decl_function_context (decl1);
10131 if (DECL_NOT_REALLY_EXTERN (decl1))
10132 DECL_EXTERNAL (decl1) = 0;
10134 if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
10135 && TREE_PUBLIC (ctx))
10136 /* This is a function in a local class in an extern inline
10138 comdat_linkage (decl1);
10140 /* If this function belongs to an interface, it is public.
10141 If it belongs to someone else's interface, it is also external.
10142 This only affects inlines and template instantiations. */
10143 else if (finfo->interface_unknown == 0
10144 && ! DECL_TEMPLATE_INSTANTIATION (decl1))
10146 if (DECL_DECLARED_INLINE_P (decl1)
10147 || DECL_TEMPLATE_INSTANTIATION (decl1)
10148 || processing_template_decl)
10150 DECL_EXTERNAL (decl1)
10151 = (finfo->interface_only
10152 || (DECL_DECLARED_INLINE_P (decl1)
10153 && ! flag_implement_inlines
10154 && !DECL_VINDEX (decl1)));
10156 /* For WIN32 we also want to put these in linkonce sections. */
10157 maybe_make_one_only (decl1);
10160 DECL_EXTERNAL (decl1) = 0;
10161 DECL_NOT_REALLY_EXTERN (decl1) = 0;
10162 DECL_INTERFACE_KNOWN (decl1) = 1;
10163 /* If this function is in an interface implemented in this file,
10164 make sure that the backend knows to emit this function
10166 if (!DECL_EXTERNAL (decl1))
10167 mark_needed (decl1);
10169 else if (finfo->interface_unknown && finfo->interface_only
10170 && ! DECL_TEMPLATE_INSTANTIATION (decl1))
10172 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
10173 interface, we will have both finfo->interface_unknown and
10174 finfo->interface_only set. In that case, we don't want to
10175 use the normal heuristics because someone will supply a
10176 #pragma implementation elsewhere, and deducing it here would
10177 produce a conflict. */
10178 comdat_linkage (decl1);
10179 DECL_EXTERNAL (decl1) = 0;
10180 DECL_INTERFACE_KNOWN (decl1) = 1;
10181 DECL_DEFER_OUTPUT (decl1) = 1;
10185 /* This is a definition, not a reference.
10186 So clear DECL_EXTERNAL. */
10187 DECL_EXTERNAL (decl1) = 0;
10189 if ((DECL_DECLARED_INLINE_P (decl1)
10190 || DECL_TEMPLATE_INSTANTIATION (decl1))
10191 && ! DECL_INTERFACE_KNOWN (decl1)
10192 /* Don't try to defer nested functions for now. */
10193 && ! decl_function_context (decl1))
10194 DECL_DEFER_OUTPUT (decl1) = 1;
10196 DECL_INTERFACE_KNOWN (decl1) = 1;
10199 begin_scope (sk_function_parms, decl1);
10203 if (DECL_DESTRUCTOR_P (decl1)
10204 || (DECL_CONSTRUCTOR_P (decl1)
10205 && targetm.cxx.cdtor_returns_this ()))
10207 cdtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
10208 DECL_CONTEXT (cdtor_label) = current_function_decl;
10211 start_fname_decls ();
10213 store_parm_decls (current_function_parms);
10217 /* Like start_preparsed_function, except that instead of a
10218 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
10220 Returns 1 on success. If the DECLARATOR is not suitable for a function
10221 (it defines a datum instead), we return 0, which tells
10222 yyparse to report a parse error. */
10225 start_function (cp_decl_specifier_seq *declspecs,
10226 const cp_declarator *declarator,
10231 if (have_extern_spec)
10233 declspecs->storage_class = sc_extern;
10234 /* This should only be done once on the outermost decl. */
10235 have_extern_spec = false;
10238 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
10239 /* If the declarator is not suitable for a function definition,
10240 cause a syntax error. */
10241 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
10244 /* If #pragma weak was used, mark the decl weak now. */
10245 if (global_scope_p (current_binding_level))
10246 maybe_apply_pragma_weak (decl1);
10248 if (DECL_MAIN_P (decl1))
10249 /* main must return int. grokfndecl should have corrected it
10250 (and issued a diagnostic) if the user got it wrong. */
10251 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1)),
10252 integer_type_node));
10254 start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT);
10259 /* Store the parameter declarations into the current function declaration.
10260 This is called after parsing the parameter declarations, before
10261 digesting the body of the function.
10263 Also install to binding contour return value identifier, if any. */
10266 store_parm_decls (tree current_function_parms)
10268 tree fndecl = current_function_decl;
10271 /* This is a chain of any other decls that came in among the parm
10272 declarations. If a parm is declared with enum {foo, bar} x;
10273 then CONST_DECLs for foo and bar are put here. */
10274 tree nonparms = NULL_TREE;
10276 if (current_function_parms)
10278 /* This case is when the function was defined with an ANSI prototype.
10279 The parms already have decls, so we need not do anything here
10280 except record them as in effect
10281 and complain if any redundant old-style parm decls were written. */
10283 tree specparms = current_function_parms;
10286 /* Must clear this because it might contain TYPE_DECLs declared
10288 current_binding_level->names = NULL;
10290 /* If we're doing semantic analysis, then we'll call pushdecl
10291 for each of these. We must do them in reverse order so that
10292 they end in the correct forward order. */
10293 specparms = nreverse (specparms);
10295 for (parm = specparms; parm; parm = next)
10297 next = TREE_CHAIN (parm);
10298 if (TREE_CODE (parm) == PARM_DECL)
10300 if (DECL_NAME (parm) == NULL_TREE
10301 || TREE_CODE (parm) != VOID_TYPE)
10304 error ("parameter %qD declared void", parm);
10308 /* If we find an enum constant or a type tag,
10309 put it aside for the moment. */
10310 TREE_CHAIN (parm) = NULL_TREE;
10311 nonparms = chainon (nonparms, parm);
10315 /* Get the decls in their original chain order and record in the
10316 function. This is all and only the PARM_DECLs that were
10317 pushed into scope by the loop above. */
10318 DECL_ARGUMENTS (fndecl) = getdecls ();
10321 DECL_ARGUMENTS (fndecl) = NULL_TREE;
10323 /* Now store the final chain of decls for the arguments
10324 as the decl-chain of the current lexical scope.
10325 Put the enumerators in as well, at the front so that
10326 DECL_ARGUMENTS is not modified. */
10327 current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));
10329 /* For a cloned function, we've already got all the code we need;
10330 there's no need to add any extra bits. */
10331 if (!DECL_CLONED_FUNCTION_P (fndecl))
10333 /* Do the starting of the exception specifications, if we have any. */
10334 if (flag_exceptions && !processing_template_decl
10335 && flag_enforce_eh_specs
10336 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
10337 current_eh_spec_block = begin_eh_spec_block ();
10342 /* We have finished doing semantic analysis on DECL, but have not yet
10343 generated RTL for its body. Save away our current state, so that
10344 when we want to generate RTL later we know what to do. */
10347 save_function_data (tree decl)
10349 struct language_function *f;
10351 /* Save the language-specific per-function data so that we can
10352 get it back when we really expand this function. */
10353 gcc_assert (!DECL_PENDING_INLINE_P (decl));
10356 f = GGC_NEW (struct language_function);
10357 memcpy (f, cp_function_chain, sizeof (struct language_function));
10358 DECL_SAVED_FUNCTION_DATA (decl) = f;
10360 /* Clear out the bits we don't need. */
10361 f->base.x_stmt_tree.x_cur_stmt_list = NULL_TREE;
10362 f->x_named_label_uses = NULL;
10363 f->bindings = NULL;
10364 f->x_local_names = NULL;
10368 /* Set the return value of the constructor (if present). */
10371 finish_constructor_body (void)
10376 if (targetm.cxx.cdtor_returns_this ())
10378 /* Any return from a constructor will end up here. */
10379 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
10381 val = DECL_ARGUMENTS (current_function_decl);
10382 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
10383 DECL_RESULT (current_function_decl), val);
10384 /* Return the address of the object. */
10385 exprstmt = build_stmt (RETURN_EXPR, val);
10386 add_stmt (exprstmt);
10390 /* Do all the processing for the beginning of a destructor; set up the
10391 vtable pointers and cleanups for bases and members. */
10394 begin_destructor_body (void)
10397 tree compound_stmt;
10399 /* If the dtor is empty, and we know there is not any possible
10400 way we could use any vtable entries, before they are possibly
10401 set by a base class dtor, we don't have to setup the vtables,
10402 as we know that any base class dtor will set up any vtables
10403 it needs. We avoid MI, because one base class dtor can do a
10404 virtual dispatch to an overridden function that would need to
10405 have a non-related vtable set up, we cannot avoid setting up
10406 vtables in that case. We could change this to see if there
10407 is just one vtable.
10409 ??? In the destructor for a class, the vtables are set
10410 appropriately for that class. There will be no non-related
10411 vtables. jason 2001-12-11. */
10412 if_stmt = begin_if_stmt ();
10414 /* If it is not safe to avoid setting up the vtables, then
10415 someone will change the condition to be boolean_true_node.
10416 (Actually, for now, we do not have code to set the condition
10417 appropriately, so we just assume that we always need to
10418 initialize the vtables.) */
10419 finish_if_stmt_cond (boolean_true_node, if_stmt);
10421 compound_stmt = begin_compound_stmt (0);
10423 /* Make all virtual function table pointers in non-virtual base
10424 classes point to CURRENT_CLASS_TYPE's virtual function
10426 initialize_vtbl_ptrs (current_class_ptr);
10428 finish_compound_stmt (compound_stmt);
10429 finish_then_clause (if_stmt);
10430 finish_if_stmt (if_stmt);
10432 /* And insert cleanups for our bases and members so that they
10433 will be properly destroyed if we throw. */
10434 push_base_cleanups ();
10437 /* At the end of every destructor we generate code to delete the object if
10438 necessary. Do that now. */
10441 finish_destructor_body (void)
10445 /* Any return from a destructor will end up here; that way all base
10446 and member cleanups will be run when the function returns. */
10447 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
10449 /* In a virtual destructor, we must call delete. */
10450 if (DECL_VIRTUAL_P (current_function_decl))
10453 tree virtual_size = cxx_sizeof (current_class_type);
10457 At the point of definition of a virtual destructor (including
10458 an implicit definition), non-placement operator delete shall
10459 be looked up in the scope of the destructor's class and if
10460 found shall be accessible and unambiguous. */
10461 exprstmt = build_op_delete_call
10462 (DELETE_EXPR, current_class_ptr, virtual_size,
10463 /*global_p=*/false, NULL_TREE);
10465 if_stmt = begin_if_stmt ();
10466 finish_if_stmt_cond (build2 (BIT_AND_EXPR, integer_type_node,
10467 current_in_charge_parm,
10470 finish_expr_stmt (exprstmt);
10471 finish_then_clause (if_stmt);
10472 finish_if_stmt (if_stmt);
10475 if (targetm.cxx.cdtor_returns_this ())
10479 val = DECL_ARGUMENTS (current_function_decl);
10480 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
10481 DECL_RESULT (current_function_decl), val);
10482 /* Return the address of the object. */
10483 exprstmt = build_stmt (RETURN_EXPR, val);
10484 add_stmt (exprstmt);
10488 /* Do the necessary processing for the beginning of a function body, which
10489 in this case includes member-initializers, but not the catch clauses of
10490 a function-try-block. Currently, this means opening a binding level
10491 for the member-initializers (in a ctor) and member cleanups (in a dtor).
10492 In other functions, this isn't necessary, but it doesn't hurt. */
10495 begin_function_body (void)
10499 if (processing_template_decl)
10500 /* Do nothing now. */;
10502 /* Always keep the BLOCK node associated with the outermost pair of
10503 curly braces of a function. These are needed for correct
10504 operation of dwarfout.c. */
10505 keep_next_level (true);
10507 stmt = begin_compound_stmt (BCS_FN_BODY);
10509 if (processing_template_decl)
10510 /* Do nothing now. */;
10511 else if (DECL_DESTRUCTOR_P (current_function_decl))
10512 begin_destructor_body ();
10517 /* Do the processing for the end of a function body. Currently, this means
10518 closing out the cleanups for fully-constructed bases and members, and in
10519 the case of the destructor, deleting the object if desired. Again, this
10520 is only meaningful for [cd]tors, since they are the only functions where
10521 there is a significant distinction between the main body and any
10522 function catch clauses. Handling, say, main() return semantics here
10523 would be wrong, as flowing off the end of a function catch clause for
10524 main() would also need to return 0. */
10527 finish_function_body (tree compstmt)
10529 /* Close the block. */
10530 finish_compound_stmt (compstmt);
10532 if (processing_template_decl)
10533 /* Do nothing now. */;
10534 else if (DECL_CONSTRUCTOR_P (current_function_decl))
10535 finish_constructor_body ();
10536 else if (DECL_DESTRUCTOR_P (current_function_decl))
10537 finish_destructor_body ();
10540 /* Finish up a function declaration and compile that function
10541 all the way to assembler language output. The free the storage
10542 for the function definition.
10544 FLAGS is a bitwise or of the following values:
10546 We just finished processing the body of an in-class inline
10547 function definition. (This processing will have taken place
10548 after the class definition is complete.) */
10551 finish_function (int flags)
10553 tree fndecl = current_function_decl;
10554 tree fntype, ctype = NULL_TREE;
10555 int inclass_inline = (flags & 2) != 0;
10558 /* When we get some parse errors, we can end up without a
10559 current_function_decl, so cope. */
10560 if (fndecl == NULL_TREE)
10561 return error_mark_node;
10563 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
10564 && DECL_VIRTUAL_P (fndecl)
10565 && !processing_template_decl)
10567 tree fnclass = DECL_CONTEXT (fndecl);
10568 if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
10569 keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
10572 nested = function_depth > 1;
10573 fntype = TREE_TYPE (fndecl);
10575 /* TREE_READONLY (fndecl) = 1;
10576 This caused &foo to be of type ptr-to-const-function
10577 which then got a warning when stored in a ptr-to-function variable. */
10579 gcc_assert (building_stmt_tree ());
10581 /* For a cloned function, we've already got all the code we need;
10582 there's no need to add any extra bits. */
10583 if (!DECL_CLONED_FUNCTION_P (fndecl))
10585 if (DECL_MAIN_P (current_function_decl))
10589 /* Make it so that `main' always returns 0 by default (or
10592 stmt = finish_return_stmt (integer_one_node);
10594 stmt = finish_return_stmt (integer_zero_node);
10596 /* Hack. We don't want the middle-end to warn that this
10597 return is unreachable, so put the statement on the
10599 annotate_with_file_line (stmt, input_filename, 0);
10602 /* Finish dealing with exception specifiers. */
10603 if (flag_exceptions && !processing_template_decl
10604 && flag_enforce_eh_specs
10605 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (current_function_decl)))
10606 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
10607 (TREE_TYPE (current_function_decl)),
10608 current_eh_spec_block);
10611 /* If we're saving up tree structure, tie off the function now. */
10612 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
10614 finish_fname_decls ();
10616 /* If this function can't throw any exceptions, remember that. */
10617 if (!processing_template_decl
10618 && !cp_function_chain->can_throw
10619 && !flag_non_call_exceptions)
10620 TREE_NOTHROW (fndecl) = 1;
10622 /* This must come after expand_function_end because cleanups might
10623 have declarations (from inline functions) that need to go into
10624 this function's blocks. */
10626 /* If the current binding level isn't the outermost binding level
10627 for this function, either there is a bug, or we have experienced
10628 syntax errors and the statement tree is malformed. */
10629 if (current_binding_level->kind != sk_function_parms)
10631 /* Make sure we have already experienced errors. */
10632 gcc_assert (errorcount);
10634 /* Throw away the broken statement tree and extra binding
10636 DECL_SAVED_TREE (fndecl) = alloc_stmt_list ();
10638 while (current_binding_level->kind != sk_function_parms)
10640 if (current_binding_level->kind == sk_class)
10641 pop_nested_class ();
10643 poplevel (0, 0, 0);
10646 poplevel (1, 0, 1);
10648 /* Statements should always be full-expressions at the outermost set
10649 of curly braces for a function. */
10650 gcc_assert (stmts_are_full_exprs_p ());
10652 /* Set up the named return value optimization, if we can. Candidate
10653 variables are selected in check_return_value. */
10654 if (current_function_return_value)
10656 tree r = current_function_return_value;
10659 if (r != error_mark_node
10660 /* This is only worth doing for fns that return in memory--and
10661 simpler, since we don't have to worry about promoted modes. */
10662 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
10663 /* Only allow this for variables declared in the outer scope of
10664 the function so we know that their lifetime always ends with a
10665 return; see g++.dg/opt/nrv6.C. We could be more flexible if
10666 we were to do this optimization in tree-ssa. */
10667 && (outer = BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl)))
10668 /* Skip the artificial function body block. */
10669 && (outer = BLOCK_SUBBLOCKS (outer))
10670 && chain_member (r, BLOCK_VARS (outer)))
10671 finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));
10673 current_function_return_value = NULL_TREE;
10676 /* Remember that we were in class scope. */
10677 if (current_class_name)
10678 ctype = current_class_type;
10680 /* Must mark the RESULT_DECL as being in this function. */
10681 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
10683 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
10684 to the FUNCTION_DECL node itself. */
10685 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
10687 /* Save away current state, if appropriate. */
10688 if (!processing_template_decl)
10689 save_function_data (fndecl);
10691 /* Complain if there's just no return statement. */
10692 if (warn_return_type
10693 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
10694 && !dependent_type_p (TREE_TYPE (fntype))
10695 && !current_function_returns_value && !current_function_returns_null
10696 /* Don't complain if we abort or throw. */
10697 && !current_function_returns_abnormally
10698 && !DECL_NAME (DECL_RESULT (fndecl))
10699 /* Normally, with -Wreturn-type, flow will complain. Unless we're an
10700 inline function, as we might never be compiled separately. */
10701 && (DECL_INLINE (fndecl) || processing_template_decl)
10702 /* Structor return values (if any) are set by the compiler. */
10703 && !DECL_CONSTRUCTOR_P (fndecl)
10704 && !DECL_DESTRUCTOR_P (fndecl))
10705 warning ("no return statement in function returning non-void");
10707 /* Store the end of the function, so that we get good line number
10708 info for the epilogue. */
10709 cfun->function_end_locus = input_location;
10711 /* Genericize before inlining. */
10712 if (!processing_template_decl)
10714 struct language_function *f = DECL_SAVED_FUNCTION_DATA (fndecl);
10715 cp_genericize (fndecl);
10716 /* Clear out the bits we don't need. */
10717 f->x_current_class_ptr = NULL;
10718 f->x_current_class_ref = NULL;
10719 f->x_eh_spec_block = NULL;
10720 f->x_in_charge_parm = NULL;
10721 f->x_vtt_parm = NULL;
10722 f->x_return_value = NULL;
10723 f->bindings = NULL;
10725 /* Handle attribute((warn_unused_result)). Relies on gimple input. */
10726 c_warn_unused_result (&DECL_SAVED_TREE (fndecl));
10728 /* Clear out the bits we don't need. */
10729 local_names = NULL;
10730 named_label_uses = NULL;
10732 /* We're leaving the context of this function, so zap cfun. It's still in
10733 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
10735 current_function_decl = NULL;
10737 /* If this is an in-class inline definition, we may have to pop the
10738 bindings for the template parameters that we added in
10739 maybe_begin_member_template_processing when start_function was
10741 if (inclass_inline)
10742 maybe_end_member_template_processing ();
10744 /* Leave the scope of the class. */
10746 pop_nested_class ();
10752 /* Let the error reporting routines know that we're outside a
10753 function. For a nested function, this value is used in
10754 cxx_pop_function_context and then reset via pop_function_context. */
10755 current_function_decl = NULL_TREE;
10760 /* Create the FUNCTION_DECL for a function definition.
10761 DECLSPECS and DECLARATOR are the parts of the declaration;
10762 they describe the return type and the name of the function,
10763 but twisted together in a fashion that parallels the syntax of C.
10765 This function creates a binding context for the function body
10766 as well as setting up the FUNCTION_DECL in current_function_decl.
10768 Returns a FUNCTION_DECL on success.
10770 If the DECLARATOR is not suitable for a function (it defines a datum
10771 instead), we return 0, which tells yyparse to report a parse error.
10773 May return void_type_node indicating that this method is actually
10774 a friend. See grokfield for more details.
10776 Came here with a `.pushlevel' .
10778 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
10779 CHANGES TO CODE IN `grokfield'. */
10782 start_method (cp_decl_specifier_seq *declspecs,
10783 const cp_declarator *declarator, tree attrlist)
10785 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
10788 if (fndecl == error_mark_node)
10789 return error_mark_node;
10791 if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
10793 error ("invalid member function declaration");
10794 return error_mark_node;
10798 cplus_decl_attributes (&fndecl, attrlist, 0);
10800 /* Pass friends other than inline friend functions back. */
10801 if (fndecl == void_type_node)
10804 if (DECL_IN_AGGR_P (fndecl))
10806 if (DECL_CONTEXT (fndecl)
10807 && TREE_CODE( DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
10808 error ("%qD is already defined in class %qT", fndecl,
10809 DECL_CONTEXT (fndecl));
10810 return void_type_node;
10813 check_template_shadow (fndecl);
10815 DECL_DECLARED_INLINE_P (fndecl) = 1;
10816 if (flag_default_inline)
10817 DECL_INLINE (fndecl) = 1;
10819 /* We process method specializations in finish_struct_1. */
10820 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
10822 fndecl = push_template_decl (fndecl);
10823 if (fndecl == error_mark_node)
10827 if (! DECL_FRIEND_P (fndecl))
10829 if (TREE_CHAIN (fndecl))
10831 fndecl = copy_node (fndecl);
10832 TREE_CHAIN (fndecl) = NULL_TREE;
10834 grok_special_member_properties (fndecl);
10837 cp_finish_decl (fndecl, NULL_TREE, NULL_TREE, 0);
10839 /* Make a place for the parms. */
10840 begin_scope (sk_function_parms, fndecl);
10842 DECL_IN_AGGR_P (fndecl) = 1;
10846 /* Go through the motions of finishing a function definition.
10847 We don't compile this method until after the whole class has
10850 FINISH_METHOD must return something that looks as though it
10851 came from GROKFIELD (since we are defining a method, after all).
10853 This is called after parsing the body of the function definition.
10854 STMTS is the chain of statements that makes up the function body.
10856 DECL is the ..._DECL that `start_method' provided. */
10859 finish_method (tree decl)
10861 tree fndecl = decl;
10866 if (decl == void_type_node)
10869 old_initial = DECL_INITIAL (fndecl);
10871 /* Undo the level for the parms (from start_method).
10872 This is like poplevel, but it causes nothing to be
10873 saved. Saving information here confuses symbol-table
10874 output routines. Besides, this information will
10875 be correctly output when this method is actually
10878 /* Clear out the meanings of the local variables of this level;
10879 also record in each decl which block it belongs to. */
10881 for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
10883 if (DECL_NAME (link) != NULL_TREE)
10884 pop_binding (DECL_NAME (link), link);
10885 gcc_assert (TREE_CODE (link) != FUNCTION_DECL);
10886 DECL_CONTEXT (link) = NULL_TREE;
10889 poplevel (0, 0, 0);
10891 DECL_INITIAL (fndecl) = old_initial;
10893 /* We used to check if the context of FNDECL was different from
10894 current_class_type as another way to get inside here. This didn't work
10895 for String.cc in libg++. */
10896 if (DECL_FRIEND_P (fndecl))
10898 VEC_safe_push (tree, CLASSTYPE_INLINE_FRIENDS (current_class_type),
10900 decl = void_type_node;
10907 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
10908 we can lay it out later, when and if its type becomes complete. */
10911 maybe_register_incomplete_var (tree var)
10913 gcc_assert (TREE_CODE (var) == VAR_DECL);
10915 /* Keep track of variables with incomplete types. */
10916 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
10917 && DECL_EXTERNAL (var))
10919 tree inner_type = TREE_TYPE (var);
10921 while (TREE_CODE (inner_type) == ARRAY_TYPE)
10922 inner_type = TREE_TYPE (inner_type);
10923 inner_type = TYPE_MAIN_VARIANT (inner_type);
10925 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
10926 /* RTTI TD entries are created while defining the type_info. */
10927 || (TYPE_LANG_SPECIFIC (inner_type)
10928 && TYPE_BEING_DEFINED (inner_type)))
10929 incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
10933 /* Called when a class type (given by TYPE) is defined. If there are
10934 any existing VAR_DECLs whose type hsa been completed by this
10935 declaration, update them now. */
10938 complete_vars (tree type)
10940 tree *list = &incomplete_vars;
10942 gcc_assert (CLASS_TYPE_P (type));
10945 if (same_type_p (type, TREE_PURPOSE (*list)))
10947 tree var = TREE_VALUE (*list);
10948 tree type = TREE_TYPE (var);
10949 /* Complete the type of the variable. The VAR_DECL itself
10950 will be laid out in expand_expr. */
10951 complete_type (type);
10952 cp_apply_type_quals_to_decl (cp_type_quals (type), var);
10953 /* Remove this entry from the list. */
10954 *list = TREE_CHAIN (*list);
10957 list = &TREE_CHAIN (*list);
10960 /* Check for pending declarations which may have abstract type. */
10961 complete_type_check_abstract (type);
10964 /* If DECL is of a type which needs a cleanup, build that cleanup
10968 cxx_maybe_build_cleanup (tree decl)
10970 tree type = TREE_TYPE (decl);
10972 if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
10974 int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
10976 bool has_vbases = (TREE_CODE (type) == RECORD_TYPE
10977 && CLASSTYPE_VBASECLASSES (type));
10979 if (TREE_CODE (type) == ARRAY_TYPE)
10983 cxx_mark_addressable (decl);
10984 rval = build_unary_op (ADDR_EXPR, decl, 0);
10987 /* Optimize for space over speed here. */
10988 if (!has_vbases || flag_expensive_optimizations)
10989 flags |= LOOKUP_NONVIRTUAL;
10991 rval = build_delete (TREE_TYPE (rval), rval,
10992 sfk_complete_destructor, flags, 0);
10999 /* When a stmt has been parsed, this function is called. */
11006 /* DECL was originally constructed as a non-static member function,
11007 but turned out to be static. Update it accordingly. */
11010 revert_static_member_fn (tree decl)
11013 tree function = TREE_TYPE (decl);
11014 tree args = TYPE_ARG_TYPES (function);
11016 if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
11017 != TYPE_UNQUALIFIED)
11018 error ("static member function %q#D declared with type qualifiers", decl);
11020 args = TREE_CHAIN (args);
11021 tmp = build_function_type (TREE_TYPE (function), args);
11022 tmp = build_qualified_type (tmp, cp_type_quals (function));
11023 tmp = build_exception_variant (tmp,
11024 TYPE_RAISES_EXCEPTIONS (function));
11025 TREE_TYPE (decl) = tmp;
11026 if (DECL_ARGUMENTS (decl))
11027 DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
11028 DECL_STATIC_FUNCTION_P (decl) = 1;
11031 /* Initialize the variables used during compilation of a C++
11035 cxx_push_function_context (struct function * f)
11037 struct language_function *p = GGC_CNEW (struct language_function);
11040 /* Whenever we start a new function, we destroy temporaries in the
11042 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
11048 if (DECL_SAVED_FUNCTION_DATA (fn))
11050 /* If we already parsed this function, and we're just expanding it
11051 now, restore saved state. */
11052 *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (fn);
11054 /* We don't need the saved data anymore. Unless this is an inline
11055 function; we need the named return value info for
11056 declare_return_variable. */
11057 if (! DECL_INLINE (fn))
11058 DECL_SAVED_FUNCTION_DATA (fn) = NULL;
11063 /* Free the language-specific parts of F, now that we've finished
11064 compiling the function. */
11067 cxx_pop_function_context (struct function * f)
11072 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
11073 one of the language-independent trees. */
11075 enum cp_tree_node_structure_enum
11076 cp_tree_node_structure (union lang_tree_node * t)
11078 switch (TREE_CODE (&t->generic))
11080 case DEFAULT_ARG: return TS_CP_DEFAULT_ARG;
11081 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER;
11082 case OVERLOAD: return TS_CP_OVERLOAD;
11083 case TEMPLATE_PARM_INDEX: return TS_CP_TPI;
11084 case TINST_LEVEL: return TS_CP_TINST_LEVEL;
11085 case PTRMEM_CST: return TS_CP_PTRMEM;
11086 case BASELINK: return TS_CP_BASELINK;
11087 default: return TS_CP_GENERIC;
11091 /* Build the void_list_node (void_type_node having been created). */
11093 build_void_list_node (void)
11095 tree t = build_tree_list (NULL_TREE, void_type_node);
11100 cp_missing_noreturn_ok_p (tree decl)
11102 /* A missing noreturn is ok for the `main' function. */
11103 return DECL_MAIN_P (decl);
11106 /* Return the COMDAT group into which DECL should be placed. */
11109 cxx_comdat_group (tree decl)
11113 /* Virtual tables, construction virtual tables, and virtual table
11114 tables all go in a single COMDAT group, named after the primary
11116 if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
11117 name = DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl)));
11118 /* For all other DECLs, the COMDAT group is the mangled name of the
11119 declaration itself. */
11121 name = DECL_ASSEMBLER_NAME (decl);
11123 return IDENTIFIER_POINTER (name);
11126 #include "gt-cp-decl.h"