1 /* Process declarations and variables for C++ compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006 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, 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, 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 void maybe_deduce_size_from_array_init (tree, tree);
84 static void layout_var_decl (tree);
85 static void maybe_commonize_var (tree);
86 static tree check_initializer (tree, tree, int, tree *);
87 static void make_rtl_for_nonlocal_decl (tree, tree, const char *);
88 static void save_function_data (tree);
89 static void check_function_type (tree, tree);
90 static void finish_constructor_body (void);
91 static void begin_destructor_body (void);
92 static void finish_destructor_body (void);
93 static tree create_array_type_for_decl (tree, tree, tree);
94 static tree get_atexit_node (void);
95 static tree get_dso_handle_node (void);
96 static tree start_cleanup_fn (void);
97 static void end_cleanup_fn (void);
98 static tree cp_make_fname_decl (tree, int);
99 static void initialize_predefined_identifiers (void);
100 static tree check_special_function_return_type
101 (special_function_kind, tree, tree);
102 static tree push_cp_library_fn (enum tree_code, tree);
103 static tree build_cp_library_fn (tree, enum tree_code, tree);
104 static void store_parm_decls (tree);
105 static void initialize_local_var (tree, tree);
106 static void expand_static_init (tree, tree);
107 static tree next_initializable_field (tree);
109 /* The following symbols are subsumed in the cp_global_trees array, and
110 listed here individually for documentation purposes.
113 tree wchar_decl_node;
115 tree vtable_entry_type;
116 tree delta_type_node;
117 tree __t_desc_type_node;
119 tree class_type_node;
120 tree unknown_type_node;
122 Array type `vtable_entry_type[]'
125 tree vtbl_ptr_type_node;
132 A FUNCTION_DECL which can call `abort'. Not necessarily the
133 one that the user will declare, but sufficient to be called
134 by routines that want to abort the program.
138 The FUNCTION_DECL for the default `::operator delete'.
140 tree global_delete_fndecl;
143 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
148 tree cp_global_trees[CPTI_MAX];
150 /* Indicates that there is a type value in some namespace, although
151 that is not necessarily in scope at the moment. */
153 tree global_type_node;
155 /* The node that holds the "name" of the global scope. */
156 tree global_scope_name;
158 #define local_names cp_function_chain->x_local_names
160 /* A list of objects which have constructors or destructors
161 which reside in the global scope. The decl is stored in
162 the TREE_VALUE slot and the initializer is stored
163 in the TREE_PURPOSE slot. */
164 tree static_aggregates;
168 /* A node for the integer constants 2, and 3. */
170 tree integer_two_node, integer_three_node;
172 /* Used only for jumps to as-yet undefined labels, since jumps to
173 defined labels can have their validity checked immediately. */
175 struct named_label_use_entry GTY(())
177 struct named_label_use_entry *next;
178 /* The binding level to which this entry is *currently* attached.
179 This is initially the binding level in which the goto appeared,
180 but is modified as scopes are closed. */
181 struct cp_binding_level *binding_level;
182 /* The head of the names list that was current when the goto appeared,
183 or the inner scope popped. These are the decls that will *not* be
184 skipped when jumping to the label. */
186 /* The location of the goto, for error reporting. */
187 location_t o_goto_locus;
188 /* True if an OpenMP structured block scope has been closed since
189 the goto appeared. This means that the branch from the label will
190 illegally exit an OpenMP scope. */
194 /* A list of all LABEL_DECLs in the function that have names. Here so
195 we can clear out their names' definitions at the end of the
196 function, and so we can check the validity of jumps to these labels. */
198 struct named_label_entry GTY(())
200 /* The decl itself. */
203 /* The binding level to which the label is *currently* attached.
204 This is initially set to the binding level in which the label
205 is defined, but is modified as scopes are closed. */
206 struct cp_binding_level *binding_level;
207 /* The head of the names list that was current when the label was
208 defined, or the inner scope popped. These are the decls that will
209 be skipped when jumping to the label. */
211 /* A tree list of all decls from all binding levels that would be
212 crossed by a backward branch to the label. */
215 /* A list of uses of the label, before the label is defined. */
216 struct named_label_use_entry *uses;
218 /* The following bits are set after the label is defined, and are
219 updated as scopes are popped. They indicate that a backward jump
220 to the label will illegally enter a scope of the given flavor. */
226 #define named_labels cp_function_chain->x_named_labels
228 /* The number of function bodies which we are currently processing.
229 (Zero if we are at namespace scope, one inside the body of a
230 function, two inside the body of a function in a local class, etc.) */
233 /* States indicating how grokdeclarator() should handle declspecs marked
234 with __attribute__((deprecated)). An object declared as
235 __attribute__((deprecated)) suppresses warnings of uses of other
238 enum deprecated_states {
243 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
245 /* True if a declaration with an `extern' linkage specifier is being
247 bool have_extern_spec;
250 /* A TREE_LIST of VAR_DECLs. The TREE_PURPOSE is a RECORD_TYPE or
251 UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type. At the
252 time the VAR_DECL was declared, the type was incomplete. */
254 static GTY(()) tree incomplete_vars;
256 /* Returns the kind of template specialization we are currently
257 processing, given that it's declaration contained N_CLASS_SCOPES
258 explicit scope qualifications. */
261 current_tmpl_spec_kind (int n_class_scopes)
263 int n_template_parm_scopes = 0;
264 int seen_specialization_p = 0;
265 int innermost_specialization_p = 0;
266 struct cp_binding_level *b;
268 /* Scan through the template parameter scopes. */
269 for (b = current_binding_level;
270 b->kind == sk_template_parms;
273 /* If we see a specialization scope inside a parameter scope,
274 then something is wrong. That corresponds to a declaration
277 template <class T> template <> ...
279 which is always invalid since [temp.expl.spec] forbids the
280 specialization of a class member template if the enclosing
281 class templates are not explicitly specialized as well. */
282 if (b->explicit_spec_p)
284 if (n_template_parm_scopes == 0)
285 innermost_specialization_p = 1;
287 seen_specialization_p = 1;
289 else if (seen_specialization_p == 1)
290 return tsk_invalid_member_spec;
292 ++n_template_parm_scopes;
295 /* Handle explicit instantiations. */
296 if (processing_explicit_instantiation)
298 if (n_template_parm_scopes != 0)
299 /* We've seen a template parameter list during an explicit
300 instantiation. For example:
302 template <class T> template void f(int);
304 This is erroneous. */
305 return tsk_invalid_expl_inst;
307 return tsk_expl_inst;
310 if (n_template_parm_scopes < n_class_scopes)
311 /* We've not seen enough template headers to match all the
312 specialized classes present. For example:
314 template <class T> void R<T>::S<T>::f(int);
316 This is invalid; there needs to be one set of template
317 parameters for each class. */
318 return tsk_insufficient_parms;
319 else if (n_template_parm_scopes == n_class_scopes)
320 /* We're processing a non-template declaration (even though it may
321 be a member of a template class.) For example:
323 template <class T> void S<T>::f(int);
325 The `class T' maches the `S<T>', leaving no template headers
326 corresponding to the `f'. */
328 else if (n_template_parm_scopes > n_class_scopes + 1)
329 /* We've got too many template headers. For example:
331 template <> template <class T> void f (T);
333 There need to be more enclosing classes. */
334 return tsk_excessive_parms;
336 /* This must be a template. It's of the form:
338 template <class T> template <class U> void S<T>::f(U);
340 This is a specialization if the innermost level was a
341 specialization; otherwise it's just a definition of the
343 return innermost_specialization_p ? tsk_expl_spec : tsk_template;
346 /* Exit the current scope. */
354 /* When a label goes out of scope, check to see if that label was used
355 in a valid manner, and issue any appropriate warnings or errors. */
358 pop_label (tree label, tree old_value)
360 if (!processing_template_decl)
362 if (DECL_INITIAL (label) == NULL_TREE)
366 error ("label %q+D used but not defined", label);
367 #ifdef USE_MAPPED_LOCATION
368 location = input_location; /* FIXME want (input_filename, (line)0) */
370 location.file = input_filename;
373 /* Avoid crashing later. */
374 define_label (location, DECL_NAME (label));
376 else if (!TREE_USED (label))
377 warning (OPT_Wunused_label, "label %q+D defined but not used", label);
380 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
383 /* At the end of a function, all labels declared within the function
384 go out of scope. BLOCK is the top-level block for the
388 pop_labels_1 (void **slot, void *data)
390 struct named_label_entry *ent = (struct named_label_entry *) *slot;
391 tree block = (tree) data;
393 pop_label (ent->label_decl, NULL_TREE);
395 /* Put the labels into the "variables" of the top-level block,
396 so debugger can see them. */
397 TREE_CHAIN (ent->label_decl) = BLOCK_VARS (block);
398 BLOCK_VARS (block) = ent->label_decl;
400 htab_clear_slot (named_labels, slot);
406 pop_labels (tree block)
410 htab_traverse (named_labels, pop_labels_1, block);
415 /* At the end of a block with local labels, restore the outer definition. */
418 pop_local_label (tree label, tree old_value)
420 struct named_label_entry dummy;
423 pop_label (label, old_value);
425 dummy.label_decl = label;
426 slot = htab_find_slot (named_labels, &dummy, NO_INSERT);
427 htab_clear_slot (named_labels, slot);
430 /* The following two routines are used to interface to Objective-C++.
431 The binding level is purposely treated as an opaque type. */
434 objc_get_current_scope (void)
436 return current_binding_level;
439 /* The following routine is used by the NeXT-style SJLJ exceptions;
440 variables get marked 'volatile' so as to not be clobbered by
441 _setjmp()/_longjmp() calls. All variables in the current scope,
442 as well as parent scopes up to (but not including) ENCLOSING_BLK
443 shall be thusly marked. */
446 objc_mark_locals_volatile (void *enclosing_blk)
448 struct cp_binding_level *scope;
450 for (scope = current_binding_level;
451 scope && scope != enclosing_blk;
452 scope = scope->level_chain)
456 for (decl = scope->names; decl; decl = TREE_CHAIN (decl))
457 objc_volatilize_decl (decl);
459 /* Do not climb up past the current function. */
460 if (scope->kind == sk_function_parms)
465 /* Update data for defined and undefined labels when leaving a scope. */
468 poplevel_named_label_1 (void **slot, void *data)
470 struct named_label_entry *ent = (struct named_label_entry *) *slot;
471 struct cp_binding_level *bl = (struct cp_binding_level *) data;
472 struct cp_binding_level *obl = bl->level_chain;
474 if (ent->binding_level == bl)
478 for (decl = ent->names_in_scope; decl; decl = TREE_CHAIN (decl))
479 if (decl_jump_unsafe (decl))
480 ent->bad_decls = tree_cons (NULL, decl, ent->bad_decls);
482 ent->binding_level = obl;
483 ent->names_in_scope = obl->names;
487 ent->in_try_scope = true;
490 ent->in_catch_scope = true;
493 ent->in_omp_scope = true;
501 struct named_label_use_entry *use;
503 for (use = ent->uses; use ; use = use->next)
504 if (use->binding_level == bl)
506 use->binding_level = obl;
507 use->names_in_scope = obl->names;
508 if (bl->kind == sk_omp)
509 use->in_omp_scope = true;
516 /* Exit a binding level.
517 Pop the level off, and restore the state of the identifier-decl mappings
518 that were in effect when this level was entered.
520 If KEEP == 1, this level had explicit declarations, so
521 and create a "block" (a BLOCK node) for the level
522 to record its declarations and subblocks for symbol table output.
524 If FUNCTIONBODY is nonzero, this level is the body of a function,
525 so create a block as if KEEP were set and also clear out all
528 If REVERSE is nonzero, reverse the order of decls before putting
529 them into the BLOCK. */
532 poplevel (int keep, int reverse, int functionbody)
535 /* The chain of decls was accumulated in reverse order.
536 Put it into forward order, just for cleanliness. */
538 int tmp = functionbody;
539 int real_functionbody;
543 int leaving_for_scope;
546 timevar_push (TV_NAME_LOOKUP);
551 gcc_assert (current_binding_level->kind != sk_class);
553 real_functionbody = (current_binding_level->kind == sk_cleanup
554 ? ((functionbody = 0), tmp) : functionbody);
555 subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
557 gcc_assert (!VEC_length(cp_class_binding,
558 current_binding_level->class_shadowed));
560 /* We used to use KEEP == 2 to indicate that the new block should go
561 at the beginning of the list of blocks at this binding level,
562 rather than the end. This hack is no longer used. */
563 gcc_assert (keep == 0 || keep == 1);
565 if (current_binding_level->keep)
568 /* Any uses of undefined labels, and any defined labels, now operate
569 under constraints of next binding contour. */
570 if (cfun && !functionbody && named_labels)
571 htab_traverse (named_labels, poplevel_named_label_1,
572 current_binding_level);
574 /* Get the decls in the order they were written.
575 Usually current_binding_level->names is in reverse order.
576 But parameter decls were previously put in forward order. */
579 current_binding_level->names
580 = decls = nreverse (current_binding_level->names);
582 decls = current_binding_level->names;
584 /* If there were any declarations or structure tags in that level,
585 or if this level is a function body,
586 create a BLOCK to record them for the life of this function. */
588 if (keep == 1 || functionbody)
589 block = make_node (BLOCK);
590 if (block != NULL_TREE)
592 BLOCK_VARS (block) = decls;
593 BLOCK_SUBBLOCKS (block) = subblocks;
596 /* In each subblock, record that this is its superior. */
598 for (link = subblocks; link; link = TREE_CHAIN (link))
599 BLOCK_SUPERCONTEXT (link) = block;
601 /* We still support the old for-scope rules, whereby the variables
602 in a for-init statement were in scope after the for-statement
603 ended. We only use the new rules if flag_new_for_scope is
606 = current_binding_level->kind == sk_for && flag_new_for_scope == 1;
608 /* Before we remove the declarations first check for unused variables. */
609 if (warn_unused_variable
610 && !processing_template_decl)
611 for (decl = getdecls (); decl; decl = TREE_CHAIN (decl))
612 if (TREE_CODE (decl) == VAR_DECL
613 && ! TREE_USED (decl)
614 && ! DECL_IN_SYSTEM_HEADER (decl)
615 && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl))
616 warning (OPT_Wunused_variable, "unused variable %q+D", decl);
618 /* Remove declarations for all the DECLs in this level. */
619 for (link = decls; link; link = TREE_CHAIN (link))
621 if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
624 tree name = DECL_NAME (link);
628 ob = outer_binding (name,
629 IDENTIFIER_BINDING (name),
632 ns_binding = IDENTIFIER_NAMESPACE_VALUE (name);
634 ns_binding = NULL_TREE;
636 if (ob && ob->scope == current_binding_level->level_chain)
637 /* We have something like:
642 and we are leaving the `for' scope. There's no reason to
643 keep the binding of the inner `i' in this case. */
644 pop_binding (name, link);
645 else if ((ob && (TREE_CODE (ob->value) == TYPE_DECL))
646 || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL))
647 /* Here, we have something like:
655 We must pop the for-scope binding so we know what's a
656 type and what isn't. */
657 pop_binding (name, link);
660 /* Mark this VAR_DECL as dead so that we can tell we left it
661 there only for backward compatibility. */
662 DECL_DEAD_FOR_LOCAL (link) = 1;
664 /* Keep track of what should have happened when we
665 popped the binding. */
668 SET_DECL_SHADOWED_FOR_VAR (link, ob->value);
669 DECL_HAS_SHADOWED_FOR_VAR_P (link) = 1;
672 /* Add it to the list of dead variables in the next
673 outermost binding to that we can remove these when we
674 leave that binding. */
675 current_binding_level->level_chain->dead_vars_from_for
676 = tree_cons (NULL_TREE, link,
677 current_binding_level->level_chain->
680 /* Although we don't pop the cxx_binding, we do clear
681 its SCOPE since the scope is going away now. */
682 IDENTIFIER_BINDING (name)->scope
683 = current_binding_level->level_chain;
690 /* Remove the binding. */
693 if (TREE_CODE (decl) == TREE_LIST)
694 decl = TREE_VALUE (decl);
697 if (TREE_CODE (name) == OVERLOAD)
698 name = OVL_FUNCTION (name);
700 gcc_assert (DECL_P (name));
701 pop_binding (DECL_NAME (name), decl);
705 /* Remove declarations for any `for' variables from inner scopes
706 that we kept around. */
707 for (link = current_binding_level->dead_vars_from_for;
708 link; link = TREE_CHAIN (link))
709 pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
711 /* Restore the IDENTIFIER_TYPE_VALUEs. */
712 for (link = current_binding_level->type_shadowed;
713 link; link = TREE_CHAIN (link))
714 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
716 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
717 for (link = current_binding_level->shadowed_labels;
719 link = TREE_CHAIN (link))
720 pop_local_label (TREE_VALUE (link), TREE_PURPOSE (link));
722 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
723 list if a `using' declaration put them there. The debugging
724 back-ends won't understand OVERLOAD, so we remove them here.
725 Because the BLOCK_VARS are (temporarily) shared with
726 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
727 popped all the bindings. */
732 for (d = &BLOCK_VARS (block); *d; )
734 if (TREE_CODE (*d) == TREE_LIST)
735 *d = TREE_CHAIN (*d);
737 d = &TREE_CHAIN (*d);
741 /* If the level being exited is the top level of a function,
742 check over all the labels. */
745 /* Since this is the top level block of a function, the vars are
746 the function's parameters. Don't leave them in the BLOCK
747 because they are found in the FUNCTION_DECL instead. */
748 BLOCK_VARS (block) = 0;
752 kind = current_binding_level->kind;
753 if (kind == sk_cleanup)
757 /* If this is a temporary binding created for a cleanup, then we'll
758 have pushed a statement list level. Pop that, create a new
759 BIND_EXPR for the block, and insert it into the stream. */
760 stmt = pop_stmt_list (current_binding_level->statement_list);
761 stmt = c_build_bind_expr (block, stmt);
767 DECL_INITIAL (current_function_decl) = block;
769 current_binding_level->blocks
770 = chainon (current_binding_level->blocks, block);
772 /* If we did not make a block for the level just exited,
773 any blocks made for inner levels
774 (since they cannot be recorded as subblocks in that level)
775 must be carried forward so they will later become subblocks
776 of something else. */
778 current_binding_level->blocks
779 = chainon (current_binding_level->blocks, subblocks);
781 /* Each and every BLOCK node created here in `poplevel' is important
782 (e.g. for proper debugging information) so if we created one
783 earlier, mark it as "used". */
785 TREE_USED (block) = 1;
787 /* All temporary bindings created for cleanups are popped silently. */
788 if (kind == sk_cleanup)
791 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, block);
794 /* Insert BLOCK at the end of the list of subblocks of the
795 current binding level. This is used when a BIND_EXPR is expanded,
796 to handle the BLOCK node inside the BIND_EXPR. */
799 insert_block (tree block)
801 TREE_USED (block) = 1;
802 current_binding_level->blocks
803 = chainon (current_binding_level->blocks, block);
806 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
807 itself, calling F for each. The DATA is passed to F as well. */
810 walk_namespaces_r (tree namespace, walk_namespaces_fn f, void* data)
813 tree current = NAMESPACE_LEVEL (namespace)->namespaces;
815 result |= (*f) (namespace, data);
817 for (; current; current = TREE_CHAIN (current))
818 result |= walk_namespaces_r (current, f, data);
823 /* Walk all the namespaces, calling F for each. The DATA is passed to
827 walk_namespaces (walk_namespaces_fn f, void* data)
829 return walk_namespaces_r (global_namespace, f, data);
832 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
833 DATA is non-NULL, this is the last time we will call
834 wrapup_global_declarations for this NAMESPACE. */
837 wrapup_globals_for_namespace (tree namespace, void* data)
839 struct cp_binding_level *level = NAMESPACE_LEVEL (namespace);
840 VEC(tree,gc) *statics = level->static_decls;
841 tree *vec = VEC_address (tree, statics);
842 int len = VEC_length (tree, statics);
843 int last_time = (data != 0);
847 check_global_declarations (vec, len);
848 emit_debug_global_declarations (vec, len);
852 /* Write out any globals that need to be output. */
853 return wrapup_global_declarations (vec, len);
857 /* In C++, you don't have to write `struct S' to refer to `S'; you
858 can just use `S'. We accomplish this by creating a TYPE_DECL as
859 if the user had written `typedef struct S S'. Create and return
860 the TYPE_DECL for TYPE. */
863 create_implicit_typedef (tree name, tree type)
867 decl = build_decl (TYPE_DECL, name, type);
868 DECL_ARTIFICIAL (decl) = 1;
869 /* There are other implicit type declarations, like the one *within*
870 a class that allows you to write `S::S'. We must distinguish
872 SET_DECL_IMPLICIT_TYPEDEF_P (decl);
873 TYPE_NAME (type) = decl;
878 /* Remember a local name for name-mangling purposes. */
881 push_local_name (tree decl)
886 timevar_push (TV_NAME_LOOKUP);
888 name = DECL_NAME (decl);
890 nelts = VEC_length (tree, local_names);
891 for (i = 0; i < nelts; i++)
893 t = VEC_index (tree, local_names, i);
894 if (DECL_NAME (t) == name)
896 if (!DECL_LANG_SPECIFIC (decl))
897 retrofit_lang_decl (decl);
898 DECL_LANG_SPECIFIC (decl)->decl_flags.u2sel = 1;
899 if (DECL_LANG_SPECIFIC (t))
900 DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
902 DECL_DISCRIMINATOR (decl) = 1;
904 VEC_replace (tree, local_names, i, decl);
905 timevar_pop (TV_NAME_LOOKUP);
910 VEC_safe_push (tree, gc, local_names, decl);
911 timevar_pop (TV_NAME_LOOKUP);
914 /* Subroutine of duplicate_decls: return truthvalue of whether
915 or not types of these decls match.
917 For C++, we must compare the parameter list so that `int' can match
918 `int&' in a parameter position, but `int&' is not confused with
922 decls_match (tree newdecl, tree olddecl)
926 if (newdecl == olddecl)
929 if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
930 /* If the two DECLs are not even the same kind of thing, we're not
931 interested in their types. */
934 if (TREE_CODE (newdecl) == FUNCTION_DECL)
936 tree f1 = TREE_TYPE (newdecl);
937 tree f2 = TREE_TYPE (olddecl);
938 tree p1 = TYPE_ARG_TYPES (f1);
939 tree p2 = TYPE_ARG_TYPES (f2);
941 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
942 && ! (DECL_EXTERN_C_P (newdecl)
943 && DECL_EXTERN_C_P (olddecl)))
946 if (TREE_CODE (f1) != TREE_CODE (f2))
949 if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
951 if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
952 && (DECL_BUILT_IN (olddecl)
953 #ifndef NO_IMPLICIT_EXTERN_C
954 || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
955 || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
959 types_match = self_promoting_args_p (p1);
960 if (p1 == void_list_node)
961 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
963 #ifndef NO_IMPLICIT_EXTERN_C
964 else if (p1 == NULL_TREE
965 && (DECL_EXTERN_C_P (olddecl)
966 && DECL_IN_SYSTEM_HEADER (olddecl)
967 && !DECL_CLASS_SCOPE_P (olddecl))
968 && (DECL_EXTERN_C_P (newdecl)
969 && DECL_IN_SYSTEM_HEADER (newdecl)
970 && !DECL_CLASS_SCOPE_P (newdecl)))
972 types_match = self_promoting_args_p (p2);
973 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
977 types_match = compparms (p1, p2);
982 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
984 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
985 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
988 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
989 DECL_TEMPLATE_PARMS (olddecl)))
992 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
993 types_match = same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)),
994 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl)));
996 types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
997 DECL_TEMPLATE_RESULT (newdecl));
1001 /* Need to check scope for variable declaration (VAR_DECL).
1002 For typedef (TYPE_DECL), scope is ignored. */
1003 if (TREE_CODE (newdecl) == VAR_DECL
1004 && CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
1007 if (TREE_TYPE (newdecl) == error_mark_node)
1008 types_match = TREE_TYPE (olddecl) == error_mark_node;
1009 else if (TREE_TYPE (olddecl) == NULL_TREE)
1010 types_match = TREE_TYPE (newdecl) == NULL_TREE;
1011 else if (TREE_TYPE (newdecl) == NULL_TREE)
1014 types_match = comptypes (TREE_TYPE (newdecl),
1015 TREE_TYPE (olddecl),
1016 COMPARE_REDECLARATION);
1022 /* If NEWDECL is `static' and an `extern' was seen previously,
1023 warn about it. OLDDECL is the previous declaration.
1025 Note that this does not apply to the C++ case of declaring
1026 a variable `extern const' and then later `const'.
1028 Don't complain about built-in functions, since they are beyond
1029 the user's control. */
1032 warn_extern_redeclared_static (tree newdecl, tree olddecl)
1036 if (TREE_CODE (newdecl) == TYPE_DECL
1037 || TREE_CODE (newdecl) == TEMPLATE_DECL
1038 || TREE_CODE (newdecl) == CONST_DECL
1039 || TREE_CODE (newdecl) == NAMESPACE_DECL)
1042 /* Don't get confused by static member functions; that's a different
1044 if (TREE_CODE (newdecl) == FUNCTION_DECL
1045 && DECL_STATIC_FUNCTION_P (newdecl))
1048 /* If the old declaration was `static', or the new one isn't, then
1049 then everything is OK. */
1050 if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
1053 /* It's OK to declare a builtin function as `static'. */
1054 if (TREE_CODE (olddecl) == FUNCTION_DECL
1055 && DECL_ARTIFICIAL (olddecl))
1058 name = DECL_ASSEMBLER_NAME (newdecl);
1059 pedwarn ("%qD was declared %<extern%> and later %<static%>", newdecl);
1060 pedwarn ("previous declaration of %q+D", olddecl);
1063 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1064 function templates. If their exception specifications do not
1065 match, issue an a diagnostic. */
1068 check_redeclaration_exception_specification (tree new_decl,
1073 tree new_exceptions;
1074 tree old_exceptions;
1076 new_type = TREE_TYPE (new_decl);
1077 new_exceptions = TYPE_RAISES_EXCEPTIONS (new_type);
1078 old_type = TREE_TYPE (old_decl);
1079 old_exceptions = TYPE_RAISES_EXCEPTIONS (old_type);
1083 If any declaration of a function has an exception-specification,
1084 all declarations, including the definition and an explicit
1085 specialization, of that function shall have an
1086 exception-specification with the same set of type-ids. */
1087 if ((pedantic || ! DECL_IN_SYSTEM_HEADER (old_decl))
1088 && ! DECL_IS_BUILTIN (old_decl)
1090 && !comp_except_specs (new_exceptions, old_exceptions,
1093 error ("declaration of %qF throws different exceptions", new_decl);
1094 error ("from previous declaration %q+F", old_decl);
1098 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1099 If the redeclaration is invalid, a diagnostic is issued, and the
1100 error_mark_node is returned. Otherwise, OLDDECL is returned.
1102 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1105 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1108 duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend)
1110 unsigned olddecl_uid = DECL_UID (olddecl);
1111 int olddecl_friend = 0, types_match = 0, hidden_friend = 0;
1112 int new_defines_function = 0;
1115 if (newdecl == olddecl)
1118 types_match = decls_match (newdecl, olddecl);
1120 /* If either the type of the new decl or the type of the old decl is an
1121 error_mark_node, then that implies that we have already issued an
1122 error (earlier) for some bogus type specification, and in that case,
1123 it is rather pointless to harass the user with yet more error message
1124 about the same declaration, so just pretend the types match here. */
1125 if (TREE_TYPE (newdecl) == error_mark_node
1126 || TREE_TYPE (olddecl) == error_mark_node)
1129 if (DECL_P (olddecl)
1130 && TREE_CODE (newdecl) == FUNCTION_DECL
1131 && TREE_CODE (olddecl) == FUNCTION_DECL
1132 && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
1134 if (DECL_DECLARED_INLINE_P (newdecl)
1135 && DECL_UNINLINABLE (newdecl)
1136 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1137 /* Already warned elsewhere. */;
1138 else if (DECL_DECLARED_INLINE_P (olddecl)
1139 && DECL_UNINLINABLE (olddecl)
1140 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1141 /* Already warned. */;
1142 else if (DECL_DECLARED_INLINE_P (newdecl)
1143 && DECL_UNINLINABLE (olddecl)
1144 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1146 warning (OPT_Wattributes, "function %q+D redeclared as inline",
1148 warning (OPT_Wattributes, "previous declaration of %q+D "
1149 "with attribute noinline", olddecl);
1151 else if (DECL_DECLARED_INLINE_P (olddecl)
1152 && DECL_UNINLINABLE (newdecl)
1153 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1155 warning (OPT_Wattributes, "function %q+D redeclared with "
1156 "attribute noinline", newdecl);
1157 warning (OPT_Wattributes, "previous declaration of %q+D was inline",
1162 /* Check for redeclaration and other discrepancies. */
1163 if (TREE_CODE (olddecl) == FUNCTION_DECL
1164 && DECL_ARTIFICIAL (olddecl))
1166 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl));
1167 if (TREE_CODE (newdecl) != FUNCTION_DECL)
1169 /* Avoid warnings redeclaring built-ins which have not been
1170 explicitly declared. */
1171 if (DECL_ANTICIPATED (olddecl))
1174 /* If you declare a built-in or predefined function name as static,
1175 the old definition is overridden, but optionally warn this was a
1176 bad choice of name. */
1177 if (! TREE_PUBLIC (newdecl))
1179 warning (OPT_Wshadow, "shadowing %s function %q#D",
1180 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
1182 /* Discard the old built-in function. */
1185 /* If the built-in is not ansi, then programs can override
1186 it even globally without an error. */
1187 else if (! DECL_BUILT_IN (olddecl))
1188 warning (0, "library function %q#D redeclared as non-function %q#D",
1192 error ("declaration of %q#D", newdecl);
1193 error ("conflicts with built-in declaration %q#D",
1198 else if (!types_match)
1200 /* Avoid warnings redeclaring built-ins which have not been
1201 explicitly declared. */
1202 if (DECL_ANTICIPATED (olddecl))
1204 /* Deal with fileptr_type_node. FILE type is not known
1205 at the time we create the builtins. */
1208 for (t1 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1209 t2 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1211 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1214 else if (TREE_VALUE (t2) == fileptr_type_node)
1216 tree t = TREE_VALUE (t1);
1218 if (TREE_CODE (t) == POINTER_TYPE
1219 && TYPE_NAME (TREE_TYPE (t))
1220 && DECL_NAME (TYPE_NAME (TREE_TYPE (t)))
1221 == get_identifier ("FILE")
1222 && compparms (TREE_CHAIN (t1), TREE_CHAIN (t2)))
1224 tree oldargs = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1226 TYPE_ARG_TYPES (TREE_TYPE (olddecl))
1227 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1228 types_match = decls_match (newdecl, olddecl);
1230 return duplicate_decls (newdecl, olddecl,
1232 TYPE_ARG_TYPES (TREE_TYPE (olddecl)) = oldargs;
1235 else if (! same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1238 else if ((DECL_EXTERN_C_P (newdecl)
1239 && DECL_EXTERN_C_P (olddecl))
1240 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1241 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1243 /* A near match; override the builtin. */
1245 if (TREE_PUBLIC (newdecl))
1247 warning (0, "new declaration %q#D", newdecl);
1248 warning (0, "ambiguates built-in declaration %q#D",
1252 warning (OPT_Wshadow, "shadowing %s function %q#D",
1253 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
1257 /* Discard the old built-in function. */
1260 /* Replace the old RTL to avoid problems with inlining. */
1261 COPY_DECL_RTL (newdecl, olddecl);
1263 /* Even if the types match, prefer the new declarations type for
1264 built-ins which have not been explicitly declared, for
1265 exception lists, etc... */
1266 else if (DECL_ANTICIPATED (olddecl))
1268 tree type = TREE_TYPE (newdecl);
1269 tree attribs = (*targetm.merge_type_attributes)
1270 (TREE_TYPE (olddecl), type);
1272 type = cp_build_type_attribute_variant (type, attribs);
1273 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = type;
1276 /* Whether or not the builtin can throw exceptions has no
1277 bearing on this declarator. */
1278 TREE_NOTHROW (olddecl) = 0;
1280 if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
1282 /* If a builtin function is redeclared as `static', merge
1283 the declarations, but make the original one static. */
1284 DECL_THIS_STATIC (olddecl) = 1;
1285 TREE_PUBLIC (olddecl) = 0;
1287 /* Make the old declaration consistent with the new one so
1288 that all remnants of the builtin-ness of this function
1289 will be banished. */
1290 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1291 COPY_DECL_RTL (newdecl, olddecl);
1294 else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1296 if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
1297 && TREE_CODE (newdecl) != TYPE_DECL
1298 && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
1299 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
1300 || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
1301 && TREE_CODE (olddecl) != TYPE_DECL
1302 && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
1303 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
1306 /* We do nothing special here, because C++ does such nasty
1307 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1308 get shadowed, and know that if we need to find a TYPE_DECL
1309 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1310 slot of the identifier. */
1314 if ((TREE_CODE (newdecl) == FUNCTION_DECL
1315 && DECL_FUNCTION_TEMPLATE_P (olddecl))
1316 || (TREE_CODE (olddecl) == FUNCTION_DECL
1317 && DECL_FUNCTION_TEMPLATE_P (newdecl)))
1320 error ("%q#D redeclared as different kind of symbol", newdecl);
1321 if (TREE_CODE (olddecl) == TREE_LIST)
1322 olddecl = TREE_VALUE (olddecl);
1323 error ("previous declaration of %q+#D", olddecl);
1325 return error_mark_node;
1327 else if (!types_match)
1329 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
1330 /* These are certainly not duplicate declarations; they're
1331 from different scopes. */
1334 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1336 /* The name of a class template may not be declared to refer to
1337 any other template, class, function, object, namespace, value,
1338 or type in the same scope. */
1339 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
1340 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1342 error ("declaration of template %q#D", newdecl);
1343 error ("conflicts with previous declaration %q+#D", olddecl);
1345 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
1346 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
1347 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
1348 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
1349 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1350 DECL_TEMPLATE_PARMS (olddecl))
1351 /* Template functions can be disambiguated by
1353 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
1354 TREE_TYPE (TREE_TYPE (olddecl))))
1356 error ("new declaration %q#D", newdecl);
1357 error ("ambiguates old declaration %q+#D", olddecl);
1361 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1363 if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
1365 error ("declaration of C function %q#D conflicts with",
1367 error ("previous declaration %q+#D here", olddecl);
1369 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1370 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1372 error ("new declaration %q#D", newdecl);
1373 error ("ambiguates old declaration %q+#D", olddecl);
1380 error ("conflicting declaration %q#D", newdecl);
1381 error ("%q+D has a previous declaration as %q#D", olddecl, olddecl);
1382 return error_mark_node;
1385 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1386 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
1387 && (!DECL_TEMPLATE_INFO (newdecl)
1388 || (DECL_TI_TEMPLATE (newdecl)
1389 != DECL_TI_TEMPLATE (olddecl))))
1390 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
1391 && (!DECL_TEMPLATE_INFO (olddecl)
1392 || (DECL_TI_TEMPLATE (olddecl)
1393 != DECL_TI_TEMPLATE (newdecl))))))
1394 /* It's OK to have a template specialization and a non-template
1395 with the same type, or to have specializations of two
1396 different templates with the same type. Note that if one is a
1397 specialization, and the other is an instantiation of the same
1398 template, that we do not exit at this point. That situation
1399 can occur if we instantiate a template class, and then
1400 specialize one of its methods. This situation is valid, but
1401 the declarations must be merged in the usual way. */
1403 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1404 && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
1405 && !DECL_USE_TEMPLATE (newdecl))
1406 || (DECL_TEMPLATE_INSTANTIATION (newdecl)
1407 && !DECL_USE_TEMPLATE (olddecl))))
1408 /* One of the declarations is a template instantiation, and the
1409 other is not a template at all. That's OK. */
1411 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1413 /* In [namespace.alias] we have:
1415 In a declarative region, a namespace-alias-definition can be
1416 used to redefine a namespace-alias declared in that declarative
1417 region to refer only to the namespace to which it already
1420 Therefore, if we encounter a second alias directive for the same
1421 alias, we can just ignore the second directive. */
1422 if (DECL_NAMESPACE_ALIAS (newdecl)
1423 && (DECL_NAMESPACE_ALIAS (newdecl)
1424 == DECL_NAMESPACE_ALIAS (olddecl)))
1426 /* [namespace.alias]
1428 A namespace-name or namespace-alias shall not be declared as
1429 the name of any other entity in the same declarative region.
1430 A namespace-name defined at global scope shall not be
1431 declared as the name of any other entity in any global scope
1433 error ("declaration of namespace %qD conflicts with", newdecl);
1434 error ("previous declaration of namespace %q+D here", olddecl);
1435 return error_mark_node;
1439 const char *errmsg = redeclaration_error_message (newdecl, olddecl);
1442 error (errmsg, newdecl);
1443 if (DECL_NAME (olddecl) != NULL_TREE)
1444 error ((DECL_INITIAL (olddecl) && namespace_bindings_p ())
1445 ? "%q+#D previously defined here"
1446 : "%q+#D previously declared here", olddecl);
1447 return error_mark_node;
1449 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1450 && DECL_INITIAL (olddecl) != NULL_TREE
1451 && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
1452 && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
1454 /* Prototype decl follows defn w/o prototype. */
1455 warning (0, "prototype for %q+#D", newdecl);
1456 warning (0, "%Jfollows non-prototype definition here", olddecl);
1458 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1459 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
1461 /* extern "C" int foo ();
1462 int foo () { bar (); }
1464 if (current_lang_depth () == 0)
1465 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1468 error ("previous declaration of %q+#D with %qL linkage",
1469 olddecl, DECL_LANGUAGE (olddecl));
1470 error ("conflicts with new declaration with %qL linkage",
1471 DECL_LANGUAGE (newdecl));
1475 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
1477 else if (TREE_CODE (olddecl) == FUNCTION_DECL)
1479 tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1480 tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1483 if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
1484 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
1486 for (; t1 && t1 != void_list_node;
1487 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
1488 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
1490 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
1493 pedwarn ("default argument given for parameter %d of %q#D",
1495 pedwarn ("after previous specification in %q+#D", olddecl);
1499 error ("default argument given for parameter %d of %q#D",
1501 error ("after previous specification in %q+#D",
1506 if (DECL_DECLARED_INLINE_P (newdecl)
1507 && ! DECL_DECLARED_INLINE_P (olddecl)
1508 && TREE_ADDRESSABLE (olddecl) && warn_inline)
1510 warning (0, "%q#D was used before it was declared inline", newdecl);
1511 warning (0, "%Jprevious non-inline declaration here", olddecl);
1516 /* Do not merge an implicit typedef with an explicit one. In:
1520 typedef class A A __attribute__ ((foo));
1522 the attribute should apply only to the typedef. */
1523 if (TREE_CODE (olddecl) == TYPE_DECL
1524 && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
1525 || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
1528 /* If new decl is `static' and an `extern' was seen previously,
1530 warn_extern_redeclared_static (newdecl, olddecl);
1532 /* We have committed to returning 1 at this point. */
1533 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1535 /* Now that functions must hold information normally held
1536 by field decls, there is extra work to do so that
1537 declaration information does not get destroyed during
1539 if (DECL_VINDEX (olddecl))
1540 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
1541 if (DECL_CONTEXT (olddecl))
1542 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1543 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
1544 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1545 DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
1546 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
1547 DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
1548 if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
1549 SET_OVERLOADED_OPERATOR_CODE
1550 (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
1551 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
1553 /* Optionally warn about more than one declaration for the same
1554 name, but don't warn about a function declaration followed by a
1556 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
1557 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
1558 /* Don't warn about extern decl followed by definition. */
1559 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
1560 /* Don't warn about friends, let add_friend take care of it. */
1561 && ! (newdecl_is_friend || DECL_FRIEND_P (olddecl)))
1563 warning (OPT_Wredundant_decls, "redundant redeclaration of %qD in same scope", newdecl);
1564 warning (OPT_Wredundant_decls, "previous declaration of %q+D", olddecl);
1568 /* Deal with C++: must preserve virtual function table size. */
1569 if (TREE_CODE (olddecl) == TYPE_DECL)
1571 tree newtype = TREE_TYPE (newdecl);
1572 tree oldtype = TREE_TYPE (olddecl);
1574 if (newtype != error_mark_node && oldtype != error_mark_node
1575 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
1576 CLASSTYPE_FRIEND_CLASSES (newtype)
1577 = CLASSTYPE_FRIEND_CLASSES (oldtype);
1579 DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
1582 /* Copy all the DECL_... slots specified in the new decl
1583 except for any that we copy here from the old type. */
1584 DECL_ATTRIBUTES (newdecl)
1585 = (*targetm.merge_decl_attributes) (olddecl, newdecl);
1587 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1591 old_result = DECL_TEMPLATE_RESULT (olddecl);
1592 new_result = DECL_TEMPLATE_RESULT (newdecl);
1593 TREE_TYPE (olddecl) = TREE_TYPE (old_result);
1594 DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
1595 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
1596 DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
1598 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1600 DECL_INLINE (old_result)
1601 |= DECL_INLINE (new_result);
1602 DECL_DECLARED_INLINE_P (old_result)
1603 |= DECL_DECLARED_INLINE_P (new_result);
1604 check_redeclaration_exception_specification (newdecl, olddecl);
1607 /* If the new declaration is a definition, update the file and
1608 line information on the declaration. */
1609 if (DECL_INITIAL (old_result) == NULL_TREE
1610 && DECL_INITIAL (new_result) != NULL_TREE)
1612 DECL_SOURCE_LOCATION (olddecl)
1613 = DECL_SOURCE_LOCATION (old_result)
1614 = DECL_SOURCE_LOCATION (newdecl);
1615 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1616 DECL_ARGUMENTS (old_result)
1617 = DECL_ARGUMENTS (new_result);
1625 /* Automatically handles default parameters. */
1626 tree oldtype = TREE_TYPE (olddecl);
1629 /* Merge the data types specified in the two decls. */
1630 newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1632 /* If merge_types produces a non-typedef type, just use the old type. */
1633 if (TREE_CODE (newdecl) == TYPE_DECL
1634 && newtype == DECL_ORIGINAL_TYPE (newdecl))
1637 if (TREE_CODE (newdecl) == VAR_DECL)
1639 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
1640 DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
1641 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl)
1642 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl);
1643 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl)
1644 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl);
1646 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
1647 if (DECL_LANG_SPECIFIC (olddecl)
1648 && CP_DECL_THREADPRIVATE_P (olddecl))
1650 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
1651 if (!DECL_LANG_SPECIFIC (newdecl))
1652 retrofit_lang_decl (newdecl);
1654 DECL_TLS_MODEL (newdecl) = DECL_TLS_MODEL (olddecl);
1655 CP_DECL_THREADPRIVATE_P (newdecl) = 1;
1659 /* Do this after calling `merge_types' so that default
1660 parameters don't confuse us. */
1661 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1662 check_redeclaration_exception_specification (newdecl, olddecl);
1663 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
1665 /* Lay the type out, unless already done. */
1666 if (! same_type_p (newtype, oldtype)
1667 && TREE_TYPE (newdecl) != error_mark_node
1668 && !(processing_template_decl && uses_template_parms (newdecl)))
1669 layout_type (TREE_TYPE (newdecl));
1671 if ((TREE_CODE (newdecl) == VAR_DECL
1672 || TREE_CODE (newdecl) == PARM_DECL
1673 || TREE_CODE (newdecl) == RESULT_DECL
1674 || TREE_CODE (newdecl) == FIELD_DECL
1675 || TREE_CODE (newdecl) == TYPE_DECL)
1676 && !(processing_template_decl && uses_template_parms (newdecl)))
1677 layout_decl (newdecl, 0);
1679 /* Merge the type qualifiers. */
1680 if (TREE_READONLY (newdecl))
1681 TREE_READONLY (olddecl) = 1;
1682 if (TREE_THIS_VOLATILE (newdecl))
1683 TREE_THIS_VOLATILE (olddecl) = 1;
1684 if (TREE_NOTHROW (newdecl))
1685 TREE_NOTHROW (olddecl) = 1;
1687 /* Merge deprecatedness. */
1688 if (TREE_DEPRECATED (newdecl))
1689 TREE_DEPRECATED (olddecl) = 1;
1691 /* Merge the initialization information. */
1692 if (DECL_INITIAL (newdecl) == NULL_TREE
1693 && DECL_INITIAL (olddecl) != NULL_TREE)
1695 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1696 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
1697 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
1698 && DECL_LANG_SPECIFIC (newdecl)
1699 && DECL_LANG_SPECIFIC (olddecl))
1701 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1702 DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
1706 /* Merge the section attribute.
1707 We want to issue an error if the sections conflict but that must be
1708 done later in decl_attributes since we are called before attributes
1710 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1711 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1713 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1715 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1716 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1717 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1718 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1719 TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
1720 TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl);
1721 DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
1722 DECL_IS_PURE (newdecl) |= DECL_IS_PURE (olddecl);
1723 /* Keep the old RTL. */
1724 COPY_DECL_RTL (olddecl, newdecl);
1726 else if (TREE_CODE (newdecl) == VAR_DECL
1727 && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
1729 /* Keep the old RTL. We cannot keep the old RTL if the old
1730 declaration was for an incomplete object and the new
1731 declaration is not since many attributes of the RTL will
1733 COPY_DECL_RTL (olddecl, newdecl);
1736 /* If cannot merge, then use the new type and qualifiers,
1737 and don't preserve the old rtl. */
1740 /* Clean out any memory we had of the old declaration. */
1741 tree oldstatic = value_member (olddecl, static_aggregates);
1743 TREE_VALUE (oldstatic) = error_mark_node;
1745 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1746 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1747 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1748 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1751 /* Merge the storage class information. */
1752 merge_weak (newdecl, olddecl);
1754 DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
1755 DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
1756 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1757 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
1758 if (! DECL_EXTERNAL (olddecl))
1759 DECL_EXTERNAL (newdecl) = 0;
1761 new_template = NULL_TREE;
1762 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
1764 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
1765 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
1766 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
1767 DECL_TEMPLATE_INSTANTIATED (newdecl)
1768 |= DECL_TEMPLATE_INSTANTIATED (olddecl);
1770 /* If the OLDDECL is an instantiation and/or specialization,
1771 then the NEWDECL must be too. But, it may not yet be marked
1772 as such if the caller has created NEWDECL, but has not yet
1773 figured out that it is a redeclaration. */
1774 if (!DECL_USE_TEMPLATE (newdecl))
1775 DECL_USE_TEMPLATE (newdecl) = DECL_USE_TEMPLATE (olddecl);
1777 /* Don't really know how much of the language-specific
1778 values we should copy from old to new. */
1779 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
1780 DECL_LANG_SPECIFIC (newdecl)->decl_flags.u2 =
1781 DECL_LANG_SPECIFIC (olddecl)->decl_flags.u2;
1782 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
1783 DECL_REPO_AVAILABLE_P (newdecl) = DECL_REPO_AVAILABLE_P (olddecl);
1784 if (DECL_TEMPLATE_INFO (newdecl))
1785 new_template = DECL_TI_TEMPLATE (newdecl);
1786 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
1787 DECL_INITIALIZED_IN_CLASS_P (newdecl)
1788 |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
1789 olddecl_friend = DECL_FRIEND_P (olddecl);
1790 hidden_friend = (DECL_ANTICIPATED (olddecl)
1791 && DECL_HIDDEN_FRIEND_P (olddecl)
1792 && newdecl_is_friend);
1794 /* Only functions have DECL_BEFRIENDING_CLASSES. */
1795 if (TREE_CODE (newdecl) == FUNCTION_DECL
1796 || DECL_FUNCTION_TEMPLATE_P (newdecl))
1798 DECL_BEFRIENDING_CLASSES (newdecl)
1799 = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
1800 DECL_BEFRIENDING_CLASSES (olddecl));
1801 /* DECL_THUNKS is only valid for virtual functions,
1802 otherwise it is a DECL_FRIEND_CONTEXT. */
1803 if (DECL_VIRTUAL_P (newdecl))
1804 DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl);
1808 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1810 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
1811 && !DECL_TEMPLATE_INSTANTIATION (newdecl))
1813 /* If newdecl is not a specialization, then it is not a
1814 template-related function at all. And that means that we
1815 should have exited above, returning 0. */
1816 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl));
1818 if (TREE_USED (olddecl))
1819 /* From [temp.expl.spec]:
1821 If a template, a member template or the member of a class
1822 template is explicitly specialized then that
1823 specialization shall be declared before the first use of
1824 that specialization that would cause an implicit
1825 instantiation to take place, in every translation unit in
1826 which such a use occurs. */
1827 error ("explicit specialization of %qD after first use",
1830 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
1832 /* [temp.expl.spec/14] We don't inline explicit specialization
1833 just because the primary template says so. */
1837 if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
1838 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
1840 DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
1842 /* If either decl says `inline', this fn is inline, unless
1843 its definition was passed already. */
1844 if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
1845 DECL_INLINE (olddecl) = 1;
1846 DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
1848 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
1849 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
1852 /* Preserve abstractness on cloned [cd]tors. */
1853 DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
1857 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1858 COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
1859 COPY_DECL_RTL (newdecl, olddecl);
1861 if (! types_match || new_defines_function)
1863 /* These need to be copied so that the names are available.
1864 Note that if the types do match, we'll preserve inline
1865 info and other bits, but if not, we won't. */
1866 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
1867 DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
1869 if (new_defines_function)
1870 /* If defining a function declared with other language
1871 linkage, use the previously declared language linkage. */
1872 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1873 else if (types_match)
1875 /* If redeclaring a builtin function, and not a definition,
1876 it stays built in. */
1877 if (DECL_BUILT_IN (olddecl))
1879 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
1880 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
1881 /* If we're keeping the built-in definition, keep the rtl,
1882 regardless of declaration matches. */
1883 COPY_DECL_RTL (olddecl, newdecl);
1886 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
1887 /* Don't clear out the arguments if we're redefining a function. */
1888 if (DECL_ARGUMENTS (olddecl))
1889 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
1892 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1893 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
1895 /* Now preserve various other info from the definition. */
1896 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
1897 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
1898 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
1899 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
1901 /* Warn about conflicting visibility specifications. */
1902 if (DECL_VISIBILITY_SPECIFIED (olddecl)
1903 && DECL_VISIBILITY_SPECIFIED (newdecl)
1904 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
1906 warning (OPT_Wattributes, "%q+D: visibility attribute ignored "
1907 "because it", newdecl);
1908 warning (OPT_Wattributes, "%Jconflicts with previous "
1909 "declaration here", olddecl);
1911 /* Choose the declaration which specified visibility. */
1912 if (DECL_VISIBILITY_SPECIFIED (olddecl))
1914 DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
1915 DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
1917 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
1918 so keep this behavior. */
1919 if (TREE_CODE (newdecl) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (newdecl))
1921 SET_DECL_INIT_PRIORITY (olddecl, DECL_INIT_PRIORITY (newdecl));
1922 DECL_HAS_INIT_PRIORITY_P (olddecl) = 1;
1925 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
1926 with that from NEWDECL below. */
1927 if (DECL_LANG_SPECIFIC (olddecl))
1929 gcc_assert (DECL_LANG_SPECIFIC (olddecl)
1930 != DECL_LANG_SPECIFIC (newdecl));
1931 ggc_free (DECL_LANG_SPECIFIC (olddecl));
1934 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1938 function_size = sizeof (struct tree_decl_common);
1940 memcpy ((char *) olddecl + sizeof (struct tree_common),
1941 (char *) newdecl + sizeof (struct tree_common),
1942 function_size - sizeof (struct tree_common));
1944 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
1945 (char *) newdecl + sizeof (struct tree_decl_common),
1946 sizeof (struct tree_function_decl) - sizeof (struct tree_decl_common));
1948 /* If newdecl is a template instantiation, it is possible that
1949 the following sequence of events has occurred:
1951 o A friend function was declared in a class template. The
1952 class template was instantiated.
1954 o The instantiation of the friend declaration was
1955 recorded on the instantiation list, and is newdecl.
1957 o Later, however, instantiate_class_template called pushdecl
1958 on the newdecl to perform name injection. But, pushdecl in
1959 turn called duplicate_decls when it discovered that another
1960 declaration of a global function with the same name already
1963 o Here, in duplicate_decls, we decided to clobber newdecl.
1965 If we're going to do that, we'd better make sure that
1966 olddecl, and not newdecl, is on the list of
1967 instantiations so that if we try to do the instantiation
1968 again we won't get the clobbered declaration. */
1969 reregister_specialization (newdecl,
1975 size_t size = tree_code_size (TREE_CODE (olddecl));
1976 memcpy ((char *) olddecl + sizeof (struct tree_common),
1977 (char *) newdecl + sizeof (struct tree_common),
1978 sizeof (struct tree_decl_common) - sizeof (struct tree_common));
1979 switch (TREE_CODE (olddecl))
1989 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
1990 (char *) newdecl + sizeof (struct tree_decl_common),
1991 size - sizeof (struct tree_decl_common)
1992 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
1996 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
1997 (char *) newdecl + sizeof (struct tree_decl_common),
1998 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common)
1999 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2003 DECL_UID (olddecl) = olddecl_uid;
2005 DECL_FRIEND_P (olddecl) = 1;
2008 DECL_ANTICIPATED (olddecl) = 1;
2009 DECL_HIDDEN_FRIEND_P (olddecl) = 1;
2012 /* NEWDECL contains the merged attribute lists.
2013 Update OLDDECL to be the same. */
2014 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
2016 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2017 so that encode_section_info has a chance to look at the new decl
2018 flags and attributes. */
2019 if (DECL_RTL_SET_P (olddecl)
2020 && (TREE_CODE (olddecl) == FUNCTION_DECL
2021 || (TREE_CODE (olddecl) == VAR_DECL
2022 && TREE_STATIC (olddecl))))
2023 make_decl_rtl (olddecl);
2025 /* The NEWDECL will no longer be needed. Because every out-of-class
2026 declaration of a member results in a call to duplicate_decls,
2027 freeing these nodes represents in a significant savings. */
2033 /* Return zero if the declaration NEWDECL is valid
2034 when the declaration OLDDECL (assumed to be for the same name)
2035 has already been seen.
2036 Otherwise return an error message format string with a %s
2037 where the identifier should go. */
2040 redeclaration_error_message (tree newdecl, tree olddecl)
2042 if (TREE_CODE (newdecl) == TYPE_DECL)
2044 /* Because C++ can put things into name space for free,
2045 constructs like "typedef struct foo { ... } foo"
2046 would look like an erroneous redeclaration. */
2047 if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
2050 return "redefinition of %q#D";
2052 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
2054 /* If this is a pure function, its olddecl will actually be
2055 the original initialization to `0' (which we force to call
2056 abort()). Don't complain about redefinition in this case. */
2057 if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl)
2058 && DECL_INITIAL (olddecl) == NULL_TREE)
2061 /* If both functions come from different namespaces, this is not
2062 a redeclaration - this is a conflict with a used function. */
2063 if (DECL_NAMESPACE_SCOPE_P (olddecl)
2064 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl)
2065 && ! decls_match (olddecl, newdecl))
2066 return "%qD conflicts with used function";
2068 /* We'll complain about linkage mismatches in
2069 warn_extern_redeclared_static. */
2071 /* Defining the same name twice is no good. */
2072 if (DECL_INITIAL (olddecl) != NULL_TREE
2073 && DECL_INITIAL (newdecl) != NULL_TREE)
2075 if (DECL_NAME (olddecl) == NULL_TREE)
2076 return "%q#D not declared in class";
2078 return "redefinition of %q#D";
2082 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2086 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2088 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl))
2089 && COMPLETE_TYPE_P (TREE_TYPE (olddecl)))
2090 return "redefinition of %q#D";
2094 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL
2095 || (DECL_TEMPLATE_RESULT (newdecl)
2096 == DECL_TEMPLATE_RESULT (olddecl)))
2099 nt = DECL_TEMPLATE_RESULT (newdecl);
2100 if (DECL_TEMPLATE_INFO (nt))
2101 nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt));
2102 ot = DECL_TEMPLATE_RESULT (olddecl);
2103 if (DECL_TEMPLATE_INFO (ot))
2104 ot = DECL_TEMPLATE_RESULT (template_for_substitution (ot));
2105 if (DECL_INITIAL (nt) && DECL_INITIAL (ot))
2106 return "redefinition of %q#D";
2110 else if (TREE_CODE (newdecl) == VAR_DECL
2111 && DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl)
2112 && (! DECL_LANG_SPECIFIC (olddecl)
2113 || ! CP_DECL_THREADPRIVATE_P (olddecl)
2114 || DECL_THREAD_LOCAL_P (newdecl)))
2116 /* Only variables can be thread-local, and all declarations must
2117 agree on this property. */
2118 if (DECL_THREAD_LOCAL_P (newdecl))
2119 return "thread-local declaration of %q#D follows "
2120 "non-thread-local declaration";
2122 return "non-thread-local declaration of %q#D follows "
2123 "thread-local declaration";
2125 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
2127 /* Objects declared at top level: */
2128 /* If at least one is a reference, it's ok. */
2129 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2131 /* Reject two definitions. */
2132 return "redefinition of %q#D";
2136 /* Objects declared with block scope: */
2137 /* Reject two definitions, and reject a definition
2138 together with an external reference. */
2139 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
2140 return "redeclaration of %q#D";
2145 /* Hash and equality functions for the named_label table. */
2148 named_label_entry_hash (const void *data)
2150 const struct named_label_entry *ent = (const struct named_label_entry *) data;
2151 return DECL_UID (ent->label_decl);
2155 named_label_entry_eq (const void *a, const void *b)
2157 const struct named_label_entry *ent_a = (const struct named_label_entry *) a;
2158 const struct named_label_entry *ent_b = (const struct named_label_entry *) b;
2159 return ent_a->label_decl == ent_b->label_decl;
2162 /* Create a new label, named ID. */
2165 make_label_decl (tree id, int local_p)
2167 struct named_label_entry *ent;
2171 decl = build_decl (LABEL_DECL, id, void_type_node);
2173 DECL_CONTEXT (decl) = current_function_decl;
2174 DECL_MODE (decl) = VOIDmode;
2175 C_DECLARED_LABEL_FLAG (decl) = local_p;
2177 /* Say where one reference is to the label, for the sake of the
2178 error if it is not defined. */
2179 DECL_SOURCE_LOCATION (decl) = input_location;
2181 /* Record the fact that this identifier is bound to this label. */
2182 SET_IDENTIFIER_LABEL_VALUE (id, decl);
2184 /* Create the label htab for the function on demand. */
2186 named_labels = htab_create_ggc (13, named_label_entry_hash,
2187 named_label_entry_eq, NULL);
2189 /* Record this label on the list of labels used in this function.
2190 We do this before calling make_label_decl so that we get the
2191 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2192 ent = GGC_CNEW (struct named_label_entry);
2193 ent->label_decl = decl;
2195 slot = htab_find_slot (named_labels, ent, INSERT);
2196 gcc_assert (*slot == NULL);
2202 /* Look for a label named ID in the current function. If one cannot
2203 be found, create one. (We keep track of used, but undefined,
2204 labels, and complain about them at the end of a function.) */
2207 lookup_label (tree id)
2211 timevar_push (TV_NAME_LOOKUP);
2212 /* You can't use labels at global scope. */
2213 if (current_function_decl == NULL_TREE)
2215 error ("label %qE referenced outside of any function", id);
2216 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2219 /* See if we've already got this label. */
2220 decl = IDENTIFIER_LABEL_VALUE (id);
2221 if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
2222 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2224 decl = make_label_decl (id, /*local_p=*/0);
2225 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2228 /* Declare a local label named ID. */
2231 declare_local_label (tree id)
2235 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2236 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2237 shadow = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
2238 current_binding_level->shadowed_labels);
2239 current_binding_level->shadowed_labels = shadow;
2241 decl = make_label_decl (id, /*local_p=*/1);
2242 TREE_VALUE (shadow) = decl;
2247 /* Returns nonzero if it is ill-formed to jump past the declaration of
2248 DECL. Returns 2 if it's also a real problem. */
2251 decl_jump_unsafe (tree decl)
2253 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl)
2254 || TREE_TYPE (decl) == error_mark_node)
2257 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
2258 || DECL_NONTRIVIALLY_INITIALIZED_P (decl))
2261 if (pod_type_p (TREE_TYPE (decl)))
2264 /* The POD stuff is just pedantry; why should it matter if the class
2265 contains a field of pointer to member type? */
2269 /* A subroutine of check_previous_goto_1 to identify a branch to the user. */
2272 identify_goto (tree decl, const location_t *locus)
2275 pedwarn ("jump to label %qD", decl);
2277 pedwarn ("jump to case label");
2279 pedwarn ("%H from here", locus);
2282 /* Check that a single previously seen jump to a newly defined label
2283 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2284 the jump context; NAMES are the names in scope in LEVEL at the jump
2285 context; LOCUS is the source position of the jump or 0. Returns
2286 true if all is well. */
2289 check_previous_goto_1 (tree decl, struct cp_binding_level* level, tree names,
2290 bool exited_omp, const location_t *locus)
2292 struct cp_binding_level *b;
2293 bool identified = false, saw_eh = false, saw_omp = false;
2297 identify_goto (decl, locus);
2298 error (" exits OpenMP structured block");
2299 identified = saw_omp = true;
2302 for (b = current_binding_level; b ; b = b->level_chain)
2304 tree new_decls, old_decls = (b == level ? names : NULL_TREE);
2306 for (new_decls = b->names; new_decls != old_decls;
2307 new_decls = TREE_CHAIN (new_decls))
2309 int problem = decl_jump_unsafe (new_decls);
2315 identify_goto (decl, locus);
2319 error (" crosses initialization of %q+#D", new_decls);
2321 pedwarn (" enters scope of non-POD %q+#D", new_decls);
2326 if ((b->kind == sk_try || b->kind == sk_catch) && !saw_eh)
2330 identify_goto (decl, locus);
2333 if (b->kind == sk_try)
2334 error (" enters try block");
2336 error (" enters catch block");
2339 if (b->kind == sk_omp && !saw_omp)
2343 identify_goto (decl, locus);
2346 error (" enters OpenMP structured block");
2355 check_previous_goto (tree decl, struct named_label_use_entry *use)
2357 check_previous_goto_1 (decl, use->binding_level,
2358 use->names_in_scope, use->in_omp_scope,
2359 &use->o_goto_locus);
2363 check_switch_goto (struct cp_binding_level* level)
2365 return check_previous_goto_1 (NULL_TREE, level, level->names, false, NULL);
2368 /* Check that a new jump to a label DECL is OK. Called by
2369 finish_goto_stmt. */
2372 check_goto (tree decl)
2374 struct named_label_entry *ent, dummy;
2375 bool saw_catch = false, identified = false;
2378 /* We can't know where a computed goto is jumping.
2379 So we assume that it's OK. */
2380 if (TREE_CODE (decl) != LABEL_DECL)
2383 /* We didn't record any information about this label when we created it,
2384 and there's not much point since it's trivial to analyze as a return. */
2385 if (decl == cdtor_label)
2388 dummy.label_decl = decl;
2389 ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2390 gcc_assert (ent != NULL);
2392 /* If the label hasn't been defined yet, defer checking. */
2393 if (! DECL_INITIAL (decl))
2395 struct named_label_use_entry *new_use;
2397 /* Don't bother creating another use if the last goto had the
2398 same data, and will therefore create the same set of errors. */
2400 && ent->uses->names_in_scope == current_binding_level->names)
2403 new_use = GGC_NEW (struct named_label_use_entry);
2404 new_use->binding_level = current_binding_level;
2405 new_use->names_in_scope = current_binding_level->names;
2406 new_use->o_goto_locus = input_location;
2407 new_use->in_omp_scope = false;
2409 new_use->next = ent->uses;
2410 ent->uses = new_use;
2414 if (ent->in_try_scope || ent->in_catch_scope
2415 || ent->in_omp_scope || ent->bad_decls)
2417 pedwarn ("jump to label %q+D", decl);
2418 pedwarn (" from here");
2422 for (bad = ent->bad_decls; bad; bad = TREE_CHAIN (bad))
2424 tree b = TREE_VALUE (bad);
2425 int u = decl_jump_unsafe (b);
2427 if (u > 1 && DECL_ARTIFICIAL (b))
2429 /* Can't skip init of __exception_info. */
2430 error ("%J enters catch block", b);
2434 error (" skips initialization of %q+#D", b);
2436 pedwarn (" enters scope of non-POD %q+#D", b);
2439 if (ent->in_try_scope)
2440 error (" enters try block");
2441 else if (ent->in_catch_scope && !saw_catch)
2442 error (" enters catch block");
2444 if (ent->in_omp_scope)
2445 error (" enters OpenMP structured block");
2446 else if (flag_openmp)
2448 struct cp_binding_level *b;
2449 for (b = current_binding_level; b ; b = b->level_chain)
2451 if (b == ent->binding_level)
2453 if (b->kind == sk_omp)
2457 pedwarn ("jump to label %q+D", decl);
2458 pedwarn (" from here");
2461 error (" exits OpenMP structured block");
2468 /* Check that a return is ok wrt OpenMP structured blocks.
2469 Called by finish_return_stmt. Returns true if all is well. */
2472 check_omp_return (void)
2474 struct cp_binding_level *b;
2475 for (b = current_binding_level; b ; b = b->level_chain)
2476 if (b->kind == sk_omp)
2478 error ("invalid exit from OpenMP structured block");
2484 /* Define a label, specifying the location in the source file.
2485 Return the LABEL_DECL node for the label. */
2488 define_label (location_t location, tree name)
2490 struct named_label_entry *ent, dummy;
2491 struct cp_binding_level *p;
2494 timevar_push (TV_NAME_LOOKUP);
2496 decl = lookup_label (name);
2498 dummy.label_decl = decl;
2499 ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2500 gcc_assert (ent != NULL);
2502 /* After labels, make any new cleanups in the function go into their
2503 own new (temporary) binding contour. */
2504 for (p = current_binding_level;
2505 p->kind != sk_function_parms;
2507 p->more_cleanups_ok = 0;
2509 if (name == get_identifier ("wchar_t"))
2510 pedwarn ("label named wchar_t");
2512 if (DECL_INITIAL (decl) != NULL_TREE)
2513 error ("duplicate label %qD", decl);
2516 struct named_label_use_entry *use;
2518 /* Mark label as having been defined. */
2519 DECL_INITIAL (decl) = error_mark_node;
2520 /* Say where in the source. */
2521 DECL_SOURCE_LOCATION (decl) = location;
2523 ent->binding_level = current_binding_level;
2524 ent->names_in_scope = current_binding_level->names;
2526 for (use = ent->uses; use ; use = use->next)
2527 check_previous_goto (decl, use);
2531 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2536 struct cp_binding_level *level;
2537 struct cp_switch *next;
2538 /* The SWITCH_STMT being built. */
2540 /* A splay-tree mapping the low element of a case range to the high
2541 element, or NULL_TREE if there is no high element. Used to
2542 determine whether or not a new case label duplicates an old case
2543 label. We need a tree, rather than simply a hash table, because
2544 of the GNU case range extension. */
2548 /* A stack of the currently active switch statements. The innermost
2549 switch statement is on the top of the stack. There is no need to
2550 mark the stack for garbage collection because it is only active
2551 during the processing of the body of a function, and we never
2552 collect at that point. */
2554 static struct cp_switch *switch_stack;
2556 /* Called right after a switch-statement condition is parsed.
2557 SWITCH_STMT is the switch statement being parsed. */
2560 push_switch (tree switch_stmt)
2562 struct cp_switch *p = XNEW (struct cp_switch);
2563 p->level = current_binding_level;
2564 p->next = switch_stack;
2565 p->switch_stmt = switch_stmt;
2566 p->cases = splay_tree_new (case_compare, NULL, NULL);
2573 struct cp_switch *cs = switch_stack;
2574 location_t switch_location;
2576 /* Emit warnings as needed. */
2577 if (EXPR_HAS_LOCATION (cs->switch_stmt))
2578 switch_location = EXPR_LOCATION (cs->switch_stmt);
2580 switch_location = input_location;
2581 if (!processing_template_decl)
2582 c_do_switch_warnings (cs->cases, switch_location,
2583 SWITCH_STMT_TYPE (cs->switch_stmt),
2584 SWITCH_STMT_COND (cs->switch_stmt));
2586 splay_tree_delete (cs->cases);
2587 switch_stack = switch_stack->next;
2591 /* Note that we've seen a definition of a case label, and complain if this
2592 is a bad place for one. */
2595 finish_case_label (tree low_value, tree high_value)
2598 struct cp_binding_level *p;
2600 if (processing_template_decl)
2604 /* For templates, just add the case label; we'll do semantic
2605 analysis at instantiation-time. */
2606 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
2607 return add_stmt (build_case_label (low_value, high_value, label));
2610 /* Find the condition on which this switch statement depends. */
2611 cond = SWITCH_STMT_COND (switch_stack->switch_stmt);
2612 if (cond && TREE_CODE (cond) == TREE_LIST)
2613 cond = TREE_VALUE (cond);
2615 if (!check_switch_goto (switch_stack->level))
2616 return error_mark_node;
2618 r = c_add_case_label (switch_stack->cases, cond, TREE_TYPE (cond),
2619 low_value, high_value);
2621 /* After labels, make any new cleanups in the function go into their
2622 own new (temporary) binding contour. */
2623 for (p = current_binding_level;
2624 p->kind != sk_function_parms;
2626 p->more_cleanups_ok = 0;
2631 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
2634 typename_hash (const void* k)
2639 hash = (htab_hash_pointer (TYPE_CONTEXT (t))
2640 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));
2645 typedef struct typename_info {
2653 /* Compare two TYPENAME_TYPEs. K1 and K2 are really of type `tree'. */
2656 typename_compare (const void * k1, const void * k2)
2659 const typename_info *t2;
2662 t2 = (const typename_info *) k2;
2664 return (DECL_NAME (TYPE_NAME (t1)) == t2->name
2665 && TYPE_CONTEXT (t1) == t2->scope
2666 && TYPENAME_TYPE_FULLNAME (t1) == t2->template_id
2667 && TYPENAME_IS_ENUM_P (t1) == t2->enum_p
2668 && TYPENAME_IS_CLASS_P (t1) == t2->class_p);
2671 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
2672 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
2674 Returns the new TYPENAME_TYPE. */
2676 static GTY ((param_is (union tree_node))) htab_t typename_htab;
2679 build_typename_type (tree context, tree name, tree fullname,
2680 enum tag_types tag_type)
2688 if (typename_htab == NULL)
2689 typename_htab = htab_create_ggc (61, &typename_hash,
2690 &typename_compare, NULL);
2692 ti.scope = FROB_CONTEXT (context);
2694 ti.template_id = fullname;
2695 ti.enum_p = tag_type == enum_type;
2696 ti.class_p = (tag_type == class_type
2697 || tag_type == record_type
2698 || tag_type == union_type);
2699 hash = (htab_hash_pointer (ti.scope)
2700 ^ htab_hash_pointer (ti.name));
2702 /* See if we already have this type. */
2703 e = htab_find_slot_with_hash (typename_htab, &ti, hash, INSERT);
2708 /* Build the TYPENAME_TYPE. */
2709 t = make_aggr_type (TYPENAME_TYPE);
2710 TYPE_CONTEXT (t) = ti.scope;
2711 TYPENAME_TYPE_FULLNAME (t) = ti.template_id;
2712 TYPENAME_IS_ENUM_P (t) = ti.enum_p;
2713 TYPENAME_IS_CLASS_P (t) = ti.class_p;
2715 /* Build the corresponding TYPE_DECL. */
2716 d = build_decl (TYPE_DECL, name, t);
2717 TYPE_NAME (TREE_TYPE (d)) = d;
2718 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2719 DECL_CONTEXT (d) = FROB_CONTEXT (context);
2720 DECL_ARTIFICIAL (d) = 1;
2722 /* Store it in the hash table. */
2729 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
2730 provided to name the type. Returns an appropriate type, unless an
2731 error occurs, in which case error_mark_node is returned. If we
2732 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
2733 return that, rather than the _TYPE it corresponds to, in other
2734 cases we look through the type decl. If TF_ERROR is set, complain
2735 about errors, otherwise be quiet. */
2738 make_typename_type (tree context, tree name, enum tag_types tag_type,
2739 tsubst_flags_t complain)
2743 if (name == error_mark_node
2744 || context == NULL_TREE
2745 || context == error_mark_node)
2746 return error_mark_node;
2750 if (!(TYPE_LANG_SPECIFIC (name)
2751 && (CLASSTYPE_IS_TEMPLATE (name)
2752 || CLASSTYPE_USE_TEMPLATE (name))))
2753 name = TYPE_IDENTIFIER (name);
2755 /* Create a TEMPLATE_ID_EXPR for the type. */
2756 name = build_nt (TEMPLATE_ID_EXPR,
2757 CLASSTYPE_TI_TEMPLATE (name),
2758 CLASSTYPE_TI_ARGS (name));
2760 else if (TREE_CODE (name) == TYPE_DECL)
2761 name = DECL_NAME (name);
2765 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
2767 name = TREE_OPERAND (name, 0);
2768 if (TREE_CODE (name) == TEMPLATE_DECL)
2769 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
2771 if (TREE_CODE (name) == TEMPLATE_DECL)
2773 error ("%qD used without template parameters", name);
2774 return error_mark_node;
2776 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
2777 gcc_assert (TYPE_P (context));
2779 if (!dependent_type_p (context)
2780 || currently_open_class (context))
2782 if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
2784 tree tmpl = NULL_TREE;
2785 if (IS_AGGR_TYPE (context))
2786 tmpl = lookup_field (context, name, 0, false);
2787 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
2789 if (complain & tf_error)
2790 error ("no class template named %q#T in %q#T",
2792 return error_mark_node;
2795 if (complain & tf_error)
2796 perform_or_defer_access_check (TYPE_BINFO (context), tmpl);
2798 return lookup_template_class (tmpl,
2799 TREE_OPERAND (fullname, 1),
2801 /*entering_scope=*/0,
2802 tf_warning_or_error | tf_user);
2808 if (!IS_AGGR_TYPE (context))
2810 if (complain & tf_error)
2811 error ("no type named %q#T in %q#T", name, context);
2812 return error_mark_node;
2815 t = lookup_field (context, name, 0, true);
2818 if (TREE_CODE (t) != TYPE_DECL)
2820 if (complain & tf_error)
2821 error ("no type named %q#T in %q#T", name, context);
2822 return error_mark_node;
2825 if (complain & tf_error)
2826 perform_or_defer_access_check (TYPE_BINFO (context), t);
2828 if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
2836 /* If the CONTEXT is not a template type, then either the field is
2837 there now or its never going to be. */
2838 if (!dependent_type_p (context))
2840 if (complain & tf_error)
2841 error ("no type named %q#T in %q#T", name, context);
2842 return error_mark_node;
2845 return build_typename_type (context, name, fullname, tag_type);
2848 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
2849 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
2850 in which case error_mark_node is returned.
2852 If PARM_LIST is non-NULL, also make sure that the template parameter
2853 list of TEMPLATE_DECL matches.
2855 If COMPLAIN zero, don't complain about any errors that occur. */
2858 make_unbound_class_template (tree context, tree name, tree parm_list,
2859 tsubst_flags_t complain)
2865 name = TYPE_IDENTIFIER (name);
2866 else if (DECL_P (name))
2867 name = DECL_NAME (name);
2868 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
2870 if (!dependent_type_p (context)
2871 || currently_open_class (context))
2873 tree tmpl = NULL_TREE;
2875 if (IS_AGGR_TYPE (context))
2876 tmpl = lookup_field (context, name, 0, false);
2878 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
2880 if (complain & tf_error)
2881 error ("no class template named %q#T in %q#T", name, context);
2882 return error_mark_node;
2886 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl), parm_list))
2888 if (complain & tf_error)
2890 error ("template parameters do not match template");
2891 error ("%q+D declared here", tmpl);
2893 return error_mark_node;
2896 if (complain & tf_error)
2897 perform_or_defer_access_check (TYPE_BINFO (context), tmpl);
2902 /* Build the UNBOUND_CLASS_TEMPLATE. */
2903 t = make_aggr_type (UNBOUND_CLASS_TEMPLATE);
2904 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
2905 TREE_TYPE (t) = NULL_TREE;
2907 /* Build the corresponding TEMPLATE_DECL. */
2908 d = build_decl (TEMPLATE_DECL, name, t);
2909 TYPE_NAME (TREE_TYPE (d)) = d;
2910 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2911 DECL_CONTEXT (d) = FROB_CONTEXT (context);
2912 DECL_ARTIFICIAL (d) = 1;
2913 DECL_TEMPLATE_PARMS (d) = parm_list;
2920 /* Push the declarations of builtin types into the namespace.
2921 RID_INDEX is the index of the builtin type in the array
2922 RID_POINTERS. NAME is the name used when looking up the builtin
2923 type. TYPE is the _TYPE node for the builtin type. */
2926 record_builtin_type (enum rid rid_index,
2930 tree rname = NULL_TREE, tname = NULL_TREE;
2931 tree tdecl = NULL_TREE;
2933 if ((int) rid_index < (int) RID_MAX)
2934 rname = ridpointers[(int) rid_index];
2936 tname = get_identifier (name);
2938 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
2939 eliminated. Built-in types should not be looked up name; their
2940 names are keywords that the parser can recognize. However, there
2941 is code in c-common.c that uses identifier_global_value to look
2942 up built-in types by name. */
2945 tdecl = build_decl (TYPE_DECL, tname, type);
2946 DECL_ARTIFICIAL (tdecl) = 1;
2947 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
2953 tdecl = build_decl (TYPE_DECL, rname, type);
2954 DECL_ARTIFICIAL (tdecl) = 1;
2956 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
2959 if (!TYPE_NAME (type))
2960 TYPE_NAME (type) = tdecl;
2963 debug_hooks->type_decl (tdecl, 0);
2966 /* Record one of the standard Java types.
2967 * Declare it as having the given NAME.
2968 * If SIZE > 0, it is the size of one of the integral types;
2969 * otherwise it is the negative of the size of one of the other types. */
2972 record_builtin_java_type (const char* name, int size)
2976 type = make_signed_type (size);
2977 else if (size > -32)
2978 { /* "__java_char" or ""__java_boolean". */
2979 type = make_unsigned_type (-size);
2980 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
2983 { /* "__java_float" or ""__java_double". */
2984 type = make_node (REAL_TYPE);
2985 TYPE_PRECISION (type) = - size;
2988 record_builtin_type (RID_MAX, name, type);
2989 decl = TYPE_NAME (type);
2991 /* Suppress generate debug symbol entries for these types,
2992 since for normal C++ they are just clutter.
2993 However, push_lang_context undoes this if extern "Java" is seen. */
2994 DECL_IGNORED_P (decl) = 1;
2996 TYPE_FOR_JAVA (type) = 1;
3000 /* Push a type into the namespace so that the back-ends ignore it. */
3003 record_unknown_type (tree type, const char* name)
3005 tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
3006 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3007 DECL_IGNORED_P (decl) = 1;
3008 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
3009 TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
3010 TYPE_ALIGN (type) = 1;
3011 TYPE_USER_ALIGN (type) = 0;
3012 TYPE_MODE (type) = TYPE_MODE (void_type_node);
3015 /* A string for which we should create an IDENTIFIER_NODE at
3018 typedef struct predefined_identifier
3020 /* The name of the identifier. */
3021 const char *const name;
3022 /* The place where the IDENTIFIER_NODE should be stored. */
3024 /* Nonzero if this is the name of a constructor or destructor. */
3025 const int ctor_or_dtor_p;
3026 } predefined_identifier;
3028 /* Create all the predefined identifiers. */
3031 initialize_predefined_identifiers (void)
3033 const predefined_identifier *pid;
3035 /* A table of identifiers to create at startup. */
3036 static const predefined_identifier predefined_identifiers[] = {
3037 { "C++", &lang_name_cplusplus, 0 },
3038 { "C", &lang_name_c, 0 },
3039 { "Java", &lang_name_java, 0 },
3040 /* Some of these names have a trailing space so that it is
3041 impossible for them to conflict with names written by users. */
3042 { "__ct ", &ctor_identifier, 1 },
3043 { "__base_ctor ", &base_ctor_identifier, 1 },
3044 { "__comp_ctor ", &complete_ctor_identifier, 1 },
3045 { "__dt ", &dtor_identifier, 1 },
3046 { "__comp_dtor ", &complete_dtor_identifier, 1 },
3047 { "__base_dtor ", &base_dtor_identifier, 1 },
3048 { "__deleting_dtor ", &deleting_dtor_identifier, 1 },
3049 { IN_CHARGE_NAME, &in_charge_identifier, 0 },
3050 { "nelts", &nelts_identifier, 0 },
3051 { THIS_NAME, &this_identifier, 0 },
3052 { VTABLE_DELTA_NAME, &delta_identifier, 0 },
3053 { VTABLE_PFN_NAME, &pfn_identifier, 0 },
3054 { "_vptr", &vptr_identifier, 0 },
3055 { "__vtt_parm", &vtt_parm_identifier, 0 },
3056 { "::", &global_scope_name, 0 },
3057 { "std", &std_identifier, 0 },
3061 for (pid = predefined_identifiers; pid->name; ++pid)
3063 *pid->node = get_identifier (pid->name);
3064 if (pid->ctor_or_dtor_p)
3065 IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
3069 /* Create the predefined scalar types of C,
3070 and some nodes representing standard constants (0, 1, (void *)0).
3071 Initialize the global binding level.
3072 Make definitions for built-in primitive functions. */
3075 cxx_init_decl_processing (void)
3078 tree void_ftype_ptr;
3080 build_common_tree_nodes (flag_signed_char, false);
3082 /* Create all the identifiers we need. */
3083 initialize_predefined_identifiers ();
3085 /* Create the global variables. */
3086 push_to_top_level ();
3088 current_function_decl = NULL_TREE;
3089 current_binding_level = NULL;
3090 /* Enter the global namespace. */
3091 gcc_assert (global_namespace == NULL_TREE);
3092 global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name,
3094 begin_scope (sk_namespace, global_namespace);
3096 current_lang_name = NULL_TREE;
3098 /* Adjust various flags based on command-line settings. */
3099 if (!flag_permissive)
3100 flag_pedantic_errors = 1;
3101 if (!flag_no_inline)
3103 flag_inline_trees = 1;
3106 if (flag_inline_functions)
3107 flag_inline_trees = 2;
3109 /* Force minimum function alignment if using the least significant
3110 bit of function pointers to store the virtual bit. */
3111 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
3112 && force_align_functions_log < 1)
3113 force_align_functions_log = 1;
3116 current_lang_name = lang_name_c;
3118 /* Create the `std' namespace. */
3119 push_namespace (std_identifier);
3120 std_node = current_namespace;
3123 c_common_nodes_and_builtins ();
3125 java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
3126 java_short_type_node = record_builtin_java_type ("__java_short", 16);
3127 java_int_type_node = record_builtin_java_type ("__java_int", 32);
3128 java_long_type_node = record_builtin_java_type ("__java_long", 64);
3129 java_float_type_node = record_builtin_java_type ("__java_float", -32);
3130 java_double_type_node = record_builtin_java_type ("__java_double", -64);
3131 java_char_type_node = record_builtin_java_type ("__java_char", -16);
3132 java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
3134 integer_two_node = build_int_cst (NULL_TREE, 2);
3135 integer_three_node = build_int_cst (NULL_TREE, 3);
3137 record_builtin_type (RID_BOOL, "bool", boolean_type_node);
3138 truthvalue_type_node = boolean_type_node;
3139 truthvalue_false_node = boolean_false_node;
3140 truthvalue_true_node = boolean_true_node;
3142 empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
3145 record_builtin_type (RID_MAX, NULL, string_type_node);
3148 delta_type_node = ptrdiff_type_node;
3149 vtable_index_type = ptrdiff_type_node;
3151 vtt_parm_type = build_pointer_type (const_ptr_type_node);
3152 void_ftype = build_function_type (void_type_node, void_list_node);
3153 void_ftype_ptr = build_function_type (void_type_node,
3154 tree_cons (NULL_TREE,
3158 = build_exception_variant (void_ftype_ptr, empty_except_spec);
3160 /* C++ extensions */
3162 unknown_type_node = make_node (UNKNOWN_TYPE);
3163 record_unknown_type (unknown_type_node, "unknown type");
3165 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3166 TREE_TYPE (unknown_type_node) = unknown_type_node;
3168 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3170 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
3171 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
3174 /* Make sure we get a unique function type, so we can give
3175 its pointer type a name. (This wins for gdb.) */
3176 tree vfunc_type = make_node (FUNCTION_TYPE);
3177 TREE_TYPE (vfunc_type) = integer_type_node;
3178 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
3179 layout_type (vfunc_type);
3181 vtable_entry_type = build_pointer_type (vfunc_type);
3183 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
3186 = build_cplus_array_type (vtable_entry_type, NULL_TREE);
3187 layout_type (vtbl_type_node);
3188 vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
3189 record_builtin_type (RID_MAX, NULL, vtbl_type_node);
3190 vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
3191 layout_type (vtbl_ptr_type_node);
3192 record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
3194 push_namespace (get_identifier ("__cxxabiv1"));
3195 abi_node = current_namespace;
3198 global_type_node = make_node (LANG_TYPE);
3199 record_unknown_type (global_type_node, "global type");
3202 current_lang_name = lang_name_cplusplus;
3206 tree bad_alloc_type_node;
3207 tree bad_alloc_decl;
3208 tree newtype, deltype;
3209 tree ptr_ftype_sizetype;
3211 push_namespace (std_identifier);
3212 bad_alloc_id = get_identifier ("bad_alloc");
3213 bad_alloc_type_node = make_aggr_type (RECORD_TYPE);
3214 TYPE_CONTEXT (bad_alloc_type_node) = current_namespace;
3216 = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node);
3217 DECL_CONTEXT (bad_alloc_decl) = current_namespace;
3218 TYPE_STUB_DECL (bad_alloc_type_node) = bad_alloc_decl;
3222 = build_function_type (ptr_type_node,
3223 tree_cons (NULL_TREE,
3226 newtype = build_exception_variant
3227 (ptr_ftype_sizetype, add_exception_specifier
3228 (NULL_TREE, bad_alloc_type_node, -1));
3229 deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
3230 push_cp_library_fn (NEW_EXPR, newtype);
3231 push_cp_library_fn (VEC_NEW_EXPR, newtype);
3232 global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
3233 push_cp_library_fn (VEC_DELETE_EXPR, deltype);
3237 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
3239 /* Perform other language dependent initializations. */
3240 init_class_processing ();
3241 init_rtti_processing ();
3243 if (flag_exceptions)
3244 init_exception_processing ();
3246 if (! supports_one_only ())
3249 make_fname_decl = cp_make_fname_decl;
3250 start_fname_decls ();
3252 /* Show we use EH for cleanups. */
3253 if (flag_exceptions)
3254 using_eh_for_cleanups ();
3257 /* Generate an initializer for a function naming variable from
3258 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3259 filled in with the type of the init. */
3262 cp_fname_init (const char* name, tree *type_p)
3264 tree domain = NULL_TREE;
3266 tree init = NULL_TREE;
3271 length = strlen (name);
3272 domain = build_index_type (size_int (length));
3273 init = build_string (length + 1, name);
3276 type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
3277 type = build_cplus_array_type (type, domain);
3282 TREE_TYPE (init) = type;
3284 init = error_mark_node;
3289 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
3290 decl, NAME is the initialization string and TYPE_DEP indicates whether
3291 NAME depended on the type of the function. We make use of that to detect
3292 __PRETTY_FUNCTION__ inside a template fn. This is being done
3293 lazily at the point of first use, so we mustn't push the decl now. */
3296 cp_make_fname_decl (tree id, int type_dep)
3298 const char *const name = (type_dep && processing_template_decl
3299 ? NULL : fname_as_string (type_dep));
3301 tree init = cp_fname_init (name, &type);
3302 tree decl = build_decl (VAR_DECL, id, type);
3305 free ((char *) name);
3307 /* As we're using pushdecl_with_scope, we must set the context. */
3308 DECL_CONTEXT (decl) = current_function_decl;
3309 DECL_PRETTY_FUNCTION_P (decl) = type_dep;
3311 TREE_STATIC (decl) = 1;
3312 TREE_READONLY (decl) = 1;
3313 DECL_ARTIFICIAL (decl) = 1;
3315 TREE_USED (decl) = 1;
3317 if (current_function_decl)
3319 struct cp_binding_level *b = current_binding_level;
3320 while (b->level_chain->kind != sk_function_parms)
3322 pushdecl_with_scope (decl, b, /*is_friend=*/false);
3323 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE,
3324 LOOKUP_ONLYCONVERTING);
3327 pushdecl_top_level_and_finish (decl, init);
3332 /* Make a definition for a builtin function named NAME in the current
3333 namespace, whose data type is TYPE and whose context is CONTEXT.
3334 TYPE should be a function type with argument types.
3336 CLASS and CODE tell later passes how to compile calls to this function.
3337 See tree.h for possible values.
3339 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3340 the name to be called if we can't opencode the function.
3341 If ATTRS is nonzero, use that for the function's attribute
3345 builtin_function_1 (const char* name,
3348 enum built_in_function code,
3349 enum built_in_class class,
3350 const char* libname,
3353 tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
3354 DECL_BUILT_IN_CLASS (decl) = class;
3355 DECL_FUNCTION_CODE (decl) = code;
3356 DECL_CONTEXT (decl) = context;
3360 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
3361 we cannot change DECL_ASSEMBLER_NAME until we have installed this
3362 function in the namespace. */
3364 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
3366 /* A function in the user's namespace should have an explicit
3367 declaration before it is used. Mark the built-in function as
3368 anticipated but not actually declared. */
3369 if (name[0] != '_' || name[1] != '_')
3370 DECL_ANTICIPATED (decl) = 1;
3372 /* Possibly apply some default attributes to this built-in function. */
3374 decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
3376 decl_attributes (&decl, NULL_TREE, 0);
3381 /* Entry point for the benefit of c_common_nodes_and_builtins.
3383 Make a definition for a builtin function named NAME and whose data type
3384 is TYPE. TYPE should be a function type with argument types. This
3385 function places the anticipated declaration in the global namespace
3386 and additionally in the std namespace if appropriate.
3388 CLASS and CODE tell later passes how to compile calls to this function.
3389 See tree.h for possible values.
3391 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3392 the name to be called if we can't opencode the function.
3394 If ATTRS is nonzero, use that for the function's attribute
3398 builtin_function (const char* name,
3401 enum built_in_class cl,
3402 const char* libname,
3405 /* All builtins that don't begin with an '_' should additionally
3406 go in the 'std' namespace. */
3409 push_namespace (std_identifier);
3410 builtin_function_1 (name, type, std_node, code, cl, libname, attrs);
3414 return builtin_function_1 (name, type, NULL_TREE, code,
3415 cl, libname, attrs);
3418 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
3419 function. Not called directly. */
3422 build_library_fn_1 (tree name, enum tree_code operator_code, tree type)
3424 tree fn = build_lang_decl (FUNCTION_DECL, name, type);
3425 DECL_EXTERNAL (fn) = 1;
3426 TREE_PUBLIC (fn) = 1;
3427 DECL_ARTIFICIAL (fn) = 1;
3428 SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
3429 SET_DECL_LANGUAGE (fn, lang_c);
3430 /* Runtime library routines are, by definition, available in an
3431 external shared object. */
3432 DECL_VISIBILITY (fn) = VISIBILITY_DEFAULT;
3433 DECL_VISIBILITY_SPECIFIED (fn) = 1;
3437 /* Returns the _DECL for a library function with C linkage.
3438 We assume that such functions never throw; if this is incorrect,
3439 callers should unset TREE_NOTHROW. */
3442 build_library_fn (tree name, tree type)
3444 tree fn = build_library_fn_1 (name, ERROR_MARK, type);
3445 TREE_NOTHROW (fn) = 1;
3449 /* Returns the _DECL for a library function with C++ linkage. */
3452 build_cp_library_fn (tree name, enum tree_code operator_code, tree type)
3454 tree fn = build_library_fn_1 (name, operator_code, type);
3455 TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
3456 DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
3457 SET_DECL_LANGUAGE (fn, lang_cplusplus);
3461 /* Like build_library_fn, but takes a C string instead of an
3465 build_library_fn_ptr (const char* name, tree type)
3467 return build_library_fn (get_identifier (name), type);
3470 /* Like build_cp_library_fn, but takes a C string instead of an
3474 build_cp_library_fn_ptr (const char* name, tree type)
3476 return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
3479 /* Like build_library_fn, but also pushes the function so that we will
3480 be able to find it via IDENTIFIER_GLOBAL_VALUE. */
3483 push_library_fn (tree name, tree type)
3485 tree fn = build_library_fn (name, type);
3486 pushdecl_top_level (fn);
3490 /* Like build_cp_library_fn, but also pushes the function so that it
3491 will be found by normal lookup. */
3494 push_cp_library_fn (enum tree_code operator_code, tree type)
3496 tree fn = build_cp_library_fn (ansi_opname (operator_code),
3503 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
3507 push_void_library_fn (tree name, tree parmtypes)
3509 tree type = build_function_type (void_type_node, parmtypes);
3510 return push_library_fn (name, type);
3513 /* Like push_library_fn, but also note that this function throws
3514 and does not return. Used for __throw_foo and the like. */
3517 push_throw_library_fn (tree name, tree type)
3519 tree fn = push_library_fn (name, type);
3520 TREE_THIS_VOLATILE (fn) = 1;
3521 TREE_NOTHROW (fn) = 0;
3525 /* When we call finish_struct for an anonymous union, we create
3526 default copy constructors and such. But, an anonymous union
3527 shouldn't have such things; this function undoes the damage to the
3528 anonymous union type T.
3530 (The reason that we create the synthesized methods is that we don't
3531 distinguish `union { int i; }' from `typedef union { int i; } U'.
3532 The first is an anonymous union; the second is just an ordinary
3536 fixup_anonymous_aggr (tree t)
3540 /* Wipe out memory of synthesized methods. */
3541 TYPE_HAS_CONSTRUCTOR (t) = 0;
3542 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
3543 TYPE_HAS_INIT_REF (t) = 0;
3544 TYPE_HAS_CONST_INIT_REF (t) = 0;
3545 TYPE_HAS_ASSIGN_REF (t) = 0;
3546 TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
3548 /* Splice the implicitly generated functions out of the TYPE_METHODS
3550 q = &TYPE_METHODS (t);
3553 if (DECL_ARTIFICIAL (*q))
3554 *q = TREE_CHAIN (*q);
3556 q = &TREE_CHAIN (*q);
3559 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
3560 if (TYPE_METHODS (t))
3561 error ("%Jan anonymous union cannot have function members",
3562 TYPE_MAIN_DECL (t));
3564 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
3565 assignment operators (because they cannot have these methods themselves).
3566 For anonymous unions this is already checked because they are not allowed
3567 in any union, otherwise we have to check it. */
3568 if (TREE_CODE (t) != UNION_TYPE)
3572 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
3573 if (TREE_CODE (field) == FIELD_DECL)
3575 type = TREE_TYPE (field);
3576 if (CLASS_TYPE_P (type))
3578 if (TYPE_NEEDS_CONSTRUCTING (type))
3579 error ("member %q+#D with constructor not allowed "
3580 "in anonymous aggregate", field);
3581 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
3582 error ("member %q+#D with destructor not allowed "
3583 "in anonymous aggregate", field);
3584 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
3585 error ("member %q+#D with copy assignment operator "
3586 "not allowed in anonymous aggregate", field);
3592 /* Make sure that a declaration with no declarator is well-formed, i.e.
3593 just declares a tagged type or anonymous union.
3595 Returns the type declared; or NULL_TREE if none. */
3598 check_tag_decl (cp_decl_specifier_seq *declspecs)
3600 int saw_friend = declspecs->specs[(int)ds_friend] != 0;
3601 int saw_typedef = declspecs->specs[(int)ds_typedef] != 0;
3602 /* If a class, struct, or enum type is declared by the DECLSPECS
3603 (i.e, if a class-specifier, enum-specifier, or non-typename
3604 elaborated-type-specifier appears in the DECLSPECS),
3605 DECLARED_TYPE is set to the corresponding type. */
3606 tree declared_type = NULL_TREE;
3607 bool error_p = false;
3609 if (declspecs->multiple_types_p)
3610 error ("multiple types in one declaration");
3611 else if (declspecs->redefined_builtin_type)
3613 if (!in_system_header)
3614 pedwarn ("redeclaration of C++ built-in type %qT",
3615 declspecs->redefined_builtin_type);
3620 && TYPE_P (declspecs->type)
3621 && ((TREE_CODE (declspecs->type) != TYPENAME_TYPE
3622 && IS_AGGR_TYPE (declspecs->type))
3623 || TREE_CODE (declspecs->type) == ENUMERAL_TYPE))
3624 declared_type = declspecs->type;
3625 else if (declspecs->type == error_mark_node)
3627 if (declared_type == NULL_TREE && ! saw_friend && !error_p)
3628 pedwarn ("declaration does not declare anything");
3629 /* Check for an anonymous union. */
3630 else if (declared_type && IS_AGGR_TYPE_CODE (TREE_CODE (declared_type))
3631 && TYPE_ANONYMOUS_P (declared_type))
3633 /* 7/3 In a simple-declaration, the optional init-declarator-list
3634 can be omitted only when declaring a class (clause 9) or
3635 enumeration (7.2), that is, when the decl-specifier-seq contains
3636 either a class-specifier, an elaborated-type-specifier with
3637 a class-key (9.1), or an enum-specifier. In these cases and
3638 whenever a class-specifier or enum-specifier is present in the
3639 decl-specifier-seq, the identifiers in these specifiers are among
3640 the names being declared by the declaration (as class-name,
3641 enum-names, or enumerators, depending on the syntax). In such
3642 cases, and except for the declaration of an unnamed bit-field (9.6),
3643 the decl-specifier-seq shall introduce one or more names into the
3644 program, or shall redeclare a name introduced by a previous
3645 declaration. [Example:
3646 enum { }; // ill-formed
3647 typedef class { }; // ill-formed
3651 error ("missing type-name in typedef-declaration");
3654 /* Anonymous unions are objects, so they can have specifiers. */;
3655 SET_ANON_AGGR_TYPE_P (declared_type);
3657 if (TREE_CODE (declared_type) != UNION_TYPE && pedantic
3658 && !in_system_header)
3659 pedwarn ("ISO C++ prohibits anonymous structs");
3664 if (declspecs->specs[(int)ds_inline]
3665 || declspecs->specs[(int)ds_virtual])
3666 error ("%qs can only be specified for functions",
3667 declspecs->specs[(int)ds_inline]
3668 ? "inline" : "virtual");
3670 && (!current_class_type
3671 || current_scope () != current_class_type))
3672 error ("%<friend%> can only be specified inside a class");
3673 else if (declspecs->specs[(int)ds_explicit])
3674 error ("%<explicit%> can only be specified for constructors");
3675 else if (declspecs->storage_class)
3676 error ("a storage class can only be specified for objects "
3678 else if (declspecs->specs[(int)ds_const]
3679 || declspecs->specs[(int)ds_volatile]
3680 || declspecs->specs[(int)ds_restrict]
3681 || declspecs->specs[(int)ds_thread])
3682 error ("qualifiers can only be specified for objects "
3686 return declared_type;
3689 /* Called when a declaration is seen that contains no names to declare.
3690 If its type is a reference to a structure, union or enum inherited
3691 from a containing scope, shadow that tag name for the current scope
3692 with a forward reference.
3693 If its type defines a new named structure or union
3694 or defines an enum, it is valid but we need not do anything here.
3695 Otherwise, it is an error.
3697 C++: may have to grok the declspecs to learn about static,
3698 complain for anonymous unions.
3700 Returns the TYPE declared -- or NULL_TREE if none. */
3703 shadow_tag (cp_decl_specifier_seq *declspecs)
3705 tree t = check_tag_decl (declspecs);
3710 if (declspecs->attributes)
3712 warning (0, "attribute ignored in declaration of %q+#T", t);
3713 warning (0, "attribute for %q+#T must follow the %qs keyword",
3714 t, class_key_or_enum_as_string (t));
3718 maybe_process_partial_specialization (t);
3720 /* This is where the variables in an anonymous union are
3721 declared. An anonymous union declaration looks like:
3723 because there is no declarator after the union, the parser
3724 sends that declaration here. */
3725 if (ANON_AGGR_TYPE_P (t))
3727 fixup_anonymous_aggr (t);
3729 if (TYPE_FIELDS (t))
3731 tree decl = grokdeclarator (/*declarator=*/NULL,
3732 declspecs, NORMAL, 0, NULL);
3733 finish_anon_union (decl);
3740 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
3743 groktypename (cp_decl_specifier_seq *type_specifiers,
3744 const cp_declarator *declarator)
3748 attrs = type_specifiers->attributes;
3749 type_specifiers->attributes = NULL_TREE;
3750 type = grokdeclarator (declarator, type_specifiers, TYPENAME, 0, &attrs);
3752 cplus_decl_attributes (&type, attrs, 0);
3756 /* Decode a declarator in an ordinary declaration or data definition.
3757 This is called as soon as the type information and variable name
3758 have been parsed, before parsing the initializer if any.
3759 Here we create the ..._DECL node, fill in its type,
3760 and put it on the list of decls for the current context.
3761 The ..._DECL node is returned as the value.
3763 Exception: for arrays where the length is not specified,
3764 the type is left null, to be filled in by `cp_finish_decl'.
3766 Function definitions do not come here; they go to start_function
3767 instead. However, external and forward declarations of functions
3768 do go through here. Structure field declarations are done by
3769 grokfield and not through here. */
3772 start_decl (const cp_declarator *declarator,
3773 cp_decl_specifier_seq *declspecs,
3776 tree prefix_attributes,
3777 tree *pushed_scope_p)
3783 *pushed_scope_p = NULL_TREE;
3785 /* This should only be done once on the top most decl. */
3786 if (have_extern_spec)
3788 declspecs->storage_class = sc_extern;
3789 have_extern_spec = false;
3792 /* An object declared as __attribute__((deprecated)) suppresses
3793 warnings of uses of other deprecated items. */
3794 if (lookup_attribute ("deprecated", attributes))
3795 deprecated_state = DEPRECATED_SUPPRESS;
3797 attributes = chainon (attributes, prefix_attributes);
3799 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
3802 deprecated_state = DEPRECATED_NORMAL;
3804 if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE
3805 || decl == error_mark_node)
3806 return error_mark_node;
3808 type = TREE_TYPE (decl);
3810 context = DECL_CONTEXT (decl);
3814 *pushed_scope_p = push_scope (context);
3816 /* We are only interested in class contexts, later. */
3817 if (TREE_CODE (context) == NAMESPACE_DECL)
3818 context = NULL_TREE;
3822 /* Is it valid for this decl to have an initializer at all?
3823 If not, set INITIALIZED to zero, which will indirectly
3824 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
3825 switch (TREE_CODE (decl))
3828 error ("typedef %qD is initialized (use __typeof__ instead)", decl);
3833 error ("function %q#D is initialized like a variable", decl);
3843 if (! toplevel_bindings_p ()
3844 && DECL_EXTERNAL (decl))
3845 warning (0, "declaration of %q#D has %<extern%> and is initialized",
3847 DECL_EXTERNAL (decl) = 0;
3848 if (toplevel_bindings_p ())
3849 TREE_STATIC (decl) = 1;
3852 /* Set attributes here so if duplicate decl, will have proper attributes. */
3853 cplus_decl_attributes (&decl, attributes, 0);
3855 /* If #pragma weak was used, mark the decl weak now. */
3856 maybe_apply_pragma_weak (decl);
3858 if (TREE_CODE (decl) == FUNCTION_DECL
3859 && DECL_DECLARED_INLINE_P (decl)
3860 && DECL_UNINLINABLE (decl)
3861 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
3862 warning (0, "inline function %q+D given attribute noinline", decl);
3864 if (context && COMPLETE_TYPE_P (complete_type (context)))
3866 if (TREE_CODE (decl) == VAR_DECL)
3868 tree field = lookup_field (context, DECL_NAME (decl), 0, false);
3869 if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
3870 error ("%q#D is not a static member of %q#T", decl, context);
3873 if (DECL_CONTEXT (field) != context)
3875 if (!same_type_p (DECL_CONTEXT (field), context))
3876 pedwarn ("ISO C++ does not permit %<%T::%D%> "
3877 "to be defined as %<%T::%D%>",
3878 DECL_CONTEXT (field), DECL_NAME (decl),
3879 context, DECL_NAME (decl));
3880 DECL_CONTEXT (decl) = DECL_CONTEXT (field);
3882 if (processing_specialization
3883 && template_class_depth (context) == 0
3884 && CLASSTYPE_TEMPLATE_SPECIALIZATION (context))
3885 error ("template header not allowed in member definition "
3886 "of explicitly specialized class");
3887 /* Static data member are tricky; an in-class initialization
3888 still doesn't provide a definition, so the in-class
3889 declaration will have DECL_EXTERNAL set, but will have an
3890 initialization. Thus, duplicate_decls won't warn
3891 about this situation, and so we check here. */
3892 if (initialized && DECL_INITIALIZED_IN_CLASS_P (field))
3893 error ("duplicate initialization of %qD", decl);
3894 if (duplicate_decls (decl, field, /*newdecl_is_friend=*/false))
3900 tree field = check_classfn (context, decl,
3901 (processing_template_decl
3902 > template_class_depth (context))
3903 ? current_template_parms
3905 if (field && duplicate_decls (decl, field,
3906 /*newdecl_is_friend=*/false))
3910 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
3911 DECL_IN_AGGR_P (decl) = 0;
3912 /* Do not mark DECL as an explicit specialization if it was not
3913 already marked as an instantiation; a declaration should
3914 never be marked as a specialization unless we know what
3915 template is being specialized. */
3916 if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
3918 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
3920 /* [temp.expl.spec] An explicit specialization of a static data
3921 member of a template is a definition if the declaration
3922 includes an initializer; otherwise, it is a declaration.
3924 We check for processing_specialization so this only applies
3925 to the new specialization syntax. */
3926 if (!initialized && processing_specialization)
3927 DECL_EXTERNAL (decl) = 1;
3930 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
3931 pedwarn ("declaration of %q#D outside of class is not definition",
3935 /* Enter this declaration into the symbol table. */
3936 tem = maybe_push_decl (decl);
3938 if (processing_template_decl)
3939 tem = push_template_decl (tem);
3940 if (tem == error_mark_node)
3941 return error_mark_node;
3943 /* Tell the back-end to use or not use .common as appropriate. If we say
3944 -fconserve-space, we want this to save .data space, at the expense of
3945 wrong semantics. If we say -fno-conserve-space, we want this to
3946 produce errors about redefs; to do this we force variables into the
3948 if (flag_conserve_space
3949 && TREE_CODE (tem) == VAR_DECL
3950 && TREE_PUBLIC (tem)
3951 && !DECL_THREAD_LOCAL_P (tem)
3952 && !have_global_bss_p ())
3953 DECL_COMMON (tem) = 1;
3955 if (!processing_template_decl && TREE_CODE (tem) == VAR_DECL)
3956 start_decl_1 (tem, initialized);
3962 start_decl_1 (tree decl, bool initialized)
3966 gcc_assert (!processing_template_decl);
3968 if (error_operand_p (decl))
3971 gcc_assert (TREE_CODE (decl) == VAR_DECL);
3972 type = TREE_TYPE (decl);
3975 /* Is it valid for this decl to have an initializer at all?
3976 If not, set INITIALIZED to zero, which will indirectly
3977 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
3979 /* Don't allow initializations for incomplete types except for
3980 arrays which might be completed by the initialization. */
3981 if (COMPLETE_TYPE_P (complete_type (type)))
3982 ; /* A complete type is ok. */
3983 else if (TREE_CODE (type) != ARRAY_TYPE)
3985 error ("variable %q#D has initializer but incomplete type", decl);
3987 type = TREE_TYPE (decl) = error_mark_node;
3989 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
3991 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
3992 error ("elements of array %q#D have incomplete type", decl);
3993 /* else we already gave an error in start_decl. */
3997 else if (IS_AGGR_TYPE (type)
3998 && ! DECL_EXTERNAL (decl))
4000 if (!COMPLETE_TYPE_P (complete_type (type)))
4002 error ("aggregate %q#D has incomplete type and cannot be defined",
4004 /* Change the type so that assemble_variable will give
4005 DECL an rtl we can live with: (mem (const_int 0)). */
4006 type = TREE_TYPE (decl) = error_mark_node;
4010 /* If any base type in the hierarchy of TYPE needs a constructor,
4011 then we set initialized to 1. This way any nodes which are
4012 created for the purposes of initializing this aggregate
4013 will live as long as it does. This is necessary for global
4014 aggregates which do not have their initializers processed until
4015 the end of the file. */
4016 initialized = TYPE_NEEDS_CONSTRUCTING (type);
4020 /* Create a new scope to hold this declaration if necessary.
4021 Whether or not a new scope is necessary cannot be determined
4022 until after the type has been completed; if the type is a
4023 specialization of a class template it is not until after
4024 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4025 will be set correctly. */
4026 maybe_push_cleanup_level (type);
4029 /* Handle initialization of references. DECL, TYPE, and INIT have the
4030 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
4031 but will be set to a new CLEANUP_STMT if a temporary is created
4032 that must be destroyed subsequently.
4034 Returns an initializer expression to use to initialize DECL, or
4035 NULL if the initialization can be performed statically.
4037 Quotes on semantics can be found in ARM 8.4.3. */
4040 grok_reference_init (tree decl, tree type, tree init, tree *cleanup)
4044 if (init == NULL_TREE)
4046 if ((DECL_LANG_SPECIFIC (decl) == 0
4047 || DECL_IN_AGGR_P (decl) == 0)
4048 && ! DECL_THIS_EXTERN (decl))
4049 error ("%qD declared as reference but not initialized", decl);
4053 if (TREE_CODE (init) == CONSTRUCTOR)
4055 error ("ISO C++ forbids use of initializer list to "
4056 "initialize reference %qD", decl);
4060 if (TREE_CODE (init) == TREE_LIST)
4061 init = build_x_compound_expr_from_list (init, "initializer");
4063 if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
4064 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
4065 /* Note: default conversion is only called in very special cases. */
4066 init = decay_conversion (init);
4068 /* Convert INIT to the reference type TYPE. This may involve the
4069 creation of a temporary, whose lifetime must be the same as that
4070 of the reference. If so, a DECL_EXPR for the temporary will be
4071 added just after the DECL_EXPR for DECL. That's why we don't set
4072 DECL_INITIAL for local references (instead assigning to them
4073 explicitly); we need to allow the temporary to be initialized
4075 tmp = initialize_reference (type, init, decl, cleanup);
4077 if (tmp == error_mark_node)
4079 else if (tmp == NULL_TREE)
4081 error ("cannot initialize %qT from %qT", type, TREE_TYPE (init));
4085 if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
4088 DECL_INITIAL (decl) = tmp;
4093 /* When parsing `int a[] = {1, 2};' we don't know the size of the
4094 array until we finish parsing the initializer. If that's the
4095 situation we're in, update DECL accordingly. */
4098 maybe_deduce_size_from_array_init (tree decl, tree init)
4100 tree type = TREE_TYPE (decl);
4102 if (TREE_CODE (type) == ARRAY_TYPE
4103 && TYPE_DOMAIN (type) == NULL_TREE
4104 && TREE_CODE (decl) != TYPE_DECL)
4106 /* do_default is really a C-ism to deal with tentative definitions.
4107 But let's leave it here to ease the eventual merge. */
4108 int do_default = !DECL_EXTERNAL (decl);
4109 tree initializer = init ? init : DECL_INITIAL (decl);
4110 int failure = cp_complete_array_type (&TREE_TYPE (decl), initializer,
4114 error ("initializer fails to determine size of %qD", decl);
4119 error ("array size missing in %qD", decl);
4120 /* If a `static' var's size isn't known, make it extern as
4121 well as static, so it does not get allocated. If it's not
4122 `static', then don't mark it extern; finish_incomplete_decl
4123 will give it a default size and it will get allocated. */
4124 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
4125 DECL_EXTERNAL (decl) = 1;
4129 error ("zero-size array %qD", decl);
4131 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl)), decl);
4133 layout_decl (decl, 0);
4137 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
4138 any appropriate error messages regarding the layout. */
4141 layout_var_decl (tree decl)
4143 tree type = TREE_TYPE (decl);
4145 /* If we haven't already layed out this declaration, do so now.
4146 Note that we must not call complete type for an external object
4147 because it's type might involve templates that we are not
4148 supposed to instantiate yet. (And it's perfectly valid to say
4149 `extern X x' for some incomplete type `X'.) */
4150 if (!DECL_EXTERNAL (decl))
4151 complete_type (type);
4152 if (!DECL_SIZE (decl)
4153 && TREE_TYPE (decl) != error_mark_node
4154 && (COMPLETE_TYPE_P (type)
4155 || (TREE_CODE (type) == ARRAY_TYPE
4156 && !TYPE_DOMAIN (type)
4157 && COMPLETE_TYPE_P (TREE_TYPE (type)))))
4158 layout_decl (decl, 0);
4160 if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
4162 /* An automatic variable with an incomplete type: that is an error.
4163 Don't talk about array types here, since we took care of that
4164 message in grokdeclarator. */
4165 error ("storage size of %qD isn't known", decl);
4166 TREE_TYPE (decl) = error_mark_node;
4169 /* Keep this code around in case we later want to control debug info
4170 based on whether a type is "used". (jason 1999-11-11) */
4172 else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
4173 /* Let debugger know it should output info for this type. */
4174 note_debug_info_needed (ttype);
4176 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
4177 note_debug_info_needed (DECL_CONTEXT (decl));
4180 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
4181 && DECL_SIZE (decl) != NULL_TREE
4182 && ! TREE_CONSTANT (DECL_SIZE (decl)))
4184 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
4185 constant_expression_warning (DECL_SIZE (decl));
4187 error ("storage size of %qD isn't constant", decl);
4190 if (TREE_STATIC (decl)
4191 && !DECL_ARTIFICIAL (decl)
4192 && current_function_decl
4193 && DECL_CONTEXT (decl) == current_function_decl)
4194 push_local_name (decl);
4197 /* If a local static variable is declared in an inline function, or if
4198 we have a weak definition, we must endeavor to create only one
4199 instance of the variable at link-time. */
4202 maybe_commonize_var (tree decl)
4204 /* Static data in a function with comdat linkage also has comdat
4206 if (TREE_STATIC (decl)
4207 /* Don't mess with __FUNCTION__. */
4208 && ! DECL_ARTIFICIAL (decl)
4209 && DECL_FUNCTION_SCOPE_P (decl)
4210 /* Unfortunately, import_export_decl has not always been called
4211 before the function is processed, so we cannot simply check
4213 && (DECL_COMDAT (DECL_CONTEXT (decl))
4214 || ((DECL_DECLARED_INLINE_P (DECL_CONTEXT (decl))
4215 || DECL_TEMPLATE_INSTANTIATION (DECL_CONTEXT (decl)))
4216 && TREE_PUBLIC (DECL_CONTEXT (decl)))))
4220 /* With weak symbols, we simply make the variable COMDAT;
4221 that will cause copies in multiple translations units to
4223 comdat_linkage (decl);
4227 if (DECL_INITIAL (decl) == NULL_TREE
4228 || DECL_INITIAL (decl) == error_mark_node)
4230 /* Without weak symbols, we can use COMMON to merge
4231 uninitialized variables. */
4232 TREE_PUBLIC (decl) = 1;
4233 DECL_COMMON (decl) = 1;
4237 /* While for initialized variables, we must use internal
4238 linkage -- which means that multiple copies will not
4240 TREE_PUBLIC (decl) = 0;
4241 DECL_COMMON (decl) = 0;
4242 warning (0, "sorry: semantics of inline function static "
4243 "data %q+#D are wrong (you'll wind up "
4244 "with multiple copies)", decl);
4245 warning (0, "%J you can work around this by removing "
4251 else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
4252 /* Set it up again; we might have set DECL_INITIAL since the last
4254 comdat_linkage (decl);
4257 /* Issue an error message if DECL is an uninitialized const variable. */
4260 check_for_uninitialized_const_var (tree decl)
4262 tree type = TREE_TYPE (decl);
4264 /* ``Unless explicitly declared extern, a const object does not have
4265 external linkage and must be initialized. ($8.4; $12.1)'' ARM
4267 if (TREE_CODE (decl) == VAR_DECL
4268 && TREE_CODE (type) != REFERENCE_TYPE
4269 && CP_TYPE_CONST_P (type)
4270 && !TYPE_NEEDS_CONSTRUCTING (type)
4271 && !DECL_INITIAL (decl))
4272 error ("uninitialized const %qD", decl);
4276 /* Structure holding the current initializer being processed by reshape_init.
4277 CUR is a pointer to the current element being processed, END is a pointer
4278 after the last element present in the initializer. */
4279 typedef struct reshape_iterator_t
4281 constructor_elt *cur;
4282 constructor_elt *end;
4285 static tree reshape_init_r (tree, reshape_iter *, bool);
4287 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
4288 returned is the next FIELD_DECL (possibly FIELD itself) that can be
4289 initialized. If there are no more such fields, the return value
4293 next_initializable_field (tree field)
4296 && (TREE_CODE (field) != FIELD_DECL
4297 || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
4298 || DECL_ARTIFICIAL (field)))
4299 field = TREE_CHAIN (field);
4304 /* Subroutine of reshape_init_array and reshape_init_vector, which does
4305 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
4306 INTEGER_CST representing the size of the array minus one (the maximum index),
4307 or NULL_TREE if the array was declared without specifying the size. D is
4308 the iterator within the constructor. */
4311 reshape_init_array_1 (tree elt_type, tree max_index, reshape_iter *d)
4314 bool sized_array_p = (max_index != NULL_TREE);
4315 unsigned HOST_WIDE_INT max_index_cst = 0;
4316 unsigned HOST_WIDE_INT index;
4318 /* The initializer for an array is always a CONSTRUCTOR. */
4319 new_init = build_constructor (NULL_TREE, NULL);
4323 /* Minus 1 is used for zero sized arrays. */
4324 if (integer_all_onesp (max_index))
4327 if (host_integerp (max_index, 1))
4328 max_index_cst = tree_low_cst (max_index, 1);
4329 /* sizetype is sign extended, not zero extended. */
4331 max_index_cst = tree_low_cst (fold_convert (size_type_node, max_index),
4335 /* Loop until there are no more initializers. */
4337 d->cur != d->end && (!sized_array_p || index <= max_index_cst);
4344 /* Handle array designated initializers (GNU extension). */
4345 if (TREE_CODE (d->cur->index) == IDENTIFIER_NODE)
4347 error ("name %qD used in a GNU-style designated "
4348 "initializer for an array", d->cur->index);
4354 elt_init = reshape_init_r (elt_type, d, /*first_initializer_p=*/false);
4355 if (elt_init == error_mark_node)
4356 return error_mark_node;
4357 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), NULL_TREE, elt_init);
4363 /* Subroutine of reshape_init_r, processes the initializers for arrays.
4364 Parameters are the same of reshape_init_r. */
4367 reshape_init_array (tree type, reshape_iter *d)
4369 tree max_index = NULL_TREE;
4371 gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
4373 if (TYPE_DOMAIN (type))
4374 max_index = array_type_nelts (type);
4376 return reshape_init_array_1 (TREE_TYPE (type), max_index, d);
4379 /* Subroutine of reshape_init_r, processes the initializers for vectors.
4380 Parameters are the same of reshape_init_r. */
4383 reshape_init_vector (tree type, reshape_iter *d)
4385 tree max_index = NULL_TREE;
4388 gcc_assert (TREE_CODE (type) == VECTOR_TYPE);
4390 if (COMPOUND_LITERAL_P (d->cur->value))
4392 tree value = d->cur->value;
4393 if (!same_type_p (TREE_TYPE (value), type))
4395 error ("invalid type %qT as initializer for a vector of type %qT",
4396 TREE_TYPE (d->cur->value), type);
4397 value = error_mark_node;
4403 /* For a vector, the representation type is a struct
4404 containing a single member which is an array of the
4405 appropriate size. */
4406 rtype = TYPE_DEBUG_REPRESENTATION_TYPE (type);
4407 if (rtype && TYPE_DOMAIN (TREE_TYPE (TYPE_FIELDS (rtype))))
4408 max_index = array_type_nelts (TREE_TYPE (TYPE_FIELDS (rtype)));
4410 return reshape_init_array_1 (TREE_TYPE (type), max_index, d);
4413 /* Subroutine of reshape_init_r, processes the initializers for classes
4414 or union. Parameters are the same of reshape_init_r. */
4417 reshape_init_class (tree type, reshape_iter *d, bool first_initializer_p)
4422 gcc_assert (CLASS_TYPE_P (type));
4424 /* The initializer for a class is always a CONSTRUCTOR. */
4425 new_init = build_constructor (NULL_TREE, NULL);
4426 field = next_initializable_field (TYPE_FIELDS (type));
4432 An initializer for an aggregate member that is an
4433 empty class shall have the form of an empty
4434 initializer-list {}. */
4435 if (!first_initializer_p)
4437 error ("initializer for %qT must be brace-enclosed", type);
4438 return error_mark_node;
4443 /* Loop through the initializable fields, gathering initializers. */
4444 while (d->cur != d->end)
4448 /* Handle designated initializers, as an extension. */
4452 pedwarn ("ISO C++ does not allow designated initializers");
4454 field = lookup_field_1 (type, d->cur->index, /*want_type=*/false);
4456 if (!field || TREE_CODE (field) != FIELD_DECL)
4457 error ("%qT has no non-static data member named %qD", type,
4461 /* If we processed all the member of the class, we are done. */
4465 field_init = reshape_init_r (TREE_TYPE (field), d,
4466 /*first_initializer_p=*/false);
4467 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), field, field_init);
4471 When a union is initialized with a brace-enclosed
4472 initializer, the braces shall only contain an
4473 initializer for the first member of the union. */
4474 if (TREE_CODE (type) == UNION_TYPE)
4477 field = next_initializable_field (TREE_CHAIN (field));
4483 /* Subroutine of reshape_init, which processes a single initializer (part of
4484 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
4485 iterator within the CONSTRUCTOR which points to the initializer to process.
4486 FIRST_INITIALIZER_P is true if this is the first initializer of the
4487 CONSTRUCTOR node. */
4490 reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p)
4492 tree init = d->cur->value;
4494 /* A non-aggregate type is always initialized with a single
4496 if (!CP_AGGREGATE_TYPE_P (type))
4498 /* It is invalid to initialize a non-aggregate type with a
4499 brace-enclosed initializer.
4500 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
4501 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
4502 a CONSTRUCTOR (with a record type). */
4503 if (TREE_CODE (init) == CONSTRUCTOR
4504 && BRACE_ENCLOSED_INITIALIZER_P (init)) /* p7626.C */
4506 error ("braces around scalar initializer for type %qT", type);
4507 init = error_mark_node;
4516 All implicit type conversions (clause _conv_) are considered when
4517 initializing the aggregate member with an initializer from an
4518 initializer-list. If the initializer can initialize a member,
4519 the member is initialized. Otherwise, if the member is itself a
4520 non-empty subaggregate, brace elision is assumed and the
4521 initializer is considered for the initialization of the first
4522 member of the subaggregate. */
4523 if (TREE_CODE (init) != CONSTRUCTOR
4524 && can_convert_arg (type, TREE_TYPE (init), init, LOOKUP_NORMAL))
4530 /* [dcl.init.string]
4532 A char array (whether plain char, signed char, or unsigned char)
4533 can be initialized by a string-literal (optionally enclosed in
4534 braces); a wchar_t array can be initialized by a wide
4535 string-literal (optionally enclosed in braces). */
4536 if (TREE_CODE (type) == ARRAY_TYPE
4537 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
4539 tree str_init = init;
4541 /* Strip one level of braces if and only if they enclose a single
4542 element (as allowed by [dcl.init.string]). */
4543 if (!first_initializer_p
4544 && TREE_CODE (str_init) == CONSTRUCTOR
4545 && VEC_length (constructor_elt, CONSTRUCTOR_ELTS (str_init)) == 1)
4547 str_init = VEC_index (constructor_elt,
4548 CONSTRUCTOR_ELTS (str_init), 0)->value;
4551 /* If it's a string literal, then it's the initializer for the array
4552 as a whole. Otherwise, continue with normal initialization for
4553 array types (one value per array element). */
4554 if (TREE_CODE (str_init) == STRING_CST)
4561 /* The following cases are about aggregates. If we are not within a full
4562 initializer already, and there is not a CONSTRUCTOR, it means that there
4563 is a missing set of braces (that is, we are processing the case for
4564 which reshape_init exists). */
4565 if (!first_initializer_p)
4567 if (TREE_CODE (init) == CONSTRUCTOR)
4569 /* For a nested compound literal, there is no need to reshape since
4570 brace elision is not allowed. Even if we decided to allow it,
4571 we should add a call to reshape_init in finish_compound_literal,
4572 before calling digest_init, so changing this code would still
4573 not be necessary. */
4574 if (!COMPOUND_LITERAL_P (init))
4577 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
4578 return reshape_init (type, init);
4581 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init));
4584 warning (OPT_Wmissing_braces, "missing braces around initializer for %qT",
4588 /* Dispatch to specialized routines. */
4589 if (CLASS_TYPE_P (type))
4590 return reshape_init_class (type, d, first_initializer_p);
4591 else if (TREE_CODE (type) == ARRAY_TYPE)
4592 return reshape_init_array (type, d);
4593 else if (TREE_CODE (type) == VECTOR_TYPE)
4594 return reshape_init_vector (type, d);
4599 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
4600 brace-enclosed aggregate initializer.
4602 INIT is the CONSTRUCTOR containing the list of initializers describing
4603 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
4604 It may not presently match the shape of the TYPE; for example:
4606 struct S { int a; int b; };
4607 struct S a[] = { 1, 2, 3, 4 };
4609 Here INIT will hold a VEC of four elements, rather than a
4610 VEC of two elements, each itself a VEC of two elements. This
4611 routine transforms INIT from the former form into the latter. The
4612 revised CONSTRUCTOR node is returned. */
4615 reshape_init (tree type, tree init)
4617 VEC(constructor_elt, gc) *v;
4621 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
4623 v = CONSTRUCTOR_ELTS (init);
4625 /* An empty constructor does not need reshaping, and it is always a valid
4627 if (VEC_empty (constructor_elt, v))
4630 /* Recurse on this CONSTRUCTOR. */
4631 d.cur = VEC_index (constructor_elt, v, 0);
4632 d.end = d.cur + VEC_length (constructor_elt, v);
4634 new_init = reshape_init_r (type, &d, true);
4635 if (new_init == error_mark_node)
4636 return error_mark_node;
4638 /* Make sure all the element of the constructor were used. Otherwise,
4639 issue an error about exceeding initializers. */
4641 error ("too many initializers for %qT", type);
4646 /* Verify INIT (the initializer for DECL), and record the
4647 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
4648 grok_reference_init.
4650 If the return value is non-NULL, it is an expression that must be
4651 evaluated dynamically to initialize DECL. */
4654 check_initializer (tree decl, tree init, int flags, tree *cleanup)
4656 tree type = TREE_TYPE (decl);
4657 tree init_code = NULL;
4659 /* Things that are going to be initialized need to have complete
4661 TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
4663 if (type == error_mark_node)
4664 /* We will have already complained. */
4666 else if (init && COMPLETE_TYPE_P (type)
4667 && !TREE_CONSTANT (TYPE_SIZE (type)))
4669 error ("variable-sized object %qD may not be initialized", decl);
4672 else if (TREE_CODE (type) == ARRAY_TYPE
4673 && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
4675 error ("elements of array %q#D have incomplete type", decl);
4678 else if (TREE_CODE (type) != ARRAY_TYPE && !COMPLETE_TYPE_P (type))
4680 error ("%qD has incomplete type", decl);
4681 TREE_TYPE (decl) = error_mark_node;
4685 if (TREE_CODE (decl) == CONST_DECL)
4687 gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);
4689 DECL_INITIAL (decl) = init;
4691 gcc_assert (init != NULL_TREE);
4694 else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
4695 init = grok_reference_init (decl, type, init, cleanup);
4698 /* Do not reshape constructors of vectors (they don't need to be
4700 if (TREE_CODE (init) == CONSTRUCTOR
4701 && !COMPOUND_LITERAL_P (init)
4702 && !TREE_TYPE (init)) /* ptrmemfunc */
4704 init = reshape_init (type, init);
4706 if ((*targetm.vector_opaque_p) (type))
4708 error ("opaque vector types cannot be initialized");
4709 init = error_mark_node;
4713 /* If DECL has an array type without a specific bound, deduce the
4714 array size from the initializer. */
4715 maybe_deduce_size_from_array_init (decl, init);
4716 type = TREE_TYPE (decl);
4718 if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
4720 if (TREE_CODE (type) == ARRAY_TYPE)
4721 goto initialize_aggr;
4722 else if (TREE_CODE (init) == CONSTRUCTOR)
4724 if (TYPE_NON_AGGREGATE_CLASS (type))
4726 error ("%qD must be initialized by constructor, "
4729 init = error_mark_node;
4732 goto dont_use_constructor;
4736 int saved_stmts_are_full_exprs_p;
4739 saved_stmts_are_full_exprs_p = 0;
4740 if (building_stmt_tree ())
4742 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
4743 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
4745 init = build_aggr_init (decl, init, flags);
4746 if (building_stmt_tree ())
4747 current_stmt_tree ()->stmts_are_full_exprs_p =
4748 saved_stmts_are_full_exprs_p;
4754 dont_use_constructor:
4755 if (TREE_CODE (init) != TREE_VEC)
4757 init_code = store_init_value (decl, init);
4758 if (pedantic && TREE_CODE (type) == ARRAY_TYPE
4759 && DECL_INITIAL (decl)
4760 && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST
4761 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl)))
4762 warning (0, "array %qD initialized by parenthesized string literal %qE",
4763 decl, DECL_INITIAL (decl));
4768 else if (DECL_EXTERNAL (decl))
4770 else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
4771 goto initialize_aggr;
4772 else if (IS_AGGR_TYPE (type))
4774 tree core_type = strip_array_types (type);
4776 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
4777 error ("structure %qD with uninitialized const members", decl);
4778 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
4779 error ("structure %qD with uninitialized reference members", decl);
4781 check_for_uninitialized_const_var (decl);
4784 check_for_uninitialized_const_var (decl);
4786 if (init && init != error_mark_node)
4787 init_code = build2 (INIT_EXPR, type, decl, init);
4792 /* If DECL is not a local variable, give it RTL. */
4795 make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
4797 int toplev = toplevel_bindings_p ();
4799 const char *filename;
4801 /* Set the DECL_ASSEMBLER_NAME for the object. */
4804 /* The `register' keyword, when used together with an
4805 asm-specification, indicates that the variable should be
4806 placed in a particular register. */
4807 if (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
4809 set_user_assembler_name (decl, asmspec);
4810 DECL_HARD_REGISTER (decl) = 1;
4814 if (TREE_CODE (decl) == FUNCTION_DECL
4815 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
4816 set_builtin_user_assembler_name (decl, asmspec);
4817 set_user_assembler_name (decl, asmspec);
4821 /* Handle non-variables up front. */
4822 if (TREE_CODE (decl) != VAR_DECL)
4824 rest_of_decl_compilation (decl, toplev, at_eof);
4828 /* If we see a class member here, it should be a static data
4830 if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
4832 gcc_assert (TREE_STATIC (decl));
4833 /* An in-class declaration of a static data member should be
4834 external; it is only a declaration, and not a definition. */
4835 if (init == NULL_TREE)
4836 gcc_assert (DECL_EXTERNAL (decl));
4839 /* We don't create any RTL for local variables. */
4840 if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
4843 /* We defer emission of local statics until the corresponding
4844 DECL_EXPR is expanded. */
4845 defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
4847 /* We try to defer namespace-scope static constants so that they are
4848 not emitted into the object file unnecessarily. */
4849 filename = input_filename;
4850 if (!DECL_VIRTUAL_P (decl)
4851 && TREE_READONLY (decl)
4852 && DECL_INITIAL (decl) != NULL_TREE
4853 && DECL_INITIAL (decl) != error_mark_node
4855 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
4857 && !TREE_PUBLIC (decl))
4859 /* Fool with the linkage of static consts according to #pragma
4861 struct c_fileinfo *finfo = get_fileinfo (lbasename (filename));
4862 if (!finfo->interface_unknown && !TREE_PUBLIC (decl))
4864 TREE_PUBLIC (decl) = 1;
4865 DECL_EXTERNAL (decl) = finfo->interface_only;
4870 /* Likewise for template instantiations. */
4871 else if (DECL_LANG_SPECIFIC (decl)
4872 && DECL_IMPLICIT_INSTANTIATION (decl))
4875 /* If we're not deferring, go ahead and assemble the variable. */
4877 rest_of_decl_compilation (decl, toplev, at_eof);
4880 /* Generate code to initialize DECL (a local variable). */
4883 initialize_local_var (tree decl, tree init)
4885 tree type = TREE_TYPE (decl);
4888 gcc_assert (TREE_CODE (decl) == VAR_DECL
4889 || TREE_CODE (decl) == RESULT_DECL);
4890 gcc_assert (!TREE_STATIC (decl));
4892 if (DECL_SIZE (decl) == NULL_TREE)
4894 /* If we used it already as memory, it must stay in memory. */
4895 DECL_INITIAL (decl) = NULL_TREE;
4896 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
4899 if (DECL_SIZE (decl) && type != error_mark_node)
4903 /* Compute and store the initial value. */
4904 already_used = TREE_USED (decl) || TREE_USED (type);
4906 /* Perform the initialization. */
4909 int saved_stmts_are_full_exprs_p;
4911 gcc_assert (building_stmt_tree ());
4912 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
4913 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
4914 finish_expr_stmt (init);
4915 current_stmt_tree ()->stmts_are_full_exprs_p =
4916 saved_stmts_are_full_exprs_p;
4919 /* Set this to 0 so we can tell whether an aggregate which was
4920 initialized was ever used. Don't do this if it has a
4921 destructor, so we don't complain about the 'resource
4922 allocation is initialization' idiom. Now set
4923 attribute((unused)) on types so decls of that type will be
4924 marked used. (see TREE_USED, above.) */
4925 if (TYPE_NEEDS_CONSTRUCTING (type)
4927 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
4928 && DECL_NAME (decl))
4929 TREE_USED (decl) = 0;
4930 else if (already_used)
4931 TREE_USED (decl) = 1;
4934 /* Generate a cleanup, if necessary. */
4935 cleanup = cxx_maybe_build_cleanup (decl);
4936 if (DECL_SIZE (decl) && cleanup)
4937 finish_decl_cleanup (decl, cleanup);
4940 /* DECL is a VAR_DECL for a compiler-generated variable with static
4941 storage duration (like a virtual table) whose initializer is a
4942 compile-time constant. INIT must be either a TREE_LIST of values,
4943 or a CONSTRUCTOR. Initialize the variable and provide it to the
4947 initialize_artificial_var (tree decl, tree init)
4949 if (TREE_CODE (init) == TREE_LIST)
4950 init = build_constructor_from_list (NULL_TREE, init);
4951 gcc_assert (TREE_CODE (init) == CONSTRUCTOR);
4952 DECL_INITIAL (decl) = init;
4953 DECL_INITIALIZED_P (decl) = 1;
4954 determine_visibility (decl);
4955 layout_var_decl (decl);
4956 maybe_commonize_var (decl);
4957 make_rtl_for_nonlocal_decl (decl, init, /*asmspec=*/NULL);
4960 /* Finish processing of a declaration;
4961 install its line number and initial value.
4962 If the length of an array type is not known before,
4963 it must be determined now, from the initial value, or it is an error.
4965 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
4966 true, then INIT is an integral constant expression.
4968 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
4969 if the (init) syntax was used. */
4972 cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
4973 tree asmspec_tree, int flags)
4977 const char *asmspec = NULL;
4978 int was_readonly = 0;
4979 bool var_definition_p = false;
4981 if (decl == error_mark_node)
4986 error ("assignment (not initialization) in declaration");
4990 gcc_assert (TREE_CODE (decl) != RESULT_DECL);
4992 /* Assume no cleanup is required. */
4993 cleanup = NULL_TREE;
4995 /* If a name was specified, get the string. */
4996 if (global_scope_p (current_binding_level))
4997 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
4999 asmspec = TREE_STRING_POINTER (asmspec_tree);
5001 if (init && TREE_CODE (init) == NAMESPACE_DECL)
5003 error ("cannot initialize %qD to namespace %qD", decl, init);
5007 if (current_class_type
5008 && CP_DECL_CONTEXT (decl) == current_class_type
5009 && TYPE_BEING_DEFINED (current_class_type)
5010 && (DECL_INITIAL (decl) || init))
5011 DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
5013 type = TREE_TYPE (decl);
5015 if (type == error_mark_node)
5018 if (processing_template_decl)
5020 /* Add this declaration to the statement-tree. */
5021 if (at_function_scope_p ())
5022 add_decl_expr (decl);
5026 DECL_INITIAL (decl) = init;
5027 if (init_const_expr_p)
5029 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
5030 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl))
5031 TREE_CONSTANT (decl) = 1;
5035 if (TREE_CODE (decl) == VAR_DECL
5036 && !DECL_PRETTY_FUNCTION_P (decl)
5037 && !dependent_type_p (TREE_TYPE (decl)))
5038 maybe_deduce_size_from_array_init (decl, init);
5043 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
5044 gcc_assert (TREE_CODE (decl) != PARM_DECL);
5046 /* Take care of TYPE_DECLs up front. */
5047 if (TREE_CODE (decl) == TYPE_DECL)
5049 if (type != error_mark_node
5050 && IS_AGGR_TYPE (type) && DECL_NAME (decl))
5052 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
5053 warning (0, "shadowing previous type declaration of %q#D", decl);
5054 set_identifier_type_value (DECL_NAME (decl), decl);
5057 /* If we have installed this as the canonical typedef for this
5058 type, and that type has not been defined yet, delay emitting
5059 the debug information for it, as we will emit it later. */
5060 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
5061 && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
5062 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
5064 rest_of_decl_compilation (decl, DECL_CONTEXT (decl) == NULL_TREE,
5069 /* A reference will be modified here, as it is initialized. */
5070 if (! DECL_EXTERNAL (decl)
5071 && TREE_READONLY (decl)
5072 && TREE_CODE (type) == REFERENCE_TYPE)
5075 TREE_READONLY (decl) = 0;
5078 if (TREE_CODE (decl) == VAR_DECL)
5080 /* Only PODs can have thread-local storage. Other types may require
5081 various kinds of non-trivial initialization. */
5082 if (DECL_THREAD_LOCAL_P (decl) && !pod_type_p (TREE_TYPE (decl)))
5083 error ("%qD cannot be thread-local because it has non-POD type %qT",
5084 decl, TREE_TYPE (decl));
5085 /* Convert the initializer to the type of DECL, if we have not
5086 already initialized DECL. */
5087 if (!DECL_INITIALIZED_P (decl)
5088 /* If !DECL_EXTERNAL then DECL is being defined. In the
5089 case of a static data member initialized inside the
5090 class-specifier, there can be an initializer even if DECL
5091 is *not* defined. */
5092 && (!DECL_EXTERNAL (decl) || init))
5096 DECL_NONTRIVIALLY_INITIALIZED_P (decl) = 1;
5097 if (init_const_expr_p)
5099 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
5100 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl))
5101 TREE_CONSTANT (decl) = 1;
5104 init = check_initializer (decl, init, flags, &cleanup);
5105 /* Thread-local storage cannot be dynamically initialized. */
5106 if (DECL_THREAD_LOCAL_P (decl) && init)
5108 error ("%qD is thread-local and so cannot be dynamically "
5109 "initialized", decl);
5113 /* Check that the initializer for a static data member was a
5114 constant. Although we check in the parser that the
5115 initializer is an integral constant expression, we do not
5116 simplify division-by-zero at the point at which it
5117 occurs. Therefore, in:
5119 struct S { static const int i = 7 / 0; };
5121 we issue an error at this point. It would
5122 probably be better to forbid division by zero in
5123 integral constant expressions. */
5124 if (DECL_EXTERNAL (decl) && init)
5126 error ("%qD cannot be initialized by a non-constant expression"
5127 " when being declared", decl);
5128 DECL_INITIALIZED_IN_CLASS_P (decl) = 0;
5136 The memory occupied by any object of static storage
5137 duration is zero-initialized at program startup before
5138 any other initialization takes place.
5140 We cannot create an appropriate initializer until after
5141 the type of DECL is finalized. If DECL_INITIAL is set,
5142 then the DECL is statically initialized, and any
5143 necessary zero-initialization has already been performed. */
5144 if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
5145 DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
5146 /*nelts=*/NULL_TREE,
5147 /*static_storage_p=*/true);
5148 /* Remember that the initialization for this variable has
5150 DECL_INITIALIZED_P (decl) = 1;
5151 /* This declaration is the definition of this variable,
5152 unless we are initializing a static data member within
5153 the class specifier. */
5154 if (!DECL_EXTERNAL (decl))
5155 var_definition_p = true;
5157 /* If the variable has an array type, lay out the type, even if
5158 there is no initializer. It is valid to index through the
5159 array, and we must get TYPE_ALIGN set correctly on the array
5161 else if (TREE_CODE (type) == ARRAY_TYPE)
5165 /* Add this declaration to the statement-tree. This needs to happen
5166 after the call to check_initializer so that the DECL_EXPR for a
5167 reference temp is added before the DECL_EXPR for the reference itself. */
5168 if (at_function_scope_p ())
5169 add_decl_expr (decl);
5171 if (TREE_CODE (decl) == VAR_DECL)
5172 layout_var_decl (decl);
5174 /* Output the assembler code and/or RTL code for variables and functions,
5175 unless the type is an undefined structure or union.
5176 If not, it will get done when the type is completed. */
5177 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
5179 if (TREE_CODE (decl) == VAR_DECL)
5180 maybe_commonize_var (decl);
5182 make_rtl_for_nonlocal_decl (decl, init, asmspec);
5184 /* Check for abstractness of the type. Notice that there is no
5185 need to strip array types here since the check for those types
5186 is already done within create_array_type_for_decl. */
5187 if (TREE_CODE (type) == FUNCTION_TYPE
5188 || TREE_CODE (type) == METHOD_TYPE)
5189 abstract_virtuals_error (decl, TREE_TYPE (type));
5191 abstract_virtuals_error (decl, type);
5193 if (TREE_CODE (decl) == FUNCTION_DECL
5194 || TREE_TYPE (decl) == error_mark_node)
5195 /* No initialization required. */
5197 else if (DECL_EXTERNAL (decl)
5198 && ! (DECL_LANG_SPECIFIC (decl)
5199 && DECL_NOT_REALLY_EXTERN (decl)))
5202 DECL_INITIAL (decl) = init;
5206 /* A variable definition. */
5207 if (DECL_FUNCTION_SCOPE_P (decl))
5209 /* Initialize the local variable. */
5210 if (processing_template_decl)
5211 DECL_INITIAL (decl) = init;
5212 else if (!TREE_STATIC (decl))
5213 initialize_local_var (decl, init);
5216 /* The variable is being defined, so determine its visibility.
5217 This needs to happen after the linkage is set. */
5218 determine_visibility (decl);
5220 /* If a variable is defined, and then a subsequent
5221 definition with external linkage is encountered, we will
5222 get here twice for the same variable. We want to avoid
5223 calling expand_static_init more than once. For variables
5224 that are not static data members, we can call
5225 expand_static_init only when we actually process the
5226 initializer. It is not legal to redeclare a static data
5227 member, so this issue does not arise in that case. */
5228 if (var_definition_p && TREE_STATIC (decl))
5229 expand_static_init (decl, init);
5233 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
5234 reference, insert it in the statement-tree now. */
5236 push_cleanup (decl, cleanup, false);
5241 TREE_READONLY (decl) = 1;
5243 /* If this was marked 'used', be sure it will be output. */
5244 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
5245 mark_decl_referenced (decl);
5248 /* This is here for a midend callback from c-common.c. */
5251 finish_decl (tree decl, tree init, tree asmspec_tree)
5253 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, asmspec_tree, 0);
5256 /* Returns a declaration for a VAR_DECL as if:
5258 extern "C" TYPE NAME;
5260 had been seen. Used to create compiler-generated global
5264 declare_global_var (tree name, tree type)
5268 push_to_top_level ();
5269 decl = build_decl (VAR_DECL, name, type);
5270 TREE_PUBLIC (decl) = 1;
5271 DECL_EXTERNAL (decl) = 1;
5272 DECL_ARTIFICIAL (decl) = 1;
5273 /* If the user has explicitly declared this variable (perhaps
5274 because the code we are compiling is part of a low-level runtime
5275 library), then it is possible that our declaration will be merged
5276 with theirs by pushdecl. */
5277 decl = pushdecl (decl);
5278 finish_decl (decl, NULL_TREE, NULL_TREE);
5279 pop_from_top_level ();
5284 /* Returns a pointer to the `atexit' function. Note that if
5285 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
5286 `__cxa_atexit' function specified in the IA64 C++ ABI. */
5289 get_atexit_node (void)
5296 bool use_aeabi_atexit;
5301 if (flag_use_cxa_atexit)
5303 /* The declaration for `__cxa_atexit' is:
5305 int __cxa_atexit (void (*)(void *), void *, void *)
5307 We build up the argument types and then then function type
5310 use_aeabi_atexit = targetm.cxx.use_aeabi_atexit ();
5311 /* First, build the pointer-to-function type for the first
5313 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5314 fn_type = build_function_type (void_type_node, arg_types);
5315 fn_ptr_type = build_pointer_type (fn_type);
5316 /* Then, build the rest of the argument types. */
5317 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5318 if (use_aeabi_atexit)
5320 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
5321 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
5325 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
5326 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
5328 /* And the final __cxa_atexit type. */
5329 fn_type = build_function_type (integer_type_node, arg_types);
5330 fn_ptr_type = build_pointer_type (fn_type);
5331 if (use_aeabi_atexit)
5332 name = "__aeabi_atexit";
5334 name = "__cxa_atexit";
5338 /* The declaration for `atexit' is:
5340 int atexit (void (*)());
5342 We build up the argument types and then then function type
5344 fn_type = build_function_type (void_type_node, void_list_node);
5345 fn_ptr_type = build_pointer_type (fn_type);
5346 arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
5347 /* Build the final atexit type. */
5348 fn_type = build_function_type (integer_type_node, arg_types);
5352 /* Now, build the function declaration. */
5353 push_lang_context (lang_name_c);
5354 atexit_fndecl = build_library_fn_ptr (name, fn_type);
5355 mark_used (atexit_fndecl);
5356 pop_lang_context ();
5357 atexit_node = decay_conversion (atexit_fndecl);
5362 /* Returns the __dso_handle VAR_DECL. */
5365 get_dso_handle_node (void)
5367 if (dso_handle_node)
5368 return dso_handle_node;
5370 /* Declare the variable. */
5371 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
5374 return dso_handle_node;
5377 /* Begin a new function with internal linkage whose job will be simply
5378 to destroy some particular variable. */
5380 static GTY(()) int start_cleanup_cnt;
5383 start_cleanup_fn (void)
5390 push_to_top_level ();
5392 /* No need to mangle this. */
5393 push_lang_context (lang_name_c);
5395 /* Build the parameter-types. */
5396 parmtypes = void_list_node;
5397 /* Functions passed to __cxa_atexit take an additional parameter.
5398 We'll just ignore it. After we implement the new calling
5399 convention for destructors, we can eliminate the use of
5400 additional cleanup functions entirely in the -fnew-abi case. */
5401 if (flag_use_cxa_atexit)
5402 parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
5403 /* Build the function type itself. */
5404 fntype = build_function_type (void_type_node, parmtypes);
5405 /* Build the name of the function. */
5406 sprintf (name, "__tcf_%d", start_cleanup_cnt++);
5407 /* Build the function declaration. */
5408 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
5409 /* It's a function with internal linkage, generated by the
5411 TREE_PUBLIC (fndecl) = 0;
5412 DECL_ARTIFICIAL (fndecl) = 1;
5413 /* Make the function `inline' so that it is only emitted if it is
5414 actually needed. It is unlikely that it will be inlined, since
5415 it is only called via a function pointer, but we avoid unnecessary
5416 emissions this way. */
5417 DECL_INLINE (fndecl) = 1;
5418 DECL_DECLARED_INLINE_P (fndecl) = 1;
5419 DECL_INTERFACE_KNOWN (fndecl) = 1;
5420 /* Build the parameter. */
5421 if (flag_use_cxa_atexit)
5425 parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
5426 DECL_CONTEXT (parmdecl) = fndecl;
5427 TREE_USED (parmdecl) = 1;
5428 DECL_ARGUMENTS (fndecl) = parmdecl;
5432 start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED);
5434 pop_lang_context ();
5436 return current_function_decl;
5439 /* Finish the cleanup function begun by start_cleanup_fn. */
5442 end_cleanup_fn (void)
5444 expand_or_defer_fn (finish_function (0));
5446 pop_from_top_level ();
5449 /* Generate code to handle the destruction of DECL, an object with
5450 static storage duration. */
5453 register_dtor_fn (tree decl)
5460 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
5461 return void_zero_node;
5463 /* Call build_cleanup before we enter the anonymous function so that
5464 any access checks will be done relative to the current scope,
5465 rather than the scope of the anonymous function. */
5466 build_cleanup (decl);
5468 /* Now start the function. */
5469 cleanup = start_cleanup_fn ();
5471 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
5472 to the original function, rather than the anonymous one. That
5473 will make the back-end think that nested functions are in use,
5474 which causes confusion. */
5476 push_deferring_access_checks (dk_no_check);
5477 fcall = build_cleanup (decl);
5478 pop_deferring_access_checks ();
5480 /* Create the body of the anonymous function. */
5481 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
5482 finish_expr_stmt (fcall);
5483 finish_compound_stmt (compound_stmt);
5486 /* Call atexit with the cleanup function. */
5487 cxx_mark_addressable (cleanup);
5488 mark_used (cleanup);
5489 cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
5490 if (flag_use_cxa_atexit)
5492 args = tree_cons (NULL_TREE,
5493 build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0),
5495 if (targetm.cxx.use_aeabi_atexit ())
5497 args = tree_cons (NULL_TREE, cleanup, args);
5498 args = tree_cons (NULL_TREE, null_pointer_node, args);
5502 args = tree_cons (NULL_TREE, null_pointer_node, args);
5503 args = tree_cons (NULL_TREE, cleanup, args);
5507 args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
5508 return build_function_call (get_atexit_node (), args);
5511 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
5512 is its initializer. Generate code to handle the construction
5513 and destruction of DECL. */
5516 expand_static_init (tree decl, tree init)
5518 gcc_assert (TREE_CODE (decl) == VAR_DECL);
5519 gcc_assert (TREE_STATIC (decl));
5521 /* Some variables require no initialization. */
5523 && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
5524 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
5527 if (DECL_FUNCTION_SCOPE_P (decl))
5529 /* Emit code to perform this initialization but once. */
5530 tree if_stmt = NULL_TREE, inner_if_stmt = NULL_TREE;
5531 tree then_clause = NULL_TREE, inner_then_clause = NULL_TREE;
5532 tree guard, guard_addr, guard_addr_list;
5533 tree acquire_fn, release_fn, abort_fn;
5536 /* Emit code to perform this initialization but once. This code
5539 static <type> guard;
5540 if (!guard.first_byte) {
5541 if (__cxa_guard_acquire (&guard)) {
5544 // Do initialization.
5545 flag = true; __cxa_guard_release (&guard);
5546 // Register variable for destruction at end of program.
5548 if (!flag) __cxa_guard_abort (&guard);
5552 Note that the `flag' variable is only set to 1 *after* the
5553 initialization is complete. This ensures that an exception,
5554 thrown during the construction, will cause the variable to
5555 reinitialized when we pass through this code again, as per:
5559 If the initialization exits by throwing an exception, the
5560 initialization is not complete, so it will be tried again
5561 the next time control enters the declaration.
5563 This process should be thread-safe, too; multiple threads
5564 should not be able to initialize the variable more than
5567 /* Create the guard variable. */
5568 guard = get_guard (decl);
5570 /* This optimization isn't safe on targets with relaxed memory
5571 consistency. On such targets we force synchronization in
5572 __cxa_guard_acquire. */
5573 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
5575 /* Begin the conditional initialization. */
5576 if_stmt = begin_if_stmt ();
5577 finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
5578 then_clause = begin_compound_stmt (BCS_NO_SCOPE);
5581 if (flag_threadsafe_statics)
5583 guard_addr = build_address (guard);
5584 guard_addr_list = build_tree_list (NULL_TREE, guard_addr);
5586 acquire_fn = get_identifier ("__cxa_guard_acquire");
5587 release_fn = get_identifier ("__cxa_guard_release");
5588 abort_fn = get_identifier ("__cxa_guard_abort");
5589 if (!get_global_value_if_present (acquire_fn, &acquire_fn))
5591 tree argtypes = tree_cons (NULL_TREE, TREE_TYPE (guard_addr),
5593 tree vfntype = build_function_type (void_type_node, argtypes);
5594 acquire_fn = push_library_fn
5595 (acquire_fn, build_function_type (integer_type_node, argtypes));
5596 release_fn = push_library_fn (release_fn, vfntype);
5597 abort_fn = push_library_fn (abort_fn, vfntype);
5601 release_fn = identifier_global_value (release_fn);
5602 abort_fn = identifier_global_value (abort_fn);
5605 inner_if_stmt = begin_if_stmt ();
5606 finish_if_stmt_cond (build_call (acquire_fn, guard_addr_list),
5609 inner_then_clause = begin_compound_stmt (BCS_NO_SCOPE);
5610 begin = get_target_expr (boolean_false_node);
5611 flag = TARGET_EXPR_SLOT (begin);
5613 TARGET_EXPR_CLEANUP (begin)
5614 = build3 (COND_EXPR, void_type_node, flag,
5616 build_call (abort_fn, guard_addr_list));
5617 CLEANUP_EH_ONLY (begin) = 1;
5619 /* Do the initialization itself. */
5620 init = add_stmt_to_compound (begin, init);
5621 init = add_stmt_to_compound
5622 (init, build2 (MODIFY_EXPR, void_type_node, flag, boolean_true_node));
5623 init = add_stmt_to_compound
5624 (init, build_call (release_fn, guard_addr_list));
5627 init = add_stmt_to_compound (init, set_guard (guard));
5629 /* Use atexit to register a function for destroying this static
5631 init = add_stmt_to_compound (init, register_dtor_fn (decl));
5633 finish_expr_stmt (init);
5635 if (flag_threadsafe_statics)
5637 finish_compound_stmt (inner_then_clause);
5638 finish_then_clause (inner_if_stmt);
5639 finish_if_stmt (inner_if_stmt);
5642 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
5644 finish_compound_stmt (then_clause);
5645 finish_then_clause (if_stmt);
5646 finish_if_stmt (if_stmt);
5650 static_aggregates = tree_cons (init, decl, static_aggregates);
5654 /* Make TYPE a complete type based on INITIAL_VALUE.
5655 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
5656 2 if there was no information (in which case assume 0 if DO_DEFAULT),
5657 3 if the initializer list is empty (in pedantic mode). */
5660 cp_complete_array_type (tree *ptype, tree initial_value, bool do_default)
5663 tree type, elt_type;
5667 /* An array of character type can be initialized from a
5668 brace-enclosed string constant.
5670 FIXME: this code is duplicated from reshape_init. Probably
5671 we should just call reshape_init here? */
5672 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype)))
5673 && TREE_CODE (initial_value) == CONSTRUCTOR
5674 && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (initial_value)))
5676 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
5677 tree value = VEC_index (constructor_elt, v, 0)->value;
5679 if (TREE_CODE (value) == STRING_CST
5680 && VEC_length (constructor_elt, v) == 1)
5681 initial_value = value;
5685 failure = complete_array_type (ptype, initial_value, do_default);
5687 /* We can create the array before the element type is complete, which
5688 means that we didn't have these two bits set in the original type
5689 either. In completing the type, we are expected to propagate these
5690 bits. See also complete_type which does the same thing for arrays
5693 if (TYPE_DOMAIN (type))
5695 elt_type = TREE_TYPE (type);
5696 TYPE_NEEDS_CONSTRUCTING (type) = TYPE_NEEDS_CONSTRUCTING (elt_type);
5697 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
5698 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type);
5704 /* Return zero if something is declared to be a member of type
5705 CTYPE when in the context of CUR_TYPE. STRING is the error
5706 message to print in that case. Otherwise, quietly return 1. */
5709 member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
5711 if (ctype && ctype != cur_type)
5713 if (flags == DTOR_FLAG)
5714 error ("destructor for alien class %qT cannot be a member", ctype);
5716 error ("constructor for alien class %qT cannot be a member", ctype);
5722 /* Subroutine of `grokdeclarator'. */
5724 /* Generate errors possibly applicable for a given set of specifiers.
5725 This is for ARM $7.1.2. */
5728 bad_specifiers (tree object,
5737 error ("%qD declared as a %<virtual%> %s", object, type);
5739 error ("%qD declared as an %<inline%> %s", object, type);
5741 error ("%<const%> and %<volatile%> function specifiers on "
5742 "%qD invalid in %s declaration",
5745 error ("%q+D declared as a friend", object);
5747 && (TREE_CODE (object) == TYPE_DECL
5748 || (!TYPE_PTRFN_P (TREE_TYPE (object))
5749 && !TYPE_REFFN_P (TREE_TYPE (object))
5750 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
5751 error ("%q+D declared with an exception specification", object);
5754 /* DECL is a member function or static data member and is presently
5755 being defined. Check that the definition is taking place in a
5759 check_class_member_definition_namespace (tree decl)
5761 /* These checks only apply to member functions and static data
5763 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
5764 || TREE_CODE (decl) == VAR_DECL);
5765 /* We check for problems with specializations in pt.c in
5766 check_specialization_namespace, where we can issue better
5768 if (processing_specialization)
5770 /* There are no restrictions on the placement of
5771 explicit instantiations. */
5772 if (processing_explicit_instantiation)
5776 A member function definition that appears outside of the
5777 class definition shall appear in a namespace scope enclosing
5778 the class definition.
5782 The definition for a static data member shall appear in a
5783 namespace scope enclosing the member's class definition. */
5784 if (!is_ancestor (current_namespace, DECL_CONTEXT (decl)))
5785 pedwarn ("definition of %qD is not in namespace enclosing %qT",
5786 decl, DECL_CONTEXT (decl));
5789 /* Build a PARM_DECL for the "this" parameter. TYPE is the
5790 METHOD_TYPE for a non-static member function; QUALS are the
5791 cv-qualifiers that apply to the function. */
5794 build_this_parm (tree type, cp_cv_quals quals)
5799 cp_cv_quals this_quals;
5801 this_type = TREE_VALUE (TYPE_ARG_TYPES (type));
5802 /* The `this' parameter is implicitly `const'; it cannot be
5804 this_quals = (quals & TYPE_QUAL_RESTRICT) | TYPE_QUAL_CONST;
5805 qual_type = cp_build_qualified_type (this_type, this_quals);
5806 parm = build_artificial_parm (this_identifier, qual_type);
5807 cp_apply_type_quals_to_decl (this_quals, parm);
5811 /* CTYPE is class type, or null if non-class.
5812 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
5814 DECLARATOR is the function's name.
5815 PARMS is a chain of PARM_DECLs for the function.
5816 VIRTUALP is truthvalue of whether the function is virtual or not.
5817 FLAGS are to be passed through to `grokclassfn'.
5818 QUALS are qualifiers indicating whether the function is `const'
5820 RAISES is a list of exceptions that this function can raise.
5821 CHECK is 1 if we must find this method in CTYPE, 0 if we should
5822 not look, and -1 if we should not call `grokclassfn' at all.
5824 SFK is the kind of special function (if any) for the new function.
5826 Returns `NULL_TREE' if something goes wrong, after issuing
5827 applicable error messages. */
5830 grokfndecl (tree ctype,
5834 tree orig_declarator,
5836 enum overload_flags flags,
5843 special_function_kind sfk,
5850 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
5854 type = build_exception_variant (type, raises);
5856 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
5857 if (TREE_CODE (type) == METHOD_TYPE)
5860 parm = build_this_parm (type, quals);
5861 TREE_CHAIN (parm) = parms;
5864 DECL_ARGUMENTS (decl) = parms;
5865 /* Propagate volatile out from type to decl. */
5866 if (TYPE_VOLATILE (type))
5867 TREE_THIS_VOLATILE (decl) = 1;
5870 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
5874 ("defining explicit specialization %qD in friend declaration",
5878 tree fns = TREE_OPERAND (orig_declarator, 0);
5879 tree args = TREE_OPERAND (orig_declarator, 1);
5881 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
5883 /* Something like `template <class T> friend void f<T>()'. */
5884 error ("invalid use of template-id %qD in declaration "
5885 "of primary template",
5891 /* A friend declaration of the form friend void f<>(). Record
5892 the information in the TEMPLATE_ID_EXPR. */
5893 SET_DECL_IMPLICIT_INSTANTIATION (decl);
5895 if (TREE_CODE (fns) == COMPONENT_REF)
5897 /* Due to bison parser ickiness, we will have already looked
5898 up an operator_name or PFUNCNAME within the current class
5899 (see template_id in parse.y). If the current class contains
5900 such a name, we'll get a COMPONENT_REF here. Undo that. */
5902 gcc_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
5903 == current_class_type);
5904 fns = TREE_OPERAND (fns, 1);
5906 gcc_assert (TREE_CODE (fns) == IDENTIFIER_NODE
5907 || TREE_CODE (fns) == OVERLOAD);
5908 DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
5910 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
5911 if (TREE_PURPOSE (t)
5912 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
5914 error ("default arguments are not allowed in declaration "
5915 "of friend template specialization %qD",
5922 error ("%<inline%> is not allowed in declaration of friend "
5923 "template specialization %qD",
5930 /* If this decl has namespace scope, set that up. */
5932 set_decl_namespace (decl, in_namespace, friendp);
5934 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
5936 /* `main' and builtins have implicit 'C' linkage. */
5937 if ((MAIN_NAME_P (declarator)
5938 || (IDENTIFIER_LENGTH (declarator) > 10
5939 && IDENTIFIER_POINTER (declarator)[0] == '_'
5940 && IDENTIFIER_POINTER (declarator)[1] == '_'
5941 && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
5942 && current_lang_name == lang_name_cplusplus
5943 && ctype == NULL_TREE
5944 /* NULL_TREE means global namespace. */
5945 && DECL_CONTEXT (decl) == NULL_TREE)
5946 SET_DECL_LANGUAGE (decl, lang_c);
5948 /* Should probably propagate const out from type to decl I bet (mrs). */
5951 DECL_STATIC_FUNCTION_P (decl) = 1;
5952 DECL_CONTEXT (decl) = ctype;
5957 DECL_CONTEXT (decl) = ctype;
5959 check_class_member_definition_namespace (decl);
5962 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
5964 if (processing_template_decl)
5965 error ("cannot declare %<::main%> to be a template");
5967 error ("cannot declare %<::main%> to be inline");
5969 error ("cannot declare %<::main%> to be static");
5970 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
5973 tree oldtypeargs = TYPE_ARG_TYPES (TREE_TYPE (decl));
5975 error ("%<::main%> must return %<int%>");
5976 newtype = build_function_type (integer_type_node,
5978 TREE_TYPE (decl) = newtype;
5984 /* Members of anonymous types and local classes have no linkage; make
5985 them internal. If a typedef is made later, this will be changed. */
5986 if (ctype && (TYPE_ANONYMOUS_P (ctype)
5987 || decl_function_context (TYPE_MAIN_DECL (ctype))))
5992 /* [basic.link]: A name with no linkage (notably, the name of a class
5993 or enumeration declared in a local scope) shall not be used to
5994 declare an entity with linkage.
5996 Only check this for public decls for now. See core 319, 389. */
5997 t = no_linkage_check (TREE_TYPE (decl),
5998 /*relaxed_p=*/false);
6001 if (TYPE_ANONYMOUS_P (t))
6003 if (DECL_EXTERN_C_P (decl))
6004 /* Allow this; it's pretty common in C. */;
6007 pedwarn ("non-local function %q#D uses anonymous type",
6009 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
6010 pedwarn ("%q+#D does not refer to the unqualified "
6011 "type, so it is not used for linkage",
6016 pedwarn ("non-local function %q#D uses local type %qT", decl, t);
6020 TREE_PUBLIC (decl) = publicp;
6023 DECL_INTERFACE_KNOWN (decl) = 1;
6024 DECL_NOT_REALLY_EXTERN (decl) = 1;
6027 /* If the declaration was declared inline, mark it as such. */
6029 DECL_DECLARED_INLINE_P (decl) = 1;
6030 /* We inline functions that are explicitly declared inline, or, when
6031 the user explicitly asks us to, all functions. */
6032 if (DECL_DECLARED_INLINE_P (decl)
6033 || (flag_inline_trees == 2 && !DECL_INLINE (decl) && funcdef_flag))
6034 DECL_INLINE (decl) = 1;
6036 DECL_EXTERNAL (decl) = 1;
6037 if (quals && TREE_CODE (type) == FUNCTION_TYPE)
6039 error ("%smember function %qD cannot have cv-qualifier",
6040 (ctype ? "static " : "non-"), decl);
6041 quals = TYPE_UNQUALIFIED;
6044 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
6045 grok_op_properties (decl, /*complain=*/true);
6047 if (ctype && decl_function_context (decl))
6048 DECL_NO_STATIC_CHAIN (decl) = 1;
6051 /* Make the init_value nonzero so pushdecl knows this is not
6052 tentative. error_mark_node is replaced later with the BLOCK. */
6053 DECL_INITIAL (decl) = error_mark_node;
6055 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
6056 TREE_NOTHROW (decl) = 1;
6058 /* Caller will do the rest of this. */
6062 if (ctype != NULL_TREE)
6064 if (sfk == sfk_constructor)
6065 DECL_CONSTRUCTOR_P (decl) = 1;
6067 grokclassfn (ctype, decl, flags);
6070 decl = check_explicit_specialization (orig_declarator, decl,
6073 4 * (friendp != 0));
6074 if (decl == error_mark_node)
6079 cplus_decl_attributes (&decl, *attrlist, 0);
6080 *attrlist = NULL_TREE;
6083 if (ctype != NULL_TREE
6084 && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
6089 old_decl = check_classfn (ctype, decl,
6090 (processing_template_decl
6091 > template_class_depth (ctype))
6092 ? current_template_parms
6099 if (TREE_CODE (old_decl) == TEMPLATE_DECL)
6100 /* Because grokfndecl is always supposed to return a
6101 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
6102 here. We depend on our callers to figure out that its
6103 really a template that's being returned. */
6104 old_decl = DECL_TEMPLATE_RESULT (old_decl);
6106 if (DECL_STATIC_FUNCTION_P (old_decl)
6107 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
6108 /* Remove the `this' parm added by grokclassfn.
6109 XXX Isn't this done in start_function, too? */
6110 revert_static_member_fn (decl);
6111 if (DECL_ARTIFICIAL (old_decl))
6112 error ("definition of implicitly-declared %qD", old_decl);
6114 /* Since we've smashed OLD_DECL to its
6115 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
6116 if (TREE_CODE (decl) == TEMPLATE_DECL)
6117 decl = DECL_TEMPLATE_RESULT (decl);
6119 /* Attempt to merge the declarations. This can fail, in
6120 the case of some invalid specialization declarations. */
6121 pushed_scope = push_scope (ctype);
6122 ok = duplicate_decls (decl, old_decl, friendp);
6124 pop_scope (pushed_scope);
6127 error ("no %q#D member function declared in class %qT",
6135 if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
6138 if (ctype == NULL_TREE || check)
6142 DECL_VIRTUAL_P (decl) = 1;
6147 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
6148 the linkage that DECL will receive in the object file. */
6151 set_linkage_for_static_data_member (tree decl)
6153 /* A static data member always has static storage duration and
6154 external linkage. Note that static data members are forbidden in
6155 local classes -- the only situation in which a class has
6156 non-external linkage. */
6157 TREE_PUBLIC (decl) = 1;
6158 TREE_STATIC (decl) = 1;
6159 /* For non-template classes, static data members are always put
6160 out in exactly those files where they are defined, just as
6161 with ordinary namespace-scope variables. */
6162 if (!processing_template_decl)
6163 DECL_INTERFACE_KNOWN (decl) = 1;
6166 /* Create a VAR_DECL named NAME with the indicated TYPE.
6168 If SCOPE is non-NULL, it is the class type or namespace containing
6169 the variable. If SCOPE is NULL, the variable should is created in
6170 the innermost enclosings scope. */
6173 grokvardecl (tree type,
6175 const cp_decl_specifier_seq *declspecs,
6181 tree explicit_scope;
6183 gcc_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE);
6185 /* Compute the scope in which to place the variable, but remember
6186 whether or not that scope was explicitly specified by the user. */
6187 explicit_scope = scope;
6190 /* An explicit "extern" specifier indicates a namespace-scope
6192 if (declspecs->storage_class == sc_extern)
6193 scope = current_namespace;
6194 else if (!at_function_scope_p ())
6195 scope = current_scope ();
6199 && (/* If the variable is a namespace-scope variable declared in a
6200 template, we need DECL_LANG_SPECIFIC. */
6201 (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
6202 /* Similarly for namespace-scope variables with language linkage
6204 || (TREE_CODE (scope) == NAMESPACE_DECL
6205 && current_lang_name != lang_name_cplusplus)
6206 /* Similarly for static data members. */
6208 decl = build_lang_decl (VAR_DECL, name, type);
6210 decl = build_decl (VAR_DECL, name, type);
6212 if (explicit_scope && TREE_CODE (explicit_scope) == NAMESPACE_DECL)
6213 set_decl_namespace (decl, explicit_scope, 0);
6215 DECL_CONTEXT (decl) = scope;
6217 if (declspecs->storage_class == sc_extern)
6219 DECL_THIS_EXTERN (decl) = 1;
6220 DECL_EXTERNAL (decl) = !initialized;
6223 if (DECL_CLASS_SCOPE_P (decl))
6225 set_linkage_for_static_data_member (decl);
6226 /* This function is only called with out-of-class definitions. */
6227 DECL_EXTERNAL (decl) = 0;
6228 check_class_member_definition_namespace (decl);
6230 /* At top level, either `static' or no s.c. makes a definition
6231 (perhaps tentative), and absence of `static' makes it public. */
6232 else if (toplevel_bindings_p ())
6234 TREE_PUBLIC (decl) = (declspecs->storage_class != sc_static
6235 && (DECL_THIS_EXTERN (decl) || ! constp));
6236 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
6238 /* Not at top level, only `static' makes a static definition. */
6241 TREE_STATIC (decl) = declspecs->storage_class == sc_static;
6242 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
6245 if (declspecs->specs[(int)ds_thread])
6247 if (targetm.have_tls)
6248 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
6250 /* A mere warning is sure to result in improper semantics
6251 at runtime. Don't bother to allow this to compile. */
6252 error ("thread-local storage not supported for this target");
6255 if (TREE_PUBLIC (decl))
6257 /* [basic.link]: A name with no linkage (notably, the name of a class
6258 or enumeration declared in a local scope) shall not be used to
6259 declare an entity with linkage.
6261 Only check this for public decls for now. */
6262 tree t = no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false);
6265 if (TYPE_ANONYMOUS_P (t))
6267 if (DECL_EXTERN_C_P (decl))
6268 /* Allow this; it's pretty common in C. */
6272 /* DRs 132, 319 and 389 seem to indicate types with
6273 no linkage can only be used to declare extern "C"
6274 entities. Since it's not always an error in the
6275 ISO C++ 90 Standard, we only issue a warning. */
6276 warning (0, "non-local variable %q#D uses anonymous type",
6278 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
6279 warning (0, "%q+#D does not refer to the unqualified "
6280 "type, so it is not used for linkage",
6285 warning (0, "non-local variable %q#D uses local type %qT", decl, t);
6289 DECL_INTERFACE_KNOWN (decl) = 1;
6294 /* Create and return a canonical pointer to member function type, for
6295 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
6298 build_ptrmemfunc_type (tree type)
6302 tree unqualified_variant = NULL_TREE;
6304 if (type == error_mark_node)
6307 /* If a canonical type already exists for this type, use it. We use
6308 this method instead of type_hash_canon, because it only does a
6309 simple equality check on the list of field members. */
6311 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
6314 /* Make sure that we always have the unqualified pointer-to-member
6316 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
6318 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
6320 t = make_aggr_type (RECORD_TYPE);
6321 xref_basetypes (t, NULL_TREE);
6323 /* Let the front-end know this is a pointer to member function... */
6324 TYPE_PTRMEMFUNC_FLAG (t) = 1;
6325 /* ... and not really an aggregate. */
6326 SET_IS_AGGR_TYPE (t, 0);
6328 field = build_decl (FIELD_DECL, pfn_identifier, type);
6331 field = build_decl (FIELD_DECL, delta_identifier, delta_type_node);
6332 TREE_CHAIN (field) = fields;
6335 finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
6337 /* Zap out the name so that the back-end will give us the debugging
6338 information for this anonymous RECORD_TYPE. */
6339 TYPE_NAME (t) = NULL_TREE;
6341 /* If this is not the unqualified form of this pointer-to-member
6342 type, set the TYPE_MAIN_VARIANT for this type to be the
6343 unqualified type. Since they are actually RECORD_TYPEs that are
6344 not variants of each other, we must do this manually. */
6345 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
6347 t = build_qualified_type (t, cp_type_quals (type));
6348 TYPE_MAIN_VARIANT (t) = unqualified_variant;
6349 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
6350 TYPE_NEXT_VARIANT (unqualified_variant) = t;
6353 /* Cache this pointer-to-member type so that we can find it again
6355 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
6360 /* Create and return a pointer to data member type. */
6363 build_ptrmem_type (tree class_type, tree member_type)
6365 if (TREE_CODE (member_type) == METHOD_TYPE)
6369 arg_types = TYPE_ARG_TYPES (member_type);
6370 class_type = (cp_build_qualified_type
6372 cp_type_quals (TREE_TYPE (TREE_VALUE (arg_types)))));
6374 = build_method_type_directly (class_type,
6375 TREE_TYPE (member_type),
6376 TREE_CHAIN (arg_types));
6377 return build_ptrmemfunc_type (build_pointer_type (member_type));
6381 gcc_assert (TREE_CODE (member_type) != FUNCTION_TYPE);
6382 return build_offset_type (class_type, member_type);
6386 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
6387 Check to see that the definition is valid. Issue appropriate error
6388 messages. Return 1 if the definition is particularly bad, or 0
6392 check_static_variable_definition (tree decl, tree type)
6394 /* Motion 10 at San Diego: If a static const integral data member is
6395 initialized with an integral constant expression, the initializer
6396 may appear either in the declaration (within the class), or in
6397 the definition, but not both. If it appears in the class, the
6398 member is a member constant. The file-scope definition is always
6400 if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
6402 error ("invalid in-class initialization of static data member "
6403 "of non-integral type %qT",
6405 /* If we just return the declaration, crashes will sometimes
6406 occur. We therefore return void_type_node, as if this were a
6407 friend declaration, to cause callers to completely ignore
6408 this declaration. */
6411 else if (!CP_TYPE_CONST_P (type))
6412 error ("ISO C++ forbids in-class initialization of non-const "
6413 "static member %qD",
6415 else if (pedantic && !INTEGRAL_TYPE_P (type))
6416 pedwarn ("ISO C++ forbids initialization of member constant "
6417 "%qD of non-integral type %qT", decl, type);
6422 /* Given the SIZE (i.e., number of elements) in an array, compute an
6423 appropriate index type for the array. If non-NULL, NAME is the
6424 name of the thing being declared. */
6427 compute_array_index_type (tree name, tree size)
6432 if (error_operand_p (size))
6433 return error_mark_node;
6435 type = TREE_TYPE (size);
6436 /* The array bound must be an integer type. */
6437 if (!dependent_type_p (type) && !INTEGRAL_TYPE_P (type))
6440 error ("size of array %qD has non-integral type %qT", name, type);
6442 error ("size of array has non-integral type %qT", type);
6443 size = integer_one_node;
6444 type = TREE_TYPE (size);
6447 if (abi_version_at_least (2)
6448 /* We should only handle value dependent expressions specially. */
6449 ? value_dependent_expression_p (size)
6450 /* But for abi-1, we handled all instances in templates. This
6451 effects the manglings produced. */
6452 : processing_template_decl)
6453 return build_index_type (build_min (MINUS_EXPR, sizetype,
6454 size, integer_one_node));
6456 /* The size might be the result of a cast. */
6457 STRIP_TYPE_NOPS (size);
6459 /* It might be a const variable or enumeration constant. */
6460 size = integral_constant_value (size);
6462 /* Normally, the array-bound will be a constant. */
6463 if (TREE_CODE (size) == INTEGER_CST)
6465 /* Check to see if the array bound overflowed. Make that an
6466 error, no matter how generous we're being. */
6467 int old_flag_pedantic_errors = flag_pedantic_errors;
6468 int old_pedantic = pedantic;
6469 pedantic = flag_pedantic_errors = 1;
6470 constant_expression_warning (size);
6471 pedantic = old_pedantic;
6472 flag_pedantic_errors = old_flag_pedantic_errors;
6474 /* An array must have a positive number of elements. */
6475 if (INT_CST_LT (size, integer_zero_node))
6478 error ("size of array %qD is negative", name);
6480 error ("size of array is negative");
6481 size = integer_one_node;
6483 /* As an extension we allow zero-sized arrays. We always allow
6484 them in system headers because glibc uses them. */
6485 else if (integer_zerop (size) && pedantic && !in_system_header)
6488 pedwarn ("ISO C++ forbids zero-size array %qD", name);
6490 pedwarn ("ISO C++ forbids zero-size array");
6493 else if (TREE_CONSTANT (size))
6495 /* `(int) &fn' is not a valid array bound. */
6497 error ("size of array %qD is not an integral constant-expression",
6500 error ("size of array is not an integral constant-expression");
6501 size = integer_one_node;
6506 pedwarn ("ISO C++ forbids variable-size array %qD", name);
6508 pedwarn ("ISO C++ forbids variable-size array");
6511 if (processing_template_decl && !TREE_CONSTANT (size))
6512 /* A variable sized array. */
6513 itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node);
6516 HOST_WIDE_INT saved_processing_template_decl;
6518 /* Compute the index of the largest element in the array. It is
6519 one less than the number of elements in the array. We save
6520 and restore PROCESSING_TEMPLATE_DECL so that computations in
6521 cp_build_binary_op will be appropriately folded. */
6522 saved_processing_template_decl = processing_template_decl;
6523 processing_template_decl = 0;
6524 itype = cp_build_binary_op (MINUS_EXPR,
6525 cp_convert (ssizetype, size),
6526 cp_convert (ssizetype, integer_one_node));
6527 itype = fold (itype);
6528 processing_template_decl = saved_processing_template_decl;
6530 if (!TREE_CONSTANT (itype))
6531 /* A variable sized array. */
6532 itype = variable_size (itype);
6533 /* Make sure that there was no overflow when creating to a signed
6534 index type. (For example, on a 32-bit machine, an array with
6535 size 2^32 - 1 is too big.) */
6536 else if (TREE_CODE (itype) == INTEGER_CST
6537 && TREE_OVERFLOW (itype))
6539 error ("overflow in array dimension");
6540 TREE_OVERFLOW (itype) = 0;
6544 /* Create and return the appropriate index type. */
6545 return build_index_type (itype);
6548 /* Returns the scope (if any) in which the entity declared by
6549 DECLARATOR will be located. If the entity was declared with an
6550 unqualified name, NULL_TREE is returned. */
6553 get_scope_of_declarator (const cp_declarator *declarator)
6555 while (declarator && declarator->kind != cdk_id)
6556 declarator = declarator->declarator;
6558 /* If the declarator-id is a SCOPE_REF, the scope in which the
6559 declaration occurs is the first operand. */
6561 && declarator->u.id.qualifying_scope)
6562 return declarator->u.id.qualifying_scope;
6564 /* Otherwise, the declarator is not a qualified name; the entity will
6565 be declared in the current scope. */
6569 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
6570 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
6574 create_array_type_for_decl (tree name, tree type, tree size)
6576 tree itype = NULL_TREE;
6577 const char* error_msg;
6579 /* If things have already gone awry, bail now. */
6580 if (type == error_mark_node || size == error_mark_node)
6581 return error_mark_node;
6583 /* Assume that everything will go OK. */
6586 /* There are some types which cannot be array elements. */
6587 switch (TREE_CODE (type))
6590 error_msg = "array of void";
6594 error_msg = "array of functions";
6597 case REFERENCE_TYPE:
6598 error_msg = "array of references";
6602 error_msg = "array of function members";
6609 /* If something went wrong, issue an error-message and return. */
6613 error ("declaration of %qD as %s", name, error_msg);
6615 error ("creating %s", error_msg);
6617 return error_mark_node;
6622 The constant expressions that specify the bounds of the arrays
6623 can be omitted only for the first member of the sequence. */
6624 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
6627 error ("declaration of %qD as multidimensional array must "
6628 "have bounds for all dimensions except the first",
6631 error ("multidimensional array must have bounds for all "
6632 "dimensions except the first");
6634 return error_mark_node;
6637 /* Figure out the index type for the array. */
6639 itype = compute_array_index_type (name, size);
6642 T is called the array element type; this type shall not be [...] an
6643 abstract class type. */
6644 abstract_virtuals_error (name, type);
6646 return build_cplus_array_type (type, itype);
6649 /* Check that it's OK to declare a function with the indicated TYPE.
6650 SFK indicates the kind of special function (if any) that this
6651 function is. OPTYPE is the type given in a conversion operator
6652 declaration, or the class type for a constructor/destructor.
6653 Returns the actual return type of the function; that
6654 may be different than TYPE if an error occurs, or for certain
6655 special functions. */
6658 check_special_function_return_type (special_function_kind sfk,
6664 case sfk_constructor:
6666 error ("return type specification for constructor invalid");
6668 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
6669 type = build_pointer_type (optype);
6671 type = void_type_node;
6674 case sfk_destructor:
6676 error ("return type specification for destructor invalid");
6677 /* We can't use the proper return type here because we run into
6678 problems with ambiguous bases and covariant returns.
6679 Java classes are left unchanged because (void *) isn't a valid
6680 Java type, and we don't want to change the Java ABI. */
6681 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
6682 type = build_pointer_type (void_type_node);
6684 type = void_type_node;
6687 case sfk_conversion:
6688 if (type && !same_type_p (type, optype))
6689 error ("operator %qT declared to return %qT", optype, type);
6691 pedwarn ("return type specified for %<operator %T%>", optype);
6702 /* A variable or data member (whose unqualified name is IDENTIFIER)
6703 has been declared with the indicated TYPE. If the TYPE is not
6704 acceptable, issue an error message and return a type to use for
6705 error-recovery purposes. */
6708 check_var_type (tree identifier, tree type)
6710 if (VOID_TYPE_P (type))
6713 error ("unnamed variable or field declared void");
6714 else if (TREE_CODE (identifier) == IDENTIFIER_NODE)
6716 gcc_assert (!IDENTIFIER_OPNAME_P (identifier));
6717 error ("variable or field %qE declared void", identifier);
6720 error ("variable or field declared void");
6721 type = integer_type_node;
6727 /* Given declspecs and a declarator (abstract or otherwise), determine
6728 the name and type of the object declared and construct a DECL node
6731 DECLSPECS is a chain of tree_list nodes whose value fields
6732 are the storage classes and type specifiers.
6734 DECL_CONTEXT says which syntactic context this declaration is in:
6735 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
6736 FUNCDEF for a function definition. Like NORMAL but a few different
6737 error messages in each case. Return value may be zero meaning
6738 this definition is too screwy to try to parse.
6739 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
6740 handle member functions (which have FIELD context).
6741 Return value may be zero meaning this definition is too screwy to
6743 PARM for a parameter declaration (either within a function prototype
6744 or before a function body). Make a PARM_DECL, or return void_type_node.
6745 CATCHPARM for a parameter declaration before a catch clause.
6746 TYPENAME if for a typename (in a cast or sizeof).
6747 Don't make a DECL node; just return the ..._TYPE node.
6748 FIELD for a struct or union field; make a FIELD_DECL.
6749 BITFIELD for a field with specified width.
6750 INITIALIZED is 1 if the decl has an initializer.
6752 ATTRLIST is a pointer to the list of attributes, which may be NULL
6753 if there are none; *ATTRLIST may be modified if attributes from inside
6754 the declarator should be applied to the declaration.
6756 When this function is called, scoping variables (such as
6757 CURRENT_CLASS_TYPE) should reflect the scope in which the
6758 declaration occurs, not the scope in which the new declaration will
6759 be placed. For example, on:
6763 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
6764 should not be `S'. */
6767 grokdeclarator (const cp_declarator *declarator,
6768 const cp_decl_specifier_seq *declspecs,
6769 enum decl_context decl_context,
6773 tree type = NULL_TREE;
6775 int virtualp, explicitp, friendp, inlinep, staticp;
6776 int explicit_int = 0;
6777 int explicit_char = 0;
6778 int defaulted_int = 0;
6779 tree dependent_name = NULL_TREE;
6781 tree typedef_decl = NULL_TREE;
6782 const char *name = NULL;
6783 tree typedef_type = NULL_TREE;
6784 /* True if this declarator is a function definition. */
6785 bool funcdef_flag = false;
6786 cp_declarator_kind innermost_code = cdk_error;
6789 /* See the code below that used this. */
6790 tree decl_attr = NULL_TREE;
6793 /* Keep track of what sort of function is being processed
6794 so that we can warn about default return values, or explicit
6795 return values which do not match prescribed defaults. */
6796 special_function_kind sfk = sfk_none;
6798 tree dname = NULL_TREE;
6799 tree ctor_return_type = NULL_TREE;
6800 enum overload_flags flags = NO_SPECIAL;
6801 /* cv-qualifiers that apply to the declarator, for a declaration of
6802 a member function. */
6803 cp_cv_quals memfn_quals = TYPE_UNQUALIFIED;
6804 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
6806 tree raises = NULL_TREE;
6807 int template_count = 0;
6808 tree returned_attrs = NULL_TREE;
6809 tree parms = NULL_TREE;
6810 const cp_declarator *id_declarator;
6811 /* The unqualified name of the declarator; either an
6812 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
6813 tree unqualified_id;
6814 /* The class type, if any, in which this entity is located,
6815 or NULL_TREE if none. Note that this value may be different from
6816 the current class type; for example if an attempt is made to declare
6817 "A::f" inside "B", this value will be "A". */
6818 tree ctype = current_class_type;
6819 /* The NAMESPACE_DECL for the namespace in which this entity is
6820 located. If an unqualified name is used to declare the entity,
6821 this value will be NULL_TREE, even if the entity is located at
6823 tree in_namespace = NULL_TREE;
6824 cp_storage_class storage_class;
6825 bool unsigned_p, signed_p, short_p, long_p, thread_p;
6826 bool type_was_error_mark_node = false;
6828 signed_p = declspecs->specs[(int)ds_signed];
6829 unsigned_p = declspecs->specs[(int)ds_unsigned];
6830 short_p = declspecs->specs[(int)ds_short];
6831 long_p = declspecs->specs[(int)ds_long];
6832 longlong = declspecs->specs[(int)ds_long] >= 2;
6833 thread_p = declspecs->specs[(int)ds_thread];
6835 if (decl_context == FUNCDEF)
6836 funcdef_flag = true, decl_context = NORMAL;
6837 else if (decl_context == MEMFUNCDEF)
6838 funcdef_flag = true, decl_context = FIELD;
6839 else if (decl_context == BITFIELD)
6840 bitfield = 1, decl_context = FIELD;
6842 /* Look inside a declarator for the name being declared
6843 and get it as a string, for an error message. */
6844 for (id_declarator = declarator;
6846 id_declarator = id_declarator->declarator)
6848 if (id_declarator->kind != cdk_id)
6849 innermost_code = id_declarator->kind;
6851 switch (id_declarator->kind)
6854 if (id_declarator->declarator
6855 && id_declarator->declarator->kind == cdk_id)
6857 sfk = id_declarator->declarator->u.id.sfk;
6858 if (sfk == sfk_destructor)
6865 tree qualifying_scope = id_declarator->u.id.qualifying_scope;
6866 tree decl = id_declarator->u.id.unqualified_name;
6869 if (qualifying_scope)
6871 if (TYPE_P (qualifying_scope))
6873 ctype = qualifying_scope;
6874 if (innermost_code != cdk_function
6875 && current_class_type
6876 && !UNIQUELY_DERIVED_FROM_P (ctype,
6877 current_class_type))
6879 error ("type %qT is not derived from type %qT",
6880 ctype, current_class_type);
6881 return error_mark_node;
6884 else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL)
6885 in_namespace = qualifying_scope;
6887 switch (TREE_CODE (decl))
6893 if (innermost_code != cdk_function)
6895 error ("declaration of %qD as non-function", decl);
6896 return error_mark_node;
6898 else if (!qualifying_scope
6899 && !(current_class_type && at_class_scope_p ()))
6901 error ("declaration of %qD as non-member", decl);
6902 return error_mark_node;
6905 type = TREE_OPERAND (decl, 0);
6906 name = IDENTIFIER_POINTER (constructor_name (type));
6911 case TEMPLATE_ID_EXPR:
6913 tree fns = TREE_OPERAND (decl, 0);
6916 if (TREE_CODE (dname) == COMPONENT_REF)
6917 dname = TREE_OPERAND (dname, 1);
6918 if (TREE_CODE (dname) != IDENTIFIER_NODE)
6920 gcc_assert (is_overloaded_fn (dname));
6921 dname = DECL_NAME (get_first_fn (dname));
6926 case IDENTIFIER_NODE:
6927 if (TREE_CODE (decl) == IDENTIFIER_NODE)
6930 if (C_IS_RESERVED_WORD (dname))
6932 error ("declarator-id missing; using reserved word %qD",
6934 name = IDENTIFIER_POINTER (dname);
6936 else if (!IDENTIFIER_TYPENAME_P (dname))
6937 name = IDENTIFIER_POINTER (dname);
6940 gcc_assert (flags == NO_SPECIAL);
6941 flags = TYPENAME_FLAG;
6942 ctor_return_type = TREE_TYPE (dname);
6943 sfk = sfk_conversion;
6944 if (is_typename_at_global_scope (dname))
6945 name = IDENTIFIER_POINTER (dname);
6947 name = "<invalid operator>";
6963 return error_mark_node;
6969 if (id_declarator->kind == cdk_id)
6975 The declarator in a function-definition shall have the form
6976 D1 ( parameter-declaration-clause) ... */
6977 if (funcdef_flag && innermost_code != cdk_function)
6979 error ("function definition does not declare parameters");
6980 return error_mark_node;
6983 if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
6984 && innermost_code != cdk_function
6985 && ! (ctype && !declspecs->any_specifiers_p))
6987 error ("declaration of %qD as non-function", dname);
6988 return error_mark_node;
6991 /* Anything declared one level down from the top level
6992 must be one of the parameters of a function
6993 (because the body is at least two levels down). */
6995 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
6996 by not allowing C++ class definitions to specify their parameters
6997 with xdecls (must be spec.d in the parmlist).
6999 Since we now wait to push a class scope until we are sure that
7000 we are in a legitimate method context, we must set oldcname
7001 explicitly (since current_class_name is not yet alive).
7003 We also want to avoid calling this a PARM if it is in a namespace. */
7005 if (decl_context == NORMAL && !toplevel_bindings_p ())
7007 struct cp_binding_level *b = current_binding_level;
7008 current_binding_level = b->level_chain;
7009 if (current_binding_level != 0 && toplevel_bindings_p ())
7010 decl_context = PARM;
7011 current_binding_level = b;
7015 name = decl_context == PARM ? "parameter" : "type name";
7017 /* If there were multiple types specified in the decl-specifier-seq,
7018 issue an error message. */
7019 if (declspecs->multiple_types_p)
7020 error ("two or more data types in declaration of %qs", name);
7021 /* Extract the basic type from the decl-specifier-seq. */
7022 type = declspecs->type;
7023 if (type == error_mark_node)
7026 type_was_error_mark_node = true;
7028 /* If the entire declaration is itself tagged as deprecated then
7029 suppress reports of deprecated items. */
7030 if (type && TREE_DEPRECATED (type)
7031 && deprecated_state != DEPRECATED_SUPPRESS)
7032 warn_deprecated_use (type);
7033 if (type && TREE_CODE (type) == TYPE_DECL)
7035 typedef_decl = type;
7036 type = TREE_TYPE (typedef_decl);
7038 /* No type at all: default to `int', and set DEFAULTED_INT
7039 because it was not a user-defined typedef. */
7040 if (type == NULL_TREE && (signed_p || unsigned_p || long_p || short_p))
7042 /* These imply 'int'. */
7043 type = integer_type_node;
7047 explicit_int = declspecs->explicit_int_p;
7048 explicit_char = declspecs->explicit_char_p;
7051 /* See the code below that used this. */
7053 decl_attr = DECL_ATTRIBUTES (typedef_decl);
7055 typedef_type = type;
7058 if (sfk != sfk_conversion)
7059 ctor_return_type = ctype;
7061 if (sfk != sfk_none)
7062 type = check_special_function_return_type (sfk, type,
7064 else if (type == NULL_TREE)
7070 /* We handle `main' specially here, because 'main () { }' is so
7071 common. With no options, it is allowed. With -Wreturn-type,
7072 it is a warning. It is only an error with -pedantic-errors. */
7073 is_main = (funcdef_flag
7074 && dname && MAIN_NAME_P (dname)
7075 && ctype == NULL_TREE
7076 && in_namespace == NULL_TREE
7077 && current_namespace == global_namespace);
7079 if (type_was_error_mark_node)
7080 /* We've already issued an error, don't complain more. */;
7081 else if (in_system_header || flag_ms_extensions)
7082 /* Allow it, sigh. */;
7083 else if (pedantic || ! is_main)
7084 pedwarn ("ISO C++ forbids declaration of %qs with no type", name);
7085 else if (warn_return_type)
7086 warning (0, "ISO C++ forbids declaration of %qs with no type", name);
7088 type = integer_type_node;
7093 /* Now process the modifiers that were specified
7094 and check for invalid combinations. */
7096 /* Long double is a special combination. */
7097 if (long_p && !longlong && TYPE_MAIN_VARIANT (type) == double_type_node)
7100 type = build_qualified_type (long_double_type_node,
7101 cp_type_quals (type));
7104 /* Check all other uses of type modifiers. */
7106 if (unsigned_p || signed_p || long_p || short_p)
7110 if ((signed_p || unsigned_p) && TREE_CODE (type) != INTEGER_TYPE)
7111 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
7112 else if (signed_p && unsigned_p)
7113 error ("%<signed%> and %<unsigned%> specified together for %qs", name);
7114 else if (longlong && TREE_CODE (type) != INTEGER_TYPE)
7115 error ("%<long long%> invalid for %qs", name);
7116 else if (long_p && TREE_CODE (type) == REAL_TYPE)
7117 error ("%<long%> invalid for %qs", name);
7118 else if (short_p && TREE_CODE (type) == REAL_TYPE)
7119 error ("%<short%> invalid for %qs", name);
7120 else if ((long_p || short_p) && explicit_char)
7121 error ("%<long%> or %<short%> specified with char for %qs", name);
7122 else if (long_p && short_p)
7123 error ("%<long%> and %<short%> specified together for %qs", name);
7127 if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
7129 pedwarn ("long, short, signed or unsigned used invalidly for %qs",
7131 if (flag_pedantic_errors)
7136 /* Discard the type modifiers if they are invalid. */
7147 /* Decide whether an integer type is signed or not.
7148 Optionally treat bitfields as signed by default. */
7152 It is implementation-defined whether a plain (neither
7153 explicitly signed or unsigned) char, short, int, or long
7154 bit-field is signed or unsigned.
7156 Naturally, we extend this to long long as well. Note that
7157 this does not include wchar_t. */
7158 || (bitfield && !flag_signed_bitfields
7160 /* A typedef for plain `int' without `signed' can be
7161 controlled just like plain `int', but a typedef for
7162 `signed int' cannot be so controlled. */
7164 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
7165 && TREE_CODE (type) == INTEGER_TYPE
7166 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
7169 type = long_long_unsigned_type_node;
7171 type = long_unsigned_type_node;
7173 type = short_unsigned_type_node;
7174 else if (type == char_type_node)
7175 type = unsigned_char_type_node;
7176 else if (typedef_decl)
7177 type = c_common_unsigned_type (type);
7179 type = unsigned_type_node;
7181 else if (signed_p && type == char_type_node)
7182 type = signed_char_type_node;
7184 type = long_long_integer_type_node;
7186 type = long_integer_type_node;
7188 type = short_integer_type_node;
7190 if (declspecs->specs[(int)ds_complex])
7192 if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
7193 error ("complex invalid for %qs", name);
7194 /* If we just have "complex", it is equivalent to
7195 "complex double", but if any modifiers at all are specified it is
7196 the complex form of TYPE. E.g, "complex short" is
7197 "complex short int". */
7199 else if (defaulted_int && ! longlong
7200 && ! (long_p || short_p || signed_p || unsigned_p))
7201 type = complex_double_type_node;
7202 else if (type == integer_type_node)
7203 type = complex_integer_type_node;
7204 else if (type == float_type_node)
7205 type = complex_float_type_node;
7206 else if (type == double_type_node)
7207 type = complex_double_type_node;
7208 else if (type == long_double_type_node)
7209 type = complex_long_double_type_node;
7211 type = build_complex_type (type);
7214 type_quals = TYPE_UNQUALIFIED;
7215 if (declspecs->specs[(int)ds_const])
7216 type_quals |= TYPE_QUAL_CONST;
7217 if (declspecs->specs[(int)ds_volatile])
7218 type_quals |= TYPE_QUAL_VOLATILE;
7219 if (declspecs->specs[(int)ds_restrict])
7220 type_quals |= TYPE_QUAL_RESTRICT;
7221 if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
7222 error ("qualifiers are not allowed on declaration of %<operator %T%>",
7225 if (TREE_CODE (type) == FUNCTION_TYPE
7226 && type_quals != TYPE_UNQUALIFIED)
7228 /* This was an error in C++98 (cv-qualifiers cannot be added to
7229 a function type), but DR 295 makes the code well-formed by
7230 dropping the extra qualifiers. */
7233 tree bad_type = build_qualified_type (type, type_quals);
7234 pedwarn ("ignoring %qV qualifiers added to function type %qT",
7237 type_quals = TYPE_UNQUALIFIED;
7239 type_quals |= cp_type_quals (type);
7240 type = cp_build_qualified_type_real
7241 (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
7242 ? tf_ignore_bad_quals : 0) | tf_warning_or_error));
7243 /* We might have ignored or rejected some of the qualifiers. */
7244 type_quals = cp_type_quals (type);
7247 inlinep = !! declspecs->specs[(int)ds_inline];
7248 virtualp = !! declspecs->specs[(int)ds_virtual];
7249 explicitp = !! declspecs->specs[(int)ds_explicit];
7251 storage_class = declspecs->storage_class;
7252 if (storage_class == sc_static)
7253 staticp = 1 + (decl_context == FIELD);
7255 if (virtualp && staticp == 2)
7257 error ("member %qD cannot be declared both virtual and static", dname);
7258 storage_class = sc_none;
7261 friendp = !! declspecs->specs[(int)ds_friend];
7263 if (dependent_name && !friendp)
7265 error ("%<%T::%D%> is not a valid declarator", ctype, dependent_name);
7266 return error_mark_node;
7269 /* Issue errors about use of storage classes for parameters. */
7270 if (decl_context == PARM)
7272 if (declspecs->specs[(int)ds_typedef])
7273 error ("typedef declaration invalid in parameter declaration");
7274 else if (storage_class == sc_static
7275 || storage_class == sc_extern
7277 error ("storage class specifiers invalid in parameter declarations");
7280 /* Give error if `virtual' is used outside of class declaration. */
7282 && (current_class_name == NULL_TREE || decl_context != FIELD))
7284 error ("virtual outside class declaration");
7288 /* Static anonymous unions are dealt with here. */
7289 if (staticp && decl_context == TYPENAME
7291 && ANON_AGGR_TYPE_P (declspecs->type))
7292 decl_context = FIELD;
7294 /* Warn about storage classes that are invalid for certain
7295 kinds of declarations (parameters, typenames, etc.). */
7296 if (declspecs->multiple_storage_classes_p)
7298 error ("multiple storage classes in declaration of %qs", name);
7299 storage_class = sc_none;
7303 && storage_class != sc_extern
7304 && storage_class != sc_static)
7305 || declspecs->specs[(int)ds_typedef]))
7307 error ("multiple storage classes in declaration of %qs", name);
7310 else if (decl_context != NORMAL
7311 && ((storage_class != sc_none
7312 && storage_class != sc_mutable)
7315 if ((decl_context == PARM || decl_context == CATCHPARM)
7316 && (storage_class == sc_register
7317 || storage_class == sc_auto))
7319 else if (declspecs->specs[(int)ds_typedef])
7321 else if (decl_context == FIELD
7322 /* C++ allows static class elements. */
7323 && storage_class == sc_static)
7324 /* C++ also allows inlines and signed and unsigned elements,
7325 but in those cases we don't come in here. */
7329 if (decl_context == FIELD)
7330 error ("storage class specified for %qs", name);
7333 if (decl_context == PARM || decl_context == CATCHPARM)
7334 error ("storage class specified for parameter %qs", name);
7336 error ("storage class specified for typename");
7338 if (storage_class == sc_register
7339 || storage_class == sc_auto
7340 || storage_class == sc_extern
7342 storage_class = sc_none;
7345 else if (storage_class == sc_extern && initialized
7348 if (toplevel_bindings_p ())
7350 /* It's common practice (and completely valid) to have a const
7351 be initialized and declared extern. */
7352 if (!(type_quals & TYPE_QUAL_CONST))
7353 warning (0, "%qs initialized and declared %<extern%>", name);
7356 error ("%qs has both %<extern%> and initializer", name);
7358 else if (storage_class == sc_extern && funcdef_flag
7359 && ! toplevel_bindings_p ())
7360 error ("nested function %qs declared %<extern%>", name);
7361 else if (toplevel_bindings_p ())
7363 if (storage_class == sc_auto)
7364 error ("top-level declaration of %qs specifies %<auto%>", name);
7367 && storage_class != sc_extern
7368 && storage_class != sc_static)
7370 error ("function-scope %qs implicitly auto and declared %<__thread%>",
7375 if (storage_class && friendp)
7376 error ("storage class specifiers invalid in friend function declarations");
7379 unqualified_id = NULL_TREE;
7382 unqualified_id = id_declarator->u.id.unqualified_name;
7383 switch (TREE_CODE (unqualified_id))
7387 = constructor_name (TREE_OPERAND (unqualified_id, 0));
7390 case IDENTIFIER_NODE:
7391 case TEMPLATE_ID_EXPR:
7399 /* Determine the type of the entity declared by recurring on the
7401 for (; declarator; declarator = declarator->declarator)
7403 const cp_declarator *inner_declarator;
7406 if (type == error_mark_node)
7407 return error_mark_node;
7409 attrs = declarator->attributes;
7415 if (declarator == NULL || declarator->kind == cdk_id)
7416 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
7417 if (declarator->kind == cdk_function)
7418 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
7419 if (declarator->kind == cdk_array)
7420 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
7421 returned_attrs = decl_attributes (&type,
7422 chainon (returned_attrs, attrs),
7426 if (declarator->kind == cdk_id)
7429 inner_declarator = declarator->declarator;
7431 switch (declarator->kind)
7434 type = create_array_type_for_decl (dname, type,
7435 declarator->u.array.bounds);
7443 /* Declaring a function type.
7444 Make sure we have a valid type for the function to return. */
7446 /* We now know that the TYPE_QUALS don't apply to the
7447 decl, but to its return type. */
7448 type_quals = TYPE_UNQUALIFIED;
7450 /* Warn about some types functions can't return. */
7452 if (TREE_CODE (type) == FUNCTION_TYPE)
7454 error ("%qs declared as function returning a function", name);
7455 type = integer_type_node;
7457 if (TREE_CODE (type) == ARRAY_TYPE)
7459 error ("%qs declared as function returning an array", name);
7460 type = integer_type_node;
7463 /* Pick up type qualifiers which should be applied to `this'. */
7464 memfn_quals = declarator->u.function.qualifiers;
7466 /* Pick up the exception specifications. */
7467 raises = declarator->u.function.exception_specification;
7469 /* Say it's a definition only for the CALL_EXPR
7470 closest to the identifier. */
7471 funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id;
7473 if (ctype == NULL_TREE
7474 && decl_context == FIELD
7476 && (friendp == 0 || dname == current_class_name))
7477 ctype = current_class_type;
7479 if (ctype && (sfk == sfk_constructor
7480 || sfk == sfk_destructor))
7482 /* We are within a class's scope. If our declarator name
7483 is the same as the class name, and we are defining
7484 a function, then it is a constructor/destructor, and
7485 therefore returns a void type. */
7487 /* ISO C++ 12.4/2. A destructor may not be declared
7488 const or volatile. A destructor may not be
7491 ISO C++ 12.1. A constructor may not be declared
7492 const or volatile. A constructor may not be
7493 virtual. A constructor may not be static. */
7495 error ((flags == DTOR_FLAG)
7496 ? "destructor cannot be static member function"
7497 : "constructor cannot be static member function");
7500 error ((flags == DTOR_FLAG)
7501 ? "destructors may not be cv-qualified"
7502 : "constructors may not be cv-qualified");
7503 memfn_quals = TYPE_UNQUALIFIED;
7506 if (decl_context == FIELD
7507 && !member_function_or_else (ctype,
7510 return error_mark_node;
7512 if (flags != DTOR_FLAG)
7514 /* It's a constructor. */
7519 pedwarn ("constructors cannot be declared virtual");
7522 if (decl_context == FIELD
7523 && sfk != sfk_constructor)
7524 return error_mark_node;
7526 if (decl_context == FIELD)
7532 error ("can't initialize friend function %qs", name);
7535 /* Cannot be both friend and virtual. */
7536 error ("virtual functions cannot be friends");
7539 if (decl_context == NORMAL)
7540 error ("friend declaration not in class definition");
7541 if (current_function_decl && funcdef_flag)
7542 error ("can't define friend function %qs in a local "
7547 arg_types = grokparms (declarator->u.function.parameters,
7550 if (inner_declarator
7551 && inner_declarator->kind == cdk_id
7552 && inner_declarator->u.id.sfk == sfk_destructor
7553 && arg_types != void_list_node)
7555 error ("destructors may not have parameters");
7556 arg_types = void_list_node;
7560 type = build_function_type (type, arg_types);
7567 /* Filter out pointers-to-references and references-to-references.
7568 We can get these if a TYPE_DECL is used. */
7570 if (TREE_CODE (type) == REFERENCE_TYPE)
7572 error (declarator->kind == cdk_reference
7573 ? "cannot declare reference to %q#T"
7574 : "cannot declare pointer to %q#T", type);
7575 type = TREE_TYPE (type);
7577 else if (VOID_TYPE_P (type))
7579 if (declarator->kind == cdk_reference)
7580 error ("cannot declare reference to %q#T", type);
7581 else if (declarator->kind == cdk_ptrmem)
7582 error ("cannot declare pointer to %q#T member", type);
7585 /* We now know that the TYPE_QUALS don't apply to the decl,
7586 but to the target of the pointer. */
7587 type_quals = TYPE_UNQUALIFIED;
7589 if (declarator->kind == cdk_ptrmem
7590 && (TREE_CODE (type) == FUNCTION_TYPE || memfn_quals))
7592 memfn_quals |= cp_type_quals (type);
7593 type = build_memfn_type (type,
7594 declarator->u.pointer.class_type,
7596 memfn_quals = TYPE_UNQUALIFIED;
7599 if (declarator->kind == cdk_reference)
7601 if (!VOID_TYPE_P (type))
7602 type = build_reference_type (type);
7604 else if (TREE_CODE (type) == METHOD_TYPE)
7605 type = build_ptrmemfunc_type (build_pointer_type (type));
7606 else if (declarator->kind == cdk_ptrmem)
7608 gcc_assert (TREE_CODE (declarator->u.pointer.class_type)
7610 if (declarator->u.pointer.class_type == error_mark_node)
7611 /* We will already have complained. */
7612 type = error_mark_node;
7614 type = build_ptrmem_type (declarator->u.pointer.class_type,
7618 type = build_pointer_type (type);
7620 /* Process a list of type modifier keywords (such as
7621 const or volatile) that were given inside the `*' or `&'. */
7623 if (declarator->u.pointer.qualifiers)
7626 = cp_build_qualified_type (type,
7627 declarator->u.pointer.qualifiers);
7628 type_quals = cp_type_quals (type);
7641 if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR
7642 && TREE_CODE (type) != FUNCTION_TYPE
7643 && TREE_CODE (type) != METHOD_TYPE)
7645 error ("template-id %qD used as a declarator",
7647 unqualified_id = dname;
7650 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
7651 qualified with a class-name, turn it into a METHOD_TYPE, unless
7652 we know that the function is static. We take advantage of this
7653 opportunity to do other processing that pertains to entities
7654 explicitly declared to be class members. Note that if DECLARATOR
7655 is non-NULL, we know it is a cdk_id declarator; otherwise, we
7656 would not have exited the loop above. */
7658 && declarator->u.id.qualifying_scope
7659 && TYPE_P (declarator->u.id.qualifying_scope))
7663 ctype = declarator->u.id.qualifying_scope;
7664 ctype = TYPE_MAIN_VARIANT (ctype);
7666 while (t != NULL_TREE && CLASS_TYPE_P (t))
7668 /* You're supposed to have one `template <...>' for every
7669 template class, but you don't need one for a full
7670 specialization. For example:
7672 template <class T> struct S{};
7673 template <> struct S<int> { void f(); };
7674 void S<int>::f () {}
7676 is correct; there shouldn't be a `template <>' for the
7677 definition of `S<int>::f'. */
7678 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t)
7679 && !any_dependent_template_arguments_p (CLASSTYPE_TI_ARGS (t)))
7680 /* T is an explicit (not partial) specialization. All
7681 containing classes must therefore also be explicitly
7684 if ((CLASSTYPE_USE_TEMPLATE (t) || CLASSTYPE_IS_TEMPLATE (t))
7685 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
7686 template_count += 1;
7688 t = TYPE_MAIN_DECL (t);
7689 t = DECL_CONTEXT (t);
7692 if (ctype == current_class_type)
7695 pedwarn ("member functions are implicitly friends of their class");
7697 pedwarn ("extra qualification %<%T::%> on member %qs",
7700 else if (/* If the qualifying type is already complete, then we
7701 can skip the following checks. */
7702 !COMPLETE_TYPE_P (ctype)
7703 && (/* If the function is being defined, then
7704 qualifying type must certainly be complete. */
7706 /* A friend declaration of "T::f" is OK, even if
7707 "T" is a template parameter. But, if this
7708 function is not a friend, the qualifying type
7710 || (!friendp && !CLASS_TYPE_P (ctype))
7711 /* For a declaration, the type need not be
7712 complete, if either it is dependent (since there
7713 is no meaningful definition of complete in that
7714 case) or the qualifying class is currently being
7716 || !(dependent_type_p (ctype)
7717 || currently_open_class (ctype)))
7718 /* Check that the qualifying type is complete. */
7719 && !complete_type_or_else (ctype, NULL_TREE))
7720 return error_mark_node;
7721 else if (TREE_CODE (type) == FUNCTION_TYPE)
7723 tree sname = declarator->u.id.unqualified_name;
7725 if (current_class_type
7726 && (!friendp || funcdef_flag))
7729 ? "cannot define member function %<%T::%s%> within %<%T%>"
7730 : "cannot declare member function %<%T::%s%> within %<%T%>",
7731 ctype, name, current_class_type);
7732 return error_mark_node;
7735 if (TREE_CODE (sname) == IDENTIFIER_NODE
7736 && NEW_DELETE_OPNAME_P (sname))
7737 /* Overloaded operator new and operator delete
7738 are always static functions. */
7741 type = build_memfn_type (type, ctype, memfn_quals);
7743 else if (declspecs->specs[(int)ds_typedef]
7744 && current_class_type)
7746 error ("cannot declare member %<%T::%s%> within %qT",
7747 ctype, name, current_class_type);
7748 return error_mark_node;
7752 /* Now TYPE has the actual type. */
7757 *attrlist = chainon (returned_attrs, *attrlist);
7759 attrlist = &returned_attrs;
7762 /* Did array size calculations overflow? */
7764 if (TREE_CODE (type) == ARRAY_TYPE
7765 && COMPLETE_TYPE_P (type)
7766 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
7767 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
7769 error ("size of array %qs is too large", name);
7770 /* If we proceed with the array type as it is, we'll eventually
7771 crash in tree_low_cst(). */
7772 type = error_mark_node;
7775 if ((decl_context == FIELD || decl_context == PARM)
7776 && !processing_template_decl
7777 && variably_modified_type_p (type, NULL_TREE))
7779 if (decl_context == FIELD)
7780 error ("data member may not have variably modified type %qT", type);
7782 error ("parameter may not have variably modified type %qT", type);
7783 type = error_mark_node;
7786 if (explicitp == 1 || (explicitp && friendp))
7788 /* [dcl.fct.spec] The explicit specifier shall only be used in
7789 declarations of constructors within a class definition. */
7790 error ("only declarations of constructors can be %<explicit%>");
7794 if (storage_class == sc_mutable)
7796 if (decl_context != FIELD || friendp)
7798 error ("non-member %qs cannot be declared %<mutable%>", name);
7799 storage_class = sc_none;
7801 else if (decl_context == TYPENAME || declspecs->specs[(int)ds_typedef])
7803 error ("non-object member %qs cannot be declared %<mutable%>", name);
7804 storage_class = sc_none;
7806 else if (TREE_CODE (type) == FUNCTION_TYPE
7807 || TREE_CODE (type) == METHOD_TYPE)
7809 error ("function %qs cannot be declared %<mutable%>", name);
7810 storage_class = sc_none;
7814 error ("static %qs cannot be declared %<mutable%>", name);
7815 storage_class = sc_none;
7817 else if (type_quals & TYPE_QUAL_CONST)
7819 error ("const %qs cannot be declared %<mutable%>", name);
7820 storage_class = sc_none;
7824 /* If this is declaring a typedef name, return a TYPE_DECL. */
7825 if (declspecs->specs[(int)ds_typedef] && decl_context != TYPENAME)
7829 /* Note that the grammar rejects storage classes
7830 in typenames, fields or parameters. */
7831 if (current_lang_name == lang_name_java)
7832 TYPE_FOR_JAVA (type) = 1;
7834 /* This declaration:
7836 typedef void f(int) const;
7838 declares a function type which is not a member of any
7839 particular class, but which is cv-qualified; for
7840 example "f S::*" declares a pointer to a const-qualified
7841 member function of S. We record the cv-qualification in the
7843 if (memfn_quals && TREE_CODE (type) == FUNCTION_TYPE)
7844 type = cp_build_qualified_type (type, memfn_quals);
7846 if (decl_context == FIELD)
7847 decl = build_lang_decl (TYPE_DECL, unqualified_id, type);
7849 decl = build_decl (TYPE_DECL, unqualified_id, type);
7850 if (id_declarator && declarator->u.id.qualifying_scope)
7851 error ("%Jtypedef name may not be a nested-name-specifier", decl);
7853 if (decl_context != FIELD)
7855 if (!current_function_decl)
7856 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
7857 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl)
7858 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
7859 (current_function_decl)))
7860 /* The TYPE_DECL is "abstract" because there will be
7861 clones of this constructor/destructor, and there will
7862 be copies of this TYPE_DECL generated in those
7864 DECL_ABSTRACT (decl) = 1;
7866 else if (constructor_name_p (unqualified_id, current_class_type))
7867 pedwarn ("ISO C++ forbids nested type %qD with same name "
7868 "as enclosing class",
7871 /* If the user declares "typedef struct {...} foo" then the
7872 struct will have an anonymous name. Fill that name in now.
7873 Nothing can refer to it, so nothing needs know about the name
7875 if (type != error_mark_node
7878 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7879 && TYPE_ANONYMOUS_P (type)
7880 /* Don't do this if there are attributes. */
7881 && (!attrlist || !*attrlist)
7882 && cp_type_quals (type) == TYPE_UNQUALIFIED)
7884 tree oldname = TYPE_NAME (type);
7887 /* Replace the anonymous name with the real name everywhere. */
7888 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
7889 if (TYPE_NAME (t) == oldname)
7890 TYPE_NAME (t) = decl;
7892 if (TYPE_LANG_SPECIFIC (type))
7893 TYPE_WAS_ANONYMOUS (type) = 1;
7895 /* If this is a typedef within a template class, the nested
7896 type is a (non-primary) template. The name for the
7897 template needs updating as well. */
7898 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
7899 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
7900 = TYPE_IDENTIFIER (type);
7902 /* FIXME remangle member functions; member functions of a
7903 type with external linkage have external linkage. */
7906 /* Any qualifiers on a function type typedef have already been
7908 if (memfn_quals && !ctype && TREE_CODE (type) == FUNCTION_TYPE)
7909 memfn_quals = TYPE_UNQUALIFIED;
7912 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
7913 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
7915 bad_specifiers (decl, "type", virtualp,
7916 memfn_quals != TYPE_UNQUALIFIED,
7917 inlinep, friendp, raises != NULL_TREE);
7922 /* Detect the case of an array type of unspecified size
7923 which came, as such, direct from a typedef name.
7924 We must copy the type, so that the array's domain can be
7925 individually set by the object's initializer. */
7927 if (type && typedef_type
7928 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
7929 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
7930 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
7932 /* Detect where we're using a typedef of function type to declare a
7933 function. PARMS will not be set, so we must create it now. */
7935 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
7937 tree decls = NULL_TREE;
7940 for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
7942 tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
7944 TREE_CHAIN (decl) = decls;
7948 parms = nreverse (decls);
7950 if (decl_context != TYPENAME)
7952 /* A cv-qualifier-seq shall only be part of the function type
7953 for a non-static member function. [8.3.5/4 dcl.fct] */
7954 if (cp_type_quals (type) != TYPE_UNQUALIFIED
7955 && (current_class_type == NULL_TREE || staticp) )
7957 error ("qualified function types cannot be used to declare %s functions",
7958 (staticp? "static member" : "free"));
7959 type = TYPE_MAIN_VARIANT (type);
7962 /* The qualifiers on the function type become the qualifiers on
7963 the non-static member function. */
7964 memfn_quals |= cp_type_quals (type);
7968 /* If this is a type name (such as, in a cast or sizeof),
7969 compute the type and return it now. */
7971 if (decl_context == TYPENAME)
7973 /* Note that the grammar rejects storage classes
7974 in typenames, fields or parameters. */
7975 if (type_quals != TYPE_UNQUALIFIED)
7976 type_quals = TYPE_UNQUALIFIED;
7978 /* Special case: "friend class foo" looks like a TYPENAME context. */
7981 if (type_quals != TYPE_UNQUALIFIED)
7983 error ("type qualifiers specified for friend class declaration");
7984 type_quals = TYPE_UNQUALIFIED;
7988 error ("%<inline%> specified for friend class declaration");
7994 /* Don't allow friend declaration without a class-key. */
7995 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
7996 pedwarn ("template parameters cannot be friends");
7997 else if (TREE_CODE (type) == TYPENAME_TYPE)
7998 pedwarn ("friend declaration requires class-key, "
7999 "i.e. %<friend class %T::%D%>",
8000 TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
8002 pedwarn ("friend declaration requires class-key, "
8003 "i.e. %<friend %#T%>",
8007 /* Only try to do this stuff if we didn't already give up. */
8008 if (type != integer_type_node)
8010 /* A friendly class? */
8011 if (current_class_type)
8012 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
8015 error ("trying to make class %qT a friend of global scope",
8018 type = void_type_node;
8021 else if (memfn_quals)
8023 if (ctype == NULL_TREE)
8025 if (TREE_CODE (type) != METHOD_TYPE)
8026 error ("invalid qualifiers on non-member function type");
8028 ctype = TYPE_METHOD_BASETYPE (type);
8031 type = build_memfn_type (type, ctype, memfn_quals);
8036 else if (unqualified_id == NULL_TREE && decl_context != PARM
8037 && decl_context != CATCHPARM
8038 && TREE_CODE (type) != UNION_TYPE
8041 error ("abstract declarator %qT used as declaration", type);
8042 return error_mark_node;
8045 /* Only functions may be declared using an operator-function-id. */
8047 && IDENTIFIER_OPNAME_P (unqualified_id)
8048 && TREE_CODE (type) != FUNCTION_TYPE
8049 && TREE_CODE (type) != METHOD_TYPE)
8051 error ("declaration of %qD as non-function", unqualified_id);
8052 return error_mark_node;
8055 /* We don't check parameter types here because we can emit a better
8056 error message later. */
8057 if (decl_context != PARM)
8058 type = check_var_type (unqualified_id, type);
8060 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
8061 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
8063 if (decl_context == PARM || decl_context == CATCHPARM)
8065 if (ctype || in_namespace)
8066 error ("cannot use %<::%> in parameter declaration");
8068 /* A parameter declared as an array of T is really a pointer to T.
8069 One declared as a function is really a pointer to a function.
8070 One declared as a member is really a pointer to member. */
8072 if (TREE_CODE (type) == ARRAY_TYPE)
8074 /* Transfer const-ness of array into that of type pointed to. */
8075 type = build_pointer_type (TREE_TYPE (type));
8076 type_quals = TYPE_UNQUALIFIED;
8078 else if (TREE_CODE (type) == FUNCTION_TYPE)
8079 type = build_pointer_type (type);
8085 if (decl_context == PARM)
8087 decl = cp_build_parm_decl (unqualified_id, type);
8089 bad_specifiers (decl, "parameter", virtualp,
8090 memfn_quals != TYPE_UNQUALIFIED,
8091 inlinep, friendp, raises != NULL_TREE);
8093 else if (decl_context == FIELD)
8095 /* The C99 flexible array extension. */
8096 if (!staticp && TREE_CODE (type) == ARRAY_TYPE
8097 && TYPE_DOMAIN (type) == NULL_TREE)
8099 tree itype = compute_array_index_type (dname, integer_zero_node);
8100 type = build_cplus_array_type (TREE_TYPE (type), itype);
8103 if (type == error_mark_node)
8105 /* Happens when declaring arrays of sizes which
8106 are error_mark_node, for example. */
8109 else if (in_namespace && !friendp)
8111 /* Something like struct S { int N::j; }; */
8112 error ("invalid use of %<::%>");
8115 else if (TREE_CODE (type) == FUNCTION_TYPE)
8118 tree function_context;
8122 if (ctype == NULL_TREE)
8123 ctype = current_class_type;
8125 if (ctype == NULL_TREE)
8127 error ("can't make %qD into a method -- not in a class",
8129 return error_mark_node;
8132 /* ``A union may [ ... ] not [ have ] virtual functions.''
8134 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
8136 error ("function %qD declared virtual inside a union",
8138 return error_mark_node;
8141 if (NEW_DELETE_OPNAME_P (unqualified_id))
8145 error ("%qD cannot be declared virtual, since it "
8151 else if (staticp < 2)
8152 type = build_memfn_type (type, ctype, memfn_quals);
8155 /* Check that the name used for a destructor makes sense. */
8156 if (sfk == sfk_destructor)
8160 gcc_assert (friendp);
8161 error ("expected qualified name in friend declaration "
8162 "for destructor %qD",
8163 id_declarator->u.id.unqualified_name);
8164 return error_mark_node;
8167 if (!same_type_p (TREE_OPERAND
8168 (id_declarator->u.id.unqualified_name, 0),
8171 error ("declaration of %qD as member of %qT",
8172 id_declarator->u.id.unqualified_name, ctype);
8173 return error_mark_node;
8177 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
8178 function_context = (ctype != NULL_TREE) ?
8179 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
8180 publicp = (! friendp || ! staticp)
8181 && function_context == NULL_TREE;
8182 decl = grokfndecl (ctype, type,
8183 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
8184 ? unqualified_id : dname,
8187 virtualp, flags, memfn_quals, raises,
8188 friendp ? -1 : 0, friendp, publicp, inlinep,
8190 funcdef_flag, template_count, in_namespace, attrlist);
8191 if (decl == NULL_TREE)
8192 return error_mark_node;
8194 /* This clobbers the attrs stored in `decl' from `attrlist'. */
8195 /* The decl and setting of decl_attr is also turned off. */
8196 decl = build_decl_attribute_variant (decl, decl_attr);
8199 /* [class.conv.ctor]
8201 A constructor declared without the function-specifier
8202 explicit that can be called with a single parameter
8203 specifies a conversion from the type of its first
8204 parameter to the type of its class. Such a constructor
8205 is called a converting constructor. */
8207 DECL_NONCONVERTING_P (decl) = 1;
8208 else if (DECL_CONSTRUCTOR_P (decl))
8210 /* The constructor can be called with exactly one
8211 parameter if there is at least one parameter, and
8212 any subsequent parameters have default arguments.
8213 Ignore any compiler-added parms. */
8214 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
8216 if (arg_types == void_list_node
8218 && TREE_CHAIN (arg_types)
8219 && TREE_CHAIN (arg_types) != void_list_node
8220 && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
8221 DECL_NONCONVERTING_P (decl) = 1;
8224 else if (TREE_CODE (type) == METHOD_TYPE)
8226 /* We only get here for friend declarations of
8227 members of other classes. */
8228 /* All method decls are public, so tell grokfndecl to set
8229 TREE_PUBLIC, also. */
8230 decl = grokfndecl (ctype, type,
8231 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
8232 ? unqualified_id : dname,
8235 virtualp, flags, memfn_quals, raises,
8236 friendp ? -1 : 0, friendp, 1, 0, sfk,
8237 funcdef_flag, template_count, in_namespace,
8239 if (decl == NULL_TREE)
8240 return error_mark_node;
8242 else if (!staticp && !dependent_type_p (type)
8243 && !COMPLETE_TYPE_P (complete_type (type))
8244 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
8247 error ("field %qD has incomplete type", unqualified_id);
8249 error ("name %qT has incomplete type", type);
8251 /* If we're instantiating a template, tell them which
8252 instantiation made the field's type be incomplete. */
8253 if (current_class_type
8254 && TYPE_NAME (current_class_type)
8255 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
8257 && declspecs->type == type)
8258 error (" in instantiation of template %qT",
8259 current_class_type);
8261 type = error_mark_node;
8268 error ("%qE is neither function nor member function; "
8269 "cannot be declared friend", unqualified_id);
8277 /* Friends are treated specially. */
8278 if (ctype == current_class_type)
8279 ; /* We already issued a pedwarn. */
8280 else if (decl && DECL_NAME (decl))
8282 if (template_class_depth (current_class_type) == 0)
8284 decl = check_explicit_specialization
8285 (unqualified_id, decl, template_count,
8286 2 * funcdef_flag + 4);
8287 if (decl == error_mark_node)
8288 return error_mark_node;
8291 decl = do_friend (ctype, unqualified_id, decl,
8297 return error_mark_node;
8300 /* Structure field. It may not be a function, except for C++. */
8302 if (decl == NULL_TREE)
8308 /* An attempt is being made to initialize a non-static
8309 member. But, from [class.mem]:
8311 4 A member-declarator can contain a
8312 constant-initializer only if it declares a static
8313 member (_class.static_) of integral or enumeration
8314 type, see _class.static.data_.
8316 This used to be relatively common practice, but
8317 the rest of the compiler does not correctly
8318 handle the initialization unless the member is
8319 static so we make it static below. */
8320 pedwarn ("ISO C++ forbids initialization of member %qD",
8322 pedwarn ("making %qD static", unqualified_id);
8326 if (uses_template_parms (type))
8327 /* We'll check at instantiation time. */
8329 else if (check_static_variable_definition (unqualified_id,
8331 /* If we just return the declaration, crashes
8332 will sometimes occur. We therefore return
8333 void_type_node, as if this was a friend
8334 declaration, to cause callers to completely
8335 ignore this declaration. */
8336 return error_mark_node;
8341 /* C++ allows static class members. All other work
8342 for this is done by grokfield. */
8343 decl = build_lang_decl (VAR_DECL, unqualified_id, type);
8344 set_linkage_for_static_data_member (decl);
8345 /* Even if there is an in-class initialization, DECL
8346 is considered undefined until an out-of-class
8347 definition is provided. */
8348 DECL_EXTERNAL (decl) = 1;
8352 if (targetm.have_tls)
8353 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
8355 /* A mere warning is sure to result in improper
8356 semantics at runtime. Don't bother to allow this to
8358 error ("thread-local storage not supported for this target");
8363 decl = build_decl (FIELD_DECL, unqualified_id, type);
8364 DECL_NONADDRESSABLE_P (decl) = bitfield;
8365 if (storage_class == sc_mutable)
8367 DECL_MUTABLE_P (decl) = 1;
8368 storage_class = sc_none;
8372 bad_specifiers (decl, "field", virtualp,
8373 memfn_quals != TYPE_UNQUALIFIED,
8374 inlinep, friendp, raises != NULL_TREE);
8377 else if (TREE_CODE (type) == FUNCTION_TYPE
8378 || TREE_CODE (type) == METHOD_TYPE)
8383 if (!unqualified_id)
8384 return error_mark_node;
8386 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
8387 original_name = dname;
8389 original_name = unqualified_id;
8391 if (storage_class == sc_auto)
8392 error ("storage class %<auto%> invalid for function %qs", name);
8393 else if (storage_class == sc_register)
8394 error ("storage class %<register%> invalid for function %qs", name);
8396 error ("storage class %<__thread%> invalid for function %qs", name);
8398 /* Function declaration not at top level.
8399 Storage classes other than `extern' are not allowed
8400 and `extern' makes no difference. */
8401 if (! toplevel_bindings_p ()
8402 && (storage_class == sc_static
8403 || declspecs->specs[(int)ds_inline])
8406 if (storage_class == sc_static)
8407 pedwarn ("%<static%> specified invalid for function %qs "
8408 "declared out of global scope", name);
8410 pedwarn ("%<inline%> specifier invalid for function %qs "
8411 "declared out of global scope", name);
8414 if (ctype == NULL_TREE)
8418 error ("virtual non-class function %qs", name);
8422 else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2
8423 && !NEW_DELETE_OPNAME_P (original_name))
8424 type = build_method_type_directly (ctype,
8426 TYPE_ARG_TYPES (type));
8428 /* Record presence of `static'. */
8429 publicp = (ctype != NULL_TREE
8430 || storage_class == sc_extern
8431 || storage_class != sc_static);
8433 decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
8434 virtualp, flags, memfn_quals, raises,
8436 publicp, inlinep, sfk, funcdef_flag,
8437 template_count, in_namespace, attrlist);
8438 if (decl == NULL_TREE)
8439 return error_mark_node;
8443 int invalid_static = 0;
8445 /* Don't allow a static member function in a class, and forbid
8446 declaring main to be static. */
8447 if (TREE_CODE (type) == METHOD_TYPE)
8449 pedwarn ("cannot declare member function %qD to have "
8450 "static linkage", decl);
8453 else if (current_function_decl)
8455 /* FIXME need arm citation */
8456 error ("cannot declare static function inside another function");
8463 storage_class = sc_none;
8469 /* It's a variable. */
8471 /* An uninitialized decl with `extern' is a reference. */
8472 decl = grokvardecl (type, unqualified_id,
8475 (type_quals & TYPE_QUAL_CONST) != 0,
8476 ctype ? ctype : in_namespace);
8477 bad_specifiers (decl, "variable", virtualp,
8478 memfn_quals != TYPE_UNQUALIFIED,
8479 inlinep, friendp, raises != NULL_TREE);
8483 DECL_CONTEXT (decl) = ctype;
8486 pedwarn ("%<static%> may not be used when defining "
8487 "(as opposed to declaring) a static data member");
8489 storage_class = sc_none;
8491 if (storage_class == sc_register && TREE_STATIC (decl))
8493 error ("static member %qD declared %<register%>", decl);
8494 storage_class = sc_none;
8496 if (storage_class == sc_extern && pedantic)
8498 pedwarn ("cannot explicitly declare member %q#D to have "
8501 storage_class = sc_none;
8506 /* Record `register' declaration for warnings on &
8507 and in case doing stupid register allocation. */
8509 if (storage_class == sc_register)
8510 DECL_REGISTER (decl) = 1;
8511 else if (storage_class == sc_extern)
8512 DECL_THIS_EXTERN (decl) = 1;
8513 else if (storage_class == sc_static)
8514 DECL_THIS_STATIC (decl) = 1;
8516 /* Record constancy and volatility. There's no need to do this
8517 when processing a template; we'll do this for the instantiated
8518 declaration based on the type of DECL. */
8519 if (!processing_template_decl)
8520 cp_apply_type_quals_to_decl (type_quals, decl);
8526 /* Subroutine of start_function. Ensure that each of the parameter
8527 types (as listed in PARMS) is complete, as is required for a
8528 function definition. */
8531 require_complete_types_for_parms (tree parms)
8533 for (; parms; parms = TREE_CHAIN (parms))
8535 if (dependent_type_p (TREE_TYPE (parms)))
8537 if (!VOID_TYPE_P (TREE_TYPE (parms))
8538 && complete_type_or_else (TREE_TYPE (parms), parms))
8540 relayout_decl (parms);
8541 DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
8544 /* grokparms or complete_type_or_else will have already issued
8546 TREE_TYPE (parms) = error_mark_node;
8550 /* Returns nonzero if T is a local variable. */
8553 local_variable_p (tree t)
8555 if ((TREE_CODE (t) == VAR_DECL
8556 /* A VAR_DECL with a context that is a _TYPE is a static data
8558 && !TYPE_P (CP_DECL_CONTEXT (t))
8559 /* Any other non-local variable must be at namespace scope. */
8560 && !DECL_NAMESPACE_SCOPE_P (t))
8561 || (TREE_CODE (t) == PARM_DECL))
8567 /* Returns nonzero if T is an automatic local variable or a label.
8568 (These are the declarations that need to be remapped when the code
8569 containing them is duplicated.) */
8572 nonstatic_local_decl_p (tree t)
8574 return ((local_variable_p (t) && !TREE_STATIC (t))
8575 || TREE_CODE (t) == LABEL_DECL
8576 || TREE_CODE (t) == RESULT_DECL);
8579 /* Like local_variable_p, but suitable for use as a tree-walking
8583 local_variable_p_walkfn (tree *tp, int *walk_subtrees,
8584 void *data ATTRIBUTE_UNUSED)
8586 if (local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
8588 else if (TYPE_P (*tp))
8595 /* Check that ARG, which is a default-argument expression for a
8596 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
8597 something goes wrong. DECL may also be a _TYPE node, rather than a
8598 DECL, if there is no DECL available. */
8601 check_default_argument (tree decl, tree arg)
8606 if (TREE_CODE (arg) == DEFAULT_ARG)
8607 /* We get a DEFAULT_ARG when looking at an in-class declaration
8608 with a default argument. Ignore the argument for now; we'll
8609 deal with it after the class is complete. */
8618 decl_type = TREE_TYPE (decl);
8620 if (arg == error_mark_node
8621 || decl == error_mark_node
8622 || TREE_TYPE (arg) == error_mark_node
8623 || decl_type == error_mark_node)
8624 /* Something already went wrong. There's no need to check
8626 return error_mark_node;
8628 /* [dcl.fct.default]
8630 A default argument expression is implicitly converted to the
8632 if (!TREE_TYPE (arg)
8633 || !can_convert_arg (decl_type, TREE_TYPE (arg), arg, LOOKUP_NORMAL))
8636 error ("default argument for %q#D has type %qT",
8637 decl, TREE_TYPE (arg));
8639 error ("default argument for parameter of type %qT has type %qT",
8640 decl_type, TREE_TYPE (arg));
8642 return error_mark_node;
8645 /* [dcl.fct.default]
8647 Local variables shall not be used in default argument
8650 The keyword `this' shall not be used in a default argument of a
8652 var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
8656 error ("default argument %qE uses local variable %qD", arg, var);
8657 return error_mark_node;
8664 /* Decode the list of parameter types for a function type.
8665 Given the list of things declared inside the parens,
8666 return a list of types.
8668 If this parameter does not end with an ellipsis, we append
8671 *PARMS is set to the chain of PARM_DECLs created. */
8674 grokparms (cp_parameter_declarator *first_parm, tree *parms)
8676 tree result = NULL_TREE;
8677 tree decls = NULL_TREE;
8678 int ellipsis = !first_parm || first_parm->ellipsis_p;
8679 cp_parameter_declarator *parm;
8682 for (parm = first_parm; parm != NULL; parm = parm->next)
8684 tree type = NULL_TREE;
8685 tree init = parm->default_argument;
8689 if (parm == no_parameters)
8692 attrs = parm->decl_specifiers.attributes;
8693 parm->decl_specifiers.attributes = NULL_TREE;
8694 decl = grokdeclarator (parm->declarator, &parm->decl_specifiers,
8695 PARM, init != NULL_TREE, &attrs);
8696 if (! decl || TREE_TYPE (decl) == error_mark_node)
8700 cplus_decl_attributes (&decl, attrs, 0);
8702 type = TREE_TYPE (decl);
8703 if (VOID_TYPE_P (type))
8705 if (same_type_p (type, void_type_node)
8706 && DECL_SELF_REFERENCE_P (type)
8707 && !DECL_NAME (decl) && !result && !parm->next && !ellipsis)
8708 /* this is a parmlist of `(void)', which is ok. */
8710 cxx_incomplete_type_error (decl, type);
8711 /* It's not a good idea to actually create parameters of
8712 type `void'; other parts of the compiler assume that a
8713 void type terminates the parameter list. */
8714 type = error_mark_node;
8715 TREE_TYPE (decl) = error_mark_node;
8718 if (type != error_mark_node)
8720 /* Top-level qualifiers on the parameters are
8721 ignored for function types. */
8722 type = cp_build_qualified_type (type, 0);
8723 if (TREE_CODE (type) == METHOD_TYPE)
8725 error ("parameter %qD invalidly declared method type", decl);
8726 type = build_pointer_type (type);
8727 TREE_TYPE (decl) = type;
8729 else if (abstract_virtuals_error (decl, type))
8730 any_error = 1; /* Seems like a good idea. */
8731 else if (POINTER_TYPE_P (type))
8733 /* [dcl.fct]/6, parameter types cannot contain pointers
8734 (references) to arrays of unknown bound. */
8735 tree t = TREE_TYPE (type);
8736 int ptr = TYPE_PTR_P (type);
8742 else if (TREE_CODE (t) != ARRAY_TYPE)
8744 else if (!TYPE_DOMAIN (t))
8748 if (TREE_CODE (t) == ARRAY_TYPE)
8749 error ("parameter %qD includes %s to array of unknown "
8751 decl, ptr ? "pointer" : "reference", t);
8756 else if (init && !processing_template_decl)
8757 init = check_default_argument (decl, init);
8760 TREE_CHAIN (decl) = decls;
8762 result = tree_cons (init, type, result);
8764 decls = nreverse (decls);
8765 result = nreverse (result);
8767 result = chainon (result, void_list_node);
8774 /* D is a constructor or overloaded `operator='.
8776 Let T be the class in which D is declared. Then, this function
8779 -1 if D's is an ill-formed constructor or copy assignment operator
8780 whose first parameter is of type `T'.
8781 0 if D is not a copy constructor or copy assignment
8783 1 if D is a copy constructor or copy assignment operator whose
8784 first parameter is a reference to const qualified T.
8785 2 if D is a copy constructor or copy assignment operator whose
8786 first parameter is a reference to non-const qualified T.
8788 This function can be used as a predicate. Positive values indicate
8789 a copy constructor and nonzero values indicate a copy assignment
8799 if (!DECL_FUNCTION_MEMBER_P (d))
8800 /* Non-members are invalid. We complained, but kept the declaration. */
8803 if (TREE_CODE (d) == TEMPLATE_DECL
8804 || (DECL_TEMPLATE_INFO (d)
8805 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
8806 /* Instantiations of template member functions are never copy
8807 functions. Note that member functions of templated classes are
8808 represented as template functions internally, and we must
8809 accept those as copy functions. */
8812 args = FUNCTION_FIRST_USER_PARMTYPE (d);
8816 arg_type = TREE_VALUE (args);
8817 if (arg_type == error_mark_node)
8820 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
8822 /* Pass by value copy assignment operator. */
8825 else if (TREE_CODE (arg_type) == REFERENCE_TYPE
8826 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
8828 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
8834 args = TREE_CHAIN (args);
8836 if (args && args != void_list_node && !TREE_PURPOSE (args))
8837 /* There are more non-optional args. */
8843 /* Remember any special properties of member function DECL. */
8845 void grok_special_member_properties (tree decl)
8849 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
8852 class_type = DECL_CONTEXT (decl);
8853 if (DECL_CONSTRUCTOR_P (decl))
8855 int ctor = copy_fn_p (decl);
8857 TYPE_HAS_CONSTRUCTOR (class_type) = 1;
8863 A non-template constructor for class X is a copy
8864 constructor if its first parameter is of type X&, const
8865 X&, volatile X& or const volatile X&, and either there
8866 are no other parameters or else all other parameters have
8867 default arguments. */
8868 TYPE_HAS_INIT_REF (class_type) = 1;
8870 TYPE_HAS_CONST_INIT_REF (class_type) = 1;
8872 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
8873 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type) = 1;
8875 else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
8879 A non-template assignment operator for class X is a copy
8880 assignment operator if its parameter is of type X, X&, const
8881 X&, volatile X& or const volatile X&. */
8883 int assop = copy_fn_p (decl);
8887 TYPE_HAS_ASSIGN_REF (class_type) = 1;
8889 TYPE_HAS_CONST_ASSIGN_REF (class_type) = 1;
8894 /* Check a constructor DECL has the correct form. Complains
8895 if the class has a constructor of the form X(X). */
8898 grok_ctor_properties (tree ctype, tree decl)
8900 int ctor_parm = copy_fn_p (decl);
8906 A declaration of a constructor for a class X is ill-formed if
8907 its first parameter is of type (optionally cv-qualified) X
8908 and either there are no other parameters or else all other
8909 parameters have default arguments.
8911 We *don't* complain about member template instantiations that
8912 have this form, though; they can occur as we try to decide
8913 what constructor to use during overload resolution. Since
8914 overload resolution will never prefer such a constructor to
8915 the non-template copy constructor (which is either explicitly
8916 or implicitly defined), there's no need to worry about their
8917 existence. Theoretically, they should never even be
8918 instantiated, but that's hard to forestall. */
8919 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
8927 /* An operator with this code is unary, but can also be binary. */
8930 ambi_op_p (enum tree_code code)
8932 return (code == INDIRECT_REF
8933 || code == ADDR_EXPR
8934 || code == UNARY_PLUS_EXPR
8935 || code == NEGATE_EXPR
8936 || code == PREINCREMENT_EXPR
8937 || code == PREDECREMENT_EXPR);
8940 /* An operator with this name can only be unary. */
8943 unary_op_p (enum tree_code code)
8945 return (code == TRUTH_NOT_EXPR
8946 || code == BIT_NOT_EXPR
8947 || code == COMPONENT_REF
8948 || code == TYPE_EXPR);
8951 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
8952 errors are issued for invalid declarations. */
8955 grok_op_properties (tree decl, bool complain)
8957 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
8959 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
8960 tree name = DECL_NAME (decl);
8961 enum tree_code operator_code;
8966 /* Count the number of arguments and check for ellipsis. */
8967 for (argtype = argtypes, arity = 0;
8968 argtype && argtype != void_list_node;
8969 argtype = TREE_CHAIN (argtype))
8971 ellipsis_p = !argtype;
8973 class_type = DECL_CONTEXT (decl);
8974 if (class_type && !CLASS_TYPE_P (class_type))
8975 class_type = NULL_TREE;
8977 if (DECL_CONV_FN_P (decl))
8978 operator_code = TYPE_EXPR;
8982 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
8983 if (ansi_opname (CODE) == name) \
8985 operator_code = (CODE); \
8988 else if (ansi_assopname (CODE) == name) \
8990 operator_code = (CODE); \
8991 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
8995 #include "operators.def"
9001 gcc_assert (operator_code != LAST_CPLUS_TREE_CODE);
9002 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
9005 switch (operator_code)
9008 TYPE_HAS_NEW_OPERATOR (class_type) = 1;
9012 TYPE_GETS_DELETE (class_type) |= 1;
9016 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type) = 1;
9019 case VEC_DELETE_EXPR:
9020 TYPE_GETS_DELETE (class_type) |= 2;
9027 /* [basic.std.dynamic.allocation]/1:
9029 A program is ill-formed if an allocation function is declared
9030 in a namespace scope other than global scope or declared static
9033 The same also holds true for deallocation functions. */
9034 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR
9035 || operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
9037 if (DECL_NAMESPACE_SCOPE_P (decl))
9039 if (CP_DECL_CONTEXT (decl) != global_namespace)
9040 error ("%qD may not be declared within a namespace", decl);
9041 else if (!TREE_PUBLIC (decl))
9042 error ("%qD may not be declared as static", decl);
9046 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
9047 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
9048 else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
9049 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
9052 /* An operator function must either be a non-static member function
9053 or have at least one parameter of a class, a reference to a class,
9054 an enumeration, or a reference to an enumeration. 13.4.0.6 */
9055 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
9057 if (operator_code == TYPE_EXPR
9058 || operator_code == CALL_EXPR
9059 || operator_code == COMPONENT_REF
9060 || operator_code == ARRAY_REF
9061 || operator_code == NOP_EXPR)
9063 error ("%qD must be a nonstatic member function", decl);
9070 if (DECL_STATIC_FUNCTION_P (decl))
9072 error ("%qD must be either a non-static member "
9073 "function or a non-member function", decl);
9077 for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
9079 tree arg = non_reference (TREE_VALUE (p));
9080 if (arg == error_mark_node)
9083 /* IS_AGGR_TYPE, rather than CLASS_TYPE_P, is used
9084 because these checks are performed even on
9085 template functions. */
9086 if (IS_AGGR_TYPE (arg) || TREE_CODE (arg) == ENUMERAL_TYPE)
9090 if (!p || p == void_list_node)
9095 error ("%qD must have an argument of class or "
9102 /* There are no restrictions on the arguments to an overloaded
9104 if (operator_code == CALL_EXPR)
9107 /* Warn about conversion operators that will never be used. */
9108 if (IDENTIFIER_TYPENAME_P (name)
9109 && ! DECL_TEMPLATE_INFO (decl)
9111 /* Warn only declaring the function; there is no need to
9112 warn again about out-of-class definitions. */
9113 && class_type == current_class_type)
9115 tree t = TREE_TYPE (name);
9116 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
9117 const char *what = 0;
9120 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
9122 if (TREE_CODE (t) == VOID_TYPE)
9124 else if (class_type)
9126 if (t == class_type)
9127 what = "the same type";
9128 /* Don't force t to be complete here. */
9129 else if (IS_AGGR_TYPE (t)
9130 && COMPLETE_TYPE_P (t)
9131 && DERIVED_FROM_P (t, class_type))
9132 what = "a base class";
9136 warning (OPT_Wconversion, "conversion to %s%s will never use a type "
9137 "conversion operator",
9138 ref ? "a reference to " : "", what);
9141 if (operator_code == COND_EXPR)
9144 error ("ISO C++ prohibits overloading operator ?:");
9146 else if (ellipsis_p)
9147 error ("%qD must not have variable number of arguments", decl);
9148 else if (ambi_op_p (operator_code))
9151 /* We pick the one-argument operator codes by default, so
9152 we don't have to change anything. */
9154 else if (arity == 2)
9156 /* If we thought this was a unary operator, we now know
9157 it to be a binary operator. */
9158 switch (operator_code)
9161 operator_code = MULT_EXPR;
9165 operator_code = BIT_AND_EXPR;
9168 case UNARY_PLUS_EXPR:
9169 operator_code = PLUS_EXPR;
9173 operator_code = MINUS_EXPR;
9176 case PREINCREMENT_EXPR:
9177 operator_code = POSTINCREMENT_EXPR;
9180 case PREDECREMENT_EXPR:
9181 operator_code = POSTDECREMENT_EXPR;
9188 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
9190 if ((operator_code == POSTINCREMENT_EXPR
9191 || operator_code == POSTDECREMENT_EXPR)
9192 && ! processing_template_decl
9193 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
9196 error ("postfix %qD must take %<int%> as its argument",
9200 ("postfix %qD must take %<int%> as its second argument",
9207 error ("%qD must take either zero or one argument", decl);
9209 error ("%qD must take either one or two arguments", decl);
9212 /* More Effective C++ rule 6. */
9214 && (operator_code == POSTINCREMENT_EXPR
9215 || operator_code == POSTDECREMENT_EXPR
9216 || operator_code == PREINCREMENT_EXPR
9217 || operator_code == PREDECREMENT_EXPR))
9219 tree arg = TREE_VALUE (argtypes);
9220 tree ret = TREE_TYPE (TREE_TYPE (decl));
9221 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
9222 arg = TREE_TYPE (arg);
9223 arg = TYPE_MAIN_VARIANT (arg);
9224 if (operator_code == PREINCREMENT_EXPR
9225 || operator_code == PREDECREMENT_EXPR)
9227 if (TREE_CODE (ret) != REFERENCE_TYPE
9228 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
9230 warning (OPT_Weffc__, "prefix %qD should return %qT", decl,
9231 build_reference_type (arg));
9235 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
9236 warning (OPT_Weffc__, "postfix %qD should return %qT", decl, arg);
9240 else if (unary_op_p (operator_code))
9245 error ("%qD must take %<void%>", decl);
9247 error ("%qD must take exactly one argument", decl);
9250 else /* if (binary_op_p (operator_code)) */
9255 error ("%qD must take exactly one argument", decl);
9257 error ("%qD must take exactly two arguments", decl);
9260 /* More Effective C++ rule 7. */
9262 && (operator_code == TRUTH_ANDIF_EXPR
9263 || operator_code == TRUTH_ORIF_EXPR
9264 || operator_code == COMPOUND_EXPR))
9265 warning (OPT_Weffc__, "user-defined %qD always evaluates both arguments",
9269 /* Effective C++ rule 23. */
9272 && !DECL_ASSIGNMENT_OPERATOR_P (decl)
9273 && (operator_code == PLUS_EXPR
9274 || operator_code == MINUS_EXPR
9275 || operator_code == TRUNC_DIV_EXPR
9276 || operator_code == MULT_EXPR
9277 || operator_code == TRUNC_MOD_EXPR)
9278 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
9279 warning (OPT_Weffc__, "%qD should return by value", decl);
9282 for (; argtypes && argtypes != void_list_node;
9283 argtypes = TREE_CHAIN (argtypes))
9284 if (TREE_PURPOSE (argtypes))
9286 TREE_PURPOSE (argtypes) = NULL_TREE;
9287 if (operator_code == POSTINCREMENT_EXPR
9288 || operator_code == POSTDECREMENT_EXPR)
9291 pedwarn ("%qD cannot have default arguments", decl);
9294 error ("%qD cannot have default arguments", decl);
9301 /* Return a string giving the keyword associate with CODE. */
9304 tag_name (enum tag_types code)
9323 /* Name lookup in an elaborated-type-specifier (after the keyword
9324 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
9325 elaborated-type-specifier is invalid, issue a diagnostic and return
9326 error_mark_node; otherwise, return the *_TYPE to which it referred.
9327 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
9330 check_elaborated_type_specifier (enum tag_types tag_code,
9332 bool allow_template_p)
9338 struct S { struct S *p; };
9340 name lookup will find the TYPE_DECL for the implicit "S::S"
9341 typedef. Adjust for that here. */
9342 if (DECL_SELF_REFERENCE_P (decl))
9343 decl = TYPE_NAME (TREE_TYPE (decl));
9345 type = TREE_TYPE (decl);
9347 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
9348 is false for this case as well. */
9349 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
9351 error ("using template type parameter %qT after %qs",
9352 type, tag_name (tag_code));
9353 return error_mark_node;
9357 If the identifier resolves to a typedef-name or a template
9358 type-parameter, the elaborated-type-specifier is ill-formed.
9360 In other words, the only legitimate declaration to use in the
9361 elaborated type specifier is the implicit typedef created when
9362 the type is declared. */
9363 else if (!DECL_IMPLICIT_TYPEDEF_P (decl)
9364 && tag_code != typename_type)
9366 error ("using typedef-name %qD after %qs", decl, tag_name (tag_code));
9367 error ("%q+D has a previous declaration here", decl);
9368 return error_mark_node;
9370 else if (TREE_CODE (type) != RECORD_TYPE
9371 && TREE_CODE (type) != UNION_TYPE
9372 && tag_code != enum_type
9373 && tag_code != typename_type)
9375 error ("%qT referred to as %qs", type, tag_name (tag_code));
9376 error ("%q+T has a previous declaration here", type);
9377 return error_mark_node;
9379 else if (TREE_CODE (type) != ENUMERAL_TYPE
9380 && tag_code == enum_type)
9382 error ("%qT referred to as enum", type);
9383 error ("%q+T has a previous declaration here", type);
9384 return error_mark_node;
9386 else if (!allow_template_p
9387 && TREE_CODE (type) == RECORD_TYPE
9388 && CLASSTYPE_IS_TEMPLATE (type))
9390 /* If a class template appears as elaborated type specifier
9391 without a template header such as:
9393 template <class T> class C {};
9394 void f(class C); // No template header here
9396 then the required template argument is missing. */
9397 error ("template argument required for %<%s %T%>",
9398 tag_name (tag_code),
9399 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
9400 return error_mark_node;
9406 /* Lookup NAME in elaborate type specifier in scope according to
9407 SCOPE and issue diagnostics if necessary.
9408 Return *_TYPE node upon success, NULL_TREE when the NAME is not
9409 found, and ERROR_MARK_NODE for type error. */
9412 lookup_and_check_tag (enum tag_types tag_code, tree name,
9413 tag_scope scope, bool template_header_p)
9417 if (scope == ts_global)
9419 /* First try ordinary name lookup, ignoring hidden class name
9420 injected via friend declaration. */
9421 decl = lookup_name_prefer_type (name, 2);
9422 /* If that fails, the name will be placed in the smallest
9423 non-class, non-function-prototype scope according to 3.3.1/5.
9424 We may already have a hidden name declared as friend in this
9425 scope. So lookup again but not ignoring hidden name.
9426 If we find one, that name will be made visible rather than
9427 creating a new tag. */
9429 decl = lookup_type_scope (name, ts_within_enclosing_non_class);
9432 decl = lookup_type_scope (name, scope);
9434 if (decl && DECL_CLASS_TEMPLATE_P (decl))
9435 decl = DECL_TEMPLATE_RESULT (decl);
9437 if (decl && TREE_CODE (decl) == TYPE_DECL)
9439 /* Look for invalid nested type:
9443 if (scope == ts_current && DECL_SELF_REFERENCE_P (decl))
9445 error ("%qD has the same name as the class in which it is "
9448 return error_mark_node;
9451 /* Two cases we need to consider when deciding if a class
9452 template is allowed as an elaborated type specifier:
9453 1. It is a self reference to its own class.
9454 2. It comes with a template header.
9458 template <class T> class C {
9459 class C *c1; // DECL_SELF_REFERENCE_P is true
9462 template <class U> class C; // template_header_p is true
9463 template <class T> class C<T>::D {
9464 class C *c2; // DECL_SELF_REFERENCE_P is true
9467 t = check_elaborated_type_specifier (tag_code,
9470 | DECL_SELF_REFERENCE_P (decl));
9477 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
9478 Define the tag as a forward-reference if it is not defined.
9480 If a declaration is given, process it here, and report an error if
9481 multiple declarations are not identical.
9483 SCOPE is TS_CURRENT when this is also a definition. Only look in
9484 the current frame for the name (since C++ allows new names in any
9485 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
9486 declaration. Only look beginning from the current scope outward up
9487 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
9489 TEMPLATE_HEADER_P is true when this declaration is preceded by
9490 a set of template parameters. */
9493 xref_tag (enum tag_types tag_code, tree name,
9494 tag_scope scope, bool template_header_p)
9496 enum tree_code code;
9498 tree context = NULL_TREE;
9500 timevar_push (TV_NAME_LOOKUP);
9502 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
9514 code = ENUMERAL_TYPE;
9520 /* In case of anonymous name, xref_tag is only called to
9521 make type node and push name. Name lookup is not required. */
9522 if (ANON_AGGRNAME_P (name))
9525 t = lookup_and_check_tag (tag_code, name,
9526 scope, template_header_p);
9528 if (t == error_mark_node)
9529 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
9531 if (scope != ts_current && t && current_class_type
9532 && template_class_depth (current_class_type)
9533 && template_header_p)
9535 /* Since SCOPE is not TS_CURRENT, we are not looking at a
9536 definition of this tag. Since, in addition, we are currently
9537 processing a (member) template declaration of a template
9538 class, we must be very careful; consider:
9545 { template <class V>
9546 friend struct S1; };
9548 Here, the S2::S1 declaration should not be confused with the
9549 outer declaration. In particular, the inner version should
9550 have a template parameter of level 2, not level 1. This
9551 would be particularly important if the member declaration
9554 template <class V = U> friend struct S1;
9556 say, when we should tsubst into `U' when instantiating
9557 S2. On the other hand, when presented with:
9567 we must find the inner binding eventually. We
9568 accomplish this by making sure that the new type we
9569 create to represent this declaration has the right
9571 context = TYPE_CONTEXT (t);
9577 /* If no such tag is yet defined, create a forward-reference node
9578 and record it as the "definition".
9579 When a real declaration of this type is found,
9580 the forward-reference will be altered into a real type. */
9581 if (code == ENUMERAL_TYPE)
9583 error ("use of enum %q#D without previous declaration", name);
9584 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
9588 t = make_aggr_type (code);
9589 TYPE_CONTEXT (t) = context;
9590 t = pushtag (name, t, scope);
9595 if (template_header_p && IS_AGGR_TYPE (t))
9596 redeclare_class_template (t, current_template_parms);
9597 else if (!processing_template_decl
9599 && CLASSTYPE_IS_TEMPLATE (t))
9601 error ("redeclaration of %qT as a non-template", t);
9602 t = error_mark_node;
9605 /* Make injected friend class visible. */
9606 if (scope != ts_within_enclosing_non_class
9607 && hidden_name_p (TYPE_NAME (t)))
9609 DECL_ANTICIPATED (TYPE_NAME (t)) = 0;
9610 DECL_FRIEND_P (TYPE_NAME (t)) = 0;
9612 if (TYPE_TEMPLATE_INFO (t))
9614 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t)) = 0;
9615 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t)) = 0;
9620 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
9624 xref_tag_from_type (tree old, tree id, tag_scope scope)
9626 enum tag_types tag_kind;
9628 if (TREE_CODE (old) == RECORD_TYPE)
9629 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
9631 tag_kind = union_type;
9633 if (id == NULL_TREE)
9634 id = TYPE_IDENTIFIER (old);
9636 return xref_tag (tag_kind, id, scope, false);
9639 /* Create the binfo hierarchy for REF with (possibly NULL) base list
9640 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
9641 access_* node, and the TREE_VALUE is the type of the base-class.
9642 Non-NULL TREE_TYPE indicates virtual inheritance. */
9645 xref_basetypes (tree ref, tree base_list)
9648 tree binfo, base_binfo;
9649 unsigned max_vbases = 0; /* Maximum direct & indirect virtual bases. */
9650 unsigned max_bases = 0; /* Maximum direct bases. */
9652 tree default_access;
9653 tree igo_prev; /* Track Inheritance Graph Order. */
9655 if (ref == error_mark_node)
9658 /* The base of a derived class is private by default, all others are
9660 default_access = (TREE_CODE (ref) == RECORD_TYPE
9661 && CLASSTYPE_DECLARED_CLASS (ref)
9662 ? access_private_node : access_public_node);
9664 /* First, make sure that any templates in base-classes are
9665 instantiated. This ensures that if we call ourselves recursively
9666 we do not get confused about which classes are marked and which
9671 tree basetype = TREE_VALUE (*basep);
9673 if (!(processing_template_decl && uses_template_parms (basetype))
9674 && !complete_type_or_else (basetype, NULL))
9675 /* An incomplete type. Remove it from the list. */
9676 *basep = TREE_CHAIN (*basep);
9680 if (TREE_TYPE (*basep))
9682 if (CLASS_TYPE_P (basetype))
9683 max_vbases += VEC_length (tree, CLASSTYPE_VBASECLASSES (basetype));
9684 basep = &TREE_CHAIN (*basep);
9688 TYPE_MARKED_P (ref) = 1;
9690 /* The binfo slot should be empty, unless this is an (ill-formed)
9692 gcc_assert (!TYPE_BINFO (ref) || TYPE_SIZE (ref));
9693 gcc_assert (TYPE_MAIN_VARIANT (ref) == ref);
9695 binfo = make_tree_binfo (max_bases);
9697 TYPE_BINFO (ref) = binfo;
9698 BINFO_OFFSET (binfo) = size_zero_node;
9699 BINFO_TYPE (binfo) = ref;
9703 BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, gc, max_bases);
9704 /* An aggregate cannot have baseclasses. */
9705 CLASSTYPE_NON_AGGREGATE (ref) = 1;
9707 if (TREE_CODE (ref) == UNION_TYPE)
9708 error ("derived union %qT invalid", ref);
9713 if (TYPE_FOR_JAVA (ref))
9714 error ("Java class %qT cannot have multiple bases", ref);
9719 CLASSTYPE_VBASECLASSES (ref) = VEC_alloc (tree, gc, max_vbases);
9721 if (TYPE_FOR_JAVA (ref))
9722 error ("Java class %qT cannot have virtual bases", ref);
9725 for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list))
9727 tree access = TREE_PURPOSE (base_list);
9728 int via_virtual = TREE_TYPE (base_list) != NULL_TREE;
9729 tree basetype = TREE_VALUE (base_list);
9731 if (access == access_default_node)
9732 access = default_access;
9734 if (TREE_CODE (basetype) == TYPE_DECL)
9735 basetype = TREE_TYPE (basetype);
9736 if (TREE_CODE (basetype) != RECORD_TYPE
9737 && TREE_CODE (basetype) != TYPENAME_TYPE
9738 && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
9739 && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM)
9741 error ("base type %qT fails to be a struct or class type",
9746 if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0))
9747 TYPE_FOR_JAVA (ref) = 1;
9749 base_binfo = NULL_TREE;
9750 if (CLASS_TYPE_P (basetype) && !dependent_type_p (basetype))
9752 base_binfo = TYPE_BINFO (basetype);
9753 /* The original basetype could have been a typedef'd type. */
9754 basetype = BINFO_TYPE (base_binfo);
9756 /* Inherit flags from the base. */
9757 TYPE_HAS_NEW_OPERATOR (ref)
9758 |= TYPE_HAS_NEW_OPERATOR (basetype);
9759 TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
9760 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
9761 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
9762 TYPE_HAS_CONVERSION (ref) |= TYPE_HAS_CONVERSION (basetype);
9763 CLASSTYPE_DIAMOND_SHAPED_P (ref)
9764 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype);
9765 CLASSTYPE_REPEATED_BASE_P (ref)
9766 |= CLASSTYPE_REPEATED_BASE_P (basetype);
9769 /* We must do this test after we've seen through a typedef
9771 if (TYPE_MARKED_P (basetype))
9773 if (basetype == ref)
9774 error ("recursive type %qT undefined", basetype);
9776 error ("duplicate base type %qT invalid", basetype);
9779 TYPE_MARKED_P (basetype) = 1;
9781 base_binfo = copy_binfo (base_binfo, basetype, ref,
9782 &igo_prev, via_virtual);
9783 if (!BINFO_INHERITANCE_CHAIN (base_binfo))
9784 BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
9786 BINFO_BASE_APPEND (binfo, base_binfo);
9787 BINFO_BASE_ACCESS_APPEND (binfo, access);
9790 if (VEC_space (tree, CLASSTYPE_VBASECLASSES (ref), 1))
9791 /* If we have space in the vbase vector, we must have shared at
9792 least one of them, and are therefore diamond shaped. */
9793 CLASSTYPE_DIAMOND_SHAPED_P (ref) = 1;
9795 /* Unmark all the types. */
9796 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
9797 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
9798 TYPE_MARKED_P (ref) = 0;
9800 /* Now see if we have a repeated base type. */
9801 if (!CLASSTYPE_REPEATED_BASE_P (ref))
9803 for (base_binfo = binfo; base_binfo;
9804 base_binfo = TREE_CHAIN (base_binfo))
9806 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
9808 CLASSTYPE_REPEATED_BASE_P (ref) = 1;
9811 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 1;
9813 for (base_binfo = binfo; base_binfo;
9814 base_binfo = TREE_CHAIN (base_binfo))
9815 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
9816 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
9823 /* Begin compiling the definition of an enumeration type.
9825 Returns the type object, as yet incomplete.
9826 Also records info about it so that build_enumerator
9827 may be used to declare the individual values as they are read. */
9830 start_enum (tree name)
9834 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
9836 /* If this is the real definition for a previous forward reference,
9837 fill in the contents in the same object that used to be the
9838 forward reference. */
9840 enumtype = lookup_and_check_tag (enum_type, name,
9841 /*tag_scope=*/ts_current,
9842 /*template_header_p=*/false);
9844 if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
9846 error ("multiple definition of %q#T", enumtype);
9847 error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype));
9848 /* Clear out TYPE_VALUES, and start again. */
9849 TYPE_VALUES (enumtype) = NULL_TREE;
9853 /* In case of error, make a dummy enum to allow parsing to
9855 if (enumtype == error_mark_node)
9856 name = make_anon_name ();
9858 enumtype = make_node (ENUMERAL_TYPE);
9859 enumtype = pushtag (name, enumtype, /*tag_scope=*/ts_current);
9865 /* After processing and defining all the values of an enumeration type,
9866 install their decls in the enumeration type and finish it off.
9867 ENUMTYPE is the type object and VALUES a list of name-value pairs. */
9870 finish_enum (tree enumtype)
9879 bool use_short_enum;
9883 integer_type_kind itk;
9884 tree underlying_type = NULL_TREE;
9886 /* We built up the VALUES in reverse order. */
9887 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
9889 /* For an enum defined in a template, just set the type of the values;
9890 all further processing is postponed until the template is
9891 instantiated. We need to set the type so that tsubst of a CONST_DECL
9893 if (processing_template_decl)
9895 for (values = TYPE_VALUES (enumtype);
9897 values = TREE_CHAIN (values))
9898 TREE_TYPE (TREE_VALUE (values)) = enumtype;
9899 if (at_function_scope_p ())
9900 add_stmt (build_min (TAG_DEFN, enumtype));
9904 /* Determine the minimum and maximum values of the enumerators. */
9905 if (TYPE_VALUES (enumtype))
9907 minnode = maxnode = NULL_TREE;
9909 for (values = TYPE_VALUES (enumtype);
9911 values = TREE_CHAIN (values))
9913 decl = TREE_VALUE (values);
9915 /* [dcl.enum]: Following the closing brace of an enum-specifier,
9916 each enumerator has the type of its enumeration. Prior to the
9917 closing brace, the type of each enumerator is the type of its
9918 initializing value. */
9919 TREE_TYPE (decl) = enumtype;
9921 /* Update the minimum and maximum values, if appropriate. */
9922 value = DECL_INITIAL (decl);
9923 if (value == error_mark_node)
9924 value = integer_zero_node;
9925 /* Figure out what the minimum and maximum values of the
9928 minnode = maxnode = value;
9929 else if (tree_int_cst_lt (maxnode, value))
9931 else if (tree_int_cst_lt (value, minnode))
9938 If the enumerator-list is empty, the underlying type is as if
9939 the enumeration had a single enumerator with value 0. */
9940 minnode = maxnode = integer_zero_node;
9942 /* Compute the number of bits require to represent all values of the
9943 enumeration. We must do this before the type of MINNODE and
9944 MAXNODE are transformed, since min_precision relies on the
9945 TREE_TYPE of the value it is passed. */
9946 unsignedp = tree_int_cst_sgn (minnode) >= 0;
9947 lowprec = min_precision (minnode, unsignedp);
9948 highprec = min_precision (maxnode, unsignedp);
9949 precision = MAX (lowprec, highprec);
9951 /* Determine the underlying type of the enumeration.
9955 The underlying type of an enumeration is an integral type that
9956 can represent all the enumerator values defined in the
9957 enumeration. It is implementation-defined which integral type is
9958 used as the underlying type for an enumeration except that the
9959 underlying type shall not be larger than int unless the value of
9960 an enumerator cannot fit in an int or unsigned int.
9962 We use "int" or an "unsigned int" as the underlying type, even if
9963 a smaller integral type would work, unless the user has
9964 explicitly requested that we use the smallest possible type. The
9965 user can request that for all enumerations with a command line
9966 flag, or for just one enumeration with an attribute. */
9968 use_short_enum = flag_short_enums
9969 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype));
9971 for (itk = (use_short_enum ? itk_char : itk_int);
9975 underlying_type = integer_types[itk];
9976 if (TYPE_PRECISION (underlying_type) >= precision
9977 && TYPE_UNSIGNED (underlying_type) == unsignedp)
9980 if (itk == itk_none)
9984 IF no integral type can represent all the enumerator values, the
9985 enumeration is ill-formed. */
9986 error ("no integral type can represent all of the enumerator values "
9987 "for %qT", enumtype);
9988 precision = TYPE_PRECISION (long_long_integer_type_node);
9989 underlying_type = integer_types[itk_unsigned_long_long];
9992 /* Compute the minium and maximum values for the type.
9996 For an enumeration where emin is the smallest enumerator and emax
9997 is the largest, the values of the enumeration are the values of the
9998 underlying type in the range bmin to bmax, where bmin and bmax are,
9999 respectively, the smallest and largest values of the smallest bit-
10000 field that can store emin and emax. */
10002 /* The middle-end currently assumes that types with TYPE_PRECISION
10003 narrower than their underlying type are suitably zero or sign
10004 extended to fill their mode. g++ doesn't make these guarantees.
10005 Until the middle-end can represent such paradoxical types, we
10006 set the TYPE_PRECISION to the width of the underlying type. */
10007 TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type);
10009 set_min_and_max_values_for_integral_type (enumtype, precision, unsignedp);
10013 The value of sizeof() applied to an enumeration type, an object
10014 of an enumeration type, or an enumerator, is the value of sizeof()
10015 applied to the underlying type. */
10016 TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
10017 TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
10018 TYPE_MODE (enumtype) = TYPE_MODE (underlying_type);
10019 TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
10020 TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
10021 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);
10023 /* Convert each of the enumerators to the type of the underlying
10024 type of the enumeration. */
10025 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
10027 location_t saved_location;
10029 decl = TREE_VALUE (values);
10030 saved_location = input_location;
10031 input_location = DECL_SOURCE_LOCATION (decl);
10032 value = perform_implicit_conversion (underlying_type,
10033 DECL_INITIAL (decl));
10034 input_location = saved_location;
10036 /* Do not clobber shared ints. */
10037 value = copy_node (value);
10039 TREE_TYPE (value) = enumtype;
10040 DECL_INITIAL (decl) = value;
10041 TREE_VALUE (values) = value;
10044 /* Fix up all variant types of this enum type. */
10045 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
10047 TYPE_VALUES (t) = TYPE_VALUES (enumtype);
10048 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
10049 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
10050 TYPE_SIZE (t) = TYPE_SIZE (enumtype);
10051 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
10052 TYPE_MODE (t) = TYPE_MODE (enumtype);
10053 TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
10054 TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
10055 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
10056 TYPE_UNSIGNED (t) = TYPE_UNSIGNED (enumtype);
10059 /* Finish debugging output for this type. */
10060 rest_of_type_compilation (enumtype, namespace_bindings_p ());
10063 /* Build and install a CONST_DECL for an enumeration constant of the
10064 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
10065 Assignment of sequential values by default is handled here. */
10068 build_enumerator (tree name, tree value, tree enumtype)
10074 /* If the VALUE was erroneous, pretend it wasn't there; that will
10075 result in the enum being assigned the next value in sequence. */
10076 if (value == error_mark_node)
10079 /* Remove no-op casts from the value. */
10081 STRIP_TYPE_NOPS (value);
10083 if (! processing_template_decl)
10085 /* Validate and default VALUE. */
10086 if (value != NULL_TREE)
10088 value = integral_constant_value (value);
10090 if (TREE_CODE (value) == INTEGER_CST)
10092 value = perform_integral_promotions (value);
10093 constant_expression_warning (value);
10097 error ("enumerator value for %qD not integer constant", name);
10102 /* Default based on previous value. */
10103 if (value == NULL_TREE)
10105 if (TYPE_VALUES (enumtype))
10108 unsigned HOST_WIDE_INT lo;
10112 /* The next value is the previous value plus one. We can
10113 safely assume that the previous value is an INTEGER_CST.
10114 add_double doesn't know the type of the target expression,
10115 so we must check with int_fits_type_p as well. */
10116 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
10117 overflowed = add_double (TREE_INT_CST_LOW (prev_value),
10118 TREE_INT_CST_HIGH (prev_value),
10120 value = build_int_cst_wide (TREE_TYPE (prev_value), lo, hi);
10121 overflowed |= !int_fits_type_p (value, TREE_TYPE (prev_value));
10125 error ("overflow in enumeration values at %qD", name);
10126 value = error_mark_node;
10130 value = integer_zero_node;
10133 /* Remove no-op casts from the value. */
10134 STRIP_TYPE_NOPS (value);
10137 /* C++ associates enums with global, function, or class declarations. */
10138 context = current_scope ();
10140 /* Build the actual enumeration constant. Note that the enumeration
10141 constants have the type of their initializers until the
10142 enumeration is complete:
10146 Following the closing brace of an enum-specifier, each enumer-
10147 ator has the type of its enumeration. Prior to the closing
10148 brace, the type of each enumerator is the type of its
10149 initializing value.
10151 In finish_enum we will reset the type. Of course, if we're
10152 processing a template, there may be no value. */
10153 type = value ? TREE_TYPE (value) : NULL_TREE;
10155 if (context && context == current_class_type)
10156 /* This enum declaration is local to the class. We need the full
10157 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
10158 decl = build_lang_decl (CONST_DECL, name, type);
10160 /* It's a global enum, or it's local to a function. (Note local to
10161 a function could mean local to a class method. */
10162 decl = build_decl (CONST_DECL, name, type);
10164 DECL_CONTEXT (decl) = FROB_CONTEXT (context);
10165 TREE_CONSTANT (decl) = 1;
10166 TREE_INVARIANT (decl) = 1;
10167 TREE_READONLY (decl) = 1;
10168 DECL_INITIAL (decl) = value;
10170 if (context && context == current_class_type)
10171 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
10172 on the TYPE_FIELDS list for `S'. (That's so that you can say
10173 things like `S::i' later.) */
10174 finish_member_declaration (decl);
10178 /* Add this enumeration constant to the list for this type. */
10179 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
10183 /* We're defining DECL. Make sure that it's type is OK. */
10186 check_function_type (tree decl, tree current_function_parms)
10188 tree fntype = TREE_TYPE (decl);
10189 tree return_type = complete_type (TREE_TYPE (fntype));
10191 /* In a function definition, arg types must be complete. */
10192 require_complete_types_for_parms (current_function_parms);
10194 if (dependent_type_p (return_type))
10196 if (!COMPLETE_OR_VOID_TYPE_P (return_type))
10198 tree args = TYPE_ARG_TYPES (fntype);
10200 error ("return type %q#T is incomplete", return_type);
10202 /* Make it return void instead. */
10203 if (TREE_CODE (fntype) == METHOD_TYPE)
10204 fntype = build_method_type_directly (TREE_TYPE (TREE_VALUE (args)),
10206 TREE_CHAIN (args));
10208 fntype = build_function_type (void_type_node, args);
10210 = build_exception_variant (fntype,
10211 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)));
10214 abstract_virtuals_error (decl, TREE_TYPE (fntype));
10217 /* Create the FUNCTION_DECL for a function definition.
10218 DECLSPECS and DECLARATOR are the parts of the declaration;
10219 they describe the function's name and the type it returns,
10220 but twisted together in a fashion that parallels the syntax of C.
10222 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
10223 DECLARATOR is really the DECL for the function we are about to
10224 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
10225 indicating that the function is an inline defined in-class.
10227 This function creates a binding context for the function body
10228 as well as setting up the FUNCTION_DECL in current_function_decl.
10230 For C++, we must first check whether that datum makes any sense.
10231 For example, "class A local_a(1,2);" means that variable local_a
10232 is an aggregate of type A, which should have a constructor
10233 applied to it with the argument list [1, 2]. */
10236 start_preparsed_function (tree decl1, tree attrs, int flags)
10238 tree ctype = NULL_TREE;
10241 int doing_friend = 0;
10242 struct cp_binding_level *bl;
10243 tree current_function_parms;
10244 struct c_fileinfo *finfo
10245 = get_fileinfo (lbasename (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1))));
10246 bool honor_interface;
10248 /* Sanity check. */
10249 gcc_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE);
10250 gcc_assert (TREE_CHAIN (void_list_node) == NULL_TREE);
10252 fntype = TREE_TYPE (decl1);
10253 if (TREE_CODE (fntype) == METHOD_TYPE)
10254 ctype = TYPE_METHOD_BASETYPE (fntype);
10256 /* ISO C++ 11.4/5. A friend function defined in a class is in
10257 the (lexical) scope of the class in which it is defined. */
10258 if (!ctype && DECL_FRIEND_P (decl1))
10260 ctype = DECL_FRIEND_CONTEXT (decl1);
10262 /* CTYPE could be null here if we're dealing with a template;
10263 for example, `inline friend float foo()' inside a template
10264 will have no CTYPE set. */
10265 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
10271 if (DECL_DECLARED_INLINE_P (decl1)
10272 && lookup_attribute ("noinline", attrs))
10273 warning (0, "inline function %q+D given attribute noinline", decl1);
10275 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
10276 /* This is a constructor, we must ensure that any default args
10277 introduced by this definition are propagated to the clones
10278 now. The clones are used directly in overload resolution. */
10279 adjust_clone_args (decl1);
10281 /* Sometimes we don't notice that a function is a static member, and
10282 build a METHOD_TYPE for it. Fix that up now. */
10283 if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
10284 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
10286 revert_static_member_fn (decl1);
10290 /* Set up current_class_type, and enter the scope of the class, if
10293 push_nested_class (ctype);
10294 else if (DECL_STATIC_FUNCTION_P (decl1))
10295 push_nested_class (DECL_CONTEXT (decl1));
10297 /* Now that we have entered the scope of the class, we must restore
10298 the bindings for any template parameters surrounding DECL1, if it
10299 is an inline member template. (Order is important; consider the
10300 case where a template parameter has the same name as a field of
10301 the class.) It is not until after this point that
10302 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
10303 if (flags & SF_INCLASS_INLINE)
10304 maybe_begin_member_template_processing (decl1);
10306 /* Effective C++ rule 15. */
10308 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
10309 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
10310 warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");
10312 /* Make the init_value nonzero so pushdecl knows this is not tentative.
10313 error_mark_node is replaced below (in poplevel) with the BLOCK. */
10314 if (!DECL_INITIAL (decl1))
10315 DECL_INITIAL (decl1) = error_mark_node;
10317 /* This function exists in static storage.
10318 (This does not mean `static' in the C sense!) */
10319 TREE_STATIC (decl1) = 1;
10321 /* We must call push_template_decl after current_class_type is set
10322 up. (If we are processing inline definitions after exiting a
10323 class scope, current_class_type will be NULL_TREE until set above
10324 by push_nested_class.) */
10325 if (processing_template_decl)
10327 /* FIXME: Handle error_mark_node more gracefully. */
10328 tree newdecl1 = push_template_decl (decl1);
10329 if (newdecl1 != error_mark_node)
10333 /* We are now in the scope of the function being defined. */
10334 current_function_decl = decl1;
10336 /* Save the parm names or decls from this function's declarator
10337 where store_parm_decls will find them. */
10338 current_function_parms = DECL_ARGUMENTS (decl1);
10340 /* Make sure the parameter and return types are reasonable. When
10341 you declare a function, these types can be incomplete, but they
10342 must be complete when you define the function. */
10343 check_function_type (decl1, current_function_parms);
10344 /* Make sure no default arg is missing. */
10345 check_default_args (decl1);
10347 /* Build the return declaration for the function. */
10348 restype = TREE_TYPE (fntype);
10349 /* Promote the value to int before returning it. */
10350 if (c_promoting_integer_type_p (restype))
10351 restype = type_promotes_to (restype);
10352 if (DECL_RESULT (decl1) == NULL_TREE)
10356 resdecl = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
10357 DECL_ARTIFICIAL (resdecl) = 1;
10358 DECL_IGNORED_P (resdecl) = 1;
10359 DECL_RESULT (decl1) = resdecl;
10361 cp_apply_type_quals_to_decl (cp_type_quals (restype), resdecl);
10364 /* Initialize RTL machinery. We cannot do this until
10365 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
10366 even when processing a template; this is how we get
10367 CFUN set up, and our per-function variables initialized.
10368 FIXME factor out the non-RTL stuff. */
10369 bl = current_binding_level;
10370 allocate_struct_function (decl1);
10371 current_binding_level = bl;
10373 /* Even though we're inside a function body, we still don't want to
10374 call expand_expr to calculate the size of a variable-sized array.
10375 We haven't necessarily assigned RTL to all variables yet, so it's
10376 not safe to try to expand expressions involving them. */
10377 cfun->x_dont_save_pending_sizes_p = 1;
10379 /* Start the statement-tree, start the tree now. */
10380 DECL_SAVED_TREE (decl1) = push_stmt_list ();
10382 /* Let the user know we're compiling this function. */
10383 announce_function (decl1);
10385 /* Record the decl so that the function name is defined.
10386 If we already have a decl for this name, and it is a FUNCTION_DECL,
10387 use the old decl. */
10388 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
10390 /* A specialization is not used to guide overload resolution. */
10391 if (!DECL_FUNCTION_MEMBER_P (decl1)
10392 && !(DECL_USE_TEMPLATE (decl1) &&
10393 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1))))
10395 tree olddecl = pushdecl (decl1);
10397 if (olddecl == error_mark_node)
10398 /* If something went wrong when registering the declaration,
10399 use DECL1; we have to have a FUNCTION_DECL to use when
10400 parsing the body of the function. */
10403 /* Otherwise, OLDDECL is either a previous declaration of
10404 the same function or DECL1 itself. */
10409 /* We need to set the DECL_CONTEXT. */
10410 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
10411 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
10413 fntype = TREE_TYPE (decl1);
10415 /* If #pragma weak applies, mark the decl appropriately now.
10416 The pragma only applies to global functions. Because
10417 determining whether or not the #pragma applies involves
10418 computing the mangled name for the declaration, we cannot
10419 apply the pragma until after we have merged this declaration
10420 with any previous declarations; if the original declaration
10421 has a linkage specification, that specification applies to
10422 the definition as well, and may affect the mangled name. */
10423 if (!DECL_CONTEXT (decl1))
10424 maybe_apply_pragma_weak (decl1);
10427 /* Reset these in case the call to pushdecl changed them. */
10428 current_function_decl = decl1;
10429 cfun->decl = decl1;
10431 /* If we are (erroneously) defining a function that we have already
10432 defined before, wipe out what we knew before. */
10433 if (!DECL_PENDING_INLINE_P (decl1))
10434 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
10436 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
10438 /* We know that this was set up by `grokclassfn'. We do not
10439 wait until `store_parm_decls', since evil parse errors may
10440 never get us to that point. Here we keep the consistency
10441 between `current_class_type' and `current_class_ptr'. */
10442 tree t = DECL_ARGUMENTS (decl1);
10444 gcc_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL);
10445 gcc_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE);
10447 cp_function_chain->x_current_class_ref
10448 = build_indirect_ref (t, NULL);
10449 cp_function_chain->x_current_class_ptr = t;
10451 /* Constructors and destructors need to know whether they're "in
10452 charge" of initializing virtual base classes. */
10453 t = TREE_CHAIN (t);
10454 if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
10456 current_in_charge_parm = t;
10457 t = TREE_CHAIN (t);
10459 if (DECL_HAS_VTT_PARM_P (decl1))
10461 gcc_assert (DECL_NAME (t) == vtt_parm_identifier);
10462 current_vtt_parm = t;
10466 honor_interface = (!DECL_TEMPLATE_INSTANTIATION (decl1)
10467 /* Implicitly-defined methods (like the
10468 destructor for a class in which no destructor
10469 is explicitly declared) must not be defined
10470 until their definition is needed. So, we
10471 ignore interface specifications for
10472 compiler-generated functions. */
10473 && !DECL_ARTIFICIAL (decl1));
10475 if (DECL_INTERFACE_KNOWN (decl1))
10477 tree ctx = decl_function_context (decl1);
10479 if (DECL_NOT_REALLY_EXTERN (decl1))
10480 DECL_EXTERNAL (decl1) = 0;
10482 if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
10483 && TREE_PUBLIC (ctx))
10484 /* This is a function in a local class in an extern inline
10486 comdat_linkage (decl1);
10488 /* If this function belongs to an interface, it is public.
10489 If it belongs to someone else's interface, it is also external.
10490 This only affects inlines and template instantiations. */
10491 else if (!finfo->interface_unknown && honor_interface)
10493 if (DECL_DECLARED_INLINE_P (decl1)
10494 || DECL_TEMPLATE_INSTANTIATION (decl1)
10495 || processing_template_decl)
10497 DECL_EXTERNAL (decl1)
10498 = (finfo->interface_only
10499 || (DECL_DECLARED_INLINE_P (decl1)
10500 && ! flag_implement_inlines
10501 && !DECL_VINDEX (decl1)));
10503 /* For WIN32 we also want to put these in linkonce sections. */
10504 maybe_make_one_only (decl1);
10507 DECL_EXTERNAL (decl1) = 0;
10508 DECL_INTERFACE_KNOWN (decl1) = 1;
10509 /* If this function is in an interface implemented in this file,
10510 make sure that the backend knows to emit this function
10512 if (!DECL_EXTERNAL (decl1))
10513 mark_needed (decl1);
10515 else if (finfo->interface_unknown && finfo->interface_only
10516 && honor_interface)
10518 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
10519 interface, we will have both finfo->interface_unknown and
10520 finfo->interface_only set. In that case, we don't want to
10521 use the normal heuristics because someone will supply a
10522 #pragma implementation elsewhere, and deducing it here would
10523 produce a conflict. */
10524 comdat_linkage (decl1);
10525 DECL_EXTERNAL (decl1) = 0;
10526 DECL_INTERFACE_KNOWN (decl1) = 1;
10527 DECL_DEFER_OUTPUT (decl1) = 1;
10531 /* This is a definition, not a reference.
10532 So clear DECL_EXTERNAL. */
10533 DECL_EXTERNAL (decl1) = 0;
10535 if ((DECL_DECLARED_INLINE_P (decl1)
10536 || DECL_TEMPLATE_INSTANTIATION (decl1))
10537 && ! DECL_INTERFACE_KNOWN (decl1)
10538 /* Don't try to defer nested functions for now. */
10539 && ! decl_function_context (decl1))
10540 DECL_DEFER_OUTPUT (decl1) = 1;
10542 DECL_INTERFACE_KNOWN (decl1) = 1;
10545 /* Determine the ELF visibility attribute for the function. We must not
10546 do this before calling "pushdecl", as we must allow "duplicate_decls"
10547 to merge any attributes appropriately. We also need to wait until
10549 if (!DECL_CLONED_FUNCTION_P (decl1))
10550 determine_visibility (decl1);
10552 begin_scope (sk_function_parms, decl1);
10556 if (DECL_DESTRUCTOR_P (decl1)
10557 || (DECL_CONSTRUCTOR_P (decl1)
10558 && targetm.cxx.cdtor_returns_this ()))
10560 cdtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
10561 DECL_CONTEXT (cdtor_label) = current_function_decl;
10564 start_fname_decls ();
10566 store_parm_decls (current_function_parms);
10570 /* Like start_preparsed_function, except that instead of a
10571 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
10573 Returns 1 on success. If the DECLARATOR is not suitable for a function
10574 (it defines a datum instead), we return 0, which tells
10575 yyparse to report a parse error. */
10578 start_function (cp_decl_specifier_seq *declspecs,
10579 const cp_declarator *declarator,
10584 if (have_extern_spec)
10586 declspecs->storage_class = sc_extern;
10587 /* This should only be done once on the outermost decl. */
10588 have_extern_spec = false;
10591 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
10592 /* If the declarator is not suitable for a function definition,
10593 cause a syntax error. */
10594 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
10597 if (DECL_MAIN_P (decl1))
10598 /* main must return int. grokfndecl should have corrected it
10599 (and issued a diagnostic) if the user got it wrong. */
10600 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1)),
10601 integer_type_node));
10603 start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT);
10608 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
10612 use_eh_spec_block (tree fn)
10614 return (flag_exceptions && flag_enforce_eh_specs
10615 && !processing_template_decl
10616 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn))
10617 /* We insert the EH_SPEC_BLOCK only in the original
10618 function; then, it is copied automatically to the
10620 && !DECL_CLONED_FUNCTION_P (fn)
10621 /* Implicitly-generated constructors and destructors have
10622 exception specifications. However, those specifications
10623 are the union of the possible exceptions specified by the
10624 constructors/destructors for bases and members, so no
10625 unallowed exception will ever reach this function. By
10626 not creating the EH_SPEC_BLOCK we save a little memory,
10627 and we avoid spurious warnings about unreachable
10629 && !DECL_ARTIFICIAL (fn));
10632 /* Store the parameter declarations into the current function declaration.
10633 This is called after parsing the parameter declarations, before
10634 digesting the body of the function.
10636 Also install to binding contour return value identifier, if any. */
10639 store_parm_decls (tree current_function_parms)
10641 tree fndecl = current_function_decl;
10644 /* This is a chain of any other decls that came in among the parm
10645 declarations. If a parm is declared with enum {foo, bar} x;
10646 then CONST_DECLs for foo and bar are put here. */
10647 tree nonparms = NULL_TREE;
10649 if (current_function_parms)
10651 /* This case is when the function was defined with an ANSI prototype.
10652 The parms already have decls, so we need not do anything here
10653 except record them as in effect
10654 and complain if any redundant old-style parm decls were written. */
10656 tree specparms = current_function_parms;
10659 /* Must clear this because it might contain TYPE_DECLs declared
10661 current_binding_level->names = NULL;
10663 /* If we're doing semantic analysis, then we'll call pushdecl
10664 for each of these. We must do them in reverse order so that
10665 they end in the correct forward order. */
10666 specparms = nreverse (specparms);
10668 for (parm = specparms; parm; parm = next)
10670 next = TREE_CHAIN (parm);
10671 if (TREE_CODE (parm) == PARM_DECL)
10673 if (DECL_NAME (parm) == NULL_TREE
10674 || TREE_CODE (parm) != VOID_TYPE)
10677 error ("parameter %qD declared void", parm);
10681 /* If we find an enum constant or a type tag,
10682 put it aside for the moment. */
10683 TREE_CHAIN (parm) = NULL_TREE;
10684 nonparms = chainon (nonparms, parm);
10688 /* Get the decls in their original chain order and record in the
10689 function. This is all and only the PARM_DECLs that were
10690 pushed into scope by the loop above. */
10691 DECL_ARGUMENTS (fndecl) = getdecls ();
10694 DECL_ARGUMENTS (fndecl) = NULL_TREE;
10696 /* Now store the final chain of decls for the arguments
10697 as the decl-chain of the current lexical scope.
10698 Put the enumerators in as well, at the front so that
10699 DECL_ARGUMENTS is not modified. */
10700 current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));
10702 if (use_eh_spec_block (current_function_decl))
10703 current_eh_spec_block = begin_eh_spec_block ();
10707 /* We have finished doing semantic analysis on DECL, but have not yet
10708 generated RTL for its body. Save away our current state, so that
10709 when we want to generate RTL later we know what to do. */
10712 save_function_data (tree decl)
10714 struct language_function *f;
10716 /* Save the language-specific per-function data so that we can
10717 get it back when we really expand this function. */
10718 gcc_assert (!DECL_PENDING_INLINE_P (decl));
10721 f = GGC_NEW (struct language_function);
10722 memcpy (f, cp_function_chain, sizeof (struct language_function));
10723 DECL_SAVED_FUNCTION_DATA (decl) = f;
10725 /* Clear out the bits we don't need. */
10726 f->base.x_stmt_tree.x_cur_stmt_list = NULL_TREE;
10727 f->bindings = NULL;
10728 f->x_local_names = NULL;
10732 /* Set the return value of the constructor (if present). */
10735 finish_constructor_body (void)
10740 if (targetm.cxx.cdtor_returns_this ())
10742 /* Any return from a constructor will end up here. */
10743 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
10745 val = DECL_ARGUMENTS (current_function_decl);
10746 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
10747 DECL_RESULT (current_function_decl), val);
10748 /* Return the address of the object. */
10749 exprstmt = build_stmt (RETURN_EXPR, val);
10750 add_stmt (exprstmt);
10754 /* Do all the processing for the beginning of a destructor; set up the
10755 vtable pointers and cleanups for bases and members. */
10758 begin_destructor_body (void)
10760 tree compound_stmt;
10762 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
10763 issued an error message. We still want to try to process the
10764 body of the function, but initialize_vtbl_ptrs will crash if
10765 TYPE_BINFO is NULL. */
10766 if (COMPLETE_TYPE_P (current_class_type))
10768 compound_stmt = begin_compound_stmt (0);
10769 /* Make all virtual function table pointers in non-virtual base
10770 classes point to CURRENT_CLASS_TYPE's virtual function
10772 initialize_vtbl_ptrs (current_class_ptr);
10773 finish_compound_stmt (compound_stmt);
10775 /* And insert cleanups for our bases and members so that they
10776 will be properly destroyed if we throw. */
10777 push_base_cleanups ();
10781 /* At the end of every destructor we generate code to delete the object if
10782 necessary. Do that now. */
10785 finish_destructor_body (void)
10789 /* Any return from a destructor will end up here; that way all base
10790 and member cleanups will be run when the function returns. */
10791 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
10793 /* In a virtual destructor, we must call delete. */
10794 if (DECL_VIRTUAL_P (current_function_decl))
10797 tree virtual_size = cxx_sizeof (current_class_type);
10801 At the point of definition of a virtual destructor (including
10802 an implicit definition), non-placement operator delete shall
10803 be looked up in the scope of the destructor's class and if
10804 found shall be accessible and unambiguous. */
10805 exprstmt = build_op_delete_call(DELETE_EXPR, current_class_ptr,
10807 /*global_p=*/false,
10808 /*placement=*/NULL_TREE,
10809 /*alloc_fn=*/NULL_TREE);
10811 if_stmt = begin_if_stmt ();
10812 finish_if_stmt_cond (build2 (BIT_AND_EXPR, integer_type_node,
10813 current_in_charge_parm,
10816 finish_expr_stmt (exprstmt);
10817 finish_then_clause (if_stmt);
10818 finish_if_stmt (if_stmt);
10821 if (targetm.cxx.cdtor_returns_this ())
10825 val = DECL_ARGUMENTS (current_function_decl);
10826 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
10827 DECL_RESULT (current_function_decl), val);
10828 /* Return the address of the object. */
10829 exprstmt = build_stmt (RETURN_EXPR, val);
10830 add_stmt (exprstmt);
10834 /* Do the necessary processing for the beginning of a function body, which
10835 in this case includes member-initializers, but not the catch clauses of
10836 a function-try-block. Currently, this means opening a binding level
10837 for the member-initializers (in a ctor) and member cleanups (in a dtor). */
10840 begin_function_body (void)
10844 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
10847 if (processing_template_decl)
10848 /* Do nothing now. */;
10850 /* Always keep the BLOCK node associated with the outermost pair of
10851 curly braces of a function. These are needed for correct
10852 operation of dwarfout.c. */
10853 keep_next_level (true);
10855 stmt = begin_compound_stmt (BCS_FN_BODY);
10857 if (processing_template_decl)
10858 /* Do nothing now. */;
10859 else if (DECL_DESTRUCTOR_P (current_function_decl))
10860 begin_destructor_body ();
10865 /* Do the processing for the end of a function body. Currently, this means
10866 closing out the cleanups for fully-constructed bases and members, and in
10867 the case of the destructor, deleting the object if desired. Again, this
10868 is only meaningful for [cd]tors, since they are the only functions where
10869 there is a significant distinction between the main body and any
10870 function catch clauses. Handling, say, main() return semantics here
10871 would be wrong, as flowing off the end of a function catch clause for
10872 main() would also need to return 0. */
10875 finish_function_body (tree compstmt)
10877 if (compstmt == NULL_TREE)
10880 /* Close the block. */
10881 finish_compound_stmt (compstmt);
10883 if (processing_template_decl)
10884 /* Do nothing now. */;
10885 else if (DECL_CONSTRUCTOR_P (current_function_decl))
10886 finish_constructor_body ();
10887 else if (DECL_DESTRUCTOR_P (current_function_decl))
10888 finish_destructor_body ();
10891 /* Given a function, returns the BLOCK corresponding to the outermost level
10892 of curly braces, skipping the artificial block created for constructor
10896 outer_curly_brace_block (tree fndecl)
10898 tree block = BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl));
10899 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
10900 /* Skip the artificial function body block. */
10901 block = BLOCK_SUBBLOCKS (block);
10905 /* Finish up a function declaration and compile that function
10906 all the way to assembler language output. The free the storage
10907 for the function definition.
10909 FLAGS is a bitwise or of the following values:
10911 We just finished processing the body of an in-class inline
10912 function definition. (This processing will have taken place
10913 after the class definition is complete.) */
10916 finish_function (int flags)
10918 tree fndecl = current_function_decl;
10919 tree fntype, ctype = NULL_TREE;
10920 int inclass_inline = (flags & 2) != 0;
10923 /* When we get some parse errors, we can end up without a
10924 current_function_decl, so cope. */
10925 if (fndecl == NULL_TREE)
10926 return error_mark_node;
10928 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
10929 && DECL_VIRTUAL_P (fndecl)
10930 && !processing_template_decl)
10932 tree fnclass = DECL_CONTEXT (fndecl);
10933 if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
10934 keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
10937 nested = function_depth > 1;
10938 fntype = TREE_TYPE (fndecl);
10940 /* TREE_READONLY (fndecl) = 1;
10941 This caused &foo to be of type ptr-to-const-function
10942 which then got a warning when stored in a ptr-to-function variable. */
10944 gcc_assert (building_stmt_tree ());
10946 /* For a cloned function, we've already got all the code we need;
10947 there's no need to add any extra bits. */
10948 if (!DECL_CLONED_FUNCTION_P (fndecl))
10950 if (DECL_MAIN_P (current_function_decl))
10954 /* Make it so that `main' always returns 0 by default (or
10957 stmt = finish_return_stmt (integer_one_node);
10959 stmt = finish_return_stmt (integer_zero_node);
10961 /* Hack. We don't want the middle-end to warn that this
10962 return is unreachable, so put the statement on the
10964 #ifdef USE_MAPPED_LOCATION
10965 SET_EXPR_LOCATION (stmt, UNKNOWN_LOCATION);
10967 annotate_with_file_line (stmt, input_filename, 0);
10971 if (use_eh_spec_block (current_function_decl))
10972 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
10973 (TREE_TYPE (current_function_decl)),
10974 current_eh_spec_block);
10977 /* If we're saving up tree structure, tie off the function now. */
10978 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
10980 finish_fname_decls ();
10982 /* If this function can't throw any exceptions, remember that. */
10983 if (!processing_template_decl
10984 && !cp_function_chain->can_throw
10985 && !flag_non_call_exceptions)
10986 TREE_NOTHROW (fndecl) = 1;
10988 /* This must come after expand_function_end because cleanups might
10989 have declarations (from inline functions) that need to go into
10990 this function's blocks. */
10992 /* If the current binding level isn't the outermost binding level
10993 for this function, either there is a bug, or we have experienced
10994 syntax errors and the statement tree is malformed. */
10995 if (current_binding_level->kind != sk_function_parms)
10997 /* Make sure we have already experienced errors. */
10998 gcc_assert (errorcount);
11000 /* Throw away the broken statement tree and extra binding
11002 DECL_SAVED_TREE (fndecl) = alloc_stmt_list ();
11004 while (current_binding_level->kind != sk_function_parms)
11006 if (current_binding_level->kind == sk_class)
11007 pop_nested_class ();
11009 poplevel (0, 0, 0);
11012 poplevel (1, 0, 1);
11014 /* Statements should always be full-expressions at the outermost set
11015 of curly braces for a function. */
11016 gcc_assert (stmts_are_full_exprs_p ());
11018 /* Set up the named return value optimization, if we can. Candidate
11019 variables are selected in check_return_value. */
11020 if (current_function_return_value)
11022 tree r = current_function_return_value;
11025 if (r != error_mark_node
11026 /* This is only worth doing for fns that return in memory--and
11027 simpler, since we don't have to worry about promoted modes. */
11028 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
11029 /* Only allow this for variables declared in the outer scope of
11030 the function so we know that their lifetime always ends with a
11031 return; see g++.dg/opt/nrv6.C. We could be more flexible if
11032 we were to do this optimization in tree-ssa. */
11033 && (outer = outer_curly_brace_block (fndecl))
11034 && chain_member (r, BLOCK_VARS (outer)))
11035 finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));
11037 current_function_return_value = NULL_TREE;
11040 /* Remember that we were in class scope. */
11041 if (current_class_name)
11042 ctype = current_class_type;
11044 /* Must mark the RESULT_DECL as being in this function. */
11045 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
11047 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
11048 to the FUNCTION_DECL node itself. */
11049 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
11051 /* Save away current state, if appropriate. */
11052 if (!processing_template_decl)
11053 save_function_data (fndecl);
11055 /* Complain if there's just no return statement. */
11056 if (warn_return_type
11057 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
11058 && !dependent_type_p (TREE_TYPE (fntype))
11059 && !current_function_returns_value && !current_function_returns_null
11060 /* Don't complain if we abort or throw. */
11061 && !current_function_returns_abnormally
11062 && !DECL_NAME (DECL_RESULT (fndecl))
11063 /* Normally, with -Wreturn-type, flow will complain. Unless we're an
11064 inline function, as we might never be compiled separately. */
11065 && (DECL_INLINE (fndecl) || processing_template_decl)
11066 /* Structor return values (if any) are set by the compiler. */
11067 && !DECL_CONSTRUCTOR_P (fndecl)
11068 && !DECL_DESTRUCTOR_P (fndecl))
11069 warning (OPT_Wreturn_type, "no return statement in function returning non-void");
11071 /* Store the end of the function, so that we get good line number
11072 info for the epilogue. */
11073 cfun->function_end_locus = input_location;
11075 /* Genericize before inlining. */
11076 if (!processing_template_decl)
11078 struct language_function *f = DECL_SAVED_FUNCTION_DATA (fndecl);
11079 cp_genericize (fndecl);
11080 /* Clear out the bits we don't need. */
11081 f->x_current_class_ptr = NULL;
11082 f->x_current_class_ref = NULL;
11083 f->x_eh_spec_block = NULL;
11084 f->x_in_charge_parm = NULL;
11085 f->x_vtt_parm = NULL;
11086 f->x_return_value = NULL;
11087 f->bindings = NULL;
11089 /* Handle attribute((warn_unused_result)). Relies on gimple input. */
11090 c_warn_unused_result (&DECL_SAVED_TREE (fndecl));
11092 /* Clear out the bits we don't need. */
11093 local_names = NULL;
11095 /* We're leaving the context of this function, so zap cfun. It's still in
11096 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
11098 current_function_decl = NULL;
11100 /* If this is an in-class inline definition, we may have to pop the
11101 bindings for the template parameters that we added in
11102 maybe_begin_member_template_processing when start_function was
11104 if (inclass_inline)
11105 maybe_end_member_template_processing ();
11107 /* Leave the scope of the class. */
11109 pop_nested_class ();
11115 /* Let the error reporting routines know that we're outside a
11116 function. For a nested function, this value is used in
11117 cxx_pop_function_context and then reset via pop_function_context. */
11118 current_function_decl = NULL_TREE;
11123 /* Create the FUNCTION_DECL for a function definition.
11124 DECLSPECS and DECLARATOR are the parts of the declaration;
11125 they describe the return type and the name of the function,
11126 but twisted together in a fashion that parallels the syntax of C.
11128 This function creates a binding context for the function body
11129 as well as setting up the FUNCTION_DECL in current_function_decl.
11131 Returns a FUNCTION_DECL on success.
11133 If the DECLARATOR is not suitable for a function (it defines a datum
11134 instead), we return 0, which tells yyparse to report a parse error.
11136 May return void_type_node indicating that this method is actually
11137 a friend. See grokfield for more details.
11139 Came here with a `.pushlevel' .
11141 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
11142 CHANGES TO CODE IN `grokfield'. */
11145 start_method (cp_decl_specifier_seq *declspecs,
11146 const cp_declarator *declarator, tree attrlist)
11148 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
11151 if (fndecl == error_mark_node)
11152 return error_mark_node;
11154 if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
11156 error ("invalid member function declaration");
11157 return error_mark_node;
11161 cplus_decl_attributes (&fndecl, attrlist, 0);
11163 /* Pass friends other than inline friend functions back. */
11164 if (fndecl == void_type_node)
11167 if (DECL_IN_AGGR_P (fndecl))
11169 if (DECL_CONTEXT (fndecl)
11170 && TREE_CODE (DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
11171 error ("%qD is already defined in class %qT", fndecl,
11172 DECL_CONTEXT (fndecl));
11173 return error_mark_node;
11176 check_template_shadow (fndecl);
11178 DECL_DECLARED_INLINE_P (fndecl) = 1;
11179 if (flag_default_inline)
11180 DECL_INLINE (fndecl) = 1;
11182 /* We process method specializations in finish_struct_1. */
11183 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
11185 fndecl = push_template_decl (fndecl);
11186 if (fndecl == error_mark_node)
11190 if (! DECL_FRIEND_P (fndecl))
11192 if (TREE_CHAIN (fndecl))
11194 fndecl = copy_node (fndecl);
11195 TREE_CHAIN (fndecl) = NULL_TREE;
11199 finish_decl (fndecl, NULL_TREE, NULL_TREE);
11201 /* Make a place for the parms. */
11202 begin_scope (sk_function_parms, fndecl);
11204 DECL_IN_AGGR_P (fndecl) = 1;
11208 /* Go through the motions of finishing a function definition.
11209 We don't compile this method until after the whole class has
11212 FINISH_METHOD must return something that looks as though it
11213 came from GROKFIELD (since we are defining a method, after all).
11215 This is called after parsing the body of the function definition.
11216 STMTS is the chain of statements that makes up the function body.
11218 DECL is the ..._DECL that `start_method' provided. */
11221 finish_method (tree decl)
11223 tree fndecl = decl;
11228 if (decl == void_type_node)
11231 old_initial = DECL_INITIAL (fndecl);
11233 /* Undo the level for the parms (from start_method).
11234 This is like poplevel, but it causes nothing to be
11235 saved. Saving information here confuses symbol-table
11236 output routines. Besides, this information will
11237 be correctly output when this method is actually
11240 /* Clear out the meanings of the local variables of this level;
11241 also record in each decl which block it belongs to. */
11243 for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
11245 if (DECL_NAME (link) != NULL_TREE)
11246 pop_binding (DECL_NAME (link), link);
11247 gcc_assert (TREE_CODE (link) != FUNCTION_DECL);
11248 DECL_CONTEXT (link) = NULL_TREE;
11251 poplevel (0, 0, 0);
11253 DECL_INITIAL (fndecl) = old_initial;
11255 /* We used to check if the context of FNDECL was different from
11256 current_class_type as another way to get inside here. This didn't work
11257 for String.cc in libg++. */
11258 if (DECL_FRIEND_P (fndecl))
11260 VEC_safe_push (tree, gc, CLASSTYPE_INLINE_FRIENDS (current_class_type),
11262 decl = void_type_node;
11269 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
11270 we can lay it out later, when and if its type becomes complete. */
11273 maybe_register_incomplete_var (tree var)
11275 gcc_assert (TREE_CODE (var) == VAR_DECL);
11277 /* Keep track of variables with incomplete types. */
11278 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
11279 && DECL_EXTERNAL (var))
11281 tree inner_type = TREE_TYPE (var);
11283 while (TREE_CODE (inner_type) == ARRAY_TYPE)
11284 inner_type = TREE_TYPE (inner_type);
11285 inner_type = TYPE_MAIN_VARIANT (inner_type);
11287 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
11288 /* RTTI TD entries are created while defining the type_info. */
11289 || (TYPE_LANG_SPECIFIC (inner_type)
11290 && TYPE_BEING_DEFINED (inner_type)))
11291 incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
11295 /* Called when a class type (given by TYPE) is defined. If there are
11296 any existing VAR_DECLs whose type hsa been completed by this
11297 declaration, update them now. */
11300 complete_vars (tree type)
11302 tree *list = &incomplete_vars;
11304 gcc_assert (CLASS_TYPE_P (type));
11307 if (same_type_p (type, TREE_PURPOSE (*list)))
11309 tree var = TREE_VALUE (*list);
11310 tree type = TREE_TYPE (var);
11311 /* Complete the type of the variable. The VAR_DECL itself
11312 will be laid out in expand_expr. */
11313 complete_type (type);
11314 cp_apply_type_quals_to_decl (cp_type_quals (type), var);
11315 /* Remove this entry from the list. */
11316 *list = TREE_CHAIN (*list);
11319 list = &TREE_CHAIN (*list);
11322 /* Check for pending declarations which may have abstract type. */
11323 complete_type_check_abstract (type);
11326 /* If DECL is of a type which needs a cleanup, build that cleanup
11330 cxx_maybe_build_cleanup (tree decl)
11332 tree type = TREE_TYPE (decl);
11334 if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
11336 int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
11338 bool has_vbases = (TREE_CODE (type) == RECORD_TYPE
11339 && CLASSTYPE_VBASECLASSES (type));
11341 if (TREE_CODE (type) == ARRAY_TYPE)
11345 cxx_mark_addressable (decl);
11346 rval = build_unary_op (ADDR_EXPR, decl, 0);
11349 /* Optimize for space over speed here. */
11350 if (!has_vbases || flag_expensive_optimizations)
11351 flags |= LOOKUP_NONVIRTUAL;
11353 rval = build_delete (TREE_TYPE (rval), rval,
11354 sfk_complete_destructor, flags, 0);
11361 /* When a stmt has been parsed, this function is called. */
11368 /* DECL was originally constructed as a non-static member function,
11369 but turned out to be static. Update it accordingly. */
11372 revert_static_member_fn (tree decl)
11375 tree function = TREE_TYPE (decl);
11376 tree args = TYPE_ARG_TYPES (function);
11378 if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
11379 != TYPE_UNQUALIFIED)
11380 error ("static member function %q#D declared with type qualifiers", decl);
11382 args = TREE_CHAIN (args);
11383 tmp = build_function_type (TREE_TYPE (function), args);
11384 tmp = build_qualified_type (tmp, cp_type_quals (function));
11385 tmp = build_exception_variant (tmp,
11386 TYPE_RAISES_EXCEPTIONS (function));
11387 TREE_TYPE (decl) = tmp;
11388 if (DECL_ARGUMENTS (decl))
11389 DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
11390 DECL_STATIC_FUNCTION_P (decl) = 1;
11393 /* Initialize the variables used during compilation of a C++
11397 cxx_push_function_context (struct function * f)
11399 struct language_function *p = GGC_CNEW (struct language_function);
11402 /* Whenever we start a new function, we destroy temporaries in the
11404 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
11410 if (DECL_SAVED_FUNCTION_DATA (fn))
11412 /* If we already parsed this function, and we're just expanding it
11413 now, restore saved state. */
11414 *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (fn);
11416 /* We don't need the saved data anymore. Unless this is an inline
11417 function; we need the named return value info for
11418 declare_return_variable. */
11419 if (! DECL_INLINE (fn))
11420 DECL_SAVED_FUNCTION_DATA (fn) = NULL;
11425 /* Free the language-specific parts of F, now that we've finished
11426 compiling the function. */
11429 cxx_pop_function_context (struct function * f)
11434 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
11435 one of the language-independent trees. */
11437 enum cp_tree_node_structure_enum
11438 cp_tree_node_structure (union lang_tree_node * t)
11440 switch (TREE_CODE (&t->generic))
11442 case DEFAULT_ARG: return TS_CP_DEFAULT_ARG;
11443 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER;
11444 case OVERLOAD: return TS_CP_OVERLOAD;
11445 case TEMPLATE_PARM_INDEX: return TS_CP_TPI;
11446 case TINST_LEVEL: return TS_CP_TINST_LEVEL;
11447 case PTRMEM_CST: return TS_CP_PTRMEM;
11448 case BASELINK: return TS_CP_BASELINK;
11449 default: return TS_CP_GENERIC;
11453 /* Build the void_list_node (void_type_node having been created). */
11455 build_void_list_node (void)
11457 tree t = build_tree_list (NULL_TREE, void_type_node);
11462 cp_missing_noreturn_ok_p (tree decl)
11464 /* A missing noreturn is ok for the `main' function. */
11465 return DECL_MAIN_P (decl);
11468 /* Return the COMDAT group into which DECL should be placed. */
11471 cxx_comdat_group (tree decl)
11475 /* Virtual tables, construction virtual tables, and virtual table
11476 tables all go in a single COMDAT group, named after the primary
11478 if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
11479 name = DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl)));
11480 /* For all other DECLs, the COMDAT group is the mangled name of the
11481 declaration itself. */
11484 while (DECL_THUNK_P (decl))
11486 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
11487 into the same section as the target function. In that case
11488 we must return target's name. */
11489 tree target = THUNK_TARGET (decl);
11490 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target)
11491 && DECL_SECTION_NAME (target) != NULL
11492 && DECL_ONE_ONLY (target))
11497 name = DECL_ASSEMBLER_NAME (decl);
11500 return IDENTIFIER_POINTER (name);
11503 #include "gt-cp-decl.h"