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);
1380 error ("conflicting declaration %q#D", newdecl);
1381 error ("%q+D has a previous declaration as %q#D", olddecl, olddecl);
1382 return error_mark_node;
1385 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1386 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
1387 && (!DECL_TEMPLATE_INFO (newdecl)
1388 || (DECL_TI_TEMPLATE (newdecl)
1389 != DECL_TI_TEMPLATE (olddecl))))
1390 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
1391 && (!DECL_TEMPLATE_INFO (olddecl)
1392 || (DECL_TI_TEMPLATE (olddecl)
1393 != DECL_TI_TEMPLATE (newdecl))))))
1394 /* It's OK to have a template specialization and a non-template
1395 with the same type, or to have specializations of two
1396 different templates with the same type. Note that if one is a
1397 specialization, and the other is an instantiation of the same
1398 template, that we do not exit at this point. That situation
1399 can occur if we instantiate a template class, and then
1400 specialize one of its methods. This situation is valid, but
1401 the declarations must be merged in the usual way. */
1403 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1404 && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
1405 && !DECL_USE_TEMPLATE (newdecl))
1406 || (DECL_TEMPLATE_INSTANTIATION (newdecl)
1407 && !DECL_USE_TEMPLATE (olddecl))))
1408 /* One of the declarations is a template instantiation, and the
1409 other is not a template at all. That's OK. */
1411 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1413 /* In [namespace.alias] we have:
1415 In a declarative region, a namespace-alias-definition can be
1416 used to redefine a namespace-alias declared in that declarative
1417 region to refer only to the namespace to which it already
1420 Therefore, if we encounter a second alias directive for the same
1421 alias, we can just ignore the second directive. */
1422 if (DECL_NAMESPACE_ALIAS (newdecl)
1423 && (DECL_NAMESPACE_ALIAS (newdecl)
1424 == DECL_NAMESPACE_ALIAS (olddecl)))
1426 /* [namespace.alias]
1428 A namespace-name or namespace-alias shall not be declared as
1429 the name of any other entity in the same declarative region.
1430 A namespace-name defined at global scope shall not be
1431 declared as the name of any other entity in any global scope
1433 error ("declaration of namespace %qD conflicts with", newdecl);
1434 error ("previous declaration of namespace %q+D here", olddecl);
1435 return error_mark_node;
1439 const char *errmsg = redeclaration_error_message (newdecl, olddecl);
1442 error (errmsg, newdecl);
1443 if (DECL_NAME (olddecl) != NULL_TREE)
1444 error ((DECL_INITIAL (olddecl) && namespace_bindings_p ())
1445 ? "%q+#D previously defined here"
1446 : "%q+#D previously declared here", olddecl);
1447 return error_mark_node;
1449 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1450 && DECL_INITIAL (olddecl) != NULL_TREE
1451 && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
1452 && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
1454 /* Prototype decl follows defn w/o prototype. */
1455 warning (0, "prototype for %q+#D", newdecl);
1456 warning (0, "%Jfollows non-prototype definition here", olddecl);
1458 else if ((TREE_CODE (olddecl) == FUNCTION_DECL
1459 || TREE_CODE (olddecl) == VAR_DECL)
1460 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
1463 If two declarations of the same function or object
1464 specify different linkage-specifications ..., the program
1465 is ill-formed.... Except for functions with C++ linkage,
1466 a function declaration without a linkage specification
1467 shall not precede the first linkage specification for
1468 that function. A function can be declared without a
1469 linkage specification after an explicit linkage
1470 specification has been seen; the linkage explicitly
1471 specified in the earlier declaration is not affected by
1472 such a function declaration.
1474 DR 563 raises the question why the restrictions on
1475 functions should not also apply to objects. Older
1476 versions of G++ silently ignore the linkage-specification
1484 which is clearly wrong. Therefore, we now treat objects
1486 if (current_lang_depth () == 0)
1488 /* There is no explicit linkage-specification, so we use
1489 the linkage from the previous declaration. */
1490 if (!DECL_LANG_SPECIFIC (newdecl))
1491 retrofit_lang_decl (newdecl);
1492 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1496 error ("previous declaration of %q+#D with %qL linkage",
1497 olddecl, DECL_LANGUAGE (olddecl));
1498 error ("conflicts with new declaration with %qL linkage",
1499 DECL_LANGUAGE (newdecl));
1503 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
1505 else if (TREE_CODE (olddecl) == FUNCTION_DECL)
1507 tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1508 tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1511 if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
1512 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
1514 for (; t1 && t1 != void_list_node;
1515 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
1516 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
1518 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
1521 pedwarn ("default argument given for parameter %d of %q#D",
1523 pedwarn ("after previous specification in %q+#D", olddecl);
1527 error ("default argument given for parameter %d of %q#D",
1529 error ("after previous specification in %q+#D",
1534 if (DECL_DECLARED_INLINE_P (newdecl)
1535 && ! DECL_DECLARED_INLINE_P (olddecl)
1536 && TREE_ADDRESSABLE (olddecl) && warn_inline)
1538 warning (0, "%q#D was used before it was declared inline", newdecl);
1539 warning (0, "%Jprevious non-inline declaration here", olddecl);
1544 /* Do not merge an implicit typedef with an explicit one. In:
1548 typedef class A A __attribute__ ((foo));
1550 the attribute should apply only to the typedef. */
1551 if (TREE_CODE (olddecl) == TYPE_DECL
1552 && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
1553 || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
1556 /* If new decl is `static' and an `extern' was seen previously,
1558 warn_extern_redeclared_static (newdecl, olddecl);
1560 /* We have committed to returning 1 at this point. */
1561 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1563 /* Now that functions must hold information normally held
1564 by field decls, there is extra work to do so that
1565 declaration information does not get destroyed during
1567 if (DECL_VINDEX (olddecl))
1568 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
1569 if (DECL_CONTEXT (olddecl))
1570 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1571 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
1572 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1573 DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
1574 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
1575 DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
1576 if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
1577 SET_OVERLOADED_OPERATOR_CODE
1578 (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
1579 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
1581 /* Optionally warn about more than one declaration for the same
1582 name, but don't warn about a function declaration followed by a
1584 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
1585 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
1586 /* Don't warn about extern decl followed by definition. */
1587 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
1588 /* Don't warn about friends, let add_friend take care of it. */
1589 && ! (newdecl_is_friend || DECL_FRIEND_P (olddecl)))
1591 warning (OPT_Wredundant_decls, "redundant redeclaration of %qD in same scope", newdecl);
1592 warning (OPT_Wredundant_decls, "previous declaration of %q+D", olddecl);
1596 /* Deal with C++: must preserve virtual function table size. */
1597 if (TREE_CODE (olddecl) == TYPE_DECL)
1599 tree newtype = TREE_TYPE (newdecl);
1600 tree oldtype = TREE_TYPE (olddecl);
1602 if (newtype != error_mark_node && oldtype != error_mark_node
1603 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
1604 CLASSTYPE_FRIEND_CLASSES (newtype)
1605 = CLASSTYPE_FRIEND_CLASSES (oldtype);
1607 DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
1610 /* Copy all the DECL_... slots specified in the new decl
1611 except for any that we copy here from the old type. */
1612 DECL_ATTRIBUTES (newdecl)
1613 = (*targetm.merge_decl_attributes) (olddecl, newdecl);
1615 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1619 old_result = DECL_TEMPLATE_RESULT (olddecl);
1620 new_result = DECL_TEMPLATE_RESULT (newdecl);
1621 TREE_TYPE (olddecl) = TREE_TYPE (old_result);
1622 DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
1623 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
1624 DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
1626 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1628 DECL_INLINE (old_result)
1629 |= DECL_INLINE (new_result);
1630 DECL_DECLARED_INLINE_P (old_result)
1631 |= DECL_DECLARED_INLINE_P (new_result);
1632 check_redeclaration_exception_specification (newdecl, olddecl);
1635 /* If the new declaration is a definition, update the file and
1636 line information on the declaration. */
1637 if (DECL_INITIAL (old_result) == NULL_TREE
1638 && DECL_INITIAL (new_result) != NULL_TREE)
1640 DECL_SOURCE_LOCATION (olddecl)
1641 = DECL_SOURCE_LOCATION (old_result)
1642 = DECL_SOURCE_LOCATION (newdecl);
1643 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1644 DECL_ARGUMENTS (old_result)
1645 = DECL_ARGUMENTS (new_result);
1653 /* Automatically handles default parameters. */
1654 tree oldtype = TREE_TYPE (olddecl);
1657 /* Merge the data types specified in the two decls. */
1658 newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1660 /* If merge_types produces a non-typedef type, just use the old type. */
1661 if (TREE_CODE (newdecl) == TYPE_DECL
1662 && newtype == DECL_ORIGINAL_TYPE (newdecl))
1665 if (TREE_CODE (newdecl) == VAR_DECL)
1667 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
1668 DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
1669 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl)
1670 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl);
1671 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl)
1672 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl);
1674 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
1675 if (DECL_LANG_SPECIFIC (olddecl)
1676 && CP_DECL_THREADPRIVATE_P (olddecl))
1678 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
1679 if (!DECL_LANG_SPECIFIC (newdecl))
1680 retrofit_lang_decl (newdecl);
1682 DECL_TLS_MODEL (newdecl) = DECL_TLS_MODEL (olddecl);
1683 CP_DECL_THREADPRIVATE_P (newdecl) = 1;
1687 /* Do this after calling `merge_types' so that default
1688 parameters don't confuse us. */
1689 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1690 check_redeclaration_exception_specification (newdecl, olddecl);
1691 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
1693 /* Lay the type out, unless already done. */
1694 if (! same_type_p (newtype, oldtype)
1695 && TREE_TYPE (newdecl) != error_mark_node
1696 && !(processing_template_decl && uses_template_parms (newdecl)))
1697 layout_type (TREE_TYPE (newdecl));
1699 if ((TREE_CODE (newdecl) == VAR_DECL
1700 || TREE_CODE (newdecl) == PARM_DECL
1701 || TREE_CODE (newdecl) == RESULT_DECL
1702 || TREE_CODE (newdecl) == FIELD_DECL
1703 || TREE_CODE (newdecl) == TYPE_DECL)
1704 && !(processing_template_decl && uses_template_parms (newdecl)))
1705 layout_decl (newdecl, 0);
1707 /* Merge the type qualifiers. */
1708 if (TREE_READONLY (newdecl))
1709 TREE_READONLY (olddecl) = 1;
1710 if (TREE_THIS_VOLATILE (newdecl))
1711 TREE_THIS_VOLATILE (olddecl) = 1;
1712 if (TREE_NOTHROW (newdecl))
1713 TREE_NOTHROW (olddecl) = 1;
1715 /* Merge deprecatedness. */
1716 if (TREE_DEPRECATED (newdecl))
1717 TREE_DEPRECATED (olddecl) = 1;
1719 /* Merge the initialization information. */
1720 if (DECL_INITIAL (newdecl) == NULL_TREE
1721 && DECL_INITIAL (olddecl) != NULL_TREE)
1723 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1724 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
1725 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
1726 && DECL_LANG_SPECIFIC (newdecl)
1727 && DECL_LANG_SPECIFIC (olddecl))
1729 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1730 DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
1734 /* Merge the section attribute.
1735 We want to issue an error if the sections conflict but that must be
1736 done later in decl_attributes since we are called before attributes
1738 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1739 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1741 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1743 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1744 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1745 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1746 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1747 TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
1748 TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl);
1749 DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
1750 DECL_IS_PURE (newdecl) |= DECL_IS_PURE (olddecl);
1751 /* Keep the old RTL. */
1752 COPY_DECL_RTL (olddecl, newdecl);
1754 else if (TREE_CODE (newdecl) == VAR_DECL
1755 && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
1757 /* Keep the old RTL. We cannot keep the old RTL if the old
1758 declaration was for an incomplete object and the new
1759 declaration is not since many attributes of the RTL will
1761 COPY_DECL_RTL (olddecl, newdecl);
1764 /* If cannot merge, then use the new type and qualifiers,
1765 and don't preserve the old rtl. */
1768 /* Clean out any memory we had of the old declaration. */
1769 tree oldstatic = value_member (olddecl, static_aggregates);
1771 TREE_VALUE (oldstatic) = error_mark_node;
1773 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1774 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1775 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1776 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1779 /* Merge the storage class information. */
1780 merge_weak (newdecl, olddecl);
1782 DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
1783 DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
1784 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1785 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
1786 if (! DECL_EXTERNAL (olddecl))
1787 DECL_EXTERNAL (newdecl) = 0;
1789 new_template = NULL_TREE;
1790 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
1792 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
1793 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
1794 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
1795 DECL_TEMPLATE_INSTANTIATED (newdecl)
1796 |= DECL_TEMPLATE_INSTANTIATED (olddecl);
1798 /* If the OLDDECL is an instantiation and/or specialization,
1799 then the NEWDECL must be too. But, it may not yet be marked
1800 as such if the caller has created NEWDECL, but has not yet
1801 figured out that it is a redeclaration. */
1802 if (!DECL_USE_TEMPLATE (newdecl))
1803 DECL_USE_TEMPLATE (newdecl) = DECL_USE_TEMPLATE (olddecl);
1805 /* Don't really know how much of the language-specific
1806 values we should copy from old to new. */
1807 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
1808 DECL_LANG_SPECIFIC (newdecl)->decl_flags.u2 =
1809 DECL_LANG_SPECIFIC (olddecl)->decl_flags.u2;
1810 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
1811 DECL_REPO_AVAILABLE_P (newdecl) = DECL_REPO_AVAILABLE_P (olddecl);
1812 if (DECL_TEMPLATE_INFO (newdecl))
1813 new_template = DECL_TI_TEMPLATE (newdecl);
1814 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
1815 DECL_INITIALIZED_IN_CLASS_P (newdecl)
1816 |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
1817 olddecl_friend = DECL_FRIEND_P (olddecl);
1818 hidden_friend = (DECL_ANTICIPATED (olddecl)
1819 && DECL_HIDDEN_FRIEND_P (olddecl)
1820 && newdecl_is_friend);
1822 /* Only functions have DECL_BEFRIENDING_CLASSES. */
1823 if (TREE_CODE (newdecl) == FUNCTION_DECL
1824 || DECL_FUNCTION_TEMPLATE_P (newdecl))
1826 DECL_BEFRIENDING_CLASSES (newdecl)
1827 = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
1828 DECL_BEFRIENDING_CLASSES (olddecl));
1829 /* DECL_THUNKS is only valid for virtual functions,
1830 otherwise it is a DECL_FRIEND_CONTEXT. */
1831 if (DECL_VIRTUAL_P (newdecl))
1832 DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl);
1836 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1838 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
1839 && !DECL_TEMPLATE_INSTANTIATION (newdecl))
1841 /* If newdecl is not a specialization, then it is not a
1842 template-related function at all. And that means that we
1843 should have exited above, returning 0. */
1844 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl));
1846 if (TREE_USED (olddecl))
1847 /* From [temp.expl.spec]:
1849 If a template, a member template or the member of a class
1850 template is explicitly specialized then that
1851 specialization shall be declared before the first use of
1852 that specialization that would cause an implicit
1853 instantiation to take place, in every translation unit in
1854 which such a use occurs. */
1855 error ("explicit specialization of %qD after first use",
1858 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
1860 /* [temp.expl.spec/14] We don't inline explicit specialization
1861 just because the primary template says so. */
1865 if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
1866 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
1868 DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
1870 /* If either decl says `inline', this fn is inline, unless
1871 its definition was passed already. */
1872 if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
1873 DECL_INLINE (olddecl) = 1;
1874 DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
1876 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
1877 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
1880 /* Preserve abstractness on cloned [cd]tors. */
1881 DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
1885 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1886 COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
1887 COPY_DECL_RTL (newdecl, olddecl);
1889 if (! types_match || new_defines_function)
1891 /* These need to be copied so that the names are available.
1892 Note that if the types do match, we'll preserve inline
1893 info and other bits, but if not, we won't. */
1894 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
1895 DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
1897 if (new_defines_function)
1898 /* If defining a function declared with other language
1899 linkage, use the previously declared language linkage. */
1900 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1901 else if (types_match)
1903 /* If redeclaring a builtin function, and not a definition,
1904 it stays built in. */
1905 if (DECL_BUILT_IN (olddecl))
1907 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
1908 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
1909 /* If we're keeping the built-in definition, keep the rtl,
1910 regardless of declaration matches. */
1911 COPY_DECL_RTL (olddecl, newdecl);
1914 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
1915 /* Don't clear out the arguments if we're redefining a function. */
1916 if (DECL_ARGUMENTS (olddecl))
1917 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
1920 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1921 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
1923 /* Now preserve various other info from the definition. */
1924 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
1925 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
1926 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
1927 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
1929 /* Warn about conflicting visibility specifications. */
1930 if (DECL_VISIBILITY_SPECIFIED (olddecl)
1931 && DECL_VISIBILITY_SPECIFIED (newdecl)
1932 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
1934 warning (OPT_Wattributes, "%q+D: visibility attribute ignored "
1935 "because it", newdecl);
1936 warning (OPT_Wattributes, "%Jconflicts with previous "
1937 "declaration here", olddecl);
1939 /* Choose the declaration which specified visibility. */
1940 if (DECL_VISIBILITY_SPECIFIED (olddecl))
1942 DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
1943 DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
1945 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
1946 so keep this behavior. */
1947 if (TREE_CODE (newdecl) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (newdecl))
1949 SET_DECL_INIT_PRIORITY (olddecl, DECL_INIT_PRIORITY (newdecl));
1950 DECL_HAS_INIT_PRIORITY_P (olddecl) = 1;
1953 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
1954 with that from NEWDECL below. */
1955 if (DECL_LANG_SPECIFIC (olddecl))
1957 gcc_assert (DECL_LANG_SPECIFIC (olddecl)
1958 != DECL_LANG_SPECIFIC (newdecl));
1959 ggc_free (DECL_LANG_SPECIFIC (olddecl));
1962 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1966 function_size = sizeof (struct tree_decl_common);
1968 memcpy ((char *) olddecl + sizeof (struct tree_common),
1969 (char *) newdecl + sizeof (struct tree_common),
1970 function_size - sizeof (struct tree_common));
1972 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
1973 (char *) newdecl + sizeof (struct tree_decl_common),
1974 sizeof (struct tree_function_decl) - sizeof (struct tree_decl_common));
1976 /* If newdecl is a template instantiation, it is possible that
1977 the following sequence of events has occurred:
1979 o A friend function was declared in a class template. The
1980 class template was instantiated.
1982 o The instantiation of the friend declaration was
1983 recorded on the instantiation list, and is newdecl.
1985 o Later, however, instantiate_class_template called pushdecl
1986 on the newdecl to perform name injection. But, pushdecl in
1987 turn called duplicate_decls when it discovered that another
1988 declaration of a global function with the same name already
1991 o Here, in duplicate_decls, we decided to clobber newdecl.
1993 If we're going to do that, we'd better make sure that
1994 olddecl, and not newdecl, is on the list of
1995 instantiations so that if we try to do the instantiation
1996 again we won't get the clobbered declaration. */
1997 reregister_specialization (newdecl,
2003 size_t size = tree_code_size (TREE_CODE (olddecl));
2004 memcpy ((char *) olddecl + sizeof (struct tree_common),
2005 (char *) newdecl + sizeof (struct tree_common),
2006 sizeof (struct tree_decl_common) - sizeof (struct tree_common));
2007 switch (TREE_CODE (olddecl))
2017 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2018 (char *) newdecl + sizeof (struct tree_decl_common),
2019 size - sizeof (struct tree_decl_common)
2020 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2024 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2025 (char *) newdecl + sizeof (struct tree_decl_common),
2026 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common)
2027 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2031 DECL_UID (olddecl) = olddecl_uid;
2033 DECL_FRIEND_P (olddecl) = 1;
2036 DECL_ANTICIPATED (olddecl) = 1;
2037 DECL_HIDDEN_FRIEND_P (olddecl) = 1;
2040 /* NEWDECL contains the merged attribute lists.
2041 Update OLDDECL to be the same. */
2042 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
2044 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2045 so that encode_section_info has a chance to look at the new decl
2046 flags and attributes. */
2047 if (DECL_RTL_SET_P (olddecl)
2048 && (TREE_CODE (olddecl) == FUNCTION_DECL
2049 || (TREE_CODE (olddecl) == VAR_DECL
2050 && TREE_STATIC (olddecl))))
2051 make_decl_rtl (olddecl);
2053 /* The NEWDECL will no longer be needed. Because every out-of-class
2054 declaration of a member results in a call to duplicate_decls,
2055 freeing these nodes represents in a significant savings. */
2061 /* Return zero if the declaration NEWDECL is valid
2062 when the declaration OLDDECL (assumed to be for the same name)
2063 has already been seen.
2064 Otherwise return an error message format string with a %s
2065 where the identifier should go. */
2068 redeclaration_error_message (tree newdecl, tree olddecl)
2070 if (TREE_CODE (newdecl) == TYPE_DECL)
2072 /* Because C++ can put things into name space for free,
2073 constructs like "typedef struct foo { ... } foo"
2074 would look like an erroneous redeclaration. */
2075 if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
2078 return "redefinition of %q#D";
2080 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
2082 /* If this is a pure function, its olddecl will actually be
2083 the original initialization to `0' (which we force to call
2084 abort()). Don't complain about redefinition in this case. */
2085 if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl)
2086 && DECL_INITIAL (olddecl) == NULL_TREE)
2089 /* If both functions come from different namespaces, this is not
2090 a redeclaration - this is a conflict with a used function. */
2091 if (DECL_NAMESPACE_SCOPE_P (olddecl)
2092 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl)
2093 && ! decls_match (olddecl, newdecl))
2094 return "%qD conflicts with used function";
2096 /* We'll complain about linkage mismatches in
2097 warn_extern_redeclared_static. */
2099 /* Defining the same name twice is no good. */
2100 if (DECL_INITIAL (olddecl) != NULL_TREE
2101 && DECL_INITIAL (newdecl) != NULL_TREE)
2103 if (DECL_NAME (olddecl) == NULL_TREE)
2104 return "%q#D not declared in class";
2106 return "redefinition of %q#D";
2110 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2114 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2116 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl))
2117 && COMPLETE_TYPE_P (TREE_TYPE (olddecl)))
2118 return "redefinition of %q#D";
2122 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL
2123 || (DECL_TEMPLATE_RESULT (newdecl)
2124 == DECL_TEMPLATE_RESULT (olddecl)))
2127 nt = DECL_TEMPLATE_RESULT (newdecl);
2128 if (DECL_TEMPLATE_INFO (nt))
2129 nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt));
2130 ot = DECL_TEMPLATE_RESULT (olddecl);
2131 if (DECL_TEMPLATE_INFO (ot))
2132 ot = DECL_TEMPLATE_RESULT (template_for_substitution (ot));
2133 if (DECL_INITIAL (nt) && DECL_INITIAL (ot))
2134 return "redefinition of %q#D";
2138 else if (TREE_CODE (newdecl) == VAR_DECL
2139 && DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl)
2140 && (! DECL_LANG_SPECIFIC (olddecl)
2141 || ! CP_DECL_THREADPRIVATE_P (olddecl)
2142 || DECL_THREAD_LOCAL_P (newdecl)))
2144 /* Only variables can be thread-local, and all declarations must
2145 agree on this property. */
2146 if (DECL_THREAD_LOCAL_P (newdecl))
2147 return "thread-local declaration of %q#D follows "
2148 "non-thread-local declaration";
2150 return "non-thread-local declaration of %q#D follows "
2151 "thread-local declaration";
2153 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
2155 /* Objects declared at top level: */
2156 /* If at least one is a reference, it's ok. */
2157 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2159 /* Reject two definitions. */
2160 return "redefinition of %q#D";
2164 /* Objects declared with block scope: */
2165 /* Reject two definitions, and reject a definition
2166 together with an external reference. */
2167 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
2168 return "redeclaration of %q#D";
2173 /* Hash and equality functions for the named_label table. */
2176 named_label_entry_hash (const void *data)
2178 const struct named_label_entry *ent = (const struct named_label_entry *) data;
2179 return DECL_UID (ent->label_decl);
2183 named_label_entry_eq (const void *a, const void *b)
2185 const struct named_label_entry *ent_a = (const struct named_label_entry *) a;
2186 const struct named_label_entry *ent_b = (const struct named_label_entry *) b;
2187 return ent_a->label_decl == ent_b->label_decl;
2190 /* Create a new label, named ID. */
2193 make_label_decl (tree id, int local_p)
2195 struct named_label_entry *ent;
2199 decl = build_decl (LABEL_DECL, id, void_type_node);
2201 DECL_CONTEXT (decl) = current_function_decl;
2202 DECL_MODE (decl) = VOIDmode;
2203 C_DECLARED_LABEL_FLAG (decl) = local_p;
2205 /* Say where one reference is to the label, for the sake of the
2206 error if it is not defined. */
2207 DECL_SOURCE_LOCATION (decl) = input_location;
2209 /* Record the fact that this identifier is bound to this label. */
2210 SET_IDENTIFIER_LABEL_VALUE (id, decl);
2212 /* Create the label htab for the function on demand. */
2214 named_labels = htab_create_ggc (13, named_label_entry_hash,
2215 named_label_entry_eq, NULL);
2217 /* Record this label on the list of labels used in this function.
2218 We do this before calling make_label_decl so that we get the
2219 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2220 ent = GGC_CNEW (struct named_label_entry);
2221 ent->label_decl = decl;
2223 slot = htab_find_slot (named_labels, ent, INSERT);
2224 gcc_assert (*slot == NULL);
2230 /* Look for a label named ID in the current function. If one cannot
2231 be found, create one. (We keep track of used, but undefined,
2232 labels, and complain about them at the end of a function.) */
2235 lookup_label (tree id)
2239 timevar_push (TV_NAME_LOOKUP);
2240 /* You can't use labels at global scope. */
2241 if (current_function_decl == NULL_TREE)
2243 error ("label %qE referenced outside of any function", id);
2244 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2247 /* See if we've already got this label. */
2248 decl = IDENTIFIER_LABEL_VALUE (id);
2249 if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
2250 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2252 decl = make_label_decl (id, /*local_p=*/0);
2253 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2256 /* Declare a local label named ID. */
2259 declare_local_label (tree id)
2263 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2264 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2265 shadow = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
2266 current_binding_level->shadowed_labels);
2267 current_binding_level->shadowed_labels = shadow;
2269 decl = make_label_decl (id, /*local_p=*/1);
2270 TREE_VALUE (shadow) = decl;
2275 /* Returns nonzero if it is ill-formed to jump past the declaration of
2276 DECL. Returns 2 if it's also a real problem. */
2279 decl_jump_unsafe (tree decl)
2281 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl)
2282 || TREE_TYPE (decl) == error_mark_node)
2285 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
2286 || DECL_NONTRIVIALLY_INITIALIZED_P (decl))
2289 if (pod_type_p (TREE_TYPE (decl)))
2292 /* The POD stuff is just pedantry; why should it matter if the class
2293 contains a field of pointer to member type? */
2297 /* A subroutine of check_previous_goto_1 to identify a branch to the user. */
2300 identify_goto (tree decl, const location_t *locus)
2303 pedwarn ("jump to label %qD", decl);
2305 pedwarn ("jump to case label");
2307 pedwarn ("%H from here", locus);
2310 /* Check that a single previously seen jump to a newly defined label
2311 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2312 the jump context; NAMES are the names in scope in LEVEL at the jump
2313 context; LOCUS is the source position of the jump or 0. Returns
2314 true if all is well. */
2317 check_previous_goto_1 (tree decl, struct cp_binding_level* level, tree names,
2318 bool exited_omp, const location_t *locus)
2320 struct cp_binding_level *b;
2321 bool identified = false, saw_eh = false, saw_omp = false;
2325 identify_goto (decl, locus);
2326 error (" exits OpenMP structured block");
2327 identified = saw_omp = true;
2330 for (b = current_binding_level; b ; b = b->level_chain)
2332 tree new_decls, old_decls = (b == level ? names : NULL_TREE);
2334 for (new_decls = b->names; new_decls != old_decls;
2335 new_decls = TREE_CHAIN (new_decls))
2337 int problem = decl_jump_unsafe (new_decls);
2343 identify_goto (decl, locus);
2347 error (" crosses initialization of %q+#D", new_decls);
2349 pedwarn (" enters scope of non-POD %q+#D", new_decls);
2354 if ((b->kind == sk_try || b->kind == sk_catch) && !saw_eh)
2358 identify_goto (decl, locus);
2361 if (b->kind == sk_try)
2362 error (" enters try block");
2364 error (" enters catch block");
2367 if (b->kind == sk_omp && !saw_omp)
2371 identify_goto (decl, locus);
2374 error (" enters OpenMP structured block");
2383 check_previous_goto (tree decl, struct named_label_use_entry *use)
2385 check_previous_goto_1 (decl, use->binding_level,
2386 use->names_in_scope, use->in_omp_scope,
2387 &use->o_goto_locus);
2391 check_switch_goto (struct cp_binding_level* level)
2393 return check_previous_goto_1 (NULL_TREE, level, level->names, false, NULL);
2396 /* Check that a new jump to a label DECL is OK. Called by
2397 finish_goto_stmt. */
2400 check_goto (tree decl)
2402 struct named_label_entry *ent, dummy;
2403 bool saw_catch = false, identified = false;
2406 /* We can't know where a computed goto is jumping.
2407 So we assume that it's OK. */
2408 if (TREE_CODE (decl) != LABEL_DECL)
2411 /* We didn't record any information about this label when we created it,
2412 and there's not much point since it's trivial to analyze as a return. */
2413 if (decl == cdtor_label)
2416 dummy.label_decl = decl;
2417 ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2418 gcc_assert (ent != NULL);
2420 /* If the label hasn't been defined yet, defer checking. */
2421 if (! DECL_INITIAL (decl))
2423 struct named_label_use_entry *new_use;
2425 /* Don't bother creating another use if the last goto had the
2426 same data, and will therefore create the same set of errors. */
2428 && ent->uses->names_in_scope == current_binding_level->names)
2431 new_use = GGC_NEW (struct named_label_use_entry);
2432 new_use->binding_level = current_binding_level;
2433 new_use->names_in_scope = current_binding_level->names;
2434 new_use->o_goto_locus = input_location;
2435 new_use->in_omp_scope = false;
2437 new_use->next = ent->uses;
2438 ent->uses = new_use;
2442 if (ent->in_try_scope || ent->in_catch_scope
2443 || ent->in_omp_scope || ent->bad_decls)
2445 pedwarn ("jump to label %q+D", decl);
2446 pedwarn (" from here");
2450 for (bad = ent->bad_decls; bad; bad = TREE_CHAIN (bad))
2452 tree b = TREE_VALUE (bad);
2453 int u = decl_jump_unsafe (b);
2455 if (u > 1 && DECL_ARTIFICIAL (b))
2457 /* Can't skip init of __exception_info. */
2458 error ("%J enters catch block", b);
2462 error (" skips initialization of %q+#D", b);
2464 pedwarn (" enters scope of non-POD %q+#D", b);
2467 if (ent->in_try_scope)
2468 error (" enters try block");
2469 else if (ent->in_catch_scope && !saw_catch)
2470 error (" enters catch block");
2472 if (ent->in_omp_scope)
2473 error (" enters OpenMP structured block");
2474 else if (flag_openmp)
2476 struct cp_binding_level *b;
2477 for (b = current_binding_level; b ; b = b->level_chain)
2479 if (b == ent->binding_level)
2481 if (b->kind == sk_omp)
2485 pedwarn ("jump to label %q+D", decl);
2486 pedwarn (" from here");
2489 error (" exits OpenMP structured block");
2496 /* Check that a return is ok wrt OpenMP structured blocks.
2497 Called by finish_return_stmt. Returns true if all is well. */
2500 check_omp_return (void)
2502 struct cp_binding_level *b;
2503 for (b = current_binding_level; b ; b = b->level_chain)
2504 if (b->kind == sk_omp)
2506 error ("invalid exit from OpenMP structured block");
2512 /* Define a label, specifying the location in the source file.
2513 Return the LABEL_DECL node for the label. */
2516 define_label (location_t location, tree name)
2518 struct named_label_entry *ent, dummy;
2519 struct cp_binding_level *p;
2522 timevar_push (TV_NAME_LOOKUP);
2524 decl = lookup_label (name);
2526 dummy.label_decl = decl;
2527 ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2528 gcc_assert (ent != NULL);
2530 /* After labels, make any new cleanups in the function go into their
2531 own new (temporary) binding contour. */
2532 for (p = current_binding_level;
2533 p->kind != sk_function_parms;
2535 p->more_cleanups_ok = 0;
2537 if (name == get_identifier ("wchar_t"))
2538 pedwarn ("label named wchar_t");
2540 if (DECL_INITIAL (decl) != NULL_TREE)
2541 error ("duplicate label %qD", decl);
2544 struct named_label_use_entry *use;
2546 /* Mark label as having been defined. */
2547 DECL_INITIAL (decl) = error_mark_node;
2548 /* Say where in the source. */
2549 DECL_SOURCE_LOCATION (decl) = location;
2551 ent->binding_level = current_binding_level;
2552 ent->names_in_scope = current_binding_level->names;
2554 for (use = ent->uses; use ; use = use->next)
2555 check_previous_goto (decl, use);
2559 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2564 struct cp_binding_level *level;
2565 struct cp_switch *next;
2566 /* The SWITCH_STMT being built. */
2568 /* A splay-tree mapping the low element of a case range to the high
2569 element, or NULL_TREE if there is no high element. Used to
2570 determine whether or not a new case label duplicates an old case
2571 label. We need a tree, rather than simply a hash table, because
2572 of the GNU case range extension. */
2576 /* A stack of the currently active switch statements. The innermost
2577 switch statement is on the top of the stack. There is no need to
2578 mark the stack for garbage collection because it is only active
2579 during the processing of the body of a function, and we never
2580 collect at that point. */
2582 static struct cp_switch *switch_stack;
2584 /* Called right after a switch-statement condition is parsed.
2585 SWITCH_STMT is the switch statement being parsed. */
2588 push_switch (tree switch_stmt)
2590 struct cp_switch *p = XNEW (struct cp_switch);
2591 p->level = current_binding_level;
2592 p->next = switch_stack;
2593 p->switch_stmt = switch_stmt;
2594 p->cases = splay_tree_new (case_compare, NULL, NULL);
2601 struct cp_switch *cs = switch_stack;
2602 location_t switch_location;
2604 /* Emit warnings as needed. */
2605 if (EXPR_HAS_LOCATION (cs->switch_stmt))
2606 switch_location = EXPR_LOCATION (cs->switch_stmt);
2608 switch_location = input_location;
2609 if (!processing_template_decl)
2610 c_do_switch_warnings (cs->cases, switch_location,
2611 SWITCH_STMT_TYPE (cs->switch_stmt),
2612 SWITCH_STMT_COND (cs->switch_stmt));
2614 splay_tree_delete (cs->cases);
2615 switch_stack = switch_stack->next;
2619 /* Note that we've seen a definition of a case label, and complain if this
2620 is a bad place for one. */
2623 finish_case_label (tree low_value, tree high_value)
2626 struct cp_binding_level *p;
2628 if (processing_template_decl)
2632 /* For templates, just add the case label; we'll do semantic
2633 analysis at instantiation-time. */
2634 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
2635 return add_stmt (build_case_label (low_value, high_value, label));
2638 /* Find the condition on which this switch statement depends. */
2639 cond = SWITCH_STMT_COND (switch_stack->switch_stmt);
2640 if (cond && TREE_CODE (cond) == TREE_LIST)
2641 cond = TREE_VALUE (cond);
2643 if (!check_switch_goto (switch_stack->level))
2644 return error_mark_node;
2646 r = c_add_case_label (switch_stack->cases, cond, TREE_TYPE (cond),
2647 low_value, high_value);
2649 /* After labels, make any new cleanups in the function go into their
2650 own new (temporary) binding contour. */
2651 for (p = current_binding_level;
2652 p->kind != sk_function_parms;
2654 p->more_cleanups_ok = 0;
2659 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
2662 typename_hash (const void* k)
2667 hash = (htab_hash_pointer (TYPE_CONTEXT (t))
2668 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));
2673 typedef struct typename_info {
2681 /* Compare two TYPENAME_TYPEs. K1 and K2 are really of type `tree'. */
2684 typename_compare (const void * k1, const void * k2)
2687 const typename_info *t2;
2690 t2 = (const typename_info *) k2;
2692 return (DECL_NAME (TYPE_NAME (t1)) == t2->name
2693 && TYPE_CONTEXT (t1) == t2->scope
2694 && TYPENAME_TYPE_FULLNAME (t1) == t2->template_id
2695 && TYPENAME_IS_ENUM_P (t1) == t2->enum_p
2696 && TYPENAME_IS_CLASS_P (t1) == t2->class_p);
2699 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
2700 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
2702 Returns the new TYPENAME_TYPE. */
2704 static GTY ((param_is (union tree_node))) htab_t typename_htab;
2707 build_typename_type (tree context, tree name, tree fullname,
2708 enum tag_types tag_type)
2716 if (typename_htab == NULL)
2717 typename_htab = htab_create_ggc (61, &typename_hash,
2718 &typename_compare, NULL);
2720 ti.scope = FROB_CONTEXT (context);
2722 ti.template_id = fullname;
2723 ti.enum_p = tag_type == enum_type;
2724 ti.class_p = (tag_type == class_type
2725 || tag_type == record_type
2726 || tag_type == union_type);
2727 hash = (htab_hash_pointer (ti.scope)
2728 ^ htab_hash_pointer (ti.name));
2730 /* See if we already have this type. */
2731 e = htab_find_slot_with_hash (typename_htab, &ti, hash, INSERT);
2736 /* Build the TYPENAME_TYPE. */
2737 t = make_aggr_type (TYPENAME_TYPE);
2738 TYPE_CONTEXT (t) = ti.scope;
2739 TYPENAME_TYPE_FULLNAME (t) = ti.template_id;
2740 TYPENAME_IS_ENUM_P (t) = ti.enum_p;
2741 TYPENAME_IS_CLASS_P (t) = ti.class_p;
2743 /* Build the corresponding TYPE_DECL. */
2744 d = build_decl (TYPE_DECL, name, t);
2745 TYPE_NAME (TREE_TYPE (d)) = d;
2746 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2747 DECL_CONTEXT (d) = FROB_CONTEXT (context);
2748 DECL_ARTIFICIAL (d) = 1;
2750 /* Store it in the hash table. */
2757 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
2758 provided to name the type. Returns an appropriate type, unless an
2759 error occurs, in which case error_mark_node is returned. If we
2760 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
2761 return that, rather than the _TYPE it corresponds to, in other
2762 cases we look through the type decl. If TF_ERROR is set, complain
2763 about errors, otherwise be quiet. */
2766 make_typename_type (tree context, tree name, enum tag_types tag_type,
2767 tsubst_flags_t complain)
2771 if (name == error_mark_node
2772 || context == NULL_TREE
2773 || context == error_mark_node)
2774 return error_mark_node;
2778 if (!(TYPE_LANG_SPECIFIC (name)
2779 && (CLASSTYPE_IS_TEMPLATE (name)
2780 || CLASSTYPE_USE_TEMPLATE (name))))
2781 name = TYPE_IDENTIFIER (name);
2783 /* Create a TEMPLATE_ID_EXPR for the type. */
2784 name = build_nt (TEMPLATE_ID_EXPR,
2785 CLASSTYPE_TI_TEMPLATE (name),
2786 CLASSTYPE_TI_ARGS (name));
2788 else if (TREE_CODE (name) == TYPE_DECL)
2789 name = DECL_NAME (name);
2793 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
2795 name = TREE_OPERAND (name, 0);
2796 if (TREE_CODE (name) == TEMPLATE_DECL)
2797 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
2799 if (TREE_CODE (name) == TEMPLATE_DECL)
2801 error ("%qD used without template parameters", name);
2802 return error_mark_node;
2804 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
2805 gcc_assert (TYPE_P (context));
2807 if (!dependent_type_p (context)
2808 || currently_open_class (context))
2810 if (TREE_CODE (fullname) == TEMPLATE_ID_EXPR)
2812 tree tmpl = NULL_TREE;
2813 if (IS_AGGR_TYPE (context))
2814 tmpl = lookup_field (context, name, 0, false);
2815 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
2817 if (complain & tf_error)
2818 error ("no class template named %q#T in %q#T",
2820 return error_mark_node;
2823 if (complain & tf_error)
2824 perform_or_defer_access_check (TYPE_BINFO (context), tmpl);
2826 return lookup_template_class (tmpl,
2827 TREE_OPERAND (fullname, 1),
2829 /*entering_scope=*/0,
2830 tf_warning_or_error | tf_user);
2836 if (!IS_AGGR_TYPE (context))
2838 if (complain & tf_error)
2839 error ("no type named %q#T in %q#T", name, context);
2840 return error_mark_node;
2843 t = lookup_field (context, name, 0, true);
2846 if (TREE_CODE (t) != TYPE_DECL)
2848 if (complain & tf_error)
2849 error ("no type named %q#T in %q#T", name, context);
2850 return error_mark_node;
2853 if (complain & tf_error)
2854 perform_or_defer_access_check (TYPE_BINFO (context), t);
2856 if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
2864 /* If the CONTEXT is not a template type, then either the field is
2865 there now or its never going to be. */
2866 if (!dependent_type_p (context))
2868 if (complain & tf_error)
2869 error ("no type named %q#T in %q#T", name, context);
2870 return error_mark_node;
2873 return build_typename_type (context, name, fullname, tag_type);
2876 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
2877 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
2878 in which case error_mark_node is returned.
2880 If PARM_LIST is non-NULL, also make sure that the template parameter
2881 list of TEMPLATE_DECL matches.
2883 If COMPLAIN zero, don't complain about any errors that occur. */
2886 make_unbound_class_template (tree context, tree name, tree parm_list,
2887 tsubst_flags_t complain)
2893 name = TYPE_IDENTIFIER (name);
2894 else if (DECL_P (name))
2895 name = DECL_NAME (name);
2896 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
2898 if (!dependent_type_p (context)
2899 || currently_open_class (context))
2901 tree tmpl = NULL_TREE;
2903 if (IS_AGGR_TYPE (context))
2904 tmpl = lookup_field (context, name, 0, false);
2906 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
2908 if (complain & tf_error)
2909 error ("no class template named %q#T in %q#T", name, context);
2910 return error_mark_node;
2914 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl), parm_list))
2916 if (complain & tf_error)
2918 error ("template parameters do not match template");
2919 error ("%q+D declared here", tmpl);
2921 return error_mark_node;
2924 if (complain & tf_error)
2925 perform_or_defer_access_check (TYPE_BINFO (context), tmpl);
2930 /* Build the UNBOUND_CLASS_TEMPLATE. */
2931 t = make_aggr_type (UNBOUND_CLASS_TEMPLATE);
2932 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
2933 TREE_TYPE (t) = NULL_TREE;
2935 /* Build the corresponding TEMPLATE_DECL. */
2936 d = build_decl (TEMPLATE_DECL, name, t);
2937 TYPE_NAME (TREE_TYPE (d)) = d;
2938 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2939 DECL_CONTEXT (d) = FROB_CONTEXT (context);
2940 DECL_ARTIFICIAL (d) = 1;
2941 DECL_TEMPLATE_PARMS (d) = parm_list;
2948 /* Push the declarations of builtin types into the namespace.
2949 RID_INDEX is the index of the builtin type in the array
2950 RID_POINTERS. NAME is the name used when looking up the builtin
2951 type. TYPE is the _TYPE node for the builtin type. */
2954 record_builtin_type (enum rid rid_index,
2958 tree rname = NULL_TREE, tname = NULL_TREE;
2959 tree tdecl = NULL_TREE;
2961 if ((int) rid_index < (int) RID_MAX)
2962 rname = ridpointers[(int) rid_index];
2964 tname = get_identifier (name);
2966 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
2967 eliminated. Built-in types should not be looked up name; their
2968 names are keywords that the parser can recognize. However, there
2969 is code in c-common.c that uses identifier_global_value to look
2970 up built-in types by name. */
2973 tdecl = build_decl (TYPE_DECL, tname, type);
2974 DECL_ARTIFICIAL (tdecl) = 1;
2975 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
2981 tdecl = build_decl (TYPE_DECL, rname, type);
2982 DECL_ARTIFICIAL (tdecl) = 1;
2984 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
2987 if (!TYPE_NAME (type))
2988 TYPE_NAME (type) = tdecl;
2991 debug_hooks->type_decl (tdecl, 0);
2994 /* Record one of the standard Java types.
2995 * Declare it as having the given NAME.
2996 * If SIZE > 0, it is the size of one of the integral types;
2997 * otherwise it is the negative of the size of one of the other types. */
3000 record_builtin_java_type (const char* name, int size)
3004 type = make_signed_type (size);
3005 else if (size > -32)
3006 { /* "__java_char" or ""__java_boolean". */
3007 type = make_unsigned_type (-size);
3008 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
3011 { /* "__java_float" or ""__java_double". */
3012 type = make_node (REAL_TYPE);
3013 TYPE_PRECISION (type) = - size;
3016 record_builtin_type (RID_MAX, name, type);
3017 decl = TYPE_NAME (type);
3019 /* Suppress generate debug symbol entries for these types,
3020 since for normal C++ they are just clutter.
3021 However, push_lang_context undoes this if extern "Java" is seen. */
3022 DECL_IGNORED_P (decl) = 1;
3024 TYPE_FOR_JAVA (type) = 1;
3028 /* Push a type into the namespace so that the back-ends ignore it. */
3031 record_unknown_type (tree type, const char* name)
3033 tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
3034 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3035 DECL_IGNORED_P (decl) = 1;
3036 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
3037 TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
3038 TYPE_ALIGN (type) = 1;
3039 TYPE_USER_ALIGN (type) = 0;
3040 TYPE_MODE (type) = TYPE_MODE (void_type_node);
3043 /* A string for which we should create an IDENTIFIER_NODE at
3046 typedef struct predefined_identifier
3048 /* The name of the identifier. */
3049 const char *const name;
3050 /* The place where the IDENTIFIER_NODE should be stored. */
3052 /* Nonzero if this is the name of a constructor or destructor. */
3053 const int ctor_or_dtor_p;
3054 } predefined_identifier;
3056 /* Create all the predefined identifiers. */
3059 initialize_predefined_identifiers (void)
3061 const predefined_identifier *pid;
3063 /* A table of identifiers to create at startup. */
3064 static const predefined_identifier predefined_identifiers[] = {
3065 { "C++", &lang_name_cplusplus, 0 },
3066 { "C", &lang_name_c, 0 },
3067 { "Java", &lang_name_java, 0 },
3068 /* Some of these names have a trailing space so that it is
3069 impossible for them to conflict with names written by users. */
3070 { "__ct ", &ctor_identifier, 1 },
3071 { "__base_ctor ", &base_ctor_identifier, 1 },
3072 { "__comp_ctor ", &complete_ctor_identifier, 1 },
3073 { "__dt ", &dtor_identifier, 1 },
3074 { "__comp_dtor ", &complete_dtor_identifier, 1 },
3075 { "__base_dtor ", &base_dtor_identifier, 1 },
3076 { "__deleting_dtor ", &deleting_dtor_identifier, 1 },
3077 { IN_CHARGE_NAME, &in_charge_identifier, 0 },
3078 { "nelts", &nelts_identifier, 0 },
3079 { THIS_NAME, &this_identifier, 0 },
3080 { VTABLE_DELTA_NAME, &delta_identifier, 0 },
3081 { VTABLE_PFN_NAME, &pfn_identifier, 0 },
3082 { "_vptr", &vptr_identifier, 0 },
3083 { "__vtt_parm", &vtt_parm_identifier, 0 },
3084 { "::", &global_scope_name, 0 },
3085 { "std", &std_identifier, 0 },
3089 for (pid = predefined_identifiers; pid->name; ++pid)
3091 *pid->node = get_identifier (pid->name);
3092 if (pid->ctor_or_dtor_p)
3093 IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
3097 /* Create the predefined scalar types of C,
3098 and some nodes representing standard constants (0, 1, (void *)0).
3099 Initialize the global binding level.
3100 Make definitions for built-in primitive functions. */
3103 cxx_init_decl_processing (void)
3106 tree void_ftype_ptr;
3108 build_common_tree_nodes (flag_signed_char, false);
3110 /* Create all the identifiers we need. */
3111 initialize_predefined_identifiers ();
3113 /* Create the global variables. */
3114 push_to_top_level ();
3116 current_function_decl = NULL_TREE;
3117 current_binding_level = NULL;
3118 /* Enter the global namespace. */
3119 gcc_assert (global_namespace == NULL_TREE);
3120 global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name,
3122 begin_scope (sk_namespace, global_namespace);
3124 current_lang_name = NULL_TREE;
3126 /* Adjust various flags based on command-line settings. */
3127 if (!flag_permissive)
3128 flag_pedantic_errors = 1;
3129 if (!flag_no_inline)
3131 flag_inline_trees = 1;
3134 if (flag_inline_functions)
3135 flag_inline_trees = 2;
3137 /* Force minimum function alignment if using the least significant
3138 bit of function pointers to store the virtual bit. */
3139 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
3140 && force_align_functions_log < 1)
3141 force_align_functions_log = 1;
3144 current_lang_name = lang_name_c;
3146 /* Create the `std' namespace. */
3147 push_namespace (std_identifier);
3148 std_node = current_namespace;
3151 c_common_nodes_and_builtins ();
3153 java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
3154 java_short_type_node = record_builtin_java_type ("__java_short", 16);
3155 java_int_type_node = record_builtin_java_type ("__java_int", 32);
3156 java_long_type_node = record_builtin_java_type ("__java_long", 64);
3157 java_float_type_node = record_builtin_java_type ("__java_float", -32);
3158 java_double_type_node = record_builtin_java_type ("__java_double", -64);
3159 java_char_type_node = record_builtin_java_type ("__java_char", -16);
3160 java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
3162 integer_two_node = build_int_cst (NULL_TREE, 2);
3163 integer_three_node = build_int_cst (NULL_TREE, 3);
3165 record_builtin_type (RID_BOOL, "bool", boolean_type_node);
3166 truthvalue_type_node = boolean_type_node;
3167 truthvalue_false_node = boolean_false_node;
3168 truthvalue_true_node = boolean_true_node;
3170 empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
3173 record_builtin_type (RID_MAX, NULL, string_type_node);
3176 delta_type_node = ptrdiff_type_node;
3177 vtable_index_type = ptrdiff_type_node;
3179 vtt_parm_type = build_pointer_type (const_ptr_type_node);
3180 void_ftype = build_function_type (void_type_node, void_list_node);
3181 void_ftype_ptr = build_function_type (void_type_node,
3182 tree_cons (NULL_TREE,
3186 = build_exception_variant (void_ftype_ptr, empty_except_spec);
3188 /* C++ extensions */
3190 unknown_type_node = make_node (UNKNOWN_TYPE);
3191 record_unknown_type (unknown_type_node, "unknown type");
3193 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3194 TREE_TYPE (unknown_type_node) = unknown_type_node;
3196 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3198 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
3199 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
3202 /* Make sure we get a unique function type, so we can give
3203 its pointer type a name. (This wins for gdb.) */
3204 tree vfunc_type = make_node (FUNCTION_TYPE);
3205 TREE_TYPE (vfunc_type) = integer_type_node;
3206 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
3207 layout_type (vfunc_type);
3209 vtable_entry_type = build_pointer_type (vfunc_type);
3211 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
3214 = build_cplus_array_type (vtable_entry_type, NULL_TREE);
3215 layout_type (vtbl_type_node);
3216 vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
3217 record_builtin_type (RID_MAX, NULL, vtbl_type_node);
3218 vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
3219 layout_type (vtbl_ptr_type_node);
3220 record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
3222 push_namespace (get_identifier ("__cxxabiv1"));
3223 abi_node = current_namespace;
3226 global_type_node = make_node (LANG_TYPE);
3227 record_unknown_type (global_type_node, "global type");
3230 current_lang_name = lang_name_cplusplus;
3234 tree bad_alloc_type_node;
3235 tree bad_alloc_decl;
3236 tree newtype, deltype;
3237 tree ptr_ftype_sizetype;
3239 push_namespace (std_identifier);
3240 bad_alloc_id = get_identifier ("bad_alloc");
3241 bad_alloc_type_node = make_aggr_type (RECORD_TYPE);
3242 TYPE_CONTEXT (bad_alloc_type_node) = current_namespace;
3244 = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node);
3245 DECL_CONTEXT (bad_alloc_decl) = current_namespace;
3246 TYPE_STUB_DECL (bad_alloc_type_node) = bad_alloc_decl;
3250 = build_function_type (ptr_type_node,
3251 tree_cons (NULL_TREE,
3254 newtype = build_exception_variant
3255 (ptr_ftype_sizetype, add_exception_specifier
3256 (NULL_TREE, bad_alloc_type_node, -1));
3257 deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
3258 push_cp_library_fn (NEW_EXPR, newtype);
3259 push_cp_library_fn (VEC_NEW_EXPR, newtype);
3260 global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
3261 push_cp_library_fn (VEC_DELETE_EXPR, deltype);
3265 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
3267 /* Perform other language dependent initializations. */
3268 init_class_processing ();
3269 init_rtti_processing ();
3271 if (flag_exceptions)
3272 init_exception_processing ();
3274 if (! supports_one_only ())
3277 make_fname_decl = cp_make_fname_decl;
3278 start_fname_decls ();
3280 /* Show we use EH for cleanups. */
3281 if (flag_exceptions)
3282 using_eh_for_cleanups ();
3285 /* Generate an initializer for a function naming variable from
3286 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3287 filled in with the type of the init. */
3290 cp_fname_init (const char* name, tree *type_p)
3292 tree domain = NULL_TREE;
3294 tree init = NULL_TREE;
3299 length = strlen (name);
3300 domain = build_index_type (size_int (length));
3301 init = build_string (length + 1, name);
3304 type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
3305 type = build_cplus_array_type (type, domain);
3310 TREE_TYPE (init) = type;
3312 init = error_mark_node;
3317 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
3318 decl, NAME is the initialization string and TYPE_DEP indicates whether
3319 NAME depended on the type of the function. We make use of that to detect
3320 __PRETTY_FUNCTION__ inside a template fn. This is being done
3321 lazily at the point of first use, so we mustn't push the decl now. */
3324 cp_make_fname_decl (tree id, int type_dep)
3326 const char *const name = (type_dep && processing_template_decl
3327 ? NULL : fname_as_string (type_dep));
3329 tree init = cp_fname_init (name, &type);
3330 tree decl = build_decl (VAR_DECL, id, type);
3333 free ((char *) name);
3335 /* As we're using pushdecl_with_scope, we must set the context. */
3336 DECL_CONTEXT (decl) = current_function_decl;
3337 DECL_PRETTY_FUNCTION_P (decl) = type_dep;
3339 TREE_STATIC (decl) = 1;
3340 TREE_READONLY (decl) = 1;
3341 DECL_ARTIFICIAL (decl) = 1;
3343 TREE_USED (decl) = 1;
3345 if (current_function_decl)
3347 struct cp_binding_level *b = current_binding_level;
3348 while (b->level_chain->kind != sk_function_parms)
3350 pushdecl_with_scope (decl, b, /*is_friend=*/false);
3351 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE,
3352 LOOKUP_ONLYCONVERTING);
3355 pushdecl_top_level_and_finish (decl, init);
3360 /* Make a definition for a builtin function named NAME in the current
3361 namespace, whose data type is TYPE and whose context is CONTEXT.
3362 TYPE should be a function type with argument types.
3364 CLASS and CODE tell later passes how to compile calls to this function.
3365 See tree.h for possible values.
3367 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3368 the name to be called if we can't opencode the function.
3369 If ATTRS is nonzero, use that for the function's attribute
3373 builtin_function_1 (const char* name,
3376 enum built_in_function code,
3377 enum built_in_class class,
3378 const char* libname,
3381 tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
3382 DECL_BUILT_IN_CLASS (decl) = class;
3383 DECL_FUNCTION_CODE (decl) = code;
3384 DECL_CONTEXT (decl) = context;
3388 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
3389 we cannot change DECL_ASSEMBLER_NAME until we have installed this
3390 function in the namespace. */
3392 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
3394 /* A function in the user's namespace should have an explicit
3395 declaration before it is used. Mark the built-in function as
3396 anticipated but not actually declared. */
3397 if (name[0] != '_' || name[1] != '_')
3398 DECL_ANTICIPATED (decl) = 1;
3400 /* Possibly apply some default attributes to this built-in function. */
3402 decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
3404 decl_attributes (&decl, NULL_TREE, 0);
3409 /* Entry point for the benefit of c_common_nodes_and_builtins.
3411 Make a definition for a builtin function named NAME and whose data type
3412 is TYPE. TYPE should be a function type with argument types. This
3413 function places the anticipated declaration in the global namespace
3414 and additionally in the std namespace if appropriate.
3416 CLASS and CODE tell later passes how to compile calls to this function.
3417 See tree.h for possible values.
3419 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3420 the name to be called if we can't opencode the function.
3422 If ATTRS is nonzero, use that for the function's attribute
3426 builtin_function (const char* name,
3429 enum built_in_class cl,
3430 const char* libname,
3433 /* All builtins that don't begin with an '_' should additionally
3434 go in the 'std' namespace. */
3437 push_namespace (std_identifier);
3438 builtin_function_1 (name, type, std_node, code, cl, libname, attrs);
3442 return builtin_function_1 (name, type, NULL_TREE, code,
3443 cl, libname, attrs);
3446 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
3447 function. Not called directly. */
3450 build_library_fn_1 (tree name, enum tree_code operator_code, tree type)
3452 tree fn = build_lang_decl (FUNCTION_DECL, name, type);
3453 DECL_EXTERNAL (fn) = 1;
3454 TREE_PUBLIC (fn) = 1;
3455 DECL_ARTIFICIAL (fn) = 1;
3456 SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
3457 SET_DECL_LANGUAGE (fn, lang_c);
3458 /* Runtime library routines are, by definition, available in an
3459 external shared object. */
3460 DECL_VISIBILITY (fn) = VISIBILITY_DEFAULT;
3461 DECL_VISIBILITY_SPECIFIED (fn) = 1;
3465 /* Returns the _DECL for a library function with C linkage.
3466 We assume that such functions never throw; if this is incorrect,
3467 callers should unset TREE_NOTHROW. */
3470 build_library_fn (tree name, tree type)
3472 tree fn = build_library_fn_1 (name, ERROR_MARK, type);
3473 TREE_NOTHROW (fn) = 1;
3477 /* Returns the _DECL for a library function with C++ linkage. */
3480 build_cp_library_fn (tree name, enum tree_code operator_code, tree type)
3482 tree fn = build_library_fn_1 (name, operator_code, type);
3483 TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
3484 DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
3485 SET_DECL_LANGUAGE (fn, lang_cplusplus);
3489 /* Like build_library_fn, but takes a C string instead of an
3493 build_library_fn_ptr (const char* name, tree type)
3495 return build_library_fn (get_identifier (name), type);
3498 /* Like build_cp_library_fn, but takes a C string instead of an
3502 build_cp_library_fn_ptr (const char* name, tree type)
3504 return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
3507 /* Like build_library_fn, but also pushes the function so that we will
3508 be able to find it via IDENTIFIER_GLOBAL_VALUE. */
3511 push_library_fn (tree name, tree type)
3513 tree fn = build_library_fn (name, type);
3514 pushdecl_top_level (fn);
3518 /* Like build_cp_library_fn, but also pushes the function so that it
3519 will be found by normal lookup. */
3522 push_cp_library_fn (enum tree_code operator_code, tree type)
3524 tree fn = build_cp_library_fn (ansi_opname (operator_code),
3531 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
3535 push_void_library_fn (tree name, tree parmtypes)
3537 tree type = build_function_type (void_type_node, parmtypes);
3538 return push_library_fn (name, type);
3541 /* Like push_library_fn, but also note that this function throws
3542 and does not return. Used for __throw_foo and the like. */
3545 push_throw_library_fn (tree name, tree type)
3547 tree fn = push_library_fn (name, type);
3548 TREE_THIS_VOLATILE (fn) = 1;
3549 TREE_NOTHROW (fn) = 0;
3553 /* When we call finish_struct for an anonymous union, we create
3554 default copy constructors and such. But, an anonymous union
3555 shouldn't have such things; this function undoes the damage to the
3556 anonymous union type T.
3558 (The reason that we create the synthesized methods is that we don't
3559 distinguish `union { int i; }' from `typedef union { int i; } U'.
3560 The first is an anonymous union; the second is just an ordinary
3564 fixup_anonymous_aggr (tree t)
3568 /* Wipe out memory of synthesized methods. */
3569 TYPE_HAS_CONSTRUCTOR (t) = 0;
3570 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
3571 TYPE_HAS_INIT_REF (t) = 0;
3572 TYPE_HAS_CONST_INIT_REF (t) = 0;
3573 TYPE_HAS_ASSIGN_REF (t) = 0;
3574 TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
3576 /* Splice the implicitly generated functions out of the TYPE_METHODS
3578 q = &TYPE_METHODS (t);
3581 if (DECL_ARTIFICIAL (*q))
3582 *q = TREE_CHAIN (*q);
3584 q = &TREE_CHAIN (*q);
3587 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
3588 if (TYPE_METHODS (t))
3589 error ("%Jan anonymous union cannot have function members",
3590 TYPE_MAIN_DECL (t));
3592 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
3593 assignment operators (because they cannot have these methods themselves).
3594 For anonymous unions this is already checked because they are not allowed
3595 in any union, otherwise we have to check it. */
3596 if (TREE_CODE (t) != UNION_TYPE)
3600 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
3601 if (TREE_CODE (field) == FIELD_DECL)
3603 type = TREE_TYPE (field);
3604 if (CLASS_TYPE_P (type))
3606 if (TYPE_NEEDS_CONSTRUCTING (type))
3607 error ("member %q+#D with constructor not allowed "
3608 "in anonymous aggregate", field);
3609 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
3610 error ("member %q+#D with destructor not allowed "
3611 "in anonymous aggregate", field);
3612 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
3613 error ("member %q+#D with copy assignment operator "
3614 "not allowed in anonymous aggregate", field);
3620 /* Make sure that a declaration with no declarator is well-formed, i.e.
3621 just declares a tagged type or anonymous union.
3623 Returns the type declared; or NULL_TREE if none. */
3626 check_tag_decl (cp_decl_specifier_seq *declspecs)
3628 int saw_friend = declspecs->specs[(int)ds_friend] != 0;
3629 int saw_typedef = declspecs->specs[(int)ds_typedef] != 0;
3630 /* If a class, struct, or enum type is declared by the DECLSPECS
3631 (i.e, if a class-specifier, enum-specifier, or non-typename
3632 elaborated-type-specifier appears in the DECLSPECS),
3633 DECLARED_TYPE is set to the corresponding type. */
3634 tree declared_type = NULL_TREE;
3635 bool error_p = false;
3637 if (declspecs->multiple_types_p)
3638 error ("multiple types in one declaration");
3639 else if (declspecs->redefined_builtin_type)
3641 if (!in_system_header)
3642 pedwarn ("redeclaration of C++ built-in type %qT",
3643 declspecs->redefined_builtin_type);
3648 && TYPE_P (declspecs->type)
3649 && ((TREE_CODE (declspecs->type) != TYPENAME_TYPE
3650 && IS_AGGR_TYPE (declspecs->type))
3651 || TREE_CODE (declspecs->type) == ENUMERAL_TYPE))
3652 declared_type = declspecs->type;
3653 else if (declspecs->type == error_mark_node)
3655 if (declared_type == NULL_TREE && ! saw_friend && !error_p)
3656 pedwarn ("declaration does not declare anything");
3657 /* Check for an anonymous union. */
3658 else if (declared_type && IS_AGGR_TYPE_CODE (TREE_CODE (declared_type))
3659 && TYPE_ANONYMOUS_P (declared_type))
3661 /* 7/3 In a simple-declaration, the optional init-declarator-list
3662 can be omitted only when declaring a class (clause 9) or
3663 enumeration (7.2), that is, when the decl-specifier-seq contains
3664 either a class-specifier, an elaborated-type-specifier with
3665 a class-key (9.1), or an enum-specifier. In these cases and
3666 whenever a class-specifier or enum-specifier is present in the
3667 decl-specifier-seq, the identifiers in these specifiers are among
3668 the names being declared by the declaration (as class-name,
3669 enum-names, or enumerators, depending on the syntax). In such
3670 cases, and except for the declaration of an unnamed bit-field (9.6),
3671 the decl-specifier-seq shall introduce one or more names into the
3672 program, or shall redeclare a name introduced by a previous
3673 declaration. [Example:
3674 enum { }; // ill-formed
3675 typedef class { }; // ill-formed
3679 error ("missing type-name in typedef-declaration");
3682 /* Anonymous unions are objects, so they can have specifiers. */;
3683 SET_ANON_AGGR_TYPE_P (declared_type);
3685 if (TREE_CODE (declared_type) != UNION_TYPE && pedantic
3686 && !in_system_header)
3687 pedwarn ("ISO C++ prohibits anonymous structs");
3692 if (declspecs->specs[(int)ds_inline]
3693 || declspecs->specs[(int)ds_virtual])
3694 error ("%qs can only be specified for functions",
3695 declspecs->specs[(int)ds_inline]
3696 ? "inline" : "virtual");
3698 && (!current_class_type
3699 || current_scope () != current_class_type))
3700 error ("%<friend%> can only be specified inside a class");
3701 else if (declspecs->specs[(int)ds_explicit])
3702 error ("%<explicit%> can only be specified for constructors");
3703 else if (declspecs->storage_class)
3704 error ("a storage class can only be specified for objects "
3706 else if (declspecs->specs[(int)ds_const]
3707 || declspecs->specs[(int)ds_volatile]
3708 || declspecs->specs[(int)ds_restrict]
3709 || declspecs->specs[(int)ds_thread])
3710 error ("qualifiers can only be specified for objects "
3714 return declared_type;
3717 /* Called when a declaration is seen that contains no names to declare.
3718 If its type is a reference to a structure, union or enum inherited
3719 from a containing scope, shadow that tag name for the current scope
3720 with a forward reference.
3721 If its type defines a new named structure or union
3722 or defines an enum, it is valid but we need not do anything here.
3723 Otherwise, it is an error.
3725 C++: may have to grok the declspecs to learn about static,
3726 complain for anonymous unions.
3728 Returns the TYPE declared -- or NULL_TREE if none. */
3731 shadow_tag (cp_decl_specifier_seq *declspecs)
3733 tree t = check_tag_decl (declspecs);
3738 if (declspecs->attributes)
3740 warning (0, "attribute ignored in declaration of %q+#T", t);
3741 warning (0, "attribute for %q+#T must follow the %qs keyword",
3742 t, class_key_or_enum_as_string (t));
3746 maybe_process_partial_specialization (t);
3748 /* This is where the variables in an anonymous union are
3749 declared. An anonymous union declaration looks like:
3751 because there is no declarator after the union, the parser
3752 sends that declaration here. */
3753 if (ANON_AGGR_TYPE_P (t))
3755 fixup_anonymous_aggr (t);
3757 if (TYPE_FIELDS (t))
3759 tree decl = grokdeclarator (/*declarator=*/NULL,
3760 declspecs, NORMAL, 0, NULL);
3761 finish_anon_union (decl);
3768 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
3771 groktypename (cp_decl_specifier_seq *type_specifiers,
3772 const cp_declarator *declarator)
3776 attrs = type_specifiers->attributes;
3777 type_specifiers->attributes = NULL_TREE;
3778 type = grokdeclarator (declarator, type_specifiers, TYPENAME, 0, &attrs);
3780 cplus_decl_attributes (&type, attrs, 0);
3784 /* Decode a declarator in an ordinary declaration or data definition.
3785 This is called as soon as the type information and variable name
3786 have been parsed, before parsing the initializer if any.
3787 Here we create the ..._DECL node, fill in its type,
3788 and put it on the list of decls for the current context.
3789 The ..._DECL node is returned as the value.
3791 Exception: for arrays where the length is not specified,
3792 the type is left null, to be filled in by `cp_finish_decl'.
3794 Function definitions do not come here; they go to start_function
3795 instead. However, external and forward declarations of functions
3796 do go through here. Structure field declarations are done by
3797 grokfield and not through here. */
3800 start_decl (const cp_declarator *declarator,
3801 cp_decl_specifier_seq *declspecs,
3804 tree prefix_attributes,
3805 tree *pushed_scope_p)
3811 *pushed_scope_p = NULL_TREE;
3813 /* An object declared as __attribute__((deprecated)) suppresses
3814 warnings of uses of other deprecated items. */
3815 if (lookup_attribute ("deprecated", attributes))
3816 deprecated_state = DEPRECATED_SUPPRESS;
3818 attributes = chainon (attributes, prefix_attributes);
3820 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
3823 deprecated_state = DEPRECATED_NORMAL;
3825 if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE
3826 || decl == error_mark_node)
3827 return error_mark_node;
3829 type = TREE_TYPE (decl);
3831 context = DECL_CONTEXT (decl);
3835 *pushed_scope_p = push_scope (context);
3837 /* We are only interested in class contexts, later. */
3838 if (TREE_CODE (context) == NAMESPACE_DECL)
3839 context = NULL_TREE;
3843 /* Is it valid for this decl to have an initializer at all?
3844 If not, set INITIALIZED to zero, which will indirectly
3845 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
3846 switch (TREE_CODE (decl))
3849 error ("typedef %qD is initialized (use __typeof__ instead)", decl);
3854 error ("function %q#D is initialized like a variable", decl);
3864 if (! toplevel_bindings_p ()
3865 && DECL_EXTERNAL (decl))
3866 warning (0, "declaration of %q#D has %<extern%> and is initialized",
3868 DECL_EXTERNAL (decl) = 0;
3869 if (toplevel_bindings_p ())
3870 TREE_STATIC (decl) = 1;
3873 /* Set attributes here so if duplicate decl, will have proper attributes. */
3874 cplus_decl_attributes (&decl, attributes, 0);
3876 /* If #pragma weak was used, mark the decl weak now. */
3877 maybe_apply_pragma_weak (decl);
3879 if (TREE_CODE (decl) == FUNCTION_DECL
3880 && DECL_DECLARED_INLINE_P (decl)
3881 && DECL_UNINLINABLE (decl)
3882 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
3883 warning (0, "inline function %q+D given attribute noinline", decl);
3885 if (context && COMPLETE_TYPE_P (complete_type (context)))
3887 if (TREE_CODE (decl) == VAR_DECL)
3889 tree field = lookup_field (context, DECL_NAME (decl), 0, false);
3890 if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
3891 error ("%q#D is not a static member of %q#T", decl, context);
3894 if (DECL_CONTEXT (field) != context)
3896 if (!same_type_p (DECL_CONTEXT (field), context))
3897 pedwarn ("ISO C++ does not permit %<%T::%D%> "
3898 "to be defined as %<%T::%D%>",
3899 DECL_CONTEXT (field), DECL_NAME (decl),
3900 context, DECL_NAME (decl));
3901 DECL_CONTEXT (decl) = DECL_CONTEXT (field);
3903 if (processing_specialization
3904 && template_class_depth (context) == 0
3905 && CLASSTYPE_TEMPLATE_SPECIALIZATION (context))
3906 error ("template header not allowed in member definition "
3907 "of explicitly specialized class");
3908 /* Static data member are tricky; an in-class initialization
3909 still doesn't provide a definition, so the in-class
3910 declaration will have DECL_EXTERNAL set, but will have an
3911 initialization. Thus, duplicate_decls won't warn
3912 about this situation, and so we check here. */
3913 if (initialized && DECL_INITIALIZED_IN_CLASS_P (field))
3914 error ("duplicate initialization of %qD", decl);
3915 if (duplicate_decls (decl, field, /*newdecl_is_friend=*/false))
3921 tree field = check_classfn (context, decl,
3922 (processing_template_decl
3923 > template_class_depth (context))
3924 ? current_template_parms
3926 if (field && duplicate_decls (decl, field,
3927 /*newdecl_is_friend=*/false))
3931 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
3932 DECL_IN_AGGR_P (decl) = 0;
3933 /* Do not mark DECL as an explicit specialization if it was not
3934 already marked as an instantiation; a declaration should
3935 never be marked as a specialization unless we know what
3936 template is being specialized. */
3937 if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
3939 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
3941 /* [temp.expl.spec] An explicit specialization of a static data
3942 member of a template is a definition if the declaration
3943 includes an initializer; otherwise, it is a declaration.
3945 We check for processing_specialization so this only applies
3946 to the new specialization syntax. */
3947 if (!initialized && processing_specialization)
3948 DECL_EXTERNAL (decl) = 1;
3951 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
3952 pedwarn ("declaration of %q#D outside of class is not definition",
3956 /* Enter this declaration into the symbol table. */
3957 tem = maybe_push_decl (decl);
3959 if (processing_template_decl)
3960 tem = push_template_decl (tem);
3961 if (tem == error_mark_node)
3962 return error_mark_node;
3964 /* Tell the back-end to use or not use .common as appropriate. If we say
3965 -fconserve-space, we want this to save .data space, at the expense of
3966 wrong semantics. If we say -fno-conserve-space, we want this to
3967 produce errors about redefs; to do this we force variables into the
3969 if (flag_conserve_space
3970 && TREE_CODE (tem) == VAR_DECL
3971 && TREE_PUBLIC (tem)
3972 && !DECL_THREAD_LOCAL_P (tem)
3973 && !have_global_bss_p ())
3974 DECL_COMMON (tem) = 1;
3976 if (!processing_template_decl && TREE_CODE (tem) == VAR_DECL)
3977 start_decl_1 (tem, initialized);
3983 start_decl_1 (tree decl, bool initialized)
3987 gcc_assert (!processing_template_decl);
3989 if (error_operand_p (decl))
3992 gcc_assert (TREE_CODE (decl) == VAR_DECL);
3993 type = TREE_TYPE (decl);
3996 /* Is it valid for this decl to have an initializer at all?
3997 If not, set INITIALIZED to zero, which will indirectly
3998 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
4000 /* Don't allow initializations for incomplete types except for
4001 arrays which might be completed by the initialization. */
4002 if (COMPLETE_TYPE_P (complete_type (type)))
4003 ; /* A complete type is ok. */
4004 else if (TREE_CODE (type) != ARRAY_TYPE)
4006 error ("variable %q#D has initializer but incomplete type", decl);
4008 type = TREE_TYPE (decl) = error_mark_node;
4010 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
4012 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
4013 error ("elements of array %q#D have incomplete type", decl);
4014 /* else we already gave an error in start_decl. */
4018 else if (IS_AGGR_TYPE (type)
4019 && ! DECL_EXTERNAL (decl))
4021 if (!COMPLETE_TYPE_P (complete_type (type)))
4023 error ("aggregate %q#D has incomplete type and cannot be defined",
4025 /* Change the type so that assemble_variable will give
4026 DECL an rtl we can live with: (mem (const_int 0)). */
4027 type = TREE_TYPE (decl) = error_mark_node;
4031 /* If any base type in the hierarchy of TYPE needs a constructor,
4032 then we set initialized to 1. This way any nodes which are
4033 created for the purposes of initializing this aggregate
4034 will live as long as it does. This is necessary for global
4035 aggregates which do not have their initializers processed until
4036 the end of the file. */
4037 initialized = TYPE_NEEDS_CONSTRUCTING (type);
4041 /* Create a new scope to hold this declaration if necessary.
4042 Whether or not a new scope is necessary cannot be determined
4043 until after the type has been completed; if the type is a
4044 specialization of a class template it is not until after
4045 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4046 will be set correctly. */
4047 maybe_push_cleanup_level (type);
4050 /* Handle initialization of references. DECL, TYPE, and INIT have the
4051 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
4052 but will be set to a new CLEANUP_STMT if a temporary is created
4053 that must be destroyed subsequently.
4055 Returns an initializer expression to use to initialize DECL, or
4056 NULL if the initialization can be performed statically.
4058 Quotes on semantics can be found in ARM 8.4.3. */
4061 grok_reference_init (tree decl, tree type, tree init, tree *cleanup)
4065 if (init == NULL_TREE)
4067 if ((DECL_LANG_SPECIFIC (decl) == 0
4068 || DECL_IN_AGGR_P (decl) == 0)
4069 && ! DECL_THIS_EXTERN (decl))
4070 error ("%qD declared as reference but not initialized", decl);
4074 if (TREE_CODE (init) == CONSTRUCTOR)
4076 error ("ISO C++ forbids use of initializer list to "
4077 "initialize reference %qD", decl);
4081 if (TREE_CODE (init) == TREE_LIST)
4082 init = build_x_compound_expr_from_list (init, "initializer");
4084 if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
4085 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
4086 /* Note: default conversion is only called in very special cases. */
4087 init = decay_conversion (init);
4089 /* Convert INIT to the reference type TYPE. This may involve the
4090 creation of a temporary, whose lifetime must be the same as that
4091 of the reference. If so, a DECL_EXPR for the temporary will be
4092 added just after the DECL_EXPR for DECL. That's why we don't set
4093 DECL_INITIAL for local references (instead assigning to them
4094 explicitly); we need to allow the temporary to be initialized
4096 tmp = initialize_reference (type, init, decl, cleanup);
4098 if (tmp == error_mark_node)
4100 else if (tmp == NULL_TREE)
4102 error ("cannot initialize %qT from %qT", type, TREE_TYPE (init));
4106 if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
4109 DECL_INITIAL (decl) = tmp;
4114 /* When parsing `int a[] = {1, 2};' we don't know the size of the
4115 array until we finish parsing the initializer. If that's the
4116 situation we're in, update DECL accordingly. */
4119 maybe_deduce_size_from_array_init (tree decl, tree init)
4121 tree type = TREE_TYPE (decl);
4123 if (TREE_CODE (type) == ARRAY_TYPE
4124 && TYPE_DOMAIN (type) == NULL_TREE
4125 && TREE_CODE (decl) != TYPE_DECL)
4127 /* do_default is really a C-ism to deal with tentative definitions.
4128 But let's leave it here to ease the eventual merge. */
4129 int do_default = !DECL_EXTERNAL (decl);
4130 tree initializer = init ? init : DECL_INITIAL (decl);
4131 int failure = cp_complete_array_type (&TREE_TYPE (decl), initializer,
4136 error ("initializer fails to determine size of %qD", decl);
4137 TREE_TYPE (decl) = error_mark_node;
4139 else if (failure == 2)
4143 error ("array size missing in %qD", decl);
4144 TREE_TYPE (decl) = error_mark_node;
4146 /* If a `static' var's size isn't known, make it extern as
4147 well as static, so it does not get allocated. If it's not
4148 `static', then don't mark it extern; finish_incomplete_decl
4149 will give it a default size and it will get allocated. */
4150 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
4151 DECL_EXTERNAL (decl) = 1;
4153 else if (failure == 3)
4155 error ("zero-size array %qD", decl);
4156 TREE_TYPE (decl) = error_mark_node;
4159 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl)), decl);
4161 layout_decl (decl, 0);
4165 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
4166 any appropriate error messages regarding the layout. */
4169 layout_var_decl (tree decl)
4173 if (TREE_STATIC (decl)
4174 && !DECL_ARTIFICIAL (decl)
4175 && current_function_decl
4176 && DECL_CONTEXT (decl) == current_function_decl)
4177 push_local_name (decl);
4179 type = TREE_TYPE (decl);
4180 if (type == error_mark_node)
4183 /* If we haven't already layed out this declaration, do so now.
4184 Note that we must not call complete type for an external object
4185 because it's type might involve templates that we are not
4186 supposed to instantiate yet. (And it's perfectly valid to say
4187 `extern X x' for some incomplete type `X'.) */
4188 if (!DECL_EXTERNAL (decl))
4189 complete_type (type);
4190 if (!DECL_SIZE (decl)
4191 && TREE_TYPE (decl) != error_mark_node
4192 && (COMPLETE_TYPE_P (type)
4193 || (TREE_CODE (type) == ARRAY_TYPE
4194 && !TYPE_DOMAIN (type)
4195 && COMPLETE_TYPE_P (TREE_TYPE (type)))))
4196 layout_decl (decl, 0);
4198 if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
4200 /* An automatic variable with an incomplete type: that is an error.
4201 Don't talk about array types here, since we took care of that
4202 message in grokdeclarator. */
4203 error ("storage size of %qD isn't known", decl);
4204 TREE_TYPE (decl) = error_mark_node;
4207 /* Keep this code around in case we later want to control debug info
4208 based on whether a type is "used". (jason 1999-11-11) */
4210 else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
4211 /* Let debugger know it should output info for this type. */
4212 note_debug_info_needed (ttype);
4214 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
4215 note_debug_info_needed (DECL_CONTEXT (decl));
4218 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
4219 && DECL_SIZE (decl) != NULL_TREE
4220 && ! TREE_CONSTANT (DECL_SIZE (decl)))
4222 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
4223 constant_expression_warning (DECL_SIZE (decl));
4225 error ("storage size of %qD isn't constant", decl);
4229 /* If a local static variable is declared in an inline function, or if
4230 we have a weak definition, we must endeavor to create only one
4231 instance of the variable at link-time. */
4234 maybe_commonize_var (tree decl)
4236 /* Static data in a function with comdat linkage also has comdat
4238 if (TREE_STATIC (decl)
4239 /* Don't mess with __FUNCTION__. */
4240 && ! DECL_ARTIFICIAL (decl)
4241 && DECL_FUNCTION_SCOPE_P (decl)
4242 /* Unfortunately, import_export_decl has not always been called
4243 before the function is processed, so we cannot simply check
4245 && (DECL_COMDAT (DECL_CONTEXT (decl))
4246 || ((DECL_DECLARED_INLINE_P (DECL_CONTEXT (decl))
4247 || DECL_TEMPLATE_INSTANTIATION (DECL_CONTEXT (decl)))
4248 && TREE_PUBLIC (DECL_CONTEXT (decl)))))
4252 /* With weak symbols, we simply make the variable COMDAT;
4253 that will cause copies in multiple translations units to
4255 comdat_linkage (decl);
4259 if (DECL_INITIAL (decl) == NULL_TREE
4260 || DECL_INITIAL (decl) == error_mark_node)
4262 /* Without weak symbols, we can use COMMON to merge
4263 uninitialized variables. */
4264 TREE_PUBLIC (decl) = 1;
4265 DECL_COMMON (decl) = 1;
4269 /* While for initialized variables, we must use internal
4270 linkage -- which means that multiple copies will not
4272 TREE_PUBLIC (decl) = 0;
4273 DECL_COMMON (decl) = 0;
4274 warning (0, "sorry: semantics of inline function static "
4275 "data %q+#D are wrong (you'll wind up "
4276 "with multiple copies)", decl);
4277 warning (0, "%J you can work around this by removing "
4283 else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
4284 /* Set it up again; we might have set DECL_INITIAL since the last
4286 comdat_linkage (decl);
4289 /* Issue an error message if DECL is an uninitialized const variable. */
4292 check_for_uninitialized_const_var (tree decl)
4294 tree type = TREE_TYPE (decl);
4296 /* ``Unless explicitly declared extern, a const object does not have
4297 external linkage and must be initialized. ($8.4; $12.1)'' ARM
4299 if (TREE_CODE (decl) == VAR_DECL
4300 && TREE_CODE (type) != REFERENCE_TYPE
4301 && CP_TYPE_CONST_P (type)
4302 && !TYPE_NEEDS_CONSTRUCTING (type)
4303 && !DECL_INITIAL (decl))
4304 error ("uninitialized const %qD", decl);
4308 /* Structure holding the current initializer being processed by reshape_init.
4309 CUR is a pointer to the current element being processed, END is a pointer
4310 after the last element present in the initializer. */
4311 typedef struct reshape_iterator_t
4313 constructor_elt *cur;
4314 constructor_elt *end;
4317 static tree reshape_init_r (tree, reshape_iter *, bool);
4319 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
4320 returned is the next FIELD_DECL (possibly FIELD itself) that can be
4321 initialized. If there are no more such fields, the return value
4325 next_initializable_field (tree field)
4328 && (TREE_CODE (field) != FIELD_DECL
4329 || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
4330 || DECL_ARTIFICIAL (field)))
4331 field = TREE_CHAIN (field);
4336 /* Subroutine of reshape_init_array and reshape_init_vector, which does
4337 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
4338 INTEGER_CST representing the size of the array minus one (the maximum index),
4339 or NULL_TREE if the array was declared without specifying the size. D is
4340 the iterator within the constructor. */
4343 reshape_init_array_1 (tree elt_type, tree max_index, reshape_iter *d)
4346 bool sized_array_p = (max_index != NULL_TREE);
4347 unsigned HOST_WIDE_INT max_index_cst = 0;
4348 unsigned HOST_WIDE_INT index;
4350 /* The initializer for an array is always a CONSTRUCTOR. */
4351 new_init = build_constructor (NULL_TREE, NULL);
4355 /* Minus 1 is used for zero sized arrays. */
4356 if (integer_all_onesp (max_index))
4359 if (host_integerp (max_index, 1))
4360 max_index_cst = tree_low_cst (max_index, 1);
4361 /* sizetype is sign extended, not zero extended. */
4363 max_index_cst = tree_low_cst (fold_convert (size_type_node, max_index),
4367 /* Loop until there are no more initializers. */
4369 d->cur != d->end && (!sized_array_p || index <= max_index_cst);
4376 /* Handle array designated initializers (GNU extension). */
4377 if (TREE_CODE (d->cur->index) == IDENTIFIER_NODE)
4379 error ("name %qD used in a GNU-style designated "
4380 "initializer for an array", d->cur->index);
4386 elt_init = reshape_init_r (elt_type, d, /*first_initializer_p=*/false);
4387 if (elt_init == error_mark_node)
4388 return error_mark_node;
4389 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), NULL_TREE, elt_init);
4395 /* Subroutine of reshape_init_r, processes the initializers for arrays.
4396 Parameters are the same of reshape_init_r. */
4399 reshape_init_array (tree type, reshape_iter *d)
4401 tree max_index = NULL_TREE;
4403 gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
4405 if (TYPE_DOMAIN (type))
4406 max_index = array_type_nelts (type);
4408 return reshape_init_array_1 (TREE_TYPE (type), max_index, d);
4411 /* Subroutine of reshape_init_r, processes the initializers for vectors.
4412 Parameters are the same of reshape_init_r. */
4415 reshape_init_vector (tree type, reshape_iter *d)
4417 tree max_index = NULL_TREE;
4420 gcc_assert (TREE_CODE (type) == VECTOR_TYPE);
4422 if (COMPOUND_LITERAL_P (d->cur->value))
4424 tree value = d->cur->value;
4425 if (!same_type_p (TREE_TYPE (value), type))
4427 error ("invalid type %qT as initializer for a vector of type %qT",
4428 TREE_TYPE (d->cur->value), type);
4429 value = error_mark_node;
4435 /* For a vector, the representation type is a struct
4436 containing a single member which is an array of the
4437 appropriate size. */
4438 rtype = TYPE_DEBUG_REPRESENTATION_TYPE (type);
4439 if (rtype && TYPE_DOMAIN (TREE_TYPE (TYPE_FIELDS (rtype))))
4440 max_index = array_type_nelts (TREE_TYPE (TYPE_FIELDS (rtype)));
4442 return reshape_init_array_1 (TREE_TYPE (type), max_index, d);
4445 /* Subroutine of reshape_init_r, processes the initializers for classes
4446 or union. Parameters are the same of reshape_init_r. */
4449 reshape_init_class (tree type, reshape_iter *d, bool first_initializer_p)
4454 gcc_assert (CLASS_TYPE_P (type));
4456 /* The initializer for a class is always a CONSTRUCTOR. */
4457 new_init = build_constructor (NULL_TREE, NULL);
4458 field = next_initializable_field (TYPE_FIELDS (type));
4464 An initializer for an aggregate member that is an
4465 empty class shall have the form of an empty
4466 initializer-list {}. */
4467 if (!first_initializer_p)
4469 error ("initializer for %qT must be brace-enclosed", type);
4470 return error_mark_node;
4475 /* Loop through the initializable fields, gathering initializers. */
4476 while (d->cur != d->end)
4480 /* Handle designated initializers, as an extension. */
4484 pedwarn ("ISO C++ does not allow designated initializers");
4486 field = lookup_field_1 (type, d->cur->index, /*want_type=*/false);
4488 if (!field || TREE_CODE (field) != FIELD_DECL)
4489 error ("%qT has no non-static data member named %qD", type,
4493 /* If we processed all the member of the class, we are done. */
4497 field_init = reshape_init_r (TREE_TYPE (field), d,
4498 /*first_initializer_p=*/false);
4499 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), field, field_init);
4503 When a union is initialized with a brace-enclosed
4504 initializer, the braces shall only contain an
4505 initializer for the first member of the union. */
4506 if (TREE_CODE (type) == UNION_TYPE)
4509 field = next_initializable_field (TREE_CHAIN (field));
4515 /* Subroutine of reshape_init, which processes a single initializer (part of
4516 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
4517 iterator within the CONSTRUCTOR which points to the initializer to process.
4518 FIRST_INITIALIZER_P is true if this is the first initializer of the
4519 CONSTRUCTOR node. */
4522 reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p)
4524 tree init = d->cur->value;
4526 /* A non-aggregate type is always initialized with a single
4528 if (!CP_AGGREGATE_TYPE_P (type))
4530 /* It is invalid to initialize a non-aggregate type with a
4531 brace-enclosed initializer.
4532 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
4533 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
4534 a CONSTRUCTOR (with a record type). */
4535 if (TREE_CODE (init) == CONSTRUCTOR
4536 && BRACE_ENCLOSED_INITIALIZER_P (init)) /* p7626.C */
4538 error ("braces around scalar initializer for type %qT", type);
4539 init = error_mark_node;
4548 All implicit type conversions (clause _conv_) are considered when
4549 initializing the aggregate member with an initializer from an
4550 initializer-list. If the initializer can initialize a member,
4551 the member is initialized. Otherwise, if the member is itself a
4552 non-empty subaggregate, brace elision is assumed and the
4553 initializer is considered for the initialization of the first
4554 member of the subaggregate. */
4555 if (TREE_CODE (init) != CONSTRUCTOR
4556 && can_convert_arg (type, TREE_TYPE (init), init, LOOKUP_NORMAL))
4562 /* [dcl.init.string]
4564 A char array (whether plain char, signed char, or unsigned char)
4565 can be initialized by a string-literal (optionally enclosed in
4566 braces); a wchar_t array can be initialized by a wide
4567 string-literal (optionally enclosed in braces). */
4568 if (TREE_CODE (type) == ARRAY_TYPE
4569 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
4571 tree str_init = init;
4573 /* Strip one level of braces if and only if they enclose a single
4574 element (as allowed by [dcl.init.string]). */
4575 if (!first_initializer_p
4576 && TREE_CODE (str_init) == CONSTRUCTOR
4577 && VEC_length (constructor_elt, CONSTRUCTOR_ELTS (str_init)) == 1)
4579 str_init = VEC_index (constructor_elt,
4580 CONSTRUCTOR_ELTS (str_init), 0)->value;
4583 /* If it's a string literal, then it's the initializer for the array
4584 as a whole. Otherwise, continue with normal initialization for
4585 array types (one value per array element). */
4586 if (TREE_CODE (str_init) == STRING_CST)
4593 /* The following cases are about aggregates. If we are not within a full
4594 initializer already, and there is not a CONSTRUCTOR, it means that there
4595 is a missing set of braces (that is, we are processing the case for
4596 which reshape_init exists). */
4597 if (!first_initializer_p)
4599 if (TREE_CODE (init) == CONSTRUCTOR)
4601 /* For a nested compound literal, there is no need to reshape since
4602 brace elision is not allowed. Even if we decided to allow it,
4603 we should add a call to reshape_init in finish_compound_literal,
4604 before calling digest_init, so changing this code would still
4605 not be necessary. */
4606 if (!COMPOUND_LITERAL_P (init))
4609 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
4610 return reshape_init (type, init);
4613 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init));
4616 warning (OPT_Wmissing_braces, "missing braces around initializer for %qT",
4620 /* Dispatch to specialized routines. */
4621 if (CLASS_TYPE_P (type))
4622 return reshape_init_class (type, d, first_initializer_p);
4623 else if (TREE_CODE (type) == ARRAY_TYPE)
4624 return reshape_init_array (type, d);
4625 else if (TREE_CODE (type) == VECTOR_TYPE)
4626 return reshape_init_vector (type, d);
4631 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
4632 brace-enclosed aggregate initializer.
4634 INIT is the CONSTRUCTOR containing the list of initializers describing
4635 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
4636 It may not presently match the shape of the TYPE; for example:
4638 struct S { int a; int b; };
4639 struct S a[] = { 1, 2, 3, 4 };
4641 Here INIT will hold a VEC of four elements, rather than a
4642 VEC of two elements, each itself a VEC of two elements. This
4643 routine transforms INIT from the former form into the latter. The
4644 revised CONSTRUCTOR node is returned. */
4647 reshape_init (tree type, tree init)
4649 VEC(constructor_elt, gc) *v;
4653 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
4655 v = CONSTRUCTOR_ELTS (init);
4657 /* An empty constructor does not need reshaping, and it is always a valid
4659 if (VEC_empty (constructor_elt, v))
4662 /* Recurse on this CONSTRUCTOR. */
4663 d.cur = VEC_index (constructor_elt, v, 0);
4664 d.end = d.cur + VEC_length (constructor_elt, v);
4666 new_init = reshape_init_r (type, &d, true);
4667 if (new_init == error_mark_node)
4668 return error_mark_node;
4670 /* Make sure all the element of the constructor were used. Otherwise,
4671 issue an error about exceeding initializers. */
4673 error ("too many initializers for %qT", type);
4678 /* Verify INIT (the initializer for DECL), and record the
4679 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
4680 grok_reference_init.
4682 If the return value is non-NULL, it is an expression that must be
4683 evaluated dynamically to initialize DECL. */
4686 check_initializer (tree decl, tree init, int flags, tree *cleanup)
4688 tree type = TREE_TYPE (decl);
4689 tree init_code = NULL;
4691 /* Things that are going to be initialized need to have complete
4693 TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
4695 if (type == error_mark_node)
4696 /* We will have already complained. */
4698 else if (init && COMPLETE_TYPE_P (type)
4699 && !TREE_CONSTANT (TYPE_SIZE (type)))
4701 error ("variable-sized object %qD may not be initialized", decl);
4704 else if (TREE_CODE (type) == ARRAY_TYPE
4705 && !COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
4707 error ("elements of array %q#D have incomplete type", decl);
4710 else if (TREE_CODE (type) != ARRAY_TYPE && !COMPLETE_TYPE_P (type))
4712 error ("%qD has incomplete type", decl);
4713 TREE_TYPE (decl) = error_mark_node;
4717 if (TREE_CODE (decl) == CONST_DECL)
4719 gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);
4721 DECL_INITIAL (decl) = init;
4723 gcc_assert (init != NULL_TREE);
4726 else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
4727 init = grok_reference_init (decl, type, init, cleanup);
4730 /* Do not reshape constructors of vectors (they don't need to be
4732 if (TREE_CODE (init) == CONSTRUCTOR
4733 && !COMPOUND_LITERAL_P (init)
4734 && !TREE_TYPE (init)) /* ptrmemfunc */
4736 init = reshape_init (type, init);
4738 if ((*targetm.vector_opaque_p) (type))
4740 error ("opaque vector types cannot be initialized");
4741 init = error_mark_node;
4745 /* If DECL has an array type without a specific bound, deduce the
4746 array size from the initializer. */
4747 maybe_deduce_size_from_array_init (decl, init);
4748 type = TREE_TYPE (decl);
4749 if (type == error_mark_node)
4752 if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
4754 if (TREE_CODE (type) == ARRAY_TYPE)
4755 goto initialize_aggr;
4756 else if (TREE_CODE (init) == CONSTRUCTOR)
4758 if (TYPE_NON_AGGREGATE_CLASS (type))
4760 error ("%qD must be initialized by constructor, "
4763 init = error_mark_node;
4766 goto dont_use_constructor;
4770 int saved_stmts_are_full_exprs_p;
4773 saved_stmts_are_full_exprs_p = 0;
4774 if (building_stmt_tree ())
4776 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
4777 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
4779 init = build_aggr_init (decl, init, flags);
4780 if (building_stmt_tree ())
4781 current_stmt_tree ()->stmts_are_full_exprs_p =
4782 saved_stmts_are_full_exprs_p;
4788 dont_use_constructor:
4789 if (TREE_CODE (init) != TREE_VEC)
4791 init_code = store_init_value (decl, init);
4792 if (pedantic && TREE_CODE (type) == ARRAY_TYPE
4793 && DECL_INITIAL (decl)
4794 && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST
4795 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl)))
4796 warning (0, "array %qD initialized by parenthesized string literal %qE",
4797 decl, DECL_INITIAL (decl));
4802 else if (DECL_EXTERNAL (decl))
4804 else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
4805 goto initialize_aggr;
4806 else if (IS_AGGR_TYPE (type))
4808 tree core_type = strip_array_types (type);
4810 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
4811 error ("structure %qD with uninitialized const members", decl);
4812 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
4813 error ("structure %qD with uninitialized reference members", decl);
4815 check_for_uninitialized_const_var (decl);
4818 check_for_uninitialized_const_var (decl);
4820 if (init && init != error_mark_node)
4821 init_code = build2 (INIT_EXPR, type, decl, init);
4826 /* If DECL is not a local variable, give it RTL. */
4829 make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
4831 int toplev = toplevel_bindings_p ();
4833 const char *filename;
4835 /* Set the DECL_ASSEMBLER_NAME for the object. */
4838 /* The `register' keyword, when used together with an
4839 asm-specification, indicates that the variable should be
4840 placed in a particular register. */
4841 if (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
4843 set_user_assembler_name (decl, asmspec);
4844 DECL_HARD_REGISTER (decl) = 1;
4848 if (TREE_CODE (decl) == FUNCTION_DECL
4849 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
4850 set_builtin_user_assembler_name (decl, asmspec);
4851 set_user_assembler_name (decl, asmspec);
4855 /* Handle non-variables up front. */
4856 if (TREE_CODE (decl) != VAR_DECL)
4858 rest_of_decl_compilation (decl, toplev, at_eof);
4862 /* If we see a class member here, it should be a static data
4864 if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
4866 gcc_assert (TREE_STATIC (decl));
4867 /* An in-class declaration of a static data member should be
4868 external; it is only a declaration, and not a definition. */
4869 if (init == NULL_TREE)
4870 gcc_assert (DECL_EXTERNAL (decl));
4873 /* We don't create any RTL for local variables. */
4874 if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
4877 /* We defer emission of local statics until the corresponding
4878 DECL_EXPR is expanded. */
4879 defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
4881 /* We try to defer namespace-scope static constants so that they are
4882 not emitted into the object file unnecessarily. */
4883 filename = input_filename;
4884 if (!DECL_VIRTUAL_P (decl)
4885 && TREE_READONLY (decl)
4886 && DECL_INITIAL (decl) != NULL_TREE
4887 && DECL_INITIAL (decl) != error_mark_node
4889 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
4891 && !TREE_PUBLIC (decl))
4893 /* Fool with the linkage of static consts according to #pragma
4895 struct c_fileinfo *finfo = get_fileinfo (lbasename (filename));
4896 if (!finfo->interface_unknown && !TREE_PUBLIC (decl))
4898 TREE_PUBLIC (decl) = 1;
4899 DECL_EXTERNAL (decl) = finfo->interface_only;
4904 /* Likewise for template instantiations. */
4905 else if (DECL_LANG_SPECIFIC (decl)
4906 && DECL_IMPLICIT_INSTANTIATION (decl))
4909 /* If we're not deferring, go ahead and assemble the variable. */
4911 rest_of_decl_compilation (decl, toplev, at_eof);
4914 /* Generate code to initialize DECL (a local variable). */
4917 initialize_local_var (tree decl, tree init)
4919 tree type = TREE_TYPE (decl);
4922 gcc_assert (TREE_CODE (decl) == VAR_DECL
4923 || TREE_CODE (decl) == RESULT_DECL);
4924 gcc_assert (!TREE_STATIC (decl));
4926 if (DECL_SIZE (decl) == NULL_TREE)
4928 /* If we used it already as memory, it must stay in memory. */
4929 DECL_INITIAL (decl) = NULL_TREE;
4930 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
4933 if (DECL_SIZE (decl) && type != error_mark_node)
4937 /* Compute and store the initial value. */
4938 already_used = TREE_USED (decl) || TREE_USED (type);
4940 /* Perform the initialization. */
4943 int saved_stmts_are_full_exprs_p;
4945 gcc_assert (building_stmt_tree ());
4946 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
4947 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
4948 finish_expr_stmt (init);
4949 current_stmt_tree ()->stmts_are_full_exprs_p =
4950 saved_stmts_are_full_exprs_p;
4953 /* Set this to 0 so we can tell whether an aggregate which was
4954 initialized was ever used. Don't do this if it has a
4955 destructor, so we don't complain about the 'resource
4956 allocation is initialization' idiom. Now set
4957 attribute((unused)) on types so decls of that type will be
4958 marked used. (see TREE_USED, above.) */
4959 if (TYPE_NEEDS_CONSTRUCTING (type)
4961 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
4962 && DECL_NAME (decl))
4963 TREE_USED (decl) = 0;
4964 else if (already_used)
4965 TREE_USED (decl) = 1;
4968 /* Generate a cleanup, if necessary. */
4969 cleanup = cxx_maybe_build_cleanup (decl);
4970 if (DECL_SIZE (decl) && cleanup)
4971 finish_decl_cleanup (decl, cleanup);
4974 /* DECL is a VAR_DECL for a compiler-generated variable with static
4975 storage duration (like a virtual table) whose initializer is a
4976 compile-time constant. INIT must be either a TREE_LIST of values,
4977 or a CONSTRUCTOR. Initialize the variable and provide it to the
4981 initialize_artificial_var (tree decl, tree init)
4983 if (TREE_CODE (init) == TREE_LIST)
4984 init = build_constructor_from_list (NULL_TREE, init);
4985 gcc_assert (TREE_CODE (init) == CONSTRUCTOR);
4986 DECL_INITIAL (decl) = init;
4987 DECL_INITIALIZED_P (decl) = 1;
4988 determine_visibility (decl);
4989 layout_var_decl (decl);
4990 maybe_commonize_var (decl);
4991 make_rtl_for_nonlocal_decl (decl, init, /*asmspec=*/NULL);
4994 /* Finish processing of a declaration;
4995 install its line number and initial value.
4996 If the length of an array type is not known before,
4997 it must be determined now, from the initial value, or it is an error.
4999 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
5000 true, then INIT is an integral constant expression.
5002 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
5003 if the (init) syntax was used. */
5006 cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
5007 tree asmspec_tree, int flags)
5011 const char *asmspec = NULL;
5012 int was_readonly = 0;
5013 bool var_definition_p = false;
5014 int saved_processing_template_decl;
5016 if (decl == error_mark_node)
5021 error ("assignment (not initialization) in declaration");
5025 gcc_assert (TREE_CODE (decl) != RESULT_DECL);
5026 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
5027 gcc_assert (TREE_CODE (decl) != PARM_DECL);
5029 type = TREE_TYPE (decl);
5030 if (type == error_mark_node)
5033 /* Assume no cleanup is required. */
5034 cleanup = NULL_TREE;
5035 saved_processing_template_decl = processing_template_decl;
5037 /* If a name was specified, get the string. */
5038 if (global_scope_p (current_binding_level))
5039 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
5041 asmspec = TREE_STRING_POINTER (asmspec_tree);
5043 if (current_class_type
5044 && CP_DECL_CONTEXT (decl) == current_class_type
5045 && TYPE_BEING_DEFINED (current_class_type)
5046 && (DECL_INITIAL (decl) || init))
5047 DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
5049 if (processing_template_decl)
5051 bool type_dependent_p;
5053 /* Add this declaration to the statement-tree. */
5054 if (at_function_scope_p ())
5055 add_decl_expr (decl);
5057 type_dependent_p = dependent_type_p (type);
5059 if (init && init_const_expr_p)
5061 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
5062 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl))
5063 TREE_CONSTANT (decl) = 1;
5067 || !DECL_CLASS_SCOPE_P (decl)
5068 || !DECL_INTEGRAL_CONSTANT_VAR_P (decl)
5070 || value_dependent_expression_p (init))
5073 DECL_INITIAL (decl) = init;
5074 if (TREE_CODE (decl) == VAR_DECL
5075 && !DECL_PRETTY_FUNCTION_P (decl)
5076 && !type_dependent_p)
5077 maybe_deduce_size_from_array_init (decl, init);
5081 init = fold_non_dependent_expr (init);
5082 processing_template_decl = 0;
5085 /* Take care of TYPE_DECLs up front. */
5086 if (TREE_CODE (decl) == TYPE_DECL)
5088 if (type != error_mark_node
5089 && IS_AGGR_TYPE (type) && DECL_NAME (decl))
5091 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
5092 warning (0, "shadowing previous type declaration of %q#D", decl);
5093 set_identifier_type_value (DECL_NAME (decl), decl);
5096 /* If we have installed this as the canonical typedef for this
5097 type, and that type has not been defined yet, delay emitting
5098 the debug information for it, as we will emit it later. */
5099 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
5100 && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
5101 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
5103 rest_of_decl_compilation (decl, DECL_CONTEXT (decl) == NULL_TREE,
5108 /* A reference will be modified here, as it is initialized. */
5109 if (! DECL_EXTERNAL (decl)
5110 && TREE_READONLY (decl)
5111 && TREE_CODE (type) == REFERENCE_TYPE)
5114 TREE_READONLY (decl) = 0;
5117 if (TREE_CODE (decl) == VAR_DECL)
5119 /* Only PODs can have thread-local storage. Other types may require
5120 various kinds of non-trivial initialization. */
5121 if (DECL_THREAD_LOCAL_P (decl) && !pod_type_p (TREE_TYPE (decl)))
5122 error ("%qD cannot be thread-local because it has non-POD type %qT",
5123 decl, TREE_TYPE (decl));
5124 /* Convert the initializer to the type of DECL, if we have not
5125 already initialized DECL. */
5126 if (!DECL_INITIALIZED_P (decl)
5127 /* If !DECL_EXTERNAL then DECL is being defined. In the
5128 case of a static data member initialized inside the
5129 class-specifier, there can be an initializer even if DECL
5130 is *not* defined. */
5131 && (!DECL_EXTERNAL (decl) || init))
5135 DECL_NONTRIVIALLY_INITIALIZED_P (decl) = 1;
5136 if (init_const_expr_p)
5138 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
5139 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl))
5140 TREE_CONSTANT (decl) = 1;
5143 init = check_initializer (decl, init, flags, &cleanup);
5144 /* Thread-local storage cannot be dynamically initialized. */
5145 if (DECL_THREAD_LOCAL_P (decl) && init)
5147 error ("%qD is thread-local and so cannot be dynamically "
5148 "initialized", decl);
5152 /* Check that the initializer for a static data member was a
5153 constant. Although we check in the parser that the
5154 initializer is an integral constant expression, we do not
5155 simplify division-by-zero at the point at which it
5156 occurs. Therefore, in:
5158 struct S { static const int i = 7 / 0; };
5160 we issue an error at this point. It would
5161 probably be better to forbid division by zero in
5162 integral constant expressions. */
5163 if (DECL_EXTERNAL (decl) && init)
5165 error ("%qD cannot be initialized by a non-constant expression"
5166 " when being declared", decl);
5167 DECL_INITIALIZED_IN_CLASS_P (decl) = 0;
5175 The memory occupied by any object of static storage
5176 duration is zero-initialized at program startup before
5177 any other initialization takes place.
5179 We cannot create an appropriate initializer until after
5180 the type of DECL is finalized. If DECL_INITIAL is set,
5181 then the DECL is statically initialized, and any
5182 necessary zero-initialization has already been performed. */
5183 if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
5184 DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
5185 /*nelts=*/NULL_TREE,
5186 /*static_storage_p=*/true);
5187 /* Remember that the initialization for this variable has
5189 DECL_INITIALIZED_P (decl) = 1;
5190 /* This declaration is the definition of this variable,
5191 unless we are initializing a static data member within
5192 the class specifier. */
5193 if (!DECL_EXTERNAL (decl))
5194 var_definition_p = true;
5196 /* If the variable has an array type, lay out the type, even if
5197 there is no initializer. It is valid to index through the
5198 array, and we must get TYPE_ALIGN set correctly on the array
5200 else if (TREE_CODE (type) == ARRAY_TYPE)
5204 /* Add this declaration to the statement-tree. This needs to happen
5205 after the call to check_initializer so that the DECL_EXPR for a
5206 reference temp is added before the DECL_EXPR for the reference itself. */
5207 if (at_function_scope_p ())
5208 add_decl_expr (decl);
5210 if (TREE_CODE (decl) == VAR_DECL)
5211 layout_var_decl (decl);
5213 /* Output the assembler code and/or RTL code for variables and functions,
5214 unless the type is an undefined structure or union.
5215 If not, it will get done when the type is completed. */
5216 if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
5218 if (TREE_CODE (decl) == VAR_DECL)
5219 maybe_commonize_var (decl);
5221 make_rtl_for_nonlocal_decl (decl, init, asmspec);
5223 /* Check for abstractness of the type. Notice that there is no
5224 need to strip array types here since the check for those types
5225 is already done within create_array_type_for_decl. */
5226 if (TREE_CODE (type) == FUNCTION_TYPE
5227 || TREE_CODE (type) == METHOD_TYPE)
5228 abstract_virtuals_error (decl, TREE_TYPE (type));
5230 abstract_virtuals_error (decl, type);
5232 if (TREE_CODE (decl) == FUNCTION_DECL
5233 || TREE_TYPE (decl) == error_mark_node)
5234 /* No initialization required. */
5236 else if (DECL_EXTERNAL (decl)
5237 && ! (DECL_LANG_SPECIFIC (decl)
5238 && DECL_NOT_REALLY_EXTERN (decl)))
5241 DECL_INITIAL (decl) = init;
5245 /* A variable definition. */
5246 if (DECL_FUNCTION_SCOPE_P (decl))
5248 /* Initialize the local variable. */
5249 if (processing_template_decl)
5250 DECL_INITIAL (decl) = init;
5251 else if (!TREE_STATIC (decl))
5252 initialize_local_var (decl, init);
5255 /* The variable is being defined, so determine its visibility.
5256 This needs to happen after the linkage is set. */
5257 determine_visibility (decl);
5259 /* If a variable is defined, and then a subsequent
5260 definition with external linkage is encountered, we will
5261 get here twice for the same variable. We want to avoid
5262 calling expand_static_init more than once. For variables
5263 that are not static data members, we can call
5264 expand_static_init only when we actually process the
5265 initializer. It is not legal to redeclare a static data
5266 member, so this issue does not arise in that case. */
5267 if (var_definition_p && TREE_STATIC (decl))
5268 expand_static_init (decl, init);
5272 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
5273 reference, insert it in the statement-tree now. */
5275 push_cleanup (decl, cleanup, false);
5278 processing_template_decl = saved_processing_template_decl;
5281 TREE_READONLY (decl) = 1;
5283 /* If this was marked 'used', be sure it will be output. */
5284 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
5285 mark_decl_referenced (decl);
5288 /* This is here for a midend callback from c-common.c. */
5291 finish_decl (tree decl, tree init, tree asmspec_tree)
5293 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, asmspec_tree, 0);
5296 /* Returns a declaration for a VAR_DECL as if:
5298 extern "C" TYPE NAME;
5300 had been seen. Used to create compiler-generated global
5304 declare_global_var (tree name, tree type)
5308 push_to_top_level ();
5309 decl = build_decl (VAR_DECL, name, type);
5310 TREE_PUBLIC (decl) = 1;
5311 DECL_EXTERNAL (decl) = 1;
5312 DECL_ARTIFICIAL (decl) = 1;
5313 /* If the user has explicitly declared this variable (perhaps
5314 because the code we are compiling is part of a low-level runtime
5315 library), then it is possible that our declaration will be merged
5316 with theirs by pushdecl. */
5317 decl = pushdecl (decl);
5318 finish_decl (decl, NULL_TREE, NULL_TREE);
5319 pop_from_top_level ();
5324 /* Returns a pointer to the `atexit' function. Note that if
5325 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
5326 `__cxa_atexit' function specified in the IA64 C++ ABI. */
5329 get_atexit_node (void)
5336 bool use_aeabi_atexit;
5341 if (flag_use_cxa_atexit)
5343 /* The declaration for `__cxa_atexit' is:
5345 int __cxa_atexit (void (*)(void *), void *, void *)
5347 We build up the argument types and then then function type
5350 use_aeabi_atexit = targetm.cxx.use_aeabi_atexit ();
5351 /* First, build the pointer-to-function type for the first
5353 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5354 fn_type = build_function_type (void_type_node, arg_types);
5355 fn_ptr_type = build_pointer_type (fn_type);
5356 /* Then, build the rest of the argument types. */
5357 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5358 if (use_aeabi_atexit)
5360 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
5361 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
5365 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
5366 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
5368 /* And the final __cxa_atexit type. */
5369 fn_type = build_function_type (integer_type_node, arg_types);
5370 fn_ptr_type = build_pointer_type (fn_type);
5371 if (use_aeabi_atexit)
5372 name = "__aeabi_atexit";
5374 name = "__cxa_atexit";
5378 /* The declaration for `atexit' is:
5380 int atexit (void (*)());
5382 We build up the argument types and then then function type
5384 fn_type = build_function_type (void_type_node, void_list_node);
5385 fn_ptr_type = build_pointer_type (fn_type);
5386 arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
5387 /* Build the final atexit type. */
5388 fn_type = build_function_type (integer_type_node, arg_types);
5392 /* Now, build the function declaration. */
5393 push_lang_context (lang_name_c);
5394 atexit_fndecl = build_library_fn_ptr (name, fn_type);
5395 mark_used (atexit_fndecl);
5396 pop_lang_context ();
5397 atexit_node = decay_conversion (atexit_fndecl);
5402 /* Returns the __dso_handle VAR_DECL. */
5405 get_dso_handle_node (void)
5407 if (dso_handle_node)
5408 return dso_handle_node;
5410 /* Declare the variable. */
5411 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
5414 return dso_handle_node;
5417 /* Begin a new function with internal linkage whose job will be simply
5418 to destroy some particular variable. */
5420 static GTY(()) int start_cleanup_cnt;
5423 start_cleanup_fn (void)
5430 push_to_top_level ();
5432 /* No need to mangle this. */
5433 push_lang_context (lang_name_c);
5435 /* Build the parameter-types. */
5436 parmtypes = void_list_node;
5437 /* Functions passed to __cxa_atexit take an additional parameter.
5438 We'll just ignore it. After we implement the new calling
5439 convention for destructors, we can eliminate the use of
5440 additional cleanup functions entirely in the -fnew-abi case. */
5441 if (flag_use_cxa_atexit)
5442 parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
5443 /* Build the function type itself. */
5444 fntype = build_function_type (void_type_node, parmtypes);
5445 /* Build the name of the function. */
5446 sprintf (name, "__tcf_%d", start_cleanup_cnt++);
5447 /* Build the function declaration. */
5448 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
5449 /* It's a function with internal linkage, generated by the
5451 TREE_PUBLIC (fndecl) = 0;
5452 DECL_ARTIFICIAL (fndecl) = 1;
5453 /* Make the function `inline' so that it is only emitted if it is
5454 actually needed. It is unlikely that it will be inlined, since
5455 it is only called via a function pointer, but we avoid unnecessary
5456 emissions this way. */
5457 DECL_INLINE (fndecl) = 1;
5458 DECL_DECLARED_INLINE_P (fndecl) = 1;
5459 DECL_INTERFACE_KNOWN (fndecl) = 1;
5460 /* Build the parameter. */
5461 if (flag_use_cxa_atexit)
5465 parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
5466 DECL_CONTEXT (parmdecl) = fndecl;
5467 TREE_USED (parmdecl) = 1;
5468 DECL_ARGUMENTS (fndecl) = parmdecl;
5472 start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED);
5474 pop_lang_context ();
5476 return current_function_decl;
5479 /* Finish the cleanup function begun by start_cleanup_fn. */
5482 end_cleanup_fn (void)
5484 expand_or_defer_fn (finish_function (0));
5486 pop_from_top_level ();
5489 /* Generate code to handle the destruction of DECL, an object with
5490 static storage duration. */
5493 register_dtor_fn (tree decl)
5500 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
5501 return void_zero_node;
5503 /* Call build_cleanup before we enter the anonymous function so that
5504 any access checks will be done relative to the current scope,
5505 rather than the scope of the anonymous function. */
5506 build_cleanup (decl);
5508 /* Now start the function. */
5509 cleanup = start_cleanup_fn ();
5511 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
5512 to the original function, rather than the anonymous one. That
5513 will make the back-end think that nested functions are in use,
5514 which causes confusion. */
5516 push_deferring_access_checks (dk_no_check);
5517 fcall = build_cleanup (decl);
5518 pop_deferring_access_checks ();
5520 /* Create the body of the anonymous function. */
5521 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
5522 finish_expr_stmt (fcall);
5523 finish_compound_stmt (compound_stmt);
5526 /* Call atexit with the cleanup function. */
5527 cxx_mark_addressable (cleanup);
5528 mark_used (cleanup);
5529 cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
5530 if (flag_use_cxa_atexit)
5532 args = tree_cons (NULL_TREE,
5533 build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0),
5535 if (targetm.cxx.use_aeabi_atexit ())
5537 args = tree_cons (NULL_TREE, cleanup, args);
5538 args = tree_cons (NULL_TREE, null_pointer_node, args);
5542 args = tree_cons (NULL_TREE, null_pointer_node, args);
5543 args = tree_cons (NULL_TREE, cleanup, args);
5547 args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
5548 return build_function_call (get_atexit_node (), args);
5551 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
5552 is its initializer. Generate code to handle the construction
5553 and destruction of DECL. */
5556 expand_static_init (tree decl, tree init)
5558 gcc_assert (TREE_CODE (decl) == VAR_DECL);
5559 gcc_assert (TREE_STATIC (decl));
5561 /* Some variables require no initialization. */
5563 && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
5564 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
5567 if (DECL_FUNCTION_SCOPE_P (decl))
5569 /* Emit code to perform this initialization but once. */
5570 tree if_stmt = NULL_TREE, inner_if_stmt = NULL_TREE;
5571 tree then_clause = NULL_TREE, inner_then_clause = NULL_TREE;
5572 tree guard, guard_addr, guard_addr_list;
5573 tree acquire_fn, release_fn, abort_fn;
5576 /* Emit code to perform this initialization but once. This code
5579 static <type> guard;
5580 if (!guard.first_byte) {
5581 if (__cxa_guard_acquire (&guard)) {
5584 // Do initialization.
5585 flag = true; __cxa_guard_release (&guard);
5586 // Register variable for destruction at end of program.
5588 if (!flag) __cxa_guard_abort (&guard);
5592 Note that the `flag' variable is only set to 1 *after* the
5593 initialization is complete. This ensures that an exception,
5594 thrown during the construction, will cause the variable to
5595 reinitialized when we pass through this code again, as per:
5599 If the initialization exits by throwing an exception, the
5600 initialization is not complete, so it will be tried again
5601 the next time control enters the declaration.
5603 This process should be thread-safe, too; multiple threads
5604 should not be able to initialize the variable more than
5607 /* Create the guard variable. */
5608 guard = get_guard (decl);
5610 /* This optimization isn't safe on targets with relaxed memory
5611 consistency. On such targets we force synchronization in
5612 __cxa_guard_acquire. */
5613 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
5615 /* Begin the conditional initialization. */
5616 if_stmt = begin_if_stmt ();
5617 finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
5618 then_clause = begin_compound_stmt (BCS_NO_SCOPE);
5621 if (flag_threadsafe_statics)
5623 guard_addr = build_address (guard);
5624 guard_addr_list = build_tree_list (NULL_TREE, guard_addr);
5626 acquire_fn = get_identifier ("__cxa_guard_acquire");
5627 release_fn = get_identifier ("__cxa_guard_release");
5628 abort_fn = get_identifier ("__cxa_guard_abort");
5629 if (!get_global_value_if_present (acquire_fn, &acquire_fn))
5631 tree argtypes = tree_cons (NULL_TREE, TREE_TYPE (guard_addr),
5633 tree vfntype = build_function_type (void_type_node, argtypes);
5634 acquire_fn = push_library_fn
5635 (acquire_fn, build_function_type (integer_type_node, argtypes));
5636 release_fn = push_library_fn (release_fn, vfntype);
5637 abort_fn = push_library_fn (abort_fn, vfntype);
5641 release_fn = identifier_global_value (release_fn);
5642 abort_fn = identifier_global_value (abort_fn);
5645 inner_if_stmt = begin_if_stmt ();
5646 finish_if_stmt_cond (build_call (acquire_fn, guard_addr_list),
5649 inner_then_clause = begin_compound_stmt (BCS_NO_SCOPE);
5650 begin = get_target_expr (boolean_false_node);
5651 flag = TARGET_EXPR_SLOT (begin);
5653 TARGET_EXPR_CLEANUP (begin)
5654 = build3 (COND_EXPR, void_type_node, flag,
5656 build_call (abort_fn, guard_addr_list));
5657 CLEANUP_EH_ONLY (begin) = 1;
5659 /* Do the initialization itself. */
5660 init = add_stmt_to_compound (begin, init);
5661 init = add_stmt_to_compound
5662 (init, build2 (MODIFY_EXPR, void_type_node, flag, boolean_true_node));
5663 init = add_stmt_to_compound
5664 (init, build_call (release_fn, guard_addr_list));
5667 init = add_stmt_to_compound (init, set_guard (guard));
5669 /* Use atexit to register a function for destroying this static
5671 init = add_stmt_to_compound (init, register_dtor_fn (decl));
5673 finish_expr_stmt (init);
5675 if (flag_threadsafe_statics)
5677 finish_compound_stmt (inner_then_clause);
5678 finish_then_clause (inner_if_stmt);
5679 finish_if_stmt (inner_if_stmt);
5682 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
5684 finish_compound_stmt (then_clause);
5685 finish_then_clause (if_stmt);
5686 finish_if_stmt (if_stmt);
5690 static_aggregates = tree_cons (init, decl, static_aggregates);
5694 /* Make TYPE a complete type based on INITIAL_VALUE.
5695 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
5696 2 if there was no information (in which case assume 0 if DO_DEFAULT),
5697 3 if the initializer list is empty (in pedantic mode). */
5700 cp_complete_array_type (tree *ptype, tree initial_value, bool do_default)
5703 tree type, elt_type;
5707 /* An array of character type can be initialized from a
5708 brace-enclosed string constant.
5710 FIXME: this code is duplicated from reshape_init. Probably
5711 we should just call reshape_init here? */
5712 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype)))
5713 && TREE_CODE (initial_value) == CONSTRUCTOR
5714 && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (initial_value)))
5716 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
5717 tree value = VEC_index (constructor_elt, v, 0)->value;
5719 if (TREE_CODE (value) == STRING_CST
5720 && VEC_length (constructor_elt, v) == 1)
5721 initial_value = value;
5725 failure = complete_array_type (ptype, initial_value, do_default);
5727 /* We can create the array before the element type is complete, which
5728 means that we didn't have these two bits set in the original type
5729 either. In completing the type, we are expected to propagate these
5730 bits. See also complete_type which does the same thing for arrays
5733 if (TYPE_DOMAIN (type))
5735 elt_type = TREE_TYPE (type);
5736 TYPE_NEEDS_CONSTRUCTING (type) = TYPE_NEEDS_CONSTRUCTING (elt_type);
5737 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
5738 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type);
5744 /* Return zero if something is declared to be a member of type
5745 CTYPE when in the context of CUR_TYPE. STRING is the error
5746 message to print in that case. Otherwise, quietly return 1. */
5749 member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
5751 if (ctype && ctype != cur_type)
5753 if (flags == DTOR_FLAG)
5754 error ("destructor for alien class %qT cannot be a member", ctype);
5756 error ("constructor for alien class %qT cannot be a member", ctype);
5762 /* Subroutine of `grokdeclarator'. */
5764 /* Generate errors possibly applicable for a given set of specifiers.
5765 This is for ARM $7.1.2. */
5768 bad_specifiers (tree object,
5777 error ("%qD declared as a %<virtual%> %s", object, type);
5779 error ("%qD declared as an %<inline%> %s", object, type);
5781 error ("%<const%> and %<volatile%> function specifiers on "
5782 "%qD invalid in %s declaration",
5785 error ("%q+D declared as a friend", object);
5787 && (TREE_CODE (object) == TYPE_DECL
5788 || (!TYPE_PTRFN_P (TREE_TYPE (object))
5789 && !TYPE_REFFN_P (TREE_TYPE (object))
5790 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
5791 error ("%q+D declared with an exception specification", object);
5794 /* DECL is a member function or static data member and is presently
5795 being defined. Check that the definition is taking place in a
5799 check_class_member_definition_namespace (tree decl)
5801 /* These checks only apply to member functions and static data
5803 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
5804 || TREE_CODE (decl) == VAR_DECL);
5805 /* We check for problems with specializations in pt.c in
5806 check_specialization_namespace, where we can issue better
5808 if (processing_specialization)
5810 /* There are no restrictions on the placement of
5811 explicit instantiations. */
5812 if (processing_explicit_instantiation)
5816 A member function definition that appears outside of the
5817 class definition shall appear in a namespace scope enclosing
5818 the class definition.
5822 The definition for a static data member shall appear in a
5823 namespace scope enclosing the member's class definition. */
5824 if (!is_ancestor (current_namespace, DECL_CONTEXT (decl)))
5825 pedwarn ("definition of %qD is not in namespace enclosing %qT",
5826 decl, DECL_CONTEXT (decl));
5829 /* Build a PARM_DECL for the "this" parameter. TYPE is the
5830 METHOD_TYPE for a non-static member function; QUALS are the
5831 cv-qualifiers that apply to the function. */
5834 build_this_parm (tree type, cp_cv_quals quals)
5839 cp_cv_quals this_quals;
5841 this_type = TREE_VALUE (TYPE_ARG_TYPES (type));
5842 /* The `this' parameter is implicitly `const'; it cannot be
5844 this_quals = (quals & TYPE_QUAL_RESTRICT) | TYPE_QUAL_CONST;
5845 qual_type = cp_build_qualified_type (this_type, this_quals);
5846 parm = build_artificial_parm (this_identifier, qual_type);
5847 cp_apply_type_quals_to_decl (this_quals, parm);
5851 /* CTYPE is class type, or null if non-class.
5852 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
5854 DECLARATOR is the function's name.
5855 PARMS is a chain of PARM_DECLs for the function.
5856 VIRTUALP is truthvalue of whether the function is virtual or not.
5857 FLAGS are to be passed through to `grokclassfn'.
5858 QUALS are qualifiers indicating whether the function is `const'
5860 RAISES is a list of exceptions that this function can raise.
5861 CHECK is 1 if we must find this method in CTYPE, 0 if we should
5862 not look, and -1 if we should not call `grokclassfn' at all.
5864 SFK is the kind of special function (if any) for the new function.
5866 Returns `NULL_TREE' if something goes wrong, after issuing
5867 applicable error messages. */
5870 grokfndecl (tree ctype,
5874 tree orig_declarator,
5876 enum overload_flags flags,
5883 special_function_kind sfk,
5890 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
5894 type = build_exception_variant (type, raises);
5896 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
5897 if (TREE_CODE (type) == METHOD_TYPE)
5900 parm = build_this_parm (type, quals);
5901 TREE_CHAIN (parm) = parms;
5904 DECL_ARGUMENTS (decl) = parms;
5905 /* Propagate volatile out from type to decl. */
5906 if (TYPE_VOLATILE (type))
5907 TREE_THIS_VOLATILE (decl) = 1;
5910 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
5914 ("defining explicit specialization %qD in friend declaration",
5918 tree fns = TREE_OPERAND (orig_declarator, 0);
5919 tree args = TREE_OPERAND (orig_declarator, 1);
5921 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
5923 /* Something like `template <class T> friend void f<T>()'. */
5924 error ("invalid use of template-id %qD in declaration "
5925 "of primary template",
5931 /* A friend declaration of the form friend void f<>(). Record
5932 the information in the TEMPLATE_ID_EXPR. */
5933 SET_DECL_IMPLICIT_INSTANTIATION (decl);
5935 if (TREE_CODE (fns) == COMPONENT_REF)
5937 /* Due to bison parser ickiness, we will have already looked
5938 up an operator_name or PFUNCNAME within the current class
5939 (see template_id in parse.y). If the current class contains
5940 such a name, we'll get a COMPONENT_REF here. Undo that. */
5942 gcc_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
5943 == current_class_type);
5944 fns = TREE_OPERAND (fns, 1);
5946 gcc_assert (TREE_CODE (fns) == IDENTIFIER_NODE
5947 || TREE_CODE (fns) == OVERLOAD);
5948 DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
5950 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
5951 if (TREE_PURPOSE (t)
5952 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
5954 error ("default arguments are not allowed in declaration "
5955 "of friend template specialization %qD",
5962 error ("%<inline%> is not allowed in declaration of friend "
5963 "template specialization %qD",
5970 /* If this decl has namespace scope, set that up. */
5972 set_decl_namespace (decl, in_namespace, friendp);
5974 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
5976 /* `main' and builtins have implicit 'C' linkage. */
5977 if ((MAIN_NAME_P (declarator)
5978 || (IDENTIFIER_LENGTH (declarator) > 10
5979 && IDENTIFIER_POINTER (declarator)[0] == '_'
5980 && IDENTIFIER_POINTER (declarator)[1] == '_'
5981 && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
5982 && current_lang_name == lang_name_cplusplus
5983 && ctype == NULL_TREE
5984 /* NULL_TREE means global namespace. */
5985 && DECL_CONTEXT (decl) == NULL_TREE)
5986 SET_DECL_LANGUAGE (decl, lang_c);
5988 /* Should probably propagate const out from type to decl I bet (mrs). */
5991 DECL_STATIC_FUNCTION_P (decl) = 1;
5992 DECL_CONTEXT (decl) = ctype;
5997 DECL_CONTEXT (decl) = ctype;
5999 check_class_member_definition_namespace (decl);
6002 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
6004 if (processing_template_decl)
6005 error ("cannot declare %<::main%> to be a template");
6007 error ("cannot declare %<::main%> to be inline");
6009 error ("cannot declare %<::main%> to be static");
6010 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
6013 tree oldtypeargs = TYPE_ARG_TYPES (TREE_TYPE (decl));
6015 error ("%<::main%> must return %<int%>");
6016 newtype = build_function_type (integer_type_node,
6018 TREE_TYPE (decl) = newtype;
6024 /* Members of anonymous types and local classes have no linkage; make
6025 them internal. If a typedef is made later, this will be changed. */
6026 if (ctype && (TYPE_ANONYMOUS_P (ctype)
6027 || decl_function_context (TYPE_MAIN_DECL (ctype))))
6032 /* [basic.link]: A name with no linkage (notably, the name of a class
6033 or enumeration declared in a local scope) shall not be used to
6034 declare an entity with linkage.
6036 Only check this for public decls for now. See core 319, 389. */
6037 t = no_linkage_check (TREE_TYPE (decl),
6038 /*relaxed_p=*/false);
6041 if (TYPE_ANONYMOUS_P (t))
6043 if (DECL_EXTERN_C_P (decl))
6044 /* Allow this; it's pretty common in C. */;
6047 pedwarn ("non-local function %q#D uses anonymous type",
6049 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
6050 pedwarn ("%q+#D does not refer to the unqualified "
6051 "type, so it is not used for linkage",
6056 pedwarn ("non-local function %q#D uses local type %qT", decl, t);
6060 TREE_PUBLIC (decl) = publicp;
6063 DECL_INTERFACE_KNOWN (decl) = 1;
6064 DECL_NOT_REALLY_EXTERN (decl) = 1;
6067 /* If the declaration was declared inline, mark it as such. */
6069 DECL_DECLARED_INLINE_P (decl) = 1;
6070 /* We inline functions that are explicitly declared inline, or, when
6071 the user explicitly asks us to, all functions. */
6072 if (DECL_DECLARED_INLINE_P (decl)
6073 || (flag_inline_trees == 2 && !DECL_INLINE (decl) && funcdef_flag))
6074 DECL_INLINE (decl) = 1;
6076 DECL_EXTERNAL (decl) = 1;
6077 if (quals && TREE_CODE (type) == FUNCTION_TYPE)
6079 error ("%smember function %qD cannot have cv-qualifier",
6080 (ctype ? "static " : "non-"), decl);
6081 quals = TYPE_UNQUALIFIED;
6084 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl)))
6085 grok_op_properties (decl, /*complain=*/true);
6087 if (ctype && decl_function_context (decl))
6088 DECL_NO_STATIC_CHAIN (decl) = 1;
6091 /* Make the init_value nonzero so pushdecl knows this is not
6092 tentative. error_mark_node is replaced later with the BLOCK. */
6093 DECL_INITIAL (decl) = error_mark_node;
6095 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
6096 TREE_NOTHROW (decl) = 1;
6098 /* Caller will do the rest of this. */
6102 if (ctype != NULL_TREE)
6104 if (sfk == sfk_constructor)
6105 DECL_CONSTRUCTOR_P (decl) = 1;
6107 grokclassfn (ctype, decl, flags);
6110 decl = check_explicit_specialization (orig_declarator, decl,
6113 4 * (friendp != 0));
6114 if (decl == error_mark_node)
6119 cplus_decl_attributes (&decl, *attrlist, 0);
6120 *attrlist = NULL_TREE;
6123 if (ctype != NULL_TREE
6124 && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
6129 old_decl = check_classfn (ctype, decl,
6130 (processing_template_decl
6131 > template_class_depth (ctype))
6132 ? current_template_parms
6139 if (TREE_CODE (old_decl) == TEMPLATE_DECL)
6140 /* Because grokfndecl is always supposed to return a
6141 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
6142 here. We depend on our callers to figure out that its
6143 really a template that's being returned. */
6144 old_decl = DECL_TEMPLATE_RESULT (old_decl);
6146 if (DECL_STATIC_FUNCTION_P (old_decl)
6147 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
6148 /* Remove the `this' parm added by grokclassfn.
6149 XXX Isn't this done in start_function, too? */
6150 revert_static_member_fn (decl);
6151 if (DECL_ARTIFICIAL (old_decl))
6152 error ("definition of implicitly-declared %qD", old_decl);
6154 /* Since we've smashed OLD_DECL to its
6155 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
6156 if (TREE_CODE (decl) == TEMPLATE_DECL)
6157 decl = DECL_TEMPLATE_RESULT (decl);
6159 /* Attempt to merge the declarations. This can fail, in
6160 the case of some invalid specialization declarations. */
6161 pushed_scope = push_scope (ctype);
6162 ok = duplicate_decls (decl, old_decl, friendp);
6164 pop_scope (pushed_scope);
6167 error ("no %q#D member function declared in class %qT",
6175 if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
6178 if (ctype == NULL_TREE || check)
6182 DECL_VIRTUAL_P (decl) = 1;
6187 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
6188 the linkage that DECL will receive in the object file. */
6191 set_linkage_for_static_data_member (tree decl)
6193 /* A static data member always has static storage duration and
6194 external linkage. Note that static data members are forbidden in
6195 local classes -- the only situation in which a class has
6196 non-external linkage. */
6197 TREE_PUBLIC (decl) = 1;
6198 TREE_STATIC (decl) = 1;
6199 /* For non-template classes, static data members are always put
6200 out in exactly those files where they are defined, just as
6201 with ordinary namespace-scope variables. */
6202 if (!processing_template_decl)
6203 DECL_INTERFACE_KNOWN (decl) = 1;
6206 /* Create a VAR_DECL named NAME with the indicated TYPE.
6208 If SCOPE is non-NULL, it is the class type or namespace containing
6209 the variable. If SCOPE is NULL, the variable should is created in
6210 the innermost enclosings scope. */
6213 grokvardecl (tree type,
6215 const cp_decl_specifier_seq *declspecs,
6221 tree explicit_scope;
6223 gcc_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE);
6225 /* Compute the scope in which to place the variable, but remember
6226 whether or not that scope was explicitly specified by the user. */
6227 explicit_scope = scope;
6230 /* An explicit "extern" specifier indicates a namespace-scope
6232 if (declspecs->storage_class == sc_extern)
6233 scope = current_namespace;
6234 else if (!at_function_scope_p ())
6235 scope = current_scope ();
6239 && (/* If the variable is a namespace-scope variable declared in a
6240 template, we need DECL_LANG_SPECIFIC. */
6241 (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
6242 /* Similarly for namespace-scope variables with language linkage
6244 || (TREE_CODE (scope) == NAMESPACE_DECL
6245 && current_lang_name != lang_name_cplusplus)
6246 /* Similarly for static data members. */
6248 decl = build_lang_decl (VAR_DECL, name, type);
6250 decl = build_decl (VAR_DECL, name, type);
6252 if (explicit_scope && TREE_CODE (explicit_scope) == NAMESPACE_DECL)
6253 set_decl_namespace (decl, explicit_scope, 0);
6255 DECL_CONTEXT (decl) = scope;
6257 if (declspecs->storage_class == sc_extern)
6259 DECL_THIS_EXTERN (decl) = 1;
6260 DECL_EXTERNAL (decl) = !initialized;
6263 if (DECL_CLASS_SCOPE_P (decl))
6265 set_linkage_for_static_data_member (decl);
6266 /* This function is only called with out-of-class definitions. */
6267 DECL_EXTERNAL (decl) = 0;
6268 check_class_member_definition_namespace (decl);
6270 /* At top level, either `static' or no s.c. makes a definition
6271 (perhaps tentative), and absence of `static' makes it public. */
6272 else if (toplevel_bindings_p ())
6274 TREE_PUBLIC (decl) = (declspecs->storage_class != sc_static
6275 && (DECL_THIS_EXTERN (decl) || ! constp));
6276 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
6278 /* Not at top level, only `static' makes a static definition. */
6281 TREE_STATIC (decl) = declspecs->storage_class == sc_static;
6282 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
6285 if (declspecs->specs[(int)ds_thread])
6287 if (targetm.have_tls)
6288 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
6290 /* A mere warning is sure to result in improper semantics
6291 at runtime. Don't bother to allow this to compile. */
6292 error ("thread-local storage not supported for this target");
6295 if (TREE_PUBLIC (decl))
6297 /* [basic.link]: A name with no linkage (notably, the name of a class
6298 or enumeration declared in a local scope) shall not be used to
6299 declare an entity with linkage.
6301 Only check this for public decls for now. */
6302 tree t = no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false);
6305 if (TYPE_ANONYMOUS_P (t))
6307 if (DECL_EXTERN_C_P (decl))
6308 /* Allow this; it's pretty common in C. */
6312 /* DRs 132, 319 and 389 seem to indicate types with
6313 no linkage can only be used to declare extern "C"
6314 entities. Since it's not always an error in the
6315 ISO C++ 90 Standard, we only issue a warning. */
6316 warning (0, "non-local variable %q#D uses anonymous type",
6318 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
6319 warning (0, "%q+#D does not refer to the unqualified "
6320 "type, so it is not used for linkage",
6325 warning (0, "non-local variable %q#D uses local type %qT", decl, t);
6329 DECL_INTERFACE_KNOWN (decl) = 1;
6334 /* Create and return a canonical pointer to member function type, for
6335 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
6338 build_ptrmemfunc_type (tree type)
6342 tree unqualified_variant = NULL_TREE;
6344 if (type == error_mark_node)
6347 /* If a canonical type already exists for this type, use it. We use
6348 this method instead of type_hash_canon, because it only does a
6349 simple equality check on the list of field members. */
6351 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
6354 /* Make sure that we always have the unqualified pointer-to-member
6356 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
6358 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
6360 t = make_aggr_type (RECORD_TYPE);
6361 xref_basetypes (t, NULL_TREE);
6363 /* Let the front-end know this is a pointer to member function... */
6364 TYPE_PTRMEMFUNC_FLAG (t) = 1;
6365 /* ... and not really an aggregate. */
6366 SET_IS_AGGR_TYPE (t, 0);
6368 field = build_decl (FIELD_DECL, pfn_identifier, type);
6371 field = build_decl (FIELD_DECL, delta_identifier, delta_type_node);
6372 TREE_CHAIN (field) = fields;
6375 finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
6377 /* Zap out the name so that the back-end will give us the debugging
6378 information for this anonymous RECORD_TYPE. */
6379 TYPE_NAME (t) = NULL_TREE;
6381 /* If this is not the unqualified form of this pointer-to-member
6382 type, set the TYPE_MAIN_VARIANT for this type to be the
6383 unqualified type. Since they are actually RECORD_TYPEs that are
6384 not variants of each other, we must do this manually. */
6385 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
6387 t = build_qualified_type (t, cp_type_quals (type));
6388 TYPE_MAIN_VARIANT (t) = unqualified_variant;
6389 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
6390 TYPE_NEXT_VARIANT (unqualified_variant) = t;
6393 /* Cache this pointer-to-member type so that we can find it again
6395 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
6400 /* Create and return a pointer to data member type. */
6403 build_ptrmem_type (tree class_type, tree member_type)
6405 if (TREE_CODE (member_type) == METHOD_TYPE)
6409 arg_types = TYPE_ARG_TYPES (member_type);
6410 class_type = (cp_build_qualified_type
6412 cp_type_quals (TREE_TYPE (TREE_VALUE (arg_types)))));
6414 = build_method_type_directly (class_type,
6415 TREE_TYPE (member_type),
6416 TREE_CHAIN (arg_types));
6417 return build_ptrmemfunc_type (build_pointer_type (member_type));
6421 gcc_assert (TREE_CODE (member_type) != FUNCTION_TYPE);
6422 return build_offset_type (class_type, member_type);
6426 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
6427 Check to see that the definition is valid. Issue appropriate error
6428 messages. Return 1 if the definition is particularly bad, or 0
6432 check_static_variable_definition (tree decl, tree type)
6434 /* Motion 10 at San Diego: If a static const integral data member is
6435 initialized with an integral constant expression, the initializer
6436 may appear either in the declaration (within the class), or in
6437 the definition, but not both. If it appears in the class, the
6438 member is a member constant. The file-scope definition is always
6440 if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
6442 error ("invalid in-class initialization of static data member "
6443 "of non-integral type %qT",
6445 /* If we just return the declaration, crashes will sometimes
6446 occur. We therefore return void_type_node, as if this were a
6447 friend declaration, to cause callers to completely ignore
6448 this declaration. */
6451 else if (!CP_TYPE_CONST_P (type))
6452 error ("ISO C++ forbids in-class initialization of non-const "
6453 "static member %qD",
6455 else if (pedantic && !INTEGRAL_TYPE_P (type))
6456 pedwarn ("ISO C++ forbids initialization of member constant "
6457 "%qD of non-integral type %qT", decl, type);
6462 /* Given the SIZE (i.e., number of elements) in an array, compute an
6463 appropriate index type for the array. If non-NULL, NAME is the
6464 name of the thing being declared. */
6467 compute_array_index_type (tree name, tree size)
6472 if (error_operand_p (size))
6473 return error_mark_node;
6475 type = TREE_TYPE (size);
6476 /* The array bound must be an integer type. */
6477 if (!dependent_type_p (type) && !INTEGRAL_TYPE_P (type))
6480 error ("size of array %qD has non-integral type %qT", name, type);
6482 error ("size of array has non-integral type %qT", type);
6483 size = integer_one_node;
6484 type = TREE_TYPE (size);
6487 if (abi_version_at_least (2)
6488 /* We should only handle value dependent expressions specially. */
6489 ? value_dependent_expression_p (size)
6490 /* But for abi-1, we handled all instances in templates. This
6491 effects the manglings produced. */
6492 : processing_template_decl)
6493 return build_index_type (build_min (MINUS_EXPR, sizetype,
6494 size, integer_one_node));
6496 /* The size might be the result of a cast. */
6497 STRIP_TYPE_NOPS (size);
6499 /* It might be a const variable or enumeration constant. */
6500 size = integral_constant_value (size);
6502 /* Normally, the array-bound will be a constant. */
6503 if (TREE_CODE (size) == INTEGER_CST)
6505 /* Check to see if the array bound overflowed. Make that an
6506 error, no matter how generous we're being. */
6507 int old_flag_pedantic_errors = flag_pedantic_errors;
6508 int old_pedantic = pedantic;
6509 pedantic = flag_pedantic_errors = 1;
6510 constant_expression_warning (size);
6511 pedantic = old_pedantic;
6512 flag_pedantic_errors = old_flag_pedantic_errors;
6514 /* An array must have a positive number of elements. */
6515 if (INT_CST_LT (size, integer_zero_node))
6518 error ("size of array %qD is negative", name);
6520 error ("size of array is negative");
6521 size = integer_one_node;
6523 /* As an extension we allow zero-sized arrays. We always allow
6524 them in system headers because glibc uses them. */
6525 else if (integer_zerop (size) && pedantic && !in_system_header)
6528 pedwarn ("ISO C++ forbids zero-size array %qD", name);
6530 pedwarn ("ISO C++ forbids zero-size array");
6533 else if (TREE_CONSTANT (size))
6535 /* `(int) &fn' is not a valid array bound. */
6537 error ("size of array %qD is not an integral constant-expression",
6540 error ("size of array is not an integral constant-expression");
6541 size = integer_one_node;
6546 pedwarn ("ISO C++ forbids variable-size array %qD", name);
6548 pedwarn ("ISO C++ forbids variable-size array");
6551 if (processing_template_decl && !TREE_CONSTANT (size))
6552 /* A variable sized array. */
6553 itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node);
6556 HOST_WIDE_INT saved_processing_template_decl;
6558 /* Compute the index of the largest element in the array. It is
6559 one less than the number of elements in the array. We save
6560 and restore PROCESSING_TEMPLATE_DECL so that computations in
6561 cp_build_binary_op will be appropriately folded. */
6562 saved_processing_template_decl = processing_template_decl;
6563 processing_template_decl = 0;
6564 itype = cp_build_binary_op (MINUS_EXPR,
6565 cp_convert (ssizetype, size),
6566 cp_convert (ssizetype, integer_one_node));
6567 itype = fold (itype);
6568 processing_template_decl = saved_processing_template_decl;
6570 if (!TREE_CONSTANT (itype))
6571 /* A variable sized array. */
6572 itype = variable_size (itype);
6573 /* Make sure that there was no overflow when creating to a signed
6574 index type. (For example, on a 32-bit machine, an array with
6575 size 2^32 - 1 is too big.) */
6576 else if (TREE_CODE (itype) == INTEGER_CST
6577 && TREE_OVERFLOW (itype))
6579 error ("overflow in array dimension");
6580 TREE_OVERFLOW (itype) = 0;
6584 /* Create and return the appropriate index type. */
6585 return build_index_type (itype);
6588 /* Returns the scope (if any) in which the entity declared by
6589 DECLARATOR will be located. If the entity was declared with an
6590 unqualified name, NULL_TREE is returned. */
6593 get_scope_of_declarator (const cp_declarator *declarator)
6595 while (declarator && declarator->kind != cdk_id)
6596 declarator = declarator->declarator;
6598 /* If the declarator-id is a SCOPE_REF, the scope in which the
6599 declaration occurs is the first operand. */
6601 && declarator->u.id.qualifying_scope)
6602 return declarator->u.id.qualifying_scope;
6604 /* Otherwise, the declarator is not a qualified name; the entity will
6605 be declared in the current scope. */
6609 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
6610 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
6614 create_array_type_for_decl (tree name, tree type, tree size)
6616 tree itype = NULL_TREE;
6617 const char* error_msg;
6619 /* If things have already gone awry, bail now. */
6620 if (type == error_mark_node || size == error_mark_node)
6621 return error_mark_node;
6623 /* Assume that everything will go OK. */
6626 /* There are some types which cannot be array elements. */
6627 switch (TREE_CODE (type))
6630 error_msg = "array of void";
6634 error_msg = "array of functions";
6637 case REFERENCE_TYPE:
6638 error_msg = "array of references";
6642 error_msg = "array of function members";
6649 /* If something went wrong, issue an error-message and return. */
6653 error ("declaration of %qD as %s", name, error_msg);
6655 error ("creating %s", error_msg);
6657 return error_mark_node;
6662 The constant expressions that specify the bounds of the arrays
6663 can be omitted only for the first member of the sequence. */
6664 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
6667 error ("declaration of %qD as multidimensional array must "
6668 "have bounds for all dimensions except the first",
6671 error ("multidimensional array must have bounds for all "
6672 "dimensions except the first");
6674 return error_mark_node;
6677 /* Figure out the index type for the array. */
6679 itype = compute_array_index_type (name, size);
6682 T is called the array element type; this type shall not be [...] an
6683 abstract class type. */
6684 abstract_virtuals_error (name, type);
6686 return build_cplus_array_type (type, itype);
6689 /* Check that it's OK to declare a function with the indicated TYPE.
6690 SFK indicates the kind of special function (if any) that this
6691 function is. OPTYPE is the type given in a conversion operator
6692 declaration, or the class type for a constructor/destructor.
6693 Returns the actual return type of the function; that
6694 may be different than TYPE if an error occurs, or for certain
6695 special functions. */
6698 check_special_function_return_type (special_function_kind sfk,
6704 case sfk_constructor:
6706 error ("return type specification for constructor invalid");
6708 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
6709 type = build_pointer_type (optype);
6711 type = void_type_node;
6714 case sfk_destructor:
6716 error ("return type specification for destructor invalid");
6717 /* We can't use the proper return type here because we run into
6718 problems with ambiguous bases and covariant returns.
6719 Java classes are left unchanged because (void *) isn't a valid
6720 Java type, and we don't want to change the Java ABI. */
6721 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
6722 type = build_pointer_type (void_type_node);
6724 type = void_type_node;
6727 case sfk_conversion:
6728 if (type && !same_type_p (type, optype))
6729 error ("operator %qT declared to return %qT", optype, type);
6731 pedwarn ("return type specified for %<operator %T%>", optype);
6742 /* A variable or data member (whose unqualified name is IDENTIFIER)
6743 has been declared with the indicated TYPE. If the TYPE is not
6744 acceptable, issue an error message and return a type to use for
6745 error-recovery purposes. */
6748 check_var_type (tree identifier, tree type)
6750 if (VOID_TYPE_P (type))
6753 error ("unnamed variable or field declared void");
6754 else if (TREE_CODE (identifier) == IDENTIFIER_NODE)
6756 gcc_assert (!IDENTIFIER_OPNAME_P (identifier));
6757 error ("variable or field %qE declared void", identifier);
6760 error ("variable or field declared void");
6761 type = integer_type_node;
6767 /* Given declspecs and a declarator (abstract or otherwise), determine
6768 the name and type of the object declared and construct a DECL node
6771 DECLSPECS is a chain of tree_list nodes whose value fields
6772 are the storage classes and type specifiers.
6774 DECL_CONTEXT says which syntactic context this declaration is in:
6775 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
6776 FUNCDEF for a function definition. Like NORMAL but a few different
6777 error messages in each case. Return value may be zero meaning
6778 this definition is too screwy to try to parse.
6779 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
6780 handle member functions (which have FIELD context).
6781 Return value may be zero meaning this definition is too screwy to
6783 PARM for a parameter declaration (either within a function prototype
6784 or before a function body). Make a PARM_DECL, or return void_type_node.
6785 CATCHPARM for a parameter declaration before a catch clause.
6786 TYPENAME if for a typename (in a cast or sizeof).
6787 Don't make a DECL node; just return the ..._TYPE node.
6788 FIELD for a struct or union field; make a FIELD_DECL.
6789 BITFIELD for a field with specified width.
6790 INITIALIZED is 1 if the decl has an initializer.
6792 ATTRLIST is a pointer to the list of attributes, which may be NULL
6793 if there are none; *ATTRLIST may be modified if attributes from inside
6794 the declarator should be applied to the declaration.
6796 When this function is called, scoping variables (such as
6797 CURRENT_CLASS_TYPE) should reflect the scope in which the
6798 declaration occurs, not the scope in which the new declaration will
6799 be placed. For example, on:
6803 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
6804 should not be `S'. */
6807 grokdeclarator (const cp_declarator *declarator,
6808 const cp_decl_specifier_seq *declspecs,
6809 enum decl_context decl_context,
6813 tree type = NULL_TREE;
6815 int virtualp, explicitp, friendp, inlinep, staticp;
6816 int explicit_int = 0;
6817 int explicit_char = 0;
6818 int defaulted_int = 0;
6819 tree dependent_name = NULL_TREE;
6821 tree typedef_decl = NULL_TREE;
6822 const char *name = NULL;
6823 tree typedef_type = NULL_TREE;
6824 /* True if this declarator is a function definition. */
6825 bool funcdef_flag = false;
6826 cp_declarator_kind innermost_code = cdk_error;
6829 /* See the code below that used this. */
6830 tree decl_attr = NULL_TREE;
6833 /* Keep track of what sort of function is being processed
6834 so that we can warn about default return values, or explicit
6835 return values which do not match prescribed defaults. */
6836 special_function_kind sfk = sfk_none;
6838 tree dname = NULL_TREE;
6839 tree ctor_return_type = NULL_TREE;
6840 enum overload_flags flags = NO_SPECIAL;
6841 /* cv-qualifiers that apply to the declarator, for a declaration of
6842 a member function. */
6843 cp_cv_quals memfn_quals = TYPE_UNQUALIFIED;
6844 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
6846 tree raises = NULL_TREE;
6847 int template_count = 0;
6848 tree returned_attrs = NULL_TREE;
6849 tree parms = NULL_TREE;
6850 const cp_declarator *id_declarator;
6851 /* The unqualified name of the declarator; either an
6852 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
6853 tree unqualified_id;
6854 /* The class type, if any, in which this entity is located,
6855 or NULL_TREE if none. Note that this value may be different from
6856 the current class type; for example if an attempt is made to declare
6857 "A::f" inside "B", this value will be "A". */
6858 tree ctype = current_class_type;
6859 /* The NAMESPACE_DECL for the namespace in which this entity is
6860 located. If an unqualified name is used to declare the entity,
6861 this value will be NULL_TREE, even if the entity is located at
6863 tree in_namespace = NULL_TREE;
6864 cp_storage_class storage_class;
6865 bool unsigned_p, signed_p, short_p, long_p, thread_p;
6866 bool type_was_error_mark_node = false;
6868 signed_p = declspecs->specs[(int)ds_signed];
6869 unsigned_p = declspecs->specs[(int)ds_unsigned];
6870 short_p = declspecs->specs[(int)ds_short];
6871 long_p = declspecs->specs[(int)ds_long];
6872 longlong = declspecs->specs[(int)ds_long] >= 2;
6873 thread_p = declspecs->specs[(int)ds_thread];
6875 if (decl_context == FUNCDEF)
6876 funcdef_flag = true, decl_context = NORMAL;
6877 else if (decl_context == MEMFUNCDEF)
6878 funcdef_flag = true, decl_context = FIELD;
6879 else if (decl_context == BITFIELD)
6880 bitfield = 1, decl_context = FIELD;
6882 /* Look inside a declarator for the name being declared
6883 and get it as a string, for an error message. */
6884 for (id_declarator = declarator;
6886 id_declarator = id_declarator->declarator)
6888 if (id_declarator->kind != cdk_id)
6889 innermost_code = id_declarator->kind;
6891 switch (id_declarator->kind)
6894 if (id_declarator->declarator
6895 && id_declarator->declarator->kind == cdk_id)
6897 sfk = id_declarator->declarator->u.id.sfk;
6898 if (sfk == sfk_destructor)
6905 tree qualifying_scope = id_declarator->u.id.qualifying_scope;
6906 tree decl = id_declarator->u.id.unqualified_name;
6909 if (qualifying_scope)
6911 if (TYPE_P (qualifying_scope))
6913 ctype = qualifying_scope;
6914 if (innermost_code != cdk_function
6915 && current_class_type
6916 && !UNIQUELY_DERIVED_FROM_P (ctype,
6917 current_class_type))
6919 error ("type %qT is not derived from type %qT",
6920 ctype, current_class_type);
6921 return error_mark_node;
6924 else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL)
6925 in_namespace = qualifying_scope;
6927 switch (TREE_CODE (decl))
6933 if (innermost_code != cdk_function)
6935 error ("declaration of %qD as non-function", decl);
6936 return error_mark_node;
6938 else if (!qualifying_scope
6939 && !(current_class_type && at_class_scope_p ()))
6941 error ("declaration of %qD as non-member", decl);
6942 return error_mark_node;
6945 type = TREE_OPERAND (decl, 0);
6946 name = IDENTIFIER_POINTER (constructor_name (type));
6951 case TEMPLATE_ID_EXPR:
6953 tree fns = TREE_OPERAND (decl, 0);
6956 if (TREE_CODE (dname) == COMPONENT_REF)
6957 dname = TREE_OPERAND (dname, 1);
6958 if (TREE_CODE (dname) != IDENTIFIER_NODE)
6960 gcc_assert (is_overloaded_fn (dname));
6961 dname = DECL_NAME (get_first_fn (dname));
6966 case IDENTIFIER_NODE:
6967 if (TREE_CODE (decl) == IDENTIFIER_NODE)
6970 if (C_IS_RESERVED_WORD (dname))
6972 error ("declarator-id missing; using reserved word %qD",
6974 name = IDENTIFIER_POINTER (dname);
6976 else if (!IDENTIFIER_TYPENAME_P (dname))
6977 name = IDENTIFIER_POINTER (dname);
6980 gcc_assert (flags == NO_SPECIAL);
6981 flags = TYPENAME_FLAG;
6982 ctor_return_type = TREE_TYPE (dname);
6983 sfk = sfk_conversion;
6984 if (is_typename_at_global_scope (dname))
6985 name = IDENTIFIER_POINTER (dname);
6987 name = "<invalid operator>";
7003 return error_mark_node;
7009 if (id_declarator->kind == cdk_id)
7015 The declarator in a function-definition shall have the form
7016 D1 ( parameter-declaration-clause) ... */
7017 if (funcdef_flag && innermost_code != cdk_function)
7019 error ("function definition does not declare parameters");
7020 return error_mark_node;
7023 if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
7024 && innermost_code != cdk_function
7025 && ! (ctype && !declspecs->any_specifiers_p))
7027 error ("declaration of %qD as non-function", dname);
7028 return error_mark_node;
7031 /* Anything declared one level down from the top level
7032 must be one of the parameters of a function
7033 (because the body is at least two levels down). */
7035 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
7036 by not allowing C++ class definitions to specify their parameters
7037 with xdecls (must be spec.d in the parmlist).
7039 Since we now wait to push a class scope until we are sure that
7040 we are in a legitimate method context, we must set oldcname
7041 explicitly (since current_class_name is not yet alive).
7043 We also want to avoid calling this a PARM if it is in a namespace. */
7045 if (decl_context == NORMAL && !toplevel_bindings_p ())
7047 struct cp_binding_level *b = current_binding_level;
7048 current_binding_level = b->level_chain;
7049 if (current_binding_level != 0 && toplevel_bindings_p ())
7050 decl_context = PARM;
7051 current_binding_level = b;
7055 name = decl_context == PARM ? "parameter" : "type name";
7057 /* If there were multiple types specified in the decl-specifier-seq,
7058 issue an error message. */
7059 if (declspecs->multiple_types_p)
7060 error ("two or more data types in declaration of %qs", name);
7061 /* Extract the basic type from the decl-specifier-seq. */
7062 type = declspecs->type;
7063 if (type == error_mark_node)
7066 type_was_error_mark_node = true;
7068 /* If the entire declaration is itself tagged as deprecated then
7069 suppress reports of deprecated items. */
7070 if (type && TREE_DEPRECATED (type)
7071 && deprecated_state != DEPRECATED_SUPPRESS)
7072 warn_deprecated_use (type);
7073 if (type && TREE_CODE (type) == TYPE_DECL)
7075 typedef_decl = type;
7076 type = TREE_TYPE (typedef_decl);
7078 /* No type at all: default to `int', and set DEFAULTED_INT
7079 because it was not a user-defined typedef. */
7080 if (type == NULL_TREE && (signed_p || unsigned_p || long_p || short_p))
7082 /* These imply 'int'. */
7083 type = integer_type_node;
7087 explicit_int = declspecs->explicit_int_p;
7088 explicit_char = declspecs->explicit_char_p;
7091 /* See the code below that used this. */
7093 decl_attr = DECL_ATTRIBUTES (typedef_decl);
7095 typedef_type = type;
7098 if (sfk != sfk_conversion)
7099 ctor_return_type = ctype;
7101 if (sfk != sfk_none)
7102 type = check_special_function_return_type (sfk, type,
7104 else if (type == NULL_TREE)
7110 /* We handle `main' specially here, because 'main () { }' is so
7111 common. With no options, it is allowed. With -Wreturn-type,
7112 it is a warning. It is only an error with -pedantic-errors. */
7113 is_main = (funcdef_flag
7114 && dname && MAIN_NAME_P (dname)
7115 && ctype == NULL_TREE
7116 && in_namespace == NULL_TREE
7117 && current_namespace == global_namespace);
7119 if (type_was_error_mark_node)
7120 /* We've already issued an error, don't complain more. */;
7121 else if (in_system_header || flag_ms_extensions)
7122 /* Allow it, sigh. */;
7123 else if (pedantic || ! is_main)
7124 pedwarn ("ISO C++ forbids declaration of %qs with no type", name);
7125 else if (warn_return_type)
7126 warning (0, "ISO C++ forbids declaration of %qs with no type", name);
7128 type = integer_type_node;
7133 /* Now process the modifiers that were specified
7134 and check for invalid combinations. */
7136 /* Long double is a special combination. */
7137 if (long_p && !longlong && TYPE_MAIN_VARIANT (type) == double_type_node)
7140 type = build_qualified_type (long_double_type_node,
7141 cp_type_quals (type));
7144 /* Check all other uses of type modifiers. */
7146 if (unsigned_p || signed_p || long_p || short_p)
7150 if ((signed_p || unsigned_p) && TREE_CODE (type) != INTEGER_TYPE)
7151 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
7152 else if (signed_p && unsigned_p)
7153 error ("%<signed%> and %<unsigned%> specified together for %qs", name);
7154 else if (longlong && TREE_CODE (type) != INTEGER_TYPE)
7155 error ("%<long long%> invalid for %qs", name);
7156 else if (long_p && TREE_CODE (type) == REAL_TYPE)
7157 error ("%<long%> invalid for %qs", name);
7158 else if (short_p && TREE_CODE (type) == REAL_TYPE)
7159 error ("%<short%> invalid for %qs", name);
7160 else if ((long_p || short_p) && explicit_char)
7161 error ("%<long%> or %<short%> specified with char for %qs", name);
7162 else if (long_p && short_p)
7163 error ("%<long%> and %<short%> specified together for %qs", name);
7167 if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
7169 pedwarn ("long, short, signed or unsigned used invalidly for %qs",
7171 if (flag_pedantic_errors)
7176 /* Discard the type modifiers if they are invalid. */
7187 /* Decide whether an integer type is signed or not.
7188 Optionally treat bitfields as signed by default. */
7192 It is implementation-defined whether a plain (neither
7193 explicitly signed or unsigned) char, short, int, or long
7194 bit-field is signed or unsigned.
7196 Naturally, we extend this to long long as well. Note that
7197 this does not include wchar_t. */
7198 || (bitfield && !flag_signed_bitfields
7200 /* A typedef for plain `int' without `signed' can be
7201 controlled just like plain `int', but a typedef for
7202 `signed int' cannot be so controlled. */
7204 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
7205 && TREE_CODE (type) == INTEGER_TYPE
7206 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
7209 type = long_long_unsigned_type_node;
7211 type = long_unsigned_type_node;
7213 type = short_unsigned_type_node;
7214 else if (type == char_type_node)
7215 type = unsigned_char_type_node;
7216 else if (typedef_decl)
7217 type = c_common_unsigned_type (type);
7219 type = unsigned_type_node;
7221 else if (signed_p && type == char_type_node)
7222 type = signed_char_type_node;
7224 type = long_long_integer_type_node;
7226 type = long_integer_type_node;
7228 type = short_integer_type_node;
7230 if (declspecs->specs[(int)ds_complex])
7232 if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
7233 error ("complex invalid for %qs", name);
7234 /* If we just have "complex", it is equivalent to
7235 "complex double", but if any modifiers at all are specified it is
7236 the complex form of TYPE. E.g, "complex short" is
7237 "complex short int". */
7239 else if (defaulted_int && ! longlong
7240 && ! (long_p || short_p || signed_p || unsigned_p))
7241 type = complex_double_type_node;
7242 else if (type == integer_type_node)
7243 type = complex_integer_type_node;
7244 else if (type == float_type_node)
7245 type = complex_float_type_node;
7246 else if (type == double_type_node)
7247 type = complex_double_type_node;
7248 else if (type == long_double_type_node)
7249 type = complex_long_double_type_node;
7251 type = build_complex_type (type);
7254 type_quals = TYPE_UNQUALIFIED;
7255 if (declspecs->specs[(int)ds_const])
7256 type_quals |= TYPE_QUAL_CONST;
7257 if (declspecs->specs[(int)ds_volatile])
7258 type_quals |= TYPE_QUAL_VOLATILE;
7259 if (declspecs->specs[(int)ds_restrict])
7260 type_quals |= TYPE_QUAL_RESTRICT;
7261 if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
7262 error ("qualifiers are not allowed on declaration of %<operator %T%>",
7265 if (TREE_CODE (type) == FUNCTION_TYPE
7266 && type_quals != TYPE_UNQUALIFIED)
7268 /* This was an error in C++98 (cv-qualifiers cannot be added to
7269 a function type), but DR 295 makes the code well-formed by
7270 dropping the extra qualifiers. */
7273 tree bad_type = build_qualified_type (type, type_quals);
7274 pedwarn ("ignoring %qV qualifiers added to function type %qT",
7277 type_quals = TYPE_UNQUALIFIED;
7279 type_quals |= cp_type_quals (type);
7280 type = cp_build_qualified_type_real
7281 (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
7282 ? tf_ignore_bad_quals : 0) | tf_warning_or_error));
7283 /* We might have ignored or rejected some of the qualifiers. */
7284 type_quals = cp_type_quals (type);
7287 inlinep = !! declspecs->specs[(int)ds_inline];
7288 virtualp = !! declspecs->specs[(int)ds_virtual];
7289 explicitp = !! declspecs->specs[(int)ds_explicit];
7291 storage_class = declspecs->storage_class;
7292 if (storage_class == sc_static)
7293 staticp = 1 + (decl_context == FIELD);
7295 if (virtualp && staticp == 2)
7297 error ("member %qD cannot be declared both virtual and static", dname);
7298 storage_class = sc_none;
7301 friendp = !! declspecs->specs[(int)ds_friend];
7303 if (dependent_name && !friendp)
7305 error ("%<%T::%D%> is not a valid declarator", ctype, dependent_name);
7306 return error_mark_node;
7309 /* Issue errors about use of storage classes for parameters. */
7310 if (decl_context == PARM)
7312 if (declspecs->specs[(int)ds_typedef])
7313 error ("typedef declaration invalid in parameter declaration");
7314 else if (storage_class == sc_static
7315 || storage_class == sc_extern
7317 error ("storage class specifiers invalid in parameter declarations");
7320 /* Give error if `virtual' is used outside of class declaration. */
7322 && (current_class_name == NULL_TREE || decl_context != FIELD))
7324 error ("virtual outside class declaration");
7328 /* Static anonymous unions are dealt with here. */
7329 if (staticp && decl_context == TYPENAME
7331 && ANON_AGGR_TYPE_P (declspecs->type))
7332 decl_context = FIELD;
7334 /* Warn about storage classes that are invalid for certain
7335 kinds of declarations (parameters, typenames, etc.). */
7336 if (declspecs->multiple_storage_classes_p)
7338 error ("multiple storage classes in declaration of %qs", name);
7339 storage_class = sc_none;
7343 && storage_class != sc_extern
7344 && storage_class != sc_static)
7345 || declspecs->specs[(int)ds_typedef]))
7347 error ("multiple storage classes in declaration of %qs", name);
7350 else if (decl_context != NORMAL
7351 && ((storage_class != sc_none
7352 && storage_class != sc_mutable)
7355 if ((decl_context == PARM || decl_context == CATCHPARM)
7356 && (storage_class == sc_register
7357 || storage_class == sc_auto))
7359 else if (declspecs->specs[(int)ds_typedef])
7361 else if (decl_context == FIELD
7362 /* C++ allows static class elements. */
7363 && storage_class == sc_static)
7364 /* C++ also allows inlines and signed and unsigned elements,
7365 but in those cases we don't come in here. */
7369 if (decl_context == FIELD)
7370 error ("storage class specified for %qs", name);
7373 if (decl_context == PARM || decl_context == CATCHPARM)
7374 error ("storage class specified for parameter %qs", name);
7376 error ("storage class specified for typename");
7378 if (storage_class == sc_register
7379 || storage_class == sc_auto
7380 || storage_class == sc_extern
7382 storage_class = sc_none;
7385 else if (storage_class == sc_extern && initialized
7388 if (toplevel_bindings_p ())
7390 /* It's common practice (and completely valid) to have a const
7391 be initialized and declared extern. */
7392 if (!(type_quals & TYPE_QUAL_CONST))
7393 warning (0, "%qs initialized and declared %<extern%>", name);
7396 error ("%qs has both %<extern%> and initializer", name);
7398 else if (storage_class == sc_extern && funcdef_flag
7399 && ! toplevel_bindings_p ())
7400 error ("nested function %qs declared %<extern%>", name);
7401 else if (toplevel_bindings_p ())
7403 if (storage_class == sc_auto)
7404 error ("top-level declaration of %qs specifies %<auto%>", name);
7407 && storage_class != sc_extern
7408 && storage_class != sc_static)
7410 error ("function-scope %qs implicitly auto and declared %<__thread%>",
7415 if (storage_class && friendp)
7416 error ("storage class specifiers invalid in friend function declarations");
7419 unqualified_id = NULL_TREE;
7422 unqualified_id = id_declarator->u.id.unqualified_name;
7423 switch (TREE_CODE (unqualified_id))
7427 = constructor_name (TREE_OPERAND (unqualified_id, 0));
7430 case IDENTIFIER_NODE:
7431 case TEMPLATE_ID_EXPR:
7439 /* Determine the type of the entity declared by recurring on the
7441 for (; declarator; declarator = declarator->declarator)
7443 const cp_declarator *inner_declarator;
7446 if (type == error_mark_node)
7447 return error_mark_node;
7449 attrs = declarator->attributes;
7455 if (declarator == NULL || declarator->kind == cdk_id)
7456 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
7457 if (declarator->kind == cdk_function)
7458 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
7459 if (declarator->kind == cdk_array)
7460 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
7461 returned_attrs = decl_attributes (&type,
7462 chainon (returned_attrs, attrs),
7466 if (declarator->kind == cdk_id)
7469 inner_declarator = declarator->declarator;
7471 switch (declarator->kind)
7474 type = create_array_type_for_decl (dname, type,
7475 declarator->u.array.bounds);
7483 /* Declaring a function type.
7484 Make sure we have a valid type for the function to return. */
7486 /* We now know that the TYPE_QUALS don't apply to the
7487 decl, but to its return type. */
7488 type_quals = TYPE_UNQUALIFIED;
7490 /* Warn about some types functions can't return. */
7492 if (TREE_CODE (type) == FUNCTION_TYPE)
7494 error ("%qs declared as function returning a function", name);
7495 type = integer_type_node;
7497 if (TREE_CODE (type) == ARRAY_TYPE)
7499 error ("%qs declared as function returning an array", name);
7500 type = integer_type_node;
7503 /* Pick up type qualifiers which should be applied to `this'. */
7504 memfn_quals = declarator->u.function.qualifiers;
7506 /* Pick up the exception specifications. */
7507 raises = declarator->u.function.exception_specification;
7509 /* Say it's a definition only for the CALL_EXPR
7510 closest to the identifier. */
7511 funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id;
7513 if (ctype == NULL_TREE
7514 && decl_context == FIELD
7516 && (friendp == 0 || dname == current_class_name))
7517 ctype = current_class_type;
7519 if (ctype && (sfk == sfk_constructor
7520 || sfk == sfk_destructor))
7522 /* We are within a class's scope. If our declarator name
7523 is the same as the class name, and we are defining
7524 a function, then it is a constructor/destructor, and
7525 therefore returns a void type. */
7527 /* ISO C++ 12.4/2. A destructor may not be declared
7528 const or volatile. A destructor may not be
7531 ISO C++ 12.1. A constructor may not be declared
7532 const or volatile. A constructor may not be
7533 virtual. A constructor may not be static. */
7535 error ((flags == DTOR_FLAG)
7536 ? "destructor cannot be static member function"
7537 : "constructor cannot be static member function");
7540 error ((flags == DTOR_FLAG)
7541 ? "destructors may not be cv-qualified"
7542 : "constructors may not be cv-qualified");
7543 memfn_quals = TYPE_UNQUALIFIED;
7546 if (decl_context == FIELD
7547 && !member_function_or_else (ctype,
7550 return error_mark_node;
7552 if (flags != DTOR_FLAG)
7554 /* It's a constructor. */
7559 pedwarn ("constructors cannot be declared virtual");
7562 if (decl_context == FIELD
7563 && sfk != sfk_constructor)
7564 return error_mark_node;
7566 if (decl_context == FIELD)
7572 error ("can't initialize friend function %qs", name);
7575 /* Cannot be both friend and virtual. */
7576 error ("virtual functions cannot be friends");
7579 if (decl_context == NORMAL)
7580 error ("friend declaration not in class definition");
7581 if (current_function_decl && funcdef_flag)
7582 error ("can't define friend function %qs in a local "
7587 arg_types = grokparms (declarator->u.function.parameters,
7590 if (inner_declarator
7591 && inner_declarator->kind == cdk_id
7592 && inner_declarator->u.id.sfk == sfk_destructor
7593 && arg_types != void_list_node)
7595 error ("destructors may not have parameters");
7596 arg_types = void_list_node;
7600 type = build_function_type (type, arg_types);
7607 /* Filter out pointers-to-references and references-to-references.
7608 We can get these if a TYPE_DECL is used. */
7610 if (TREE_CODE (type) == REFERENCE_TYPE)
7612 error (declarator->kind == cdk_reference
7613 ? "cannot declare reference to %q#T"
7614 : "cannot declare pointer to %q#T", type);
7615 type = TREE_TYPE (type);
7617 else if (VOID_TYPE_P (type))
7619 if (declarator->kind == cdk_reference)
7620 error ("cannot declare reference to %q#T", type);
7621 else if (declarator->kind == cdk_ptrmem)
7622 error ("cannot declare pointer to %q#T member", type);
7625 /* We now know that the TYPE_QUALS don't apply to the decl,
7626 but to the target of the pointer. */
7627 type_quals = TYPE_UNQUALIFIED;
7629 if (declarator->kind == cdk_ptrmem
7630 && (TREE_CODE (type) == FUNCTION_TYPE || memfn_quals))
7632 memfn_quals |= cp_type_quals (type);
7633 type = build_memfn_type (type,
7634 declarator->u.pointer.class_type,
7636 memfn_quals = TYPE_UNQUALIFIED;
7639 if (declarator->kind == cdk_reference)
7641 if (!VOID_TYPE_P (type))
7642 type = build_reference_type (type);
7644 else if (TREE_CODE (type) == METHOD_TYPE)
7645 type = build_ptrmemfunc_type (build_pointer_type (type));
7646 else if (declarator->kind == cdk_ptrmem)
7648 gcc_assert (TREE_CODE (declarator->u.pointer.class_type)
7650 if (declarator->u.pointer.class_type == error_mark_node)
7651 /* We will already have complained. */
7652 type = error_mark_node;
7654 type = build_ptrmem_type (declarator->u.pointer.class_type,
7658 type = build_pointer_type (type);
7660 /* Process a list of type modifier keywords (such as
7661 const or volatile) that were given inside the `*' or `&'. */
7663 if (declarator->u.pointer.qualifiers)
7666 = cp_build_qualified_type (type,
7667 declarator->u.pointer.qualifiers);
7668 type_quals = cp_type_quals (type);
7681 if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR
7682 && TREE_CODE (type) != FUNCTION_TYPE
7683 && TREE_CODE (type) != METHOD_TYPE)
7685 error ("template-id %qD used as a declarator",
7687 unqualified_id = dname;
7690 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
7691 qualified with a class-name, turn it into a METHOD_TYPE, unless
7692 we know that the function is static. We take advantage of this
7693 opportunity to do other processing that pertains to entities
7694 explicitly declared to be class members. Note that if DECLARATOR
7695 is non-NULL, we know it is a cdk_id declarator; otherwise, we
7696 would not have exited the loop above. */
7698 && declarator->u.id.qualifying_scope
7699 && TYPE_P (declarator->u.id.qualifying_scope))
7703 ctype = declarator->u.id.qualifying_scope;
7704 ctype = TYPE_MAIN_VARIANT (ctype);
7706 while (t != NULL_TREE && CLASS_TYPE_P (t))
7708 /* You're supposed to have one `template <...>' for every
7709 template class, but you don't need one for a full
7710 specialization. For example:
7712 template <class T> struct S{};
7713 template <> struct S<int> { void f(); };
7714 void S<int>::f () {}
7716 is correct; there shouldn't be a `template <>' for the
7717 definition of `S<int>::f'. */
7718 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t)
7719 && !any_dependent_template_arguments_p (CLASSTYPE_TI_ARGS (t)))
7720 /* T is an explicit (not partial) specialization. All
7721 containing classes must therefore also be explicitly
7724 if ((CLASSTYPE_USE_TEMPLATE (t) || CLASSTYPE_IS_TEMPLATE (t))
7725 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
7726 template_count += 1;
7728 t = TYPE_MAIN_DECL (t);
7729 t = DECL_CONTEXT (t);
7732 if (ctype == current_class_type)
7735 pedwarn ("member functions are implicitly friends of their class");
7737 pedwarn ("extra qualification %<%T::%> on member %qs",
7740 else if (/* If the qualifying type is already complete, then we
7741 can skip the following checks. */
7742 !COMPLETE_TYPE_P (ctype)
7743 && (/* If the function is being defined, then
7744 qualifying type must certainly be complete. */
7746 /* A friend declaration of "T::f" is OK, even if
7747 "T" is a template parameter. But, if this
7748 function is not a friend, the qualifying type
7750 || (!friendp && !CLASS_TYPE_P (ctype))
7751 /* For a declaration, the type need not be
7752 complete, if either it is dependent (since there
7753 is no meaningful definition of complete in that
7754 case) or the qualifying class is currently being
7756 || !(dependent_type_p (ctype)
7757 || currently_open_class (ctype)))
7758 /* Check that the qualifying type is complete. */
7759 && !complete_type_or_else (ctype, NULL_TREE))
7760 return error_mark_node;
7761 else if (TREE_CODE (type) == FUNCTION_TYPE)
7763 tree sname = declarator->u.id.unqualified_name;
7765 if (current_class_type
7766 && (!friendp || funcdef_flag))
7769 ? "cannot define member function %<%T::%s%> within %<%T%>"
7770 : "cannot declare member function %<%T::%s%> within %<%T%>",
7771 ctype, name, current_class_type);
7772 return error_mark_node;
7775 if (TREE_CODE (sname) == IDENTIFIER_NODE
7776 && NEW_DELETE_OPNAME_P (sname))
7777 /* Overloaded operator new and operator delete
7778 are always static functions. */
7781 type = build_memfn_type (type, ctype, memfn_quals);
7783 else if (declspecs->specs[(int)ds_typedef]
7784 && current_class_type)
7786 error ("cannot declare member %<%T::%s%> within %qT",
7787 ctype, name, current_class_type);
7788 return error_mark_node;
7792 /* Now TYPE has the actual type. */
7797 *attrlist = chainon (returned_attrs, *attrlist);
7799 attrlist = &returned_attrs;
7802 /* Did array size calculations overflow? */
7804 if (TREE_CODE (type) == ARRAY_TYPE
7805 && COMPLETE_TYPE_P (type)
7806 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
7807 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
7809 error ("size of array %qs is too large", name);
7810 /* If we proceed with the array type as it is, we'll eventually
7811 crash in tree_low_cst(). */
7812 type = error_mark_node;
7815 if ((decl_context == FIELD || decl_context == PARM)
7816 && !processing_template_decl
7817 && variably_modified_type_p (type, NULL_TREE))
7819 if (decl_context == FIELD)
7820 error ("data member may not have variably modified type %qT", type);
7822 error ("parameter may not have variably modified type %qT", type);
7823 type = error_mark_node;
7826 if (explicitp == 1 || (explicitp && friendp))
7828 /* [dcl.fct.spec] The explicit specifier shall only be used in
7829 declarations of constructors within a class definition. */
7830 error ("only declarations of constructors can be %<explicit%>");
7834 if (storage_class == sc_mutable)
7836 if (decl_context != FIELD || friendp)
7838 error ("non-member %qs cannot be declared %<mutable%>", name);
7839 storage_class = sc_none;
7841 else if (decl_context == TYPENAME || declspecs->specs[(int)ds_typedef])
7843 error ("non-object member %qs cannot be declared %<mutable%>", name);
7844 storage_class = sc_none;
7846 else if (TREE_CODE (type) == FUNCTION_TYPE
7847 || TREE_CODE (type) == METHOD_TYPE)
7849 error ("function %qs cannot be declared %<mutable%>", name);
7850 storage_class = sc_none;
7854 error ("static %qs cannot be declared %<mutable%>", name);
7855 storage_class = sc_none;
7857 else if (type_quals & TYPE_QUAL_CONST)
7859 error ("const %qs cannot be declared %<mutable%>", name);
7860 storage_class = sc_none;
7864 /* If this is declaring a typedef name, return a TYPE_DECL. */
7865 if (declspecs->specs[(int)ds_typedef] && decl_context != TYPENAME)
7869 /* Note that the grammar rejects storage classes
7870 in typenames, fields or parameters. */
7871 if (current_lang_name == lang_name_java)
7872 TYPE_FOR_JAVA (type) = 1;
7874 /* This declaration:
7876 typedef void f(int) const;
7878 declares a function type which is not a member of any
7879 particular class, but which is cv-qualified; for
7880 example "f S::*" declares a pointer to a const-qualified
7881 member function of S. We record the cv-qualification in the
7883 if (memfn_quals && TREE_CODE (type) == FUNCTION_TYPE)
7884 type = cp_build_qualified_type (type, memfn_quals);
7886 if (decl_context == FIELD)
7887 decl = build_lang_decl (TYPE_DECL, unqualified_id, type);
7889 decl = build_decl (TYPE_DECL, unqualified_id, type);
7890 if (id_declarator && declarator->u.id.qualifying_scope)
7891 error ("%Jtypedef name may not be a nested-name-specifier", decl);
7893 if (decl_context != FIELD)
7895 if (!current_function_decl)
7896 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
7897 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl)
7898 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
7899 (current_function_decl)))
7900 /* The TYPE_DECL is "abstract" because there will be
7901 clones of this constructor/destructor, and there will
7902 be copies of this TYPE_DECL generated in those
7904 DECL_ABSTRACT (decl) = 1;
7906 else if (constructor_name_p (unqualified_id, current_class_type))
7907 pedwarn ("ISO C++ forbids nested type %qD with same name "
7908 "as enclosing class",
7911 /* If the user declares "typedef struct {...} foo" then the
7912 struct will have an anonymous name. Fill that name in now.
7913 Nothing can refer to it, so nothing needs know about the name
7915 if (type != error_mark_node
7918 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7919 && TYPE_ANONYMOUS_P (type)
7920 /* Don't do this if there are attributes. */
7921 && (!attrlist || !*attrlist)
7922 && cp_type_quals (type) == TYPE_UNQUALIFIED)
7924 tree oldname = TYPE_NAME (type);
7927 /* Replace the anonymous name with the real name everywhere. */
7928 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
7929 if (TYPE_NAME (t) == oldname)
7930 TYPE_NAME (t) = decl;
7932 if (TYPE_LANG_SPECIFIC (type))
7933 TYPE_WAS_ANONYMOUS (type) = 1;
7935 /* If this is a typedef within a template class, the nested
7936 type is a (non-primary) template. The name for the
7937 template needs updating as well. */
7938 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
7939 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
7940 = TYPE_IDENTIFIER (type);
7942 /* FIXME remangle member functions; member functions of a
7943 type with external linkage have external linkage. */
7946 /* Any qualifiers on a function type typedef have already been
7948 if (memfn_quals && !ctype && TREE_CODE (type) == FUNCTION_TYPE)
7949 memfn_quals = TYPE_UNQUALIFIED;
7952 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
7953 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
7955 bad_specifiers (decl, "type", virtualp,
7956 memfn_quals != TYPE_UNQUALIFIED,
7957 inlinep, friendp, raises != NULL_TREE);
7962 /* Detect the case of an array type of unspecified size
7963 which came, as such, direct from a typedef name.
7964 We must copy the type, so that the array's domain can be
7965 individually set by the object's initializer. */
7967 if (type && typedef_type
7968 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
7969 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
7970 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
7972 /* Detect where we're using a typedef of function type to declare a
7973 function. PARMS will not be set, so we must create it now. */
7975 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
7977 tree decls = NULL_TREE;
7980 for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
7982 tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
7984 TREE_CHAIN (decl) = decls;
7988 parms = nreverse (decls);
7990 if (decl_context != TYPENAME)
7992 /* A cv-qualifier-seq shall only be part of the function type
7993 for a non-static member function. [8.3.5/4 dcl.fct] */
7994 if (cp_type_quals (type) != TYPE_UNQUALIFIED
7995 && (current_class_type == NULL_TREE || staticp) )
7997 error ("qualified function types cannot be used to declare %s functions",
7998 (staticp? "static member" : "free"));
7999 type = TYPE_MAIN_VARIANT (type);
8002 /* The qualifiers on the function type become the qualifiers on
8003 the non-static member function. */
8004 memfn_quals |= cp_type_quals (type);
8008 /* If this is a type name (such as, in a cast or sizeof),
8009 compute the type and return it now. */
8011 if (decl_context == TYPENAME)
8013 /* Note that the grammar rejects storage classes
8014 in typenames, fields or parameters. */
8015 if (type_quals != TYPE_UNQUALIFIED)
8016 type_quals = TYPE_UNQUALIFIED;
8018 /* Special case: "friend class foo" looks like a TYPENAME context. */
8021 if (type_quals != TYPE_UNQUALIFIED)
8023 error ("type qualifiers specified for friend class declaration");
8024 type_quals = TYPE_UNQUALIFIED;
8028 error ("%<inline%> specified for friend class declaration");
8034 /* Don't allow friend declaration without a class-key. */
8035 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
8036 pedwarn ("template parameters cannot be friends");
8037 else if (TREE_CODE (type) == TYPENAME_TYPE)
8038 pedwarn ("friend declaration requires class-key, "
8039 "i.e. %<friend class %T::%D%>",
8040 TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
8042 pedwarn ("friend declaration requires class-key, "
8043 "i.e. %<friend %#T%>",
8047 /* Only try to do this stuff if we didn't already give up. */
8048 if (type != integer_type_node)
8050 /* A friendly class? */
8051 if (current_class_type)
8052 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
8055 error ("trying to make class %qT a friend of global scope",
8058 type = void_type_node;
8061 else if (memfn_quals)
8063 if (ctype == NULL_TREE)
8065 if (TREE_CODE (type) != METHOD_TYPE)
8066 error ("invalid qualifiers on non-member function type");
8068 ctype = TYPE_METHOD_BASETYPE (type);
8071 type = build_memfn_type (type, ctype, memfn_quals);
8076 else if (unqualified_id == NULL_TREE && decl_context != PARM
8077 && decl_context != CATCHPARM
8078 && TREE_CODE (type) != UNION_TYPE
8081 error ("abstract declarator %qT used as declaration", type);
8082 return error_mark_node;
8085 /* Only functions may be declared using an operator-function-id. */
8087 && IDENTIFIER_OPNAME_P (unqualified_id)
8088 && TREE_CODE (type) != FUNCTION_TYPE
8089 && TREE_CODE (type) != METHOD_TYPE)
8091 error ("declaration of %qD as non-function", unqualified_id);
8092 return error_mark_node;
8095 /* We don't check parameter types here because we can emit a better
8096 error message later. */
8097 if (decl_context != PARM)
8098 type = check_var_type (unqualified_id, type);
8100 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
8101 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
8103 if (decl_context == PARM || decl_context == CATCHPARM)
8105 if (ctype || in_namespace)
8106 error ("cannot use %<::%> in parameter declaration");
8108 /* A parameter declared as an array of T is really a pointer to T.
8109 One declared as a function is really a pointer to a function.
8110 One declared as a member is really a pointer to member. */
8112 if (TREE_CODE (type) == ARRAY_TYPE)
8114 /* Transfer const-ness of array into that of type pointed to. */
8115 type = build_pointer_type (TREE_TYPE (type));
8116 type_quals = TYPE_UNQUALIFIED;
8118 else if (TREE_CODE (type) == FUNCTION_TYPE)
8119 type = build_pointer_type (type);
8125 if (decl_context == PARM)
8127 decl = cp_build_parm_decl (unqualified_id, type);
8129 bad_specifiers (decl, "parameter", virtualp,
8130 memfn_quals != TYPE_UNQUALIFIED,
8131 inlinep, friendp, raises != NULL_TREE);
8133 else if (decl_context == FIELD)
8135 /* The C99 flexible array extension. */
8136 if (!staticp && TREE_CODE (type) == ARRAY_TYPE
8137 && TYPE_DOMAIN (type) == NULL_TREE)
8139 tree itype = compute_array_index_type (dname, integer_zero_node);
8140 type = build_cplus_array_type (TREE_TYPE (type), itype);
8143 if (type == error_mark_node)
8145 /* Happens when declaring arrays of sizes which
8146 are error_mark_node, for example. */
8149 else if (in_namespace && !friendp)
8151 /* Something like struct S { int N::j; }; */
8152 error ("invalid use of %<::%>");
8155 else if (TREE_CODE (type) == FUNCTION_TYPE)
8158 tree function_context;
8162 if (ctype == NULL_TREE)
8163 ctype = current_class_type;
8165 if (ctype == NULL_TREE)
8167 error ("can't make %qD into a method -- not in a class",
8169 return error_mark_node;
8172 /* ``A union may [ ... ] not [ have ] virtual functions.''
8174 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
8176 error ("function %qD declared virtual inside a union",
8178 return error_mark_node;
8181 if (NEW_DELETE_OPNAME_P (unqualified_id))
8185 error ("%qD cannot be declared virtual, since it "
8191 else if (staticp < 2)
8192 type = build_memfn_type (type, ctype, memfn_quals);
8195 /* Check that the name used for a destructor makes sense. */
8196 if (sfk == sfk_destructor)
8200 gcc_assert (friendp);
8201 error ("expected qualified name in friend declaration "
8202 "for destructor %qD",
8203 id_declarator->u.id.unqualified_name);
8204 return error_mark_node;
8207 if (!same_type_p (TREE_OPERAND
8208 (id_declarator->u.id.unqualified_name, 0),
8211 error ("declaration of %qD as member of %qT",
8212 id_declarator->u.id.unqualified_name, ctype);
8213 return error_mark_node;
8217 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
8218 function_context = (ctype != NULL_TREE) ?
8219 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
8220 publicp = (! friendp || ! staticp)
8221 && function_context == NULL_TREE;
8222 decl = grokfndecl (ctype, type,
8223 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
8224 ? unqualified_id : dname,
8227 virtualp, flags, memfn_quals, raises,
8228 friendp ? -1 : 0, friendp, publicp, inlinep,
8230 funcdef_flag, template_count, in_namespace, attrlist);
8231 if (decl == NULL_TREE)
8232 return error_mark_node;
8234 /* This clobbers the attrs stored in `decl' from `attrlist'. */
8235 /* The decl and setting of decl_attr is also turned off. */
8236 decl = build_decl_attribute_variant (decl, decl_attr);
8239 /* [class.conv.ctor]
8241 A constructor declared without the function-specifier
8242 explicit that can be called with a single parameter
8243 specifies a conversion from the type of its first
8244 parameter to the type of its class. Such a constructor
8245 is called a converting constructor. */
8247 DECL_NONCONVERTING_P (decl) = 1;
8248 else if (DECL_CONSTRUCTOR_P (decl))
8250 /* The constructor can be called with exactly one
8251 parameter if there is at least one parameter, and
8252 any subsequent parameters have default arguments.
8253 Ignore any compiler-added parms. */
8254 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
8256 if (arg_types == void_list_node
8258 && TREE_CHAIN (arg_types)
8259 && TREE_CHAIN (arg_types) != void_list_node
8260 && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
8261 DECL_NONCONVERTING_P (decl) = 1;
8264 else if (TREE_CODE (type) == METHOD_TYPE)
8266 /* We only get here for friend declarations of
8267 members of other classes. */
8268 /* All method decls are public, so tell grokfndecl to set
8269 TREE_PUBLIC, also. */
8270 decl = grokfndecl (ctype, type,
8271 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
8272 ? unqualified_id : dname,
8275 virtualp, flags, memfn_quals, raises,
8276 friendp ? -1 : 0, friendp, 1, 0, sfk,
8277 funcdef_flag, template_count, in_namespace,
8279 if (decl == NULL_TREE)
8280 return error_mark_node;
8282 else if (!staticp && !dependent_type_p (type)
8283 && !COMPLETE_TYPE_P (complete_type (type))
8284 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
8287 error ("field %qD has incomplete type", unqualified_id);
8289 error ("name %qT has incomplete type", type);
8291 /* If we're instantiating a template, tell them which
8292 instantiation made the field's type be incomplete. */
8293 if (current_class_type
8294 && TYPE_NAME (current_class_type)
8295 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
8297 && declspecs->type == type)
8298 error (" in instantiation of template %qT",
8299 current_class_type);
8301 type = error_mark_node;
8308 error ("%qE is neither function nor member function; "
8309 "cannot be declared friend", unqualified_id);
8317 /* Friends are treated specially. */
8318 if (ctype == current_class_type)
8319 ; /* We already issued a pedwarn. */
8320 else if (decl && DECL_NAME (decl))
8322 if (template_class_depth (current_class_type) == 0)
8324 decl = check_explicit_specialization
8325 (unqualified_id, decl, template_count,
8326 2 * funcdef_flag + 4);
8327 if (decl == error_mark_node)
8328 return error_mark_node;
8331 decl = do_friend (ctype, unqualified_id, decl,
8337 return error_mark_node;
8340 /* Structure field. It may not be a function, except for C++. */
8342 if (decl == NULL_TREE)
8348 /* An attempt is being made to initialize a non-static
8349 member. But, from [class.mem]:
8351 4 A member-declarator can contain a
8352 constant-initializer only if it declares a static
8353 member (_class.static_) of integral or enumeration
8354 type, see _class.static.data_.
8356 This used to be relatively common practice, but
8357 the rest of the compiler does not correctly
8358 handle the initialization unless the member is
8359 static so we make it static below. */
8360 pedwarn ("ISO C++ forbids initialization of member %qD",
8362 pedwarn ("making %qD static", unqualified_id);
8366 if (uses_template_parms (type))
8367 /* We'll check at instantiation time. */
8369 else if (check_static_variable_definition (unqualified_id,
8371 /* If we just return the declaration, crashes
8372 will sometimes occur. We therefore return
8373 void_type_node, as if this was a friend
8374 declaration, to cause callers to completely
8375 ignore this declaration. */
8376 return error_mark_node;
8381 /* C++ allows static class members. All other work
8382 for this is done by grokfield. */
8383 decl = build_lang_decl (VAR_DECL, unqualified_id, type);
8384 set_linkage_for_static_data_member (decl);
8385 /* Even if there is an in-class initialization, DECL
8386 is considered undefined until an out-of-class
8387 definition is provided. */
8388 DECL_EXTERNAL (decl) = 1;
8392 if (targetm.have_tls)
8393 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
8395 /* A mere warning is sure to result in improper
8396 semantics at runtime. Don't bother to allow this to
8398 error ("thread-local storage not supported for this target");
8403 decl = build_decl (FIELD_DECL, unqualified_id, type);
8404 DECL_NONADDRESSABLE_P (decl) = bitfield;
8405 if (storage_class == sc_mutable)
8407 DECL_MUTABLE_P (decl) = 1;
8408 storage_class = sc_none;
8412 bad_specifiers (decl, "field", virtualp,
8413 memfn_quals != TYPE_UNQUALIFIED,
8414 inlinep, friendp, raises != NULL_TREE);
8417 else if (TREE_CODE (type) == FUNCTION_TYPE
8418 || TREE_CODE (type) == METHOD_TYPE)
8423 if (!unqualified_id)
8424 return error_mark_node;
8426 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
8427 original_name = dname;
8429 original_name = unqualified_id;
8431 if (storage_class == sc_auto)
8432 error ("storage class %<auto%> invalid for function %qs", name);
8433 else if (storage_class == sc_register)
8434 error ("storage class %<register%> invalid for function %qs", name);
8436 error ("storage class %<__thread%> invalid for function %qs", name);
8438 /* Function declaration not at top level.
8439 Storage classes other than `extern' are not allowed
8440 and `extern' makes no difference. */
8441 if (! toplevel_bindings_p ()
8442 && (storage_class == sc_static
8443 || declspecs->specs[(int)ds_inline])
8446 if (storage_class == sc_static)
8447 pedwarn ("%<static%> specified invalid for function %qs "
8448 "declared out of global scope", name);
8450 pedwarn ("%<inline%> specifier invalid for function %qs "
8451 "declared out of global scope", name);
8454 if (ctype == NULL_TREE)
8458 error ("virtual non-class function %qs", name);
8462 else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2
8463 && !NEW_DELETE_OPNAME_P (original_name))
8464 type = build_method_type_directly (ctype,
8466 TYPE_ARG_TYPES (type));
8468 /* Record presence of `static'. */
8469 publicp = (ctype != NULL_TREE
8470 || storage_class == sc_extern
8471 || storage_class != sc_static);
8473 decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
8474 virtualp, flags, memfn_quals, raises,
8476 publicp, inlinep, sfk, funcdef_flag,
8477 template_count, in_namespace, attrlist);
8478 if (decl == NULL_TREE)
8479 return error_mark_node;
8483 int invalid_static = 0;
8485 /* Don't allow a static member function in a class, and forbid
8486 declaring main to be static. */
8487 if (TREE_CODE (type) == METHOD_TYPE)
8489 pedwarn ("cannot declare member function %qD to have "
8490 "static linkage", decl);
8493 else if (current_function_decl)
8495 /* FIXME need arm citation */
8496 error ("cannot declare static function inside another function");
8503 storage_class = sc_none;
8509 /* It's a variable. */
8511 /* An uninitialized decl with `extern' is a reference. */
8512 decl = grokvardecl (type, unqualified_id,
8515 (type_quals & TYPE_QUAL_CONST) != 0,
8516 ctype ? ctype : in_namespace);
8517 bad_specifiers (decl, "variable", virtualp,
8518 memfn_quals != TYPE_UNQUALIFIED,
8519 inlinep, friendp, raises != NULL_TREE);
8523 DECL_CONTEXT (decl) = ctype;
8526 pedwarn ("%<static%> may not be used when defining "
8527 "(as opposed to declaring) a static data member");
8529 storage_class = sc_none;
8531 if (storage_class == sc_register && TREE_STATIC (decl))
8533 error ("static member %qD declared %<register%>", decl);
8534 storage_class = sc_none;
8536 if (storage_class == sc_extern && pedantic)
8538 pedwarn ("cannot explicitly declare member %q#D to have "
8541 storage_class = sc_none;
8546 /* Record `register' declaration for warnings on &
8547 and in case doing stupid register allocation. */
8549 if (storage_class == sc_register)
8550 DECL_REGISTER (decl) = 1;
8551 else if (storage_class == sc_extern)
8552 DECL_THIS_EXTERN (decl) = 1;
8553 else if (storage_class == sc_static)
8554 DECL_THIS_STATIC (decl) = 1;
8556 /* Record constancy and volatility. There's no need to do this
8557 when processing a template; we'll do this for the instantiated
8558 declaration based on the type of DECL. */
8559 if (!processing_template_decl)
8560 cp_apply_type_quals_to_decl (type_quals, decl);
8566 /* Subroutine of start_function. Ensure that each of the parameter
8567 types (as listed in PARMS) is complete, as is required for a
8568 function definition. */
8571 require_complete_types_for_parms (tree parms)
8573 for (; parms; parms = TREE_CHAIN (parms))
8575 if (dependent_type_p (TREE_TYPE (parms)))
8577 if (!VOID_TYPE_P (TREE_TYPE (parms))
8578 && complete_type_or_else (TREE_TYPE (parms), parms))
8580 relayout_decl (parms);
8581 DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
8584 /* grokparms or complete_type_or_else will have already issued
8586 TREE_TYPE (parms) = error_mark_node;
8590 /* Returns nonzero if T is a local variable. */
8593 local_variable_p (tree t)
8595 if ((TREE_CODE (t) == VAR_DECL
8596 /* A VAR_DECL with a context that is a _TYPE is a static data
8598 && !TYPE_P (CP_DECL_CONTEXT (t))
8599 /* Any other non-local variable must be at namespace scope. */
8600 && !DECL_NAMESPACE_SCOPE_P (t))
8601 || (TREE_CODE (t) == PARM_DECL))
8607 /* Returns nonzero if T is an automatic local variable or a label.
8608 (These are the declarations that need to be remapped when the code
8609 containing them is duplicated.) */
8612 nonstatic_local_decl_p (tree t)
8614 return ((local_variable_p (t) && !TREE_STATIC (t))
8615 || TREE_CODE (t) == LABEL_DECL
8616 || TREE_CODE (t) == RESULT_DECL);
8619 /* Like local_variable_p, but suitable for use as a tree-walking
8623 local_variable_p_walkfn (tree *tp, int *walk_subtrees,
8624 void *data ATTRIBUTE_UNUSED)
8626 if (local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
8628 else if (TYPE_P (*tp))
8635 /* Check that ARG, which is a default-argument expression for a
8636 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
8637 something goes wrong. DECL may also be a _TYPE node, rather than a
8638 DECL, if there is no DECL available. */
8641 check_default_argument (tree decl, tree arg)
8646 if (TREE_CODE (arg) == DEFAULT_ARG)
8647 /* We get a DEFAULT_ARG when looking at an in-class declaration
8648 with a default argument. Ignore the argument for now; we'll
8649 deal with it after the class is complete. */
8658 decl_type = TREE_TYPE (decl);
8660 if (arg == error_mark_node
8661 || decl == error_mark_node
8662 || TREE_TYPE (arg) == error_mark_node
8663 || decl_type == error_mark_node)
8664 /* Something already went wrong. There's no need to check
8666 return error_mark_node;
8668 /* [dcl.fct.default]
8670 A default argument expression is implicitly converted to the
8672 if (!TREE_TYPE (arg)
8673 || !can_convert_arg (decl_type, TREE_TYPE (arg), arg, LOOKUP_NORMAL))
8676 error ("default argument for %q#D has type %qT",
8677 decl, TREE_TYPE (arg));
8679 error ("default argument for parameter of type %qT has type %qT",
8680 decl_type, TREE_TYPE (arg));
8682 return error_mark_node;
8685 /* [dcl.fct.default]
8687 Local variables shall not be used in default argument
8690 The keyword `this' shall not be used in a default argument of a
8692 var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
8696 error ("default argument %qE uses local variable %qD", arg, var);
8697 return error_mark_node;
8704 /* Decode the list of parameter types for a function type.
8705 Given the list of things declared inside the parens,
8706 return a list of types.
8708 If this parameter does not end with an ellipsis, we append
8711 *PARMS is set to the chain of PARM_DECLs created. */
8714 grokparms (cp_parameter_declarator *first_parm, tree *parms)
8716 tree result = NULL_TREE;
8717 tree decls = NULL_TREE;
8718 int ellipsis = !first_parm || first_parm->ellipsis_p;
8719 cp_parameter_declarator *parm;
8722 for (parm = first_parm; parm != NULL; parm = parm->next)
8724 tree type = NULL_TREE;
8725 tree init = parm->default_argument;
8729 if (parm == no_parameters)
8732 attrs = parm->decl_specifiers.attributes;
8733 parm->decl_specifiers.attributes = NULL_TREE;
8734 decl = grokdeclarator (parm->declarator, &parm->decl_specifiers,
8735 PARM, init != NULL_TREE, &attrs);
8736 if (! decl || TREE_TYPE (decl) == error_mark_node)
8740 cplus_decl_attributes (&decl, attrs, 0);
8742 type = TREE_TYPE (decl);
8743 if (VOID_TYPE_P (type))
8745 if (same_type_p (type, void_type_node)
8746 && DECL_SELF_REFERENCE_P (type)
8747 && !DECL_NAME (decl) && !result && !parm->next && !ellipsis)
8748 /* this is a parmlist of `(void)', which is ok. */
8750 cxx_incomplete_type_error (decl, type);
8751 /* It's not a good idea to actually create parameters of
8752 type `void'; other parts of the compiler assume that a
8753 void type terminates the parameter list. */
8754 type = error_mark_node;
8755 TREE_TYPE (decl) = error_mark_node;
8758 if (type != error_mark_node)
8760 /* Top-level qualifiers on the parameters are
8761 ignored for function types. */
8762 type = cp_build_qualified_type (type, 0);
8763 if (TREE_CODE (type) == METHOD_TYPE)
8765 error ("parameter %qD invalidly declared method type", decl);
8766 type = build_pointer_type (type);
8767 TREE_TYPE (decl) = type;
8769 else if (abstract_virtuals_error (decl, type))
8770 any_error = 1; /* Seems like a good idea. */
8771 else if (POINTER_TYPE_P (type))
8773 /* [dcl.fct]/6, parameter types cannot contain pointers
8774 (references) to arrays of unknown bound. */
8775 tree t = TREE_TYPE (type);
8776 int ptr = TYPE_PTR_P (type);
8782 else if (TREE_CODE (t) != ARRAY_TYPE)
8784 else if (!TYPE_DOMAIN (t))
8788 if (TREE_CODE (t) == ARRAY_TYPE)
8789 error ("parameter %qD includes %s to array of unknown "
8791 decl, ptr ? "pointer" : "reference", t);
8796 else if (init && !processing_template_decl)
8797 init = check_default_argument (decl, init);
8800 TREE_CHAIN (decl) = decls;
8802 result = tree_cons (init, type, result);
8804 decls = nreverse (decls);
8805 result = nreverse (result);
8807 result = chainon (result, void_list_node);
8814 /* D is a constructor or overloaded `operator='.
8816 Let T be the class in which D is declared. Then, this function
8819 -1 if D's is an ill-formed constructor or copy assignment operator
8820 whose first parameter is of type `T'.
8821 0 if D is not a copy constructor or copy assignment
8823 1 if D is a copy constructor or copy assignment operator whose
8824 first parameter is a reference to const qualified T.
8825 2 if D is a copy constructor or copy assignment operator whose
8826 first parameter is a reference to non-const qualified T.
8828 This function can be used as a predicate. Positive values indicate
8829 a copy constructor and nonzero values indicate a copy assignment
8839 if (!DECL_FUNCTION_MEMBER_P (d))
8840 /* Non-members are invalid. We complained, but kept the declaration. */
8843 if (TREE_CODE (d) == TEMPLATE_DECL
8844 || (DECL_TEMPLATE_INFO (d)
8845 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
8846 /* Instantiations of template member functions are never copy
8847 functions. Note that member functions of templated classes are
8848 represented as template functions internally, and we must
8849 accept those as copy functions. */
8852 args = FUNCTION_FIRST_USER_PARMTYPE (d);
8856 arg_type = TREE_VALUE (args);
8857 if (arg_type == error_mark_node)
8860 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
8862 /* Pass by value copy assignment operator. */
8865 else if (TREE_CODE (arg_type) == REFERENCE_TYPE
8866 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
8868 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
8874 args = TREE_CHAIN (args);
8876 if (args && args != void_list_node && !TREE_PURPOSE (args))
8877 /* There are more non-optional args. */
8883 /* Remember any special properties of member function DECL. */
8885 void grok_special_member_properties (tree decl)
8889 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
8892 class_type = DECL_CONTEXT (decl);
8893 if (DECL_CONSTRUCTOR_P (decl))
8895 int ctor = copy_fn_p (decl);
8897 TYPE_HAS_CONSTRUCTOR (class_type) = 1;
8903 A non-template constructor for class X is a copy
8904 constructor if its first parameter is of type X&, const
8905 X&, volatile X& or const volatile X&, and either there
8906 are no other parameters or else all other parameters have
8907 default arguments. */
8908 TYPE_HAS_INIT_REF (class_type) = 1;
8910 TYPE_HAS_CONST_INIT_REF (class_type) = 1;
8912 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
8913 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type) = 1;
8915 else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
8919 A non-template assignment operator for class X is a copy
8920 assignment operator if its parameter is of type X, X&, const
8921 X&, volatile X& or const volatile X&. */
8923 int assop = copy_fn_p (decl);
8927 TYPE_HAS_ASSIGN_REF (class_type) = 1;
8929 TYPE_HAS_CONST_ASSIGN_REF (class_type) = 1;
8934 /* Check a constructor DECL has the correct form. Complains
8935 if the class has a constructor of the form X(X). */
8938 grok_ctor_properties (tree ctype, tree decl)
8940 int ctor_parm = copy_fn_p (decl);
8946 A declaration of a constructor for a class X is ill-formed if
8947 its first parameter is of type (optionally cv-qualified) X
8948 and either there are no other parameters or else all other
8949 parameters have default arguments.
8951 We *don't* complain about member template instantiations that
8952 have this form, though; they can occur as we try to decide
8953 what constructor to use during overload resolution. Since
8954 overload resolution will never prefer such a constructor to
8955 the non-template copy constructor (which is either explicitly
8956 or implicitly defined), there's no need to worry about their
8957 existence. Theoretically, they should never even be
8958 instantiated, but that's hard to forestall. */
8959 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
8967 /* An operator with this code is unary, but can also be binary. */
8970 ambi_op_p (enum tree_code code)
8972 return (code == INDIRECT_REF
8973 || code == ADDR_EXPR
8974 || code == UNARY_PLUS_EXPR
8975 || code == NEGATE_EXPR
8976 || code == PREINCREMENT_EXPR
8977 || code == PREDECREMENT_EXPR);
8980 /* An operator with this name can only be unary. */
8983 unary_op_p (enum tree_code code)
8985 return (code == TRUTH_NOT_EXPR
8986 || code == BIT_NOT_EXPR
8987 || code == COMPONENT_REF
8988 || code == TYPE_EXPR);
8991 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
8992 errors are issued for invalid declarations. */
8995 grok_op_properties (tree decl, bool complain)
8997 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
8999 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
9000 tree name = DECL_NAME (decl);
9001 enum tree_code operator_code;
9006 /* Count the number of arguments and check for ellipsis. */
9007 for (argtype = argtypes, arity = 0;
9008 argtype && argtype != void_list_node;
9009 argtype = TREE_CHAIN (argtype))
9011 ellipsis_p = !argtype;
9013 class_type = DECL_CONTEXT (decl);
9014 if (class_type && !CLASS_TYPE_P (class_type))
9015 class_type = NULL_TREE;
9017 if (DECL_CONV_FN_P (decl))
9018 operator_code = TYPE_EXPR;
9022 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
9023 if (ansi_opname (CODE) == name) \
9025 operator_code = (CODE); \
9028 else if (ansi_assopname (CODE) == name) \
9030 operator_code = (CODE); \
9031 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
9035 #include "operators.def"
9041 gcc_assert (operator_code != LAST_CPLUS_TREE_CODE);
9042 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
9045 switch (operator_code)
9048 TYPE_HAS_NEW_OPERATOR (class_type) = 1;
9052 TYPE_GETS_DELETE (class_type) |= 1;
9056 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type) = 1;
9059 case VEC_DELETE_EXPR:
9060 TYPE_GETS_DELETE (class_type) |= 2;
9067 /* [basic.std.dynamic.allocation]/1:
9069 A program is ill-formed if an allocation function is declared
9070 in a namespace scope other than global scope or declared static
9073 The same also holds true for deallocation functions. */
9074 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR
9075 || operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
9077 if (DECL_NAMESPACE_SCOPE_P (decl))
9079 if (CP_DECL_CONTEXT (decl) != global_namespace)
9080 error ("%qD may not be declared within a namespace", decl);
9081 else if (!TREE_PUBLIC (decl))
9082 error ("%qD may not be declared as static", decl);
9086 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
9087 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
9088 else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
9089 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
9092 /* An operator function must either be a non-static member function
9093 or have at least one parameter of a class, a reference to a class,
9094 an enumeration, or a reference to an enumeration. 13.4.0.6 */
9095 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
9097 if (operator_code == TYPE_EXPR
9098 || operator_code == CALL_EXPR
9099 || operator_code == COMPONENT_REF
9100 || operator_code == ARRAY_REF
9101 || operator_code == NOP_EXPR)
9103 error ("%qD must be a nonstatic member function", decl);
9110 if (DECL_STATIC_FUNCTION_P (decl))
9112 error ("%qD must be either a non-static member "
9113 "function or a non-member function", decl);
9117 for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
9119 tree arg = non_reference (TREE_VALUE (p));
9120 if (arg == error_mark_node)
9123 /* IS_AGGR_TYPE, rather than CLASS_TYPE_P, is used
9124 because these checks are performed even on
9125 template functions. */
9126 if (IS_AGGR_TYPE (arg) || TREE_CODE (arg) == ENUMERAL_TYPE)
9130 if (!p || p == void_list_node)
9135 error ("%qD must have an argument of class or "
9142 /* There are no restrictions on the arguments to an overloaded
9144 if (operator_code == CALL_EXPR)
9147 /* Warn about conversion operators that will never be used. */
9148 if (IDENTIFIER_TYPENAME_P (name)
9149 && ! DECL_TEMPLATE_INFO (decl)
9151 /* Warn only declaring the function; there is no need to
9152 warn again about out-of-class definitions. */
9153 && class_type == current_class_type)
9155 tree t = TREE_TYPE (name);
9156 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
9157 const char *what = 0;
9160 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
9162 if (TREE_CODE (t) == VOID_TYPE)
9164 else if (class_type)
9166 if (t == class_type)
9167 what = "the same type";
9168 /* Don't force t to be complete here. */
9169 else if (IS_AGGR_TYPE (t)
9170 && COMPLETE_TYPE_P (t)
9171 && DERIVED_FROM_P (t, class_type))
9172 what = "a base class";
9176 warning (OPT_Wconversion, "conversion to %s%s will never use a type "
9177 "conversion operator",
9178 ref ? "a reference to " : "", what);
9181 if (operator_code == COND_EXPR)
9184 error ("ISO C++ prohibits overloading operator ?:");
9186 else if (ellipsis_p)
9187 error ("%qD must not have variable number of arguments", decl);
9188 else if (ambi_op_p (operator_code))
9191 /* We pick the one-argument operator codes by default, so
9192 we don't have to change anything. */
9194 else if (arity == 2)
9196 /* If we thought this was a unary operator, we now know
9197 it to be a binary operator. */
9198 switch (operator_code)
9201 operator_code = MULT_EXPR;
9205 operator_code = BIT_AND_EXPR;
9208 case UNARY_PLUS_EXPR:
9209 operator_code = PLUS_EXPR;
9213 operator_code = MINUS_EXPR;
9216 case PREINCREMENT_EXPR:
9217 operator_code = POSTINCREMENT_EXPR;
9220 case PREDECREMENT_EXPR:
9221 operator_code = POSTDECREMENT_EXPR;
9228 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
9230 if ((operator_code == POSTINCREMENT_EXPR
9231 || operator_code == POSTDECREMENT_EXPR)
9232 && ! processing_template_decl
9233 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
9236 error ("postfix %qD must take %<int%> as its argument",
9240 ("postfix %qD must take %<int%> as its second argument",
9247 error ("%qD must take either zero or one argument", decl);
9249 error ("%qD must take either one or two arguments", decl);
9252 /* More Effective C++ rule 6. */
9254 && (operator_code == POSTINCREMENT_EXPR
9255 || operator_code == POSTDECREMENT_EXPR
9256 || operator_code == PREINCREMENT_EXPR
9257 || operator_code == PREDECREMENT_EXPR))
9259 tree arg = TREE_VALUE (argtypes);
9260 tree ret = TREE_TYPE (TREE_TYPE (decl));
9261 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
9262 arg = TREE_TYPE (arg);
9263 arg = TYPE_MAIN_VARIANT (arg);
9264 if (operator_code == PREINCREMENT_EXPR
9265 || operator_code == PREDECREMENT_EXPR)
9267 if (TREE_CODE (ret) != REFERENCE_TYPE
9268 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
9270 warning (OPT_Weffc__, "prefix %qD should return %qT", decl,
9271 build_reference_type (arg));
9275 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
9276 warning (OPT_Weffc__, "postfix %qD should return %qT", decl, arg);
9280 else if (unary_op_p (operator_code))
9285 error ("%qD must take %<void%>", decl);
9287 error ("%qD must take exactly one argument", decl);
9290 else /* if (binary_op_p (operator_code)) */
9295 error ("%qD must take exactly one argument", decl);
9297 error ("%qD must take exactly two arguments", decl);
9300 /* More Effective C++ rule 7. */
9302 && (operator_code == TRUTH_ANDIF_EXPR
9303 || operator_code == TRUTH_ORIF_EXPR
9304 || operator_code == COMPOUND_EXPR))
9305 warning (OPT_Weffc__, "user-defined %qD always evaluates both arguments",
9309 /* Effective C++ rule 23. */
9312 && !DECL_ASSIGNMENT_OPERATOR_P (decl)
9313 && (operator_code == PLUS_EXPR
9314 || operator_code == MINUS_EXPR
9315 || operator_code == TRUNC_DIV_EXPR
9316 || operator_code == MULT_EXPR
9317 || operator_code == TRUNC_MOD_EXPR)
9318 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
9319 warning (OPT_Weffc__, "%qD should return by value", decl);
9322 for (; argtypes && argtypes != void_list_node;
9323 argtypes = TREE_CHAIN (argtypes))
9324 if (TREE_PURPOSE (argtypes))
9326 TREE_PURPOSE (argtypes) = NULL_TREE;
9327 if (operator_code == POSTINCREMENT_EXPR
9328 || operator_code == POSTDECREMENT_EXPR)
9331 pedwarn ("%qD cannot have default arguments", decl);
9334 error ("%qD cannot have default arguments", decl);
9341 /* Return a string giving the keyword associate with CODE. */
9344 tag_name (enum tag_types code)
9363 /* Name lookup in an elaborated-type-specifier (after the keyword
9364 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
9365 elaborated-type-specifier is invalid, issue a diagnostic and return
9366 error_mark_node; otherwise, return the *_TYPE to which it referred.
9367 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
9370 check_elaborated_type_specifier (enum tag_types tag_code,
9372 bool allow_template_p)
9378 struct S { struct S *p; };
9380 name lookup will find the TYPE_DECL for the implicit "S::S"
9381 typedef. Adjust for that here. */
9382 if (DECL_SELF_REFERENCE_P (decl))
9383 decl = TYPE_NAME (TREE_TYPE (decl));
9385 type = TREE_TYPE (decl);
9387 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
9388 is false for this case as well. */
9389 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
9391 error ("using template type parameter %qT after %qs",
9392 type, tag_name (tag_code));
9393 return error_mark_node;
9397 If the identifier resolves to a typedef-name or a template
9398 type-parameter, the elaborated-type-specifier is ill-formed.
9400 In other words, the only legitimate declaration to use in the
9401 elaborated type specifier is the implicit typedef created when
9402 the type is declared. */
9403 else if (!DECL_IMPLICIT_TYPEDEF_P (decl)
9404 && tag_code != typename_type)
9406 error ("using typedef-name %qD after %qs", decl, tag_name (tag_code));
9407 error ("%q+D has a previous declaration here", decl);
9408 return error_mark_node;
9410 else if (TREE_CODE (type) != RECORD_TYPE
9411 && TREE_CODE (type) != UNION_TYPE
9412 && tag_code != enum_type
9413 && tag_code != typename_type)
9415 error ("%qT referred to as %qs", type, tag_name (tag_code));
9416 error ("%q+T has a previous declaration here", type);
9417 return error_mark_node;
9419 else if (TREE_CODE (type) != ENUMERAL_TYPE
9420 && tag_code == enum_type)
9422 error ("%qT referred to as enum", type);
9423 error ("%q+T has a previous declaration here", type);
9424 return error_mark_node;
9426 else if (!allow_template_p
9427 && TREE_CODE (type) == RECORD_TYPE
9428 && CLASSTYPE_IS_TEMPLATE (type))
9430 /* If a class template appears as elaborated type specifier
9431 without a template header such as:
9433 template <class T> class C {};
9434 void f(class C); // No template header here
9436 then the required template argument is missing. */
9437 error ("template argument required for %<%s %T%>",
9438 tag_name (tag_code),
9439 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
9440 return error_mark_node;
9446 /* Lookup NAME in elaborate type specifier in scope according to
9447 SCOPE and issue diagnostics if necessary.
9448 Return *_TYPE node upon success, NULL_TREE when the NAME is not
9449 found, and ERROR_MARK_NODE for type error. */
9452 lookup_and_check_tag (enum tag_types tag_code, tree name,
9453 tag_scope scope, bool template_header_p)
9457 if (scope == ts_global)
9459 /* First try ordinary name lookup, ignoring hidden class name
9460 injected via friend declaration. */
9461 decl = lookup_name_prefer_type (name, 2);
9462 /* If that fails, the name will be placed in the smallest
9463 non-class, non-function-prototype scope according to 3.3.1/5.
9464 We may already have a hidden name declared as friend in this
9465 scope. So lookup again but not ignoring hidden name.
9466 If we find one, that name will be made visible rather than
9467 creating a new tag. */
9469 decl = lookup_type_scope (name, ts_within_enclosing_non_class);
9472 decl = lookup_type_scope (name, scope);
9474 if (decl && DECL_CLASS_TEMPLATE_P (decl))
9475 decl = DECL_TEMPLATE_RESULT (decl);
9477 if (decl && TREE_CODE (decl) == TYPE_DECL)
9479 /* Look for invalid nested type:
9483 if (scope == ts_current && DECL_SELF_REFERENCE_P (decl))
9485 error ("%qD has the same name as the class in which it is "
9488 return error_mark_node;
9491 /* Two cases we need to consider when deciding if a class
9492 template is allowed as an elaborated type specifier:
9493 1. It is a self reference to its own class.
9494 2. It comes with a template header.
9498 template <class T> class C {
9499 class C *c1; // DECL_SELF_REFERENCE_P is true
9502 template <class U> class C; // template_header_p is true
9503 template <class T> class C<T>::D {
9504 class C *c2; // DECL_SELF_REFERENCE_P is true
9507 t = check_elaborated_type_specifier (tag_code,
9510 | DECL_SELF_REFERENCE_P (decl));
9517 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
9518 Define the tag as a forward-reference if it is not defined.
9520 If a declaration is given, process it here, and report an error if
9521 multiple declarations are not identical.
9523 SCOPE is TS_CURRENT when this is also a definition. Only look in
9524 the current frame for the name (since C++ allows new names in any
9525 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
9526 declaration. Only look beginning from the current scope outward up
9527 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
9529 TEMPLATE_HEADER_P is true when this declaration is preceded by
9530 a set of template parameters. */
9533 xref_tag (enum tag_types tag_code, tree name,
9534 tag_scope scope, bool template_header_p)
9536 enum tree_code code;
9538 tree context = NULL_TREE;
9540 timevar_push (TV_NAME_LOOKUP);
9542 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
9554 code = ENUMERAL_TYPE;
9560 /* In case of anonymous name, xref_tag is only called to
9561 make type node and push name. Name lookup is not required. */
9562 if (ANON_AGGRNAME_P (name))
9565 t = lookup_and_check_tag (tag_code, name,
9566 scope, template_header_p);
9568 if (t == error_mark_node)
9569 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
9571 if (scope != ts_current && t && current_class_type
9572 && template_class_depth (current_class_type)
9573 && template_header_p)
9575 /* Since SCOPE is not TS_CURRENT, we are not looking at a
9576 definition of this tag. Since, in addition, we are currently
9577 processing a (member) template declaration of a template
9578 class, we must be very careful; consider:
9585 { template <class V>
9586 friend struct S1; };
9588 Here, the S2::S1 declaration should not be confused with the
9589 outer declaration. In particular, the inner version should
9590 have a template parameter of level 2, not level 1. This
9591 would be particularly important if the member declaration
9594 template <class V = U> friend struct S1;
9596 say, when we should tsubst into `U' when instantiating
9597 S2. On the other hand, when presented with:
9607 we must find the inner binding eventually. We
9608 accomplish this by making sure that the new type we
9609 create to represent this declaration has the right
9611 context = TYPE_CONTEXT (t);
9617 /* If no such tag is yet defined, create a forward-reference node
9618 and record it as the "definition".
9619 When a real declaration of this type is found,
9620 the forward-reference will be altered into a real type. */
9621 if (code == ENUMERAL_TYPE)
9623 error ("use of enum %q#D without previous declaration", name);
9624 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
9628 t = make_aggr_type (code);
9629 TYPE_CONTEXT (t) = context;
9630 t = pushtag (name, t, scope);
9635 if (template_header_p && IS_AGGR_TYPE (t))
9636 redeclare_class_template (t, current_template_parms);
9637 else if (!processing_template_decl
9639 && CLASSTYPE_IS_TEMPLATE (t))
9641 error ("redeclaration of %qT as a non-template", t);
9642 t = error_mark_node;
9645 /* Make injected friend class visible. */
9646 if (scope != ts_within_enclosing_non_class
9647 && hidden_name_p (TYPE_NAME (t)))
9649 DECL_ANTICIPATED (TYPE_NAME (t)) = 0;
9650 DECL_FRIEND_P (TYPE_NAME (t)) = 0;
9652 if (TYPE_TEMPLATE_INFO (t))
9654 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t)) = 0;
9655 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t)) = 0;
9660 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
9664 xref_tag_from_type (tree old, tree id, tag_scope scope)
9666 enum tag_types tag_kind;
9668 if (TREE_CODE (old) == RECORD_TYPE)
9669 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
9671 tag_kind = union_type;
9673 if (id == NULL_TREE)
9674 id = TYPE_IDENTIFIER (old);
9676 return xref_tag (tag_kind, id, scope, false);
9679 /* Create the binfo hierarchy for REF with (possibly NULL) base list
9680 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
9681 access_* node, and the TREE_VALUE is the type of the base-class.
9682 Non-NULL TREE_TYPE indicates virtual inheritance. */
9685 xref_basetypes (tree ref, tree base_list)
9688 tree binfo, base_binfo;
9689 unsigned max_vbases = 0; /* Maximum direct & indirect virtual bases. */
9690 unsigned max_bases = 0; /* Maximum direct bases. */
9692 tree default_access;
9693 tree igo_prev; /* Track Inheritance Graph Order. */
9695 if (ref == error_mark_node)
9698 /* The base of a derived class is private by default, all others are
9700 default_access = (TREE_CODE (ref) == RECORD_TYPE
9701 && CLASSTYPE_DECLARED_CLASS (ref)
9702 ? access_private_node : access_public_node);
9704 /* First, make sure that any templates in base-classes are
9705 instantiated. This ensures that if we call ourselves recursively
9706 we do not get confused about which classes are marked and which
9711 tree basetype = TREE_VALUE (*basep);
9713 if (!(processing_template_decl && uses_template_parms (basetype))
9714 && !complete_type_or_else (basetype, NULL))
9715 /* An incomplete type. Remove it from the list. */
9716 *basep = TREE_CHAIN (*basep);
9720 if (TREE_TYPE (*basep))
9722 if (CLASS_TYPE_P (basetype))
9723 max_vbases += VEC_length (tree, CLASSTYPE_VBASECLASSES (basetype));
9724 basep = &TREE_CHAIN (*basep);
9728 TYPE_MARKED_P (ref) = 1;
9730 /* The binfo slot should be empty, unless this is an (ill-formed)
9732 gcc_assert (!TYPE_BINFO (ref) || TYPE_SIZE (ref));
9733 gcc_assert (TYPE_MAIN_VARIANT (ref) == ref);
9735 binfo = make_tree_binfo (max_bases);
9737 TYPE_BINFO (ref) = binfo;
9738 BINFO_OFFSET (binfo) = size_zero_node;
9739 BINFO_TYPE (binfo) = ref;
9743 BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, gc, max_bases);
9744 /* An aggregate cannot have baseclasses. */
9745 CLASSTYPE_NON_AGGREGATE (ref) = 1;
9747 if (TREE_CODE (ref) == UNION_TYPE)
9748 error ("derived union %qT invalid", ref);
9753 if (TYPE_FOR_JAVA (ref))
9754 error ("Java class %qT cannot have multiple bases", ref);
9759 CLASSTYPE_VBASECLASSES (ref) = VEC_alloc (tree, gc, max_vbases);
9761 if (TYPE_FOR_JAVA (ref))
9762 error ("Java class %qT cannot have virtual bases", ref);
9765 for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list))
9767 tree access = TREE_PURPOSE (base_list);
9768 int via_virtual = TREE_TYPE (base_list) != NULL_TREE;
9769 tree basetype = TREE_VALUE (base_list);
9771 if (access == access_default_node)
9772 access = default_access;
9774 if (TREE_CODE (basetype) == TYPE_DECL)
9775 basetype = TREE_TYPE (basetype);
9776 if (TREE_CODE (basetype) != RECORD_TYPE
9777 && TREE_CODE (basetype) != TYPENAME_TYPE
9778 && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
9779 && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM)
9781 error ("base type %qT fails to be a struct or class type",
9786 if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0))
9787 TYPE_FOR_JAVA (ref) = 1;
9789 base_binfo = NULL_TREE;
9790 if (CLASS_TYPE_P (basetype) && !dependent_type_p (basetype))
9792 base_binfo = TYPE_BINFO (basetype);
9793 /* The original basetype could have been a typedef'd type. */
9794 basetype = BINFO_TYPE (base_binfo);
9796 /* Inherit flags from the base. */
9797 TYPE_HAS_NEW_OPERATOR (ref)
9798 |= TYPE_HAS_NEW_OPERATOR (basetype);
9799 TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
9800 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
9801 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
9802 TYPE_HAS_CONVERSION (ref) |= TYPE_HAS_CONVERSION (basetype);
9803 CLASSTYPE_DIAMOND_SHAPED_P (ref)
9804 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype);
9805 CLASSTYPE_REPEATED_BASE_P (ref)
9806 |= CLASSTYPE_REPEATED_BASE_P (basetype);
9809 /* We must do this test after we've seen through a typedef
9811 if (TYPE_MARKED_P (basetype))
9813 if (basetype == ref)
9814 error ("recursive type %qT undefined", basetype);
9816 error ("duplicate base type %qT invalid", basetype);
9819 TYPE_MARKED_P (basetype) = 1;
9821 base_binfo = copy_binfo (base_binfo, basetype, ref,
9822 &igo_prev, via_virtual);
9823 if (!BINFO_INHERITANCE_CHAIN (base_binfo))
9824 BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
9826 BINFO_BASE_APPEND (binfo, base_binfo);
9827 BINFO_BASE_ACCESS_APPEND (binfo, access);
9830 if (VEC_space (tree, CLASSTYPE_VBASECLASSES (ref), 1))
9831 /* If we have space in the vbase vector, we must have shared at
9832 least one of them, and are therefore diamond shaped. */
9833 CLASSTYPE_DIAMOND_SHAPED_P (ref) = 1;
9835 /* Unmark all the types. */
9836 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
9837 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
9838 TYPE_MARKED_P (ref) = 0;
9840 /* Now see if we have a repeated base type. */
9841 if (!CLASSTYPE_REPEATED_BASE_P (ref))
9843 for (base_binfo = binfo; base_binfo;
9844 base_binfo = TREE_CHAIN (base_binfo))
9846 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
9848 CLASSTYPE_REPEATED_BASE_P (ref) = 1;
9851 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 1;
9853 for (base_binfo = binfo; base_binfo;
9854 base_binfo = TREE_CHAIN (base_binfo))
9855 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
9856 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
9863 /* Begin compiling the definition of an enumeration type.
9865 Returns the type object, as yet incomplete.
9866 Also records info about it so that build_enumerator
9867 may be used to declare the individual values as they are read. */
9870 start_enum (tree name)
9874 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
9876 /* If this is the real definition for a previous forward reference,
9877 fill in the contents in the same object that used to be the
9878 forward reference. */
9880 enumtype = lookup_and_check_tag (enum_type, name,
9881 /*tag_scope=*/ts_current,
9882 /*template_header_p=*/false);
9884 if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
9886 error ("multiple definition of %q#T", enumtype);
9887 error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype));
9888 /* Clear out TYPE_VALUES, and start again. */
9889 TYPE_VALUES (enumtype) = NULL_TREE;
9893 /* In case of error, make a dummy enum to allow parsing to
9895 if (enumtype == error_mark_node)
9896 name = make_anon_name ();
9898 enumtype = make_node (ENUMERAL_TYPE);
9899 enumtype = pushtag (name, enumtype, /*tag_scope=*/ts_current);
9905 /* After processing and defining all the values of an enumeration type,
9906 install their decls in the enumeration type and finish it off.
9907 ENUMTYPE is the type object and VALUES a list of name-value pairs. */
9910 finish_enum (tree enumtype)
9919 bool use_short_enum;
9923 integer_type_kind itk;
9924 tree underlying_type = NULL_TREE;
9926 /* We built up the VALUES in reverse order. */
9927 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
9929 /* For an enum defined in a template, just set the type of the values;
9930 all further processing is postponed until the template is
9931 instantiated. We need to set the type so that tsubst of a CONST_DECL
9933 if (processing_template_decl)
9935 for (values = TYPE_VALUES (enumtype);
9937 values = TREE_CHAIN (values))
9938 TREE_TYPE (TREE_VALUE (values)) = enumtype;
9939 if (at_function_scope_p ())
9940 add_stmt (build_min (TAG_DEFN, enumtype));
9944 /* Determine the minimum and maximum values of the enumerators. */
9945 if (TYPE_VALUES (enumtype))
9947 minnode = maxnode = NULL_TREE;
9949 for (values = TYPE_VALUES (enumtype);
9951 values = TREE_CHAIN (values))
9953 decl = TREE_VALUE (values);
9955 /* [dcl.enum]: Following the closing brace of an enum-specifier,
9956 each enumerator has the type of its enumeration. Prior to the
9957 closing brace, the type of each enumerator is the type of its
9958 initializing value. */
9959 TREE_TYPE (decl) = enumtype;
9961 /* Update the minimum and maximum values, if appropriate. */
9962 value = DECL_INITIAL (decl);
9963 if (value == error_mark_node)
9964 value = integer_zero_node;
9965 /* Figure out what the minimum and maximum values of the
9968 minnode = maxnode = value;
9969 else if (tree_int_cst_lt (maxnode, value))
9971 else if (tree_int_cst_lt (value, minnode))
9978 If the enumerator-list is empty, the underlying type is as if
9979 the enumeration had a single enumerator with value 0. */
9980 minnode = maxnode = integer_zero_node;
9982 /* Compute the number of bits require to represent all values of the
9983 enumeration. We must do this before the type of MINNODE and
9984 MAXNODE are transformed, since min_precision relies on the
9985 TREE_TYPE of the value it is passed. */
9986 unsignedp = tree_int_cst_sgn (minnode) >= 0;
9987 lowprec = min_precision (minnode, unsignedp);
9988 highprec = min_precision (maxnode, unsignedp);
9989 precision = MAX (lowprec, highprec);
9991 /* Determine the underlying type of the enumeration.
9995 The underlying type of an enumeration is an integral type that
9996 can represent all the enumerator values defined in the
9997 enumeration. It is implementation-defined which integral type is
9998 used as the underlying type for an enumeration except that the
9999 underlying type shall not be larger than int unless the value of
10000 an enumerator cannot fit in an int or unsigned int.
10002 We use "int" or an "unsigned int" as the underlying type, even if
10003 a smaller integral type would work, unless the user has
10004 explicitly requested that we use the smallest possible type. The
10005 user can request that for all enumerations with a command line
10006 flag, or for just one enumeration with an attribute. */
10008 use_short_enum = flag_short_enums
10009 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype));
10011 for (itk = (use_short_enum ? itk_char : itk_int);
10015 underlying_type = integer_types[itk];
10016 if (TYPE_PRECISION (underlying_type) >= precision
10017 && TYPE_UNSIGNED (underlying_type) == unsignedp)
10020 if (itk == itk_none)
10024 IF no integral type can represent all the enumerator values, the
10025 enumeration is ill-formed. */
10026 error ("no integral type can represent all of the enumerator values "
10027 "for %qT", enumtype);
10028 precision = TYPE_PRECISION (long_long_integer_type_node);
10029 underlying_type = integer_types[itk_unsigned_long_long];
10032 /* Compute the minium and maximum values for the type.
10036 For an enumeration where emin is the smallest enumerator and emax
10037 is the largest, the values of the enumeration are the values of the
10038 underlying type in the range bmin to bmax, where bmin and bmax are,
10039 respectively, the smallest and largest values of the smallest bit-
10040 field that can store emin and emax. */
10042 /* The middle-end currently assumes that types with TYPE_PRECISION
10043 narrower than their underlying type are suitably zero or sign
10044 extended to fill their mode. g++ doesn't make these guarantees.
10045 Until the middle-end can represent such paradoxical types, we
10046 set the TYPE_PRECISION to the width of the underlying type. */
10047 TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type);
10049 set_min_and_max_values_for_integral_type (enumtype, precision, unsignedp);
10053 The value of sizeof() applied to an enumeration type, an object
10054 of an enumeration type, or an enumerator, is the value of sizeof()
10055 applied to the underlying type. */
10056 TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
10057 TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
10058 TYPE_MODE (enumtype) = TYPE_MODE (underlying_type);
10059 TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
10060 TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
10061 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);
10063 /* Convert each of the enumerators to the type of the underlying
10064 type of the enumeration. */
10065 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
10067 location_t saved_location;
10069 decl = TREE_VALUE (values);
10070 saved_location = input_location;
10071 input_location = DECL_SOURCE_LOCATION (decl);
10072 value = perform_implicit_conversion (underlying_type,
10073 DECL_INITIAL (decl));
10074 input_location = saved_location;
10076 /* Do not clobber shared ints. */
10077 value = copy_node (value);
10079 TREE_TYPE (value) = enumtype;
10080 DECL_INITIAL (decl) = value;
10081 TREE_VALUE (values) = value;
10084 /* Fix up all variant types of this enum type. */
10085 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
10087 TYPE_VALUES (t) = TYPE_VALUES (enumtype);
10088 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
10089 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
10090 TYPE_SIZE (t) = TYPE_SIZE (enumtype);
10091 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
10092 TYPE_MODE (t) = TYPE_MODE (enumtype);
10093 TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
10094 TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
10095 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
10096 TYPE_UNSIGNED (t) = TYPE_UNSIGNED (enumtype);
10099 /* Finish debugging output for this type. */
10100 rest_of_type_compilation (enumtype, namespace_bindings_p ());
10103 /* Build and install a CONST_DECL for an enumeration constant of the
10104 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
10105 Assignment of sequential values by default is handled here. */
10108 build_enumerator (tree name, tree value, tree enumtype)
10114 /* If the VALUE was erroneous, pretend it wasn't there; that will
10115 result in the enum being assigned the next value in sequence. */
10116 if (value == error_mark_node)
10119 /* Remove no-op casts from the value. */
10121 STRIP_TYPE_NOPS (value);
10123 if (! processing_template_decl)
10125 /* Validate and default VALUE. */
10126 if (value != NULL_TREE)
10128 value = integral_constant_value (value);
10130 if (TREE_CODE (value) == INTEGER_CST)
10132 value = perform_integral_promotions (value);
10133 constant_expression_warning (value);
10137 error ("enumerator value for %qD not integer constant", name);
10142 /* Default based on previous value. */
10143 if (value == NULL_TREE)
10145 if (TYPE_VALUES (enumtype))
10148 unsigned HOST_WIDE_INT lo;
10152 /* The next value is the previous value plus one. We can
10153 safely assume that the previous value is an INTEGER_CST.
10154 add_double doesn't know the type of the target expression,
10155 so we must check with int_fits_type_p as well. */
10156 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
10157 overflowed = add_double (TREE_INT_CST_LOW (prev_value),
10158 TREE_INT_CST_HIGH (prev_value),
10160 value = build_int_cst_wide (TREE_TYPE (prev_value), lo, hi);
10161 overflowed |= !int_fits_type_p (value, TREE_TYPE (prev_value));
10165 error ("overflow in enumeration values at %qD", name);
10166 value = error_mark_node;
10170 value = integer_zero_node;
10173 /* Remove no-op casts from the value. */
10174 STRIP_TYPE_NOPS (value);
10177 /* C++ associates enums with global, function, or class declarations. */
10178 context = current_scope ();
10180 /* Build the actual enumeration constant. Note that the enumeration
10181 constants have the type of their initializers until the
10182 enumeration is complete:
10186 Following the closing brace of an enum-specifier, each enumer-
10187 ator has the type of its enumeration. Prior to the closing
10188 brace, the type of each enumerator is the type of its
10189 initializing value.
10191 In finish_enum we will reset the type. Of course, if we're
10192 processing a template, there may be no value. */
10193 type = value ? TREE_TYPE (value) : NULL_TREE;
10195 if (context && context == current_class_type)
10196 /* This enum declaration is local to the class. We need the full
10197 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
10198 decl = build_lang_decl (CONST_DECL, name, type);
10200 /* It's a global enum, or it's local to a function. (Note local to
10201 a function could mean local to a class method. */
10202 decl = build_decl (CONST_DECL, name, type);
10204 DECL_CONTEXT (decl) = FROB_CONTEXT (context);
10205 TREE_CONSTANT (decl) = 1;
10206 TREE_INVARIANT (decl) = 1;
10207 TREE_READONLY (decl) = 1;
10208 DECL_INITIAL (decl) = value;
10210 if (context && context == current_class_type)
10211 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
10212 on the TYPE_FIELDS list for `S'. (That's so that you can say
10213 things like `S::i' later.) */
10214 finish_member_declaration (decl);
10218 /* Add this enumeration constant to the list for this type. */
10219 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
10223 /* We're defining DECL. Make sure that it's type is OK. */
10226 check_function_type (tree decl, tree current_function_parms)
10228 tree fntype = TREE_TYPE (decl);
10229 tree return_type = complete_type (TREE_TYPE (fntype));
10231 /* In a function definition, arg types must be complete. */
10232 require_complete_types_for_parms (current_function_parms);
10234 if (dependent_type_p (return_type))
10236 if (!COMPLETE_OR_VOID_TYPE_P (return_type))
10238 tree args = TYPE_ARG_TYPES (fntype);
10240 error ("return type %q#T is incomplete", return_type);
10242 /* Make it return void instead. */
10243 if (TREE_CODE (fntype) == METHOD_TYPE)
10244 fntype = build_method_type_directly (TREE_TYPE (TREE_VALUE (args)),
10246 TREE_CHAIN (args));
10248 fntype = build_function_type (void_type_node, args);
10250 = build_exception_variant (fntype,
10251 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)));
10254 abstract_virtuals_error (decl, TREE_TYPE (fntype));
10257 /* Create the FUNCTION_DECL for a function definition.
10258 DECLSPECS and DECLARATOR are the parts of the declaration;
10259 they describe the function's name and the type it returns,
10260 but twisted together in a fashion that parallels the syntax of C.
10262 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
10263 DECLARATOR is really the DECL for the function we are about to
10264 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
10265 indicating that the function is an inline defined in-class.
10267 This function creates a binding context for the function body
10268 as well as setting up the FUNCTION_DECL in current_function_decl.
10270 For C++, we must first check whether that datum makes any sense.
10271 For example, "class A local_a(1,2);" means that variable local_a
10272 is an aggregate of type A, which should have a constructor
10273 applied to it with the argument list [1, 2]. */
10276 start_preparsed_function (tree decl1, tree attrs, int flags)
10278 tree ctype = NULL_TREE;
10281 int doing_friend = 0;
10282 struct cp_binding_level *bl;
10283 tree current_function_parms;
10284 struct c_fileinfo *finfo
10285 = get_fileinfo (lbasename (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1))));
10286 bool honor_interface;
10288 /* Sanity check. */
10289 gcc_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE);
10290 gcc_assert (TREE_CHAIN (void_list_node) == NULL_TREE);
10292 fntype = TREE_TYPE (decl1);
10293 if (TREE_CODE (fntype) == METHOD_TYPE)
10294 ctype = TYPE_METHOD_BASETYPE (fntype);
10296 /* ISO C++ 11.4/5. A friend function defined in a class is in
10297 the (lexical) scope of the class in which it is defined. */
10298 if (!ctype && DECL_FRIEND_P (decl1))
10300 ctype = DECL_FRIEND_CONTEXT (decl1);
10302 /* CTYPE could be null here if we're dealing with a template;
10303 for example, `inline friend float foo()' inside a template
10304 will have no CTYPE set. */
10305 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
10311 if (DECL_DECLARED_INLINE_P (decl1)
10312 && lookup_attribute ("noinline", attrs))
10313 warning (0, "inline function %q+D given attribute noinline", decl1);
10315 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
10316 /* This is a constructor, we must ensure that any default args
10317 introduced by this definition are propagated to the clones
10318 now. The clones are used directly in overload resolution. */
10319 adjust_clone_args (decl1);
10321 /* Sometimes we don't notice that a function is a static member, and
10322 build a METHOD_TYPE for it. Fix that up now. */
10323 if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
10324 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
10326 revert_static_member_fn (decl1);
10330 /* Set up current_class_type, and enter the scope of the class, if
10333 push_nested_class (ctype);
10334 else if (DECL_STATIC_FUNCTION_P (decl1))
10335 push_nested_class (DECL_CONTEXT (decl1));
10337 /* Now that we have entered the scope of the class, we must restore
10338 the bindings for any template parameters surrounding DECL1, if it
10339 is an inline member template. (Order is important; consider the
10340 case where a template parameter has the same name as a field of
10341 the class.) It is not until after this point that
10342 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
10343 if (flags & SF_INCLASS_INLINE)
10344 maybe_begin_member_template_processing (decl1);
10346 /* Effective C++ rule 15. */
10348 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
10349 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
10350 warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");
10352 /* Make the init_value nonzero so pushdecl knows this is not tentative.
10353 error_mark_node is replaced below (in poplevel) with the BLOCK. */
10354 if (!DECL_INITIAL (decl1))
10355 DECL_INITIAL (decl1) = error_mark_node;
10357 /* This function exists in static storage.
10358 (This does not mean `static' in the C sense!) */
10359 TREE_STATIC (decl1) = 1;
10361 /* We must call push_template_decl after current_class_type is set
10362 up. (If we are processing inline definitions after exiting a
10363 class scope, current_class_type will be NULL_TREE until set above
10364 by push_nested_class.) */
10365 if (processing_template_decl)
10367 /* FIXME: Handle error_mark_node more gracefully. */
10368 tree newdecl1 = push_template_decl (decl1);
10369 if (newdecl1 != error_mark_node)
10373 /* We are now in the scope of the function being defined. */
10374 current_function_decl = decl1;
10376 /* Save the parm names or decls from this function's declarator
10377 where store_parm_decls will find them. */
10378 current_function_parms = DECL_ARGUMENTS (decl1);
10380 /* Make sure the parameter and return types are reasonable. When
10381 you declare a function, these types can be incomplete, but they
10382 must be complete when you define the function. */
10383 check_function_type (decl1, current_function_parms);
10384 /* Make sure no default arg is missing. */
10385 check_default_args (decl1);
10387 /* Build the return declaration for the function. */
10388 restype = TREE_TYPE (fntype);
10389 /* Promote the value to int before returning it. */
10390 if (c_promoting_integer_type_p (restype))
10391 restype = type_promotes_to (restype);
10392 if (DECL_RESULT (decl1) == NULL_TREE)
10396 resdecl = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
10397 DECL_ARTIFICIAL (resdecl) = 1;
10398 DECL_IGNORED_P (resdecl) = 1;
10399 DECL_RESULT (decl1) = resdecl;
10401 cp_apply_type_quals_to_decl (cp_type_quals (restype), resdecl);
10404 /* Initialize RTL machinery. We cannot do this until
10405 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
10406 even when processing a template; this is how we get
10407 CFUN set up, and our per-function variables initialized.
10408 FIXME factor out the non-RTL stuff. */
10409 bl = current_binding_level;
10410 allocate_struct_function (decl1);
10411 current_binding_level = bl;
10413 /* Even though we're inside a function body, we still don't want to
10414 call expand_expr to calculate the size of a variable-sized array.
10415 We haven't necessarily assigned RTL to all variables yet, so it's
10416 not safe to try to expand expressions involving them. */
10417 cfun->x_dont_save_pending_sizes_p = 1;
10419 /* Start the statement-tree, start the tree now. */
10420 DECL_SAVED_TREE (decl1) = push_stmt_list ();
10422 /* Let the user know we're compiling this function. */
10423 announce_function (decl1);
10425 /* Record the decl so that the function name is defined.
10426 If we already have a decl for this name, and it is a FUNCTION_DECL,
10427 use the old decl. */
10428 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
10430 /* A specialization is not used to guide overload resolution. */
10431 if (!DECL_FUNCTION_MEMBER_P (decl1)
10432 && !(DECL_USE_TEMPLATE (decl1) &&
10433 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1))))
10435 tree olddecl = pushdecl (decl1);
10437 if (olddecl == error_mark_node)
10438 /* If something went wrong when registering the declaration,
10439 use DECL1; we have to have a FUNCTION_DECL to use when
10440 parsing the body of the function. */
10443 /* Otherwise, OLDDECL is either a previous declaration of
10444 the same function or DECL1 itself. */
10449 /* We need to set the DECL_CONTEXT. */
10450 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
10451 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
10453 fntype = TREE_TYPE (decl1);
10455 /* If #pragma weak applies, mark the decl appropriately now.
10456 The pragma only applies to global functions. Because
10457 determining whether or not the #pragma applies involves
10458 computing the mangled name for the declaration, we cannot
10459 apply the pragma until after we have merged this declaration
10460 with any previous declarations; if the original declaration
10461 has a linkage specification, that specification applies to
10462 the definition as well, and may affect the mangled name. */
10463 if (!DECL_CONTEXT (decl1))
10464 maybe_apply_pragma_weak (decl1);
10467 /* Reset these in case the call to pushdecl changed them. */
10468 current_function_decl = decl1;
10469 cfun->decl = decl1;
10471 /* If we are (erroneously) defining a function that we have already
10472 defined before, wipe out what we knew before. */
10473 if (!DECL_PENDING_INLINE_P (decl1))
10474 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
10476 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
10478 /* We know that this was set up by `grokclassfn'. We do not
10479 wait until `store_parm_decls', since evil parse errors may
10480 never get us to that point. Here we keep the consistency
10481 between `current_class_type' and `current_class_ptr'. */
10482 tree t = DECL_ARGUMENTS (decl1);
10484 gcc_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL);
10485 gcc_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE);
10487 cp_function_chain->x_current_class_ref
10488 = build_indirect_ref (t, NULL);
10489 cp_function_chain->x_current_class_ptr = t;
10491 /* Constructors and destructors need to know whether they're "in
10492 charge" of initializing virtual base classes. */
10493 t = TREE_CHAIN (t);
10494 if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
10496 current_in_charge_parm = t;
10497 t = TREE_CHAIN (t);
10499 if (DECL_HAS_VTT_PARM_P (decl1))
10501 gcc_assert (DECL_NAME (t) == vtt_parm_identifier);
10502 current_vtt_parm = t;
10506 honor_interface = (!DECL_TEMPLATE_INSTANTIATION (decl1)
10507 /* Implicitly-defined methods (like the
10508 destructor for a class in which no destructor
10509 is explicitly declared) must not be defined
10510 until their definition is needed. So, we
10511 ignore interface specifications for
10512 compiler-generated functions. */
10513 && !DECL_ARTIFICIAL (decl1));
10515 if (DECL_INTERFACE_KNOWN (decl1))
10517 tree ctx = decl_function_context (decl1);
10519 if (DECL_NOT_REALLY_EXTERN (decl1))
10520 DECL_EXTERNAL (decl1) = 0;
10522 if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
10523 && TREE_PUBLIC (ctx))
10524 /* This is a function in a local class in an extern inline
10526 comdat_linkage (decl1);
10528 /* If this function belongs to an interface, it is public.
10529 If it belongs to someone else's interface, it is also external.
10530 This only affects inlines and template instantiations. */
10531 else if (!finfo->interface_unknown && honor_interface)
10533 if (DECL_DECLARED_INLINE_P (decl1)
10534 || DECL_TEMPLATE_INSTANTIATION (decl1)
10535 || processing_template_decl)
10537 DECL_EXTERNAL (decl1)
10538 = (finfo->interface_only
10539 || (DECL_DECLARED_INLINE_P (decl1)
10540 && ! flag_implement_inlines
10541 && !DECL_VINDEX (decl1)));
10543 /* For WIN32 we also want to put these in linkonce sections. */
10544 maybe_make_one_only (decl1);
10547 DECL_EXTERNAL (decl1) = 0;
10548 DECL_INTERFACE_KNOWN (decl1) = 1;
10549 /* If this function is in an interface implemented in this file,
10550 make sure that the backend knows to emit this function
10552 if (!DECL_EXTERNAL (decl1))
10553 mark_needed (decl1);
10555 else if (finfo->interface_unknown && finfo->interface_only
10556 && honor_interface)
10558 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
10559 interface, we will have both finfo->interface_unknown and
10560 finfo->interface_only set. In that case, we don't want to
10561 use the normal heuristics because someone will supply a
10562 #pragma implementation elsewhere, and deducing it here would
10563 produce a conflict. */
10564 comdat_linkage (decl1);
10565 DECL_EXTERNAL (decl1) = 0;
10566 DECL_INTERFACE_KNOWN (decl1) = 1;
10567 DECL_DEFER_OUTPUT (decl1) = 1;
10571 /* This is a definition, not a reference.
10572 So clear DECL_EXTERNAL. */
10573 DECL_EXTERNAL (decl1) = 0;
10575 if ((DECL_DECLARED_INLINE_P (decl1)
10576 || DECL_TEMPLATE_INSTANTIATION (decl1))
10577 && ! DECL_INTERFACE_KNOWN (decl1)
10578 /* Don't try to defer nested functions for now. */
10579 && ! decl_function_context (decl1))
10580 DECL_DEFER_OUTPUT (decl1) = 1;
10582 DECL_INTERFACE_KNOWN (decl1) = 1;
10585 /* Determine the ELF visibility attribute for the function. We must not
10586 do this before calling "pushdecl", as we must allow "duplicate_decls"
10587 to merge any attributes appropriately. We also need to wait until
10589 if (!DECL_CLONED_FUNCTION_P (decl1))
10590 determine_visibility (decl1);
10592 begin_scope (sk_function_parms, decl1);
10596 if (DECL_DESTRUCTOR_P (decl1)
10597 || (DECL_CONSTRUCTOR_P (decl1)
10598 && targetm.cxx.cdtor_returns_this ()))
10600 cdtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
10601 DECL_CONTEXT (cdtor_label) = current_function_decl;
10604 start_fname_decls ();
10606 store_parm_decls (current_function_parms);
10610 /* Like start_preparsed_function, except that instead of a
10611 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
10613 Returns 1 on success. If the DECLARATOR is not suitable for a function
10614 (it defines a datum instead), we return 0, which tells
10615 yyparse to report a parse error. */
10618 start_function (cp_decl_specifier_seq *declspecs,
10619 const cp_declarator *declarator,
10624 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
10625 /* If the declarator is not suitable for a function definition,
10626 cause a syntax error. */
10627 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
10630 if (DECL_MAIN_P (decl1))
10631 /* main must return int. grokfndecl should have corrected it
10632 (and issued a diagnostic) if the user got it wrong. */
10633 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1)),
10634 integer_type_node));
10636 start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT);
10641 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
10645 use_eh_spec_block (tree fn)
10647 return (flag_exceptions && flag_enforce_eh_specs
10648 && !processing_template_decl
10649 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn))
10650 /* We insert the EH_SPEC_BLOCK only in the original
10651 function; then, it is copied automatically to the
10653 && !DECL_CLONED_FUNCTION_P (fn)
10654 /* Implicitly-generated constructors and destructors have
10655 exception specifications. However, those specifications
10656 are the union of the possible exceptions specified by the
10657 constructors/destructors for bases and members, so no
10658 unallowed exception will ever reach this function. By
10659 not creating the EH_SPEC_BLOCK we save a little memory,
10660 and we avoid spurious warnings about unreachable
10662 && !DECL_ARTIFICIAL (fn));
10665 /* Store the parameter declarations into the current function declaration.
10666 This is called after parsing the parameter declarations, before
10667 digesting the body of the function.
10669 Also install to binding contour return value identifier, if any. */
10672 store_parm_decls (tree current_function_parms)
10674 tree fndecl = current_function_decl;
10677 /* This is a chain of any other decls that came in among the parm
10678 declarations. If a parm is declared with enum {foo, bar} x;
10679 then CONST_DECLs for foo and bar are put here. */
10680 tree nonparms = NULL_TREE;
10682 if (current_function_parms)
10684 /* This case is when the function was defined with an ANSI prototype.
10685 The parms already have decls, so we need not do anything here
10686 except record them as in effect
10687 and complain if any redundant old-style parm decls were written. */
10689 tree specparms = current_function_parms;
10692 /* Must clear this because it might contain TYPE_DECLs declared
10694 current_binding_level->names = NULL;
10696 /* If we're doing semantic analysis, then we'll call pushdecl
10697 for each of these. We must do them in reverse order so that
10698 they end in the correct forward order. */
10699 specparms = nreverse (specparms);
10701 for (parm = specparms; parm; parm = next)
10703 next = TREE_CHAIN (parm);
10704 if (TREE_CODE (parm) == PARM_DECL)
10706 if (DECL_NAME (parm) == NULL_TREE
10707 || TREE_CODE (parm) != VOID_TYPE)
10710 error ("parameter %qD declared void", parm);
10714 /* If we find an enum constant or a type tag,
10715 put it aside for the moment. */
10716 TREE_CHAIN (parm) = NULL_TREE;
10717 nonparms = chainon (nonparms, parm);
10721 /* Get the decls in their original chain order and record in the
10722 function. This is all and only the PARM_DECLs that were
10723 pushed into scope by the loop above. */
10724 DECL_ARGUMENTS (fndecl) = getdecls ();
10727 DECL_ARGUMENTS (fndecl) = NULL_TREE;
10729 /* Now store the final chain of decls for the arguments
10730 as the decl-chain of the current lexical scope.
10731 Put the enumerators in as well, at the front so that
10732 DECL_ARGUMENTS is not modified. */
10733 current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));
10735 if (use_eh_spec_block (current_function_decl))
10736 current_eh_spec_block = begin_eh_spec_block ();
10740 /* We have finished doing semantic analysis on DECL, but have not yet
10741 generated RTL for its body. Save away our current state, so that
10742 when we want to generate RTL later we know what to do. */
10745 save_function_data (tree decl)
10747 struct language_function *f;
10749 /* Save the language-specific per-function data so that we can
10750 get it back when we really expand this function. */
10751 gcc_assert (!DECL_PENDING_INLINE_P (decl));
10754 f = GGC_NEW (struct language_function);
10755 memcpy (f, cp_function_chain, sizeof (struct language_function));
10756 DECL_SAVED_FUNCTION_DATA (decl) = f;
10758 /* Clear out the bits we don't need. */
10759 f->base.x_stmt_tree.x_cur_stmt_list = NULL_TREE;
10760 f->bindings = NULL;
10761 f->x_local_names = NULL;
10765 /* Set the return value of the constructor (if present). */
10768 finish_constructor_body (void)
10773 if (targetm.cxx.cdtor_returns_this ())
10775 /* Any return from a constructor will end up here. */
10776 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
10778 val = DECL_ARGUMENTS (current_function_decl);
10779 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
10780 DECL_RESULT (current_function_decl), val);
10781 /* Return the address of the object. */
10782 exprstmt = build_stmt (RETURN_EXPR, val);
10783 add_stmt (exprstmt);
10787 /* Do all the processing for the beginning of a destructor; set up the
10788 vtable pointers and cleanups for bases and members. */
10791 begin_destructor_body (void)
10793 tree compound_stmt;
10795 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
10796 issued an error message. We still want to try to process the
10797 body of the function, but initialize_vtbl_ptrs will crash if
10798 TYPE_BINFO is NULL. */
10799 if (COMPLETE_TYPE_P (current_class_type))
10801 compound_stmt = begin_compound_stmt (0);
10802 /* Make all virtual function table pointers in non-virtual base
10803 classes point to CURRENT_CLASS_TYPE's virtual function
10805 initialize_vtbl_ptrs (current_class_ptr);
10806 finish_compound_stmt (compound_stmt);
10808 /* And insert cleanups for our bases and members so that they
10809 will be properly destroyed if we throw. */
10810 push_base_cleanups ();
10814 /* At the end of every destructor we generate code to delete the object if
10815 necessary. Do that now. */
10818 finish_destructor_body (void)
10822 /* Any return from a destructor will end up here; that way all base
10823 and member cleanups will be run when the function returns. */
10824 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
10826 /* In a virtual destructor, we must call delete. */
10827 if (DECL_VIRTUAL_P (current_function_decl))
10830 tree virtual_size = cxx_sizeof (current_class_type);
10834 At the point of definition of a virtual destructor (including
10835 an implicit definition), non-placement operator delete shall
10836 be looked up in the scope of the destructor's class and if
10837 found shall be accessible and unambiguous. */
10838 exprstmt = build_op_delete_call(DELETE_EXPR, current_class_ptr,
10840 /*global_p=*/false,
10841 /*placement=*/NULL_TREE,
10842 /*alloc_fn=*/NULL_TREE);
10844 if_stmt = begin_if_stmt ();
10845 finish_if_stmt_cond (build2 (BIT_AND_EXPR, integer_type_node,
10846 current_in_charge_parm,
10849 finish_expr_stmt (exprstmt);
10850 finish_then_clause (if_stmt);
10851 finish_if_stmt (if_stmt);
10854 if (targetm.cxx.cdtor_returns_this ())
10858 val = DECL_ARGUMENTS (current_function_decl);
10859 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
10860 DECL_RESULT (current_function_decl), val);
10861 /* Return the address of the object. */
10862 exprstmt = build_stmt (RETURN_EXPR, val);
10863 add_stmt (exprstmt);
10867 /* Do the necessary processing for the beginning of a function body, which
10868 in this case includes member-initializers, but not the catch clauses of
10869 a function-try-block. Currently, this means opening a binding level
10870 for the member-initializers (in a ctor) and member cleanups (in a dtor). */
10873 begin_function_body (void)
10877 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
10880 if (processing_template_decl)
10881 /* Do nothing now. */;
10883 /* Always keep the BLOCK node associated with the outermost pair of
10884 curly braces of a function. These are needed for correct
10885 operation of dwarfout.c. */
10886 keep_next_level (true);
10888 stmt = begin_compound_stmt (BCS_FN_BODY);
10890 if (processing_template_decl)
10891 /* Do nothing now. */;
10892 else if (DECL_DESTRUCTOR_P (current_function_decl))
10893 begin_destructor_body ();
10898 /* Do the processing for the end of a function body. Currently, this means
10899 closing out the cleanups for fully-constructed bases and members, and in
10900 the case of the destructor, deleting the object if desired. Again, this
10901 is only meaningful for [cd]tors, since they are the only functions where
10902 there is a significant distinction between the main body and any
10903 function catch clauses. Handling, say, main() return semantics here
10904 would be wrong, as flowing off the end of a function catch clause for
10905 main() would also need to return 0. */
10908 finish_function_body (tree compstmt)
10910 if (compstmt == NULL_TREE)
10913 /* Close the block. */
10914 finish_compound_stmt (compstmt);
10916 if (processing_template_decl)
10917 /* Do nothing now. */;
10918 else if (DECL_CONSTRUCTOR_P (current_function_decl))
10919 finish_constructor_body ();
10920 else if (DECL_DESTRUCTOR_P (current_function_decl))
10921 finish_destructor_body ();
10924 /* Given a function, returns the BLOCK corresponding to the outermost level
10925 of curly braces, skipping the artificial block created for constructor
10929 outer_curly_brace_block (tree fndecl)
10931 tree block = BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl));
10932 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
10933 /* Skip the artificial function body block. */
10934 block = BLOCK_SUBBLOCKS (block);
10938 /* Finish up a function declaration and compile that function
10939 all the way to assembler language output. The free the storage
10940 for the function definition.
10942 FLAGS is a bitwise or of the following values:
10944 We just finished processing the body of an in-class inline
10945 function definition. (This processing will have taken place
10946 after the class definition is complete.) */
10949 finish_function (int flags)
10951 tree fndecl = current_function_decl;
10952 tree fntype, ctype = NULL_TREE;
10953 int inclass_inline = (flags & 2) != 0;
10956 /* When we get some parse errors, we can end up without a
10957 current_function_decl, so cope. */
10958 if (fndecl == NULL_TREE)
10959 return error_mark_node;
10961 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
10962 && DECL_VIRTUAL_P (fndecl)
10963 && !processing_template_decl)
10965 tree fnclass = DECL_CONTEXT (fndecl);
10966 if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
10967 keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
10970 nested = function_depth > 1;
10971 fntype = TREE_TYPE (fndecl);
10973 /* TREE_READONLY (fndecl) = 1;
10974 This caused &foo to be of type ptr-to-const-function
10975 which then got a warning when stored in a ptr-to-function variable. */
10977 gcc_assert (building_stmt_tree ());
10979 /* For a cloned function, we've already got all the code we need;
10980 there's no need to add any extra bits. */
10981 if (!DECL_CLONED_FUNCTION_P (fndecl))
10983 if (DECL_MAIN_P (current_function_decl))
10987 /* Make it so that `main' always returns 0 by default (or
10990 stmt = finish_return_stmt (integer_one_node);
10992 stmt = finish_return_stmt (integer_zero_node);
10994 /* Hack. We don't want the middle-end to warn that this
10995 return is unreachable, so put the statement on the
10997 #ifdef USE_MAPPED_LOCATION
10998 SET_EXPR_LOCATION (stmt, UNKNOWN_LOCATION);
11000 annotate_with_file_line (stmt, input_filename, 0);
11004 if (use_eh_spec_block (current_function_decl))
11005 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
11006 (TREE_TYPE (current_function_decl)),
11007 current_eh_spec_block);
11010 /* If we're saving up tree structure, tie off the function now. */
11011 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
11013 finish_fname_decls ();
11015 /* If this function can't throw any exceptions, remember that. */
11016 if (!processing_template_decl
11017 && !cp_function_chain->can_throw
11018 && !flag_non_call_exceptions)
11019 TREE_NOTHROW (fndecl) = 1;
11021 /* This must come after expand_function_end because cleanups might
11022 have declarations (from inline functions) that need to go into
11023 this function's blocks. */
11025 /* If the current binding level isn't the outermost binding level
11026 for this function, either there is a bug, or we have experienced
11027 syntax errors and the statement tree is malformed. */
11028 if (current_binding_level->kind != sk_function_parms)
11030 /* Make sure we have already experienced errors. */
11031 gcc_assert (errorcount);
11033 /* Throw away the broken statement tree and extra binding
11035 DECL_SAVED_TREE (fndecl) = alloc_stmt_list ();
11037 while (current_binding_level->kind != sk_function_parms)
11039 if (current_binding_level->kind == sk_class)
11040 pop_nested_class ();
11042 poplevel (0, 0, 0);
11045 poplevel (1, 0, 1);
11047 /* Statements should always be full-expressions at the outermost set
11048 of curly braces for a function. */
11049 gcc_assert (stmts_are_full_exprs_p ());
11051 /* Set up the named return value optimization, if we can. Candidate
11052 variables are selected in check_return_value. */
11053 if (current_function_return_value)
11055 tree r = current_function_return_value;
11058 if (r != error_mark_node
11059 /* This is only worth doing for fns that return in memory--and
11060 simpler, since we don't have to worry about promoted modes. */
11061 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
11062 /* Only allow this for variables declared in the outer scope of
11063 the function so we know that their lifetime always ends with a
11064 return; see g++.dg/opt/nrv6.C. We could be more flexible if
11065 we were to do this optimization in tree-ssa. */
11066 && (outer = outer_curly_brace_block (fndecl))
11067 && chain_member (r, BLOCK_VARS (outer)))
11068 finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));
11070 current_function_return_value = NULL_TREE;
11073 /* Remember that we were in class scope. */
11074 if (current_class_name)
11075 ctype = current_class_type;
11077 /* Must mark the RESULT_DECL as being in this function. */
11078 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
11080 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
11081 to the FUNCTION_DECL node itself. */
11082 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
11084 /* Save away current state, if appropriate. */
11085 if (!processing_template_decl)
11086 save_function_data (fndecl);
11088 /* Complain if there's just no return statement. */
11089 if (warn_return_type
11090 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
11091 && !dependent_type_p (TREE_TYPE (fntype))
11092 && !current_function_returns_value && !current_function_returns_null
11093 /* Don't complain if we abort or throw. */
11094 && !current_function_returns_abnormally
11095 && !DECL_NAME (DECL_RESULT (fndecl))
11096 /* Normally, with -Wreturn-type, flow will complain. Unless we're an
11097 inline function, as we might never be compiled separately. */
11098 && (DECL_INLINE (fndecl) || processing_template_decl)
11099 /* Structor return values (if any) are set by the compiler. */
11100 && !DECL_CONSTRUCTOR_P (fndecl)
11101 && !DECL_DESTRUCTOR_P (fndecl))
11102 warning (OPT_Wreturn_type, "no return statement in function returning non-void");
11104 /* Store the end of the function, so that we get good line number
11105 info for the epilogue. */
11106 cfun->function_end_locus = input_location;
11108 /* Genericize before inlining. */
11109 if (!processing_template_decl)
11111 struct language_function *f = DECL_SAVED_FUNCTION_DATA (fndecl);
11112 cp_genericize (fndecl);
11113 /* Clear out the bits we don't need. */
11114 f->x_current_class_ptr = NULL;
11115 f->x_current_class_ref = NULL;
11116 f->x_eh_spec_block = NULL;
11117 f->x_in_charge_parm = NULL;
11118 f->x_vtt_parm = NULL;
11119 f->x_return_value = NULL;
11120 f->bindings = NULL;
11121 f->extern_decl_map = NULL;
11123 /* Handle attribute((warn_unused_result)). Relies on gimple input. */
11124 c_warn_unused_result (&DECL_SAVED_TREE (fndecl));
11126 /* Clear out the bits we don't need. */
11127 local_names = NULL;
11129 /* We're leaving the context of this function, so zap cfun. It's still in
11130 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
11132 current_function_decl = NULL;
11134 /* If this is an in-class inline definition, we may have to pop the
11135 bindings for the template parameters that we added in
11136 maybe_begin_member_template_processing when start_function was
11138 if (inclass_inline)
11139 maybe_end_member_template_processing ();
11141 /* Leave the scope of the class. */
11143 pop_nested_class ();
11149 /* Let the error reporting routines know that we're outside a
11150 function. For a nested function, this value is used in
11151 cxx_pop_function_context and then reset via pop_function_context. */
11152 current_function_decl = NULL_TREE;
11157 /* Create the FUNCTION_DECL for a function definition.
11158 DECLSPECS and DECLARATOR are the parts of the declaration;
11159 they describe the return type and the name of the function,
11160 but twisted together in a fashion that parallels the syntax of C.
11162 This function creates a binding context for the function body
11163 as well as setting up the FUNCTION_DECL in current_function_decl.
11165 Returns a FUNCTION_DECL on success.
11167 If the DECLARATOR is not suitable for a function (it defines a datum
11168 instead), we return 0, which tells yyparse to report a parse error.
11170 May return void_type_node indicating that this method is actually
11171 a friend. See grokfield for more details.
11173 Came here with a `.pushlevel' .
11175 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
11176 CHANGES TO CODE IN `grokfield'. */
11179 start_method (cp_decl_specifier_seq *declspecs,
11180 const cp_declarator *declarator, tree attrlist)
11182 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
11185 if (fndecl == error_mark_node)
11186 return error_mark_node;
11188 if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
11190 error ("invalid member function declaration");
11191 return error_mark_node;
11195 cplus_decl_attributes (&fndecl, attrlist, 0);
11197 /* Pass friends other than inline friend functions back. */
11198 if (fndecl == void_type_node)
11201 if (DECL_IN_AGGR_P (fndecl))
11203 if (DECL_CONTEXT (fndecl)
11204 && TREE_CODE (DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
11205 error ("%qD is already defined in class %qT", fndecl,
11206 DECL_CONTEXT (fndecl));
11207 return error_mark_node;
11210 check_template_shadow (fndecl);
11212 DECL_DECLARED_INLINE_P (fndecl) = 1;
11213 if (flag_default_inline)
11214 DECL_INLINE (fndecl) = 1;
11216 /* We process method specializations in finish_struct_1. */
11217 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
11219 fndecl = push_template_decl (fndecl);
11220 if (fndecl == error_mark_node)
11224 if (! DECL_FRIEND_P (fndecl))
11226 if (TREE_CHAIN (fndecl))
11228 fndecl = copy_node (fndecl);
11229 TREE_CHAIN (fndecl) = NULL_TREE;
11233 finish_decl (fndecl, NULL_TREE, NULL_TREE);
11235 /* Make a place for the parms. */
11236 begin_scope (sk_function_parms, fndecl);
11238 DECL_IN_AGGR_P (fndecl) = 1;
11242 /* Go through the motions of finishing a function definition.
11243 We don't compile this method until after the whole class has
11246 FINISH_METHOD must return something that looks as though it
11247 came from GROKFIELD (since we are defining a method, after all).
11249 This is called after parsing the body of the function definition.
11250 STMTS is the chain of statements that makes up the function body.
11252 DECL is the ..._DECL that `start_method' provided. */
11255 finish_method (tree decl)
11257 tree fndecl = decl;
11262 if (decl == void_type_node)
11265 old_initial = DECL_INITIAL (fndecl);
11267 /* Undo the level for the parms (from start_method).
11268 This is like poplevel, but it causes nothing to be
11269 saved. Saving information here confuses symbol-table
11270 output routines. Besides, this information will
11271 be correctly output when this method is actually
11274 /* Clear out the meanings of the local variables of this level;
11275 also record in each decl which block it belongs to. */
11277 for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
11279 if (DECL_NAME (link) != NULL_TREE)
11280 pop_binding (DECL_NAME (link), link);
11281 gcc_assert (TREE_CODE (link) != FUNCTION_DECL);
11282 DECL_CONTEXT (link) = NULL_TREE;
11285 poplevel (0, 0, 0);
11287 DECL_INITIAL (fndecl) = old_initial;
11289 /* We used to check if the context of FNDECL was different from
11290 current_class_type as another way to get inside here. This didn't work
11291 for String.cc in libg++. */
11292 if (DECL_FRIEND_P (fndecl))
11294 VEC_safe_push (tree, gc, CLASSTYPE_INLINE_FRIENDS (current_class_type),
11296 decl = void_type_node;
11303 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
11304 we can lay it out later, when and if its type becomes complete. */
11307 maybe_register_incomplete_var (tree var)
11309 gcc_assert (TREE_CODE (var) == VAR_DECL);
11311 /* Keep track of variables with incomplete types. */
11312 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
11313 && DECL_EXTERNAL (var))
11315 tree inner_type = TREE_TYPE (var);
11317 while (TREE_CODE (inner_type) == ARRAY_TYPE)
11318 inner_type = TREE_TYPE (inner_type);
11319 inner_type = TYPE_MAIN_VARIANT (inner_type);
11321 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
11322 /* RTTI TD entries are created while defining the type_info. */
11323 || (TYPE_LANG_SPECIFIC (inner_type)
11324 && TYPE_BEING_DEFINED (inner_type)))
11325 incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
11329 /* Called when a class type (given by TYPE) is defined. If there are
11330 any existing VAR_DECLs whose type hsa been completed by this
11331 declaration, update them now. */
11334 complete_vars (tree type)
11336 tree *list = &incomplete_vars;
11338 gcc_assert (CLASS_TYPE_P (type));
11341 if (same_type_p (type, TREE_PURPOSE (*list)))
11343 tree var = TREE_VALUE (*list);
11344 tree type = TREE_TYPE (var);
11345 /* Complete the type of the variable. The VAR_DECL itself
11346 will be laid out in expand_expr. */
11347 complete_type (type);
11348 cp_apply_type_quals_to_decl (cp_type_quals (type), var);
11349 /* Remove this entry from the list. */
11350 *list = TREE_CHAIN (*list);
11353 list = &TREE_CHAIN (*list);
11356 /* Check for pending declarations which may have abstract type. */
11357 complete_type_check_abstract (type);
11360 /* If DECL is of a type which needs a cleanup, build that cleanup
11364 cxx_maybe_build_cleanup (tree decl)
11366 tree type = TREE_TYPE (decl);
11368 if (type != error_mark_node && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
11370 int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
11372 bool has_vbases = (TREE_CODE (type) == RECORD_TYPE
11373 && CLASSTYPE_VBASECLASSES (type));
11375 if (TREE_CODE (type) == ARRAY_TYPE)
11379 cxx_mark_addressable (decl);
11380 rval = build_unary_op (ADDR_EXPR, decl, 0);
11383 /* Optimize for space over speed here. */
11384 if (!has_vbases || flag_expensive_optimizations)
11385 flags |= LOOKUP_NONVIRTUAL;
11387 rval = build_delete (TREE_TYPE (rval), rval,
11388 sfk_complete_destructor, flags, 0);
11395 /* When a stmt has been parsed, this function is called. */
11402 /* DECL was originally constructed as a non-static member function,
11403 but turned out to be static. Update it accordingly. */
11406 revert_static_member_fn (tree decl)
11409 tree function = TREE_TYPE (decl);
11410 tree args = TYPE_ARG_TYPES (function);
11412 if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
11413 != TYPE_UNQUALIFIED)
11414 error ("static member function %q#D declared with type qualifiers", decl);
11416 args = TREE_CHAIN (args);
11417 tmp = build_function_type (TREE_TYPE (function), args);
11418 tmp = build_qualified_type (tmp, cp_type_quals (function));
11419 tmp = build_exception_variant (tmp,
11420 TYPE_RAISES_EXCEPTIONS (function));
11421 TREE_TYPE (decl) = tmp;
11422 if (DECL_ARGUMENTS (decl))
11423 DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
11424 DECL_STATIC_FUNCTION_P (decl) = 1;
11427 /* Initialize the variables used during compilation of a C++
11431 cxx_push_function_context (struct function * f)
11433 struct language_function *p = GGC_CNEW (struct language_function);
11436 /* Whenever we start a new function, we destroy temporaries in the
11438 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
11444 if (DECL_SAVED_FUNCTION_DATA (fn))
11446 /* If we already parsed this function, and we're just expanding it
11447 now, restore saved state. */
11448 *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (fn);
11450 /* We don't need the saved data anymore. Unless this is an inline
11451 function; we need the named return value info for
11452 declare_return_variable. */
11453 if (! DECL_INLINE (fn))
11454 DECL_SAVED_FUNCTION_DATA (fn) = NULL;
11459 /* Free the language-specific parts of F, now that we've finished
11460 compiling the function. */
11463 cxx_pop_function_context (struct function * f)
11468 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
11469 one of the language-independent trees. */
11471 enum cp_tree_node_structure_enum
11472 cp_tree_node_structure (union lang_tree_node * t)
11474 switch (TREE_CODE (&t->generic))
11476 case DEFAULT_ARG: return TS_CP_DEFAULT_ARG;
11477 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER;
11478 case OVERLOAD: return TS_CP_OVERLOAD;
11479 case TEMPLATE_PARM_INDEX: return TS_CP_TPI;
11480 case TINST_LEVEL: return TS_CP_TINST_LEVEL;
11481 case PTRMEM_CST: return TS_CP_PTRMEM;
11482 case BASELINK: return TS_CP_BASELINK;
11483 default: return TS_CP_GENERIC;
11487 /* Build the void_list_node (void_type_node having been created). */
11489 build_void_list_node (void)
11491 tree t = build_tree_list (NULL_TREE, void_type_node);
11496 cp_missing_noreturn_ok_p (tree decl)
11498 /* A missing noreturn is ok for the `main' function. */
11499 return DECL_MAIN_P (decl);
11502 /* Return the COMDAT group into which DECL should be placed. */
11505 cxx_comdat_group (tree decl)
11509 /* Virtual tables, construction virtual tables, and virtual table
11510 tables all go in a single COMDAT group, named after the primary
11512 if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
11513 name = DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl)));
11514 /* For all other DECLs, the COMDAT group is the mangled name of the
11515 declaration itself. */
11518 while (DECL_THUNK_P (decl))
11520 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
11521 into the same section as the target function. In that case
11522 we must return target's name. */
11523 tree target = THUNK_TARGET (decl);
11524 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target)
11525 && DECL_SECTION_NAME (target) != NULL
11526 && DECL_ONE_ONLY (target))
11531 name = DECL_ASSEMBLER_NAME (decl);
11534 return IDENTIFIER_POINTER (name);
11537 #include "gt-cp-decl.h"