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;
144 tree tinfo_var_id; */
146 tree cp_global_trees[CPTI_MAX];
148 /* Indicates that there is a type value in some namespace, although
149 that is not necessarily in scope at the moment. */
151 tree global_type_node;
153 /* The node that holds the "name" of the global scope. */
154 tree global_scope_name;
156 #define local_names cp_function_chain->x_local_names
158 /* A list of objects which have constructors or destructors
159 which reside in the global scope. The decl is stored in
160 the TREE_VALUE slot and the initializer is stored
161 in the TREE_PURPOSE slot. */
162 tree static_aggregates;
166 /* A node for the integer constants 2, and 3. */
168 tree integer_two_node, integer_three_node;
170 /* Used only for jumps to as-yet undefined labels, since jumps to
171 defined labels can have their validity checked immediately. */
173 struct named_label_use_entry GTY(())
175 struct named_label_use_entry *next;
176 /* The binding level to which this entry is *currently* attached.
177 This is initially the binding level in which the goto appeared,
178 but is modified as scopes are closed. */
179 struct cp_binding_level *binding_level;
180 /* The head of the names list that was current when the goto appeared,
181 or the inner scope popped. These are the decls that will *not* be
182 skipped when jumping to the label. */
184 /* The location of the goto, for error reporting. */
185 location_t o_goto_locus;
186 /* True if an OpenMP structured block scope has been closed since
187 the goto appeared. This means that the branch from the label will
188 illegally exit an OpenMP scope. */
192 /* A list of all LABEL_DECLs in the function that have names. Here so
193 we can clear out their names' definitions at the end of the
194 function, and so we can check the validity of jumps to these labels. */
196 struct named_label_entry GTY(())
198 /* The decl itself. */
201 /* The binding level to which the label is *currently* attached.
202 This is initially set to the binding level in which the label
203 is defined, but is modified as scopes are closed. */
204 struct cp_binding_level *binding_level;
205 /* The head of the names list that was current when the label was
206 defined, or the inner scope popped. These are the decls that will
207 be skipped when jumping to the label. */
209 /* A tree list of all decls from all binding levels that would be
210 crossed by a backward branch to the label. */
213 /* A list of uses of the label, before the label is defined. */
214 struct named_label_use_entry *uses;
216 /* The following bits are set after the label is defined, and are
217 updated as scopes are popped. They indicate that a backward jump
218 to the label will illegally enter a scope of the given flavor. */
224 #define named_labels cp_function_chain->x_named_labels
226 /* The number of function bodies which we are currently processing.
227 (Zero if we are at namespace scope, one inside the body of a
228 function, two inside the body of a function in a local class, etc.) */
231 /* States indicating how grokdeclarator() should handle declspecs marked
232 with __attribute__((deprecated)). An object declared as
233 __attribute__((deprecated)) suppresses warnings of uses of other
236 enum deprecated_states {
241 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
244 /* A TREE_LIST of VAR_DECLs. The TREE_PURPOSE is a RECORD_TYPE or
245 UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type. At the
246 time the VAR_DECL was declared, the type was incomplete. */
248 static GTY(()) tree incomplete_vars;
250 /* Returns the kind of template specialization we are currently
251 processing, given that it's declaration contained N_CLASS_SCOPES
252 explicit scope qualifications. */
255 current_tmpl_spec_kind (int n_class_scopes)
257 int n_template_parm_scopes = 0;
258 int seen_specialization_p = 0;
259 int innermost_specialization_p = 0;
260 struct cp_binding_level *b;
262 /* Scan through the template parameter scopes. */
263 for (b = current_binding_level;
264 b->kind == sk_template_parms;
267 /* If we see a specialization scope inside a parameter scope,
268 then something is wrong. That corresponds to a declaration
271 template <class T> template <> ...
273 which is always invalid since [temp.expl.spec] forbids the
274 specialization of a class member template if the enclosing
275 class templates are not explicitly specialized as well. */
276 if (b->explicit_spec_p)
278 if (n_template_parm_scopes == 0)
279 innermost_specialization_p = 1;
281 seen_specialization_p = 1;
283 else if (seen_specialization_p == 1)
284 return tsk_invalid_member_spec;
286 ++n_template_parm_scopes;
289 /* Handle explicit instantiations. */
290 if (processing_explicit_instantiation)
292 if (n_template_parm_scopes != 0)
293 /* We've seen a template parameter list during an explicit
294 instantiation. For example:
296 template <class T> template void f(int);
298 This is erroneous. */
299 return tsk_invalid_expl_inst;
301 return tsk_expl_inst;
304 if (n_template_parm_scopes < n_class_scopes)
305 /* We've not seen enough template headers to match all the
306 specialized classes present. For example:
308 template <class T> void R<T>::S<T>::f(int);
310 This is invalid; there needs to be one set of template
311 parameters for each class. */
312 return tsk_insufficient_parms;
313 else if (n_template_parm_scopes == n_class_scopes)
314 /* We're processing a non-template declaration (even though it may
315 be a member of a template class.) For example:
317 template <class T> void S<T>::f(int);
319 The `class T' maches the `S<T>', leaving no template headers
320 corresponding to the `f'. */
322 else if (n_template_parm_scopes > n_class_scopes + 1)
323 /* We've got too many template headers. For example:
325 template <> template <class T> void f (T);
327 There need to be more enclosing classes. */
328 return tsk_excessive_parms;
330 /* This must be a template. It's of the form:
332 template <class T> template <class U> void S<T>::f(U);
334 This is a specialization if the innermost level was a
335 specialization; otherwise it's just a definition of the
337 return innermost_specialization_p ? tsk_expl_spec : tsk_template;
340 /* Exit the current scope. */
348 /* When a label goes out of scope, check to see if that label was used
349 in a valid manner, and issue any appropriate warnings or errors. */
352 pop_label (tree label, tree old_value)
354 if (!processing_template_decl)
356 if (DECL_INITIAL (label) == NULL_TREE)
360 error ("label %q+D used but not defined", label);
361 #ifdef USE_MAPPED_LOCATION
362 location = input_location; /* FIXME want (input_filename, (line)0) */
364 location.file = input_filename;
367 /* Avoid crashing later. */
368 define_label (location, DECL_NAME (label));
370 else if (!TREE_USED (label))
371 warning (OPT_Wunused_label, "label %q+D defined but not used", label);
374 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
377 /* At the end of a function, all labels declared within the function
378 go out of scope. BLOCK is the top-level block for the
382 pop_labels_1 (void **slot, void *data)
384 struct named_label_entry *ent = (struct named_label_entry *) *slot;
385 tree block = (tree) data;
387 pop_label (ent->label_decl, NULL_TREE);
389 /* Put the labels into the "variables" of the top-level block,
390 so debugger can see them. */
391 TREE_CHAIN (ent->label_decl) = BLOCK_VARS (block);
392 BLOCK_VARS (block) = ent->label_decl;
394 htab_clear_slot (named_labels, slot);
400 pop_labels (tree block)
404 htab_traverse (named_labels, pop_labels_1, block);
409 /* At the end of a block with local labels, restore the outer definition. */
412 pop_local_label (tree label, tree old_value)
414 struct named_label_entry dummy;
417 pop_label (label, old_value);
419 dummy.label_decl = label;
420 slot = htab_find_slot (named_labels, &dummy, NO_INSERT);
421 htab_clear_slot (named_labels, slot);
424 /* The following two routines are used to interface to Objective-C++.
425 The binding level is purposely treated as an opaque type. */
428 objc_get_current_scope (void)
430 return current_binding_level;
433 /* The following routine is used by the NeXT-style SJLJ exceptions;
434 variables get marked 'volatile' so as to not be clobbered by
435 _setjmp()/_longjmp() calls. All variables in the current scope,
436 as well as parent scopes up to (but not including) ENCLOSING_BLK
437 shall be thusly marked. */
440 objc_mark_locals_volatile (void *enclosing_blk)
442 struct cp_binding_level *scope;
444 for (scope = current_binding_level;
445 scope && scope != enclosing_blk;
446 scope = scope->level_chain)
450 for (decl = scope->names; decl; decl = TREE_CHAIN (decl))
451 objc_volatilize_decl (decl);
453 /* Do not climb up past the current function. */
454 if (scope->kind == sk_function_parms)
459 /* Update data for defined and undefined labels when leaving a scope. */
462 poplevel_named_label_1 (void **slot, void *data)
464 struct named_label_entry *ent = (struct named_label_entry *) *slot;
465 struct cp_binding_level *bl = (struct cp_binding_level *) data;
466 struct cp_binding_level *obl = bl->level_chain;
468 if (ent->binding_level == bl)
472 for (decl = ent->names_in_scope; decl; decl = TREE_CHAIN (decl))
473 if (decl_jump_unsafe (decl))
474 ent->bad_decls = tree_cons (NULL, decl, ent->bad_decls);
476 ent->binding_level = obl;
477 ent->names_in_scope = obl->names;
481 ent->in_try_scope = true;
484 ent->in_catch_scope = true;
487 ent->in_omp_scope = true;
495 struct named_label_use_entry *use;
497 for (use = ent->uses; use ; use = use->next)
498 if (use->binding_level == bl)
500 use->binding_level = obl;
501 use->names_in_scope = obl->names;
502 if (bl->kind == sk_omp)
503 use->in_omp_scope = true;
510 /* Exit a binding level.
511 Pop the level off, and restore the state of the identifier-decl mappings
512 that were in effect when this level was entered.
514 If KEEP == 1, this level had explicit declarations, so
515 and create a "block" (a BLOCK node) for the level
516 to record its declarations and subblocks for symbol table output.
518 If FUNCTIONBODY is nonzero, this level is the body of a function,
519 so create a block as if KEEP were set and also clear out all
522 If REVERSE is nonzero, reverse the order of decls before putting
523 them into the BLOCK. */
526 poplevel (int keep, int reverse, int functionbody)
529 /* The chain of decls was accumulated in reverse order.
530 Put it into forward order, just for cleanliness. */
532 int tmp = functionbody;
533 int real_functionbody;
537 int leaving_for_scope;
540 timevar_push (TV_NAME_LOOKUP);
545 gcc_assert (current_binding_level->kind != sk_class);
547 real_functionbody = (current_binding_level->kind == sk_cleanup
548 ? ((functionbody = 0), tmp) : functionbody);
549 subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
551 gcc_assert (!VEC_length(cp_class_binding,
552 current_binding_level->class_shadowed));
554 /* We used to use KEEP == 2 to indicate that the new block should go
555 at the beginning of the list of blocks at this binding level,
556 rather than the end. This hack is no longer used. */
557 gcc_assert (keep == 0 || keep == 1);
559 if (current_binding_level->keep)
562 /* Any uses of undefined labels, and any defined labels, now operate
563 under constraints of next binding contour. */
564 if (cfun && !functionbody && named_labels)
565 htab_traverse (named_labels, poplevel_named_label_1,
566 current_binding_level);
568 /* Get the decls in the order they were written.
569 Usually current_binding_level->names is in reverse order.
570 But parameter decls were previously put in forward order. */
573 current_binding_level->names
574 = decls = nreverse (current_binding_level->names);
576 decls = current_binding_level->names;
578 /* If there were any declarations or structure tags in that level,
579 or if this level is a function body,
580 create a BLOCK to record them for the life of this function. */
582 if (keep == 1 || functionbody)
583 block = make_node (BLOCK);
584 if (block != NULL_TREE)
586 BLOCK_VARS (block) = decls;
587 BLOCK_SUBBLOCKS (block) = subblocks;
590 /* In each subblock, record that this is its superior. */
592 for (link = subblocks; link; link = TREE_CHAIN (link))
593 BLOCK_SUPERCONTEXT (link) = block;
595 /* We still support the old for-scope rules, whereby the variables
596 in a for-init statement were in scope after the for-statement
597 ended. We only use the new rules if flag_new_for_scope is
600 = current_binding_level->kind == sk_for && flag_new_for_scope == 1;
602 /* Before we remove the declarations first check for unused variables. */
603 if (warn_unused_variable
604 && !processing_template_decl)
605 for (decl = getdecls (); decl; decl = TREE_CHAIN (decl))
606 if (TREE_CODE (decl) == VAR_DECL
607 && ! TREE_USED (decl)
608 && ! DECL_IN_SYSTEM_HEADER (decl)
609 && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl))
610 warning (OPT_Wunused_variable, "unused variable %q+D", decl);
612 /* Remove declarations for all the DECLs in this level. */
613 for (link = decls; link; link = TREE_CHAIN (link))
615 if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
618 tree name = DECL_NAME (link);
622 ob = outer_binding (name,
623 IDENTIFIER_BINDING (name),
626 ns_binding = IDENTIFIER_NAMESPACE_VALUE (name);
628 ns_binding = NULL_TREE;
630 if (ob && ob->scope == current_binding_level->level_chain)
631 /* We have something like:
636 and we are leaving the `for' scope. There's no reason to
637 keep the binding of the inner `i' in this case. */
638 pop_binding (name, link);
639 else if ((ob && (TREE_CODE (ob->value) == TYPE_DECL))
640 || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL))
641 /* Here, we have something like:
649 We must pop the for-scope binding so we know what's a
650 type and what isn't. */
651 pop_binding (name, link);
654 /* Mark this VAR_DECL as dead so that we can tell we left it
655 there only for backward compatibility. */
656 DECL_DEAD_FOR_LOCAL (link) = 1;
658 /* Keep track of what should have happened when we
659 popped the binding. */
662 SET_DECL_SHADOWED_FOR_VAR (link, ob->value);
663 DECL_HAS_SHADOWED_FOR_VAR_P (link) = 1;
666 /* Add it to the list of dead variables in the next
667 outermost binding to that we can remove these when we
668 leave that binding. */
669 current_binding_level->level_chain->dead_vars_from_for
670 = tree_cons (NULL_TREE, link,
671 current_binding_level->level_chain->
674 /* Although we don't pop the cxx_binding, we do clear
675 its SCOPE since the scope is going away now. */
676 IDENTIFIER_BINDING (name)->scope
677 = current_binding_level->level_chain;
684 /* Remove the binding. */
687 if (TREE_CODE (decl) == TREE_LIST)
688 decl = TREE_VALUE (decl);
691 if (TREE_CODE (name) == OVERLOAD)
692 name = OVL_FUNCTION (name);
694 gcc_assert (DECL_P (name));
695 pop_binding (DECL_NAME (name), decl);
699 /* Remove declarations for any `for' variables from inner scopes
700 that we kept around. */
701 for (link = current_binding_level->dead_vars_from_for;
702 link; link = TREE_CHAIN (link))
703 pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
705 /* Restore the IDENTIFIER_TYPE_VALUEs. */
706 for (link = current_binding_level->type_shadowed;
707 link; link = TREE_CHAIN (link))
708 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
710 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
711 for (link = current_binding_level->shadowed_labels;
713 link = TREE_CHAIN (link))
714 pop_local_label (TREE_VALUE (link), TREE_PURPOSE (link));
716 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
717 list if a `using' declaration put them there. The debugging
718 back-ends won't understand OVERLOAD, so we remove them here.
719 Because the BLOCK_VARS are (temporarily) shared with
720 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
721 popped all the bindings. */
726 for (d = &BLOCK_VARS (block); *d; )
728 if (TREE_CODE (*d) == TREE_LIST)
729 *d = TREE_CHAIN (*d);
731 d = &TREE_CHAIN (*d);
735 /* If the level being exited is the top level of a function,
736 check over all the labels. */
739 /* Since this is the top level block of a function, the vars are
740 the function's parameters. Don't leave them in the BLOCK
741 because they are found in the FUNCTION_DECL instead. */
742 BLOCK_VARS (block) = 0;
746 kind = current_binding_level->kind;
747 if (kind == sk_cleanup)
751 /* If this is a temporary binding created for a cleanup, then we'll
752 have pushed a statement list level. Pop that, create a new
753 BIND_EXPR for the block, and insert it into the stream. */
754 stmt = pop_stmt_list (current_binding_level->statement_list);
755 stmt = c_build_bind_expr (block, stmt);
761 DECL_INITIAL (current_function_decl) = block;
763 current_binding_level->blocks
764 = chainon (current_binding_level->blocks, block);
766 /* If we did not make a block for the level just exited,
767 any blocks made for inner levels
768 (since they cannot be recorded as subblocks in that level)
769 must be carried forward so they will later become subblocks
770 of something else. */
772 current_binding_level->blocks
773 = chainon (current_binding_level->blocks, subblocks);
775 /* Each and every BLOCK node created here in `poplevel' is important
776 (e.g. for proper debugging information) so if we created one
777 earlier, mark it as "used". */
779 TREE_USED (block) = 1;
781 /* All temporary bindings created for cleanups are popped silently. */
782 if (kind == sk_cleanup)
785 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, block);
788 /* Insert BLOCK at the end of the list of subblocks of the
789 current binding level. This is used when a BIND_EXPR is expanded,
790 to handle the BLOCK node inside the BIND_EXPR. */
793 insert_block (tree block)
795 TREE_USED (block) = 1;
796 current_binding_level->blocks
797 = chainon (current_binding_level->blocks, block);
800 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
801 itself, calling F for each. The DATA is passed to F as well. */
804 walk_namespaces_r (tree namespace, walk_namespaces_fn f, void* data)
807 tree current = NAMESPACE_LEVEL (namespace)->namespaces;
809 result |= (*f) (namespace, data);
811 for (; current; current = TREE_CHAIN (current))
812 result |= walk_namespaces_r (current, f, data);
817 /* Walk all the namespaces, calling F for each. The DATA is passed to
821 walk_namespaces (walk_namespaces_fn f, void* data)
823 return walk_namespaces_r (global_namespace, f, data);
826 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
827 DATA is non-NULL, this is the last time we will call
828 wrapup_global_declarations for this NAMESPACE. */
831 wrapup_globals_for_namespace (tree namespace, void* data)
833 struct cp_binding_level *level = NAMESPACE_LEVEL (namespace);
834 VEC(tree,gc) *statics = level->static_decls;
835 tree *vec = VEC_address (tree, statics);
836 int len = VEC_length (tree, statics);
837 int last_time = (data != 0);
841 check_global_declarations (vec, len);
842 emit_debug_global_declarations (vec, len);
846 /* Write out any globals that need to be output. */
847 return wrapup_global_declarations (vec, len);
851 /* In C++, you don't have to write `struct S' to refer to `S'; you
852 can just use `S'. We accomplish this by creating a TYPE_DECL as
853 if the user had written `typedef struct S S'. Create and return
854 the TYPE_DECL for TYPE. */
857 create_implicit_typedef (tree name, tree type)
861 decl = build_decl (TYPE_DECL, name, type);
862 DECL_ARTIFICIAL (decl) = 1;
863 /* There are other implicit type declarations, like the one *within*
864 a class that allows you to write `S::S'. We must distinguish
866 SET_DECL_IMPLICIT_TYPEDEF_P (decl);
867 TYPE_NAME (type) = decl;
872 /* Remember a local name for name-mangling purposes. */
875 push_local_name (tree decl)
880 timevar_push (TV_NAME_LOOKUP);
882 name = DECL_NAME (decl);
884 nelts = VEC_length (tree, local_names);
885 for (i = 0; i < nelts; i++)
887 t = VEC_index (tree, local_names, i);
888 if (DECL_NAME (t) == name)
890 if (!DECL_LANG_SPECIFIC (decl))
891 retrofit_lang_decl (decl);
892 DECL_LANG_SPECIFIC (decl)->decl_flags.u2sel = 1;
893 if (DECL_LANG_SPECIFIC (t))
894 DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
896 DECL_DISCRIMINATOR (decl) = 1;
898 VEC_replace (tree, local_names, i, decl);
899 timevar_pop (TV_NAME_LOOKUP);
904 VEC_safe_push (tree, gc, local_names, decl);
905 timevar_pop (TV_NAME_LOOKUP);
908 /* Subroutine of duplicate_decls: return truthvalue of whether
909 or not types of these decls match.
911 For C++, we must compare the parameter list so that `int' can match
912 `int&' in a parameter position, but `int&' is not confused with
916 decls_match (tree newdecl, tree olddecl)
920 if (newdecl == olddecl)
923 if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
924 /* If the two DECLs are not even the same kind of thing, we're not
925 interested in their types. */
928 if (TREE_CODE (newdecl) == FUNCTION_DECL)
930 tree f1 = TREE_TYPE (newdecl);
931 tree f2 = TREE_TYPE (olddecl);
932 tree p1 = TYPE_ARG_TYPES (f1);
933 tree p2 = TYPE_ARG_TYPES (f2);
935 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
936 && ! (DECL_EXTERN_C_P (newdecl)
937 && DECL_EXTERN_C_P (olddecl)))
940 if (TREE_CODE (f1) != TREE_CODE (f2))
943 if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
945 if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
946 && (DECL_BUILT_IN (olddecl)
947 #ifndef NO_IMPLICIT_EXTERN_C
948 || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
949 || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
953 types_match = self_promoting_args_p (p1);
954 if (p1 == void_list_node)
955 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
957 #ifndef NO_IMPLICIT_EXTERN_C
958 else if (p1 == NULL_TREE
959 && (DECL_EXTERN_C_P (olddecl)
960 && DECL_IN_SYSTEM_HEADER (olddecl)
961 && !DECL_CLASS_SCOPE_P (olddecl))
962 && (DECL_EXTERN_C_P (newdecl)
963 && DECL_IN_SYSTEM_HEADER (newdecl)
964 && !DECL_CLASS_SCOPE_P (newdecl)))
966 types_match = self_promoting_args_p (p2);
967 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
971 types_match = compparms (p1, p2);
976 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
978 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
979 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
982 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
983 DECL_TEMPLATE_PARMS (olddecl)))
986 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
987 types_match = same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)),
988 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl)));
990 types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
991 DECL_TEMPLATE_RESULT (newdecl));
995 /* Need to check scope for variable declaration (VAR_DECL).
996 For typedef (TYPE_DECL), scope is ignored. */
997 if (TREE_CODE (newdecl) == VAR_DECL
998 && CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
1000 Two declarations for an object with C language linkage
1001 with the same name (ignoring the namespace that qualify
1002 it) that appear in different namespace scopes refer to
1004 && !(DECL_EXTERN_C_P (olddecl) && DECL_EXTERN_C_P (newdecl)))
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);
1374 return error_mark_node;
1381 error ("conflicting declaration %q#D", newdecl);
1382 error ("%q+D has a previous declaration as %q#D", olddecl, olddecl);
1383 return error_mark_node;
1386 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1387 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
1388 && (!DECL_TEMPLATE_INFO (newdecl)
1389 || (DECL_TI_TEMPLATE (newdecl)
1390 != DECL_TI_TEMPLATE (olddecl))))
1391 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
1392 && (!DECL_TEMPLATE_INFO (olddecl)
1393 || (DECL_TI_TEMPLATE (olddecl)
1394 != DECL_TI_TEMPLATE (newdecl))))))
1395 /* It's OK to have a template specialization and a non-template
1396 with the same type, or to have specializations of two
1397 different templates with the same type. Note that if one is a
1398 specialization, and the other is an instantiation of the same
1399 template, that we do not exit at this point. That situation
1400 can occur if we instantiate a template class, and then
1401 specialize one of its methods. This situation is valid, but
1402 the declarations must be merged in the usual way. */
1404 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1405 && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
1406 && !DECL_USE_TEMPLATE (newdecl))
1407 || (DECL_TEMPLATE_INSTANTIATION (newdecl)
1408 && !DECL_USE_TEMPLATE (olddecl))))
1409 /* One of the declarations is a template instantiation, and the
1410 other is not a template at all. That's OK. */
1412 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1414 /* In [namespace.alias] we have:
1416 In a declarative region, a namespace-alias-definition can be
1417 used to redefine a namespace-alias declared in that declarative
1418 region to refer only to the namespace to which it already
1421 Therefore, if we encounter a second alias directive for the same
1422 alias, we can just ignore the second directive. */
1423 if (DECL_NAMESPACE_ALIAS (newdecl)
1424 && (DECL_NAMESPACE_ALIAS (newdecl)
1425 == DECL_NAMESPACE_ALIAS (olddecl)))
1427 /* [namespace.alias]
1429 A namespace-name or namespace-alias shall not be declared as
1430 the name of any other entity in the same declarative region.
1431 A namespace-name defined at global scope shall not be
1432 declared as the name of any other entity in any global scope
1434 error ("declaration of namespace %qD conflicts with", newdecl);
1435 error ("previous declaration of namespace %q+D here", olddecl);
1436 return error_mark_node;
1440 const char *errmsg = redeclaration_error_message (newdecl, olddecl);
1443 error (errmsg, newdecl);
1444 if (DECL_NAME (olddecl) != NULL_TREE)
1445 error ((DECL_INITIAL (olddecl) && namespace_bindings_p ())
1446 ? "%q+#D previously defined here"
1447 : "%q+#D previously declared here", olddecl);
1448 return error_mark_node;
1450 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1451 && DECL_INITIAL (olddecl) != NULL_TREE
1452 && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
1453 && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
1455 /* Prototype decl follows defn w/o prototype. */
1456 warning (0, "prototype for %q+#D", newdecl);
1457 warning (0, "%Jfollows non-prototype definition here", olddecl);
1459 else if ((TREE_CODE (olddecl) == FUNCTION_DECL
1460 || TREE_CODE (olddecl) == VAR_DECL)
1461 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
1464 If two declarations of the same function or object
1465 specify different linkage-specifications ..., the program
1466 is ill-formed.... Except for functions with C++ linkage,
1467 a function declaration without a linkage specification
1468 shall not precede the first linkage specification for
1469 that function. A function can be declared without a
1470 linkage specification after an explicit linkage
1471 specification has been seen; the linkage explicitly
1472 specified in the earlier declaration is not affected by
1473 such a function declaration.
1475 DR 563 raises the question why the restrictions on
1476 functions should not also apply to objects. Older
1477 versions of G++ silently ignore the linkage-specification
1485 which is clearly wrong. Therefore, we now treat objects
1487 if (current_lang_depth () == 0)
1489 /* There is no explicit linkage-specification, so we use
1490 the linkage from the previous declaration. */
1491 if (!DECL_LANG_SPECIFIC (newdecl))
1492 retrofit_lang_decl (newdecl);
1493 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1497 error ("previous declaration of %q+#D with %qL linkage",
1498 olddecl, DECL_LANGUAGE (olddecl));
1499 error ("conflicts with new declaration with %qL linkage",
1500 DECL_LANGUAGE (newdecl));
1504 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
1506 else if (TREE_CODE (olddecl) == FUNCTION_DECL)
1508 tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1509 tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1512 if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
1513 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
1515 for (; t1 && t1 != void_list_node;
1516 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
1517 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
1519 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
1522 pedwarn ("default argument given for parameter %d of %q#D",
1524 pedwarn ("after previous specification in %q+#D", olddecl);
1528 error ("default argument given for parameter %d of %q#D",
1530 error ("after previous specification in %q+#D",
1535 if (DECL_DECLARED_INLINE_P (newdecl)
1536 && ! DECL_DECLARED_INLINE_P (olddecl)
1537 && TREE_ADDRESSABLE (olddecl) && warn_inline)
1539 warning (0, "%q#D was used before it was declared inline", newdecl);
1540 warning (0, "%Jprevious non-inline declaration here", olddecl);
1545 /* Do not merge an implicit typedef with an explicit one. In:
1549 typedef class A A __attribute__ ((foo));
1551 the attribute should apply only to the typedef. */
1552 if (TREE_CODE (olddecl) == TYPE_DECL
1553 && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
1554 || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
1557 /* If new decl is `static' and an `extern' was seen previously,
1559 warn_extern_redeclared_static (newdecl, olddecl);
1561 /* We have committed to returning 1 at this point. */
1562 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1564 /* Now that functions must hold information normally held
1565 by field decls, there is extra work to do so that
1566 declaration information does not get destroyed during
1568 if (DECL_VINDEX (olddecl))
1569 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
1570 if (DECL_CONTEXT (olddecl))
1571 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1572 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
1573 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1574 DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
1575 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
1576 DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
1577 if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
1578 SET_OVERLOADED_OPERATOR_CODE
1579 (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
1580 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
1582 /* Optionally warn about more than one declaration for the same
1583 name, but don't warn about a function declaration followed by a
1585 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
1586 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
1587 /* Don't warn about extern decl followed by definition. */
1588 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
1589 /* Don't warn about friends, let add_friend take care of it. */
1590 && ! (newdecl_is_friend || DECL_FRIEND_P (olddecl)))
1592 warning (OPT_Wredundant_decls, "redundant redeclaration of %qD in same scope", newdecl);
1593 warning (OPT_Wredundant_decls, "previous declaration of %q+D", olddecl);
1597 /* Deal with C++: must preserve virtual function table size. */
1598 if (TREE_CODE (olddecl) == TYPE_DECL)
1600 tree newtype = TREE_TYPE (newdecl);
1601 tree oldtype = TREE_TYPE (olddecl);
1603 if (newtype != error_mark_node && oldtype != error_mark_node
1604 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
1605 CLASSTYPE_FRIEND_CLASSES (newtype)
1606 = CLASSTYPE_FRIEND_CLASSES (oldtype);
1608 DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
1611 /* Copy all the DECL_... slots specified in the new decl
1612 except for any that we copy here from the old type. */
1613 DECL_ATTRIBUTES (newdecl)
1614 = (*targetm.merge_decl_attributes) (olddecl, newdecl);
1616 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1620 old_result = DECL_TEMPLATE_RESULT (olddecl);
1621 new_result = DECL_TEMPLATE_RESULT (newdecl);
1622 TREE_TYPE (olddecl) = TREE_TYPE (old_result);
1623 DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
1624 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
1625 DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
1627 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1629 DECL_INLINE (old_result)
1630 |= DECL_INLINE (new_result);
1631 DECL_DECLARED_INLINE_P (old_result)
1632 |= DECL_DECLARED_INLINE_P (new_result);
1633 check_redeclaration_exception_specification (newdecl, olddecl);
1636 /* If the new declaration is a definition, update the file and
1637 line information on the declaration. */
1638 if (DECL_INITIAL (old_result) == NULL_TREE
1639 && DECL_INITIAL (new_result) != NULL_TREE)
1641 DECL_SOURCE_LOCATION (olddecl)
1642 = DECL_SOURCE_LOCATION (old_result)
1643 = DECL_SOURCE_LOCATION (newdecl);
1644 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1645 DECL_ARGUMENTS (old_result)
1646 = DECL_ARGUMENTS (new_result);
1654 /* Automatically handles default parameters. */
1655 tree oldtype = TREE_TYPE (olddecl);
1658 /* Merge the data types specified in the two decls. */
1659 newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1661 /* If merge_types produces a non-typedef type, just use the old type. */
1662 if (TREE_CODE (newdecl) == TYPE_DECL
1663 && newtype == DECL_ORIGINAL_TYPE (newdecl))
1666 if (TREE_CODE (newdecl) == VAR_DECL)
1668 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
1669 DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
1670 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl)
1671 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl);
1672 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl)
1673 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl);
1675 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
1676 if (DECL_LANG_SPECIFIC (olddecl)
1677 && CP_DECL_THREADPRIVATE_P (olddecl))
1679 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
1680 if (!DECL_LANG_SPECIFIC (newdecl))
1681 retrofit_lang_decl (newdecl);
1683 DECL_TLS_MODEL (newdecl) = DECL_TLS_MODEL (olddecl);
1684 CP_DECL_THREADPRIVATE_P (newdecl) = 1;
1688 /* Do this after calling `merge_types' so that default
1689 parameters don't confuse us. */
1690 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1691 check_redeclaration_exception_specification (newdecl, olddecl);
1692 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
1694 /* Lay the type out, unless already done. */
1695 if (! same_type_p (newtype, oldtype)
1696 && TREE_TYPE (newdecl) != error_mark_node
1697 && !(processing_template_decl && uses_template_parms (newdecl)))
1698 layout_type (TREE_TYPE (newdecl));
1700 if ((TREE_CODE (newdecl) == VAR_DECL
1701 || TREE_CODE (newdecl) == PARM_DECL
1702 || TREE_CODE (newdecl) == RESULT_DECL
1703 || TREE_CODE (newdecl) == FIELD_DECL
1704 || TREE_CODE (newdecl) == TYPE_DECL)
1705 && !(processing_template_decl && uses_template_parms (newdecl)))
1706 layout_decl (newdecl, 0);
1708 /* Merge the type qualifiers. */
1709 if (TREE_READONLY (newdecl))
1710 TREE_READONLY (olddecl) = 1;
1711 if (TREE_THIS_VOLATILE (newdecl))
1712 TREE_THIS_VOLATILE (olddecl) = 1;
1713 if (TREE_NOTHROW (newdecl))
1714 TREE_NOTHROW (olddecl) = 1;
1716 /* Merge deprecatedness. */
1717 if (TREE_DEPRECATED (newdecl))
1718 TREE_DEPRECATED (olddecl) = 1;
1720 /* Merge the initialization information. */
1721 if (DECL_INITIAL (newdecl) == NULL_TREE
1722 && DECL_INITIAL (olddecl) != NULL_TREE)
1724 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1725 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
1726 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
1727 && DECL_LANG_SPECIFIC (newdecl)
1728 && DECL_LANG_SPECIFIC (olddecl))
1730 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1731 DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
1735 /* Merge the section attribute.
1736 We want to issue an error if the sections conflict but that must be
1737 done later in decl_attributes since we are called before attributes
1739 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1740 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1742 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1744 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1745 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1746 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1747 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1748 TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
1749 TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl);
1750 DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
1751 DECL_IS_PURE (newdecl) |= DECL_IS_PURE (olddecl);
1752 /* Keep the old RTL. */
1753 COPY_DECL_RTL (olddecl, newdecl);
1755 else if (TREE_CODE (newdecl) == VAR_DECL
1756 && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
1758 /* Keep the old RTL. We cannot keep the old RTL if the old
1759 declaration was for an incomplete object and the new
1760 declaration is not since many attributes of the RTL will
1762 COPY_DECL_RTL (olddecl, newdecl);
1765 /* If cannot merge, then use the new type and qualifiers,
1766 and don't preserve the old rtl. */
1769 /* Clean out any memory we had of the old declaration. */
1770 tree oldstatic = value_member (olddecl, static_aggregates);
1772 TREE_VALUE (oldstatic) = error_mark_node;
1774 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1775 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1776 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1777 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1780 /* Merge the storage class information. */
1781 merge_weak (newdecl, olddecl);
1783 DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
1784 DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
1785 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1786 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
1787 if (! DECL_EXTERNAL (olddecl))
1788 DECL_EXTERNAL (newdecl) = 0;
1790 new_template = NULL_TREE;
1791 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
1793 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
1794 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
1795 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
1796 DECL_TEMPLATE_INSTANTIATED (newdecl)
1797 |= DECL_TEMPLATE_INSTANTIATED (olddecl);
1799 /* If the OLDDECL is an instantiation and/or specialization,
1800 then the NEWDECL must be too. But, it may not yet be marked
1801 as such if the caller has created NEWDECL, but has not yet
1802 figured out that it is a redeclaration. */
1803 if (!DECL_USE_TEMPLATE (newdecl))
1804 DECL_USE_TEMPLATE (newdecl) = DECL_USE_TEMPLATE (olddecl);
1806 /* Don't really know how much of the language-specific
1807 values we should copy from old to new. */
1808 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
1809 DECL_LANG_SPECIFIC (newdecl)->decl_flags.u2 =
1810 DECL_LANG_SPECIFIC (olddecl)->decl_flags.u2;
1811 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
1812 DECL_REPO_AVAILABLE_P (newdecl) = DECL_REPO_AVAILABLE_P (olddecl);
1813 if (DECL_TEMPLATE_INFO (newdecl))
1814 new_template = DECL_TI_TEMPLATE (newdecl);
1815 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
1816 DECL_INITIALIZED_IN_CLASS_P (newdecl)
1817 |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
1818 olddecl_friend = DECL_FRIEND_P (olddecl);
1819 hidden_friend = (DECL_ANTICIPATED (olddecl)
1820 && DECL_HIDDEN_FRIEND_P (olddecl)
1821 && newdecl_is_friend);
1823 /* Only functions have DECL_BEFRIENDING_CLASSES. */
1824 if (TREE_CODE (newdecl) == FUNCTION_DECL
1825 || DECL_FUNCTION_TEMPLATE_P (newdecl))
1827 DECL_BEFRIENDING_CLASSES (newdecl)
1828 = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
1829 DECL_BEFRIENDING_CLASSES (olddecl));
1830 /* DECL_THUNKS is only valid for virtual functions,
1831 otherwise it is a DECL_FRIEND_CONTEXT. */
1832 if (DECL_VIRTUAL_P (newdecl))
1833 DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl);
1837 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1839 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
1840 && !DECL_TEMPLATE_INSTANTIATION (newdecl))
1842 /* If newdecl is not a specialization, then it is not a
1843 template-related function at all. And that means that we
1844 should have exited above, returning 0. */
1845 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl));
1847 if (TREE_USED (olddecl))
1848 /* From [temp.expl.spec]:
1850 If a template, a member template or the member of a class
1851 template is explicitly specialized then that
1852 specialization shall be declared before the first use of
1853 that specialization that would cause an implicit
1854 instantiation to take place, in every translation unit in
1855 which such a use occurs. */
1856 error ("explicit specialization of %qD after first use",
1859 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
1861 /* Don't propagate visibility from the template to the
1862 specialization here. We'll do that in determine_visibility if
1864 DECL_VISIBILITY_SPECIFIED (olddecl) = 0;
1866 /* [temp.expl.spec/14] We don't inline explicit specialization
1867 just because the primary template says so. */
1871 if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
1872 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
1874 DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
1876 /* If either decl says `inline', this fn is inline, unless
1877 its definition was passed already. */
1878 if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
1879 DECL_INLINE (olddecl) = 1;
1880 DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
1882 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
1883 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
1886 /* Preserve abstractness on cloned [cd]tors. */
1887 DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
1891 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1892 COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
1893 COPY_DECL_RTL (newdecl, olddecl);
1895 if (! types_match || new_defines_function)
1897 /* These need to be copied so that the names are available.
1898 Note that if the types do match, we'll preserve inline
1899 info and other bits, but if not, we won't. */
1900 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
1901 DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
1903 if (new_defines_function)
1904 /* If defining a function declared with other language
1905 linkage, use the previously declared language linkage. */
1906 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1907 else if (types_match)
1909 /* If redeclaring a builtin function, and not a definition,
1910 it stays built in. */
1911 if (DECL_BUILT_IN (olddecl))
1913 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
1914 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
1915 /* If we're keeping the built-in definition, keep the rtl,
1916 regardless of declaration matches. */
1917 COPY_DECL_RTL (olddecl, newdecl);
1920 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
1921 /* Don't clear out the arguments if we're redefining a function. */
1922 if (DECL_ARGUMENTS (olddecl))
1923 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
1926 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1927 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
1929 /* Now preserve various other info from the definition. */
1930 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
1931 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
1932 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
1933 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
1935 /* Warn about conflicting visibility specifications. */
1936 if (DECL_VISIBILITY_SPECIFIED (olddecl)
1937 && DECL_VISIBILITY_SPECIFIED (newdecl)
1938 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
1940 warning (OPT_Wattributes, "%q+D: visibility attribute ignored "
1941 "because it", newdecl);
1942 warning (OPT_Wattributes, "%Jconflicts with previous "
1943 "declaration here", olddecl);
1945 /* Choose the declaration which specified visibility. */
1946 if (DECL_VISIBILITY_SPECIFIED (olddecl))
1948 DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
1949 DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
1951 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
1952 so keep this behavior. */
1953 if (TREE_CODE (newdecl) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (newdecl))
1955 SET_DECL_INIT_PRIORITY (olddecl, DECL_INIT_PRIORITY (newdecl));
1956 DECL_HAS_INIT_PRIORITY_P (olddecl) = 1;
1959 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
1960 with that from NEWDECL below. */
1961 if (DECL_LANG_SPECIFIC (olddecl))
1963 gcc_assert (DECL_LANG_SPECIFIC (olddecl)
1964 != DECL_LANG_SPECIFIC (newdecl));
1965 ggc_free (DECL_LANG_SPECIFIC (olddecl));
1968 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1972 function_size = sizeof (struct tree_decl_common);
1974 memcpy ((char *) olddecl + sizeof (struct tree_common),
1975 (char *) newdecl + sizeof (struct tree_common),
1976 function_size - sizeof (struct tree_common));
1978 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
1979 (char *) newdecl + sizeof (struct tree_decl_common),
1980 sizeof (struct tree_function_decl) - sizeof (struct tree_decl_common));
1982 /* If newdecl is a template instantiation, it is possible that
1983 the following sequence of events has occurred:
1985 o A friend function was declared in a class template. The
1986 class template was instantiated.
1988 o The instantiation of the friend declaration was
1989 recorded on the instantiation list, and is newdecl.
1991 o Later, however, instantiate_class_template called pushdecl
1992 on the newdecl to perform name injection. But, pushdecl in
1993 turn called duplicate_decls when it discovered that another
1994 declaration of a global function with the same name already
1997 o Here, in duplicate_decls, we decided to clobber newdecl.
1999 If we're going to do that, we'd better make sure that
2000 olddecl, and not newdecl, is on the list of
2001 instantiations so that if we try to do the instantiation
2002 again we won't get the clobbered declaration. */
2003 reregister_specialization (newdecl,
2009 size_t size = tree_code_size (TREE_CODE (olddecl));
2010 memcpy ((char *) olddecl + sizeof (struct tree_common),
2011 (char *) newdecl + sizeof (struct tree_common),
2012 sizeof (struct tree_decl_common) - sizeof (struct tree_common));
2013 switch (TREE_CODE (olddecl))
2023 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2024 (char *) newdecl + sizeof (struct tree_decl_common),
2025 size - sizeof (struct tree_decl_common)
2026 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2030 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2031 (char *) newdecl + sizeof (struct tree_decl_common),
2032 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common)
2033 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2037 DECL_UID (olddecl) = olddecl_uid;
2039 DECL_FRIEND_P (olddecl) = 1;
2042 DECL_ANTICIPATED (olddecl) = 1;
2043 DECL_HIDDEN_FRIEND_P (olddecl) = 1;
2046 /* NEWDECL contains the merged attribute lists.
2047 Update OLDDECL to be the same. */
2048 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
2050 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2051 so that encode_section_info has a chance to look at the new decl
2052 flags and attributes. */
2053 if (DECL_RTL_SET_P (olddecl)
2054 && (TREE_CODE (olddecl) == FUNCTION_DECL
2055 || (TREE_CODE (olddecl) == VAR_DECL
2056 && TREE_STATIC (olddecl))))
2057 make_decl_rtl (olddecl);
2059 /* The NEWDECL will no longer be needed. Because every out-of-class
2060 declaration of a member results in a call to duplicate_decls,
2061 freeing these nodes represents in a significant savings. */
2067 /* Return zero if the declaration NEWDECL is valid
2068 when the declaration OLDDECL (assumed to be for the same name)
2069 has already been seen.
2070 Otherwise return an error message format string with a %s
2071 where the identifier should go. */
2074 redeclaration_error_message (tree newdecl, tree olddecl)
2076 if (TREE_CODE (newdecl) == TYPE_DECL)
2078 /* Because C++ can put things into name space for free,
2079 constructs like "typedef struct foo { ... } foo"
2080 would look like an erroneous redeclaration. */
2081 if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
2084 return "redefinition of %q#D";
2086 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
2088 /* If this is a pure function, its olddecl will actually be
2089 the original initialization to `0' (which we force to call
2090 abort()). Don't complain about redefinition in this case. */
2091 if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl)
2092 && DECL_INITIAL (olddecl) == NULL_TREE)
2095 /* If both functions come from different namespaces, this is not
2096 a redeclaration - this is a conflict with a used function. */
2097 if (DECL_NAMESPACE_SCOPE_P (olddecl)
2098 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl)
2099 && ! decls_match (olddecl, newdecl))
2100 return "%qD conflicts with used function";
2102 /* We'll complain about linkage mismatches in
2103 warn_extern_redeclared_static. */
2105 /* Defining the same name twice is no good. */
2106 if (DECL_INITIAL (olddecl) != NULL_TREE
2107 && DECL_INITIAL (newdecl) != NULL_TREE)
2109 if (DECL_NAME (olddecl) == NULL_TREE)
2110 return "%q#D not declared in class";
2112 return "redefinition of %q#D";
2116 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2120 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2122 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl))
2123 && COMPLETE_TYPE_P (TREE_TYPE (olddecl)))
2124 return "redefinition of %q#D";
2128 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL
2129 || (DECL_TEMPLATE_RESULT (newdecl)
2130 == DECL_TEMPLATE_RESULT (olddecl)))
2133 nt = DECL_TEMPLATE_RESULT (newdecl);
2134 if (DECL_TEMPLATE_INFO (nt))
2135 nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt));
2136 ot = DECL_TEMPLATE_RESULT (olddecl);
2137 if (DECL_TEMPLATE_INFO (ot))
2138 ot = DECL_TEMPLATE_RESULT (template_for_substitution (ot));
2139 if (DECL_INITIAL (nt) && DECL_INITIAL (ot))
2140 return "redefinition of %q#D";
2144 else if (TREE_CODE (newdecl) == VAR_DECL
2145 && DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl)
2146 && (! DECL_LANG_SPECIFIC (olddecl)
2147 || ! CP_DECL_THREADPRIVATE_P (olddecl)
2148 || DECL_THREAD_LOCAL_P (newdecl)))
2150 /* Only variables can be thread-local, and all declarations must
2151 agree on this property. */
2152 if (DECL_THREAD_LOCAL_P (newdecl))
2153 return "thread-local declaration of %q#D follows "
2154 "non-thread-local declaration";
2156 return "non-thread-local declaration of %q#D follows "
2157 "thread-local declaration";
2159 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
2161 /* Objects declared at top level: */
2162 /* If at least one is a reference, it's ok. */
2163 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2165 /* Reject two definitions. */
2166 return "redefinition of %q#D";
2170 /* Objects declared with block scope: */
2171 /* Reject two definitions, and reject a definition
2172 together with an external reference. */
2173 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
2174 return "redeclaration of %q#D";
2179 /* Hash and equality functions for the named_label table. */
2182 named_label_entry_hash (const void *data)
2184 const struct named_label_entry *ent = (const struct named_label_entry *) data;
2185 return DECL_UID (ent->label_decl);
2189 named_label_entry_eq (const void *a, const void *b)
2191 const struct named_label_entry *ent_a = (const struct named_label_entry *) a;
2192 const struct named_label_entry *ent_b = (const struct named_label_entry *) b;
2193 return ent_a->label_decl == ent_b->label_decl;
2196 /* Create a new label, named ID. */
2199 make_label_decl (tree id, int local_p)
2201 struct named_label_entry *ent;
2205 decl = build_decl (LABEL_DECL, id, void_type_node);
2207 DECL_CONTEXT (decl) = current_function_decl;
2208 DECL_MODE (decl) = VOIDmode;
2209 C_DECLARED_LABEL_FLAG (decl) = local_p;
2211 /* Say where one reference is to the label, for the sake of the
2212 error if it is not defined. */
2213 DECL_SOURCE_LOCATION (decl) = input_location;
2215 /* Record the fact that this identifier is bound to this label. */
2216 SET_IDENTIFIER_LABEL_VALUE (id, decl);
2218 /* Create the label htab for the function on demand. */
2220 named_labels = htab_create_ggc (13, named_label_entry_hash,
2221 named_label_entry_eq, NULL);
2223 /* Record this label on the list of labels used in this function.
2224 We do this before calling make_label_decl so that we get the
2225 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2226 ent = GGC_CNEW (struct named_label_entry);
2227 ent->label_decl = decl;
2229 slot = htab_find_slot (named_labels, ent, INSERT);
2230 gcc_assert (*slot == NULL);
2236 /* Look for a label named ID in the current function. If one cannot
2237 be found, create one. (We keep track of used, but undefined,
2238 labels, and complain about them at the end of a function.) */
2241 lookup_label (tree id)
2245 timevar_push (TV_NAME_LOOKUP);
2246 /* You can't use labels at global scope. */
2247 if (current_function_decl == NULL_TREE)
2249 error ("label %qE referenced outside of any function", id);
2250 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2253 /* See if we've already got this label. */
2254 decl = IDENTIFIER_LABEL_VALUE (id);
2255 if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
2256 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2258 decl = make_label_decl (id, /*local_p=*/0);
2259 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2262 /* Declare a local label named ID. */
2265 declare_local_label (tree id)
2269 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2270 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2271 shadow = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
2272 current_binding_level->shadowed_labels);
2273 current_binding_level->shadowed_labels = shadow;
2275 decl = make_label_decl (id, /*local_p=*/1);
2276 TREE_VALUE (shadow) = decl;
2281 /* Returns nonzero if it is ill-formed to jump past the declaration of
2282 DECL. Returns 2 if it's also a real problem. */
2285 decl_jump_unsafe (tree decl)
2287 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl)
2288 || TREE_TYPE (decl) == error_mark_node)
2291 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
2292 || DECL_NONTRIVIALLY_INITIALIZED_P (decl))
2295 if (pod_type_p (TREE_TYPE (decl)))
2298 /* The POD stuff is just pedantry; why should it matter if the class
2299 contains a field of pointer to member type? */
2303 /* A subroutine of check_previous_goto_1 to identify a branch to the user. */
2306 identify_goto (tree decl, const location_t *locus)
2309 pedwarn ("jump to label %qD", decl);
2311 pedwarn ("jump to case label");
2313 pedwarn ("%H from here", locus);
2316 /* Check that a single previously seen jump to a newly defined label
2317 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2318 the jump context; NAMES are the names in scope in LEVEL at the jump
2319 context; LOCUS is the source position of the jump or 0. Returns
2320 true if all is well. */
2323 check_previous_goto_1 (tree decl, struct cp_binding_level* level, tree names,
2324 bool exited_omp, const location_t *locus)
2326 struct cp_binding_level *b;
2327 bool identified = false, saw_eh = false, saw_omp = false;
2331 identify_goto (decl, locus);
2332 error (" exits OpenMP structured block");
2333 identified = saw_omp = true;
2336 for (b = current_binding_level; b ; b = b->level_chain)
2338 tree new_decls, old_decls = (b == level ? names : NULL_TREE);
2340 for (new_decls = b->names; new_decls != old_decls;
2341 new_decls = TREE_CHAIN (new_decls))
2343 int problem = decl_jump_unsafe (new_decls);
2349 identify_goto (decl, locus);
2353 error (" crosses initialization of %q+#D", new_decls);
2355 pedwarn (" enters scope of non-POD %q+#D", new_decls);
2360 if ((b->kind == sk_try || b->kind == sk_catch) && !saw_eh)
2364 identify_goto (decl, locus);
2367 if (b->kind == sk_try)
2368 error (" enters try block");
2370 error (" enters catch block");
2373 if (b->kind == sk_omp && !saw_omp)
2377 identify_goto (decl, locus);
2380 error (" enters OpenMP structured block");
2389 check_previous_goto (tree decl, struct named_label_use_entry *use)
2391 check_previous_goto_1 (decl, use->binding_level,
2392 use->names_in_scope, use->in_omp_scope,
2393 &use->o_goto_locus);
2397 check_switch_goto (struct cp_binding_level* level)
2399 return check_previous_goto_1 (NULL_TREE, level, level->names, false, NULL);
2402 /* Check that a new jump to a label DECL is OK. Called by
2403 finish_goto_stmt. */
2406 check_goto (tree decl)
2408 struct named_label_entry *ent, dummy;
2409 bool saw_catch = false, identified = false;
2412 /* We can't know where a computed goto is jumping.
2413 So we assume that it's OK. */
2414 if (TREE_CODE (decl) != LABEL_DECL)
2417 /* We didn't record any information about this label when we created it,
2418 and there's not much point since it's trivial to analyze as a return. */
2419 if (decl == cdtor_label)
2422 dummy.label_decl = decl;
2423 ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2424 gcc_assert (ent != NULL);
2426 /* If the label hasn't been defined yet, defer checking. */
2427 if (! DECL_INITIAL (decl))
2429 struct named_label_use_entry *new_use;
2431 /* Don't bother creating another use if the last goto had the
2432 same data, and will therefore create the same set of errors. */
2434 && ent->uses->names_in_scope == current_binding_level->names)
2437 new_use = GGC_NEW (struct named_label_use_entry);
2438 new_use->binding_level = current_binding_level;
2439 new_use->names_in_scope = current_binding_level->names;
2440 new_use->o_goto_locus = input_location;
2441 new_use->in_omp_scope = false;
2443 new_use->next = ent->uses;
2444 ent->uses = new_use;
2448 if (ent->in_try_scope || ent->in_catch_scope
2449 || ent->in_omp_scope || ent->bad_decls)
2451 pedwarn ("jump to label %q+D", decl);
2452 pedwarn (" from here");
2456 for (bad = ent->bad_decls; bad; bad = TREE_CHAIN (bad))
2458 tree b = TREE_VALUE (bad);
2459 int u = decl_jump_unsafe (b);
2461 if (u > 1 && DECL_ARTIFICIAL (b))
2463 /* Can't skip init of __exception_info. */
2464 error ("%J enters catch block", b);
2468 error (" skips initialization of %q+#D", b);
2470 pedwarn (" enters scope of non-POD %q+#D", b);
2473 if (ent->in_try_scope)
2474 error (" enters try block");
2475 else if (ent->in_catch_scope && !saw_catch)
2476 error (" enters catch block");
2478 if (ent->in_omp_scope)
2479 error (" enters OpenMP structured block");
2480 else if (flag_openmp)
2482 struct cp_binding_level *b;
2483 for (b = current_binding_level; b ; b = b->level_chain)
2485 if (b == ent->binding_level)
2487 if (b->kind == sk_omp)
2491 pedwarn ("jump to label %q+D", decl);
2492 pedwarn (" from here");
2495 error (" exits OpenMP structured block");
2502 /* Check that a return is ok wrt OpenMP structured blocks.
2503 Called by finish_return_stmt. Returns true if all is well. */
2506 check_omp_return (void)
2508 struct cp_binding_level *b;
2509 for (b = current_binding_level; b ; b = b->level_chain)
2510 if (b->kind == sk_omp)
2512 error ("invalid exit from OpenMP structured block");
2518 /* Define a label, specifying the location in the source file.
2519 Return the LABEL_DECL node for the label. */
2522 define_label (location_t location, tree name)
2524 struct named_label_entry *ent, dummy;
2525 struct cp_binding_level *p;
2528 timevar_push (TV_NAME_LOOKUP);
2530 decl = lookup_label (name);
2532 dummy.label_decl = decl;
2533 ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2534 gcc_assert (ent != NULL);
2536 /* After labels, make any new cleanups in the function go into their
2537 own new (temporary) binding contour. */
2538 for (p = current_binding_level;
2539 p->kind != sk_function_parms;
2541 p->more_cleanups_ok = 0;
2543 if (name == get_identifier ("wchar_t"))
2544 pedwarn ("label named wchar_t");
2546 if (DECL_INITIAL (decl) != NULL_TREE)
2548 error ("duplicate label %qD", decl);
2549 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
2553 struct named_label_use_entry *use;
2555 /* Mark label as having been defined. */
2556 DECL_INITIAL (decl) = error_mark_node;
2557 /* Say where in the source. */
2558 DECL_SOURCE_LOCATION (decl) = location;
2560 ent->binding_level = current_binding_level;
2561 ent->names_in_scope = current_binding_level->names;
2563 for (use = ent->uses; use ; use = use->next)
2564 check_previous_goto (decl, use);
2568 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2573 struct cp_binding_level *level;
2574 struct cp_switch *next;
2575 /* The SWITCH_STMT being built. */
2577 /* A splay-tree mapping the low element of a case range to the high
2578 element, or NULL_TREE if there is no high element. Used to
2579 determine whether or not a new case label duplicates an old case
2580 label. We need a tree, rather than simply a hash table, because
2581 of the GNU case range extension. */
2585 /* A stack of the currently active switch statements. The innermost
2586 switch statement is on the top of the stack. There is no need to
2587 mark the stack for garbage collection because it is only active
2588 during the processing of the body of a function, and we never
2589 collect at that point. */
2591 static struct cp_switch *switch_stack;
2593 /* Called right after a switch-statement condition is parsed.
2594 SWITCH_STMT is the switch statement being parsed. */
2597 push_switch (tree switch_stmt)
2599 struct cp_switch *p = XNEW (struct cp_switch);
2600 p->level = current_binding_level;
2601 p->next = switch_stack;
2602 p->switch_stmt = switch_stmt;
2603 p->cases = splay_tree_new (case_compare, NULL, NULL);
2610 struct cp_switch *cs = switch_stack;
2611 location_t switch_location;
2613 /* Emit warnings as needed. */
2614 if (EXPR_HAS_LOCATION (cs->switch_stmt))
2615 switch_location = EXPR_LOCATION (cs->switch_stmt);
2617 switch_location = input_location;
2618 if (!processing_template_decl)
2619 c_do_switch_warnings (cs->cases, switch_location,
2620 SWITCH_STMT_TYPE (cs->switch_stmt),
2621 SWITCH_STMT_COND (cs->switch_stmt));
2623 splay_tree_delete (cs->cases);
2624 switch_stack = switch_stack->next;
2628 /* Note that we've seen a definition of a case label, and complain if this
2629 is a bad place for one. */
2632 finish_case_label (tree low_value, tree high_value)
2635 struct cp_binding_level *p;
2637 if (processing_template_decl)
2641 /* For templates, just add the case label; we'll do semantic
2642 analysis at instantiation-time. */
2643 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
2644 return add_stmt (build_case_label (low_value, high_value, label));
2647 /* Find the condition on which this switch statement depends. */
2648 cond = SWITCH_STMT_COND (switch_stack->switch_stmt);
2649 if (cond && TREE_CODE (cond) == TREE_LIST)
2650 cond = TREE_VALUE (cond);
2652 if (!check_switch_goto (switch_stack->level))
2653 return error_mark_node;
2655 r = c_add_case_label (switch_stack->cases, cond, TREE_TYPE (cond),
2656 low_value, high_value);
2658 /* After labels, make any new cleanups in the function go into their
2659 own new (temporary) binding contour. */
2660 for (p = current_binding_level;
2661 p->kind != sk_function_parms;
2663 p->more_cleanups_ok = 0;
2668 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
2671 typename_hash (const void* k)
2676 hash = (htab_hash_pointer (TYPE_CONTEXT (t))
2677 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));
2682 typedef struct typename_info {
2690 /* Compare two TYPENAME_TYPEs. K1 and K2 are really of type `tree'. */
2693 typename_compare (const void * k1, const void * k2)
2696 const typename_info *t2;
2699 t2 = (const typename_info *) k2;
2701 return (DECL_NAME (TYPE_NAME (t1)) == t2->name
2702 && TYPE_CONTEXT (t1) == t2->scope
2703 && TYPENAME_TYPE_FULLNAME (t1) == t2->template_id
2704 && TYPENAME_IS_ENUM_P (t1) == t2->enum_p
2705 && TYPENAME_IS_CLASS_P (t1) == t2->class_p);
2708 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
2709 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
2711 Returns the new TYPENAME_TYPE. */
2713 static GTY ((param_is (union tree_node))) htab_t typename_htab;
2716 build_typename_type (tree context, tree name, tree fullname,
2717 enum tag_types tag_type)
2725 if (typename_htab == NULL)
2726 typename_htab = htab_create_ggc (61, &typename_hash,
2727 &typename_compare, NULL);
2729 ti.scope = FROB_CONTEXT (context);
2731 ti.template_id = fullname;
2732 ti.enum_p = tag_type == enum_type;
2733 ti.class_p = (tag_type == class_type
2734 || tag_type == record_type
2735 || tag_type == union_type);
2736 hash = (htab_hash_pointer (ti.scope)
2737 ^ htab_hash_pointer (ti.name));
2739 /* See if we already have this type. */
2740 e = htab_find_slot_with_hash (typename_htab, &ti, hash, INSERT);
2745 /* Build the TYPENAME_TYPE. */
2746 t = make_aggr_type (TYPENAME_TYPE);
2747 TYPE_CONTEXT (t) = ti.scope;
2748 TYPENAME_TYPE_FULLNAME (t) = ti.template_id;
2749 TYPENAME_IS_ENUM_P (t) = ti.enum_p;
2750 TYPENAME_IS_CLASS_P (t) = ti.class_p;
2752 /* Build the corresponding TYPE_DECL. */
2753 d = build_decl (TYPE_DECL, name, t);
2754 TYPE_NAME (TREE_TYPE (d)) = d;
2755 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2756 DECL_CONTEXT (d) = FROB_CONTEXT (context);
2757 DECL_ARTIFICIAL (d) = 1;
2759 /* Store it in the hash table. */
2766 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
2767 provided to name the type. Returns an appropriate type, unless an
2768 error occurs, in which case error_mark_node is returned. If we
2769 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
2770 return that, rather than the _TYPE it corresponds to, in other
2771 cases we look through the type decl. If TF_ERROR is set, complain
2772 about errors, otherwise be quiet. */
2775 make_typename_type (tree context, tree name, enum tag_types tag_type,
2776 tsubst_flags_t complain)
2780 if (name == error_mark_node
2781 || context == NULL_TREE
2782 || context == error_mark_node)
2783 return error_mark_node;
2787 if (!(TYPE_LANG_SPECIFIC (name)
2788 && (CLASSTYPE_IS_TEMPLATE (name)
2789 || CLASSTYPE_USE_TEMPLATE (name))))
2790 name = TYPE_IDENTIFIER (name);
2792 /* Create a TEMPLATE_ID_EXPR for the type. */
2793 name = build_nt (TEMPLATE_ID_EXPR,
2794 CLASSTYPE_TI_TEMPLATE (name),
2795 CLASSTYPE_TI_ARGS (name));
2797 else if (TREE_CODE (name) == TYPE_DECL)
2798 name = DECL_NAME (name);
2802 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
2804 name = TREE_OPERAND (name, 0);
2805 if (TREE_CODE (name) == TEMPLATE_DECL)
2806 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
2808 if (TREE_CODE (name) == TEMPLATE_DECL)
2810 error ("%qD used without template parameters", name);
2811 return error_mark_node;
2813 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
2814 gcc_assert (TYPE_P (context));
2816 if (!dependent_type_p (context)
2817 || currently_open_class (context))
2819 if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
2821 tree tmpl = NULL_TREE;
2822 if (IS_AGGR_TYPE (context))
2823 tmpl = lookup_field (context, name, 0, false);
2824 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
2826 if (complain & tf_error)
2827 error ("no class template named %q#T in %q#T",
2829 return error_mark_node;
2832 if (complain & tf_error)
2833 perform_or_defer_access_check (TYPE_BINFO (context), tmpl);
2835 return lookup_template_class (tmpl,
2836 TREE_OPERAND (fullname, 1),
2838 /*entering_scope=*/0,
2839 tf_warning_or_error | tf_user);
2845 if (!IS_AGGR_TYPE (context))
2847 if (complain & tf_error)
2848 error ("no type named %q#T in %q#T", name, context);
2849 return error_mark_node;
2852 t = lookup_field (context, name, 0, true);
2855 if (TREE_CODE (t) != TYPE_DECL)
2857 if (complain & tf_error)
2858 error ("no type named %q#T in %q#T", name, context);
2859 return error_mark_node;
2862 if (complain & tf_error)
2863 perform_or_defer_access_check (TYPE_BINFO (context), t);
2865 if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
2873 /* If the CONTEXT is not a template type, then either the field is
2874 there now or its never going to be. */
2875 if (!dependent_type_p (context))
2877 if (complain & tf_error)
2878 error ("no type named %q#T in %q#T", name, context);
2879 return error_mark_node;
2882 return build_typename_type (context, name, fullname, tag_type);
2885 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
2886 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
2887 in which case error_mark_node is returned.
2889 If PARM_LIST is non-NULL, also make sure that the template parameter
2890 list of TEMPLATE_DECL matches.
2892 If COMPLAIN zero, don't complain about any errors that occur. */
2895 make_unbound_class_template (tree context, tree name, tree parm_list,
2896 tsubst_flags_t complain)
2902 name = TYPE_IDENTIFIER (name);
2903 else if (DECL_P (name))
2904 name = DECL_NAME (name);
2905 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
2907 if (!dependent_type_p (context)
2908 || currently_open_class (context))
2910 tree tmpl = NULL_TREE;
2912 if (IS_AGGR_TYPE (context))
2913 tmpl = lookup_field (context, name, 0, false);
2915 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
2917 if (complain & tf_error)
2918 error ("no class template named %q#T in %q#T", name, context);
2919 return error_mark_node;
2923 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl), parm_list))
2925 if (complain & tf_error)
2927 error ("template parameters do not match template");
2928 error ("%q+D declared here", tmpl);
2930 return error_mark_node;
2933 if (complain & tf_error)
2934 perform_or_defer_access_check (TYPE_BINFO (context), tmpl);
2939 /* Build the UNBOUND_CLASS_TEMPLATE. */
2940 t = make_aggr_type (UNBOUND_CLASS_TEMPLATE);
2941 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
2942 TREE_TYPE (t) = NULL_TREE;
2944 /* Build the corresponding TEMPLATE_DECL. */
2945 d = build_decl (TEMPLATE_DECL, name, t);
2946 TYPE_NAME (TREE_TYPE (d)) = d;
2947 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2948 DECL_CONTEXT (d) = FROB_CONTEXT (context);
2949 DECL_ARTIFICIAL (d) = 1;
2950 DECL_TEMPLATE_PARMS (d) = parm_list;
2957 /* Push the declarations of builtin types into the namespace.
2958 RID_INDEX is the index of the builtin type in the array
2959 RID_POINTERS. NAME is the name used when looking up the builtin
2960 type. TYPE is the _TYPE node for the builtin type. */
2963 record_builtin_type (enum rid rid_index,
2967 tree rname = NULL_TREE, tname = NULL_TREE;
2968 tree tdecl = NULL_TREE;
2970 if ((int) rid_index < (int) RID_MAX)
2971 rname = ridpointers[(int) rid_index];
2973 tname = get_identifier (name);
2975 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
2976 eliminated. Built-in types should not be looked up name; their
2977 names are keywords that the parser can recognize. However, there
2978 is code in c-common.c that uses identifier_global_value to look
2979 up built-in types by name. */
2982 tdecl = build_decl (TYPE_DECL, tname, type);
2983 DECL_ARTIFICIAL (tdecl) = 1;
2984 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
2990 tdecl = build_decl (TYPE_DECL, rname, type);
2991 DECL_ARTIFICIAL (tdecl) = 1;
2993 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
2996 if (!TYPE_NAME (type))
2997 TYPE_NAME (type) = tdecl;
3000 debug_hooks->type_decl (tdecl, 0);
3003 /* Record one of the standard Java types.
3004 * Declare it as having the given NAME.
3005 * If SIZE > 0, it is the size of one of the integral types;
3006 * otherwise it is the negative of the size of one of the other types. */
3009 record_builtin_java_type (const char* name, int size)
3013 type = make_signed_type (size);
3014 else if (size > -32)
3015 { /* "__java_char" or ""__java_boolean". */
3016 type = make_unsigned_type (-size);
3017 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
3020 { /* "__java_float" or ""__java_double". */
3021 type = make_node (REAL_TYPE);
3022 TYPE_PRECISION (type) = - size;
3025 record_builtin_type (RID_MAX, name, type);
3026 decl = TYPE_NAME (type);
3028 /* Suppress generate debug symbol entries for these types,
3029 since for normal C++ they are just clutter.
3030 However, push_lang_context undoes this if extern "Java" is seen. */
3031 DECL_IGNORED_P (decl) = 1;
3033 TYPE_FOR_JAVA (type) = 1;
3037 /* Push a type into the namespace so that the back-ends ignore it. */
3040 record_unknown_type (tree type, const char* name)
3042 tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
3043 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3044 DECL_IGNORED_P (decl) = 1;
3045 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
3046 TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
3047 TYPE_ALIGN (type) = 1;
3048 TYPE_USER_ALIGN (type) = 0;
3049 TYPE_MODE (type) = TYPE_MODE (void_type_node);
3052 /* A string for which we should create an IDENTIFIER_NODE at
3055 typedef struct predefined_identifier
3057 /* The name of the identifier. */
3058 const char *const name;
3059 /* The place where the IDENTIFIER_NODE should be stored. */
3061 /* Nonzero if this is the name of a constructor or destructor. */
3062 const int ctor_or_dtor_p;
3063 } predefined_identifier;
3065 /* Create all the predefined identifiers. */
3068 initialize_predefined_identifiers (void)
3070 const predefined_identifier *pid;
3072 /* A table of identifiers to create at startup. */
3073 static const predefined_identifier predefined_identifiers[] = {
3074 { "C++", &lang_name_cplusplus, 0 },
3075 { "C", &lang_name_c, 0 },
3076 { "Java", &lang_name_java, 0 },
3077 /* Some of these names have a trailing space so that it is
3078 impossible for them to conflict with names written by users. */
3079 { "__ct ", &ctor_identifier, 1 },
3080 { "__base_ctor ", &base_ctor_identifier, 1 },
3081 { "__comp_ctor ", &complete_ctor_identifier, 1 },
3082 { "__dt ", &dtor_identifier, 1 },
3083 { "__comp_dtor ", &complete_dtor_identifier, 1 },
3084 { "__base_dtor ", &base_dtor_identifier, 1 },
3085 { "__deleting_dtor ", &deleting_dtor_identifier, 1 },
3086 { IN_CHARGE_NAME, &in_charge_identifier, 0 },
3087 { "nelts", &nelts_identifier, 0 },
3088 { THIS_NAME, &this_identifier, 0 },
3089 { VTABLE_DELTA_NAME, &delta_identifier, 0 },
3090 { VTABLE_PFN_NAME, &pfn_identifier, 0 },
3091 { "_vptr", &vptr_identifier, 0 },
3092 { "__vtt_parm", &vtt_parm_identifier, 0 },
3093 { "::", &global_scope_name, 0 },
3094 { "std", &std_identifier, 0 },
3098 for (pid = predefined_identifiers; pid->name; ++pid)
3100 *pid->node = get_identifier (pid->name);
3101 if (pid->ctor_or_dtor_p)
3102 IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
3106 /* Create the predefined scalar types of C,
3107 and some nodes representing standard constants (0, 1, (void *)0).
3108 Initialize the global binding level.
3109 Make definitions for built-in primitive functions. */
3112 cxx_init_decl_processing (void)
3115 tree void_ftype_ptr;
3117 build_common_tree_nodes (flag_signed_char, false);
3119 /* Create all the identifiers we need. */
3120 initialize_predefined_identifiers ();
3122 /* Create the global variables. */
3123 push_to_top_level ();
3125 current_function_decl = NULL_TREE;
3126 current_binding_level = NULL;
3127 /* Enter the global namespace. */
3128 gcc_assert (global_namespace == NULL_TREE);
3129 global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name,
3131 TREE_PUBLIC (global_namespace) = 1;
3132 begin_scope (sk_namespace, global_namespace);
3134 current_lang_name = NULL_TREE;
3136 /* Adjust various flags based on command-line settings. */
3137 if (!flag_permissive)
3138 flag_pedantic_errors = 1;
3139 if (!flag_no_inline)
3141 flag_inline_trees = 1;
3144 if (flag_inline_functions)
3145 flag_inline_trees = 2;
3147 /* Force minimum function alignment if using the least significant
3148 bit of function pointers to store the virtual bit. */
3149 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
3150 && force_align_functions_log < 1)
3151 force_align_functions_log = 1;
3154 current_lang_name = lang_name_c;
3156 /* Create the `std' namespace. */
3157 push_namespace (std_identifier);
3158 std_node = current_namespace;
3161 c_common_nodes_and_builtins ();
3163 java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
3164 java_short_type_node = record_builtin_java_type ("__java_short", 16);
3165 java_int_type_node = record_builtin_java_type ("__java_int", 32);
3166 java_long_type_node = record_builtin_java_type ("__java_long", 64);
3167 java_float_type_node = record_builtin_java_type ("__java_float", -32);
3168 java_double_type_node = record_builtin_java_type ("__java_double", -64);
3169 java_char_type_node = record_builtin_java_type ("__java_char", -16);
3170 java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
3172 integer_two_node = build_int_cst (NULL_TREE, 2);
3173 integer_three_node = build_int_cst (NULL_TREE, 3);
3175 record_builtin_type (RID_BOOL, "bool", boolean_type_node);
3176 truthvalue_type_node = boolean_type_node;
3177 truthvalue_false_node = boolean_false_node;
3178 truthvalue_true_node = boolean_true_node;
3180 empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
3183 record_builtin_type (RID_MAX, NULL, string_type_node);
3186 delta_type_node = ptrdiff_type_node;
3187 vtable_index_type = ptrdiff_type_node;
3189 vtt_parm_type = build_pointer_type (const_ptr_type_node);
3190 void_ftype = build_function_type (void_type_node, void_list_node);
3191 void_ftype_ptr = build_function_type (void_type_node,
3192 tree_cons (NULL_TREE,
3196 = build_exception_variant (void_ftype_ptr, empty_except_spec);
3198 /* C++ extensions */
3200 unknown_type_node = make_node (UNKNOWN_TYPE);
3201 record_unknown_type (unknown_type_node, "unknown type");
3203 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3204 TREE_TYPE (unknown_type_node) = unknown_type_node;
3206 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3208 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
3209 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
3212 /* Make sure we get a unique function type, so we can give
3213 its pointer type a name. (This wins for gdb.) */
3214 tree vfunc_type = make_node (FUNCTION_TYPE);
3215 TREE_TYPE (vfunc_type) = integer_type_node;
3216 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
3217 layout_type (vfunc_type);
3219 vtable_entry_type = build_pointer_type (vfunc_type);
3221 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
3224 = build_cplus_array_type (vtable_entry_type, NULL_TREE);
3225 layout_type (vtbl_type_node);
3226 vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
3227 record_builtin_type (RID_MAX, NULL, vtbl_type_node);
3228 vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
3229 layout_type (vtbl_ptr_type_node);
3230 record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
3232 push_namespace (get_identifier ("__cxxabiv1"));
3233 abi_node = current_namespace;
3236 global_type_node = make_node (LANG_TYPE);
3237 record_unknown_type (global_type_node, "global type");
3240 current_lang_name = lang_name_cplusplus;
3244 tree bad_alloc_type_node;
3245 tree bad_alloc_decl;
3246 tree newtype, deltype;
3247 tree ptr_ftype_sizetype;
3249 push_namespace (std_identifier);
3250 bad_alloc_id = get_identifier ("bad_alloc");
3251 bad_alloc_type_node = make_aggr_type (RECORD_TYPE);
3252 TYPE_CONTEXT (bad_alloc_type_node) = current_namespace;
3254 = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node);
3255 DECL_CONTEXT (bad_alloc_decl) = current_namespace;
3256 TYPE_STUB_DECL (bad_alloc_type_node) = bad_alloc_decl;
3260 = build_function_type (ptr_type_node,
3261 tree_cons (NULL_TREE,
3264 newtype = build_exception_variant
3265 (ptr_ftype_sizetype, add_exception_specifier
3266 (NULL_TREE, bad_alloc_type_node, -1));
3267 deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
3268 push_cp_library_fn (NEW_EXPR, newtype);
3269 push_cp_library_fn (VEC_NEW_EXPR, newtype);
3270 global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
3271 push_cp_library_fn (VEC_DELETE_EXPR, deltype);
3275 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
3277 /* Perform other language dependent initializations. */
3278 init_class_processing ();
3279 init_rtti_processing ();
3281 if (flag_exceptions)
3282 init_exception_processing ();
3284 if (! supports_one_only ())
3287 make_fname_decl = cp_make_fname_decl;
3288 start_fname_decls ();
3290 /* Show we use EH for cleanups. */
3291 if (flag_exceptions)
3292 using_eh_for_cleanups ();
3295 /* Generate an initializer for a function naming variable from
3296 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3297 filled in with the type of the init. */
3300 cp_fname_init (const char* name, tree *type_p)
3302 tree domain = NULL_TREE;
3304 tree init = NULL_TREE;
3309 length = strlen (name);
3310 domain = build_index_type (size_int (length));
3311 init = build_string (length + 1, name);
3314 type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
3315 type = build_cplus_array_type (type, domain);
3320 TREE_TYPE (init) = type;
3322 init = error_mark_node;
3327 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
3328 decl, NAME is the initialization string and TYPE_DEP indicates whether
3329 NAME depended on the type of the function. We make use of that to detect
3330 __PRETTY_FUNCTION__ inside a template fn. This is being done
3331 lazily at the point of first use, so we mustn't push the decl now. */
3334 cp_make_fname_decl (tree id, int type_dep)
3336 const char *const name = (type_dep && processing_template_decl
3337 ? NULL : fname_as_string (type_dep));
3339 tree init = cp_fname_init (name, &type);
3340 tree decl = build_decl (VAR_DECL, id, type);
3343 free ((char *) name);
3345 /* As we're using pushdecl_with_scope, we must set the context. */
3346 DECL_CONTEXT (decl) = current_function_decl;
3347 DECL_PRETTY_FUNCTION_P (decl) = type_dep;
3349 TREE_STATIC (decl) = 1;
3350 TREE_READONLY (decl) = 1;
3351 DECL_ARTIFICIAL (decl) = 1;
3353 TREE_USED (decl) = 1;
3355 if (current_function_decl)
3357 struct cp_binding_level *b = current_binding_level;
3358 while (b->level_chain->kind != sk_function_parms)
3360 pushdecl_with_scope (decl, b, /*is_friend=*/false);
3361 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE,
3362 LOOKUP_ONLYCONVERTING);
3365 pushdecl_top_level_and_finish (decl, init);
3370 /* Make a definition for a builtin function named NAME in the current
3371 namespace, whose data type is TYPE and whose context is CONTEXT.
3372 TYPE should be a function type with argument types.
3374 CLASS and CODE tell later passes how to compile calls to this function.
3375 See tree.h for possible values.
3377 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3378 the name to be called if we can't opencode the function.
3379 If ATTRS is nonzero, use that for the function's attribute
3383 builtin_function_1 (const char* name,
3386 enum built_in_function code,
3387 enum built_in_class class,
3388 const char* libname,
3391 tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
3392 DECL_BUILT_IN_CLASS (decl) = class;
3393 DECL_FUNCTION_CODE (decl) = code;
3394 DECL_CONTEXT (decl) = context;
3398 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
3399 we cannot change DECL_ASSEMBLER_NAME until we have installed this
3400 function in the namespace. */
3402 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
3404 /* A function in the user's namespace should have an explicit
3405 declaration before it is used. Mark the built-in function as
3406 anticipated but not actually declared. */
3407 if (name[0] != '_' || name[1] != '_')
3408 DECL_ANTICIPATED (decl) = 1;
3410 /* Possibly apply some default attributes to this built-in function. */
3412 decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
3414 decl_attributes (&decl, NULL_TREE, 0);
3419 /* Entry point for the benefit of c_common_nodes_and_builtins.
3421 Make a definition for a builtin function named NAME and whose data type
3422 is TYPE. TYPE should be a function type with argument types. This
3423 function places the anticipated declaration in the global namespace
3424 and additionally in the std namespace if appropriate.
3426 CLASS and CODE tell later passes how to compile calls to this function.
3427 See tree.h for possible values.
3429 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3430 the name to be called if we can't opencode the function.
3432 If ATTRS is nonzero, use that for the function's attribute
3436 builtin_function (const char* name,
3439 enum built_in_class cl,
3440 const char* libname,
3443 /* All builtins that don't begin with an '_' should additionally
3444 go in the 'std' namespace. */
3447 push_namespace (std_identifier);
3448 builtin_function_1 (name, type, std_node, code, cl, libname, attrs);
3452 return builtin_function_1 (name, type, NULL_TREE, code,
3453 cl, libname, attrs);
3456 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
3457 function. Not called directly. */
3460 build_library_fn_1 (tree name, enum tree_code operator_code, tree type)
3462 tree fn = build_lang_decl (FUNCTION_DECL, name, type);
3463 DECL_EXTERNAL (fn) = 1;
3464 TREE_PUBLIC (fn) = 1;
3465 DECL_ARTIFICIAL (fn) = 1;
3466 SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
3467 SET_DECL_LANGUAGE (fn, lang_c);
3468 /* Runtime library routines are, by definition, available in an
3469 external shared object. */
3470 DECL_VISIBILITY (fn) = VISIBILITY_DEFAULT;
3471 DECL_VISIBILITY_SPECIFIED (fn) = 1;
3475 /* Returns the _DECL for a library function with C linkage.
3476 We assume that such functions never throw; if this is incorrect,
3477 callers should unset TREE_NOTHROW. */
3480 build_library_fn (tree name, tree type)
3482 tree fn = build_library_fn_1 (name, ERROR_MARK, type);
3483 TREE_NOTHROW (fn) = 1;
3487 /* Returns the _DECL for a library function with C++ linkage. */
3490 build_cp_library_fn (tree name, enum tree_code operator_code, tree type)
3492 tree fn = build_library_fn_1 (name, operator_code, type);
3493 TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
3494 DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
3495 SET_DECL_LANGUAGE (fn, lang_cplusplus);
3499 /* Like build_library_fn, but takes a C string instead of an
3503 build_library_fn_ptr (const char* name, tree type)
3505 return build_library_fn (get_identifier (name), type);
3508 /* Like build_cp_library_fn, but takes a C string instead of an
3512 build_cp_library_fn_ptr (const char* name, tree type)
3514 return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
3517 /* Like build_library_fn, but also pushes the function so that we will
3518 be able to find it via IDENTIFIER_GLOBAL_VALUE. */
3521 push_library_fn (tree name, tree type)
3523 tree fn = build_library_fn (name, type);
3524 pushdecl_top_level (fn);
3528 /* Like build_cp_library_fn, but also pushes the function so that it
3529 will be found by normal lookup. */
3532 push_cp_library_fn (enum tree_code operator_code, tree type)
3534 tree fn = build_cp_library_fn (ansi_opname (operator_code),
3541 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
3545 push_void_library_fn (tree name, tree parmtypes)
3547 tree type = build_function_type (void_type_node, parmtypes);
3548 return push_library_fn (name, type);
3551 /* Like push_library_fn, but also note that this function throws
3552 and does not return. Used for __throw_foo and the like. */
3555 push_throw_library_fn (tree name, tree type)
3557 tree fn = push_library_fn (name, type);
3558 TREE_THIS_VOLATILE (fn) = 1;
3559 TREE_NOTHROW (fn) = 0;
3563 /* When we call finish_struct for an anonymous union, we create
3564 default copy constructors and such. But, an anonymous union
3565 shouldn't have such things; this function undoes the damage to the
3566 anonymous union type T.
3568 (The reason that we create the synthesized methods is that we don't
3569 distinguish `union { int i; }' from `typedef union { int i; } U'.
3570 The first is an anonymous union; the second is just an ordinary
3574 fixup_anonymous_aggr (tree t)
3578 /* Wipe out memory of synthesized methods. */
3579 TYPE_HAS_CONSTRUCTOR (t) = 0;
3580 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
3581 TYPE_HAS_INIT_REF (t) = 0;
3582 TYPE_HAS_CONST_INIT_REF (t) = 0;
3583 TYPE_HAS_ASSIGN_REF (t) = 0;
3584 TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
3586 /* Splice the implicitly generated functions out of the TYPE_METHODS
3588 q = &TYPE_METHODS (t);
3591 if (DECL_ARTIFICIAL (*q))
3592 *q = TREE_CHAIN (*q);
3594 q = &TREE_CHAIN (*q);
3597 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
3598 if (TYPE_METHODS (t))
3599 error ("%Jan anonymous union cannot have function members",
3600 TYPE_MAIN_DECL (t));
3602 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
3603 assignment operators (because they cannot have these methods themselves).
3604 For anonymous unions this is already checked because they are not allowed
3605 in any union, otherwise we have to check it. */
3606 if (TREE_CODE (t) != UNION_TYPE)
3610 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
3611 if (TREE_CODE (field) == FIELD_DECL)
3613 type = TREE_TYPE (field);
3614 if (CLASS_TYPE_P (type))
3616 if (TYPE_NEEDS_CONSTRUCTING (type))
3617 error ("member %q+#D with constructor not allowed "
3618 "in anonymous aggregate", field);
3619 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
3620 error ("member %q+#D with destructor not allowed "
3621 "in anonymous aggregate", field);
3622 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
3623 error ("member %q+#D with copy assignment operator "
3624 "not allowed in anonymous aggregate", field);
3630 /* Make sure that a declaration with no declarator is well-formed, i.e.
3631 just declares a tagged type or anonymous union.
3633 Returns the type declared; or NULL_TREE if none. */
3636 check_tag_decl (cp_decl_specifier_seq *declspecs)
3638 int saw_friend = declspecs->specs[(int)ds_friend] != 0;
3639 int saw_typedef = declspecs->specs[(int)ds_typedef] != 0;
3640 /* If a class, struct, or enum type is declared by the DECLSPECS
3641 (i.e, if a class-specifier, enum-specifier, or non-typename
3642 elaborated-type-specifier appears in the DECLSPECS),
3643 DECLARED_TYPE is set to the corresponding type. */
3644 tree declared_type = NULL_TREE;
3645 bool error_p = false;
3647 if (declspecs->multiple_types_p)
3648 error ("multiple types in one declaration");
3649 else if (declspecs->redefined_builtin_type)
3651 if (!in_system_header)
3652 pedwarn ("redeclaration of C++ built-in type %qT",
3653 declspecs->redefined_builtin_type);
3658 && TYPE_P (declspecs->type)
3659 && ((TREE_CODE (declspecs->type) != TYPENAME_TYPE
3660 && IS_AGGR_TYPE (declspecs->type))
3661 || TREE_CODE (declspecs->type) == ENUMERAL_TYPE))
3662 declared_type = declspecs->type;
3663 else if (declspecs->type == error_mark_node)
3665 if (declared_type == NULL_TREE && ! saw_friend && !error_p)
3666 pedwarn ("declaration does not declare anything");
3667 /* Check for an anonymous union. */
3668 else if (declared_type && IS_AGGR_TYPE_CODE (TREE_CODE (declared_type))
3669 && TYPE_ANONYMOUS_P (declared_type))
3671 /* 7/3 In a simple-declaration, the optional init-declarator-list
3672 can be omitted only when declaring a class (clause 9) or
3673 enumeration (7.2), that is, when the decl-specifier-seq contains
3674 either a class-specifier, an elaborated-type-specifier with
3675 a class-key (9.1), or an enum-specifier. In these cases and
3676 whenever a class-specifier or enum-specifier is present in the
3677 decl-specifier-seq, the identifiers in these specifiers are among
3678 the names being declared by the declaration (as class-name,
3679 enum-names, or enumerators, depending on the syntax). In such
3680 cases, and except for the declaration of an unnamed bit-field (9.6),
3681 the decl-specifier-seq shall introduce one or more names into the
3682 program, or shall redeclare a name introduced by a previous
3683 declaration. [Example:
3684 enum { }; // ill-formed
3685 typedef class { }; // ill-formed
3689 error ("missing type-name in typedef-declaration");
3692 /* Anonymous unions are objects, so they can have specifiers. */;
3693 SET_ANON_AGGR_TYPE_P (declared_type);
3695 if (TREE_CODE (declared_type) != UNION_TYPE && pedantic
3696 && !in_system_header)
3697 pedwarn ("ISO C++ prohibits anonymous structs");
3702 if (declspecs->specs[(int)ds_inline]
3703 || declspecs->specs[(int)ds_virtual])
3704 error ("%qs can only be specified for functions",
3705 declspecs->specs[(int)ds_inline]
3706 ? "inline" : "virtual");
3708 && (!current_class_type
3709 || current_scope () != current_class_type))
3710 error ("%<friend%> can only be specified inside a class");
3711 else if (declspecs->specs[(int)ds_explicit])
3712 error ("%<explicit%> can only be specified for constructors");
3713 else if (declspecs->storage_class)
3714 error ("a storage class can only be specified for objects "
3716 else if (declspecs->specs[(int)ds_const]
3717 || declspecs->specs[(int)ds_volatile]
3718 || declspecs->specs[(int)ds_restrict]
3719 || declspecs->specs[(int)ds_thread])
3720 error ("qualifiers can only be specified for objects "
3724 return declared_type;
3727 /* Called when a declaration is seen that contains no names to declare.
3728 If its type is a reference to a structure, union or enum inherited
3729 from a containing scope, shadow that tag name for the current scope
3730 with a forward reference.
3731 If its type defines a new named structure or union
3732 or defines an enum, it is valid but we need not do anything here.
3733 Otherwise, it is an error.
3735 C++: may have to grok the declspecs to learn about static,
3736 complain for anonymous unions.
3738 Returns the TYPE declared -- or NULL_TREE if none. */
3741 shadow_tag (cp_decl_specifier_seq *declspecs)
3743 tree t = check_tag_decl (declspecs);
3748 if (declspecs->attributes)
3750 warning (0, "attribute ignored in declaration of %q+#T", t);
3751 warning (0, "attribute for %q+#T must follow the %qs keyword",
3752 t, class_key_or_enum_as_string (t));
3756 maybe_process_partial_specialization (t);
3758 /* This is where the variables in an anonymous union are
3759 declared. An anonymous union declaration looks like:
3761 because there is no declarator after the union, the parser
3762 sends that declaration here. */
3763 if (ANON_AGGR_TYPE_P (t))
3765 fixup_anonymous_aggr (t);
3767 if (TYPE_FIELDS (t))
3769 tree decl = grokdeclarator (/*declarator=*/NULL,
3770 declspecs, NORMAL, 0, NULL);
3771 finish_anon_union (decl);
3778 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
3781 groktypename (cp_decl_specifier_seq *type_specifiers,
3782 const cp_declarator *declarator)
3786 attrs = type_specifiers->attributes;
3787 type_specifiers->attributes = NULL_TREE;
3788 type = grokdeclarator (declarator, type_specifiers, TYPENAME, 0, &attrs);
3790 cplus_decl_attributes (&type, attrs, 0);
3794 /* Decode a declarator in an ordinary declaration or data definition.
3795 This is called as soon as the type information and variable name
3796 have been parsed, before parsing the initializer if any.
3797 Here we create the ..._DECL node, fill in its type,
3798 and put it on the list of decls for the current context.
3799 The ..._DECL node is returned as the value.
3801 Exception: for arrays where the length is not specified,
3802 the type is left null, to be filled in by `cp_finish_decl'.
3804 Function definitions do not come here; they go to start_function
3805 instead. However, external and forward declarations of functions
3806 do go through here. Structure field declarations are done by
3807 grokfield and not through here. */
3810 start_decl (const cp_declarator *declarator,
3811 cp_decl_specifier_seq *declspecs,
3814 tree prefix_attributes,
3815 tree *pushed_scope_p)
3821 *pushed_scope_p = NULL_TREE;
3823 /* An object declared as __attribute__((deprecated)) suppresses
3824 warnings of uses of other deprecated items. */
3825 if (lookup_attribute ("deprecated", attributes))
3826 deprecated_state = DEPRECATED_SUPPRESS;
3828 attributes = chainon (attributes, prefix_attributes);
3830 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
3833 deprecated_state = DEPRECATED_NORMAL;
3835 if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE
3836 || decl == error_mark_node)
3837 return error_mark_node;
3839 type = TREE_TYPE (decl);
3841 context = DECL_CONTEXT (decl);
3845 *pushed_scope_p = push_scope (context);
3847 /* We are only interested in class contexts, later. */
3848 if (TREE_CODE (context) == NAMESPACE_DECL)
3849 context = NULL_TREE;
3853 /* Is it valid for this decl to have an initializer at all?
3854 If not, set INITIALIZED to zero, which will indirectly
3855 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
3856 switch (TREE_CODE (decl))
3859 error ("typedef %qD is initialized (use __typeof__ instead)", decl);
3864 error ("function %q#D is initialized like a variable", decl);
3874 if (! toplevel_bindings_p ()
3875 && DECL_EXTERNAL (decl))
3876 warning (0, "declaration of %q#D has %<extern%> and is initialized",
3878 DECL_EXTERNAL (decl) = 0;
3879 if (toplevel_bindings_p ())
3880 TREE_STATIC (decl) = 1;
3883 /* Set attributes here so if duplicate decl, will have proper attributes. */
3884 cplus_decl_attributes (&decl, attributes, 0);
3886 /* Dllimported symbols cannot be defined. Static data members (which
3887 can be initialized in-class and dllimported) go through grokfield,
3888 not here, so we don't need to exclude those decls when checking for
3890 if (initialized && DECL_DLLIMPORT_P (decl))
3892 error ("definition of %q#D is marked %<dllimport%>", decl);
3893 DECL_DLLIMPORT_P (decl) = 0;
3896 /* If #pragma weak was used, mark the decl weak now. */
3897 maybe_apply_pragma_weak (decl);
3899 if (TREE_CODE (decl) == FUNCTION_DECL
3900 && DECL_DECLARED_INLINE_P (decl)
3901 && DECL_UNINLINABLE (decl)
3902 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
3903 warning (0, "inline function %q+D given attribute noinline", decl);
3905 if (context && COMPLETE_TYPE_P (complete_type (context)))
3907 if (TREE_CODE (decl) == VAR_DECL)
3909 tree field = lookup_field (context, DECL_NAME (decl), 0, false);
3910 if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
3911 error ("%q#D is not a static member of %q#T", decl, context);
3914 if (DECL_CONTEXT (field) != context)
3916 if (!same_type_p (DECL_CONTEXT (field), context))
3917 pedwarn ("ISO C++ does not permit %<%T::%D%> "
3918 "to be defined as %<%T::%D%>",
3919 DECL_CONTEXT (field), DECL_NAME (decl),
3920 context, DECL_NAME (decl));
3921 DECL_CONTEXT (decl) = DECL_CONTEXT (field);
3923 if (processing_specialization
3924 && template_class_depth (context) == 0
3925 && CLASSTYPE_TEMPLATE_SPECIALIZATION (context))
3926 error ("template header not allowed in member definition "
3927 "of explicitly specialized class");
3928 /* Static data member are tricky; an in-class initialization
3929 still doesn't provide a definition, so the in-class
3930 declaration will have DECL_EXTERNAL set, but will have an
3931 initialization. Thus, duplicate_decls won't warn
3932 about this situation, and so we check here. */
3933 if (initialized && DECL_INITIALIZED_IN_CLASS_P (field))
3934 error ("duplicate initialization of %qD", decl);
3935 if (duplicate_decls (decl, field, /*newdecl_is_friend=*/false))
3941 tree field = check_classfn (context, decl,
3942 (processing_template_decl
3943 > template_class_depth (context))
3944 ? current_template_parms
3946 if (field && duplicate_decls (decl, field,
3947 /*newdecl_is_friend=*/false))
3951 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
3952 DECL_IN_AGGR_P (decl) = 0;
3953 /* Do not mark DECL as an explicit specialization if it was not
3954 already marked as an instantiation; a declaration should
3955 never be marked as a specialization unless we know what
3956 template is being specialized. */
3957 if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
3959 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
3961 /* [temp.expl.spec] An explicit specialization of a static data
3962 member of a template is a definition if the declaration
3963 includes an initializer; otherwise, it is a declaration.
3965 We check for processing_specialization so this only applies
3966 to the new specialization syntax. */
3967 if (!initialized && processing_specialization)
3968 DECL_EXTERNAL (decl) = 1;
3971 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
3972 pedwarn ("declaration of %q#D outside of class is not definition",
3976 /* Enter this declaration into the symbol table. */
3977 tem = maybe_push_decl (decl);
3979 if (processing_template_decl)
3980 tem = push_template_decl (tem);
3981 if (tem == error_mark_node)
3982 return error_mark_node;
3984 /* Tell the back-end to use or not use .common as appropriate. If we say
3985 -fconserve-space, we want this to save .data space, at the expense of
3986 wrong semantics. If we say -fno-conserve-space, we want this to
3987 produce errors about redefs; to do this we force variables into the
3989 if (flag_conserve_space
3990 && TREE_CODE (tem) == VAR_DECL
3991 && TREE_PUBLIC (tem)
3992 && !DECL_THREAD_LOCAL_P (tem)
3993 && !have_global_bss_p ())
3994 DECL_COMMON (tem) = 1;
3996 if (!processing_template_decl && TREE_CODE (tem) == VAR_DECL)
3997 start_decl_1 (tem, initialized);
4003 start_decl_1 (tree decl, bool initialized)
4007 gcc_assert (!processing_template_decl);
4009 if (error_operand_p (decl))
4012 gcc_assert (TREE_CODE (decl) == VAR_DECL);
4013 type = TREE_TYPE (decl);
4016 /* Is it valid for this decl to have an initializer at all?
4017 If not, set INITIALIZED to zero, which will indirectly
4018 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
4020 /* Don't allow initializations for incomplete types except for
4021 arrays which might be completed by the initialization. */
4022 if (COMPLETE_TYPE_P (complete_type (type)))
4023 ; /* A complete type is ok. */
4024 else if (TREE_CODE (type) != ARRAY_TYPE)
4026 error ("variable %q#D has initializer but incomplete type", decl);
4028 type = TREE_TYPE (decl) = error_mark_node;
4030 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
4032 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
4033 error ("elements of array %q#D have incomplete type", decl);
4034 /* else we already gave an error in start_decl. */
4038 else if (IS_AGGR_TYPE (type)
4039 && ! DECL_EXTERNAL (decl))
4041 if (!COMPLETE_TYPE_P (complete_type (type)))
4043 error ("aggregate %q#D has incomplete type and cannot be defined",
4045 /* Change the type so that assemble_variable will give
4046 DECL an rtl we can live with: (mem (const_int 0)). */
4047 type = TREE_TYPE (decl) = error_mark_node;
4051 /* If any base type in the hierarchy of TYPE needs a constructor,
4052 then we set initialized to 1. This way any nodes which are
4053 created for the purposes of initializing this aggregate
4054 will live as long as it does. This is necessary for global
4055 aggregates which do not have their initializers processed until
4056 the end of the file. */
4057 initialized = TYPE_NEEDS_CONSTRUCTING (type);
4061 /* Create a new scope to hold this declaration if necessary.
4062 Whether or not a new scope is necessary cannot be determined
4063 until after the type has been completed; if the type is a
4064 specialization of a class template it is not until after
4065 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4066 will be set correctly. */
4067 maybe_push_cleanup_level (type);
4070 /* Handle initialization of references. DECL, TYPE, and INIT have the
4071 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
4072 but will be set to a new CLEANUP_STMT if a temporary is created
4073 that must be destroyed subsequently.
4075 Returns an initializer expression to use to initialize DECL, or
4076 NULL if the initialization can be performed statically.
4078 Quotes on semantics can be found in ARM 8.4.3. */
4081 grok_reference_init (tree decl, tree type, tree init, tree *cleanup)
4085 if (init == NULL_TREE)
4087 if ((DECL_LANG_SPECIFIC (decl) == 0
4088 || DECL_IN_AGGR_P (decl) == 0)
4089 && ! DECL_THIS_EXTERN (decl))
4090 error ("%qD declared as reference but not initialized", decl);
4094 if (TREE_CODE (init) == CONSTRUCTOR)
4096 error ("ISO C++ forbids use of initializer list to "
4097 "initialize reference %qD", decl);
4101 if (TREE_CODE (init) == TREE_LIST)
4102 init = build_x_compound_expr_from_list (init, "initializer");
4104 if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
4105 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
4106 /* Note: default conversion is only called in very special cases. */
4107 init = decay_conversion (init);
4109 /* Convert INIT to the reference type TYPE. This may involve the
4110 creation of a temporary, whose lifetime must be the same as that
4111 of the reference. If so, a DECL_EXPR for the temporary will be
4112 added just after the DECL_EXPR for DECL. That's why we don't set
4113 DECL_INITIAL for local references (instead assigning to them
4114 explicitly); we need to allow the temporary to be initialized
4116 tmp = initialize_reference (type, init, decl, cleanup);
4118 if (tmp == error_mark_node)
4120 else if (tmp == NULL_TREE)
4122 error ("cannot initialize %qT from %qT", type, TREE_TYPE (init));
4126 if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
4129 DECL_INITIAL (decl) = tmp;
4134 /* When parsing `int a[] = {1, 2};' we don't know the size of the
4135 array until we finish parsing the initializer. If that's the
4136 situation we're in, update DECL accordingly. */
4139 maybe_deduce_size_from_array_init (tree decl, tree init)
4141 tree type = TREE_TYPE (decl);
4143 if (TREE_CODE (type) == ARRAY_TYPE
4144 && TYPE_DOMAIN (type) == NULL_TREE
4145 && TREE_CODE (decl) != TYPE_DECL)
4147 /* do_default is really a C-ism to deal with tentative definitions.
4148 But let's leave it here to ease the eventual merge. */
4149 int do_default = !DECL_EXTERNAL (decl);
4150 tree initializer = init ? init : DECL_INITIAL (decl);
4151 int failure = cp_complete_array_type (&TREE_TYPE (decl), initializer,
4156 error ("initializer fails to determine size of %qD", decl);
4157 TREE_TYPE (decl) = error_mark_node;
4159 else if (failure == 2)
4163 error ("array size missing in %qD", decl);
4164 TREE_TYPE (decl) = error_mark_node;
4166 /* If a `static' var's size isn't known, make it extern as
4167 well as static, so it does not get allocated. If it's not
4168 `static', then don't mark it extern; finish_incomplete_decl
4169 will give it a default size and it will get allocated. */
4170 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
4171 DECL_EXTERNAL (decl) = 1;
4173 else if (failure == 3)
4175 error ("zero-size array %qD", decl);
4176 TREE_TYPE (decl) = error_mark_node;
4179 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl)), decl);
4181 layout_decl (decl, 0);
4185 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
4186 any appropriate error messages regarding the layout. */
4189 layout_var_decl (tree decl)
4193 type = TREE_TYPE (decl);
4194 if (type == error_mark_node)
4197 /* If we haven't already layed out this declaration, do so now.
4198 Note that we must not call complete type for an external object
4199 because it's type might involve templates that we are not
4200 supposed to instantiate yet. (And it's perfectly valid to say
4201 `extern X x' for some incomplete type `X'.) */
4202 if (!DECL_EXTERNAL (decl))
4203 complete_type (type);
4204 if (!DECL_SIZE (decl)
4205 && TREE_TYPE (decl) != error_mark_node
4206 && (COMPLETE_TYPE_P (type)
4207 || (TREE_CODE (type) == ARRAY_TYPE
4208 && !TYPE_DOMAIN (type)
4209 && COMPLETE_TYPE_P (TREE_TYPE (type)))))
4210 layout_decl (decl, 0);
4212 if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
4214 /* An automatic variable with an incomplete type: that is an error.
4215 Don't talk about array types here, since we took care of that
4216 message in grokdeclarator. */
4217 error ("storage size of %qD isn't known", decl);
4218 TREE_TYPE (decl) = error_mark_node;
4221 /* Keep this code around in case we later want to control debug info
4222 based on whether a type is "used". (jason 1999-11-11) */
4224 else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
4225 /* Let debugger know it should output info for this type. */
4226 note_debug_info_needed (ttype);
4228 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
4229 note_debug_info_needed (DECL_CONTEXT (decl));
4232 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
4233 && DECL_SIZE (decl) != NULL_TREE
4234 && ! TREE_CONSTANT (DECL_SIZE (decl)))
4236 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
4237 constant_expression_warning (DECL_SIZE (decl));
4239 error ("storage size of %qD isn't constant", decl);
4243 /* If a local static variable is declared in an inline function, or if
4244 we have a weak definition, we must endeavor to create only one
4245 instance of the variable at link-time. */
4248 maybe_commonize_var (tree decl)
4250 /* Static data in a function with comdat linkage also has comdat
4252 if (TREE_STATIC (decl)
4253 /* Don't mess with __FUNCTION__. */
4254 && ! DECL_ARTIFICIAL (decl)
4255 && DECL_FUNCTION_SCOPE_P (decl)
4256 /* Unfortunately, import_export_decl has not always been called
4257 before the function is processed, so we cannot simply check
4259 && (DECL_COMDAT (DECL_CONTEXT (decl))
4260 || ((DECL_DECLARED_INLINE_P (DECL_CONTEXT (decl))
4261 || DECL_TEMPLATE_INSTANTIATION (DECL_CONTEXT (decl)))
4262 && TREE_PUBLIC (DECL_CONTEXT (decl)))))
4266 /* With weak symbols, we simply make the variable COMDAT;
4267 that will cause copies in multiple translations units to
4269 comdat_linkage (decl);
4273 if (DECL_INITIAL (decl) == NULL_TREE
4274 || DECL_INITIAL (decl) == error_mark_node)
4276 /* Without weak symbols, we can use COMMON to merge
4277 uninitialized variables. */
4278 TREE_PUBLIC (decl) = 1;
4279 DECL_COMMON (decl) = 1;
4283 /* While for initialized variables, we must use internal
4284 linkage -- which means that multiple copies will not
4286 TREE_PUBLIC (decl) = 0;
4287 DECL_COMMON (decl) = 0;
4288 warning (0, "sorry: semantics of inline function static "
4289 "data %q+#D are wrong (you'll wind up "
4290 "with multiple copies)", decl);
4291 warning (0, "%J you can work around this by removing "
4297 else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
4298 /* Set it up again; we might have set DECL_INITIAL since the last
4300 comdat_linkage (decl);
4303 /* Issue an error message if DECL is an uninitialized const variable. */
4306 check_for_uninitialized_const_var (tree decl)
4308 tree type = TREE_TYPE (decl);
4310 /* ``Unless explicitly declared extern, a const object does not have
4311 external linkage and must be initialized. ($8.4; $12.1)'' ARM
4313 if (TREE_CODE (decl) == VAR_DECL
4314 && TREE_CODE (type) != REFERENCE_TYPE
4315 && CP_TYPE_CONST_P (type)
4316 && !TYPE_NEEDS_CONSTRUCTING (type)
4317 && !DECL_INITIAL (decl))
4318 error ("uninitialized const %qD", decl);
4322 /* Structure holding the current initializer being processed by reshape_init.
4323 CUR is a pointer to the current element being processed, END is a pointer
4324 after the last element present in the initializer. */
4325 typedef struct reshape_iterator_t
4327 constructor_elt *cur;
4328 constructor_elt *end;
4331 static tree reshape_init_r (tree, reshape_iter *, bool);
4333 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
4334 returned is the next FIELD_DECL (possibly FIELD itself) that can be
4335 initialized. If there are no more such fields, the return value
4339 next_initializable_field (tree field)
4342 && (TREE_CODE (field) != FIELD_DECL
4343 || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
4344 || DECL_ARTIFICIAL (field)))
4345 field = TREE_CHAIN (field);
4350 /* Subroutine of reshape_init_array and reshape_init_vector, which does
4351 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
4352 INTEGER_CST representing the size of the array minus one (the maximum index),
4353 or NULL_TREE if the array was declared without specifying the size. D is
4354 the iterator within the constructor. */
4357 reshape_init_array_1 (tree elt_type, tree max_index, reshape_iter *d)
4360 bool sized_array_p = (max_index != NULL_TREE);
4361 unsigned HOST_WIDE_INT max_index_cst = 0;
4362 unsigned HOST_WIDE_INT index;
4364 /* The initializer for an array is always a CONSTRUCTOR. */
4365 new_init = build_constructor (NULL_TREE, NULL);
4369 /* Minus 1 is used for zero sized arrays. */
4370 if (integer_all_onesp (max_index))
4373 if (host_integerp (max_index, 1))
4374 max_index_cst = tree_low_cst (max_index, 1);
4375 /* sizetype is sign extended, not zero extended. */
4377 max_index_cst = tree_low_cst (fold_convert (size_type_node, max_index),
4381 /* Loop until there are no more initializers. */
4383 d->cur != d->end && (!sized_array_p || index <= max_index_cst);
4390 /* Handle array designated initializers (GNU extension). */
4391 if (TREE_CODE (d->cur->index) == IDENTIFIER_NODE)
4393 error ("name %qD used in a GNU-style designated "
4394 "initializer for an array", d->cur->index);
4400 elt_init = reshape_init_r (elt_type, d, /*first_initializer_p=*/false);
4401 if (elt_init == error_mark_node)
4402 return error_mark_node;
4403 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), NULL_TREE, elt_init);
4409 /* Subroutine of reshape_init_r, processes the initializers for arrays.
4410 Parameters are the same of reshape_init_r. */
4413 reshape_init_array (tree type, reshape_iter *d)
4415 tree max_index = NULL_TREE;
4417 gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
4419 if (TYPE_DOMAIN (type))
4420 max_index = array_type_nelts (type);
4422 return reshape_init_array_1 (TREE_TYPE (type), max_index, d);
4425 /* Subroutine of reshape_init_r, processes the initializers for vectors.
4426 Parameters are the same of reshape_init_r. */
4429 reshape_init_vector (tree type, reshape_iter *d)
4431 tree max_index = NULL_TREE;
4434 gcc_assert (TREE_CODE (type) == VECTOR_TYPE);
4436 if (COMPOUND_LITERAL_P (d->cur->value))
4438 tree value = d->cur->value;
4439 if (!same_type_p (TREE_TYPE (value), type))
4441 error ("invalid type %qT as initializer for a vector of type %qT",
4442 TREE_TYPE (d->cur->value), type);
4443 value = error_mark_node;
4449 /* For a vector, the representation type is a struct
4450 containing a single member which is an array of the
4451 appropriate size. */
4452 rtype = TYPE_DEBUG_REPRESENTATION_TYPE (type);
4453 if (rtype && TYPE_DOMAIN (TREE_TYPE (TYPE_FIELDS (rtype))))
4454 max_index = array_type_nelts (TREE_TYPE (TYPE_FIELDS (rtype)));
4456 return reshape_init_array_1 (TREE_TYPE (type), max_index, d);
4459 /* Subroutine of reshape_init_r, processes the initializers for classes
4460 or union. Parameters are the same of reshape_init_r. */
4463 reshape_init_class (tree type, reshape_iter *d, bool first_initializer_p)
4468 gcc_assert (CLASS_TYPE_P (type));
4470 /* The initializer for a class is always a CONSTRUCTOR. */
4471 new_init = build_constructor (NULL_TREE, NULL);
4472 field = next_initializable_field (TYPE_FIELDS (type));
4478 An initializer for an aggregate member that is an
4479 empty class shall have the form of an empty
4480 initializer-list {}. */
4481 if (!first_initializer_p)
4483 error ("initializer for %qT must be brace-enclosed", type);
4484 return error_mark_node;
4489 /* Loop through the initializable fields, gathering initializers. */
4490 while (d->cur != d->end)
4494 /* Handle designated initializers, as an extension. */
4498 pedwarn ("ISO C++ does not allow designated initializers");
4500 field = lookup_field_1 (type, d->cur->index, /*want_type=*/false);
4502 if (!field || TREE_CODE (field) != FIELD_DECL)
4504 error ("%qT has no non-static data member named %qD", type,
4506 return error_mark_node;
4510 /* If we processed all the member of the class, we are done. */
4514 field_init = reshape_init_r (TREE_TYPE (field), d,
4515 /*first_initializer_p=*/false);
4516 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), field, field_init);
4520 When a union is initialized with a brace-enclosed
4521 initializer, the braces shall only contain an
4522 initializer for the first member of the union. */
4523 if (TREE_CODE (type) == UNION_TYPE)
4526 field = next_initializable_field (TREE_CHAIN (field));
4532 /* Subroutine of reshape_init, which processes a single initializer (part of
4533 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
4534 iterator within the CONSTRUCTOR which points to the initializer to process.
4535 FIRST_INITIALIZER_P is true if this is the first initializer of the
4536 CONSTRUCTOR node. */
4539 reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p)
4541 tree init = d->cur->value;
4543 /* A non-aggregate type is always initialized with a single
4545 if (!CP_AGGREGATE_TYPE_P (type))
4547 /* It is invalid to initialize a non-aggregate type with a
4548 brace-enclosed initializer.
4549 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
4550 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
4551 a CONSTRUCTOR (with a record type). */
4552 if (TREE_CODE (init) == CONSTRUCTOR
4553 && BRACE_ENCLOSED_INITIALIZER_P (init)) /* p7626.C */
4555 error ("braces around scalar initializer for type %qT", type);
4556 init = error_mark_node;
4565 All implicit type conversions (clause _conv_) are considered when
4566 initializing the aggregate member with an initializer from an
4567 initializer-list. If the initializer can initialize a member,
4568 the member is initialized. Otherwise, if the member is itself a
4569 non-empty subaggregate, brace elision is assumed and the
4570 initializer is considered for the initialization of the first
4571 member of the subaggregate. */
4572 if (TREE_CODE (init) != CONSTRUCTOR
4573 && can_convert_arg (type, TREE_TYPE (init), init, LOOKUP_NORMAL))
4579 /* [dcl.init.string]
4581 A char array (whether plain char, signed char, or unsigned char)
4582 can be initialized by a string-literal (optionally enclosed in
4583 braces); a wchar_t array can be initialized by a wide
4584 string-literal (optionally enclosed in braces). */
4585 if (TREE_CODE (type) == ARRAY_TYPE
4586 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
4588 tree str_init = init;
4590 /* Strip one level of braces if and only if they enclose a single
4591 element (as allowed by [dcl.init.string]). */
4592 if (!first_initializer_p
4593 && TREE_CODE (str_init) == CONSTRUCTOR
4594 && VEC_length (constructor_elt, CONSTRUCTOR_ELTS (str_init)) == 1)
4596 str_init = VEC_index (constructor_elt,
4597 CONSTRUCTOR_ELTS (str_init), 0)->value;
4600 /* If it's a string literal, then it's the initializer for the array
4601 as a whole. Otherwise, continue with normal initialization for
4602 array types (one value per array element). */
4603 if (TREE_CODE (str_init) == STRING_CST)
4610 /* The following cases are about aggregates. If we are not within a full
4611 initializer already, and there is not a CONSTRUCTOR, it means that there
4612 is a missing set of braces (that is, we are processing the case for
4613 which reshape_init exists). */
4614 if (!first_initializer_p)
4616 if (TREE_CODE (init) == CONSTRUCTOR)
4618 /* For a nested compound literal, there is no need to reshape since
4619 brace elision is not allowed. Even if we decided to allow it,
4620 we should add a call to reshape_init in finish_compound_literal,
4621 before calling digest_init, so changing this code would still
4622 not be necessary. */
4623 if (!COMPOUND_LITERAL_P (init))
4626 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
4627 return reshape_init (type, init);
4630 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init));
4633 warning (OPT_Wmissing_braces, "missing braces around initializer for %qT",
4637 /* Dispatch to specialized routines. */
4638 if (CLASS_TYPE_P (type))
4639 return reshape_init_class (type, d, first_initializer_p);
4640 else if (TREE_CODE (type) == ARRAY_TYPE)
4641 return reshape_init_array (type, d);
4642 else if (TREE_CODE (type) == VECTOR_TYPE)
4643 return reshape_init_vector (type, d);
4648 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
4649 brace-enclosed aggregate initializer.
4651 INIT is the CONSTRUCTOR containing the list of initializers describing
4652 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
4653 It may not presently match the shape of the TYPE; for example:
4655 struct S { int a; int b; };
4656 struct S a[] = { 1, 2, 3, 4 };
4658 Here INIT will hold a VEC of four elements, rather than a
4659 VEC of two elements, each itself a VEC of two elements. This
4660 routine transforms INIT from the former form into the latter. The
4661 revised CONSTRUCTOR node is returned. */
4664 reshape_init (tree type, tree init)
4666 VEC(constructor_elt, gc) *v;
4670 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
4672 v = CONSTRUCTOR_ELTS (init);
4674 /* An empty constructor does not need reshaping, and it is always a valid
4676 if (VEC_empty (constructor_elt, v))
4679 /* Recurse on this CONSTRUCTOR. */
4680 d.cur = VEC_index (constructor_elt, v, 0);
4681 d.end = d.cur + VEC_length (constructor_elt, v);
4683 new_init = reshape_init_r (type, &d, true);
4684 if (new_init == error_mark_node)
4685 return error_mark_node;
4687 /* Make sure all the element of the constructor were used. Otherwise,
4688 issue an error about exceeding initializers. */
4690 error ("too many initializers for %qT", type);
4695 /* Verify INIT (the initializer for DECL), and record the
4696 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
4697 grok_reference_init.
4699 If the return value is non-NULL, it is an expression that must be
4700 evaluated dynamically to initialize DECL. */
4703 check_initializer (tree decl, tree init, int flags, tree *cleanup)
4705 tree type = TREE_TYPE (decl);
4706 tree init_code = NULL;
4708 /* Things that are going to be initialized need to have complete
4710 TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
4712 if (type == error_mark_node)
4713 /* We will have already complained. */
4715 else if (init && COMPLETE_TYPE_P (type)
4716 && !TREE_CONSTANT (TYPE_SIZE (type)))
4718 error ("variable-sized object %qD may not be initialized", decl);
4721 else if (TREE_CODE (type) == ARRAY_TYPE
4722 && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
4724 error ("elements of array %q#D have incomplete type", decl);
4727 else if (TREE_CODE (type) != ARRAY_TYPE && !COMPLETE_TYPE_P (type))
4729 error ("%qD has incomplete type", decl);
4730 TREE_TYPE (decl) = error_mark_node;
4734 if (TREE_CODE (decl) == CONST_DECL)
4736 gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);
4738 DECL_INITIAL (decl) = init;
4740 gcc_assert (init != NULL_TREE);
4743 else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
4744 init = grok_reference_init (decl, type, init, cleanup);
4747 /* Do not reshape constructors of vectors (they don't need to be
4749 if (TREE_CODE (init) == CONSTRUCTOR
4750 && !COMPOUND_LITERAL_P (init)
4751 && !TREE_TYPE (init)) /* ptrmemfunc */
4753 init = reshape_init (type, init);
4755 if ((*targetm.vector_opaque_p) (type))
4757 error ("opaque vector types cannot be initialized");
4758 init = error_mark_node;
4762 /* If DECL has an array type without a specific bound, deduce the
4763 array size from the initializer. */
4764 maybe_deduce_size_from_array_init (decl, init);
4765 type = TREE_TYPE (decl);
4766 if (type == error_mark_node)
4769 if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
4771 if (TREE_CODE (type) == ARRAY_TYPE)
4772 goto initialize_aggr;
4773 else if (TREE_CODE (init) == CONSTRUCTOR)
4775 if (TYPE_NON_AGGREGATE_CLASS (type))
4777 error ("%qD must be initialized by constructor, "
4780 init = error_mark_node;
4783 goto dont_use_constructor;
4787 int saved_stmts_are_full_exprs_p;
4790 saved_stmts_are_full_exprs_p = 0;
4791 if (building_stmt_tree ())
4793 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
4794 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
4796 init = build_aggr_init (decl, init, flags);
4797 if (building_stmt_tree ())
4798 current_stmt_tree ()->stmts_are_full_exprs_p =
4799 saved_stmts_are_full_exprs_p;
4805 dont_use_constructor:
4806 if (TREE_CODE (init) != TREE_VEC)
4808 init_code = store_init_value (decl, init);
4809 if (pedantic && TREE_CODE (type) == ARRAY_TYPE
4810 && DECL_INITIAL (decl)
4811 && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST
4812 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl)))
4813 warning (0, "array %qD initialized by parenthesized string literal %qE",
4814 decl, DECL_INITIAL (decl));
4819 else if (DECL_EXTERNAL (decl))
4821 else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
4822 goto initialize_aggr;
4823 else if (IS_AGGR_TYPE (type))
4825 tree core_type = strip_array_types (type);
4827 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
4828 error ("structure %qD with uninitialized const members", decl);
4829 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
4830 error ("structure %qD with uninitialized reference members", decl);
4832 check_for_uninitialized_const_var (decl);
4835 check_for_uninitialized_const_var (decl);
4837 if (init && init != error_mark_node)
4838 init_code = build2 (INIT_EXPR, type, decl, init);
4843 /* If DECL is not a local variable, give it RTL. */
4846 make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
4848 int toplev = toplevel_bindings_p ();
4850 const char *filename;
4852 /* Set the DECL_ASSEMBLER_NAME for the object. */
4855 /* The `register' keyword, when used together with an
4856 asm-specification, indicates that the variable should be
4857 placed in a particular register. */
4858 if (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
4860 set_user_assembler_name (decl, asmspec);
4861 DECL_HARD_REGISTER (decl) = 1;
4865 if (TREE_CODE (decl) == FUNCTION_DECL
4866 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
4867 set_builtin_user_assembler_name (decl, asmspec);
4868 set_user_assembler_name (decl, asmspec);
4872 /* Handle non-variables up front. */
4873 if (TREE_CODE (decl) != VAR_DECL)
4875 rest_of_decl_compilation (decl, toplev, at_eof);
4879 /* If we see a class member here, it should be a static data
4881 if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
4883 gcc_assert (TREE_STATIC (decl));
4884 /* An in-class declaration of a static data member should be
4885 external; it is only a declaration, and not a definition. */
4886 if (init == NULL_TREE)
4887 gcc_assert (DECL_EXTERNAL (decl));
4890 /* We don't create any RTL for local variables. */
4891 if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
4894 /* We defer emission of local statics until the corresponding
4895 DECL_EXPR is expanded. */
4896 defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
4898 /* We try to defer namespace-scope static constants so that they are
4899 not emitted into the object file unnecessarily. */
4900 filename = input_filename;
4901 if (!DECL_VIRTUAL_P (decl)
4902 && TREE_READONLY (decl)
4903 && DECL_INITIAL (decl) != NULL_TREE
4904 && DECL_INITIAL (decl) != error_mark_node
4906 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
4908 && !TREE_PUBLIC (decl))
4910 /* Fool with the linkage of static consts according to #pragma
4912 struct c_fileinfo *finfo = get_fileinfo (lbasename (filename));
4913 if (!finfo->interface_unknown && !TREE_PUBLIC (decl))
4915 TREE_PUBLIC (decl) = 1;
4916 DECL_EXTERNAL (decl) = finfo->interface_only;
4921 /* Likewise for template instantiations. */
4922 else if (DECL_LANG_SPECIFIC (decl)
4923 && DECL_IMPLICIT_INSTANTIATION (decl))
4926 /* If we're not deferring, go ahead and assemble the variable. */
4928 rest_of_decl_compilation (decl, toplev, at_eof);
4931 /* Generate code to initialize DECL (a local variable). */
4934 initialize_local_var (tree decl, tree init)
4936 tree type = TREE_TYPE (decl);
4939 gcc_assert (TREE_CODE (decl) == VAR_DECL
4940 || TREE_CODE (decl) == RESULT_DECL);
4941 gcc_assert (!TREE_STATIC (decl));
4943 if (DECL_SIZE (decl) == NULL_TREE)
4945 /* If we used it already as memory, it must stay in memory. */
4946 DECL_INITIAL (decl) = NULL_TREE;
4947 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
4950 if (DECL_SIZE (decl) && type != error_mark_node)
4954 /* Compute and store the initial value. */
4955 already_used = TREE_USED (decl) || TREE_USED (type);
4957 /* Perform the initialization. */
4960 int saved_stmts_are_full_exprs_p;
4962 gcc_assert (building_stmt_tree ());
4963 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
4964 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
4965 finish_expr_stmt (init);
4966 current_stmt_tree ()->stmts_are_full_exprs_p =
4967 saved_stmts_are_full_exprs_p;
4970 /* Set this to 0 so we can tell whether an aggregate which was
4971 initialized was ever used. Don't do this if it has a
4972 destructor, so we don't complain about the 'resource
4973 allocation is initialization' idiom. Now set
4974 attribute((unused)) on types so decls of that type will be
4975 marked used. (see TREE_USED, above.) */
4976 if (TYPE_NEEDS_CONSTRUCTING (type)
4978 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
4979 && DECL_NAME (decl))
4980 TREE_USED (decl) = 0;
4981 else if (already_used)
4982 TREE_USED (decl) = 1;
4985 /* Generate a cleanup, if necessary. */
4986 cleanup = cxx_maybe_build_cleanup (decl);
4987 if (DECL_SIZE (decl) && cleanup)
4988 finish_decl_cleanup (decl, cleanup);
4991 /* DECL is a VAR_DECL for a compiler-generated variable with static
4992 storage duration (like a virtual table) whose initializer is a
4993 compile-time constant. INIT must be either a TREE_LIST of values,
4994 or a CONSTRUCTOR. Initialize the variable and provide it to the
4998 initialize_artificial_var (tree decl, tree init)
5000 gcc_assert (DECL_ARTIFICIAL (decl));
5001 if (TREE_CODE (init) == TREE_LIST)
5002 init = build_constructor_from_list (NULL_TREE, init);
5003 gcc_assert (TREE_CODE (init) == CONSTRUCTOR);
5004 DECL_INITIAL (decl) = init;
5005 DECL_INITIALIZED_P (decl) = 1;
5006 determine_visibility (decl);
5007 layout_var_decl (decl);
5008 maybe_commonize_var (decl);
5009 make_rtl_for_nonlocal_decl (decl, init, /*asmspec=*/NULL);
5012 /* Finish processing of a declaration;
5013 install its line number and initial value.
5014 If the length of an array type is not known before,
5015 it must be determined now, from the initial value, or it is an error.
5017 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
5018 true, then INIT is an integral constant expression.
5020 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
5021 if the (init) syntax was used. */
5024 cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
5025 tree asmspec_tree, int flags)
5029 const char *asmspec = NULL;
5030 int was_readonly = 0;
5031 bool var_definition_p = false;
5032 int saved_processing_template_decl;
5034 if (decl == error_mark_node)
5039 error ("assignment (not initialization) in declaration");
5043 gcc_assert (TREE_CODE (decl) != RESULT_DECL);
5044 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
5045 gcc_assert (TREE_CODE (decl) != PARM_DECL);
5047 type = TREE_TYPE (decl);
5048 if (type == error_mark_node)
5051 /* Assume no cleanup is required. */
5052 cleanup = NULL_TREE;
5053 saved_processing_template_decl = processing_template_decl;
5055 /* If a name was specified, get the string. */
5056 if (global_scope_p (current_binding_level))
5057 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
5058 if (asmspec_tree && asmspec_tree != error_mark_node)
5059 asmspec = TREE_STRING_POINTER (asmspec_tree);
5061 if (current_class_type
5062 && CP_DECL_CONTEXT (decl) == current_class_type
5063 && TYPE_BEING_DEFINED (current_class_type)
5064 && (DECL_INITIAL (decl) || init))
5065 DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
5067 if (processing_template_decl)
5069 bool type_dependent_p;
5071 /* Add this declaration to the statement-tree. */
5072 if (at_function_scope_p ())
5073 add_decl_expr (decl);
5075 type_dependent_p = dependent_type_p (type);
5077 if (init && init_const_expr_p)
5079 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
5080 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl))
5081 TREE_CONSTANT (decl) = 1;
5085 || !DECL_CLASS_SCOPE_P (decl)
5086 || !DECL_INTEGRAL_CONSTANT_VAR_P (decl)
5088 || value_dependent_expression_p (init))
5091 DECL_INITIAL (decl) = init;
5092 if (TREE_CODE (decl) == VAR_DECL
5093 && !DECL_PRETTY_FUNCTION_P (decl)
5094 && !type_dependent_p)
5095 maybe_deduce_size_from_array_init (decl, init);
5099 init = fold_non_dependent_expr (init);
5100 processing_template_decl = 0;
5103 /* Take care of TYPE_DECLs up front. */
5104 if (TREE_CODE (decl) == TYPE_DECL)
5106 if (type != error_mark_node
5107 && IS_AGGR_TYPE (type) && DECL_NAME (decl))
5109 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
5110 warning (0, "shadowing previous type declaration of %q#D", decl);
5111 set_identifier_type_value (DECL_NAME (decl), decl);
5114 /* If we have installed this as the canonical typedef for this
5115 type, and that type has not been defined yet, delay emitting
5116 the debug information for it, as we will emit it later. */
5117 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
5118 && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
5119 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
5121 rest_of_decl_compilation (decl, DECL_CONTEXT (decl) == NULL_TREE,
5126 /* A reference will be modified here, as it is initialized. */
5127 if (! DECL_EXTERNAL (decl)
5128 && TREE_READONLY (decl)
5129 && TREE_CODE (type) == REFERENCE_TYPE)
5132 TREE_READONLY (decl) = 0;
5135 if (TREE_CODE (decl) == VAR_DECL)
5137 /* Only PODs can have thread-local storage. Other types may require
5138 various kinds of non-trivial initialization. */
5139 if (DECL_THREAD_LOCAL_P (decl) && !pod_type_p (TREE_TYPE (decl)))
5140 error ("%qD cannot be thread-local because it has non-POD type %qT",
5141 decl, TREE_TYPE (decl));
5142 /* If this is a local variable that will need a mangled name,
5143 register it now. We must do this before processing the
5144 initializer for the variable, since the initialization might
5145 require a guard variable, and since the mangled name of the
5146 guard variable will depend on the mangled name of this
5148 if (!processing_template_decl
5149 && DECL_FUNCTION_SCOPE_P (decl)
5150 && TREE_STATIC (decl)
5151 && !DECL_ARTIFICIAL (decl))
5152 push_local_name (decl);
5153 /* Convert the initializer to the type of DECL, if we have not
5154 already initialized DECL. */
5155 if (!DECL_INITIALIZED_P (decl)
5156 /* If !DECL_EXTERNAL then DECL is being defined. In the
5157 case of a static data member initialized inside the
5158 class-specifier, there can be an initializer even if DECL
5159 is *not* defined. */
5160 && (!DECL_EXTERNAL (decl) || init))
5164 DECL_NONTRIVIALLY_INITIALIZED_P (decl) = 1;
5165 if (init_const_expr_p)
5167 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
5168 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl))
5169 TREE_CONSTANT (decl) = 1;
5172 init = check_initializer (decl, init, flags, &cleanup);
5173 /* Thread-local storage cannot be dynamically initialized. */
5174 if (DECL_THREAD_LOCAL_P (decl) && init)
5176 error ("%qD is thread-local and so cannot be dynamically "
5177 "initialized", decl);
5181 /* Check that the initializer for a static data member was a
5182 constant. Although we check in the parser that the
5183 initializer is an integral constant expression, we do not
5184 simplify division-by-zero at the point at which it
5185 occurs. Therefore, in:
5187 struct S { static const int i = 7 / 0; };
5189 we issue an error at this point. It would
5190 probably be better to forbid division by zero in
5191 integral constant expressions. */
5192 if (DECL_EXTERNAL (decl) && init)
5194 error ("%qD cannot be initialized by a non-constant expression"
5195 " when being declared", decl);
5196 DECL_INITIALIZED_IN_CLASS_P (decl) = 0;
5204 The memory occupied by any object of static storage
5205 duration is zero-initialized at program startup before
5206 any other initialization takes place.
5208 We cannot create an appropriate initializer until after
5209 the type of DECL is finalized. If DECL_INITIAL is set,
5210 then the DECL is statically initialized, and any
5211 necessary zero-initialization has already been performed. */
5212 if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
5213 DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
5214 /*nelts=*/NULL_TREE,
5215 /*static_storage_p=*/true);
5216 /* Remember that the initialization for this variable has
5218 DECL_INITIALIZED_P (decl) = 1;
5219 /* This declaration is the definition of this variable,
5220 unless we are initializing a static data member within
5221 the class specifier. */
5222 if (!DECL_EXTERNAL (decl))
5223 var_definition_p = true;
5225 /* If the variable has an array type, lay out the type, even if
5226 there is no initializer. It is valid to index through the
5227 array, and we must get TYPE_ALIGN set correctly on the array
5229 else if (TREE_CODE (type) == ARRAY_TYPE)
5233 /* Add this declaration to the statement-tree. This needs to happen
5234 after the call to check_initializer so that the DECL_EXPR for a
5235 reference temp is added before the DECL_EXPR for the reference itself. */
5236 if (at_function_scope_p ())
5237 add_decl_expr (decl);
5239 /* Let the middle end know about variables and functions -- but not
5240 static data members in uninstantiated class templates. */
5241 if (!saved_processing_template_decl
5242 && (TREE_CODE (decl) == VAR_DECL
5243 || TREE_CODE (decl) == FUNCTION_DECL))
5245 if (TREE_CODE (decl) == VAR_DECL)
5247 layout_var_decl (decl);
5248 maybe_commonize_var (decl);
5249 if (DECL_NAMESPACE_SCOPE_P (decl) && !TREE_PUBLIC (decl)
5250 && !DECL_THIS_STATIC (decl) && !DECL_ARTIFICIAL (decl))
5252 /* This is a const variable with implicit 'static'. Set
5253 DECL_THIS_STATIC so we can tell it from variables that are
5254 !TREE_PUBLIC because of the anonymous namespace. */
5255 DECL_THIS_STATIC (decl) = 1;
5259 make_rtl_for_nonlocal_decl (decl, init, asmspec);
5261 /* Check for abstractness of the type. Notice that there is no
5262 need to strip array types here since the check for those types
5263 is already done within create_array_type_for_decl. */
5264 if (TREE_CODE (type) == FUNCTION_TYPE
5265 || TREE_CODE (type) == METHOD_TYPE)
5266 abstract_virtuals_error (decl, TREE_TYPE (type));
5268 abstract_virtuals_error (decl, type);
5270 /* This needs to happen after the linkage is set. */
5271 determine_visibility (decl);
5273 if (TREE_CODE (decl) == FUNCTION_DECL
5274 || TREE_TYPE (decl) == error_mark_node)
5275 /* No initialization required. */
5277 else if (DECL_EXTERNAL (decl)
5278 && ! (DECL_LANG_SPECIFIC (decl)
5279 && DECL_NOT_REALLY_EXTERN (decl)))
5282 DECL_INITIAL (decl) = init;
5286 /* A variable definition. */
5287 if (DECL_FUNCTION_SCOPE_P (decl))
5289 /* Initialize the local variable. */
5290 if (processing_template_decl)
5291 DECL_INITIAL (decl) = init;
5292 else if (!TREE_STATIC (decl))
5293 initialize_local_var (decl, init);
5296 /* If a variable is defined, and then a subsequent
5297 definition with external linkage is encountered, we will
5298 get here twice for the same variable. We want to avoid
5299 calling expand_static_init more than once. For variables
5300 that are not static data members, we can call
5301 expand_static_init only when we actually process the
5302 initializer. It is not legal to redeclare a static data
5303 member, so this issue does not arise in that case. */
5304 if (var_definition_p && TREE_STATIC (decl))
5305 expand_static_init (decl, init);
5309 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
5310 reference, insert it in the statement-tree now. */
5312 push_cleanup (decl, cleanup, false);
5315 processing_template_decl = saved_processing_template_decl;
5318 TREE_READONLY (decl) = 1;
5320 /* If this was marked 'used', be sure it will be output. */
5321 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
5322 mark_decl_referenced (decl);
5325 /* This is here for a midend callback from c-common.c. */
5328 finish_decl (tree decl, tree init, tree asmspec_tree)
5330 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, asmspec_tree, 0);
5333 /* Returns a declaration for a VAR_DECL as if:
5335 extern "C" TYPE NAME;
5337 had been seen. Used to create compiler-generated global
5341 declare_global_var (tree name, tree type)
5345 push_to_top_level ();
5346 decl = build_decl (VAR_DECL, name, type);
5347 TREE_PUBLIC (decl) = 1;
5348 DECL_EXTERNAL (decl) = 1;
5349 DECL_ARTIFICIAL (decl) = 1;
5350 /* If the user has explicitly declared this variable (perhaps
5351 because the code we are compiling is part of a low-level runtime
5352 library), then it is possible that our declaration will be merged
5353 with theirs by pushdecl. */
5354 decl = pushdecl (decl);
5355 finish_decl (decl, NULL_TREE, NULL_TREE);
5356 pop_from_top_level ();
5361 /* Returns a pointer to the `atexit' function. Note that if
5362 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
5363 `__cxa_atexit' function specified in the IA64 C++ ABI. */
5366 get_atexit_node (void)
5373 bool use_aeabi_atexit;
5378 if (flag_use_cxa_atexit)
5380 /* The declaration for `__cxa_atexit' is:
5382 int __cxa_atexit (void (*)(void *), void *, void *)
5384 We build up the argument types and then then function type
5387 use_aeabi_atexit = targetm.cxx.use_aeabi_atexit ();
5388 /* First, build the pointer-to-function type for the first
5390 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5391 fn_type = build_function_type (void_type_node, arg_types);
5392 fn_ptr_type = build_pointer_type (fn_type);
5393 /* Then, build the rest of the argument types. */
5394 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5395 if (use_aeabi_atexit)
5397 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
5398 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
5402 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
5403 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
5405 /* And the final __cxa_atexit type. */
5406 fn_type = build_function_type (integer_type_node, arg_types);
5407 fn_ptr_type = build_pointer_type (fn_type);
5408 if (use_aeabi_atexit)
5409 name = "__aeabi_atexit";
5411 name = "__cxa_atexit";
5415 /* The declaration for `atexit' is:
5417 int atexit (void (*)());
5419 We build up the argument types and then then function type
5421 fn_type = build_function_type (void_type_node, void_list_node);
5422 fn_ptr_type = build_pointer_type (fn_type);
5423 arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
5424 /* Build the final atexit type. */
5425 fn_type = build_function_type (integer_type_node, arg_types);
5429 /* Now, build the function declaration. */
5430 push_lang_context (lang_name_c);
5431 atexit_fndecl = build_library_fn_ptr (name, fn_type);
5432 mark_used (atexit_fndecl);
5433 pop_lang_context ();
5434 atexit_node = decay_conversion (atexit_fndecl);
5439 /* Returns the __dso_handle VAR_DECL. */
5442 get_dso_handle_node (void)
5444 if (dso_handle_node)
5445 return dso_handle_node;
5447 /* Declare the variable. */
5448 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
5451 return dso_handle_node;
5454 /* Begin a new function with internal linkage whose job will be simply
5455 to destroy some particular variable. */
5457 static GTY(()) int start_cleanup_cnt;
5460 start_cleanup_fn (void)
5467 push_to_top_level ();
5469 /* No need to mangle this. */
5470 push_lang_context (lang_name_c);
5472 /* Build the parameter-types. */
5473 parmtypes = void_list_node;
5474 /* Functions passed to __cxa_atexit take an additional parameter.
5475 We'll just ignore it. After we implement the new calling
5476 convention for destructors, we can eliminate the use of
5477 additional cleanup functions entirely in the -fnew-abi case. */
5478 if (flag_use_cxa_atexit)
5479 parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
5480 /* Build the function type itself. */
5481 fntype = build_function_type (void_type_node, parmtypes);
5482 /* Build the name of the function. */
5483 sprintf (name, "__tcf_%d", start_cleanup_cnt++);
5484 /* Build the function declaration. */
5485 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
5486 /* It's a function with internal linkage, generated by the
5488 TREE_PUBLIC (fndecl) = 0;
5489 DECL_ARTIFICIAL (fndecl) = 1;
5490 /* Make the function `inline' so that it is only emitted if it is
5491 actually needed. It is unlikely that it will be inlined, since
5492 it is only called via a function pointer, but we avoid unnecessary
5493 emissions this way. */
5494 DECL_INLINE (fndecl) = 1;
5495 DECL_DECLARED_INLINE_P (fndecl) = 1;
5496 DECL_INTERFACE_KNOWN (fndecl) = 1;
5497 /* Build the parameter. */
5498 if (flag_use_cxa_atexit)
5502 parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
5503 DECL_CONTEXT (parmdecl) = fndecl;
5504 TREE_USED (parmdecl) = 1;
5505 DECL_ARGUMENTS (fndecl) = parmdecl;
5509 start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED);
5511 pop_lang_context ();
5513 return current_function_decl;
5516 /* Finish the cleanup function begun by start_cleanup_fn. */
5519 end_cleanup_fn (void)
5521 expand_or_defer_fn (finish_function (0));
5523 pop_from_top_level ();
5526 /* Generate code to handle the destruction of DECL, an object with
5527 static storage duration. */
5530 register_dtor_fn (tree decl)
5537 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
5538 return void_zero_node;
5540 /* Call build_cleanup before we enter the anonymous function so that
5541 any access checks will be done relative to the current scope,
5542 rather than the scope of the anonymous function. */
5543 build_cleanup (decl);
5545 /* Now start the function. */
5546 cleanup = start_cleanup_fn ();
5548 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
5549 to the original function, rather than the anonymous one. That
5550 will make the back-end think that nested functions are in use,
5551 which causes confusion. */
5553 push_deferring_access_checks (dk_no_check);
5554 fcall = build_cleanup (decl);
5555 pop_deferring_access_checks ();
5557 /* Create the body of the anonymous function. */
5558 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
5559 finish_expr_stmt (fcall);
5560 finish_compound_stmt (compound_stmt);
5563 /* Call atexit with the cleanup function. */
5564 cxx_mark_addressable (cleanup);
5565 mark_used (cleanup);
5566 cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
5567 if (flag_use_cxa_atexit)
5569 args = tree_cons (NULL_TREE,
5570 build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0),
5572 if (targetm.cxx.use_aeabi_atexit ())
5574 args = tree_cons (NULL_TREE, cleanup, args);
5575 args = tree_cons (NULL_TREE, null_pointer_node, args);
5579 args = tree_cons (NULL_TREE, null_pointer_node, args);
5580 args = tree_cons (NULL_TREE, cleanup, args);
5584 args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
5585 return build_function_call (get_atexit_node (), args);
5588 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
5589 is its initializer. Generate code to handle the construction
5590 and destruction of DECL. */
5593 expand_static_init (tree decl, tree init)
5595 gcc_assert (TREE_CODE (decl) == VAR_DECL);
5596 gcc_assert (TREE_STATIC (decl));
5598 /* Some variables require no initialization. */
5600 && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
5601 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
5604 if (DECL_FUNCTION_SCOPE_P (decl))
5606 /* Emit code to perform this initialization but once. */
5607 tree if_stmt = NULL_TREE, inner_if_stmt = NULL_TREE;
5608 tree then_clause = NULL_TREE, inner_then_clause = NULL_TREE;
5609 tree guard, guard_addr, guard_addr_list;
5610 tree acquire_fn, release_fn, abort_fn;
5613 /* Emit code to perform this initialization but once. This code
5616 static <type> guard;
5617 if (!guard.first_byte) {
5618 if (__cxa_guard_acquire (&guard)) {
5621 // Do initialization.
5622 flag = true; __cxa_guard_release (&guard);
5623 // Register variable for destruction at end of program.
5625 if (!flag) __cxa_guard_abort (&guard);
5629 Note that the `flag' variable is only set to 1 *after* the
5630 initialization is complete. This ensures that an exception,
5631 thrown during the construction, will cause the variable to
5632 reinitialized when we pass through this code again, as per:
5636 If the initialization exits by throwing an exception, the
5637 initialization is not complete, so it will be tried again
5638 the next time control enters the declaration.
5640 This process should be thread-safe, too; multiple threads
5641 should not be able to initialize the variable more than
5644 /* Create the guard variable. */
5645 guard = get_guard (decl);
5647 /* This optimization isn't safe on targets with relaxed memory
5648 consistency. On such targets we force synchronization in
5649 __cxa_guard_acquire. */
5650 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
5652 /* Begin the conditional initialization. */
5653 if_stmt = begin_if_stmt ();
5654 finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
5655 then_clause = begin_compound_stmt (BCS_NO_SCOPE);
5658 if (flag_threadsafe_statics)
5660 guard_addr = build_address (guard);
5661 guard_addr_list = build_tree_list (NULL_TREE, guard_addr);
5663 acquire_fn = get_identifier ("__cxa_guard_acquire");
5664 release_fn = get_identifier ("__cxa_guard_release");
5665 abort_fn = get_identifier ("__cxa_guard_abort");
5666 if (!get_global_value_if_present (acquire_fn, &acquire_fn))
5668 tree argtypes = tree_cons (NULL_TREE, TREE_TYPE (guard_addr),
5670 tree vfntype = build_function_type (void_type_node, argtypes);
5671 acquire_fn = push_library_fn
5672 (acquire_fn, build_function_type (integer_type_node, argtypes));
5673 release_fn = push_library_fn (release_fn, vfntype);
5674 abort_fn = push_library_fn (abort_fn, vfntype);
5678 release_fn = identifier_global_value (release_fn);
5679 abort_fn = identifier_global_value (abort_fn);
5682 inner_if_stmt = begin_if_stmt ();
5683 finish_if_stmt_cond (build_call (acquire_fn, guard_addr_list),
5686 inner_then_clause = begin_compound_stmt (BCS_NO_SCOPE);
5687 begin = get_target_expr (boolean_false_node);
5688 flag = TARGET_EXPR_SLOT (begin);
5690 TARGET_EXPR_CLEANUP (begin)
5691 = build3 (COND_EXPR, void_type_node, flag,
5693 build_call (abort_fn, guard_addr_list));
5694 CLEANUP_EH_ONLY (begin) = 1;
5696 /* Do the initialization itself. */
5697 init = add_stmt_to_compound (begin, init);
5698 init = add_stmt_to_compound
5699 (init, build2 (MODIFY_EXPR, void_type_node, flag, boolean_true_node));
5700 init = add_stmt_to_compound
5701 (init, build_call (release_fn, guard_addr_list));
5704 init = add_stmt_to_compound (init, set_guard (guard));
5706 /* Use atexit to register a function for destroying this static
5708 init = add_stmt_to_compound (init, register_dtor_fn (decl));
5710 finish_expr_stmt (init);
5712 if (flag_threadsafe_statics)
5714 finish_compound_stmt (inner_then_clause);
5715 finish_then_clause (inner_if_stmt);
5716 finish_if_stmt (inner_if_stmt);
5719 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
5721 finish_compound_stmt (then_clause);
5722 finish_then_clause (if_stmt);
5723 finish_if_stmt (if_stmt);
5727 static_aggregates = tree_cons (init, decl, static_aggregates);
5731 /* Make TYPE a complete type based on INITIAL_VALUE.
5732 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
5733 2 if there was no information (in which case assume 0 if DO_DEFAULT),
5734 3 if the initializer list is empty (in pedantic mode). */
5737 cp_complete_array_type (tree *ptype, tree initial_value, bool do_default)
5740 tree type, elt_type;
5744 /* An array of character type can be initialized from a
5745 brace-enclosed string constant.
5747 FIXME: this code is duplicated from reshape_init. Probably
5748 we should just call reshape_init here? */
5749 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype)))
5750 && TREE_CODE (initial_value) == CONSTRUCTOR
5751 && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (initial_value)))
5753 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
5754 tree value = VEC_index (constructor_elt, v, 0)->value;
5756 if (TREE_CODE (value) == STRING_CST
5757 && VEC_length (constructor_elt, v) == 1)
5758 initial_value = value;
5762 failure = complete_array_type (ptype, initial_value, do_default);
5764 /* We can create the array before the element type is complete, which
5765 means that we didn't have these two bits set in the original type
5766 either. In completing the type, we are expected to propagate these
5767 bits. See also complete_type which does the same thing for arrays
5770 if (TYPE_DOMAIN (type))
5772 elt_type = TREE_TYPE (type);
5773 TYPE_NEEDS_CONSTRUCTING (type) = TYPE_NEEDS_CONSTRUCTING (elt_type);
5774 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
5775 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type);
5781 /* Return zero if something is declared to be a member of type
5782 CTYPE when in the context of CUR_TYPE. STRING is the error
5783 message to print in that case. Otherwise, quietly return 1. */
5786 member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
5788 if (ctype && ctype != cur_type)
5790 if (flags == DTOR_FLAG)
5791 error ("destructor for alien class %qT cannot be a member", ctype);
5793 error ("constructor for alien class %qT cannot be a member", ctype);
5799 /* Subroutine of `grokdeclarator'. */
5801 /* Generate errors possibly applicable for a given set of specifiers.
5802 This is for ARM $7.1.2. */
5805 bad_specifiers (tree object,
5814 error ("%qD declared as a %<virtual%> %s", object, type);
5816 error ("%qD declared as an %<inline%> %s", object, type);
5818 error ("%<const%> and %<volatile%> function specifiers on "
5819 "%qD invalid in %s declaration",
5822 error ("%q+D declared as a friend", object);
5824 && (TREE_CODE (object) == TYPE_DECL
5825 || (!TYPE_PTRFN_P (TREE_TYPE (object))
5826 && !TYPE_REFFN_P (TREE_TYPE (object))
5827 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
5828 error ("%q+D declared with an exception specification", object);
5831 /* DECL is a member function or static data member and is presently
5832 being defined. Check that the definition is taking place in a
5836 check_class_member_definition_namespace (tree decl)
5838 /* These checks only apply to member functions and static data
5840 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
5841 || TREE_CODE (decl) == VAR_DECL);
5842 /* We check for problems with specializations in pt.c in
5843 check_specialization_namespace, where we can issue better
5845 if (processing_specialization)
5847 /* There are no restrictions on the placement of
5848 explicit instantiations. */
5849 if (processing_explicit_instantiation)
5853 A member function definition that appears outside of the
5854 class definition shall appear in a namespace scope enclosing
5855 the class definition.
5859 The definition for a static data member shall appear in a
5860 namespace scope enclosing the member's class definition. */
5861 if (!is_ancestor (current_namespace, DECL_CONTEXT (decl)))
5862 pedwarn ("definition of %qD is not in namespace enclosing %qT",
5863 decl, DECL_CONTEXT (decl));
5866 /* Build a PARM_DECL for the "this" parameter. TYPE is the
5867 METHOD_TYPE for a non-static member function; QUALS are the
5868 cv-qualifiers that apply to the function. */
5871 build_this_parm (tree type, cp_cv_quals quals)
5876 cp_cv_quals this_quals;
5878 this_type = TREE_VALUE (TYPE_ARG_TYPES (type));
5879 /* The `this' parameter is implicitly `const'; it cannot be
5881 this_quals = (quals & TYPE_QUAL_RESTRICT) | TYPE_QUAL_CONST;
5882 qual_type = cp_build_qualified_type (this_type, this_quals);
5883 parm = build_artificial_parm (this_identifier, qual_type);
5884 cp_apply_type_quals_to_decl (this_quals, parm);
5888 /* CTYPE is class type, or null if non-class.
5889 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
5891 DECLARATOR is the function's name.
5892 PARMS is a chain of PARM_DECLs for the function.
5893 VIRTUALP is truthvalue of whether the function is virtual or not.
5894 FLAGS are to be passed through to `grokclassfn'.
5895 QUALS are qualifiers indicating whether the function is `const'
5897 RAISES is a list of exceptions that this function can raise.
5898 CHECK is 1 if we must find this method in CTYPE, 0 if we should
5899 not look, and -1 if we should not call `grokclassfn' at all.
5901 SFK is the kind of special function (if any) for the new function.
5903 Returns `NULL_TREE' if something goes wrong, after issuing
5904 applicable error messages. */
5907 grokfndecl (tree ctype,
5911 tree orig_declarator,
5913 enum overload_flags flags,
5920 special_function_kind sfk,
5927 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
5931 type = build_exception_variant (type, raises);
5933 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
5934 if (TREE_CODE (type) == METHOD_TYPE)
5937 parm = build_this_parm (type, quals);
5938 TREE_CHAIN (parm) = parms;
5941 DECL_ARGUMENTS (decl) = parms;
5942 /* Propagate volatile out from type to decl. */
5943 if (TYPE_VOLATILE (type))
5944 TREE_THIS_VOLATILE (decl) = 1;
5947 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
5951 ("defining explicit specialization %qD in friend declaration",
5955 tree fns = TREE_OPERAND (orig_declarator, 0);
5956 tree args = TREE_OPERAND (orig_declarator, 1);
5958 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
5960 /* Something like `template <class T> friend void f<T>()'. */
5961 error ("invalid use of template-id %qD in declaration "
5962 "of primary template",
5968 /* A friend declaration of the form friend void f<>(). Record
5969 the information in the TEMPLATE_ID_EXPR. */
5970 SET_DECL_IMPLICIT_INSTANTIATION (decl);
5972 if (TREE_CODE (fns) == COMPONENT_REF)
5974 /* Due to bison parser ickiness, we will have already looked
5975 up an operator_name or PFUNCNAME within the current class
5976 (see template_id in parse.y). If the current class contains
5977 such a name, we'll get a COMPONENT_REF here. Undo that. */
5979 gcc_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
5980 == current_class_type);
5981 fns = TREE_OPERAND (fns, 1);
5983 gcc_assert (TREE_CODE (fns) == IDENTIFIER_NODE
5984 || TREE_CODE (fns) == OVERLOAD);
5985 DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
5987 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
5988 if (TREE_PURPOSE (t)
5989 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
5991 error ("default arguments are not allowed in declaration "
5992 "of friend template specialization %qD",
5999 error ("%<inline%> is not allowed in declaration of friend "
6000 "template specialization %qD",
6007 /* If this decl has namespace scope, set that up. */
6009 set_decl_namespace (decl, in_namespace, friendp);
6011 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
6013 /* `main' and builtins have implicit 'C' linkage. */
6014 if ((MAIN_NAME_P (declarator)
6015 || (IDENTIFIER_LENGTH (declarator) > 10
6016 && IDENTIFIER_POINTER (declarator)[0] == '_'
6017 && IDENTIFIER_POINTER (declarator)[1] == '_'
6018 && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
6019 && current_lang_name == lang_name_cplusplus
6020 && ctype == NULL_TREE
6021 /* NULL_TREE means global namespace. */
6022 && DECL_CONTEXT (decl) == NULL_TREE)
6023 SET_DECL_LANGUAGE (decl, lang_c);
6025 /* Should probably propagate const out from type to decl I bet (mrs). */
6028 DECL_STATIC_FUNCTION_P (decl) = 1;
6029 DECL_CONTEXT (decl) = ctype;
6034 DECL_CONTEXT (decl) = ctype;
6036 check_class_member_definition_namespace (decl);
6039 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
6041 if (processing_template_decl)
6042 error ("cannot declare %<::main%> to be a template");
6044 error ("cannot declare %<::main%> to be inline");
6046 error ("cannot declare %<::main%> to be static");
6047 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
6050 tree oldtypeargs = TYPE_ARG_TYPES (TREE_TYPE (decl));
6052 error ("%<::main%> must return %<int%>");
6053 newtype = build_function_type (integer_type_node,
6055 TREE_TYPE (decl) = newtype;
6061 /* Members of anonymous types and local classes have no linkage; make
6062 them internal. If a typedef is made later, this will be changed. */
6063 if (ctype && (TYPE_ANONYMOUS_P (ctype)
6064 || decl_function_context (TYPE_MAIN_DECL (ctype))))
6069 /* [basic.link]: A name with no linkage (notably, the name of a class
6070 or enumeration declared in a local scope) shall not be used to
6071 declare an entity with linkage.
6073 Only check this for public decls for now. See core 319, 389. */
6074 t = no_linkage_check (TREE_TYPE (decl),
6075 /*relaxed_p=*/false);
6078 if (TYPE_ANONYMOUS_P (t))
6080 if (DECL_EXTERN_C_P (decl))
6081 /* Allow this; it's pretty common in C. */;
6084 pedwarn ("non-local function %q#D uses anonymous type",
6086 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
6087 pedwarn ("%q+#D does not refer to the unqualified "
6088 "type, so it is not used for linkage",
6093 pedwarn ("non-local function %q#D uses local type %qT", decl, t);
6097 TREE_PUBLIC (decl) = publicp;
6100 DECL_INTERFACE_KNOWN (decl) = 1;
6101 DECL_NOT_REALLY_EXTERN (decl) = 1;
6104 /* If the declaration was declared inline, mark it as such. */
6106 DECL_DECLARED_INLINE_P (decl) = 1;
6107 /* We inline functions that are explicitly declared inline, or, when
6108 the user explicitly asks us to, all functions. */
6109 if (DECL_DECLARED_INLINE_P (decl)
6110 || (flag_inline_trees == 2 && !DECL_INLINE (decl) && funcdef_flag))
6111 DECL_INLINE (decl) = 1;
6113 DECL_EXTERNAL (decl) = 1;
6114 if (quals && TREE_CODE (type) == FUNCTION_TYPE)
6116 error ("%smember function %qD cannot have cv-qualifier",
6117 (ctype ? "static " : "non-"), decl);
6118 quals = TYPE_UNQUALIFIED;
6121 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
6122 grok_op_properties (decl, /*complain=*/true);
6124 if (ctype && decl_function_context (decl))
6125 DECL_NO_STATIC_CHAIN (decl) = 1;
6128 /* Make the init_value nonzero so pushdecl knows this is not
6129 tentative. error_mark_node is replaced later with the BLOCK. */
6130 DECL_INITIAL (decl) = error_mark_node;
6132 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
6133 TREE_NOTHROW (decl) = 1;
6135 /* Caller will do the rest of this. */
6139 if (ctype != NULL_TREE)
6141 if (sfk == sfk_constructor)
6142 DECL_CONSTRUCTOR_P (decl) = 1;
6144 grokclassfn (ctype, decl, flags);
6147 decl = check_explicit_specialization (orig_declarator, decl,
6150 4 * (friendp != 0));
6151 if (decl == error_mark_node)
6156 cplus_decl_attributes (&decl, *attrlist, 0);
6157 *attrlist = NULL_TREE;
6160 if (ctype != NULL_TREE
6161 && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
6166 old_decl = check_classfn (ctype, decl,
6167 (processing_template_decl
6168 > template_class_depth (ctype))
6169 ? current_template_parms
6176 if (TREE_CODE (old_decl) == TEMPLATE_DECL)
6177 /* Because grokfndecl is always supposed to return a
6178 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
6179 here. We depend on our callers to figure out that its
6180 really a template that's being returned. */
6181 old_decl = DECL_TEMPLATE_RESULT (old_decl);
6183 if (DECL_STATIC_FUNCTION_P (old_decl)
6184 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
6185 /* Remove the `this' parm added by grokclassfn.
6186 XXX Isn't this done in start_function, too? */
6187 revert_static_member_fn (decl);
6188 if (DECL_ARTIFICIAL (old_decl))
6189 error ("definition of implicitly-declared %qD", old_decl);
6191 /* Since we've smashed OLD_DECL to its
6192 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
6193 if (TREE_CODE (decl) == TEMPLATE_DECL)
6194 decl = DECL_TEMPLATE_RESULT (decl);
6196 /* Attempt to merge the declarations. This can fail, in
6197 the case of some invalid specialization declarations. */
6198 pushed_scope = push_scope (ctype);
6199 ok = duplicate_decls (decl, old_decl, friendp);
6201 pop_scope (pushed_scope);
6204 error ("no %q#D member function declared in class %qT",
6212 if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
6215 if (ctype == NULL_TREE || check)
6219 DECL_VIRTUAL_P (decl) = 1;
6224 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
6225 the linkage that DECL will receive in the object file. */
6228 set_linkage_for_static_data_member (tree decl)
6230 /* A static data member always has static storage duration and
6231 external linkage. Note that static data members are forbidden in
6232 local classes -- the only situation in which a class has
6233 non-external linkage. */
6234 TREE_PUBLIC (decl) = 1;
6235 TREE_STATIC (decl) = 1;
6236 /* For non-template classes, static data members are always put
6237 out in exactly those files where they are defined, just as
6238 with ordinary namespace-scope variables. */
6239 if (!processing_template_decl)
6240 DECL_INTERFACE_KNOWN (decl) = 1;
6243 /* Create a VAR_DECL named NAME with the indicated TYPE.
6245 If SCOPE is non-NULL, it is the class type or namespace containing
6246 the variable. If SCOPE is NULL, the variable should is created in
6247 the innermost enclosings scope. */
6250 grokvardecl (tree type,
6252 const cp_decl_specifier_seq *declspecs,
6258 tree explicit_scope;
6260 gcc_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE);
6262 /* Compute the scope in which to place the variable, but remember
6263 whether or not that scope was explicitly specified by the user. */
6264 explicit_scope = scope;
6267 /* An explicit "extern" specifier indicates a namespace-scope
6269 if (declspecs->storage_class == sc_extern)
6270 scope = current_namespace;
6271 else if (!at_function_scope_p ())
6272 scope = current_scope ();
6276 && (/* If the variable is a namespace-scope variable declared in a
6277 template, we need DECL_LANG_SPECIFIC. */
6278 (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
6279 /* Similarly for namespace-scope variables with language linkage
6281 || (TREE_CODE (scope) == NAMESPACE_DECL
6282 && current_lang_name != lang_name_cplusplus)
6283 /* Similarly for static data members. */
6285 decl = build_lang_decl (VAR_DECL, name, type);
6287 decl = build_decl (VAR_DECL, name, type);
6289 if (explicit_scope && TREE_CODE (explicit_scope) == NAMESPACE_DECL)
6290 set_decl_namespace (decl, explicit_scope, 0);
6292 DECL_CONTEXT (decl) = scope;
6294 if (declspecs->storage_class == sc_extern)
6296 DECL_THIS_EXTERN (decl) = 1;
6297 DECL_EXTERNAL (decl) = !initialized;
6300 if (DECL_CLASS_SCOPE_P (decl))
6302 set_linkage_for_static_data_member (decl);
6303 /* This function is only called with out-of-class definitions. */
6304 DECL_EXTERNAL (decl) = 0;
6305 check_class_member_definition_namespace (decl);
6307 /* At top level, either `static' or no s.c. makes a definition
6308 (perhaps tentative), and absence of `static' makes it public. */
6309 else if (toplevel_bindings_p ())
6311 TREE_PUBLIC (decl) = (declspecs->storage_class != sc_static
6312 && (DECL_THIS_EXTERN (decl) || ! constp));
6313 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
6315 /* Not at top level, only `static' makes a static definition. */
6318 TREE_STATIC (decl) = declspecs->storage_class == sc_static;
6319 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
6322 if (declspecs->specs[(int)ds_thread])
6324 if (targetm.have_tls)
6325 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
6327 /* A mere warning is sure to result in improper semantics
6328 at runtime. Don't bother to allow this to compile. */
6329 error ("thread-local storage not supported for this target");
6332 if (TREE_PUBLIC (decl))
6334 /* [basic.link]: A name with no linkage (notably, the name of a class
6335 or enumeration declared in a local scope) shall not be used to
6336 declare an entity with linkage.
6338 Only check this for public decls for now. */
6339 tree t = no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false);
6342 if (TYPE_ANONYMOUS_P (t))
6344 if (DECL_EXTERN_C_P (decl))
6345 /* Allow this; it's pretty common in C. */
6349 /* DRs 132, 319 and 389 seem to indicate types with
6350 no linkage can only be used to declare extern "C"
6351 entities. Since it's not always an error in the
6352 ISO C++ 90 Standard, we only issue a warning. */
6353 warning (0, "non-local variable %q#D uses anonymous type",
6355 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
6356 warning (0, "%q+#D does not refer to the unqualified "
6357 "type, so it is not used for linkage",
6362 warning (0, "non-local variable %q#D uses local type %qT", decl, t);
6366 DECL_INTERFACE_KNOWN (decl) = 1;
6371 /* Create and return a canonical pointer to member function type, for
6372 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
6375 build_ptrmemfunc_type (tree type)
6379 tree unqualified_variant = NULL_TREE;
6381 if (type == error_mark_node)
6384 /* If a canonical type already exists for this type, use it. We use
6385 this method instead of type_hash_canon, because it only does a
6386 simple equality check on the list of field members. */
6388 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
6391 /* Make sure that we always have the unqualified pointer-to-member
6393 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
6395 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
6397 t = make_aggr_type (RECORD_TYPE);
6398 xref_basetypes (t, NULL_TREE);
6400 /* Let the front-end know this is a pointer to member function... */
6401 TYPE_PTRMEMFUNC_FLAG (t) = 1;
6402 /* ... and not really an aggregate. */
6403 SET_IS_AGGR_TYPE (t, 0);
6405 field = build_decl (FIELD_DECL, pfn_identifier, type);
6408 field = build_decl (FIELD_DECL, delta_identifier, delta_type_node);
6409 TREE_CHAIN (field) = fields;
6412 finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
6414 /* Zap out the name so that the back-end will give us the debugging
6415 information for this anonymous RECORD_TYPE. */
6416 TYPE_NAME (t) = NULL_TREE;
6418 /* If this is not the unqualified form of this pointer-to-member
6419 type, set the TYPE_MAIN_VARIANT for this type to be the
6420 unqualified type. Since they are actually RECORD_TYPEs that are
6421 not variants of each other, we must do this manually. */
6422 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
6424 t = build_qualified_type (t, cp_type_quals (type));
6425 TYPE_MAIN_VARIANT (t) = unqualified_variant;
6426 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
6427 TYPE_NEXT_VARIANT (unqualified_variant) = t;
6430 /* Cache this pointer-to-member type so that we can find it again
6432 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
6437 /* Create and return a pointer to data member type. */
6440 build_ptrmem_type (tree class_type, tree member_type)
6442 if (TREE_CODE (member_type) == METHOD_TYPE)
6446 arg_types = TYPE_ARG_TYPES (member_type);
6447 class_type = (cp_build_qualified_type
6449 cp_type_quals (TREE_TYPE (TREE_VALUE (arg_types)))));
6451 = build_method_type_directly (class_type,
6452 TREE_TYPE (member_type),
6453 TREE_CHAIN (arg_types));
6454 return build_ptrmemfunc_type (build_pointer_type (member_type));
6458 gcc_assert (TREE_CODE (member_type) != FUNCTION_TYPE);
6459 return build_offset_type (class_type, member_type);
6463 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
6464 Check to see that the definition is valid. Issue appropriate error
6465 messages. Return 1 if the definition is particularly bad, or 0
6469 check_static_variable_definition (tree decl, tree type)
6471 /* Motion 10 at San Diego: If a static const integral data member is
6472 initialized with an integral constant expression, the initializer
6473 may appear either in the declaration (within the class), or in
6474 the definition, but not both. If it appears in the class, the
6475 member is a member constant. The file-scope definition is always
6477 if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
6479 error ("invalid in-class initialization of static data member "
6480 "of non-integral type %qT",
6482 /* If we just return the declaration, crashes will sometimes
6483 occur. We therefore return void_type_node, as if this were a
6484 friend declaration, to cause callers to completely ignore
6485 this declaration. */
6488 else if (!CP_TYPE_CONST_P (type))
6489 error ("ISO C++ forbids in-class initialization of non-const "
6490 "static member %qD",
6492 else if (pedantic && !INTEGRAL_TYPE_P (type))
6493 pedwarn ("ISO C++ forbids initialization of member constant "
6494 "%qD of non-integral type %qT", decl, type);
6499 /* Given the SIZE (i.e., number of elements) in an array, compute an
6500 appropriate index type for the array. If non-NULL, NAME is the
6501 name of the thing being declared. */
6504 compute_array_index_type (tree name, tree size)
6509 if (error_operand_p (size))
6510 return error_mark_node;
6512 type = TREE_TYPE (size);
6513 /* The array bound must be an integer type. */
6514 if (!dependent_type_p (type) && !INTEGRAL_TYPE_P (type))
6517 error ("size of array %qD has non-integral type %qT", name, type);
6519 error ("size of array has non-integral type %qT", type);
6520 size = integer_one_node;
6521 type = TREE_TYPE (size);
6524 if (abi_version_at_least (2)
6525 /* We should only handle value dependent expressions specially. */
6526 ? value_dependent_expression_p (size)
6527 /* But for abi-1, we handled all instances in templates. This
6528 effects the manglings produced. */
6529 : processing_template_decl)
6530 return build_index_type (build_min (MINUS_EXPR, sizetype,
6531 size, integer_one_node));
6533 /* The size might be the result of a cast. */
6534 STRIP_TYPE_NOPS (size);
6536 /* It might be a const variable or enumeration constant. */
6537 size = integral_constant_value (size);
6539 /* Normally, the array-bound will be a constant. */
6540 if (TREE_CODE (size) == INTEGER_CST)
6542 /* Check to see if the array bound overflowed. Make that an
6543 error, no matter how generous we're being. */
6544 int old_flag_pedantic_errors = flag_pedantic_errors;
6545 int old_pedantic = pedantic;
6546 pedantic = flag_pedantic_errors = 1;
6547 constant_expression_warning (size);
6548 pedantic = old_pedantic;
6549 flag_pedantic_errors = old_flag_pedantic_errors;
6551 /* An array must have a positive number of elements. */
6552 if (INT_CST_LT (size, integer_zero_node))
6555 error ("size of array %qD is negative", name);
6557 error ("size of array is negative");
6558 size = integer_one_node;
6560 /* As an extension we allow zero-sized arrays. We always allow
6561 them in system headers because glibc uses them. */
6562 else if (integer_zerop (size) && pedantic && !in_system_header)
6565 pedwarn ("ISO C++ forbids zero-size array %qD", name);
6567 pedwarn ("ISO C++ forbids zero-size array");
6570 else if (TREE_CONSTANT (size))
6572 /* `(int) &fn' is not a valid array bound. */
6574 error ("size of array %qD is not an integral constant-expression",
6577 error ("size of array is not an integral constant-expression");
6578 size = integer_one_node;
6583 pedwarn ("ISO C++ forbids variable-size array %qD", name);
6585 pedwarn ("ISO C++ forbids variable-size array");
6588 if (processing_template_decl && !TREE_CONSTANT (size))
6589 /* A variable sized array. */
6590 itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node);
6593 HOST_WIDE_INT saved_processing_template_decl;
6595 /* Compute the index of the largest element in the array. It is
6596 one less than the number of elements in the array. We save
6597 and restore PROCESSING_TEMPLATE_DECL so that computations in
6598 cp_build_binary_op will be appropriately folded. */
6599 saved_processing_template_decl = processing_template_decl;
6600 processing_template_decl = 0;
6601 itype = cp_build_binary_op (MINUS_EXPR,
6602 cp_convert (ssizetype, size),
6603 cp_convert (ssizetype, integer_one_node));
6604 itype = fold (itype);
6605 processing_template_decl = saved_processing_template_decl;
6607 if (!TREE_CONSTANT (itype))
6608 /* A variable sized array. */
6609 itype = variable_size (itype);
6610 /* Make sure that there was no overflow when creating to a signed
6611 index type. (For example, on a 32-bit machine, an array with
6612 size 2^32 - 1 is too big.) */
6613 else if (TREE_CODE (itype) == INTEGER_CST
6614 && TREE_OVERFLOW (itype))
6616 error ("overflow in array dimension");
6617 TREE_OVERFLOW (itype) = 0;
6621 /* Create and return the appropriate index type. */
6622 return build_index_type (itype);
6625 /* Returns the scope (if any) in which the entity declared by
6626 DECLARATOR will be located. If the entity was declared with an
6627 unqualified name, NULL_TREE is returned. */
6630 get_scope_of_declarator (const cp_declarator *declarator)
6632 while (declarator && declarator->kind != cdk_id)
6633 declarator = declarator->declarator;
6635 /* If the declarator-id is a SCOPE_REF, the scope in which the
6636 declaration occurs is the first operand. */
6638 && declarator->u.id.qualifying_scope)
6639 return declarator->u.id.qualifying_scope;
6641 /* Otherwise, the declarator is not a qualified name; the entity will
6642 be declared in the current scope. */
6646 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
6647 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
6651 create_array_type_for_decl (tree name, tree type, tree size)
6653 tree itype = NULL_TREE;
6654 const char* error_msg;
6656 /* If things have already gone awry, bail now. */
6657 if (type == error_mark_node || size == error_mark_node)
6658 return error_mark_node;
6660 /* Assume that everything will go OK. */
6663 /* There are some types which cannot be array elements. */
6664 switch (TREE_CODE (type))
6667 error_msg = "array of void";
6671 error_msg = "array of functions";
6674 case REFERENCE_TYPE:
6675 error_msg = "array of references";
6679 error_msg = "array of function members";
6686 /* If something went wrong, issue an error-message and return. */
6690 error ("declaration of %qD as %s", name, error_msg);
6692 error ("creating %s", error_msg);
6694 return error_mark_node;
6699 The constant expressions that specify the bounds of the arrays
6700 can be omitted only for the first member of the sequence. */
6701 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
6704 error ("declaration of %qD as multidimensional array must "
6705 "have bounds for all dimensions except the first",
6708 error ("multidimensional array must have bounds for all "
6709 "dimensions except the first");
6711 return error_mark_node;
6714 /* Figure out the index type for the array. */
6716 itype = compute_array_index_type (name, size);
6719 T is called the array element type; this type shall not be [...] an
6720 abstract class type. */
6721 abstract_virtuals_error (name, type);
6723 return build_cplus_array_type (type, itype);
6726 /* Check that it's OK to declare a function with the indicated TYPE.
6727 SFK indicates the kind of special function (if any) that this
6728 function is. OPTYPE is the type given in a conversion operator
6729 declaration, or the class type for a constructor/destructor.
6730 Returns the actual return type of the function; that
6731 may be different than TYPE if an error occurs, or for certain
6732 special functions. */
6735 check_special_function_return_type (special_function_kind sfk,
6741 case sfk_constructor:
6743 error ("return type specification for constructor invalid");
6745 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
6746 type = build_pointer_type (optype);
6748 type = void_type_node;
6751 case sfk_destructor:
6753 error ("return type specification for destructor invalid");
6754 /* We can't use the proper return type here because we run into
6755 problems with ambiguous bases and covariant returns.
6756 Java classes are left unchanged because (void *) isn't a valid
6757 Java type, and we don't want to change the Java ABI. */
6758 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
6759 type = build_pointer_type (void_type_node);
6761 type = void_type_node;
6764 case sfk_conversion:
6765 if (type && !same_type_p (type, optype))
6766 error ("operator %qT declared to return %qT", optype, type);
6768 pedwarn ("return type specified for %<operator %T%>", optype);
6779 /* A variable or data member (whose unqualified name is IDENTIFIER)
6780 has been declared with the indicated TYPE. If the TYPE is not
6781 acceptable, issue an error message and return a type to use for
6782 error-recovery purposes. */
6785 check_var_type (tree identifier, tree type)
6787 if (VOID_TYPE_P (type))
6790 error ("unnamed variable or field declared void");
6791 else if (TREE_CODE (identifier) == IDENTIFIER_NODE)
6793 gcc_assert (!IDENTIFIER_OPNAME_P (identifier));
6794 error ("variable or field %qE declared void", identifier);
6797 error ("variable or field declared void");
6798 type = integer_type_node;
6804 /* Given declspecs and a declarator (abstract or otherwise), determine
6805 the name and type of the object declared and construct a DECL node
6808 DECLSPECS is a chain of tree_list nodes whose value fields
6809 are the storage classes and type specifiers.
6811 DECL_CONTEXT says which syntactic context this declaration is in:
6812 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
6813 FUNCDEF for a function definition. Like NORMAL but a few different
6814 error messages in each case. Return value may be zero meaning
6815 this definition is too screwy to try to parse.
6816 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
6817 handle member functions (which have FIELD context).
6818 Return value may be zero meaning this definition is too screwy to
6820 PARM for a parameter declaration (either within a function prototype
6821 or before a function body). Make a PARM_DECL, or return void_type_node.
6822 CATCHPARM for a parameter declaration before a catch clause.
6823 TYPENAME if for a typename (in a cast or sizeof).
6824 Don't make a DECL node; just return the ..._TYPE node.
6825 FIELD for a struct or union field; make a FIELD_DECL.
6826 BITFIELD for a field with specified width.
6827 INITIALIZED is 1 if the decl has an initializer.
6829 ATTRLIST is a pointer to the list of attributes, which may be NULL
6830 if there are none; *ATTRLIST may be modified if attributes from inside
6831 the declarator should be applied to the declaration.
6833 When this function is called, scoping variables (such as
6834 CURRENT_CLASS_TYPE) should reflect the scope in which the
6835 declaration occurs, not the scope in which the new declaration will
6836 be placed. For example, on:
6840 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
6843 Returns a DECL (if a declarator is present), a TYPE (if there is no
6844 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
6848 grokdeclarator (const cp_declarator *declarator,
6849 const cp_decl_specifier_seq *declspecs,
6850 enum decl_context decl_context,
6854 tree type = NULL_TREE;
6856 int virtualp, explicitp, friendp, inlinep, staticp;
6857 int explicit_int = 0;
6858 int explicit_char = 0;
6859 int defaulted_int = 0;
6860 tree dependent_name = NULL_TREE;
6862 tree typedef_decl = NULL_TREE;
6863 const char *name = NULL;
6864 tree typedef_type = NULL_TREE;
6865 /* True if this declarator is a function definition. */
6866 bool funcdef_flag = false;
6867 cp_declarator_kind innermost_code = cdk_error;
6870 /* See the code below that used this. */
6871 tree decl_attr = NULL_TREE;
6874 /* Keep track of what sort of function is being processed
6875 so that we can warn about default return values, or explicit
6876 return values which do not match prescribed defaults. */
6877 special_function_kind sfk = sfk_none;
6879 tree dname = NULL_TREE;
6880 tree ctor_return_type = NULL_TREE;
6881 enum overload_flags flags = NO_SPECIAL;
6882 /* cv-qualifiers that apply to the declarator, for a declaration of
6883 a member function. */
6884 cp_cv_quals memfn_quals = TYPE_UNQUALIFIED;
6885 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
6887 tree raises = NULL_TREE;
6888 int template_count = 0;
6889 tree returned_attrs = NULL_TREE;
6890 tree parms = NULL_TREE;
6891 const cp_declarator *id_declarator;
6892 /* The unqualified name of the declarator; either an
6893 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
6894 tree unqualified_id;
6895 /* The class type, if any, in which this entity is located,
6896 or NULL_TREE if none. Note that this value may be different from
6897 the current class type; for example if an attempt is made to declare
6898 "A::f" inside "B", this value will be "A". */
6899 tree ctype = current_class_type;
6900 /* The NAMESPACE_DECL for the namespace in which this entity is
6901 located. If an unqualified name is used to declare the entity,
6902 this value will be NULL_TREE, even if the entity is located at
6904 tree in_namespace = NULL_TREE;
6905 cp_storage_class storage_class;
6906 bool unsigned_p, signed_p, short_p, long_p, thread_p;
6907 bool type_was_error_mark_node = false;
6909 signed_p = declspecs->specs[(int)ds_signed];
6910 unsigned_p = declspecs->specs[(int)ds_unsigned];
6911 short_p = declspecs->specs[(int)ds_short];
6912 long_p = declspecs->specs[(int)ds_long];
6913 longlong = declspecs->specs[(int)ds_long] >= 2;
6914 thread_p = declspecs->specs[(int)ds_thread];
6916 if (decl_context == FUNCDEF)
6917 funcdef_flag = true, decl_context = NORMAL;
6918 else if (decl_context == MEMFUNCDEF)
6919 funcdef_flag = true, decl_context = FIELD;
6920 else if (decl_context == BITFIELD)
6921 bitfield = 1, decl_context = FIELD;
6923 /* Look inside a declarator for the name being declared
6924 and get it as a string, for an error message. */
6925 for (id_declarator = declarator;
6927 id_declarator = id_declarator->declarator)
6929 if (id_declarator->kind != cdk_id)
6930 innermost_code = id_declarator->kind;
6932 switch (id_declarator->kind)
6935 if (id_declarator->declarator
6936 && id_declarator->declarator->kind == cdk_id)
6938 sfk = id_declarator->declarator->u.id.sfk;
6939 if (sfk == sfk_destructor)
6946 tree qualifying_scope = id_declarator->u.id.qualifying_scope;
6947 tree decl = id_declarator->u.id.unqualified_name;
6950 if (qualifying_scope)
6952 if (TYPE_P (qualifying_scope))
6954 ctype = qualifying_scope;
6955 if (innermost_code != cdk_function
6956 && current_class_type
6957 && !UNIQUELY_DERIVED_FROM_P (ctype,
6958 current_class_type))
6960 error ("type %qT is not derived from type %qT",
6961 ctype, current_class_type);
6962 return error_mark_node;
6965 else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL)
6966 in_namespace = qualifying_scope;
6968 switch (TREE_CODE (decl))
6974 if (innermost_code != cdk_function)
6976 error ("declaration of %qD as non-function", decl);
6977 return error_mark_node;
6979 else if (!qualifying_scope
6980 && !(current_class_type && at_class_scope_p ()))
6982 error ("declaration of %qD as non-member", decl);
6983 return error_mark_node;
6986 type = TREE_OPERAND (decl, 0);
6987 name = IDENTIFIER_POINTER (constructor_name (type));
6992 case TEMPLATE_ID_EXPR:
6994 tree fns = TREE_OPERAND (decl, 0);
6997 if (TREE_CODE (dname) == COMPONENT_REF)
6998 dname = TREE_OPERAND (dname, 1);
6999 if (TREE_CODE (dname) != IDENTIFIER_NODE)
7001 gcc_assert (is_overloaded_fn (dname));
7002 dname = DECL_NAME (get_first_fn (dname));
7007 case IDENTIFIER_NODE:
7008 if (TREE_CODE (decl) == IDENTIFIER_NODE)
7011 if (C_IS_RESERVED_WORD (dname))
7013 error ("declarator-id missing; using reserved word %qD",
7015 name = IDENTIFIER_POINTER (dname);
7017 else if (!IDENTIFIER_TYPENAME_P (dname))
7018 name = IDENTIFIER_POINTER (dname);
7021 gcc_assert (flags == NO_SPECIAL);
7022 flags = TYPENAME_FLAG;
7023 ctor_return_type = TREE_TYPE (dname);
7024 sfk = sfk_conversion;
7025 if (is_typename_at_global_scope (dname))
7026 name = IDENTIFIER_POINTER (dname);
7028 name = "<invalid operator>";
7044 return error_mark_node;
7050 if (id_declarator->kind == cdk_id)
7056 The declarator in a function-definition shall have the form
7057 D1 ( parameter-declaration-clause) ... */
7058 if (funcdef_flag && innermost_code != cdk_function)
7060 error ("function definition does not declare parameters");
7061 return error_mark_node;
7064 if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
7065 && innermost_code != cdk_function
7066 && ! (ctype && !declspecs->any_specifiers_p))
7068 error ("declaration of %qD as non-function", dname);
7069 return error_mark_node;
7072 /* Anything declared one level down from the top level
7073 must be one of the parameters of a function
7074 (because the body is at least two levels down). */
7076 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
7077 by not allowing C++ class definitions to specify their parameters
7078 with xdecls (must be spec.d in the parmlist).
7080 Since we now wait to push a class scope until we are sure that
7081 we are in a legitimate method context, we must set oldcname
7082 explicitly (since current_class_name is not yet alive).
7084 We also want to avoid calling this a PARM if it is in a namespace. */
7086 if (decl_context == NORMAL && !toplevel_bindings_p ())
7088 struct cp_binding_level *b = current_binding_level;
7089 current_binding_level = b->level_chain;
7090 if (current_binding_level != 0 && toplevel_bindings_p ())
7091 decl_context = PARM;
7092 current_binding_level = b;
7096 name = decl_context == PARM ? "parameter" : "type name";
7098 /* If there were multiple types specified in the decl-specifier-seq,
7099 issue an error message. */
7100 if (declspecs->multiple_types_p)
7101 error ("two or more data types in declaration of %qs", name);
7102 /* Extract the basic type from the decl-specifier-seq. */
7103 type = declspecs->type;
7104 if (type == error_mark_node)
7107 type_was_error_mark_node = true;
7109 /* If the entire declaration is itself tagged as deprecated then
7110 suppress reports of deprecated items. */
7111 if (type && TREE_DEPRECATED (type)
7112 && deprecated_state != DEPRECATED_SUPPRESS)
7113 warn_deprecated_use (type);
7114 if (type && TREE_CODE (type) == TYPE_DECL)
7116 typedef_decl = type;
7117 type = TREE_TYPE (typedef_decl);
7119 /* No type at all: default to `int', and set DEFAULTED_INT
7120 because it was not a user-defined typedef. */
7121 if (type == NULL_TREE && (signed_p || unsigned_p || long_p || short_p))
7123 /* These imply 'int'. */
7124 type = integer_type_node;
7128 explicit_int = declspecs->explicit_int_p;
7129 explicit_char = declspecs->explicit_char_p;
7132 /* See the code below that used this. */
7134 decl_attr = DECL_ATTRIBUTES (typedef_decl);
7136 typedef_type = type;
7139 if (sfk != sfk_conversion)
7140 ctor_return_type = ctype;
7142 if (sfk != sfk_none)
7143 type = check_special_function_return_type (sfk, type,
7145 else if (type == NULL_TREE)
7151 /* We handle `main' specially here, because 'main () { }' is so
7152 common. With no options, it is allowed. With -Wreturn-type,
7153 it is a warning. It is only an error with -pedantic-errors. */
7154 is_main = (funcdef_flag
7155 && dname && MAIN_NAME_P (dname)
7156 && ctype == NULL_TREE
7157 && in_namespace == NULL_TREE
7158 && current_namespace == global_namespace);
7160 if (type_was_error_mark_node)
7161 /* We've already issued an error, don't complain more. */;
7162 else if (in_system_header || flag_ms_extensions)
7163 /* Allow it, sigh. */;
7164 else if (pedantic || ! is_main)
7165 pedwarn ("ISO C++ forbids declaration of %qs with no type", name);
7166 else if (warn_return_type)
7167 warning (0, "ISO C++ forbids declaration of %qs with no type", name);
7169 type = integer_type_node;
7174 /* Now process the modifiers that were specified
7175 and check for invalid combinations. */
7177 /* Long double is a special combination. */
7178 if (long_p && !longlong && TYPE_MAIN_VARIANT (type) == double_type_node)
7181 type = build_qualified_type (long_double_type_node,
7182 cp_type_quals (type));
7185 /* Check all other uses of type modifiers. */
7187 if (unsigned_p || signed_p || long_p || short_p)
7191 if ((signed_p || unsigned_p) && TREE_CODE (type) != INTEGER_TYPE)
7192 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
7193 else if (signed_p && unsigned_p)
7194 error ("%<signed%> and %<unsigned%> specified together for %qs", name);
7195 else if (longlong && TREE_CODE (type) != INTEGER_TYPE)
7196 error ("%<long long%> invalid for %qs", name);
7197 else if (long_p && TREE_CODE (type) == REAL_TYPE)
7198 error ("%<long%> invalid for %qs", name);
7199 else if (short_p && TREE_CODE (type) == REAL_TYPE)
7200 error ("%<short%> invalid for %qs", name);
7201 else if ((long_p || short_p) && explicit_char)
7202 error ("%<long%> or %<short%> specified with char for %qs", name);
7203 else if (long_p && short_p)
7204 error ("%<long%> and %<short%> specified together for %qs", name);
7208 if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
7210 pedwarn ("long, short, signed or unsigned used invalidly for %qs",
7212 if (flag_pedantic_errors)
7217 /* Discard the type modifiers if they are invalid. */
7228 /* Decide whether an integer type is signed or not.
7229 Optionally treat bitfields as signed by default. */
7233 It is implementation-defined whether a plain (neither
7234 explicitly signed or unsigned) char, short, int, or long
7235 bit-field is signed or unsigned.
7237 Naturally, we extend this to long long as well. Note that
7238 this does not include wchar_t. */
7239 || (bitfield && !flag_signed_bitfields
7241 /* A typedef for plain `int' without `signed' can be
7242 controlled just like plain `int', but a typedef for
7243 `signed int' cannot be so controlled. */
7245 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
7246 && TREE_CODE (type) == INTEGER_TYPE
7247 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
7250 type = long_long_unsigned_type_node;
7252 type = long_unsigned_type_node;
7254 type = short_unsigned_type_node;
7255 else if (type == char_type_node)
7256 type = unsigned_char_type_node;
7257 else if (typedef_decl)
7258 type = c_common_unsigned_type (type);
7260 type = unsigned_type_node;
7262 else if (signed_p && type == char_type_node)
7263 type = signed_char_type_node;
7265 type = long_long_integer_type_node;
7267 type = long_integer_type_node;
7269 type = short_integer_type_node;
7271 if (declspecs->specs[(int)ds_complex])
7273 if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
7274 error ("complex invalid for %qs", name);
7275 /* If we just have "complex", it is equivalent to
7276 "complex double", but if any modifiers at all are specified it is
7277 the complex form of TYPE. E.g, "complex short" is
7278 "complex short int". */
7280 else if (defaulted_int && ! longlong
7281 && ! (long_p || short_p || signed_p || unsigned_p))
7282 type = complex_double_type_node;
7283 else if (type == integer_type_node)
7284 type = complex_integer_type_node;
7285 else if (type == float_type_node)
7286 type = complex_float_type_node;
7287 else if (type == double_type_node)
7288 type = complex_double_type_node;
7289 else if (type == long_double_type_node)
7290 type = complex_long_double_type_node;
7292 type = build_complex_type (type);
7295 type_quals = TYPE_UNQUALIFIED;
7296 if (declspecs->specs[(int)ds_const])
7297 type_quals |= TYPE_QUAL_CONST;
7298 if (declspecs->specs[(int)ds_volatile])
7299 type_quals |= TYPE_QUAL_VOLATILE;
7300 if (declspecs->specs[(int)ds_restrict])
7301 type_quals |= TYPE_QUAL_RESTRICT;
7302 if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
7303 error ("qualifiers are not allowed on declaration of %<operator %T%>",
7306 if (TREE_CODE (type) == FUNCTION_TYPE
7307 && type_quals != TYPE_UNQUALIFIED)
7309 /* This was an error in C++98 (cv-qualifiers cannot be added to
7310 a function type), but DR 295 makes the code well-formed by
7311 dropping the extra qualifiers. */
7314 tree bad_type = build_qualified_type (type, type_quals);
7315 pedwarn ("ignoring %qV qualifiers added to function type %qT",
7318 type_quals = TYPE_UNQUALIFIED;
7320 type_quals |= cp_type_quals (type);
7321 type = cp_build_qualified_type_real
7322 (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
7323 ? tf_ignore_bad_quals : 0) | tf_warning_or_error));
7324 /* We might have ignored or rejected some of the qualifiers. */
7325 type_quals = cp_type_quals (type);
7328 inlinep = !! declspecs->specs[(int)ds_inline];
7329 virtualp = !! declspecs->specs[(int)ds_virtual];
7330 explicitp = !! declspecs->specs[(int)ds_explicit];
7332 storage_class = declspecs->storage_class;
7333 if (storage_class == sc_static)
7334 staticp = 1 + (decl_context == FIELD);
7336 if (virtualp && staticp == 2)
7338 error ("member %qD cannot be declared both virtual and static", dname);
7339 storage_class = sc_none;
7342 friendp = !! declspecs->specs[(int)ds_friend];
7344 if (dependent_name && !friendp)
7346 error ("%<%T::%D%> is not a valid declarator", ctype, dependent_name);
7347 return error_mark_node;
7350 /* Issue errors about use of storage classes for parameters. */
7351 if (decl_context == PARM)
7353 if (declspecs->specs[(int)ds_typedef])
7354 error ("typedef declaration invalid in parameter declaration");
7355 else if (storage_class == sc_static
7356 || storage_class == sc_extern
7358 error ("storage class specifiers invalid in parameter declarations");
7361 /* Give error if `virtual' is used outside of class declaration. */
7363 && (current_class_name == NULL_TREE || decl_context != FIELD))
7365 error ("virtual outside class declaration");
7369 /* Static anonymous unions are dealt with here. */
7370 if (staticp && decl_context == TYPENAME
7372 && ANON_AGGR_TYPE_P (declspecs->type))
7373 decl_context = FIELD;
7375 /* Warn about storage classes that are invalid for certain
7376 kinds of declarations (parameters, typenames, etc.). */
7377 if (declspecs->multiple_storage_classes_p)
7379 error ("multiple storage classes in declaration of %qs", name);
7380 storage_class = sc_none;
7384 && storage_class != sc_extern
7385 && storage_class != sc_static)
7386 || declspecs->specs[(int)ds_typedef]))
7388 error ("multiple storage classes in declaration of %qs", name);
7391 else if (decl_context != NORMAL
7392 && ((storage_class != sc_none
7393 && storage_class != sc_mutable)
7396 if ((decl_context == PARM || decl_context == CATCHPARM)
7397 && (storage_class == sc_register
7398 || storage_class == sc_auto))
7400 else if (declspecs->specs[(int)ds_typedef])
7402 else if (decl_context == FIELD
7403 /* C++ allows static class elements. */
7404 && storage_class == sc_static)
7405 /* C++ also allows inlines and signed and unsigned elements,
7406 but in those cases we don't come in here. */
7410 if (decl_context == FIELD)
7411 error ("storage class specified for %qs", name);
7414 if (decl_context == PARM || decl_context == CATCHPARM)
7415 error ("storage class specified for parameter %qs", name);
7417 error ("storage class specified for typename");
7419 if (storage_class == sc_register
7420 || storage_class == sc_auto
7421 || storage_class == sc_extern
7423 storage_class = sc_none;
7426 else if (storage_class == sc_extern && initialized
7429 if (toplevel_bindings_p ())
7431 /* It's common practice (and completely valid) to have a const
7432 be initialized and declared extern. */
7433 if (!(type_quals & TYPE_QUAL_CONST))
7434 warning (0, "%qs initialized and declared %<extern%>", name);
7437 error ("%qs has both %<extern%> and initializer", name);
7439 else if (storage_class == sc_extern && funcdef_flag
7440 && ! toplevel_bindings_p ())
7441 error ("nested function %qs declared %<extern%>", name);
7442 else if (toplevel_bindings_p ())
7444 if (storage_class == sc_auto)
7445 error ("top-level declaration of %qs specifies %<auto%>", name);
7448 && storage_class != sc_extern
7449 && storage_class != sc_static)
7451 error ("function-scope %qs implicitly auto and declared %<__thread%>",
7456 if (storage_class && friendp)
7457 error ("storage class specifiers invalid in friend function declarations");
7460 unqualified_id = NULL_TREE;
7463 unqualified_id = id_declarator->u.id.unqualified_name;
7464 switch (TREE_CODE (unqualified_id))
7468 = constructor_name (TREE_OPERAND (unqualified_id, 0));
7471 case IDENTIFIER_NODE:
7472 case TEMPLATE_ID_EXPR:
7480 /* Determine the type of the entity declared by recurring on the
7482 for (; declarator; declarator = declarator->declarator)
7484 const cp_declarator *inner_declarator;
7487 if (type == error_mark_node)
7488 return error_mark_node;
7490 attrs = declarator->attributes;
7496 if (declarator == NULL || declarator->kind == cdk_id)
7497 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
7498 if (declarator->kind == cdk_function)
7499 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
7500 if (declarator->kind == cdk_array)
7501 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
7502 returned_attrs = decl_attributes (&type,
7503 chainon (returned_attrs, attrs),
7507 if (declarator->kind == cdk_id)
7510 inner_declarator = declarator->declarator;
7512 switch (declarator->kind)
7515 type = create_array_type_for_decl (dname, type,
7516 declarator->u.array.bounds);
7524 /* Declaring a function type.
7525 Make sure we have a valid type for the function to return. */
7527 /* We now know that the TYPE_QUALS don't apply to the
7528 decl, but to its return type. */
7529 type_quals = TYPE_UNQUALIFIED;
7531 /* Warn about some types functions can't return. */
7533 if (TREE_CODE (type) == FUNCTION_TYPE)
7535 error ("%qs declared as function returning a function", name);
7536 type = integer_type_node;
7538 if (TREE_CODE (type) == ARRAY_TYPE)
7540 error ("%qs declared as function returning an array", name);
7541 type = integer_type_node;
7544 /* Pick up type qualifiers which should be applied to `this'. */
7545 memfn_quals = declarator->u.function.qualifiers;
7547 /* Pick up the exception specifications. */
7548 raises = declarator->u.function.exception_specification;
7550 /* Say it's a definition only for the CALL_EXPR
7551 closest to the identifier. */
7552 funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id;
7554 if (ctype == NULL_TREE
7555 && decl_context == FIELD
7557 && (friendp == 0 || dname == current_class_name))
7558 ctype = current_class_type;
7560 if (ctype && (sfk == sfk_constructor
7561 || sfk == sfk_destructor))
7563 /* We are within a class's scope. If our declarator name
7564 is the same as the class name, and we are defining
7565 a function, then it is a constructor/destructor, and
7566 therefore returns a void type. */
7568 /* ISO C++ 12.4/2. A destructor may not be declared
7569 const or volatile. A destructor may not be
7572 ISO C++ 12.1. A constructor may not be declared
7573 const or volatile. A constructor may not be
7574 virtual. A constructor may not be static. */
7576 error ((flags == DTOR_FLAG)
7577 ? "destructor cannot be static member function"
7578 : "constructor cannot be static member function");
7581 error ((flags == DTOR_FLAG)
7582 ? "destructors may not be cv-qualified"
7583 : "constructors may not be cv-qualified");
7584 memfn_quals = TYPE_UNQUALIFIED;
7587 if (decl_context == FIELD
7588 && !member_function_or_else (ctype,
7591 return error_mark_node;
7593 if (flags != DTOR_FLAG)
7595 /* It's a constructor. */
7600 pedwarn ("constructors cannot be declared virtual");
7603 if (decl_context == FIELD
7604 && sfk != sfk_constructor)
7605 return error_mark_node;
7607 if (decl_context == FIELD)
7613 error ("can't initialize friend function %qs", name);
7616 /* Cannot be both friend and virtual. */
7617 error ("virtual functions cannot be friends");
7620 if (decl_context == NORMAL)
7621 error ("friend declaration not in class definition");
7622 if (current_function_decl && funcdef_flag)
7623 error ("can't define friend function %qs in a local "
7628 arg_types = grokparms (declarator->u.function.parameters,
7631 if (inner_declarator
7632 && inner_declarator->kind == cdk_id
7633 && inner_declarator->u.id.sfk == sfk_destructor
7634 && arg_types != void_list_node)
7636 error ("destructors may not have parameters");
7637 arg_types = void_list_node;
7641 type = build_function_type (type, arg_types);
7648 /* Filter out pointers-to-references and references-to-references.
7649 We can get these if a TYPE_DECL is used. */
7651 if (TREE_CODE (type) == REFERENCE_TYPE)
7653 error (declarator->kind == cdk_reference
7654 ? "cannot declare reference to %q#T"
7655 : "cannot declare pointer to %q#T", type);
7656 type = TREE_TYPE (type);
7658 else if (VOID_TYPE_P (type))
7660 if (declarator->kind == cdk_reference)
7661 error ("cannot declare reference to %q#T", type);
7662 else if (declarator->kind == cdk_ptrmem)
7663 error ("cannot declare pointer to %q#T member", type);
7666 /* We now know that the TYPE_QUALS don't apply to the decl,
7667 but to the target of the pointer. */
7668 type_quals = TYPE_UNQUALIFIED;
7670 if (declarator->kind == cdk_ptrmem
7671 && (TREE_CODE (type) == FUNCTION_TYPE || memfn_quals))
7673 memfn_quals |= cp_type_quals (type);
7674 type = build_memfn_type (type,
7675 declarator->u.pointer.class_type,
7677 memfn_quals = TYPE_UNQUALIFIED;
7680 if (declarator->kind == cdk_reference)
7682 if (!VOID_TYPE_P (type))
7683 type = build_reference_type (type);
7685 else if (TREE_CODE (type) == METHOD_TYPE)
7686 type = build_ptrmemfunc_type (build_pointer_type (type));
7687 else if (declarator->kind == cdk_ptrmem)
7689 gcc_assert (TREE_CODE (declarator->u.pointer.class_type)
7691 if (declarator->u.pointer.class_type == error_mark_node)
7692 /* We will already have complained. */
7693 type = error_mark_node;
7695 type = build_ptrmem_type (declarator->u.pointer.class_type,
7699 type = build_pointer_type (type);
7701 /* Process a list of type modifier keywords (such as
7702 const or volatile) that were given inside the `*' or `&'. */
7704 if (declarator->u.pointer.qualifiers)
7707 = cp_build_qualified_type (type,
7708 declarator->u.pointer.qualifiers);
7709 type_quals = cp_type_quals (type);
7722 if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR
7723 && TREE_CODE (type) != FUNCTION_TYPE
7724 && TREE_CODE (type) != METHOD_TYPE)
7726 error ("template-id %qD used as a declarator",
7728 unqualified_id = dname;
7731 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
7732 qualified with a class-name, turn it into a METHOD_TYPE, unless
7733 we know that the function is static. We take advantage of this
7734 opportunity to do other processing that pertains to entities
7735 explicitly declared to be class members. Note that if DECLARATOR
7736 is non-NULL, we know it is a cdk_id declarator; otherwise, we
7737 would not have exited the loop above. */
7739 && declarator->u.id.qualifying_scope
7740 && TYPE_P (declarator->u.id.qualifying_scope))
7744 ctype = declarator->u.id.qualifying_scope;
7745 ctype = TYPE_MAIN_VARIANT (ctype);
7747 while (t != NULL_TREE && CLASS_TYPE_P (t))
7749 /* You're supposed to have one `template <...>' for every
7750 template class, but you don't need one for a full
7751 specialization. For example:
7753 template <class T> struct S{};
7754 template <> struct S<int> { void f(); };
7755 void S<int>::f () {}
7757 is correct; there shouldn't be a `template <>' for the
7758 definition of `S<int>::f'. */
7759 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t)
7760 && !any_dependent_template_arguments_p (CLASSTYPE_TI_ARGS (t)))
7761 /* T is an explicit (not partial) specialization. All
7762 containing classes must therefore also be explicitly
7765 if ((CLASSTYPE_USE_TEMPLATE (t) || CLASSTYPE_IS_TEMPLATE (t))
7766 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
7767 template_count += 1;
7769 t = TYPE_MAIN_DECL (t);
7770 t = DECL_CONTEXT (t);
7773 if (ctype == current_class_type)
7776 pedwarn ("member functions are implicitly friends of their class");
7778 pedwarn ("extra qualification %<%T::%> on member %qs",
7781 else if (/* If the qualifying type is already complete, then we
7782 can skip the following checks. */
7783 !COMPLETE_TYPE_P (ctype)
7784 && (/* If the function is being defined, then
7785 qualifying type must certainly be complete. */
7787 /* A friend declaration of "T::f" is OK, even if
7788 "T" is a template parameter. But, if this
7789 function is not a friend, the qualifying type
7791 || (!friendp && !CLASS_TYPE_P (ctype))
7792 /* For a declaration, the type need not be
7793 complete, if either it is dependent (since there
7794 is no meaningful definition of complete in that
7795 case) or the qualifying class is currently being
7797 || !(dependent_type_p (ctype)
7798 || currently_open_class (ctype)))
7799 /* Check that the qualifying type is complete. */
7800 && !complete_type_or_else (ctype, NULL_TREE))
7801 return error_mark_node;
7802 else if (TREE_CODE (type) == FUNCTION_TYPE)
7804 tree sname = declarator->u.id.unqualified_name;
7806 if (current_class_type
7807 && (!friendp || funcdef_flag))
7810 ? "cannot define member function %<%T::%s%> within %<%T%>"
7811 : "cannot declare member function %<%T::%s%> within %<%T%>",
7812 ctype, name, current_class_type);
7813 return error_mark_node;
7816 if (TREE_CODE (sname) == IDENTIFIER_NODE
7817 && NEW_DELETE_OPNAME_P (sname))
7818 /* Overloaded operator new and operator delete
7819 are always static functions. */
7822 type = build_memfn_type (type, ctype, memfn_quals);
7824 else if (declspecs->specs[(int)ds_typedef]
7825 && current_class_type)
7827 error ("cannot declare member %<%T::%s%> within %qT",
7828 ctype, name, current_class_type);
7829 return error_mark_node;
7833 /* Now TYPE has the actual type. */
7838 *attrlist = chainon (returned_attrs, *attrlist);
7840 attrlist = &returned_attrs;
7843 /* Did array size calculations overflow? */
7845 if (TREE_CODE (type) == ARRAY_TYPE
7846 && COMPLETE_TYPE_P (type)
7847 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
7848 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
7850 error ("size of array %qs is too large", name);
7851 /* If we proceed with the array type as it is, we'll eventually
7852 crash in tree_low_cst(). */
7853 type = error_mark_node;
7856 if ((decl_context == FIELD || decl_context == PARM)
7857 && !processing_template_decl
7858 && variably_modified_type_p (type, NULL_TREE))
7860 if (decl_context == FIELD)
7861 error ("data member may not have variably modified type %qT", type);
7863 error ("parameter may not have variably modified type %qT", type);
7864 type = error_mark_node;
7867 if (explicitp == 1 || (explicitp && friendp))
7869 /* [dcl.fct.spec] The explicit specifier shall only be used in
7870 declarations of constructors within a class definition. */
7871 error ("only declarations of constructors can be %<explicit%>");
7875 if (storage_class == sc_mutable)
7877 if (decl_context != FIELD || friendp)
7879 error ("non-member %qs cannot be declared %<mutable%>", name);
7880 storage_class = sc_none;
7882 else if (decl_context == TYPENAME || declspecs->specs[(int)ds_typedef])
7884 error ("non-object member %qs cannot be declared %<mutable%>", name);
7885 storage_class = sc_none;
7887 else if (TREE_CODE (type) == FUNCTION_TYPE
7888 || TREE_CODE (type) == METHOD_TYPE)
7890 error ("function %qs cannot be declared %<mutable%>", name);
7891 storage_class = sc_none;
7895 error ("static %qs cannot be declared %<mutable%>", name);
7896 storage_class = sc_none;
7898 else if (type_quals & TYPE_QUAL_CONST)
7900 error ("const %qs cannot be declared %<mutable%>", name);
7901 storage_class = sc_none;
7905 /* If this is declaring a typedef name, return a TYPE_DECL. */
7906 if (declspecs->specs[(int)ds_typedef] && decl_context != TYPENAME)
7910 /* Note that the grammar rejects storage classes
7911 in typenames, fields or parameters. */
7912 if (current_lang_name == lang_name_java)
7913 TYPE_FOR_JAVA (type) = 1;
7915 /* This declaration:
7917 typedef void f(int) const;
7919 declares a function type which is not a member of any
7920 particular class, but which is cv-qualified; for
7921 example "f S::*" declares a pointer to a const-qualified
7922 member function of S. We record the cv-qualification in the
7924 if (memfn_quals && TREE_CODE (type) == FUNCTION_TYPE)
7925 type = cp_build_qualified_type (type, memfn_quals);
7927 if (decl_context == FIELD)
7928 decl = build_lang_decl (TYPE_DECL, unqualified_id, type);
7930 decl = build_decl (TYPE_DECL, unqualified_id, type);
7931 if (id_declarator && declarator->u.id.qualifying_scope)
7932 error ("%Jtypedef name may not be a nested-name-specifier", decl);
7934 if (decl_context != FIELD)
7936 if (!current_function_decl)
7937 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
7938 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl)
7939 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
7940 (current_function_decl)))
7941 /* The TYPE_DECL is "abstract" because there will be
7942 clones of this constructor/destructor, and there will
7943 be copies of this TYPE_DECL generated in those
7945 DECL_ABSTRACT (decl) = 1;
7947 else if (constructor_name_p (unqualified_id, current_class_type))
7948 pedwarn ("ISO C++ forbids nested type %qD with same name "
7949 "as enclosing class",
7952 /* If the user declares "typedef struct {...} foo" then the
7953 struct will have an anonymous name. Fill that name in now.
7954 Nothing can refer to it, so nothing needs know about the name
7956 if (type != error_mark_node
7959 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7960 && TYPE_ANONYMOUS_P (type)
7961 /* Don't do this if there are attributes. */
7962 && (!attrlist || !*attrlist)
7963 && cp_type_quals (type) == TYPE_UNQUALIFIED)
7965 tree oldname = TYPE_NAME (type);
7968 /* Replace the anonymous name with the real name everywhere. */
7969 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
7970 if (TYPE_NAME (t) == oldname)
7971 TYPE_NAME (t) = decl;
7973 if (TYPE_LANG_SPECIFIC (type))
7974 TYPE_WAS_ANONYMOUS (type) = 1;
7976 /* If this is a typedef within a template class, the nested
7977 type is a (non-primary) template. The name for the
7978 template needs updating as well. */
7979 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
7980 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
7981 = TYPE_IDENTIFIER (type);
7983 /* FIXME remangle member functions; member functions of a
7984 type with external linkage have external linkage. */
7987 /* Any qualifiers on a function type typedef have already been
7989 if (memfn_quals && !ctype && TREE_CODE (type) == FUNCTION_TYPE)
7990 memfn_quals = TYPE_UNQUALIFIED;
7993 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
7994 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
7996 bad_specifiers (decl, "type", virtualp,
7997 memfn_quals != TYPE_UNQUALIFIED,
7998 inlinep, friendp, raises != NULL_TREE);
8003 /* Detect the case of an array type of unspecified size
8004 which came, as such, direct from a typedef name.
8005 We must copy the type, so that the array's domain can be
8006 individually set by the object's initializer. */
8008 if (type && typedef_type
8009 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
8010 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
8011 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
8013 /* Detect where we're using a typedef of function type to declare a
8014 function. PARMS will not be set, so we must create it now. */
8016 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
8018 tree decls = NULL_TREE;
8021 for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
8023 tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
8025 TREE_CHAIN (decl) = decls;
8029 parms = nreverse (decls);
8031 if (decl_context != TYPENAME)
8033 /* A cv-qualifier-seq shall only be part of the function type
8034 for a non-static member function. [8.3.5/4 dcl.fct] */
8035 if (cp_type_quals (type) != TYPE_UNQUALIFIED
8036 && (current_class_type == NULL_TREE || staticp) )
8038 error ("qualified function types cannot be used to declare %s functions",
8039 (staticp? "static member" : "free"));
8040 type = TYPE_MAIN_VARIANT (type);
8043 /* The qualifiers on the function type become the qualifiers on
8044 the non-static member function. */
8045 memfn_quals |= cp_type_quals (type);
8049 /* If this is a type name (such as, in a cast or sizeof),
8050 compute the type and return it now. */
8052 if (decl_context == TYPENAME)
8054 /* Note that the grammar rejects storage classes
8055 in typenames, fields or parameters. */
8056 if (type_quals != TYPE_UNQUALIFIED)
8057 type_quals = TYPE_UNQUALIFIED;
8059 /* Special case: "friend class foo" looks like a TYPENAME context. */
8062 if (type_quals != TYPE_UNQUALIFIED)
8064 error ("type qualifiers specified for friend class declaration");
8065 type_quals = TYPE_UNQUALIFIED;
8069 error ("%<inline%> specified for friend class declaration");
8075 /* Don't allow friend declaration without a class-key. */
8076 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
8077 pedwarn ("template parameters cannot be friends");
8078 else if (TREE_CODE (type) == TYPENAME_TYPE)
8079 pedwarn ("friend declaration requires class-key, "
8080 "i.e. %<friend class %T::%D%>",
8081 TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
8083 pedwarn ("friend declaration requires class-key, "
8084 "i.e. %<friend %#T%>",
8088 /* Only try to do this stuff if we didn't already give up. */
8089 if (type != integer_type_node)
8091 /* A friendly class? */
8092 if (current_class_type)
8093 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
8096 error ("trying to make class %qT a friend of global scope",
8099 type = void_type_node;
8102 else if (memfn_quals)
8104 if (ctype == NULL_TREE)
8106 if (TREE_CODE (type) != METHOD_TYPE)
8107 error ("invalid qualifiers on non-member function type");
8109 ctype = TYPE_METHOD_BASETYPE (type);
8112 type = build_memfn_type (type, ctype, memfn_quals);
8117 else if (unqualified_id == NULL_TREE && decl_context != PARM
8118 && decl_context != CATCHPARM
8119 && TREE_CODE (type) != UNION_TYPE
8122 error ("abstract declarator %qT used as declaration", type);
8123 return error_mark_node;
8126 /* Only functions may be declared using an operator-function-id. */
8128 && IDENTIFIER_OPNAME_P (unqualified_id)
8129 && TREE_CODE (type) != FUNCTION_TYPE
8130 && TREE_CODE (type) != METHOD_TYPE)
8132 error ("declaration of %qD as non-function", unqualified_id);
8133 return error_mark_node;
8136 /* We don't check parameter types here because we can emit a better
8137 error message later. */
8138 if (decl_context != PARM)
8139 type = check_var_type (unqualified_id, type);
8141 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
8142 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
8144 if (decl_context == PARM || decl_context == CATCHPARM)
8146 if (ctype || in_namespace)
8147 error ("cannot use %<::%> in parameter declaration");
8149 /* A parameter declared as an array of T is really a pointer to T.
8150 One declared as a function is really a pointer to a function.
8151 One declared as a member is really a pointer to member. */
8153 if (TREE_CODE (type) == ARRAY_TYPE)
8155 /* Transfer const-ness of array into that of type pointed to. */
8156 type = build_pointer_type (TREE_TYPE (type));
8157 type_quals = TYPE_UNQUALIFIED;
8159 else if (TREE_CODE (type) == FUNCTION_TYPE)
8160 type = build_pointer_type (type);
8166 if (decl_context == PARM)
8168 decl = cp_build_parm_decl (unqualified_id, type);
8170 bad_specifiers (decl, "parameter", virtualp,
8171 memfn_quals != TYPE_UNQUALIFIED,
8172 inlinep, friendp, raises != NULL_TREE);
8174 else if (decl_context == FIELD)
8176 /* The C99 flexible array extension. */
8177 if (!staticp && TREE_CODE (type) == ARRAY_TYPE
8178 && TYPE_DOMAIN (type) == NULL_TREE)
8180 tree itype = compute_array_index_type (dname, integer_zero_node);
8181 type = build_cplus_array_type (TREE_TYPE (type), itype);
8184 if (type == error_mark_node)
8186 /* Happens when declaring arrays of sizes which
8187 are error_mark_node, for example. */
8190 else if (in_namespace && !friendp)
8192 /* Something like struct S { int N::j; }; */
8193 error ("invalid use of %<::%>");
8194 return error_mark_node;
8196 else if (TREE_CODE (type) == FUNCTION_TYPE)
8199 tree function_context;
8203 if (ctype == NULL_TREE)
8204 ctype = current_class_type;
8206 if (ctype == NULL_TREE)
8208 error ("can't make %qD into a method -- not in a class",
8210 return error_mark_node;
8213 /* ``A union may [ ... ] not [ have ] virtual functions.''
8215 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
8217 error ("function %qD declared virtual inside a union",
8219 return error_mark_node;
8222 if (NEW_DELETE_OPNAME_P (unqualified_id))
8226 error ("%qD cannot be declared virtual, since it "
8232 else if (staticp < 2)
8233 type = build_memfn_type (type, ctype, memfn_quals);
8236 /* Check that the name used for a destructor makes sense. */
8237 if (sfk == sfk_destructor)
8241 gcc_assert (friendp);
8242 error ("expected qualified name in friend declaration "
8243 "for destructor %qD",
8244 id_declarator->u.id.unqualified_name);
8245 return error_mark_node;
8248 if (!same_type_p (TREE_OPERAND
8249 (id_declarator->u.id.unqualified_name, 0),
8252 error ("declaration of %qD as member of %qT",
8253 id_declarator->u.id.unqualified_name, ctype);
8254 return error_mark_node;
8258 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
8259 function_context = (ctype != NULL_TREE) ?
8260 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
8261 publicp = (! friendp || ! staticp)
8262 && function_context == NULL_TREE;
8263 decl = grokfndecl (ctype, type,
8264 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
8265 ? unqualified_id : dname,
8268 virtualp, flags, memfn_quals, raises,
8269 friendp ? -1 : 0, friendp, publicp, inlinep,
8271 funcdef_flag, template_count, in_namespace, attrlist);
8272 if (decl == NULL_TREE)
8273 return error_mark_node;
8275 /* This clobbers the attrs stored in `decl' from `attrlist'. */
8276 /* The decl and setting of decl_attr is also turned off. */
8277 decl = build_decl_attribute_variant (decl, decl_attr);
8280 /* [class.conv.ctor]
8282 A constructor declared without the function-specifier
8283 explicit that can be called with a single parameter
8284 specifies a conversion from the type of its first
8285 parameter to the type of its class. Such a constructor
8286 is called a converting constructor. */
8288 DECL_NONCONVERTING_P (decl) = 1;
8289 else if (DECL_CONSTRUCTOR_P (decl))
8291 /* The constructor can be called with exactly one
8292 parameter if there is at least one parameter, and
8293 any subsequent parameters have default arguments.
8294 Ignore any compiler-added parms. */
8295 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
8297 if (arg_types == void_list_node
8299 && TREE_CHAIN (arg_types)
8300 && TREE_CHAIN (arg_types) != void_list_node
8301 && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
8302 DECL_NONCONVERTING_P (decl) = 1;
8305 else if (TREE_CODE (type) == METHOD_TYPE)
8307 /* We only get here for friend declarations of
8308 members of other classes. */
8309 /* All method decls are public, so tell grokfndecl to set
8310 TREE_PUBLIC, also. */
8311 decl = grokfndecl (ctype, type,
8312 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
8313 ? unqualified_id : dname,
8316 virtualp, flags, memfn_quals, raises,
8317 friendp ? -1 : 0, friendp, 1, 0, sfk,
8318 funcdef_flag, template_count, in_namespace,
8320 if (decl == NULL_TREE)
8321 return error_mark_node;
8323 else if (!staticp && !dependent_type_p (type)
8324 && !COMPLETE_TYPE_P (complete_type (type))
8325 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
8328 error ("field %qD has incomplete type", unqualified_id);
8330 error ("name %qT has incomplete type", type);
8332 /* If we're instantiating a template, tell them which
8333 instantiation made the field's type be incomplete. */
8334 if (current_class_type
8335 && TYPE_NAME (current_class_type)
8336 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
8338 && declspecs->type == type)
8339 error (" in instantiation of template %qT",
8340 current_class_type);
8342 type = error_mark_node;
8349 error ("%qE is neither function nor member function; "
8350 "cannot be declared friend", unqualified_id);
8358 /* Friends are treated specially. */
8359 if (ctype == current_class_type)
8360 ; /* We already issued a pedwarn. */
8361 else if (decl && DECL_NAME (decl))
8363 if (template_class_depth (current_class_type) == 0)
8365 decl = check_explicit_specialization
8366 (unqualified_id, decl, template_count,
8367 2 * funcdef_flag + 4);
8368 if (decl == error_mark_node)
8369 return error_mark_node;
8372 decl = do_friend (ctype, unqualified_id, decl,
8378 return error_mark_node;
8381 /* Structure field. It may not be a function, except for C++. */
8383 if (decl == NULL_TREE)
8389 /* An attempt is being made to initialize a non-static
8390 member. But, from [class.mem]:
8392 4 A member-declarator can contain a
8393 constant-initializer only if it declares a static
8394 member (_class.static_) of integral or enumeration
8395 type, see _class.static.data_.
8397 This used to be relatively common practice, but
8398 the rest of the compiler does not correctly
8399 handle the initialization unless the member is
8400 static so we make it static below. */
8401 pedwarn ("ISO C++ forbids initialization of member %qD",
8403 pedwarn ("making %qD static", unqualified_id);
8407 if (uses_template_parms (type))
8408 /* We'll check at instantiation time. */
8410 else if (check_static_variable_definition (unqualified_id,
8412 /* If we just return the declaration, crashes
8413 will sometimes occur. We therefore return
8414 void_type_node, as if this was a friend
8415 declaration, to cause callers to completely
8416 ignore this declaration. */
8417 return error_mark_node;
8422 /* C++ allows static class members. All other work
8423 for this is done by grokfield. */
8424 decl = build_lang_decl (VAR_DECL, unqualified_id, type);
8425 set_linkage_for_static_data_member (decl);
8426 /* Even if there is an in-class initialization, DECL
8427 is considered undefined until an out-of-class
8428 definition is provided. */
8429 DECL_EXTERNAL (decl) = 1;
8433 if (targetm.have_tls)
8434 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
8436 /* A mere warning is sure to result in improper
8437 semantics at runtime. Don't bother to allow this to
8439 error ("thread-local storage not supported for this target");
8444 decl = build_decl (FIELD_DECL, unqualified_id, type);
8445 DECL_NONADDRESSABLE_P (decl) = bitfield;
8446 if (storage_class == sc_mutable)
8448 DECL_MUTABLE_P (decl) = 1;
8449 storage_class = sc_none;
8453 bad_specifiers (decl, "field", virtualp,
8454 memfn_quals != TYPE_UNQUALIFIED,
8455 inlinep, friendp, raises != NULL_TREE);
8458 else if (TREE_CODE (type) == FUNCTION_TYPE
8459 || TREE_CODE (type) == METHOD_TYPE)
8464 if (!unqualified_id)
8465 return error_mark_node;
8467 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
8468 original_name = dname;
8470 original_name = unqualified_id;
8472 if (storage_class == sc_auto)
8473 error ("storage class %<auto%> invalid for function %qs", name);
8474 else if (storage_class == sc_register)
8475 error ("storage class %<register%> invalid for function %qs", name);
8477 error ("storage class %<__thread%> invalid for function %qs", name);
8479 /* Function declaration not at top level.
8480 Storage classes other than `extern' are not allowed
8481 and `extern' makes no difference. */
8482 if (! toplevel_bindings_p ()
8483 && (storage_class == sc_static
8484 || declspecs->specs[(int)ds_inline])
8487 if (storage_class == sc_static)
8488 pedwarn ("%<static%> specified invalid for function %qs "
8489 "declared out of global scope", name);
8491 pedwarn ("%<inline%> specifier invalid for function %qs "
8492 "declared out of global scope", name);
8495 if (ctype == NULL_TREE)
8499 error ("virtual non-class function %qs", name);
8503 else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2
8504 && !NEW_DELETE_OPNAME_P (original_name))
8505 type = build_method_type_directly (ctype,
8507 TYPE_ARG_TYPES (type));
8509 /* Record presence of `static'. */
8510 publicp = (ctype != NULL_TREE
8511 || storage_class == sc_extern
8512 || storage_class != sc_static);
8514 decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
8515 virtualp, flags, memfn_quals, raises,
8517 publicp, inlinep, sfk, funcdef_flag,
8518 template_count, in_namespace, attrlist);
8519 if (decl == NULL_TREE)
8520 return error_mark_node;
8524 int invalid_static = 0;
8526 /* Don't allow a static member function in a class, and forbid
8527 declaring main to be static. */
8528 if (TREE_CODE (type) == METHOD_TYPE)
8530 pedwarn ("cannot declare member function %qD to have "
8531 "static linkage", decl);
8534 else if (current_function_decl)
8536 /* FIXME need arm citation */
8537 error ("cannot declare static function inside another function");
8544 storage_class = sc_none;
8550 /* It's a variable. */
8552 /* An uninitialized decl with `extern' is a reference. */
8553 decl = grokvardecl (type, unqualified_id,
8556 (type_quals & TYPE_QUAL_CONST) != 0,
8557 ctype ? ctype : in_namespace);
8558 bad_specifiers (decl, "variable", virtualp,
8559 memfn_quals != TYPE_UNQUALIFIED,
8560 inlinep, friendp, raises != NULL_TREE);
8564 DECL_CONTEXT (decl) = ctype;
8567 pedwarn ("%<static%> may not be used when defining "
8568 "(as opposed to declaring) a static data member");
8570 storage_class = sc_none;
8572 if (storage_class == sc_register && TREE_STATIC (decl))
8574 error ("static member %qD declared %<register%>", decl);
8575 storage_class = sc_none;
8577 if (storage_class == sc_extern && pedantic)
8579 pedwarn ("cannot explicitly declare member %q#D to have "
8582 storage_class = sc_none;
8587 /* Record `register' declaration for warnings on &
8588 and in case doing stupid register allocation. */
8590 if (storage_class == sc_register)
8591 DECL_REGISTER (decl) = 1;
8592 else if (storage_class == sc_extern)
8593 DECL_THIS_EXTERN (decl) = 1;
8594 else if (storage_class == sc_static)
8595 DECL_THIS_STATIC (decl) = 1;
8597 /* Record constancy and volatility. There's no need to do this
8598 when processing a template; we'll do this for the instantiated
8599 declaration based on the type of DECL. */
8600 if (!processing_template_decl)
8601 cp_apply_type_quals_to_decl (type_quals, decl);
8607 /* Subroutine of start_function. Ensure that each of the parameter
8608 types (as listed in PARMS) is complete, as is required for a
8609 function definition. */
8612 require_complete_types_for_parms (tree parms)
8614 for (; parms; parms = TREE_CHAIN (parms))
8616 if (dependent_type_p (TREE_TYPE (parms)))
8618 if (!VOID_TYPE_P (TREE_TYPE (parms))
8619 && complete_type_or_else (TREE_TYPE (parms), parms))
8621 relayout_decl (parms);
8622 DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
8625 /* grokparms or complete_type_or_else will have already issued
8627 TREE_TYPE (parms) = error_mark_node;
8631 /* Returns nonzero if T is a local variable. */
8634 local_variable_p (tree t)
8636 if ((TREE_CODE (t) == VAR_DECL
8637 /* A VAR_DECL with a context that is a _TYPE is a static data
8639 && !TYPE_P (CP_DECL_CONTEXT (t))
8640 /* Any other non-local variable must be at namespace scope. */
8641 && !DECL_NAMESPACE_SCOPE_P (t))
8642 || (TREE_CODE (t) == PARM_DECL))
8648 /* Returns nonzero if T is an automatic local variable or a label.
8649 (These are the declarations that need to be remapped when the code
8650 containing them is duplicated.) */
8653 nonstatic_local_decl_p (tree t)
8655 return ((local_variable_p (t) && !TREE_STATIC (t))
8656 || TREE_CODE (t) == LABEL_DECL
8657 || TREE_CODE (t) == RESULT_DECL);
8660 /* Like local_variable_p, but suitable for use as a tree-walking
8664 local_variable_p_walkfn (tree *tp, int *walk_subtrees,
8665 void *data ATTRIBUTE_UNUSED)
8667 if (local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
8669 else if (TYPE_P (*tp))
8676 /* Check that ARG, which is a default-argument expression for a
8677 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
8678 something goes wrong. DECL may also be a _TYPE node, rather than a
8679 DECL, if there is no DECL available. */
8682 check_default_argument (tree decl, tree arg)
8687 if (TREE_CODE (arg) == DEFAULT_ARG)
8688 /* We get a DEFAULT_ARG when looking at an in-class declaration
8689 with a default argument. Ignore the argument for now; we'll
8690 deal with it after the class is complete. */
8699 decl_type = TREE_TYPE (decl);
8701 if (arg == error_mark_node
8702 || decl == error_mark_node
8703 || TREE_TYPE (arg) == error_mark_node
8704 || decl_type == error_mark_node)
8705 /* Something already went wrong. There's no need to check
8707 return error_mark_node;
8709 /* [dcl.fct.default]
8711 A default argument expression is implicitly converted to the
8713 if (!TREE_TYPE (arg)
8714 || !can_convert_arg (decl_type, TREE_TYPE (arg), arg, LOOKUP_NORMAL))
8717 error ("default argument for %q#D has type %qT",
8718 decl, TREE_TYPE (arg));
8720 error ("default argument for parameter of type %qT has type %qT",
8721 decl_type, TREE_TYPE (arg));
8723 return error_mark_node;
8726 /* [dcl.fct.default]
8728 Local variables shall not be used in default argument
8731 The keyword `this' shall not be used in a default argument of a
8733 var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
8737 error ("default argument %qE uses local variable %qD", arg, var);
8738 return error_mark_node;
8745 /* Decode the list of parameter types for a function type.
8746 Given the list of things declared inside the parens,
8747 return a list of types.
8749 If this parameter does not end with an ellipsis, we append
8752 *PARMS is set to the chain of PARM_DECLs created. */
8755 grokparms (cp_parameter_declarator *first_parm, tree *parms)
8757 tree result = NULL_TREE;
8758 tree decls = NULL_TREE;
8759 int ellipsis = !first_parm || first_parm->ellipsis_p;
8760 cp_parameter_declarator *parm;
8763 for (parm = first_parm; parm != NULL; parm = parm->next)
8765 tree type = NULL_TREE;
8766 tree init = parm->default_argument;
8770 if (parm == no_parameters)
8773 attrs = parm->decl_specifiers.attributes;
8774 parm->decl_specifiers.attributes = NULL_TREE;
8775 decl = grokdeclarator (parm->declarator, &parm->decl_specifiers,
8776 PARM, init != NULL_TREE, &attrs);
8777 if (! decl || TREE_TYPE (decl) == error_mark_node)
8781 cplus_decl_attributes (&decl, attrs, 0);
8783 type = TREE_TYPE (decl);
8784 if (VOID_TYPE_P (type))
8786 if (same_type_p (type, void_type_node)
8787 && DECL_SELF_REFERENCE_P (type)
8788 && !DECL_NAME (decl) && !result && !parm->next && !ellipsis)
8789 /* this is a parmlist of `(void)', which is ok. */
8791 cxx_incomplete_type_error (decl, type);
8792 /* It's not a good idea to actually create parameters of
8793 type `void'; other parts of the compiler assume that a
8794 void type terminates the parameter list. */
8795 type = error_mark_node;
8796 TREE_TYPE (decl) = error_mark_node;
8799 if (type != error_mark_node)
8801 /* Top-level qualifiers on the parameters are
8802 ignored for function types. */
8803 type = cp_build_qualified_type (type, 0);
8804 if (TREE_CODE (type) == METHOD_TYPE)
8806 error ("parameter %qD invalidly declared method type", decl);
8807 type = build_pointer_type (type);
8808 TREE_TYPE (decl) = type;
8810 else if (abstract_virtuals_error (decl, type))
8811 any_error = 1; /* Seems like a good idea. */
8812 else if (POINTER_TYPE_P (type))
8814 /* [dcl.fct]/6, parameter types cannot contain pointers
8815 (references) to arrays of unknown bound. */
8816 tree t = TREE_TYPE (type);
8817 int ptr = TYPE_PTR_P (type);
8823 else if (TREE_CODE (t) != ARRAY_TYPE)
8825 else if (!TYPE_DOMAIN (t))
8829 if (TREE_CODE (t) == ARRAY_TYPE)
8830 error ("parameter %qD includes %s to array of unknown "
8832 decl, ptr ? "pointer" : "reference", t);
8837 else if (init && !processing_template_decl)
8838 init = check_default_argument (decl, init);
8841 TREE_CHAIN (decl) = decls;
8843 result = tree_cons (init, type, result);
8845 decls = nreverse (decls);
8846 result = nreverse (result);
8848 result = chainon (result, void_list_node);
8855 /* D is a constructor or overloaded `operator='.
8857 Let T be the class in which D is declared. Then, this function
8860 -1 if D's is an ill-formed constructor or copy assignment operator
8861 whose first parameter is of type `T'.
8862 0 if D is not a copy constructor or copy assignment
8864 1 if D is a copy constructor or copy assignment operator whose
8865 first parameter is a reference to const qualified T.
8866 2 if D is a copy constructor or copy assignment operator whose
8867 first parameter is a reference to non-const qualified T.
8869 This function can be used as a predicate. Positive values indicate
8870 a copy constructor and nonzero values indicate a copy assignment
8880 if (!DECL_FUNCTION_MEMBER_P (d))
8881 /* Non-members are invalid. We complained, but kept the declaration. */
8884 if (TREE_CODE (d) == TEMPLATE_DECL
8885 || (DECL_TEMPLATE_INFO (d)
8886 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
8887 /* Instantiations of template member functions are never copy
8888 functions. Note that member functions of templated classes are
8889 represented as template functions internally, and we must
8890 accept those as copy functions. */
8893 args = FUNCTION_FIRST_USER_PARMTYPE (d);
8897 arg_type = TREE_VALUE (args);
8898 if (arg_type == error_mark_node)
8901 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
8903 /* Pass by value copy assignment operator. */
8906 else if (TREE_CODE (arg_type) == REFERENCE_TYPE
8907 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
8909 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
8915 args = TREE_CHAIN (args);
8917 if (args && args != void_list_node && !TREE_PURPOSE (args))
8918 /* There are more non-optional args. */
8924 /* Remember any special properties of member function DECL. */
8926 void grok_special_member_properties (tree decl)
8930 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
8933 class_type = DECL_CONTEXT (decl);
8934 if (DECL_CONSTRUCTOR_P (decl))
8936 int ctor = copy_fn_p (decl);
8938 TYPE_HAS_CONSTRUCTOR (class_type) = 1;
8944 A non-template constructor for class X is a copy
8945 constructor if its first parameter is of type X&, const
8946 X&, volatile X& or const volatile X&, and either there
8947 are no other parameters or else all other parameters have
8948 default arguments. */
8949 TYPE_HAS_INIT_REF (class_type) = 1;
8951 TYPE_HAS_CONST_INIT_REF (class_type) = 1;
8953 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
8954 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type) = 1;
8956 else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
8960 A non-template assignment operator for class X is a copy
8961 assignment operator if its parameter is of type X, X&, const
8962 X&, volatile X& or const volatile X&. */
8964 int assop = copy_fn_p (decl);
8968 TYPE_HAS_ASSIGN_REF (class_type) = 1;
8970 TYPE_HAS_CONST_ASSIGN_REF (class_type) = 1;
8975 /* Check a constructor DECL has the correct form. Complains
8976 if the class has a constructor of the form X(X). */
8979 grok_ctor_properties (tree ctype, tree decl)
8981 int ctor_parm = copy_fn_p (decl);
8987 A declaration of a constructor for a class X is ill-formed if
8988 its first parameter is of type (optionally cv-qualified) X
8989 and either there are no other parameters or else all other
8990 parameters have default arguments.
8992 We *don't* complain about member template instantiations that
8993 have this form, though; they can occur as we try to decide
8994 what constructor to use during overload resolution. Since
8995 overload resolution will never prefer such a constructor to
8996 the non-template copy constructor (which is either explicitly
8997 or implicitly defined), there's no need to worry about their
8998 existence. Theoretically, they should never even be
8999 instantiated, but that's hard to forestall. */
9000 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
9008 /* An operator with this code is unary, but can also be binary. */
9011 ambi_op_p (enum tree_code code)
9013 return (code == INDIRECT_REF
9014 || code == ADDR_EXPR
9015 || code == UNARY_PLUS_EXPR
9016 || code == NEGATE_EXPR
9017 || code == PREINCREMENT_EXPR
9018 || code == PREDECREMENT_EXPR);
9021 /* An operator with this name can only be unary. */
9024 unary_op_p (enum tree_code code)
9026 return (code == TRUTH_NOT_EXPR
9027 || code == BIT_NOT_EXPR
9028 || code == COMPONENT_REF
9029 || code == TYPE_EXPR);
9032 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
9033 errors are issued for invalid declarations. */
9036 grok_op_properties (tree decl, bool complain)
9038 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
9040 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
9041 tree name = DECL_NAME (decl);
9042 enum tree_code operator_code;
9047 /* Count the number of arguments and check for ellipsis. */
9048 for (argtype = argtypes, arity = 0;
9049 argtype && argtype != void_list_node;
9050 argtype = TREE_CHAIN (argtype))
9052 ellipsis_p = !argtype;
9054 class_type = DECL_CONTEXT (decl);
9055 if (class_type && !CLASS_TYPE_P (class_type))
9056 class_type = NULL_TREE;
9058 if (DECL_CONV_FN_P (decl))
9059 operator_code = TYPE_EXPR;
9063 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
9064 if (ansi_opname (CODE) == name) \
9066 operator_code = (CODE); \
9069 else if (ansi_assopname (CODE) == name) \
9071 operator_code = (CODE); \
9072 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
9076 #include "operators.def"
9082 gcc_assert (operator_code != LAST_CPLUS_TREE_CODE);
9083 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
9086 switch (operator_code)
9089 TYPE_HAS_NEW_OPERATOR (class_type) = 1;
9093 TYPE_GETS_DELETE (class_type) |= 1;
9097 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type) = 1;
9100 case VEC_DELETE_EXPR:
9101 TYPE_GETS_DELETE (class_type) |= 2;
9108 /* [basic.std.dynamic.allocation]/1:
9110 A program is ill-formed if an allocation function is declared
9111 in a namespace scope other than global scope or declared static
9114 The same also holds true for deallocation functions. */
9115 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR
9116 || operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
9118 if (DECL_NAMESPACE_SCOPE_P (decl))
9120 if (CP_DECL_CONTEXT (decl) != global_namespace)
9121 error ("%qD may not be declared within a namespace", decl);
9122 else if (!TREE_PUBLIC (decl))
9123 error ("%qD may not be declared as static", decl);
9127 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
9128 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
9129 else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
9130 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
9133 /* An operator function must either be a non-static member function
9134 or have at least one parameter of a class, a reference to a class,
9135 an enumeration, or a reference to an enumeration. 13.4.0.6 */
9136 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
9138 if (operator_code == TYPE_EXPR
9139 || operator_code == CALL_EXPR
9140 || operator_code == COMPONENT_REF
9141 || operator_code == ARRAY_REF
9142 || operator_code == NOP_EXPR)
9144 error ("%qD must be a nonstatic member function", decl);
9151 if (DECL_STATIC_FUNCTION_P (decl))
9153 error ("%qD must be either a non-static member "
9154 "function or a non-member function", decl);
9158 for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
9160 tree arg = non_reference (TREE_VALUE (p));
9161 if (arg == error_mark_node)
9164 /* IS_AGGR_TYPE, rather than CLASS_TYPE_P, is used
9165 because these checks are performed even on
9166 template functions. */
9167 if (IS_AGGR_TYPE (arg) || TREE_CODE (arg) == ENUMERAL_TYPE)
9171 if (!p || p == void_list_node)
9176 error ("%qD must have an argument of class or "
9183 /* There are no restrictions on the arguments to an overloaded
9185 if (operator_code == CALL_EXPR)
9188 /* Warn about conversion operators that will never be used. */
9189 if (IDENTIFIER_TYPENAME_P (name)
9190 && ! DECL_TEMPLATE_INFO (decl)
9192 /* Warn only declaring the function; there is no need to
9193 warn again about out-of-class definitions. */
9194 && class_type == current_class_type)
9196 tree t = TREE_TYPE (name);
9197 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
9198 const char *what = 0;
9201 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
9203 if (TREE_CODE (t) == VOID_TYPE)
9205 else if (class_type)
9207 if (t == class_type)
9208 what = "the same type";
9209 /* Don't force t to be complete here. */
9210 else if (IS_AGGR_TYPE (t)
9211 && COMPLETE_TYPE_P (t)
9212 && DERIVED_FROM_P (t, class_type))
9213 what = "a base class";
9217 warning (OPT_Wconversion, "conversion to %s%s will never use a type "
9218 "conversion operator",
9219 ref ? "a reference to " : "", what);
9222 if (operator_code == COND_EXPR)
9225 error ("ISO C++ prohibits overloading operator ?:");
9227 else if (ellipsis_p)
9228 error ("%qD must not have variable number of arguments", decl);
9229 else if (ambi_op_p (operator_code))
9232 /* We pick the one-argument operator codes by default, so
9233 we don't have to change anything. */
9235 else if (arity == 2)
9237 /* If we thought this was a unary operator, we now know
9238 it to be a binary operator. */
9239 switch (operator_code)
9242 operator_code = MULT_EXPR;
9246 operator_code = BIT_AND_EXPR;
9249 case UNARY_PLUS_EXPR:
9250 operator_code = PLUS_EXPR;
9254 operator_code = MINUS_EXPR;
9257 case PREINCREMENT_EXPR:
9258 operator_code = POSTINCREMENT_EXPR;
9261 case PREDECREMENT_EXPR:
9262 operator_code = POSTDECREMENT_EXPR;
9269 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
9271 if ((operator_code == POSTINCREMENT_EXPR
9272 || operator_code == POSTDECREMENT_EXPR)
9273 && ! processing_template_decl
9274 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
9277 error ("postfix %qD must take %<int%> as its argument",
9281 ("postfix %qD must take %<int%> as its second argument",
9288 error ("%qD must take either zero or one argument", decl);
9290 error ("%qD must take either one or two arguments", decl);
9293 /* More Effective C++ rule 6. */
9295 && (operator_code == POSTINCREMENT_EXPR
9296 || operator_code == POSTDECREMENT_EXPR
9297 || operator_code == PREINCREMENT_EXPR
9298 || operator_code == PREDECREMENT_EXPR))
9300 tree arg = TREE_VALUE (argtypes);
9301 tree ret = TREE_TYPE (TREE_TYPE (decl));
9302 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
9303 arg = TREE_TYPE (arg);
9304 arg = TYPE_MAIN_VARIANT (arg);
9305 if (operator_code == PREINCREMENT_EXPR
9306 || operator_code == PREDECREMENT_EXPR)
9308 if (TREE_CODE (ret) != REFERENCE_TYPE
9309 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
9311 warning (OPT_Weffc__, "prefix %qD should return %qT", decl,
9312 build_reference_type (arg));
9316 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
9317 warning (OPT_Weffc__, "postfix %qD should return %qT", decl, arg);
9321 else if (unary_op_p (operator_code))
9326 error ("%qD must take %<void%>", decl);
9328 error ("%qD must take exactly one argument", decl);
9331 else /* if (binary_op_p (operator_code)) */
9336 error ("%qD must take exactly one argument", decl);
9338 error ("%qD must take exactly two arguments", decl);
9341 /* More Effective C++ rule 7. */
9343 && (operator_code == TRUTH_ANDIF_EXPR
9344 || operator_code == TRUTH_ORIF_EXPR
9345 || operator_code == COMPOUND_EXPR))
9346 warning (OPT_Weffc__, "user-defined %qD always evaluates both arguments",
9350 /* Effective C++ rule 23. */
9353 && !DECL_ASSIGNMENT_OPERATOR_P (decl)
9354 && (operator_code == PLUS_EXPR
9355 || operator_code == MINUS_EXPR
9356 || operator_code == TRUNC_DIV_EXPR
9357 || operator_code == MULT_EXPR
9358 || operator_code == TRUNC_MOD_EXPR)
9359 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
9360 warning (OPT_Weffc__, "%qD should return by value", decl);
9363 for (; argtypes && argtypes != void_list_node;
9364 argtypes = TREE_CHAIN (argtypes))
9365 if (TREE_PURPOSE (argtypes))
9367 TREE_PURPOSE (argtypes) = NULL_TREE;
9368 if (operator_code == POSTINCREMENT_EXPR
9369 || operator_code == POSTDECREMENT_EXPR)
9372 pedwarn ("%qD cannot have default arguments", decl);
9375 error ("%qD cannot have default arguments", decl);
9382 /* Return a string giving the keyword associate with CODE. */
9385 tag_name (enum tag_types code)
9404 /* Name lookup in an elaborated-type-specifier (after the keyword
9405 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
9406 elaborated-type-specifier is invalid, issue a diagnostic and return
9407 error_mark_node; otherwise, return the *_TYPE to which it referred.
9408 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
9411 check_elaborated_type_specifier (enum tag_types tag_code,
9413 bool allow_template_p)
9419 struct S { struct S *p; };
9421 name lookup will find the TYPE_DECL for the implicit "S::S"
9422 typedef. Adjust for that here. */
9423 if (DECL_SELF_REFERENCE_P (decl))
9424 decl = TYPE_NAME (TREE_TYPE (decl));
9426 type = TREE_TYPE (decl);
9428 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
9429 is false for this case as well. */
9430 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
9432 error ("using template type parameter %qT after %qs",
9433 type, tag_name (tag_code));
9434 return error_mark_node;
9438 If the identifier resolves to a typedef-name or a template
9439 type-parameter, the elaborated-type-specifier is ill-formed.
9441 In other words, the only legitimate declaration to use in the
9442 elaborated type specifier is the implicit typedef created when
9443 the type is declared. */
9444 else if (!DECL_IMPLICIT_TYPEDEF_P (decl)
9445 && tag_code != typename_type)
9447 error ("using typedef-name %qD after %qs", decl, tag_name (tag_code));
9448 error ("%q+D has a previous declaration here", decl);
9449 return error_mark_node;
9451 else if (TREE_CODE (type) != RECORD_TYPE
9452 && TREE_CODE (type) != UNION_TYPE
9453 && tag_code != enum_type
9454 && tag_code != typename_type)
9456 error ("%qT referred to as %qs", type, tag_name (tag_code));
9457 error ("%q+T has a previous declaration here", type);
9458 return error_mark_node;
9460 else if (TREE_CODE (type) != ENUMERAL_TYPE
9461 && tag_code == enum_type)
9463 error ("%qT referred to as enum", type);
9464 error ("%q+T has a previous declaration here", type);
9465 return error_mark_node;
9467 else if (!allow_template_p
9468 && TREE_CODE (type) == RECORD_TYPE
9469 && CLASSTYPE_IS_TEMPLATE (type))
9471 /* If a class template appears as elaborated type specifier
9472 without a template header such as:
9474 template <class T> class C {};
9475 void f(class C); // No template header here
9477 then the required template argument is missing. */
9478 error ("template argument required for %<%s %T%>",
9479 tag_name (tag_code),
9480 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
9481 return error_mark_node;
9487 /* Lookup NAME in elaborate type specifier in scope according to
9488 SCOPE and issue diagnostics if necessary.
9489 Return *_TYPE node upon success, NULL_TREE when the NAME is not
9490 found, and ERROR_MARK_NODE for type error. */
9493 lookup_and_check_tag (enum tag_types tag_code, tree name,
9494 tag_scope scope, bool template_header_p)
9498 if (scope == ts_global)
9500 /* First try ordinary name lookup, ignoring hidden class name
9501 injected via friend declaration. */
9502 decl = lookup_name_prefer_type (name, 2);
9503 /* If that fails, the name will be placed in the smallest
9504 non-class, non-function-prototype scope according to 3.3.1/5.
9505 We may already have a hidden name declared as friend in this
9506 scope. So lookup again but not ignoring hidden name.
9507 If we find one, that name will be made visible rather than
9508 creating a new tag. */
9510 decl = lookup_type_scope (name, ts_within_enclosing_non_class);
9513 decl = lookup_type_scope (name, scope);
9515 if (decl && DECL_CLASS_TEMPLATE_P (decl))
9516 decl = DECL_TEMPLATE_RESULT (decl);
9518 if (decl && TREE_CODE (decl) == TYPE_DECL)
9520 /* Look for invalid nested type:
9524 if (scope == ts_current && DECL_SELF_REFERENCE_P (decl))
9526 error ("%qD has the same name as the class in which it is "
9529 return error_mark_node;
9532 /* Two cases we need to consider when deciding if a class
9533 template is allowed as an elaborated type specifier:
9534 1. It is a self reference to its own class.
9535 2. It comes with a template header.
9539 template <class T> class C {
9540 class C *c1; // DECL_SELF_REFERENCE_P is true
9543 template <class U> class C; // template_header_p is true
9544 template <class T> class C<T>::D {
9545 class C *c2; // DECL_SELF_REFERENCE_P is true
9548 t = check_elaborated_type_specifier (tag_code,
9551 | DECL_SELF_REFERENCE_P (decl));
9558 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
9559 Define the tag as a forward-reference if it is not defined.
9561 If a declaration is given, process it here, and report an error if
9562 multiple declarations are not identical.
9564 SCOPE is TS_CURRENT when this is also a definition. Only look in
9565 the current frame for the name (since C++ allows new names in any
9566 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
9567 declaration. Only look beginning from the current scope outward up
9568 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
9570 TEMPLATE_HEADER_P is true when this declaration is preceded by
9571 a set of template parameters. */
9574 xref_tag (enum tag_types tag_code, tree name,
9575 tag_scope scope, bool template_header_p)
9577 enum tree_code code;
9579 tree context = NULL_TREE;
9581 timevar_push (TV_NAME_LOOKUP);
9583 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
9595 code = ENUMERAL_TYPE;
9601 /* In case of anonymous name, xref_tag is only called to
9602 make type node and push name. Name lookup is not required. */
9603 if (ANON_AGGRNAME_P (name))
9606 t = lookup_and_check_tag (tag_code, name,
9607 scope, template_header_p);
9609 if (t == error_mark_node)
9610 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
9612 if (scope != ts_current && t && current_class_type
9613 && template_class_depth (current_class_type)
9614 && template_header_p)
9616 /* Since SCOPE is not TS_CURRENT, we are not looking at a
9617 definition of this tag. Since, in addition, we are currently
9618 processing a (member) template declaration of a template
9619 class, we must be very careful; consider:
9626 { template <class V>
9627 friend struct S1; };
9629 Here, the S2::S1 declaration should not be confused with the
9630 outer declaration. In particular, the inner version should
9631 have a template parameter of level 2, not level 1. This
9632 would be particularly important if the member declaration
9635 template <class V = U> friend struct S1;
9637 say, when we should tsubst into `U' when instantiating
9638 S2. On the other hand, when presented with:
9648 we must find the inner binding eventually. We
9649 accomplish this by making sure that the new type we
9650 create to represent this declaration has the right
9652 context = TYPE_CONTEXT (t);
9658 /* If no such tag is yet defined, create a forward-reference node
9659 and record it as the "definition".
9660 When a real declaration of this type is found,
9661 the forward-reference will be altered into a real type. */
9662 if (code == ENUMERAL_TYPE)
9664 error ("use of enum %q#D without previous declaration", name);
9665 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
9669 t = make_aggr_type (code);
9670 TYPE_CONTEXT (t) = context;
9671 t = pushtag (name, t, scope);
9676 if (template_header_p && IS_AGGR_TYPE (t))
9677 redeclare_class_template (t, current_template_parms);
9678 else if (!processing_template_decl
9680 && CLASSTYPE_IS_TEMPLATE (t))
9682 error ("redeclaration of %qT as a non-template", t);
9683 t = error_mark_node;
9686 /* Make injected friend class visible. */
9687 if (scope != ts_within_enclosing_non_class
9688 && hidden_name_p (TYPE_NAME (t)))
9690 DECL_ANTICIPATED (TYPE_NAME (t)) = 0;
9691 DECL_FRIEND_P (TYPE_NAME (t)) = 0;
9693 if (TYPE_TEMPLATE_INFO (t))
9695 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t)) = 0;
9696 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t)) = 0;
9701 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
9705 xref_tag_from_type (tree old, tree id, tag_scope scope)
9707 enum tag_types tag_kind;
9709 if (TREE_CODE (old) == RECORD_TYPE)
9710 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
9712 tag_kind = union_type;
9714 if (id == NULL_TREE)
9715 id = TYPE_IDENTIFIER (old);
9717 return xref_tag (tag_kind, id, scope, false);
9720 /* Create the binfo hierarchy for REF with (possibly NULL) base list
9721 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
9722 access_* node, and the TREE_VALUE is the type of the base-class.
9723 Non-NULL TREE_TYPE indicates virtual inheritance. */
9726 xref_basetypes (tree ref, tree base_list)
9729 tree binfo, base_binfo;
9730 unsigned max_vbases = 0; /* Maximum direct & indirect virtual bases. */
9731 unsigned max_bases = 0; /* Maximum direct bases. */
9733 tree default_access;
9734 tree igo_prev; /* Track Inheritance Graph Order. */
9736 if (ref == error_mark_node)
9739 /* The base of a derived class is private by default, all others are
9741 default_access = (TREE_CODE (ref) == RECORD_TYPE
9742 && CLASSTYPE_DECLARED_CLASS (ref)
9743 ? access_private_node : access_public_node);
9745 /* First, make sure that any templates in base-classes are
9746 instantiated. This ensures that if we call ourselves recursively
9747 we do not get confused about which classes are marked and which
9752 tree basetype = TREE_VALUE (*basep);
9754 if (!(processing_template_decl && uses_template_parms (basetype))
9755 && !complete_type_or_else (basetype, NULL))
9756 /* An incomplete type. Remove it from the list. */
9757 *basep = TREE_CHAIN (*basep);
9761 if (TREE_TYPE (*basep))
9763 if (CLASS_TYPE_P (basetype))
9764 max_vbases += VEC_length (tree, CLASSTYPE_VBASECLASSES (basetype));
9765 basep = &TREE_CHAIN (*basep);
9769 TYPE_MARKED_P (ref) = 1;
9771 /* The binfo slot should be empty, unless this is an (ill-formed)
9773 gcc_assert (!TYPE_BINFO (ref) || TYPE_SIZE (ref));
9774 gcc_assert (TYPE_MAIN_VARIANT (ref) == ref);
9776 binfo = make_tree_binfo (max_bases);
9778 TYPE_BINFO (ref) = binfo;
9779 BINFO_OFFSET (binfo) = size_zero_node;
9780 BINFO_TYPE (binfo) = ref;
9784 BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, gc, max_bases);
9785 /* An aggregate cannot have baseclasses. */
9786 CLASSTYPE_NON_AGGREGATE (ref) = 1;
9788 if (TREE_CODE (ref) == UNION_TYPE)
9789 error ("derived union %qT invalid", ref);
9794 if (TYPE_FOR_JAVA (ref))
9795 error ("Java class %qT cannot have multiple bases", ref);
9800 CLASSTYPE_VBASECLASSES (ref) = VEC_alloc (tree, gc, max_vbases);
9802 if (TYPE_FOR_JAVA (ref))
9803 error ("Java class %qT cannot have virtual bases", ref);
9806 for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list))
9808 tree access = TREE_PURPOSE (base_list);
9809 int via_virtual = TREE_TYPE (base_list) != NULL_TREE;
9810 tree basetype = TREE_VALUE (base_list);
9812 if (access == access_default_node)
9813 access = default_access;
9815 if (TREE_CODE (basetype) == TYPE_DECL)
9816 basetype = TREE_TYPE (basetype);
9817 if (TREE_CODE (basetype) != RECORD_TYPE
9818 && TREE_CODE (basetype) != TYPENAME_TYPE
9819 && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
9820 && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM)
9822 error ("base type %qT fails to be a struct or class type",
9827 if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0))
9828 TYPE_FOR_JAVA (ref) = 1;
9830 base_binfo = NULL_TREE;
9831 if (CLASS_TYPE_P (basetype) && !dependent_type_p (basetype))
9833 base_binfo = TYPE_BINFO (basetype);
9834 /* The original basetype could have been a typedef'd type. */
9835 basetype = BINFO_TYPE (base_binfo);
9837 /* Inherit flags from the base. */
9838 TYPE_HAS_NEW_OPERATOR (ref)
9839 |= TYPE_HAS_NEW_OPERATOR (basetype);
9840 TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
9841 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
9842 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
9843 TYPE_HAS_CONVERSION (ref) |= TYPE_HAS_CONVERSION (basetype);
9844 CLASSTYPE_DIAMOND_SHAPED_P (ref)
9845 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype);
9846 CLASSTYPE_REPEATED_BASE_P (ref)
9847 |= CLASSTYPE_REPEATED_BASE_P (basetype);
9850 /* We must do this test after we've seen through a typedef
9852 if (TYPE_MARKED_P (basetype))
9854 if (basetype == ref)
9855 error ("recursive type %qT undefined", basetype);
9857 error ("duplicate base type %qT invalid", basetype);
9860 TYPE_MARKED_P (basetype) = 1;
9862 base_binfo = copy_binfo (base_binfo, basetype, ref,
9863 &igo_prev, via_virtual);
9864 if (!BINFO_INHERITANCE_CHAIN (base_binfo))
9865 BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
9867 BINFO_BASE_APPEND (binfo, base_binfo);
9868 BINFO_BASE_ACCESS_APPEND (binfo, access);
9871 if (VEC_space (tree, CLASSTYPE_VBASECLASSES (ref), 1))
9872 /* If we have space in the vbase vector, we must have shared at
9873 least one of them, and are therefore diamond shaped. */
9874 CLASSTYPE_DIAMOND_SHAPED_P (ref) = 1;
9876 /* Unmark all the types. */
9877 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
9878 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
9879 TYPE_MARKED_P (ref) = 0;
9881 /* Now see if we have a repeated base type. */
9882 if (!CLASSTYPE_REPEATED_BASE_P (ref))
9884 for (base_binfo = binfo; base_binfo;
9885 base_binfo = TREE_CHAIN (base_binfo))
9887 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
9889 CLASSTYPE_REPEATED_BASE_P (ref) = 1;
9892 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 1;
9894 for (base_binfo = binfo; base_binfo;
9895 base_binfo = TREE_CHAIN (base_binfo))
9896 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
9897 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
9904 /* Begin compiling the definition of an enumeration type.
9906 Returns the type object, as yet incomplete.
9907 Also records info about it so that build_enumerator
9908 may be used to declare the individual values as they are read. */
9911 start_enum (tree name)
9915 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
9917 /* If this is the real definition for a previous forward reference,
9918 fill in the contents in the same object that used to be the
9919 forward reference. */
9921 enumtype = lookup_and_check_tag (enum_type, name,
9922 /*tag_scope=*/ts_current,
9923 /*template_header_p=*/false);
9925 if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
9927 error ("multiple definition of %q#T", enumtype);
9928 error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype));
9929 /* Clear out TYPE_VALUES, and start again. */
9930 TYPE_VALUES (enumtype) = NULL_TREE;
9934 /* In case of error, make a dummy enum to allow parsing to
9936 if (enumtype == error_mark_node)
9937 name = make_anon_name ();
9939 enumtype = make_node (ENUMERAL_TYPE);
9940 enumtype = pushtag (name, enumtype, /*tag_scope=*/ts_current);
9946 /* After processing and defining all the values of an enumeration type,
9947 install their decls in the enumeration type and finish it off.
9948 ENUMTYPE is the type object and VALUES a list of name-value pairs. */
9951 finish_enum (tree enumtype)
9960 bool use_short_enum;
9964 integer_type_kind itk;
9965 tree underlying_type = NULL_TREE;
9967 /* We built up the VALUES in reverse order. */
9968 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
9970 /* For an enum defined in a template, just set the type of the values;
9971 all further processing is postponed until the template is
9972 instantiated. We need to set the type so that tsubst of a CONST_DECL
9974 if (processing_template_decl)
9976 for (values = TYPE_VALUES (enumtype);
9978 values = TREE_CHAIN (values))
9979 TREE_TYPE (TREE_VALUE (values)) = enumtype;
9980 if (at_function_scope_p ())
9981 add_stmt (build_min (TAG_DEFN, enumtype));
9985 /* Determine the minimum and maximum values of the enumerators. */
9986 if (TYPE_VALUES (enumtype))
9988 minnode = maxnode = NULL_TREE;
9990 for (values = TYPE_VALUES (enumtype);
9992 values = TREE_CHAIN (values))
9994 decl = TREE_VALUE (values);
9996 /* [dcl.enum]: Following the closing brace of an enum-specifier,
9997 each enumerator has the type of its enumeration. Prior to the
9998 closing brace, the type of each enumerator is the type of its
9999 initializing value. */
10000 TREE_TYPE (decl) = enumtype;
10002 /* Update the minimum and maximum values, if appropriate. */
10003 value = DECL_INITIAL (decl);
10004 if (value == error_mark_node)
10005 value = integer_zero_node;
10006 /* Figure out what the minimum and maximum values of the
10007 enumerators are. */
10009 minnode = maxnode = value;
10010 else if (tree_int_cst_lt (maxnode, value))
10012 else if (tree_int_cst_lt (value, minnode))
10019 If the enumerator-list is empty, the underlying type is as if
10020 the enumeration had a single enumerator with value 0. */
10021 minnode = maxnode = integer_zero_node;
10023 /* Compute the number of bits require to represent all values of the
10024 enumeration. We must do this before the type of MINNODE and
10025 MAXNODE are transformed, since min_precision relies on the
10026 TREE_TYPE of the value it is passed. */
10027 unsignedp = tree_int_cst_sgn (minnode) >= 0;
10028 lowprec = min_precision (minnode, unsignedp);
10029 highprec = min_precision (maxnode, unsignedp);
10030 precision = MAX (lowprec, highprec);
10032 /* Determine the underlying type of the enumeration.
10036 The underlying type of an enumeration is an integral type that
10037 can represent all the enumerator values defined in the
10038 enumeration. It is implementation-defined which integral type is
10039 used as the underlying type for an enumeration except that the
10040 underlying type shall not be larger than int unless the value of
10041 an enumerator cannot fit in an int or unsigned int.
10043 We use "int" or an "unsigned int" as the underlying type, even if
10044 a smaller integral type would work, unless the user has
10045 explicitly requested that we use the smallest possible type. The
10046 user can request that for all enumerations with a command line
10047 flag, or for just one enumeration with an attribute. */
10049 use_short_enum = flag_short_enums
10050 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype));
10052 for (itk = (use_short_enum ? itk_char : itk_int);
10056 underlying_type = integer_types[itk];
10057 if (TYPE_PRECISION (underlying_type) >= precision
10058 && TYPE_UNSIGNED (underlying_type) == unsignedp)
10061 if (itk == itk_none)
10065 IF no integral type can represent all the enumerator values, the
10066 enumeration is ill-formed. */
10067 error ("no integral type can represent all of the enumerator values "
10068 "for %qT", enumtype);
10069 precision = TYPE_PRECISION (long_long_integer_type_node);
10070 underlying_type = integer_types[itk_unsigned_long_long];
10073 /* Compute the minium and maximum values for the type.
10077 For an enumeration where emin is the smallest enumerator and emax
10078 is the largest, the values of the enumeration are the values of the
10079 underlying type in the range bmin to bmax, where bmin and bmax are,
10080 respectively, the smallest and largest values of the smallest bit-
10081 field that can store emin and emax. */
10083 /* The middle-end currently assumes that types with TYPE_PRECISION
10084 narrower than their underlying type are suitably zero or sign
10085 extended to fill their mode. g++ doesn't make these guarantees.
10086 Until the middle-end can represent such paradoxical types, we
10087 set the TYPE_PRECISION to the width of the underlying type. */
10088 TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type);
10090 set_min_and_max_values_for_integral_type (enumtype, precision, unsignedp);
10094 The value of sizeof() applied to an enumeration type, an object
10095 of an enumeration type, or an enumerator, is the value of sizeof()
10096 applied to the underlying type. */
10097 TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
10098 TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
10099 TYPE_MODE (enumtype) = TYPE_MODE (underlying_type);
10100 TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
10101 TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
10102 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);
10104 /* Convert each of the enumerators to the type of the underlying
10105 type of the enumeration. */
10106 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
10108 location_t saved_location;
10110 decl = TREE_VALUE (values);
10111 saved_location = input_location;
10112 input_location = DECL_SOURCE_LOCATION (decl);
10113 value = perform_implicit_conversion (underlying_type,
10114 DECL_INITIAL (decl));
10115 input_location = saved_location;
10117 /* Do not clobber shared ints. */
10118 value = copy_node (value);
10120 TREE_TYPE (value) = enumtype;
10121 DECL_INITIAL (decl) = value;
10122 TREE_VALUE (values) = value;
10125 /* Fix up all variant types of this enum type. */
10126 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
10128 TYPE_VALUES (t) = TYPE_VALUES (enumtype);
10129 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
10130 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
10131 TYPE_SIZE (t) = TYPE_SIZE (enumtype);
10132 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
10133 TYPE_MODE (t) = TYPE_MODE (enumtype);
10134 TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
10135 TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
10136 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
10137 TYPE_UNSIGNED (t) = TYPE_UNSIGNED (enumtype);
10140 /* Finish debugging output for this type. */
10141 rest_of_type_compilation (enumtype, namespace_bindings_p ());
10144 /* Build and install a CONST_DECL for an enumeration constant of the
10145 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
10146 Assignment of sequential values by default is handled here. */
10149 build_enumerator (tree name, tree value, tree enumtype)
10155 /* If the VALUE was erroneous, pretend it wasn't there; that will
10156 result in the enum being assigned the next value in sequence. */
10157 if (value == error_mark_node)
10160 /* Remove no-op casts from the value. */
10162 STRIP_TYPE_NOPS (value);
10164 if (! processing_template_decl)
10166 /* Validate and default VALUE. */
10167 if (value != NULL_TREE)
10169 value = integral_constant_value (value);
10171 if (TREE_CODE (value) == INTEGER_CST)
10173 value = perform_integral_promotions (value);
10174 constant_expression_warning (value);
10178 error ("enumerator value for %qD not integer constant", name);
10183 /* Default based on previous value. */
10184 if (value == NULL_TREE)
10186 if (TYPE_VALUES (enumtype))
10189 unsigned HOST_WIDE_INT lo;
10193 /* The next value is the previous value plus one. We can
10194 safely assume that the previous value is an INTEGER_CST.
10195 add_double doesn't know the type of the target expression,
10196 so we must check with int_fits_type_p as well. */
10197 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
10198 overflowed = add_double (TREE_INT_CST_LOW (prev_value),
10199 TREE_INT_CST_HIGH (prev_value),
10201 value = build_int_cst_wide (TREE_TYPE (prev_value), lo, hi);
10202 overflowed |= !int_fits_type_p (value, TREE_TYPE (prev_value));
10206 error ("overflow in enumeration values at %qD", name);
10207 value = error_mark_node;
10211 value = integer_zero_node;
10214 /* Remove no-op casts from the value. */
10215 STRIP_TYPE_NOPS (value);
10218 /* C++ associates enums with global, function, or class declarations. */
10219 context = current_scope ();
10221 /* Build the actual enumeration constant. Note that the enumeration
10222 constants have the type of their initializers until the
10223 enumeration is complete:
10227 Following the closing brace of an enum-specifier, each enumer-
10228 ator has the type of its enumeration. Prior to the closing
10229 brace, the type of each enumerator is the type of its
10230 initializing value.
10232 In finish_enum we will reset the type. Of course, if we're
10233 processing a template, there may be no value. */
10234 type = value ? TREE_TYPE (value) : NULL_TREE;
10236 if (context && context == current_class_type)
10237 /* This enum declaration is local to the class. We need the full
10238 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
10239 decl = build_lang_decl (CONST_DECL, name, type);
10241 /* It's a global enum, or it's local to a function. (Note local to
10242 a function could mean local to a class method. */
10243 decl = build_decl (CONST_DECL, name, type);
10245 DECL_CONTEXT (decl) = FROB_CONTEXT (context);
10246 TREE_CONSTANT (decl) = 1;
10247 TREE_INVARIANT (decl) = 1;
10248 TREE_READONLY (decl) = 1;
10249 DECL_INITIAL (decl) = value;
10251 if (context && context == current_class_type)
10252 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
10253 on the TYPE_FIELDS list for `S'. (That's so that you can say
10254 things like `S::i' later.) */
10255 finish_member_declaration (decl);
10259 /* Add this enumeration constant to the list for this type. */
10260 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
10264 /* We're defining DECL. Make sure that it's type is OK. */
10267 check_function_type (tree decl, tree current_function_parms)
10269 tree fntype = TREE_TYPE (decl);
10270 tree return_type = complete_type (TREE_TYPE (fntype));
10272 /* In a function definition, arg types must be complete. */
10273 require_complete_types_for_parms (current_function_parms);
10275 if (dependent_type_p (return_type))
10277 if (!COMPLETE_OR_VOID_TYPE_P (return_type))
10279 tree args = TYPE_ARG_TYPES (fntype);
10281 error ("return type %q#T is incomplete", return_type);
10283 /* Make it return void instead. */
10284 if (TREE_CODE (fntype) == METHOD_TYPE)
10285 fntype = build_method_type_directly (TREE_TYPE (TREE_VALUE (args)),
10287 TREE_CHAIN (args));
10289 fntype = build_function_type (void_type_node, args);
10291 = build_exception_variant (fntype,
10292 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)));
10295 abstract_virtuals_error (decl, TREE_TYPE (fntype));
10298 /* Create the FUNCTION_DECL for a function definition.
10299 DECLSPECS and DECLARATOR are the parts of the declaration;
10300 they describe the function's name and the type it returns,
10301 but twisted together in a fashion that parallels the syntax of C.
10303 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
10304 DECLARATOR is really the DECL for the function we are about to
10305 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
10306 indicating that the function is an inline defined in-class.
10308 This function creates a binding context for the function body
10309 as well as setting up the FUNCTION_DECL in current_function_decl.
10311 For C++, we must first check whether that datum makes any sense.
10312 For example, "class A local_a(1,2);" means that variable local_a
10313 is an aggregate of type A, which should have a constructor
10314 applied to it with the argument list [1, 2]. */
10317 start_preparsed_function (tree decl1, tree attrs, int flags)
10319 tree ctype = NULL_TREE;
10322 int doing_friend = 0;
10323 struct cp_binding_level *bl;
10324 tree current_function_parms;
10325 struct c_fileinfo *finfo
10326 = get_fileinfo (lbasename (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1))));
10327 bool honor_interface;
10329 /* Sanity check. */
10330 gcc_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE);
10331 gcc_assert (TREE_CHAIN (void_list_node) == NULL_TREE);
10333 fntype = TREE_TYPE (decl1);
10334 if (TREE_CODE (fntype) == METHOD_TYPE)
10335 ctype = TYPE_METHOD_BASETYPE (fntype);
10337 /* ISO C++ 11.4/5. A friend function defined in a class is in
10338 the (lexical) scope of the class in which it is defined. */
10339 if (!ctype && DECL_FRIEND_P (decl1))
10341 ctype = DECL_FRIEND_CONTEXT (decl1);
10343 /* CTYPE could be null here if we're dealing with a template;
10344 for example, `inline friend float foo()' inside a template
10345 will have no CTYPE set. */
10346 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
10352 if (DECL_DECLARED_INLINE_P (decl1)
10353 && lookup_attribute ("noinline", attrs))
10354 warning (0, "inline function %q+D given attribute noinline", decl1);
10356 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
10357 /* This is a constructor, we must ensure that any default args
10358 introduced by this definition are propagated to the clones
10359 now. The clones are used directly in overload resolution. */
10360 adjust_clone_args (decl1);
10362 /* Sometimes we don't notice that a function is a static member, and
10363 build a METHOD_TYPE for it. Fix that up now. */
10364 if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
10365 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
10367 revert_static_member_fn (decl1);
10371 /* Set up current_class_type, and enter the scope of the class, if
10374 push_nested_class (ctype);
10375 else if (DECL_STATIC_FUNCTION_P (decl1))
10376 push_nested_class (DECL_CONTEXT (decl1));
10378 /* Now that we have entered the scope of the class, we must restore
10379 the bindings for any template parameters surrounding DECL1, if it
10380 is an inline member template. (Order is important; consider the
10381 case where a template parameter has the same name as a field of
10382 the class.) It is not until after this point that
10383 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
10384 if (flags & SF_INCLASS_INLINE)
10385 maybe_begin_member_template_processing (decl1);
10387 /* Effective C++ rule 15. */
10389 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
10390 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
10391 warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");
10393 /* Make the init_value nonzero so pushdecl knows this is not tentative.
10394 error_mark_node is replaced below (in poplevel) with the BLOCK. */
10395 if (!DECL_INITIAL (decl1))
10396 DECL_INITIAL (decl1) = error_mark_node;
10398 /* This function exists in static storage.
10399 (This does not mean `static' in the C sense!) */
10400 TREE_STATIC (decl1) = 1;
10402 /* We must call push_template_decl after current_class_type is set
10403 up. (If we are processing inline definitions after exiting a
10404 class scope, current_class_type will be NULL_TREE until set above
10405 by push_nested_class.) */
10406 if (processing_template_decl)
10408 /* FIXME: Handle error_mark_node more gracefully. */
10409 tree newdecl1 = push_template_decl (decl1);
10410 if (newdecl1 != error_mark_node)
10414 /* We are now in the scope of the function being defined. */
10415 current_function_decl = decl1;
10417 /* Save the parm names or decls from this function's declarator
10418 where store_parm_decls will find them. */
10419 current_function_parms = DECL_ARGUMENTS (decl1);
10421 /* Make sure the parameter and return types are reasonable. When
10422 you declare a function, these types can be incomplete, but they
10423 must be complete when you define the function. */
10424 check_function_type (decl1, current_function_parms);
10425 /* Make sure no default arg is missing. */
10426 check_default_args (decl1);
10428 /* Build the return declaration for the function. */
10429 restype = TREE_TYPE (fntype);
10430 /* Promote the value to int before returning it. */
10431 if (c_promoting_integer_type_p (restype))
10432 restype = type_promotes_to (restype);
10433 if (DECL_RESULT (decl1) == NULL_TREE)
10437 resdecl = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
10438 DECL_ARTIFICIAL (resdecl) = 1;
10439 DECL_IGNORED_P (resdecl) = 1;
10440 DECL_RESULT (decl1) = resdecl;
10442 cp_apply_type_quals_to_decl (cp_type_quals (restype), resdecl);
10445 /* Initialize RTL machinery. We cannot do this until
10446 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
10447 even when processing a template; this is how we get
10448 CFUN set up, and our per-function variables initialized.
10449 FIXME factor out the non-RTL stuff. */
10450 bl = current_binding_level;
10451 allocate_struct_function (decl1);
10452 current_binding_level = bl;
10454 /* Even though we're inside a function body, we still don't want to
10455 call expand_expr to calculate the size of a variable-sized array.
10456 We haven't necessarily assigned RTL to all variables yet, so it's
10457 not safe to try to expand expressions involving them. */
10458 cfun->x_dont_save_pending_sizes_p = 1;
10460 /* Start the statement-tree, start the tree now. */
10461 DECL_SAVED_TREE (decl1) = push_stmt_list ();
10463 /* Let the user know we're compiling this function. */
10464 announce_function (decl1);
10466 /* Record the decl so that the function name is defined.
10467 If we already have a decl for this name, and it is a FUNCTION_DECL,
10468 use the old decl. */
10469 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
10471 /* A specialization is not used to guide overload resolution. */
10472 if (!DECL_FUNCTION_MEMBER_P (decl1)
10473 && !(DECL_USE_TEMPLATE (decl1) &&
10474 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1))))
10476 tree olddecl = pushdecl (decl1);
10478 if (olddecl == error_mark_node)
10479 /* If something went wrong when registering the declaration,
10480 use DECL1; we have to have a FUNCTION_DECL to use when
10481 parsing the body of the function. */
10484 /* Otherwise, OLDDECL is either a previous declaration of
10485 the same function or DECL1 itself. */
10490 /* We need to set the DECL_CONTEXT. */
10491 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
10492 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
10494 fntype = TREE_TYPE (decl1);
10496 /* If #pragma weak applies, mark the decl appropriately now.
10497 The pragma only applies to global functions. Because
10498 determining whether or not the #pragma applies involves
10499 computing the mangled name for the declaration, we cannot
10500 apply the pragma until after we have merged this declaration
10501 with any previous declarations; if the original declaration
10502 has a linkage specification, that specification applies to
10503 the definition as well, and may affect the mangled name. */
10504 if (!DECL_CONTEXT (decl1))
10505 maybe_apply_pragma_weak (decl1);
10508 /* Reset these in case the call to pushdecl changed them. */
10509 current_function_decl = decl1;
10510 cfun->decl = decl1;
10512 /* If we are (erroneously) defining a function that we have already
10513 defined before, wipe out what we knew before. */
10514 if (!DECL_PENDING_INLINE_P (decl1))
10515 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
10517 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
10519 /* We know that this was set up by `grokclassfn'. We do not
10520 wait until `store_parm_decls', since evil parse errors may
10521 never get us to that point. Here we keep the consistency
10522 between `current_class_type' and `current_class_ptr'. */
10523 tree t = DECL_ARGUMENTS (decl1);
10525 gcc_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL);
10526 gcc_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE);
10528 cp_function_chain->x_current_class_ref
10529 = build_indirect_ref (t, NULL);
10530 cp_function_chain->x_current_class_ptr = t;
10532 /* Constructors and destructors need to know whether they're "in
10533 charge" of initializing virtual base classes. */
10534 t = TREE_CHAIN (t);
10535 if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
10537 current_in_charge_parm = t;
10538 t = TREE_CHAIN (t);
10540 if (DECL_HAS_VTT_PARM_P (decl1))
10542 gcc_assert (DECL_NAME (t) == vtt_parm_identifier);
10543 current_vtt_parm = t;
10547 honor_interface = (!DECL_TEMPLATE_INSTANTIATION (decl1)
10548 /* Implicitly-defined methods (like the
10549 destructor for a class in which no destructor
10550 is explicitly declared) must not be defined
10551 until their definition is needed. So, we
10552 ignore interface specifications for
10553 compiler-generated functions. */
10554 && !DECL_ARTIFICIAL (decl1));
10556 if (DECL_INTERFACE_KNOWN (decl1))
10558 tree ctx = decl_function_context (decl1);
10560 if (DECL_NOT_REALLY_EXTERN (decl1))
10561 DECL_EXTERNAL (decl1) = 0;
10563 if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
10564 && TREE_PUBLIC (ctx))
10565 /* This is a function in a local class in an extern inline
10567 comdat_linkage (decl1);
10569 /* If this function belongs to an interface, it is public.
10570 If it belongs to someone else's interface, it is also external.
10571 This only affects inlines and template instantiations. */
10572 else if (!finfo->interface_unknown && honor_interface)
10574 if (DECL_DECLARED_INLINE_P (decl1)
10575 || DECL_TEMPLATE_INSTANTIATION (decl1)
10576 || processing_template_decl)
10578 DECL_EXTERNAL (decl1)
10579 = (finfo->interface_only
10580 || (DECL_DECLARED_INLINE_P (decl1)
10581 && ! flag_implement_inlines
10582 && !DECL_VINDEX (decl1)));
10584 /* For WIN32 we also want to put these in linkonce sections. */
10585 maybe_make_one_only (decl1);
10588 DECL_EXTERNAL (decl1) = 0;
10589 DECL_INTERFACE_KNOWN (decl1) = 1;
10590 /* If this function is in an interface implemented in this file,
10591 make sure that the backend knows to emit this function
10593 if (!DECL_EXTERNAL (decl1))
10594 mark_needed (decl1);
10596 else if (finfo->interface_unknown && finfo->interface_only
10597 && honor_interface)
10599 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
10600 interface, we will have both finfo->interface_unknown and
10601 finfo->interface_only set. In that case, we don't want to
10602 use the normal heuristics because someone will supply a
10603 #pragma implementation elsewhere, and deducing it here would
10604 produce a conflict. */
10605 comdat_linkage (decl1);
10606 DECL_EXTERNAL (decl1) = 0;
10607 DECL_INTERFACE_KNOWN (decl1) = 1;
10608 DECL_DEFER_OUTPUT (decl1) = 1;
10612 /* This is a definition, not a reference.
10613 So clear DECL_EXTERNAL. */
10614 DECL_EXTERNAL (decl1) = 0;
10616 if ((DECL_DECLARED_INLINE_P (decl1)
10617 || DECL_TEMPLATE_INSTANTIATION (decl1))
10618 && ! DECL_INTERFACE_KNOWN (decl1)
10619 /* Don't try to defer nested functions for now. */
10620 && ! decl_function_context (decl1))
10621 DECL_DEFER_OUTPUT (decl1) = 1;
10623 DECL_INTERFACE_KNOWN (decl1) = 1;
10626 /* Determine the ELF visibility attribute for the function. We must not
10627 do this before calling "pushdecl", as we must allow "duplicate_decls"
10628 to merge any attributes appropriately. We also need to wait until
10630 if (!DECL_CLONED_FUNCTION_P (decl1))
10631 determine_visibility (decl1);
10633 begin_scope (sk_function_parms, decl1);
10637 if (DECL_DESTRUCTOR_P (decl1)
10638 || (DECL_CONSTRUCTOR_P (decl1)
10639 && targetm.cxx.cdtor_returns_this ()))
10641 cdtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
10642 DECL_CONTEXT (cdtor_label) = current_function_decl;
10645 start_fname_decls ();
10647 store_parm_decls (current_function_parms);
10651 /* Like start_preparsed_function, except that instead of a
10652 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
10654 Returns 1 on success. If the DECLARATOR is not suitable for a function
10655 (it defines a datum instead), we return 0, which tells
10656 yyparse to report a parse error. */
10659 start_function (cp_decl_specifier_seq *declspecs,
10660 const cp_declarator *declarator,
10665 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
10666 /* If the declarator is not suitable for a function definition,
10667 cause a syntax error. */
10668 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
10671 if (DECL_MAIN_P (decl1))
10672 /* main must return int. grokfndecl should have corrected it
10673 (and issued a diagnostic) if the user got it wrong. */
10674 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1)),
10675 integer_type_node));
10677 start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT);
10682 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
10686 use_eh_spec_block (tree fn)
10688 return (flag_exceptions && flag_enforce_eh_specs
10689 && !processing_template_decl
10690 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn))
10691 /* We insert the EH_SPEC_BLOCK only in the original
10692 function; then, it is copied automatically to the
10694 && !DECL_CLONED_FUNCTION_P (fn)
10695 /* Implicitly-generated constructors and destructors have
10696 exception specifications. However, those specifications
10697 are the union of the possible exceptions specified by the
10698 constructors/destructors for bases and members, so no
10699 unallowed exception will ever reach this function. By
10700 not creating the EH_SPEC_BLOCK we save a little memory,
10701 and we avoid spurious warnings about unreachable
10703 && !DECL_ARTIFICIAL (fn));
10706 /* Store the parameter declarations into the current function declaration.
10707 This is called after parsing the parameter declarations, before
10708 digesting the body of the function.
10710 Also install to binding contour return value identifier, if any. */
10713 store_parm_decls (tree current_function_parms)
10715 tree fndecl = current_function_decl;
10718 /* This is a chain of any other decls that came in among the parm
10719 declarations. If a parm is declared with enum {foo, bar} x;
10720 then CONST_DECLs for foo and bar are put here. */
10721 tree nonparms = NULL_TREE;
10723 if (current_function_parms)
10725 /* This case is when the function was defined with an ANSI prototype.
10726 The parms already have decls, so we need not do anything here
10727 except record them as in effect
10728 and complain if any redundant old-style parm decls were written. */
10730 tree specparms = current_function_parms;
10733 /* Must clear this because it might contain TYPE_DECLs declared
10735 current_binding_level->names = NULL;
10737 /* If we're doing semantic analysis, then we'll call pushdecl
10738 for each of these. We must do them in reverse order so that
10739 they end in the correct forward order. */
10740 specparms = nreverse (specparms);
10742 for (parm = specparms; parm; parm = next)
10744 next = TREE_CHAIN (parm);
10745 if (TREE_CODE (parm) == PARM_DECL)
10747 if (DECL_NAME (parm) == NULL_TREE
10748 || TREE_CODE (parm) != VOID_TYPE)
10751 error ("parameter %qD declared void", parm);
10755 /* If we find an enum constant or a type tag,
10756 put it aside for the moment. */
10757 TREE_CHAIN (parm) = NULL_TREE;
10758 nonparms = chainon (nonparms, parm);
10762 /* Get the decls in their original chain order and record in the
10763 function. This is all and only the PARM_DECLs that were
10764 pushed into scope by the loop above. */
10765 DECL_ARGUMENTS (fndecl) = getdecls ();
10768 DECL_ARGUMENTS (fndecl) = NULL_TREE;
10770 /* Now store the final chain of decls for the arguments
10771 as the decl-chain of the current lexical scope.
10772 Put the enumerators in as well, at the front so that
10773 DECL_ARGUMENTS is not modified. */
10774 current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));
10776 if (use_eh_spec_block (current_function_decl))
10777 current_eh_spec_block = begin_eh_spec_block ();
10781 /* We have finished doing semantic analysis on DECL, but have not yet
10782 generated RTL for its body. Save away our current state, so that
10783 when we want to generate RTL later we know what to do. */
10786 save_function_data (tree decl)
10788 struct language_function *f;
10790 /* Save the language-specific per-function data so that we can
10791 get it back when we really expand this function. */
10792 gcc_assert (!DECL_PENDING_INLINE_P (decl));
10795 f = GGC_NEW (struct language_function);
10796 memcpy (f, cp_function_chain, sizeof (struct language_function));
10797 DECL_SAVED_FUNCTION_DATA (decl) = f;
10799 /* Clear out the bits we don't need. */
10800 f->base.x_stmt_tree.x_cur_stmt_list = NULL_TREE;
10801 f->bindings = NULL;
10802 f->x_local_names = NULL;
10806 /* Set the return value of the constructor (if present). */
10809 finish_constructor_body (void)
10814 if (targetm.cxx.cdtor_returns_this ())
10816 /* Any return from a constructor will end up here. */
10817 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
10819 val = DECL_ARGUMENTS (current_function_decl);
10820 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
10821 DECL_RESULT (current_function_decl), val);
10822 /* Return the address of the object. */
10823 exprstmt = build_stmt (RETURN_EXPR, val);
10824 add_stmt (exprstmt);
10828 /* Do all the processing for the beginning of a destructor; set up the
10829 vtable pointers and cleanups for bases and members. */
10832 begin_destructor_body (void)
10834 tree compound_stmt;
10836 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
10837 issued an error message. We still want to try to process the
10838 body of the function, but initialize_vtbl_ptrs will crash if
10839 TYPE_BINFO is NULL. */
10840 if (COMPLETE_TYPE_P (current_class_type))
10842 compound_stmt = begin_compound_stmt (0);
10843 /* Make all virtual function table pointers in non-virtual base
10844 classes point to CURRENT_CLASS_TYPE's virtual function
10846 initialize_vtbl_ptrs (current_class_ptr);
10847 finish_compound_stmt (compound_stmt);
10849 /* And insert cleanups for our bases and members so that they
10850 will be properly destroyed if we throw. */
10851 push_base_cleanups ();
10855 /* At the end of every destructor we generate code to delete the object if
10856 necessary. Do that now. */
10859 finish_destructor_body (void)
10863 /* Any return from a destructor will end up here; that way all base
10864 and member cleanups will be run when the function returns. */
10865 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
10867 /* In a virtual destructor, we must call delete. */
10868 if (DECL_VIRTUAL_P (current_function_decl))
10871 tree virtual_size = cxx_sizeof (current_class_type);
10875 At the point of definition of a virtual destructor (including
10876 an implicit definition), non-placement operator delete shall
10877 be looked up in the scope of the destructor's class and if
10878 found shall be accessible and unambiguous. */
10879 exprstmt = build_op_delete_call(DELETE_EXPR, current_class_ptr,
10881 /*global_p=*/false,
10882 /*placement=*/NULL_TREE,
10883 /*alloc_fn=*/NULL_TREE);
10885 if_stmt = begin_if_stmt ();
10886 finish_if_stmt_cond (build2 (BIT_AND_EXPR, integer_type_node,
10887 current_in_charge_parm,
10890 finish_expr_stmt (exprstmt);
10891 finish_then_clause (if_stmt);
10892 finish_if_stmt (if_stmt);
10895 if (targetm.cxx.cdtor_returns_this ())
10899 val = DECL_ARGUMENTS (current_function_decl);
10900 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
10901 DECL_RESULT (current_function_decl), val);
10902 /* Return the address of the object. */
10903 exprstmt = build_stmt (RETURN_EXPR, val);
10904 add_stmt (exprstmt);
10908 /* Do the necessary processing for the beginning of a function body, which
10909 in this case includes member-initializers, but not the catch clauses of
10910 a function-try-block. Currently, this means opening a binding level
10911 for the member-initializers (in a ctor) and member cleanups (in a dtor). */
10914 begin_function_body (void)
10918 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
10921 if (processing_template_decl)
10922 /* Do nothing now. */;
10924 /* Always keep the BLOCK node associated with the outermost pair of
10925 curly braces of a function. These are needed for correct
10926 operation of dwarfout.c. */
10927 keep_next_level (true);
10929 stmt = begin_compound_stmt (BCS_FN_BODY);
10931 if (processing_template_decl)
10932 /* Do nothing now. */;
10933 else if (DECL_DESTRUCTOR_P (current_function_decl))
10934 begin_destructor_body ();
10939 /* Do the processing for the end of a function body. Currently, this means
10940 closing out the cleanups for fully-constructed bases and members, and in
10941 the case of the destructor, deleting the object if desired. Again, this
10942 is only meaningful for [cd]tors, since they are the only functions where
10943 there is a significant distinction between the main body and any
10944 function catch clauses. Handling, say, main() return semantics here
10945 would be wrong, as flowing off the end of a function catch clause for
10946 main() would also need to return 0. */
10949 finish_function_body (tree compstmt)
10951 if (compstmt == NULL_TREE)
10954 /* Close the block. */
10955 finish_compound_stmt (compstmt);
10957 if (processing_template_decl)
10958 /* Do nothing now. */;
10959 else if (DECL_CONSTRUCTOR_P (current_function_decl))
10960 finish_constructor_body ();
10961 else if (DECL_DESTRUCTOR_P (current_function_decl))
10962 finish_destructor_body ();
10965 /* Given a function, returns the BLOCK corresponding to the outermost level
10966 of curly braces, skipping the artificial block created for constructor
10970 outer_curly_brace_block (tree fndecl)
10972 tree block = BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl));
10973 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
10974 /* Skip the artificial function body block. */
10975 block = BLOCK_SUBBLOCKS (block);
10979 /* Finish up a function declaration and compile that function
10980 all the way to assembler language output. The free the storage
10981 for the function definition.
10983 FLAGS is a bitwise or of the following values:
10985 We just finished processing the body of an in-class inline
10986 function definition. (This processing will have taken place
10987 after the class definition is complete.) */
10990 finish_function (int flags)
10992 tree fndecl = current_function_decl;
10993 tree fntype, ctype = NULL_TREE;
10994 int inclass_inline = (flags & 2) != 0;
10997 /* When we get some parse errors, we can end up without a
10998 current_function_decl, so cope. */
10999 if (fndecl == NULL_TREE)
11000 return error_mark_node;
11002 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
11003 && DECL_VIRTUAL_P (fndecl)
11004 && !processing_template_decl)
11006 tree fnclass = DECL_CONTEXT (fndecl);
11007 if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
11008 keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
11011 nested = function_depth > 1;
11012 fntype = TREE_TYPE (fndecl);
11014 /* TREE_READONLY (fndecl) = 1;
11015 This caused &foo to be of type ptr-to-const-function
11016 which then got a warning when stored in a ptr-to-function variable. */
11018 gcc_assert (building_stmt_tree ());
11020 /* For a cloned function, we've already got all the code we need;
11021 there's no need to add any extra bits. */
11022 if (!DECL_CLONED_FUNCTION_P (fndecl))
11024 if (DECL_MAIN_P (current_function_decl))
11028 /* Make it so that `main' always returns 0 by default (or
11031 stmt = finish_return_stmt (integer_one_node);
11033 stmt = finish_return_stmt (integer_zero_node);
11035 /* Hack. We don't want the middle-end to warn that this
11036 return is unreachable, so put the statement on the
11038 #ifdef USE_MAPPED_LOCATION
11039 SET_EXPR_LOCATION (stmt, UNKNOWN_LOCATION);
11041 annotate_with_file_line (stmt, input_filename, 0);
11045 if (use_eh_spec_block (current_function_decl))
11046 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
11047 (TREE_TYPE (current_function_decl)),
11048 current_eh_spec_block);
11051 /* If we're saving up tree structure, tie off the function now. */
11052 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
11054 finish_fname_decls ();
11056 /* If this function can't throw any exceptions, remember that. */
11057 if (!processing_template_decl
11058 && !cp_function_chain->can_throw
11059 && !flag_non_call_exceptions)
11060 TREE_NOTHROW (fndecl) = 1;
11062 /* This must come after expand_function_end because cleanups might
11063 have declarations (from inline functions) that need to go into
11064 this function's blocks. */
11066 /* If the current binding level isn't the outermost binding level
11067 for this function, either there is a bug, or we have experienced
11068 syntax errors and the statement tree is malformed. */
11069 if (current_binding_level->kind != sk_function_parms)
11071 /* Make sure we have already experienced errors. */
11072 gcc_assert (errorcount);
11074 /* Throw away the broken statement tree and extra binding
11076 DECL_SAVED_TREE (fndecl) = alloc_stmt_list ();
11078 while (current_binding_level->kind != sk_function_parms)
11080 if (current_binding_level->kind == sk_class)
11081 pop_nested_class ();
11083 poplevel (0, 0, 0);
11086 poplevel (1, 0, 1);
11088 /* Statements should always be full-expressions at the outermost set
11089 of curly braces for a function. */
11090 gcc_assert (stmts_are_full_exprs_p ());
11092 /* Set up the named return value optimization, if we can. Candidate
11093 variables are selected in check_return_value. */
11094 if (current_function_return_value)
11096 tree r = current_function_return_value;
11099 if (r != error_mark_node
11100 /* This is only worth doing for fns that return in memory--and
11101 simpler, since we don't have to worry about promoted modes. */
11102 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
11103 /* Only allow this for variables declared in the outer scope of
11104 the function so we know that their lifetime always ends with a
11105 return; see g++.dg/opt/nrv6.C. We could be more flexible if
11106 we were to do this optimization in tree-ssa. */
11107 && (outer = outer_curly_brace_block (fndecl))
11108 && chain_member (r, BLOCK_VARS (outer)))
11109 finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));
11111 current_function_return_value = NULL_TREE;
11114 /* Remember that we were in class scope. */
11115 if (current_class_name)
11116 ctype = current_class_type;
11118 /* Must mark the RESULT_DECL as being in this function. */
11119 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
11121 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
11122 to the FUNCTION_DECL node itself. */
11123 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
11125 /* Save away current state, if appropriate. */
11126 if (!processing_template_decl)
11127 save_function_data (fndecl);
11129 /* Complain if there's just no return statement. */
11130 if (warn_return_type
11131 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
11132 && !dependent_type_p (TREE_TYPE (fntype))
11133 && !current_function_returns_value && !current_function_returns_null
11134 /* Don't complain if we abort or throw. */
11135 && !current_function_returns_abnormally
11136 && !DECL_NAME (DECL_RESULT (fndecl))
11137 /* Normally, with -Wreturn-type, flow will complain. Unless we're an
11138 inline function, as we might never be compiled separately. */
11139 && (DECL_INLINE (fndecl) || processing_template_decl)
11140 /* Structor return values (if any) are set by the compiler. */
11141 && !DECL_CONSTRUCTOR_P (fndecl)
11142 && !DECL_DESTRUCTOR_P (fndecl))
11143 warning (OPT_Wreturn_type, "no return statement in function returning non-void");
11145 /* Store the end of the function, so that we get good line number
11146 info for the epilogue. */
11147 cfun->function_end_locus = input_location;
11149 /* Genericize before inlining. */
11150 if (!processing_template_decl)
11152 struct language_function *f = DECL_SAVED_FUNCTION_DATA (fndecl);
11153 cp_genericize (fndecl);
11154 /* Clear out the bits we don't need. */
11155 f->x_current_class_ptr = NULL;
11156 f->x_current_class_ref = NULL;
11157 f->x_eh_spec_block = NULL;
11158 f->x_in_charge_parm = NULL;
11159 f->x_vtt_parm = NULL;
11160 f->x_return_value = NULL;
11161 f->bindings = NULL;
11162 f->extern_decl_map = NULL;
11164 /* Handle attribute((warn_unused_result)). Relies on gimple input. */
11165 c_warn_unused_result (&DECL_SAVED_TREE (fndecl));
11167 /* Clear out the bits we don't need. */
11168 local_names = NULL;
11170 /* We're leaving the context of this function, so zap cfun. It's still in
11171 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
11173 current_function_decl = NULL;
11175 /* If this is an in-class inline definition, we may have to pop the
11176 bindings for the template parameters that we added in
11177 maybe_begin_member_template_processing when start_function was
11179 if (inclass_inline)
11180 maybe_end_member_template_processing ();
11182 /* Leave the scope of the class. */
11184 pop_nested_class ();
11190 /* Let the error reporting routines know that we're outside a
11191 function. For a nested function, this value is used in
11192 cxx_pop_function_context and then reset via pop_function_context. */
11193 current_function_decl = NULL_TREE;
11198 /* Create the FUNCTION_DECL for a function definition.
11199 DECLSPECS and DECLARATOR are the parts of the declaration;
11200 they describe the return type and the name of the function,
11201 but twisted together in a fashion that parallels the syntax of C.
11203 This function creates a binding context for the function body
11204 as well as setting up the FUNCTION_DECL in current_function_decl.
11206 Returns a FUNCTION_DECL on success.
11208 If the DECLARATOR is not suitable for a function (it defines a datum
11209 instead), we return 0, which tells yyparse to report a parse error.
11211 May return void_type_node indicating that this method is actually
11212 a friend. See grokfield for more details.
11214 Came here with a `.pushlevel' .
11216 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
11217 CHANGES TO CODE IN `grokfield'. */
11220 start_method (cp_decl_specifier_seq *declspecs,
11221 const cp_declarator *declarator, tree attrlist)
11223 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
11226 if (fndecl == error_mark_node)
11227 return error_mark_node;
11229 if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
11231 error ("invalid member function declaration");
11232 return error_mark_node;
11236 cplus_decl_attributes (&fndecl, attrlist, 0);
11238 /* Pass friends other than inline friend functions back. */
11239 if (fndecl == void_type_node)
11242 if (DECL_IN_AGGR_P (fndecl))
11244 if (DECL_CONTEXT (fndecl)
11245 && TREE_CODE (DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
11246 error ("%qD is already defined in class %qT", fndecl,
11247 DECL_CONTEXT (fndecl));
11248 return error_mark_node;
11251 check_template_shadow (fndecl);
11253 DECL_DECLARED_INLINE_P (fndecl) = 1;
11254 if (flag_default_inline)
11255 DECL_INLINE (fndecl) = 1;
11257 /* We process method specializations in finish_struct_1. */
11258 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
11260 fndecl = push_template_decl (fndecl);
11261 if (fndecl == error_mark_node)
11265 if (! DECL_FRIEND_P (fndecl))
11267 if (TREE_CHAIN (fndecl))
11269 fndecl = copy_node (fndecl);
11270 TREE_CHAIN (fndecl) = NULL_TREE;
11274 finish_decl (fndecl, NULL_TREE, NULL_TREE);
11276 /* Make a place for the parms. */
11277 begin_scope (sk_function_parms, fndecl);
11279 DECL_IN_AGGR_P (fndecl) = 1;
11283 /* Go through the motions of finishing a function definition.
11284 We don't compile this method until after the whole class has
11287 FINISH_METHOD must return something that looks as though it
11288 came from GROKFIELD (since we are defining a method, after all).
11290 This is called after parsing the body of the function definition.
11291 STMTS is the chain of statements that makes up the function body.
11293 DECL is the ..._DECL that `start_method' provided. */
11296 finish_method (tree decl)
11298 tree fndecl = decl;
11303 if (decl == void_type_node)
11306 old_initial = DECL_INITIAL (fndecl);
11308 /* Undo the level for the parms (from start_method).
11309 This is like poplevel, but it causes nothing to be
11310 saved. Saving information here confuses symbol-table
11311 output routines. Besides, this information will
11312 be correctly output when this method is actually
11315 /* Clear out the meanings of the local variables of this level;
11316 also record in each decl which block it belongs to. */
11318 for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
11320 if (DECL_NAME (link) != NULL_TREE)
11321 pop_binding (DECL_NAME (link), link);
11322 gcc_assert (TREE_CODE (link) != FUNCTION_DECL);
11323 DECL_CONTEXT (link) = NULL_TREE;
11326 poplevel (0, 0, 0);
11328 DECL_INITIAL (fndecl) = old_initial;
11330 /* We used to check if the context of FNDECL was different from
11331 current_class_type as another way to get inside here. This didn't work
11332 for String.cc in libg++. */
11333 if (DECL_FRIEND_P (fndecl))
11335 VEC_safe_push (tree, gc, CLASSTYPE_INLINE_FRIENDS (current_class_type),
11337 decl = void_type_node;
11344 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
11345 we can lay it out later, when and if its type becomes complete. */
11348 maybe_register_incomplete_var (tree var)
11350 gcc_assert (TREE_CODE (var) == VAR_DECL);
11352 /* Keep track of variables with incomplete types. */
11353 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
11354 && DECL_EXTERNAL (var))
11356 tree inner_type = TREE_TYPE (var);
11358 while (TREE_CODE (inner_type) == ARRAY_TYPE)
11359 inner_type = TREE_TYPE (inner_type);
11360 inner_type = TYPE_MAIN_VARIANT (inner_type);
11362 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
11363 /* RTTI TD entries are created while defining the type_info. */
11364 || (TYPE_LANG_SPECIFIC (inner_type)
11365 && TYPE_BEING_DEFINED (inner_type)))
11366 incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
11370 /* Called when a class type (given by TYPE) is defined. If there are
11371 any existing VAR_DECLs whose type hsa been completed by this
11372 declaration, update them now. */
11375 complete_vars (tree type)
11377 tree *list = &incomplete_vars;
11379 gcc_assert (CLASS_TYPE_P (type));
11382 if (same_type_p (type, TREE_PURPOSE (*list)))
11384 tree var = TREE_VALUE (*list);
11385 tree type = TREE_TYPE (var);
11386 /* Complete the type of the variable. The VAR_DECL itself
11387 will be laid out in expand_expr. */
11388 complete_type (type);
11389 cp_apply_type_quals_to_decl (cp_type_quals (type), var);
11390 /* Remove this entry from the list. */
11391 *list = TREE_CHAIN (*list);
11394 list = &TREE_CHAIN (*list);
11397 /* Check for pending declarations which may have abstract type. */
11398 complete_type_check_abstract (type);
11401 /* If DECL is of a type which needs a cleanup, build that cleanup
11405 cxx_maybe_build_cleanup (tree decl)
11407 tree type = TREE_TYPE (decl);
11409 if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
11411 int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
11413 bool has_vbases = (TREE_CODE (type) == RECORD_TYPE
11414 && CLASSTYPE_VBASECLASSES (type));
11416 if (TREE_CODE (type) == ARRAY_TYPE)
11420 cxx_mark_addressable (decl);
11421 rval = build_unary_op (ADDR_EXPR, decl, 0);
11424 /* Optimize for space over speed here. */
11425 if (!has_vbases || flag_expensive_optimizations)
11426 flags |= LOOKUP_NONVIRTUAL;
11428 rval = build_delete (TREE_TYPE (rval), rval,
11429 sfk_complete_destructor, flags, 0);
11436 /* When a stmt has been parsed, this function is called. */
11443 /* DECL was originally constructed as a non-static member function,
11444 but turned out to be static. Update it accordingly. */
11447 revert_static_member_fn (tree decl)
11450 tree function = TREE_TYPE (decl);
11451 tree args = TYPE_ARG_TYPES (function);
11453 if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
11454 != TYPE_UNQUALIFIED)
11455 error ("static member function %q#D declared with type qualifiers", decl);
11457 args = TREE_CHAIN (args);
11458 tmp = build_function_type (TREE_TYPE (function), args);
11459 tmp = build_qualified_type (tmp, cp_type_quals (function));
11460 tmp = build_exception_variant (tmp,
11461 TYPE_RAISES_EXCEPTIONS (function));
11462 TREE_TYPE (decl) = tmp;
11463 if (DECL_ARGUMENTS (decl))
11464 DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
11465 DECL_STATIC_FUNCTION_P (decl) = 1;
11468 /* Initialize the variables used during compilation of a C++
11472 cxx_push_function_context (struct function * f)
11474 struct language_function *p = GGC_CNEW (struct language_function);
11477 /* Whenever we start a new function, we destroy temporaries in the
11479 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
11485 if (DECL_SAVED_FUNCTION_DATA (fn))
11487 /* If we already parsed this function, and we're just expanding it
11488 now, restore saved state. */
11489 *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (fn);
11491 /* We don't need the saved data anymore. Unless this is an inline
11492 function; we need the named return value info for
11493 declare_return_variable. */
11494 if (! DECL_INLINE (fn))
11495 DECL_SAVED_FUNCTION_DATA (fn) = NULL;
11500 /* Free the language-specific parts of F, now that we've finished
11501 compiling the function. */
11504 cxx_pop_function_context (struct function * f)
11509 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
11510 one of the language-independent trees. */
11512 enum cp_tree_node_structure_enum
11513 cp_tree_node_structure (union lang_tree_node * t)
11515 switch (TREE_CODE (&t->generic))
11517 case DEFAULT_ARG: return TS_CP_DEFAULT_ARG;
11518 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER;
11519 case OVERLOAD: return TS_CP_OVERLOAD;
11520 case TEMPLATE_PARM_INDEX: return TS_CP_TPI;
11521 case TINST_LEVEL: return TS_CP_TINST_LEVEL;
11522 case PTRMEM_CST: return TS_CP_PTRMEM;
11523 case BASELINK: return TS_CP_BASELINK;
11524 default: return TS_CP_GENERIC;
11528 /* Build the void_list_node (void_type_node having been created). */
11530 build_void_list_node (void)
11532 tree t = build_tree_list (NULL_TREE, void_type_node);
11537 cp_missing_noreturn_ok_p (tree decl)
11539 /* A missing noreturn is ok for the `main' function. */
11540 return DECL_MAIN_P (decl);
11543 /* Return the COMDAT group into which DECL should be placed. */
11546 cxx_comdat_group (tree decl)
11550 /* Virtual tables, construction virtual tables, and virtual table
11551 tables all go in a single COMDAT group, named after the primary
11553 if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
11554 name = DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl)));
11555 /* For all other DECLs, the COMDAT group is the mangled name of the
11556 declaration itself. */
11559 while (DECL_THUNK_P (decl))
11561 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
11562 into the same section as the target function. In that case
11563 we must return target's name. */
11564 tree target = THUNK_TARGET (decl);
11565 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target)
11566 && DECL_SECTION_NAME (target) != NULL
11567 && DECL_ONE_ONLY (target))
11572 name = DECL_ASSEMBLER_NAME (decl);
11575 return IDENTIFIER_POINTER (name);
11578 #include "gt-cp-decl.h"