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, 2007 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 3, 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 COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
23 /* Process declarations and symbol lookup for C++ front end.
24 Also constructs types; the standard scalar types at initialization,
25 and structure, union, array and enum types when they are declared. */
27 /* ??? not all decl nodes are given the most useful possible
28 line numbers. For example, the CONST_DECLs for enum values. */
32 #include "coretypes.h"
39 #include "tree-inline.h"
49 #include "diagnostic.h"
53 #include "tree-flow.h"
54 #include "pointer-set.h"
56 static tree grokparms (cp_parameter_declarator *, tree *);
57 static const char *redeclaration_error_message (tree, tree);
59 static int decl_jump_unsafe (tree);
60 static void require_complete_types_for_parms (tree);
61 static int ambi_op_p (enum tree_code);
62 static int unary_op_p (enum tree_code);
63 static void push_local_name (tree);
64 static tree grok_reference_init (tree, tree, tree, tree *);
65 static tree grokvardecl (tree, tree, const cp_decl_specifier_seq *,
67 static void record_unknown_type (tree, const char *);
68 static tree builtin_function_1 (tree, tree);
69 static tree build_library_fn_1 (tree, enum tree_code, tree);
70 static int member_function_or_else (tree, tree, enum overload_flags);
71 static void bad_specifiers (tree, const char *, int, int, int, int,
73 static void check_for_uninitialized_const_var (tree);
74 static hashval_t typename_hash (const void *);
75 static int typename_compare (const void *, const void *);
76 static tree local_variable_p_walkfn (tree *, int *, void *);
77 static tree record_builtin_java_type (const char *, int);
78 static const char *tag_name (enum tag_types);
79 static tree lookup_and_check_tag (enum tag_types, tree, tag_scope, bool);
80 static int walk_namespaces_r (tree, walk_namespaces_fn, void *);
81 static void maybe_deduce_size_from_array_init (tree, tree);
82 static void layout_var_decl (tree);
83 static void maybe_commonize_var (tree);
84 static tree check_initializer (tree, tree, int, tree *);
85 static void make_rtl_for_nonlocal_decl (tree, tree, const char *);
86 static void save_function_data (tree);
87 static void check_function_type (tree, tree);
88 static void finish_constructor_body (void);
89 static void begin_destructor_body (void);
90 static void finish_destructor_body (void);
91 static tree create_array_type_for_decl (tree, tree, tree);
92 static tree get_atexit_node (void);
93 static tree get_dso_handle_node (void);
94 static tree start_cleanup_fn (void);
95 static void end_cleanup_fn (void);
96 static tree cp_make_fname_decl (tree, int);
97 static void initialize_predefined_identifiers (void);
98 static tree check_special_function_return_type
99 (special_function_kind, tree, tree);
100 static tree push_cp_library_fn (enum tree_code, tree);
101 static tree build_cp_library_fn (tree, enum tree_code, tree);
102 static void store_parm_decls (tree);
103 static void initialize_local_var (tree, tree);
104 static void expand_static_init (tree, tree);
105 static tree next_initializable_field (tree);
107 /* The following symbols are subsumed in the cp_global_trees array, and
108 listed here individually for documentation purposes.
111 tree wchar_decl_node;
113 tree vtable_entry_type;
114 tree delta_type_node;
115 tree __t_desc_type_node;
117 tree class_type_node;
118 tree unknown_type_node;
120 Array type `vtable_entry_type[]'
123 tree vtbl_ptr_type_node;
130 A FUNCTION_DECL which can call `abort'. Not necessarily the
131 one that the user will declare, but sufficient to be called
132 by routines that want to abort the program.
136 The FUNCTION_DECL for the default `::operator delete'.
138 tree global_delete_fndecl;
141 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
142 tree tinfo_var_id; */
144 tree cp_global_trees[CPTI_MAX];
146 /* Indicates that there is a type value in some namespace, although
147 that is not necessarily in scope at the moment. */
149 tree global_type_node;
151 /* The node that holds the "name" of the global scope. */
152 tree global_scope_name;
154 #define local_names cp_function_chain->x_local_names
156 /* A list of objects which have constructors or destructors
157 which reside in the global scope. The decl is stored in
158 the TREE_VALUE slot and the initializer is stored
159 in the TREE_PURPOSE slot. */
160 tree static_aggregates;
164 /* A node for the integer constants 2, and 3. */
166 tree integer_two_node, integer_three_node;
168 /* Used only for jumps to as-yet undefined labels, since jumps to
169 defined labels can have their validity checked immediately. */
171 struct named_label_use_entry GTY(())
173 struct named_label_use_entry *next;
174 /* The binding level to which this entry is *currently* attached.
175 This is initially the binding level in which the goto appeared,
176 but is modified as scopes are closed. */
177 struct cp_binding_level *binding_level;
178 /* The head of the names list that was current when the goto appeared,
179 or the inner scope popped. These are the decls that will *not* be
180 skipped when jumping to the label. */
182 /* The location of the goto, for error reporting. */
183 location_t o_goto_locus;
184 /* True if an OpenMP structured block scope has been closed since
185 the goto appeared. This means that the branch from the label will
186 illegally exit an OpenMP scope. */
190 /* A list of all LABEL_DECLs in the function that have names. Here so
191 we can clear out their names' definitions at the end of the
192 function, and so we can check the validity of jumps to these labels. */
194 struct named_label_entry GTY(())
196 /* The decl itself. */
199 /* The binding level to which the label is *currently* attached.
200 This is initially set to the binding level in which the label
201 is defined, but is modified as scopes are closed. */
202 struct cp_binding_level *binding_level;
203 /* The head of the names list that was current when the label was
204 defined, or the inner scope popped. These are the decls that will
205 be skipped when jumping to the label. */
207 /* A tree list of all decls from all binding levels that would be
208 crossed by a backward branch to the label. */
211 /* A list of uses of the label, before the label is defined. */
212 struct named_label_use_entry *uses;
214 /* The following bits are set after the label is defined, and are
215 updated as scopes are popped. They indicate that a backward jump
216 to the label will illegally enter a scope of the given flavor. */
222 #define named_labels cp_function_chain->x_named_labels
224 /* The number of function bodies which we are currently processing.
225 (Zero if we are at namespace scope, one inside the body of a
226 function, two inside the body of a function in a local class, etc.) */
229 /* States indicating how grokdeclarator() should handle declspecs marked
230 with __attribute__((deprecated)). An object declared as
231 __attribute__((deprecated)) suppresses warnings of uses of other
234 enum deprecated_states {
239 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
242 /* A TREE_LIST of VAR_DECLs. The TREE_PURPOSE is a RECORD_TYPE or
243 UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type. At the
244 time the VAR_DECL was declared, the type was incomplete. */
246 static GTY(()) tree incomplete_vars;
248 /* Returns the kind of template specialization we are currently
249 processing, given that it's declaration contained N_CLASS_SCOPES
250 explicit scope qualifications. */
253 current_tmpl_spec_kind (int n_class_scopes)
255 int n_template_parm_scopes = 0;
256 int seen_specialization_p = 0;
257 int innermost_specialization_p = 0;
258 struct cp_binding_level *b;
260 /* Scan through the template parameter scopes. */
261 for (b = current_binding_level;
262 b->kind == sk_template_parms;
265 /* If we see a specialization scope inside a parameter scope,
266 then something is wrong. That corresponds to a declaration
269 template <class T> template <> ...
271 which is always invalid since [temp.expl.spec] forbids the
272 specialization of a class member template if the enclosing
273 class templates are not explicitly specialized as well. */
274 if (b->explicit_spec_p)
276 if (n_template_parm_scopes == 0)
277 innermost_specialization_p = 1;
279 seen_specialization_p = 1;
281 else if (seen_specialization_p == 1)
282 return tsk_invalid_member_spec;
284 ++n_template_parm_scopes;
287 /* Handle explicit instantiations. */
288 if (processing_explicit_instantiation)
290 if (n_template_parm_scopes != 0)
291 /* We've seen a template parameter list during an explicit
292 instantiation. For example:
294 template <class T> template void f(int);
296 This is erroneous. */
297 return tsk_invalid_expl_inst;
299 return tsk_expl_inst;
302 if (n_template_parm_scopes < n_class_scopes)
303 /* We've not seen enough template headers to match all the
304 specialized classes present. For example:
306 template <class T> void R<T>::S<T>::f(int);
308 This is invalid; there needs to be one set of template
309 parameters for each class. */
310 return tsk_insufficient_parms;
311 else if (n_template_parm_scopes == n_class_scopes)
312 /* We're processing a non-template declaration (even though it may
313 be a member of a template class.) For example:
315 template <class T> void S<T>::f(int);
317 The `class T' maches the `S<T>', leaving no template headers
318 corresponding to the `f'. */
320 else if (n_template_parm_scopes > n_class_scopes + 1)
321 /* We've got too many template headers. For example:
323 template <> template <class T> void f (T);
325 There need to be more enclosing classes. */
326 return tsk_excessive_parms;
328 /* This must be a template. It's of the form:
330 template <class T> template <class U> void S<T>::f(U);
332 This is a specialization if the innermost level was a
333 specialization; otherwise it's just a definition of the
335 return innermost_specialization_p ? tsk_expl_spec : tsk_template;
338 /* Exit the current scope. */
346 /* When a label goes out of scope, check to see if that label was used
347 in a valid manner, and issue any appropriate warnings or errors. */
350 pop_label (tree label, tree old_value)
352 if (!processing_template_decl)
354 if (DECL_INITIAL (label) == NULL_TREE)
358 error ("label %q+D used but not defined", label);
359 #ifdef USE_MAPPED_LOCATION
360 location = input_location; /* FIXME want (input_filename, (line)0) */
362 location.file = input_filename;
365 /* Avoid crashing later. */
366 define_label (location, DECL_NAME (label));
369 warn_for_unused_label (label);
372 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
375 /* At the end of a function, all labels declared within the function
376 go out of scope. BLOCK is the top-level block for the
380 pop_labels_1 (void **slot, void *data)
382 struct named_label_entry *ent = (struct named_label_entry *) *slot;
383 tree block = (tree) data;
385 pop_label (ent->label_decl, NULL_TREE);
387 /* Put the labels into the "variables" of the top-level block,
388 so debugger can see them. */
389 TREE_CHAIN (ent->label_decl) = BLOCK_VARS (block);
390 BLOCK_VARS (block) = ent->label_decl;
392 htab_clear_slot (named_labels, slot);
398 pop_labels (tree block)
402 htab_traverse (named_labels, pop_labels_1, block);
407 /* At the end of a block with local labels, restore the outer definition. */
410 pop_local_label (tree label, tree old_value)
412 struct named_label_entry dummy;
415 pop_label (label, old_value);
417 dummy.label_decl = label;
418 slot = htab_find_slot (named_labels, &dummy, NO_INSERT);
419 htab_clear_slot (named_labels, slot);
422 /* The following two routines are used to interface to Objective-C++.
423 The binding level is purposely treated as an opaque type. */
426 objc_get_current_scope (void)
428 return current_binding_level;
431 /* The following routine is used by the NeXT-style SJLJ exceptions;
432 variables get marked 'volatile' so as to not be clobbered by
433 _setjmp()/_longjmp() calls. All variables in the current scope,
434 as well as parent scopes up to (but not including) ENCLOSING_BLK
435 shall be thusly marked. */
438 objc_mark_locals_volatile (void *enclosing_blk)
440 struct cp_binding_level *scope;
442 for (scope = current_binding_level;
443 scope && scope != enclosing_blk;
444 scope = scope->level_chain)
448 for (decl = scope->names; decl; decl = TREE_CHAIN (decl))
449 objc_volatilize_decl (decl);
451 /* Do not climb up past the current function. */
452 if (scope->kind == sk_function_parms)
457 /* Update data for defined and undefined labels when leaving a scope. */
460 poplevel_named_label_1 (void **slot, void *data)
462 struct named_label_entry *ent = (struct named_label_entry *) *slot;
463 struct cp_binding_level *bl = (struct cp_binding_level *) data;
464 struct cp_binding_level *obl = bl->level_chain;
466 if (ent->binding_level == bl)
470 for (decl = ent->names_in_scope; decl; decl = TREE_CHAIN (decl))
471 if (decl_jump_unsafe (decl))
472 ent->bad_decls = tree_cons (NULL, decl, ent->bad_decls);
474 ent->binding_level = obl;
475 ent->names_in_scope = obl->names;
479 ent->in_try_scope = true;
482 ent->in_catch_scope = true;
485 ent->in_omp_scope = true;
493 struct named_label_use_entry *use;
495 for (use = ent->uses; use ; use = use->next)
496 if (use->binding_level == bl)
498 use->binding_level = obl;
499 use->names_in_scope = obl->names;
500 if (bl->kind == sk_omp)
501 use->in_omp_scope = true;
508 /* Exit a binding level.
509 Pop the level off, and restore the state of the identifier-decl mappings
510 that were in effect when this level was entered.
512 If KEEP == 1, this level had explicit declarations, so
513 and create a "block" (a BLOCK node) for the level
514 to record its declarations and subblocks for symbol table output.
516 If FUNCTIONBODY is nonzero, this level is the body of a function,
517 so create a block as if KEEP were set and also clear out all
520 If REVERSE is nonzero, reverse the order of decls before putting
521 them into the BLOCK. */
524 poplevel (int keep, int reverse, int functionbody)
527 /* The chain of decls was accumulated in reverse order.
528 Put it into forward order, just for cleanliness. */
530 int tmp = functionbody;
531 int real_functionbody;
535 int leaving_for_scope;
538 timevar_push (TV_NAME_LOOKUP);
543 gcc_assert (current_binding_level->kind != sk_class);
545 real_functionbody = (current_binding_level->kind == sk_cleanup
546 ? ((functionbody = 0), tmp) : functionbody);
547 subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
549 gcc_assert (!VEC_length(cp_class_binding,
550 current_binding_level->class_shadowed));
552 /* We used to use KEEP == 2 to indicate that the new block should go
553 at the beginning of the list of blocks at this binding level,
554 rather than the end. This hack is no longer used. */
555 gcc_assert (keep == 0 || keep == 1);
557 if (current_binding_level->keep)
560 /* Any uses of undefined labels, and any defined labels, now operate
561 under constraints of next binding contour. */
562 if (cfun && !functionbody && named_labels)
563 htab_traverse (named_labels, poplevel_named_label_1,
564 current_binding_level);
566 /* Get the decls in the order they were written.
567 Usually current_binding_level->names is in reverse order.
568 But parameter decls were previously put in forward order. */
571 current_binding_level->names
572 = decls = nreverse (current_binding_level->names);
574 decls = current_binding_level->names;
576 /* If there were any declarations or structure tags in that level,
577 or if this level is a function body,
578 create a BLOCK to record them for the life of this function. */
580 if (keep == 1 || functionbody)
581 block = make_node (BLOCK);
582 if (block != NULL_TREE)
584 BLOCK_VARS (block) = decls;
585 BLOCK_SUBBLOCKS (block) = subblocks;
588 /* In each subblock, record that this is its superior. */
590 for (link = subblocks; link; link = TREE_CHAIN (link))
591 BLOCK_SUPERCONTEXT (link) = block;
593 /* We still support the old for-scope rules, whereby the variables
594 in a for-init statement were in scope after the for-statement
595 ended. We only use the new rules if flag_new_for_scope is
598 = current_binding_level->kind == sk_for && flag_new_for_scope == 1;
600 /* Before we remove the declarations first check for unused variables. */
601 if (warn_unused_variable
602 && !processing_template_decl)
603 for (decl = getdecls (); decl; decl = TREE_CHAIN (decl))
604 if (TREE_CODE (decl) == VAR_DECL
605 && ! TREE_USED (decl)
606 && ! DECL_IN_SYSTEM_HEADER (decl)
607 && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl))
608 warning (OPT_Wunused_variable, "unused variable %q+D", decl);
610 /* Remove declarations for all the DECLs in this level. */
611 for (link = decls; link; link = TREE_CHAIN (link))
613 if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
616 tree name = DECL_NAME (link);
620 ob = outer_binding (name,
621 IDENTIFIER_BINDING (name),
624 ns_binding = IDENTIFIER_NAMESPACE_VALUE (name);
626 ns_binding = NULL_TREE;
628 if (ob && ob->scope == current_binding_level->level_chain)
629 /* We have something like:
634 and we are leaving the `for' scope. There's no reason to
635 keep the binding of the inner `i' in this case. */
636 pop_binding (name, link);
637 else if ((ob && (TREE_CODE (ob->value) == TYPE_DECL))
638 || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL))
639 /* Here, we have something like:
647 We must pop the for-scope binding so we know what's a
648 type and what isn't. */
649 pop_binding (name, link);
652 /* Mark this VAR_DECL as dead so that we can tell we left it
653 there only for backward compatibility. */
654 DECL_DEAD_FOR_LOCAL (link) = 1;
656 /* Keep track of what should have happened when we
657 popped the binding. */
660 SET_DECL_SHADOWED_FOR_VAR (link, ob->value);
661 DECL_HAS_SHADOWED_FOR_VAR_P (link) = 1;
664 /* Add it to the list of dead variables in the next
665 outermost binding to that we can remove these when we
666 leave that binding. */
667 current_binding_level->level_chain->dead_vars_from_for
668 = tree_cons (NULL_TREE, link,
669 current_binding_level->level_chain->
672 /* Although we don't pop the cxx_binding, we do clear
673 its SCOPE since the scope is going away now. */
674 IDENTIFIER_BINDING (name)->scope
675 = current_binding_level->level_chain;
682 /* Remove the binding. */
685 if (TREE_CODE (decl) == TREE_LIST)
686 decl = TREE_VALUE (decl);
689 if (TREE_CODE (name) == OVERLOAD)
690 name = OVL_FUNCTION (name);
692 gcc_assert (DECL_P (name));
693 pop_binding (DECL_NAME (name), decl);
697 /* Remove declarations for any `for' variables from inner scopes
698 that we kept around. */
699 for (link = current_binding_level->dead_vars_from_for;
700 link; link = TREE_CHAIN (link))
701 pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
703 /* Restore the IDENTIFIER_TYPE_VALUEs. */
704 for (link = current_binding_level->type_shadowed;
705 link; link = TREE_CHAIN (link))
706 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
708 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
709 for (link = current_binding_level->shadowed_labels;
711 link = TREE_CHAIN (link))
712 pop_local_label (TREE_VALUE (link), TREE_PURPOSE (link));
714 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
715 list if a `using' declaration put them there. The debugging
716 back ends won't understand OVERLOAD, so we remove them here.
717 Because the BLOCK_VARS are (temporarily) shared with
718 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
719 popped all the bindings. */
724 for (d = &BLOCK_VARS (block); *d; )
726 if (TREE_CODE (*d) == TREE_LIST)
727 *d = TREE_CHAIN (*d);
729 d = &TREE_CHAIN (*d);
733 /* If the level being exited is the top level of a function,
734 check over all the labels. */
737 /* Since this is the top level block of a function, the vars are
738 the function's parameters. Don't leave them in the BLOCK
739 because they are found in the FUNCTION_DECL instead. */
740 BLOCK_VARS (block) = 0;
744 kind = current_binding_level->kind;
745 if (kind == sk_cleanup)
749 /* If this is a temporary binding created for a cleanup, then we'll
750 have pushed a statement list level. Pop that, create a new
751 BIND_EXPR for the block, and insert it into the stream. */
752 stmt = pop_stmt_list (current_binding_level->statement_list);
753 stmt = c_build_bind_expr (block, stmt);
760 /* The current function is being defined, so its DECL_INITIAL
761 should be error_mark_node. */
762 gcc_assert (DECL_INITIAL (current_function_decl) == error_mark_node);
763 DECL_INITIAL (current_function_decl) = block;
766 current_binding_level->blocks
767 = chainon (current_binding_level->blocks, block);
769 /* If we did not make a block for the level just exited,
770 any blocks made for inner levels
771 (since they cannot be recorded as subblocks in that level)
772 must be carried forward so they will later become subblocks
773 of something else. */
775 current_binding_level->blocks
776 = chainon (current_binding_level->blocks, subblocks);
778 /* Each and every BLOCK node created here in `poplevel' is important
779 (e.g. for proper debugging information) so if we created one
780 earlier, mark it as "used". */
782 TREE_USED (block) = 1;
784 /* All temporary bindings created for cleanups are popped silently. */
785 if (kind == sk_cleanup)
788 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, block);
791 /* Insert BLOCK at the end of the list of subblocks of the
792 current binding level. This is used when a BIND_EXPR is expanded,
793 to handle the BLOCK node inside the BIND_EXPR. */
796 insert_block (tree block)
798 TREE_USED (block) = 1;
799 current_binding_level->blocks
800 = chainon (current_binding_level->blocks, block);
803 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
804 itself, calling F for each. The DATA is passed to F as well. */
807 walk_namespaces_r (tree namespace, walk_namespaces_fn f, void* data)
810 tree current = NAMESPACE_LEVEL (namespace)->namespaces;
812 result |= (*f) (namespace, data);
814 for (; current; current = TREE_CHAIN (current))
815 result |= walk_namespaces_r (current, f, data);
820 /* Walk all the namespaces, calling F for each. The DATA is passed to
824 walk_namespaces (walk_namespaces_fn f, void* data)
826 return walk_namespaces_r (global_namespace, f, data);
829 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
830 DATA is non-NULL, this is the last time we will call
831 wrapup_global_declarations for this NAMESPACE. */
834 wrapup_globals_for_namespace (tree namespace, void* data)
836 struct cp_binding_level *level = NAMESPACE_LEVEL (namespace);
837 VEC(tree,gc) *statics = level->static_decls;
838 tree *vec = VEC_address (tree, statics);
839 int len = VEC_length (tree, statics);
840 int last_time = (data != 0);
844 check_global_declarations (vec, len);
845 emit_debug_global_declarations (vec, len);
849 /* Write out any globals that need to be output. */
850 return wrapup_global_declarations (vec, len);
854 /* In C++, you don't have to write `struct S' to refer to `S'; you
855 can just use `S'. We accomplish this by creating a TYPE_DECL as
856 if the user had written `typedef struct S S'. Create and return
857 the TYPE_DECL for TYPE. */
860 create_implicit_typedef (tree name, tree type)
864 decl = build_decl (TYPE_DECL, name, type);
865 DECL_ARTIFICIAL (decl) = 1;
866 /* There are other implicit type declarations, like the one *within*
867 a class that allows you to write `S::S'. We must distinguish
869 SET_DECL_IMPLICIT_TYPEDEF_P (decl);
870 TYPE_NAME (type) = decl;
875 /* Remember a local name for name-mangling purposes. */
878 push_local_name (tree decl)
883 timevar_push (TV_NAME_LOOKUP);
885 name = DECL_NAME (decl);
887 nelts = VEC_length (tree, local_names);
888 for (i = 0; i < nelts; i++)
890 t = VEC_index (tree, local_names, i);
891 if (DECL_NAME (t) == name)
893 if (!DECL_LANG_SPECIFIC (decl))
894 retrofit_lang_decl (decl);
895 DECL_LANG_SPECIFIC (decl)->decl_flags.u2sel = 1;
896 if (DECL_LANG_SPECIFIC (t))
897 DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
899 DECL_DISCRIMINATOR (decl) = 1;
901 VEC_replace (tree, local_names, i, decl);
902 timevar_pop (TV_NAME_LOOKUP);
907 VEC_safe_push (tree, gc, local_names, decl);
908 timevar_pop (TV_NAME_LOOKUP);
911 /* Subroutine of duplicate_decls: return truthvalue of whether
912 or not types of these decls match.
914 For C++, we must compare the parameter list so that `int' can match
915 `int&' in a parameter position, but `int&' is not confused with
919 decls_match (tree newdecl, tree olddecl)
923 if (newdecl == olddecl)
926 if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
927 /* If the two DECLs are not even the same kind of thing, we're not
928 interested in their types. */
931 if (TREE_CODE (newdecl) == FUNCTION_DECL)
933 tree f1 = TREE_TYPE (newdecl);
934 tree f2 = TREE_TYPE (olddecl);
935 tree p1 = TYPE_ARG_TYPES (f1);
936 tree p2 = TYPE_ARG_TYPES (f2);
938 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
939 && ! (DECL_EXTERN_C_P (newdecl)
940 && DECL_EXTERN_C_P (olddecl)))
943 if (TREE_CODE (f1) != TREE_CODE (f2))
946 if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
948 if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
949 && (DECL_BUILT_IN (olddecl)
950 #ifndef NO_IMPLICIT_EXTERN_C
951 || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
952 || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
956 types_match = self_promoting_args_p (p1);
957 if (p1 == void_list_node)
958 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
960 #ifndef NO_IMPLICIT_EXTERN_C
961 else if (p1 == NULL_TREE
962 && (DECL_EXTERN_C_P (olddecl)
963 && DECL_IN_SYSTEM_HEADER (olddecl)
964 && !DECL_CLASS_SCOPE_P (olddecl))
965 && (DECL_EXTERN_C_P (newdecl)
966 && DECL_IN_SYSTEM_HEADER (newdecl)
967 && !DECL_CLASS_SCOPE_P (newdecl)))
969 types_match = self_promoting_args_p (p2);
970 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
974 types_match = compparms (p1, p2);
979 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
981 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
982 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
985 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
986 DECL_TEMPLATE_PARMS (olddecl)))
989 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
990 types_match = same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)),
991 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl)));
993 types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
994 DECL_TEMPLATE_RESULT (newdecl));
998 /* Need to check scope for variable declaration (VAR_DECL).
999 For typedef (TYPE_DECL), scope is ignored. */
1000 if (TREE_CODE (newdecl) == VAR_DECL
1001 && CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
1003 Two declarations for an object with C language linkage
1004 with the same name (ignoring the namespace that qualify
1005 it) that appear in different namespace scopes refer to
1007 && !(DECL_EXTERN_C_P (olddecl) && DECL_EXTERN_C_P (newdecl)))
1010 if (TREE_TYPE (newdecl) == error_mark_node)
1011 types_match = TREE_TYPE (olddecl) == error_mark_node;
1012 else if (TREE_TYPE (olddecl) == NULL_TREE)
1013 types_match = TREE_TYPE (newdecl) == NULL_TREE;
1014 else if (TREE_TYPE (newdecl) == NULL_TREE)
1017 types_match = comptypes (TREE_TYPE (newdecl),
1018 TREE_TYPE (olddecl),
1019 COMPARE_REDECLARATION);
1025 /* If NEWDECL is `static' and an `extern' was seen previously,
1026 warn about it. OLDDECL is the previous declaration.
1028 Note that this does not apply to the C++ case of declaring
1029 a variable `extern const' and then later `const'.
1031 Don't complain about built-in functions, since they are beyond
1032 the user's control. */
1035 warn_extern_redeclared_static (tree newdecl, tree olddecl)
1039 if (TREE_CODE (newdecl) == TYPE_DECL
1040 || TREE_CODE (newdecl) == TEMPLATE_DECL
1041 || TREE_CODE (newdecl) == CONST_DECL
1042 || TREE_CODE (newdecl) == NAMESPACE_DECL)
1045 /* Don't get confused by static member functions; that's a different
1047 if (TREE_CODE (newdecl) == FUNCTION_DECL
1048 && DECL_STATIC_FUNCTION_P (newdecl))
1051 /* If the old declaration was `static', or the new one isn't, then
1052 then everything is OK. */
1053 if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
1056 /* It's OK to declare a builtin function as `static'. */
1057 if (TREE_CODE (olddecl) == FUNCTION_DECL
1058 && DECL_ARTIFICIAL (olddecl))
1061 name = DECL_ASSEMBLER_NAME (newdecl);
1062 pedwarn ("%qD was declared %<extern%> and later %<static%>", newdecl);
1063 pedwarn ("previous declaration of %q+D", olddecl);
1066 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1067 function templates. If their exception specifications do not
1068 match, issue a diagnostic. */
1071 check_redeclaration_exception_specification (tree new_decl,
1076 tree new_exceptions;
1077 tree old_exceptions;
1079 new_type = TREE_TYPE (new_decl);
1080 new_exceptions = TYPE_RAISES_EXCEPTIONS (new_type);
1081 old_type = TREE_TYPE (old_decl);
1082 old_exceptions = TYPE_RAISES_EXCEPTIONS (old_type);
1086 If any declaration of a function has an exception-specification,
1087 all declarations, including the definition and an explicit
1088 specialization, of that function shall have an
1089 exception-specification with the same set of type-ids. */
1090 if ((pedantic || ! DECL_IN_SYSTEM_HEADER (old_decl))
1091 && ! DECL_IS_BUILTIN (old_decl)
1093 && !comp_except_specs (new_exceptions, old_exceptions,
1096 error ("declaration of %qF throws different exceptions", new_decl);
1097 error ("from previous declaration %q+F", old_decl);
1101 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1102 && lookup_attribute ("gnu_inline", \
1103 DECL_ATTRIBUTES (fn)))
1105 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1106 If the redeclaration is invalid, a diagnostic is issued, and the
1107 error_mark_node is returned. Otherwise, OLDDECL is returned.
1109 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1112 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1115 duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend)
1117 unsigned olddecl_uid = DECL_UID (olddecl);
1118 int olddecl_friend = 0, types_match = 0, hidden_friend = 0;
1119 int new_defines_function = 0;
1122 if (newdecl == olddecl)
1125 types_match = decls_match (newdecl, olddecl);
1127 /* If either the type of the new decl or the type of the old decl is an
1128 error_mark_node, then that implies that we have already issued an
1129 error (earlier) for some bogus type specification, and in that case,
1130 it is rather pointless to harass the user with yet more error message
1131 about the same declaration, so just pretend the types match here. */
1132 if (TREE_TYPE (newdecl) == error_mark_node
1133 || TREE_TYPE (olddecl) == error_mark_node)
1134 return error_mark_node;
1136 if (DECL_P (olddecl)
1137 && TREE_CODE (newdecl) == FUNCTION_DECL
1138 && TREE_CODE (olddecl) == FUNCTION_DECL
1139 && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
1141 if (DECL_DECLARED_INLINE_P (newdecl)
1142 && DECL_UNINLINABLE (newdecl)
1143 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1144 /* Already warned elsewhere. */;
1145 else if (DECL_DECLARED_INLINE_P (olddecl)
1146 && DECL_UNINLINABLE (olddecl)
1147 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1148 /* Already warned. */;
1149 else if (DECL_DECLARED_INLINE_P (newdecl)
1150 && DECL_UNINLINABLE (olddecl)
1151 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1153 warning (OPT_Wattributes, "function %q+D redeclared as inline",
1155 warning (OPT_Wattributes, "previous declaration of %q+D "
1156 "with attribute noinline", olddecl);
1158 else if (DECL_DECLARED_INLINE_P (olddecl)
1159 && DECL_UNINLINABLE (newdecl)
1160 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1162 warning (OPT_Wattributes, "function %q+D redeclared with "
1163 "attribute noinline", newdecl);
1164 warning (OPT_Wattributes, "previous declaration of %q+D was inline",
1169 /* Check for redeclaration and other discrepancies. */
1170 if (TREE_CODE (olddecl) == FUNCTION_DECL
1171 && DECL_ARTIFICIAL (olddecl))
1173 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl));
1174 if (TREE_CODE (newdecl) != FUNCTION_DECL)
1176 /* Avoid warnings redeclaring built-ins which have not been
1177 explicitly declared. */
1178 if (DECL_ANTICIPATED (olddecl))
1181 /* If you declare a built-in or predefined function name as static,
1182 the old definition is overridden, but optionally warn this was a
1183 bad choice of name. */
1184 if (! TREE_PUBLIC (newdecl))
1186 warning (OPT_Wshadow, "shadowing %s function %q#D",
1187 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
1189 /* Discard the old built-in function. */
1192 /* If the built-in is not ansi, then programs can override
1193 it even globally without an error. */
1194 else if (! DECL_BUILT_IN (olddecl))
1195 warning (0, "library function %q#D redeclared as non-function %q#D",
1199 error ("declaration of %q#D", newdecl);
1200 error ("conflicts with built-in declaration %q#D",
1205 else if (!types_match)
1207 /* Avoid warnings redeclaring built-ins which have not been
1208 explicitly declared. */
1209 if (DECL_ANTICIPATED (olddecl))
1211 /* Deal with fileptr_type_node. FILE type is not known
1212 at the time we create the builtins. */
1215 for (t1 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1216 t2 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1218 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1221 else if (TREE_VALUE (t2) == fileptr_type_node)
1223 tree t = TREE_VALUE (t1);
1225 if (TREE_CODE (t) == POINTER_TYPE
1226 && TYPE_NAME (TREE_TYPE (t))
1227 && DECL_NAME (TYPE_NAME (TREE_TYPE (t)))
1228 == get_identifier ("FILE")
1229 && compparms (TREE_CHAIN (t1), TREE_CHAIN (t2)))
1231 tree oldargs = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1233 TYPE_ARG_TYPES (TREE_TYPE (olddecl))
1234 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1235 types_match = decls_match (newdecl, olddecl);
1237 return duplicate_decls (newdecl, olddecl,
1239 TYPE_ARG_TYPES (TREE_TYPE (olddecl)) = oldargs;
1242 else if (! same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1245 else if ((DECL_EXTERN_C_P (newdecl)
1246 && DECL_EXTERN_C_P (olddecl))
1247 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1248 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1250 /* A near match; override the builtin. */
1252 if (TREE_PUBLIC (newdecl))
1254 warning (0, "new declaration %q#D", newdecl);
1255 warning (0, "ambiguates built-in declaration %q#D",
1259 warning (OPT_Wshadow, "shadowing %s function %q#D",
1260 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
1264 /* Discard the old built-in function. */
1267 /* Replace the old RTL to avoid problems with inlining. */
1268 COPY_DECL_RTL (newdecl, olddecl);
1270 /* Even if the types match, prefer the new declarations type for
1271 built-ins which have not been explicitly declared, for
1272 exception lists, etc... */
1273 else if (DECL_ANTICIPATED (olddecl))
1275 tree type = TREE_TYPE (newdecl);
1276 tree attribs = (*targetm.merge_type_attributes)
1277 (TREE_TYPE (olddecl), type);
1279 type = cp_build_type_attribute_variant (type, attribs);
1280 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = type;
1283 /* If a function is explicitly declared "throw ()", propagate that to
1284 the corresponding builtin. */
1285 if (DECL_BUILT_IN_CLASS (olddecl) == BUILT_IN_NORMAL
1286 && DECL_ANTICIPATED (olddecl)
1287 && TREE_NOTHROW (newdecl)
1288 && !TREE_NOTHROW (olddecl)
1289 && built_in_decls [DECL_FUNCTION_CODE (olddecl)] != NULL_TREE
1290 && built_in_decls [DECL_FUNCTION_CODE (olddecl)] != olddecl
1292 TREE_NOTHROW (built_in_decls [DECL_FUNCTION_CODE (olddecl)]) = 1;
1294 /* Whether or not the builtin can throw exceptions has no
1295 bearing on this declarator. */
1296 TREE_NOTHROW (olddecl) = 0;
1298 if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
1300 /* If a builtin function is redeclared as `static', merge
1301 the declarations, but make the original one static. */
1302 DECL_THIS_STATIC (olddecl) = 1;
1303 TREE_PUBLIC (olddecl) = 0;
1305 /* Make the old declaration consistent with the new one so
1306 that all remnants of the builtin-ness of this function
1307 will be banished. */
1308 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1309 COPY_DECL_RTL (newdecl, olddecl);
1312 else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1314 /* C++ Standard, 3.3, clause 4:
1315 "[Note: a namespace name or a class template name must be unique
1316 in its declarative region (7.3.2, clause 14). ]" */
1317 if (TREE_CODE (olddecl) != NAMESPACE_DECL
1318 && TREE_CODE (newdecl) != NAMESPACE_DECL
1319 && (TREE_CODE (olddecl) != TEMPLATE_DECL
1320 || TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) != TYPE_DECL)
1321 && (TREE_CODE (newdecl) != TEMPLATE_DECL
1322 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != TYPE_DECL))
1324 if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
1325 && TREE_CODE (newdecl) != TYPE_DECL)
1326 || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
1327 && TREE_CODE (olddecl) != TYPE_DECL))
1329 /* We do nothing special here, because C++ does such nasty
1330 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1331 get shadowed, and know that if we need to find a TYPE_DECL
1332 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1333 slot of the identifier. */
1337 if ((TREE_CODE (newdecl) == FUNCTION_DECL
1338 && DECL_FUNCTION_TEMPLATE_P (olddecl))
1339 || (TREE_CODE (olddecl) == FUNCTION_DECL
1340 && DECL_FUNCTION_TEMPLATE_P (newdecl)))
1344 error ("%q#D redeclared as different kind of symbol", newdecl);
1345 if (TREE_CODE (olddecl) == TREE_LIST)
1346 olddecl = TREE_VALUE (olddecl);
1347 error ("previous declaration of %q+#D", olddecl);
1349 return error_mark_node;
1351 else if (!types_match)
1353 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
1354 /* These are certainly not duplicate declarations; they're
1355 from different scopes. */
1358 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1360 /* The name of a class template may not be declared to refer to
1361 any other template, class, function, object, namespace, value,
1362 or type in the same scope. */
1363 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
1364 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1366 error ("declaration of template %q#D", newdecl);
1367 error ("conflicts with previous declaration %q+#D", olddecl);
1369 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
1370 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
1371 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
1372 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
1373 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1374 DECL_TEMPLATE_PARMS (olddecl))
1375 /* Template functions can be disambiguated by
1377 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
1378 TREE_TYPE (TREE_TYPE (olddecl))))
1380 error ("new declaration %q#D", newdecl);
1381 error ("ambiguates old declaration %q+#D", olddecl);
1385 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1387 if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
1389 error ("declaration of C function %q#D conflicts with",
1391 error ("previous declaration %q+#D here", olddecl);
1393 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1394 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1396 error ("new declaration %q#D", newdecl);
1397 error ("ambiguates old declaration %q+#D", olddecl);
1398 return error_mark_node;
1405 error ("conflicting declaration %q#D", newdecl);
1406 error ("%q+D has a previous declaration as %q#D", olddecl, olddecl);
1407 return error_mark_node;
1410 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1411 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
1412 && (!DECL_TEMPLATE_INFO (newdecl)
1413 || (DECL_TI_TEMPLATE (newdecl)
1414 != DECL_TI_TEMPLATE (olddecl))))
1415 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
1416 && (!DECL_TEMPLATE_INFO (olddecl)
1417 || (DECL_TI_TEMPLATE (olddecl)
1418 != DECL_TI_TEMPLATE (newdecl))))))
1419 /* It's OK to have a template specialization and a non-template
1420 with the same type, or to have specializations of two
1421 different templates with the same type. Note that if one is a
1422 specialization, and the other is an instantiation of the same
1423 template, that we do not exit at this point. That situation
1424 can occur if we instantiate a template class, and then
1425 specialize one of its methods. This situation is valid, but
1426 the declarations must be merged in the usual way. */
1428 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1429 && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
1430 && !DECL_USE_TEMPLATE (newdecl))
1431 || (DECL_TEMPLATE_INSTANTIATION (newdecl)
1432 && !DECL_USE_TEMPLATE (olddecl))))
1433 /* One of the declarations is a template instantiation, and the
1434 other is not a template at all. That's OK. */
1436 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1438 /* In [namespace.alias] we have:
1440 In a declarative region, a namespace-alias-definition can be
1441 used to redefine a namespace-alias declared in that declarative
1442 region to refer only to the namespace to which it already
1445 Therefore, if we encounter a second alias directive for the same
1446 alias, we can just ignore the second directive. */
1447 if (DECL_NAMESPACE_ALIAS (newdecl)
1448 && (DECL_NAMESPACE_ALIAS (newdecl)
1449 == DECL_NAMESPACE_ALIAS (olddecl)))
1451 /* [namespace.alias]
1453 A namespace-name or namespace-alias shall not be declared as
1454 the name of any other entity in the same declarative region.
1455 A namespace-name defined at global scope shall not be
1456 declared as the name of any other entity in any global scope
1458 error ("declaration of namespace %qD conflicts with", newdecl);
1459 error ("previous declaration of namespace %q+D here", olddecl);
1460 return error_mark_node;
1464 const char *errmsg = redeclaration_error_message (newdecl, olddecl);
1467 error (errmsg, newdecl);
1468 if (DECL_NAME (olddecl) != NULL_TREE)
1469 error ((DECL_INITIAL (olddecl) && namespace_bindings_p ())
1470 ? "%q+#D previously defined here"
1471 : "%q+#D previously declared here", olddecl);
1472 return error_mark_node;
1474 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1475 && DECL_INITIAL (olddecl) != NULL_TREE
1476 && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
1477 && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
1479 /* Prototype decl follows defn w/o prototype. */
1480 warning (0, "prototype for %q+#D", newdecl);
1481 warning (0, "%Jfollows non-prototype definition here", olddecl);
1483 else if ((TREE_CODE (olddecl) == FUNCTION_DECL
1484 || TREE_CODE (olddecl) == VAR_DECL)
1485 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
1488 If two declarations of the same function or object
1489 specify different linkage-specifications ..., the program
1490 is ill-formed.... Except for functions with C++ linkage,
1491 a function declaration without a linkage specification
1492 shall not precede the first linkage specification for
1493 that function. A function can be declared without a
1494 linkage specification after an explicit linkage
1495 specification has been seen; the linkage explicitly
1496 specified in the earlier declaration is not affected by
1497 such a function declaration.
1499 DR 563 raises the question why the restrictions on
1500 functions should not also apply to objects. Older
1501 versions of G++ silently ignore the linkage-specification
1509 which is clearly wrong. Therefore, we now treat objects
1511 if (current_lang_depth () == 0)
1513 /* There is no explicit linkage-specification, so we use
1514 the linkage from the previous declaration. */
1515 if (!DECL_LANG_SPECIFIC (newdecl))
1516 retrofit_lang_decl (newdecl);
1517 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1521 error ("previous declaration of %q+#D with %qL linkage",
1522 olddecl, DECL_LANGUAGE (olddecl));
1523 error ("conflicts with new declaration with %qL linkage",
1524 DECL_LANGUAGE (newdecl));
1528 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
1530 else if (TREE_CODE (olddecl) == FUNCTION_DECL)
1532 tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1533 tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1536 if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
1537 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
1539 for (; t1 && t1 != void_list_node;
1540 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
1541 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
1543 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
1546 pedwarn ("default argument given for parameter %d of %q#D",
1548 pedwarn ("after previous specification in %q+#D", olddecl);
1552 error ("default argument given for parameter %d of %q#D",
1554 error ("after previous specification in %q+#D",
1559 if (DECL_DECLARED_INLINE_P (newdecl)
1560 && ! DECL_DECLARED_INLINE_P (olddecl)
1561 && TREE_ADDRESSABLE (olddecl) && warn_inline)
1563 warning (0, "%q#D was used before it was declared inline", newdecl);
1564 warning (0, "%Jprevious non-inline declaration here", olddecl);
1569 /* Do not merge an implicit typedef with an explicit one. In:
1573 typedef class A A __attribute__ ((foo));
1575 the attribute should apply only to the typedef. */
1576 if (TREE_CODE (olddecl) == TYPE_DECL
1577 && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
1578 || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
1581 /* If new decl is `static' and an `extern' was seen previously,
1583 warn_extern_redeclared_static (newdecl, olddecl);
1585 /* We have committed to returning 1 at this point. */
1586 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1588 /* Now that functions must hold information normally held
1589 by field decls, there is extra work to do so that
1590 declaration information does not get destroyed during
1592 if (DECL_VINDEX (olddecl))
1593 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
1594 if (DECL_CONTEXT (olddecl))
1595 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1596 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
1597 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1598 DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
1599 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
1600 DECL_INVALID_OVERRIDER_P (newdecl) |= DECL_INVALID_OVERRIDER_P (olddecl);
1601 DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
1602 if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
1603 SET_OVERLOADED_OPERATOR_CODE
1604 (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
1605 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
1607 /* Optionally warn about more than one declaration for the same
1608 name, but don't warn about a function declaration followed by a
1610 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
1611 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
1612 /* Don't warn about extern decl followed by definition. */
1613 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
1614 /* Don't warn about friends, let add_friend take care of it. */
1615 && ! (newdecl_is_friend || DECL_FRIEND_P (olddecl)))
1617 warning (OPT_Wredundant_decls, "redundant redeclaration of %qD in same scope", newdecl);
1618 warning (OPT_Wredundant_decls, "previous declaration of %q+D", olddecl);
1622 /* Deal with C++: must preserve virtual function table size. */
1623 if (TREE_CODE (olddecl) == TYPE_DECL)
1625 tree newtype = TREE_TYPE (newdecl);
1626 tree oldtype = TREE_TYPE (olddecl);
1628 if (newtype != error_mark_node && oldtype != error_mark_node
1629 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
1630 CLASSTYPE_FRIEND_CLASSES (newtype)
1631 = CLASSTYPE_FRIEND_CLASSES (oldtype);
1633 DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
1636 /* Copy all the DECL_... slots specified in the new decl
1637 except for any that we copy here from the old type. */
1638 DECL_ATTRIBUTES (newdecl)
1639 = (*targetm.merge_decl_attributes) (olddecl, newdecl);
1641 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1645 old_result = DECL_TEMPLATE_RESULT (olddecl);
1646 new_result = DECL_TEMPLATE_RESULT (newdecl);
1647 TREE_TYPE (olddecl) = TREE_TYPE (old_result);
1648 DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
1649 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
1650 DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
1652 DECL_ATTRIBUTES (old_result)
1653 = (*targetm.merge_decl_attributes) (old_result, new_result);
1655 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1657 if (GNU_INLINE_P (old_result) != GNU_INLINE_P (new_result)
1658 && DECL_INITIAL (new_result))
1660 if (DECL_INITIAL (old_result))
1662 DECL_INLINE (old_result) = 0;
1663 DECL_UNINLINABLE (old_result) = 1;
1667 DECL_INLINE (old_result) = DECL_INLINE (new_result);
1668 DECL_UNINLINABLE (old_result) = DECL_UNINLINABLE (new_result);
1670 DECL_EXTERNAL (old_result) = DECL_EXTERNAL (new_result);
1671 DECL_NOT_REALLY_EXTERN (old_result)
1672 = DECL_NOT_REALLY_EXTERN (new_result);
1673 DECL_INTERFACE_KNOWN (old_result)
1674 = DECL_INTERFACE_KNOWN (new_result);
1675 DECL_DECLARED_INLINE_P (old_result)
1676 = DECL_DECLARED_INLINE_P (new_result);
1680 DECL_INLINE (old_result)
1681 |= DECL_INLINE (new_result);
1682 DECL_DECLARED_INLINE_P (old_result)
1683 |= DECL_DECLARED_INLINE_P (new_result);
1684 check_redeclaration_exception_specification (newdecl, olddecl);
1688 /* If the new declaration is a definition, update the file and
1689 line information on the declaration, and also make
1690 the old declaration the same definition. */
1691 if (DECL_INITIAL (new_result) != NULL_TREE)
1693 DECL_SOURCE_LOCATION (olddecl)
1694 = DECL_SOURCE_LOCATION (old_result)
1695 = DECL_SOURCE_LOCATION (newdecl);
1696 DECL_INITIAL (old_result) = DECL_INITIAL (new_result);
1697 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1698 DECL_ARGUMENTS (old_result)
1699 = DECL_ARGUMENTS (new_result);
1707 /* Automatically handles default parameters. */
1708 tree oldtype = TREE_TYPE (olddecl);
1711 /* Merge the data types specified in the two decls. */
1712 newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1714 /* If merge_types produces a non-typedef type, just use the old type. */
1715 if (TREE_CODE (newdecl) == TYPE_DECL
1716 && newtype == DECL_ORIGINAL_TYPE (newdecl))
1719 if (TREE_CODE (newdecl) == VAR_DECL)
1721 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
1722 DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
1723 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl)
1724 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl);
1725 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl)
1726 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl);
1728 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
1729 if (DECL_LANG_SPECIFIC (olddecl)
1730 && CP_DECL_THREADPRIVATE_P (olddecl))
1732 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
1733 if (!DECL_LANG_SPECIFIC (newdecl))
1734 retrofit_lang_decl (newdecl);
1736 DECL_TLS_MODEL (newdecl) = DECL_TLS_MODEL (olddecl);
1737 CP_DECL_THREADPRIVATE_P (newdecl) = 1;
1741 /* Do this after calling `merge_types' so that default
1742 parameters don't confuse us. */
1743 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1744 check_redeclaration_exception_specification (newdecl, olddecl);
1745 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
1747 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1748 check_default_args (newdecl);
1750 /* Lay the type out, unless already done. */
1751 if (! same_type_p (newtype, oldtype)
1752 && TREE_TYPE (newdecl) != error_mark_node
1753 && !(processing_template_decl && uses_template_parms (newdecl)))
1754 layout_type (TREE_TYPE (newdecl));
1756 if ((TREE_CODE (newdecl) == VAR_DECL
1757 || TREE_CODE (newdecl) == PARM_DECL
1758 || TREE_CODE (newdecl) == RESULT_DECL
1759 || TREE_CODE (newdecl) == FIELD_DECL
1760 || TREE_CODE (newdecl) == TYPE_DECL)
1761 && !(processing_template_decl && uses_template_parms (newdecl)))
1762 layout_decl (newdecl, 0);
1764 /* Merge the type qualifiers. */
1765 if (TREE_READONLY (newdecl))
1766 TREE_READONLY (olddecl) = 1;
1767 if (TREE_THIS_VOLATILE (newdecl))
1768 TREE_THIS_VOLATILE (olddecl) = 1;
1769 if (TREE_NOTHROW (newdecl))
1770 TREE_NOTHROW (olddecl) = 1;
1772 /* Merge deprecatedness. */
1773 if (TREE_DEPRECATED (newdecl))
1774 TREE_DEPRECATED (olddecl) = 1;
1776 /* Merge the initialization information. */
1777 if (DECL_INITIAL (newdecl) == NULL_TREE
1778 && DECL_INITIAL (olddecl) != NULL_TREE)
1780 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1781 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
1782 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
1783 && DECL_LANG_SPECIFIC (newdecl)
1784 && DECL_LANG_SPECIFIC (olddecl))
1786 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1787 DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
1791 /* Merge the section attribute.
1792 We want to issue an error if the sections conflict but that must be
1793 done later in decl_attributes since we are called before attributes
1795 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1796 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1798 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1800 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1801 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1802 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1803 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1804 TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
1805 TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl);
1806 DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
1807 DECL_IS_PURE (newdecl) |= DECL_IS_PURE (olddecl);
1808 /* Keep the old RTL. */
1809 COPY_DECL_RTL (olddecl, newdecl);
1811 else if (TREE_CODE (newdecl) == VAR_DECL
1812 && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
1814 /* Keep the old RTL. We cannot keep the old RTL if the old
1815 declaration was for an incomplete object and the new
1816 declaration is not since many attributes of the RTL will
1818 COPY_DECL_RTL (olddecl, newdecl);
1821 /* If cannot merge, then use the new type and qualifiers,
1822 and don't preserve the old rtl. */
1825 /* Clean out any memory we had of the old declaration. */
1826 tree oldstatic = value_member (olddecl, static_aggregates);
1828 TREE_VALUE (oldstatic) = error_mark_node;
1830 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1831 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1832 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1833 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1836 /* Merge the storage class information. */
1837 merge_weak (newdecl, olddecl);
1839 DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
1840 DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
1841 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1842 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
1843 if (! DECL_EXTERNAL (olddecl))
1844 DECL_EXTERNAL (newdecl) = 0;
1846 new_template = NULL_TREE;
1847 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
1849 bool old_decl_gnu_inline;
1851 if ((DECL_INTERFACE_KNOWN (olddecl)
1852 && TREE_CODE (olddecl) == FUNCTION_DECL)
1853 || (TREE_CODE (olddecl) == TEMPLATE_DECL
1854 && TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL))
1858 if (TREE_CODE (fn) == TEMPLATE_DECL)
1859 fn = DECL_TEMPLATE_RESULT (olddecl);
1861 old_decl_gnu_inline = GNU_INLINE_P (fn) && DECL_INITIAL (fn);
1864 old_decl_gnu_inline = false;
1866 if (!old_decl_gnu_inline)
1868 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
1869 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
1870 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
1872 DECL_TEMPLATE_INSTANTIATED (newdecl)
1873 |= DECL_TEMPLATE_INSTANTIATED (olddecl);
1875 /* If the OLDDECL is an instantiation and/or specialization,
1876 then the NEWDECL must be too. But, it may not yet be marked
1877 as such if the caller has created NEWDECL, but has not yet
1878 figured out that it is a redeclaration. */
1879 if (!DECL_USE_TEMPLATE (newdecl))
1880 DECL_USE_TEMPLATE (newdecl) = DECL_USE_TEMPLATE (olddecl);
1882 /* Don't really know how much of the language-specific
1883 values we should copy from old to new. */
1884 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
1885 DECL_LANG_SPECIFIC (newdecl)->decl_flags.u2 =
1886 DECL_LANG_SPECIFIC (olddecl)->decl_flags.u2;
1887 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
1888 DECL_REPO_AVAILABLE_P (newdecl) = DECL_REPO_AVAILABLE_P (olddecl);
1889 if (DECL_TEMPLATE_INFO (newdecl))
1890 new_template = DECL_TI_TEMPLATE (newdecl);
1891 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
1892 DECL_INITIALIZED_IN_CLASS_P (newdecl)
1893 |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
1894 olddecl_friend = DECL_FRIEND_P (olddecl);
1895 hidden_friend = (DECL_ANTICIPATED (olddecl)
1896 && DECL_HIDDEN_FRIEND_P (olddecl)
1897 && newdecl_is_friend);
1899 /* Only functions have DECL_BEFRIENDING_CLASSES. */
1900 if (TREE_CODE (newdecl) == FUNCTION_DECL
1901 || DECL_FUNCTION_TEMPLATE_P (newdecl))
1903 DECL_BEFRIENDING_CLASSES (newdecl)
1904 = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
1905 DECL_BEFRIENDING_CLASSES (olddecl));
1906 /* DECL_THUNKS is only valid for virtual functions,
1907 otherwise it is a DECL_FRIEND_CONTEXT. */
1908 if (DECL_VIRTUAL_P (newdecl))
1909 DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl);
1913 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1915 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
1916 && !DECL_TEMPLATE_INSTANTIATION (newdecl))
1918 /* If newdecl is not a specialization, then it is not a
1919 template-related function at all. And that means that we
1920 should have exited above, returning 0. */
1921 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl));
1923 if (TREE_USED (olddecl))
1924 /* From [temp.expl.spec]:
1926 If a template, a member template or the member of a class
1927 template is explicitly specialized then that
1928 specialization shall be declared before the first use of
1929 that specialization that would cause an implicit
1930 instantiation to take place, in every translation unit in
1931 which such a use occurs. */
1932 error ("explicit specialization of %qD after first use",
1935 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
1937 /* Don't propagate visibility from the template to the
1938 specialization here. We'll do that in determine_visibility if
1940 DECL_VISIBILITY_SPECIFIED (olddecl) = 0;
1942 /* [temp.expl.spec/14] We don't inline explicit specialization
1943 just because the primary template says so. */
1945 else if (new_defines_function && DECL_INITIAL (olddecl))
1947 /* C++ is always in in unit-at-a-time mode, so we never
1948 inline re-defined extern inline functions. */
1949 DECL_INLINE (newdecl) = 0;
1950 DECL_UNINLINABLE (newdecl) = 1;
1954 if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
1955 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
1957 DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
1959 /* If either decl says `inline', this fn is inline, unless
1960 its definition was passed already. */
1961 if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
1962 DECL_INLINE (olddecl) = 1;
1963 DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
1965 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
1966 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
1968 DECL_DISREGARD_INLINE_LIMITS (newdecl)
1969 = DECL_DISREGARD_INLINE_LIMITS (olddecl)
1970 = (DECL_DISREGARD_INLINE_LIMITS (newdecl)
1971 || DECL_DISREGARD_INLINE_LIMITS (olddecl));
1974 /* Preserve abstractness on cloned [cd]tors. */
1975 DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
1979 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1980 COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
1981 COPY_DECL_RTL (newdecl, olddecl);
1983 if (! types_match || new_defines_function)
1985 /* These need to be copied so that the names are available.
1986 Note that if the types do match, we'll preserve inline
1987 info and other bits, but if not, we won't. */
1988 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
1989 DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
1991 if (new_defines_function)
1992 /* If defining a function declared with other language
1993 linkage, use the previously declared language linkage. */
1994 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1995 else if (types_match)
1997 /* If redeclaring a builtin function, and not a definition,
1998 it stays built in. */
1999 if (DECL_BUILT_IN (olddecl))
2001 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
2002 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
2003 /* If we're keeping the built-in definition, keep the rtl,
2004 regardless of declaration matches. */
2005 COPY_DECL_RTL (olddecl, newdecl);
2008 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
2009 /* Don't clear out the arguments if we're redefining a function. */
2010 if (DECL_ARGUMENTS (olddecl))
2011 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
2014 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
2015 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
2017 /* Now preserve various other info from the definition. */
2018 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
2019 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
2020 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
2021 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
2023 /* Warn about conflicting visibility specifications. */
2024 if (DECL_VISIBILITY_SPECIFIED (olddecl)
2025 && DECL_VISIBILITY_SPECIFIED (newdecl)
2026 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
2028 warning (OPT_Wattributes, "%q+D: visibility attribute ignored "
2029 "because it", newdecl);
2030 warning (OPT_Wattributes, "%Jconflicts with previous "
2031 "declaration here", olddecl);
2033 /* Choose the declaration which specified visibility. */
2034 if (DECL_VISIBILITY_SPECIFIED (olddecl))
2036 DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
2037 DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
2039 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2040 so keep this behavior. */
2041 if (TREE_CODE (newdecl) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (newdecl))
2043 SET_DECL_INIT_PRIORITY (olddecl, DECL_INIT_PRIORITY (newdecl));
2044 DECL_HAS_INIT_PRIORITY_P (olddecl) = 1;
2047 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2048 with that from NEWDECL below. */
2049 if (DECL_LANG_SPECIFIC (olddecl))
2051 gcc_assert (DECL_LANG_SPECIFIC (olddecl)
2052 != DECL_LANG_SPECIFIC (newdecl));
2053 ggc_free (DECL_LANG_SPECIFIC (olddecl));
2056 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2060 function_size = sizeof (struct tree_decl_common);
2062 memcpy ((char *) olddecl + sizeof (struct tree_common),
2063 (char *) newdecl + sizeof (struct tree_common),
2064 function_size - sizeof (struct tree_common));
2066 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2067 (char *) newdecl + sizeof (struct tree_decl_common),
2068 sizeof (struct tree_function_decl) - sizeof (struct tree_decl_common));
2070 /* If newdecl is a template instantiation, it is possible that
2071 the following sequence of events has occurred:
2073 o A friend function was declared in a class template. The
2074 class template was instantiated.
2076 o The instantiation of the friend declaration was
2077 recorded on the instantiation list, and is newdecl.
2079 o Later, however, instantiate_class_template called pushdecl
2080 on the newdecl to perform name injection. But, pushdecl in
2081 turn called duplicate_decls when it discovered that another
2082 declaration of a global function with the same name already
2085 o Here, in duplicate_decls, we decided to clobber newdecl.
2087 If we're going to do that, we'd better make sure that
2088 olddecl, and not newdecl, is on the list of
2089 instantiations so that if we try to do the instantiation
2090 again we won't get the clobbered declaration. */
2091 reregister_specialization (newdecl,
2097 size_t size = tree_code_size (TREE_CODE (olddecl));
2098 memcpy ((char *) olddecl + sizeof (struct tree_common),
2099 (char *) newdecl + sizeof (struct tree_common),
2100 sizeof (struct tree_decl_common) - sizeof (struct tree_common));
2101 switch (TREE_CODE (olddecl))
2111 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2112 (char *) newdecl + sizeof (struct tree_decl_common),
2113 size - sizeof (struct tree_decl_common)
2114 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2118 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2119 (char *) newdecl + sizeof (struct tree_decl_common),
2120 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common)
2121 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2125 DECL_UID (olddecl) = olddecl_uid;
2127 DECL_FRIEND_P (olddecl) = 1;
2130 DECL_ANTICIPATED (olddecl) = 1;
2131 DECL_HIDDEN_FRIEND_P (olddecl) = 1;
2134 /* NEWDECL contains the merged attribute lists.
2135 Update OLDDECL to be the same. */
2136 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
2138 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2139 so that encode_section_info has a chance to look at the new decl
2140 flags and attributes. */
2141 if (DECL_RTL_SET_P (olddecl)
2142 && (TREE_CODE (olddecl) == FUNCTION_DECL
2143 || (TREE_CODE (olddecl) == VAR_DECL
2144 && TREE_STATIC (olddecl))))
2145 make_decl_rtl (olddecl);
2147 /* The NEWDECL will no longer be needed. Because every out-of-class
2148 declaration of a member results in a call to duplicate_decls,
2149 freeing these nodes represents in a significant savings. */
2155 /* Return zero if the declaration NEWDECL is valid
2156 when the declaration OLDDECL (assumed to be for the same name)
2157 has already been seen.
2158 Otherwise return an error message format string with a %s
2159 where the identifier should go. */
2162 redeclaration_error_message (tree newdecl, tree olddecl)
2164 if (TREE_CODE (newdecl) == TYPE_DECL)
2166 /* Because C++ can put things into name space for free,
2167 constructs like "typedef struct foo { ... } foo"
2168 would look like an erroneous redeclaration. */
2169 if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
2172 return "redefinition of %q#D";
2174 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
2176 /* If this is a pure function, its olddecl will actually be
2177 the original initialization to `0' (which we force to call
2178 abort()). Don't complain about redefinition in this case. */
2179 if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl)
2180 && DECL_INITIAL (olddecl) == NULL_TREE)
2183 /* If both functions come from different namespaces, this is not
2184 a redeclaration - this is a conflict with a used function. */
2185 if (DECL_NAMESPACE_SCOPE_P (olddecl)
2186 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl)
2187 && ! decls_match (olddecl, newdecl))
2188 return "%qD conflicts with used function";
2190 /* We'll complain about linkage mismatches in
2191 warn_extern_redeclared_static. */
2193 /* Defining the same name twice is no good. */
2194 if (DECL_INITIAL (olddecl) != NULL_TREE
2195 && DECL_INITIAL (newdecl) != NULL_TREE)
2197 if (DECL_NAME (olddecl) == NULL_TREE)
2198 return "%q#D not declared in class";
2199 else if (!GNU_INLINE_P (olddecl)
2200 || GNU_INLINE_P (newdecl))
2201 return "redefinition of %q#D";
2204 if (DECL_DECLARED_INLINE_P (olddecl) && DECL_DECLARED_INLINE_P (newdecl))
2206 bool olda = GNU_INLINE_P (olddecl);
2207 bool newa = GNU_INLINE_P (newdecl);
2212 return "%q+D redeclared inline with %<gnu_inline%> attribute";
2214 return "%q+D redeclared inline without %<gnu_inline%> attribute";
2220 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2224 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2226 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl))
2227 && COMPLETE_TYPE_P (TREE_TYPE (olddecl)))
2228 return "redefinition of %q#D";
2232 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL
2233 || (DECL_TEMPLATE_RESULT (newdecl)
2234 == DECL_TEMPLATE_RESULT (olddecl)))
2237 nt = DECL_TEMPLATE_RESULT (newdecl);
2238 if (DECL_TEMPLATE_INFO (nt))
2239 nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt));
2240 ot = DECL_TEMPLATE_RESULT (olddecl);
2241 if (DECL_TEMPLATE_INFO (ot))
2242 ot = DECL_TEMPLATE_RESULT (template_for_substitution (ot));
2243 if (DECL_INITIAL (nt) && DECL_INITIAL (ot)
2244 && (!GNU_INLINE_P (ot) || GNU_INLINE_P (nt)))
2245 return "redefinition of %q#D";
2247 if (DECL_DECLARED_INLINE_P (ot) && DECL_DECLARED_INLINE_P (nt))
2249 bool olda = GNU_INLINE_P (ot);
2250 bool newa = GNU_INLINE_P (nt);
2255 return "%q+D redeclared inline with %<gnu_inline%> attribute";
2257 return "%q+D redeclared inline without %<gnu_inline%> attribute";
2261 /* Core issue #226 (C++0x):
2263 If a friend function template declaration specifies a
2264 default template-argument, that declaration shall be a
2265 definition and shall be the only declaration of the
2266 function template in the translation unit. */
2267 if ((cxx_dialect != cxx98)
2268 && TREE_CODE (ot) == FUNCTION_DECL && DECL_FRIEND_P (ot)
2269 && !check_default_tmpl_args (nt, DECL_TEMPLATE_PARMS (newdecl),
2270 /*is_primary=*/1, /*is_partial=*/0,
2271 /*is_friend_decl=*/2))
2272 return "redeclaration of friend %q#D may not have default template arguments";
2276 else if (TREE_CODE (newdecl) == VAR_DECL
2277 && DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl)
2278 && (! DECL_LANG_SPECIFIC (olddecl)
2279 || ! CP_DECL_THREADPRIVATE_P (olddecl)
2280 || DECL_THREAD_LOCAL_P (newdecl)))
2282 /* Only variables can be thread-local, and all declarations must
2283 agree on this property. */
2284 if (DECL_THREAD_LOCAL_P (newdecl))
2285 return "thread-local declaration of %q#D follows "
2286 "non-thread-local declaration";
2288 return "non-thread-local declaration of %q#D follows "
2289 "thread-local declaration";
2291 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
2293 /* The objects have been declared at namespace scope. If either
2294 is a member of an anonymous union, then this is an invalid
2295 redeclaration. For example:
2301 if ((TREE_CODE (newdecl) == VAR_DECL && DECL_ANON_UNION_VAR_P (newdecl))
2302 || (TREE_CODE (olddecl) == VAR_DECL && DECL_ANON_UNION_VAR_P (olddecl)))
2303 return "redeclaration of %q#D";
2304 /* If at least one declaration is a reference, there is no
2305 conflict. For example:
2311 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2313 /* Reject two definitions. */
2314 return "redefinition of %q#D";
2318 /* Objects declared with block scope: */
2319 /* Reject two definitions, and reject a definition
2320 together with an external reference. */
2321 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
2322 return "redeclaration of %q#D";
2327 /* Hash and equality functions for the named_label table. */
2330 named_label_entry_hash (const void *data)
2332 const struct named_label_entry *ent = (const struct named_label_entry *) data;
2333 return DECL_UID (ent->label_decl);
2337 named_label_entry_eq (const void *a, const void *b)
2339 const struct named_label_entry *ent_a = (const struct named_label_entry *) a;
2340 const struct named_label_entry *ent_b = (const struct named_label_entry *) b;
2341 return ent_a->label_decl == ent_b->label_decl;
2344 /* Create a new label, named ID. */
2347 make_label_decl (tree id, int local_p)
2349 struct named_label_entry *ent;
2353 decl = build_decl (LABEL_DECL, id, void_type_node);
2355 DECL_CONTEXT (decl) = current_function_decl;
2356 DECL_MODE (decl) = VOIDmode;
2357 C_DECLARED_LABEL_FLAG (decl) = local_p;
2359 /* Say where one reference is to the label, for the sake of the
2360 error if it is not defined. */
2361 DECL_SOURCE_LOCATION (decl) = input_location;
2363 /* Record the fact that this identifier is bound to this label. */
2364 SET_IDENTIFIER_LABEL_VALUE (id, decl);
2366 /* Create the label htab for the function on demand. */
2368 named_labels = htab_create_ggc (13, named_label_entry_hash,
2369 named_label_entry_eq, NULL);
2371 /* Record this label on the list of labels used in this function.
2372 We do this before calling make_label_decl so that we get the
2373 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2374 ent = GGC_CNEW (struct named_label_entry);
2375 ent->label_decl = decl;
2377 slot = htab_find_slot (named_labels, ent, INSERT);
2378 gcc_assert (*slot == NULL);
2384 /* Look for a label named ID in the current function. If one cannot
2385 be found, create one. (We keep track of used, but undefined,
2386 labels, and complain about them at the end of a function.) */
2389 lookup_label (tree id)
2393 timevar_push (TV_NAME_LOOKUP);
2394 /* You can't use labels at global scope. */
2395 if (current_function_decl == NULL_TREE)
2397 error ("label %qE referenced outside of any function", id);
2398 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2401 /* See if we've already got this label. */
2402 decl = IDENTIFIER_LABEL_VALUE (id);
2403 if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
2404 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2406 decl = make_label_decl (id, /*local_p=*/0);
2407 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2410 /* Declare a local label named ID. */
2413 declare_local_label (tree id)
2417 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2418 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2419 shadow = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
2420 current_binding_level->shadowed_labels);
2421 current_binding_level->shadowed_labels = shadow;
2423 decl = make_label_decl (id, /*local_p=*/1);
2424 TREE_VALUE (shadow) = decl;
2429 /* Returns nonzero if it is ill-formed to jump past the declaration of
2430 DECL. Returns 2 if it's also a real problem. */
2433 decl_jump_unsafe (tree decl)
2435 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl)
2436 || TREE_TYPE (decl) == error_mark_node)
2439 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
2440 || DECL_NONTRIVIALLY_INITIALIZED_P (decl))
2443 if (pod_type_p (TREE_TYPE (decl)))
2446 /* The POD stuff is just pedantry; why should it matter if the class
2447 contains a field of pointer to member type? */
2451 /* A subroutine of check_previous_goto_1 to identify a branch to the user. */
2454 identify_goto (tree decl, const location_t *locus)
2457 pedwarn ("jump to label %qD", decl);
2459 pedwarn ("jump to case label");
2461 pedwarn ("%H from here", locus);
2464 /* Check that a single previously seen jump to a newly defined label
2465 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2466 the jump context; NAMES are the names in scope in LEVEL at the jump
2467 context; LOCUS is the source position of the jump or 0. Returns
2468 true if all is well. */
2471 check_previous_goto_1 (tree decl, struct cp_binding_level* level, tree names,
2472 bool exited_omp, const location_t *locus)
2474 struct cp_binding_level *b;
2475 bool identified = false, saw_eh = false, saw_omp = false;
2479 identify_goto (decl, locus);
2480 error (" exits OpenMP structured block");
2481 identified = saw_omp = true;
2484 for (b = current_binding_level; b ; b = b->level_chain)
2486 tree new_decls, old_decls = (b == level ? names : NULL_TREE);
2488 for (new_decls = b->names; new_decls != old_decls;
2489 new_decls = TREE_CHAIN (new_decls))
2491 int problem = decl_jump_unsafe (new_decls);
2497 identify_goto (decl, locus);
2501 error (" crosses initialization of %q+#D", new_decls);
2503 pedwarn (" enters scope of non-POD %q+#D", new_decls);
2508 if ((b->kind == sk_try || b->kind == sk_catch) && !saw_eh)
2512 identify_goto (decl, locus);
2515 if (b->kind == sk_try)
2516 error (" enters try block");
2518 error (" enters catch block");
2521 if (b->kind == sk_omp && !saw_omp)
2525 identify_goto (decl, locus);
2528 error (" enters OpenMP structured block");
2537 check_previous_goto (tree decl, struct named_label_use_entry *use)
2539 check_previous_goto_1 (decl, use->binding_level,
2540 use->names_in_scope, use->in_omp_scope,
2541 &use->o_goto_locus);
2545 check_switch_goto (struct cp_binding_level* level)
2547 return check_previous_goto_1 (NULL_TREE, level, level->names, false, NULL);
2550 /* Check that a new jump to a label DECL is OK. Called by
2551 finish_goto_stmt. */
2554 check_goto (tree decl)
2556 struct named_label_entry *ent, dummy;
2557 bool saw_catch = false, identified = false;
2560 /* We can't know where a computed goto is jumping.
2561 So we assume that it's OK. */
2562 if (TREE_CODE (decl) != LABEL_DECL)
2565 /* We didn't record any information about this label when we created it,
2566 and there's not much point since it's trivial to analyze as a return. */
2567 if (decl == cdtor_label)
2570 dummy.label_decl = decl;
2571 ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2572 gcc_assert (ent != NULL);
2574 /* If the label hasn't been defined yet, defer checking. */
2575 if (! DECL_INITIAL (decl))
2577 struct named_label_use_entry *new_use;
2579 /* Don't bother creating another use if the last goto had the
2580 same data, and will therefore create the same set of errors. */
2582 && ent->uses->names_in_scope == current_binding_level->names)
2585 new_use = GGC_NEW (struct named_label_use_entry);
2586 new_use->binding_level = current_binding_level;
2587 new_use->names_in_scope = current_binding_level->names;
2588 new_use->o_goto_locus = input_location;
2589 new_use->in_omp_scope = false;
2591 new_use->next = ent->uses;
2592 ent->uses = new_use;
2596 if (ent->in_try_scope || ent->in_catch_scope
2597 || ent->in_omp_scope || ent->bad_decls)
2599 pedwarn ("jump to label %q+D", decl);
2600 pedwarn (" from here");
2604 for (bad = ent->bad_decls; bad; bad = TREE_CHAIN (bad))
2606 tree b = TREE_VALUE (bad);
2607 int u = decl_jump_unsafe (b);
2609 if (u > 1 && DECL_ARTIFICIAL (b))
2611 /* Can't skip init of __exception_info. */
2612 error ("%J enters catch block", b);
2616 error (" skips initialization of %q+#D", b);
2618 pedwarn (" enters scope of non-POD %q+#D", b);
2621 if (ent->in_try_scope)
2622 error (" enters try block");
2623 else if (ent->in_catch_scope && !saw_catch)
2624 error (" enters catch block");
2626 if (ent->in_omp_scope)
2627 error (" enters OpenMP structured block");
2628 else if (flag_openmp)
2630 struct cp_binding_level *b;
2631 for (b = current_binding_level; b ; b = b->level_chain)
2633 if (b == ent->binding_level)
2635 if (b->kind == sk_omp)
2639 pedwarn ("jump to label %q+D", decl);
2640 pedwarn (" from here");
2643 error (" exits OpenMP structured block");
2650 /* Check that a return is ok wrt OpenMP structured blocks.
2651 Called by finish_return_stmt. Returns true if all is well. */
2654 check_omp_return (void)
2656 struct cp_binding_level *b;
2657 for (b = current_binding_level; b ; b = b->level_chain)
2658 if (b->kind == sk_omp)
2660 error ("invalid exit from OpenMP structured block");
2666 /* Define a label, specifying the location in the source file.
2667 Return the LABEL_DECL node for the label. */
2670 define_label (location_t location, tree name)
2672 struct named_label_entry *ent, dummy;
2673 struct cp_binding_level *p;
2676 timevar_push (TV_NAME_LOOKUP);
2678 decl = lookup_label (name);
2680 dummy.label_decl = decl;
2681 ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2682 gcc_assert (ent != NULL);
2684 /* After labels, make any new cleanups in the function go into their
2685 own new (temporary) binding contour. */
2686 for (p = current_binding_level;
2687 p->kind != sk_function_parms;
2689 p->more_cleanups_ok = 0;
2691 if (name == get_identifier ("wchar_t"))
2692 pedwarn ("label named wchar_t");
2694 if (DECL_INITIAL (decl) != NULL_TREE)
2696 error ("duplicate label %qD", decl);
2697 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
2701 struct named_label_use_entry *use;
2703 /* Mark label as having been defined. */
2704 DECL_INITIAL (decl) = error_mark_node;
2705 /* Say where in the source. */
2706 DECL_SOURCE_LOCATION (decl) = location;
2708 ent->binding_level = current_binding_level;
2709 ent->names_in_scope = current_binding_level->names;
2711 for (use = ent->uses; use ; use = use->next)
2712 check_previous_goto (decl, use);
2716 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2721 struct cp_binding_level *level;
2722 struct cp_switch *next;
2723 /* The SWITCH_STMT being built. */
2725 /* A splay-tree mapping the low element of a case range to the high
2726 element, or NULL_TREE if there is no high element. Used to
2727 determine whether or not a new case label duplicates an old case
2728 label. We need a tree, rather than simply a hash table, because
2729 of the GNU case range extension. */
2733 /* A stack of the currently active switch statements. The innermost
2734 switch statement is on the top of the stack. There is no need to
2735 mark the stack for garbage collection because it is only active
2736 during the processing of the body of a function, and we never
2737 collect at that point. */
2739 static struct cp_switch *switch_stack;
2741 /* Called right after a switch-statement condition is parsed.
2742 SWITCH_STMT is the switch statement being parsed. */
2745 push_switch (tree switch_stmt)
2747 struct cp_switch *p = XNEW (struct cp_switch);
2748 p->level = current_binding_level;
2749 p->next = switch_stack;
2750 p->switch_stmt = switch_stmt;
2751 p->cases = splay_tree_new (case_compare, NULL, NULL);
2758 struct cp_switch *cs = switch_stack;
2759 location_t switch_location;
2761 /* Emit warnings as needed. */
2762 if (EXPR_HAS_LOCATION (cs->switch_stmt))
2763 switch_location = EXPR_LOCATION (cs->switch_stmt);
2765 switch_location = input_location;
2766 if (!processing_template_decl)
2767 c_do_switch_warnings (cs->cases, switch_location,
2768 SWITCH_STMT_TYPE (cs->switch_stmt),
2769 SWITCH_STMT_COND (cs->switch_stmt));
2771 splay_tree_delete (cs->cases);
2772 switch_stack = switch_stack->next;
2776 /* Note that we've seen a definition of a case label, and complain if this
2777 is a bad place for one. */
2780 finish_case_label (tree low_value, tree high_value)
2783 struct cp_binding_level *p;
2785 if (processing_template_decl)
2789 /* For templates, just add the case label; we'll do semantic
2790 analysis at instantiation-time. */
2791 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
2792 return add_stmt (build_case_label (low_value, high_value, label));
2795 /* Find the condition on which this switch statement depends. */
2796 cond = SWITCH_STMT_COND (switch_stack->switch_stmt);
2797 if (cond && TREE_CODE (cond) == TREE_LIST)
2798 cond = TREE_VALUE (cond);
2800 if (!check_switch_goto (switch_stack->level))
2801 return error_mark_node;
2803 r = c_add_case_label (switch_stack->cases, cond, TREE_TYPE (cond),
2804 low_value, high_value);
2806 /* After labels, make any new cleanups in the function go into their
2807 own new (temporary) binding contour. */
2808 for (p = current_binding_level;
2809 p->kind != sk_function_parms;
2811 p->more_cleanups_ok = 0;
2816 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
2819 typename_hash (const void* k)
2822 const_tree const t = (const_tree) k;
2824 hash = (htab_hash_pointer (TYPE_CONTEXT (t))
2825 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));
2830 typedef struct typename_info {
2838 /* Compare two TYPENAME_TYPEs. K1 is really of type `tree', K2 is
2839 really of type `typename_info*' */
2842 typename_compare (const void * k1, const void * k2)
2844 const_tree const t1 = (const_tree) k1;
2845 const typename_info *const t2 = (const typename_info *) k2;
2847 return (DECL_NAME (TYPE_NAME (t1)) == t2->name
2848 && TYPE_CONTEXT (t1) == t2->scope
2849 && TYPENAME_TYPE_FULLNAME (t1) == t2->template_id
2850 && TYPENAME_IS_ENUM_P (t1) == t2->enum_p
2851 && TYPENAME_IS_CLASS_P (t1) == t2->class_p);
2854 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
2855 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
2857 Returns the new TYPENAME_TYPE. */
2859 static GTY ((param_is (union tree_node))) htab_t typename_htab;
2862 build_typename_type (tree context, tree name, tree fullname,
2863 enum tag_types tag_type)
2871 if (typename_htab == NULL)
2872 typename_htab = htab_create_ggc (61, &typename_hash,
2873 &typename_compare, NULL);
2875 ti.scope = FROB_CONTEXT (context);
2877 ti.template_id = fullname;
2878 ti.enum_p = tag_type == enum_type;
2879 ti.class_p = (tag_type == class_type
2880 || tag_type == record_type
2881 || tag_type == union_type);
2882 hash = (htab_hash_pointer (ti.scope)
2883 ^ htab_hash_pointer (ti.name));
2885 /* See if we already have this type. */
2886 e = htab_find_slot_with_hash (typename_htab, &ti, hash, INSERT);
2891 /* Build the TYPENAME_TYPE. */
2892 t = make_aggr_type (TYPENAME_TYPE);
2893 TYPE_CONTEXT (t) = ti.scope;
2894 TYPENAME_TYPE_FULLNAME (t) = ti.template_id;
2895 TYPENAME_IS_ENUM_P (t) = ti.enum_p;
2896 TYPENAME_IS_CLASS_P (t) = ti.class_p;
2898 /* Build the corresponding TYPE_DECL. */
2899 d = build_decl (TYPE_DECL, name, t);
2900 TYPE_NAME (TREE_TYPE (d)) = d;
2901 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2902 DECL_CONTEXT (d) = FROB_CONTEXT (context);
2903 DECL_ARTIFICIAL (d) = 1;
2905 /* Store it in the hash table. */
2908 /* TYPENAME_TYPEs must always be compared structurally, because
2909 they may or may not resolve down to another type depending on
2910 the currently open classes. */
2911 SET_TYPE_STRUCTURAL_EQUALITY (t);
2917 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
2918 provided to name the type. Returns an appropriate type, unless an
2919 error occurs, in which case error_mark_node is returned. If we
2920 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
2921 return that, rather than the _TYPE it corresponds to, in other
2922 cases we look through the type decl. If TF_ERROR is set, complain
2923 about errors, otherwise be quiet. */
2926 make_typename_type (tree context, tree name, enum tag_types tag_type,
2927 tsubst_flags_t complain)
2933 if (name == error_mark_node
2934 || context == NULL_TREE
2935 || context == error_mark_node)
2936 return error_mark_node;
2940 if (!(TYPE_LANG_SPECIFIC (name)
2941 && (CLASSTYPE_IS_TEMPLATE (name)
2942 || CLASSTYPE_USE_TEMPLATE (name))))
2943 name = TYPE_IDENTIFIER (name);
2945 /* Create a TEMPLATE_ID_EXPR for the type. */
2946 name = build_nt (TEMPLATE_ID_EXPR,
2947 CLASSTYPE_TI_TEMPLATE (name),
2948 CLASSTYPE_TI_ARGS (name));
2950 else if (TREE_CODE (name) == TYPE_DECL)
2951 name = DECL_NAME (name);
2955 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
2957 name = TREE_OPERAND (name, 0);
2958 if (TREE_CODE (name) == TEMPLATE_DECL)
2959 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
2960 else if (TREE_CODE (name) == OVERLOAD)
2962 error ("%qD is not a type", name);
2963 return error_mark_node;
2966 if (TREE_CODE (name) == TEMPLATE_DECL)
2968 error ("%qD used without template parameters", name);
2969 return error_mark_node;
2971 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
2972 gcc_assert (TYPE_P (context));
2974 /* When the CONTEXT is a dependent type, NAME could refer to a
2975 dependent base class of CONTEXT. So we cannot peek inside it,
2976 even if CONTEXT is a currently open scope. */
2977 if (dependent_type_p (context))
2978 return build_typename_type (context, name, fullname, tag_type);
2980 if (!IS_AGGR_TYPE (context))
2982 if (complain & tf_error)
2983 error ("%q#T is not a class", context);
2984 return error_mark_node;
2987 want_template = TREE_CODE (fullname) == TEMPLATE_ID_EXPR;
2989 /* We should only set WANT_TYPE when we're a nested typename type.
2990 Then we can give better diagnostics if we find a non-type. */
2991 t = lookup_field (context, name, 0, /*want_type=*/true);
2994 if (complain & tf_error)
2995 error (want_template ? "no class template named %q#T in %q#T"
2996 : "no type named %q#T in %q#T", name, context);
2997 return error_mark_node;
3000 if (want_template && !DECL_CLASS_TEMPLATE_P (t))
3002 if (complain & tf_error)
3003 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3005 return error_mark_node;
3007 if (!want_template && TREE_CODE (t) != TYPE_DECL)
3009 if (complain & tf_error)
3010 error ("%<typename %T::%D%> names %q#T, which is not a type",
3012 return error_mark_node;
3015 if (complain & tf_error)
3016 perform_or_defer_access_check (TYPE_BINFO (context), t, t);
3019 return lookup_template_class (t, TREE_OPERAND (fullname, 1),
3021 /*entering_scope=*/0,
3022 tf_warning_or_error | tf_user);
3024 if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
3030 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3031 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3032 in which case error_mark_node is returned.
3034 If PARM_LIST is non-NULL, also make sure that the template parameter
3035 list of TEMPLATE_DECL matches.
3037 If COMPLAIN zero, don't complain about any errors that occur. */
3040 make_unbound_class_template (tree context, tree name, tree parm_list,
3041 tsubst_flags_t complain)
3047 name = TYPE_IDENTIFIER (name);
3048 else if (DECL_P (name))
3049 name = DECL_NAME (name);
3050 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
3052 if (!dependent_type_p (context)
3053 || currently_open_class (context))
3055 tree tmpl = NULL_TREE;
3057 if (IS_AGGR_TYPE (context))
3058 tmpl = lookup_field (context, name, 0, false);
3060 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
3062 if (complain & tf_error)
3063 error ("no class template named %q#T in %q#T", name, context);
3064 return error_mark_node;
3068 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl), parm_list))
3070 if (complain & tf_error)
3072 error ("template parameters do not match template");
3073 error ("%q+D declared here", tmpl);
3075 return error_mark_node;
3078 if (complain & tf_error)
3079 perform_or_defer_access_check (TYPE_BINFO (context), tmpl, tmpl);
3084 /* Build the UNBOUND_CLASS_TEMPLATE. */
3085 t = make_aggr_type (UNBOUND_CLASS_TEMPLATE);
3086 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
3087 TREE_TYPE (t) = NULL_TREE;
3088 SET_TYPE_STRUCTURAL_EQUALITY (t);
3090 /* Build the corresponding TEMPLATE_DECL. */
3091 d = build_decl (TEMPLATE_DECL, name, t);
3092 TYPE_NAME (TREE_TYPE (d)) = d;
3093 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
3094 DECL_CONTEXT (d) = FROB_CONTEXT (context);
3095 DECL_ARTIFICIAL (d) = 1;
3096 DECL_TEMPLATE_PARMS (d) = parm_list;
3103 /* Push the declarations of builtin types into the namespace.
3104 RID_INDEX is the index of the builtin type in the array
3105 RID_POINTERS. NAME is the name used when looking up the builtin
3106 type. TYPE is the _TYPE node for the builtin type. */
3109 record_builtin_type (enum rid rid_index,
3113 tree rname = NULL_TREE, tname = NULL_TREE;
3114 tree tdecl = NULL_TREE;
3116 if ((int) rid_index < (int) RID_MAX)
3117 rname = ridpointers[(int) rid_index];
3119 tname = get_identifier (name);
3121 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
3122 eliminated. Built-in types should not be looked up name; their
3123 names are keywords that the parser can recognize. However, there
3124 is code in c-common.c that uses identifier_global_value to look
3125 up built-in types by name. */
3128 tdecl = build_decl (TYPE_DECL, tname, type);
3129 DECL_ARTIFICIAL (tdecl) = 1;
3130 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
3136 tdecl = build_decl (TYPE_DECL, rname, type);
3137 DECL_ARTIFICIAL (tdecl) = 1;
3139 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
3142 if (!TYPE_NAME (type))
3143 TYPE_NAME (type) = tdecl;
3146 debug_hooks->type_decl (tdecl, 0);
3149 /* Record one of the standard Java types.
3150 * Declare it as having the given NAME.
3151 * If SIZE > 0, it is the size of one of the integral types;
3152 * otherwise it is the negative of the size of one of the other types. */
3155 record_builtin_java_type (const char* name, int size)
3159 type = make_signed_type (size);
3160 else if (size > -32)
3161 { /* "__java_char" or ""__java_boolean". */
3162 type = make_unsigned_type (-size);
3163 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
3166 { /* "__java_float" or ""__java_double". */
3167 type = make_node (REAL_TYPE);
3168 TYPE_PRECISION (type) = - size;
3171 record_builtin_type (RID_MAX, name, type);
3172 decl = TYPE_NAME (type);
3174 /* Suppress generate debug symbol entries for these types,
3175 since for normal C++ they are just clutter.
3176 However, push_lang_context undoes this if extern "Java" is seen. */
3177 DECL_IGNORED_P (decl) = 1;
3179 TYPE_FOR_JAVA (type) = 1;
3183 /* Push a type into the namespace so that the back ends ignore it. */
3186 record_unknown_type (tree type, const char* name)
3188 tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
3189 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3190 DECL_IGNORED_P (decl) = 1;
3191 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
3192 TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
3193 TYPE_ALIGN (type) = 1;
3194 TYPE_USER_ALIGN (type) = 0;
3195 TYPE_MODE (type) = TYPE_MODE (void_type_node);
3198 /* A string for which we should create an IDENTIFIER_NODE at
3201 typedef struct predefined_identifier
3203 /* The name of the identifier. */
3204 const char *const name;
3205 /* The place where the IDENTIFIER_NODE should be stored. */
3207 /* Nonzero if this is the name of a constructor or destructor. */
3208 const int ctor_or_dtor_p;
3209 } predefined_identifier;
3211 /* Create all the predefined identifiers. */
3214 initialize_predefined_identifiers (void)
3216 const predefined_identifier *pid;
3218 /* A table of identifiers to create at startup. */
3219 static const predefined_identifier predefined_identifiers[] = {
3220 { "C++", &lang_name_cplusplus, 0 },
3221 { "C", &lang_name_c, 0 },
3222 { "Java", &lang_name_java, 0 },
3223 /* Some of these names have a trailing space so that it is
3224 impossible for them to conflict with names written by users. */
3225 { "__ct ", &ctor_identifier, 1 },
3226 { "__base_ctor ", &base_ctor_identifier, 1 },
3227 { "__comp_ctor ", &complete_ctor_identifier, 1 },
3228 { "__dt ", &dtor_identifier, 1 },
3229 { "__comp_dtor ", &complete_dtor_identifier, 1 },
3230 { "__base_dtor ", &base_dtor_identifier, 1 },
3231 { "__deleting_dtor ", &deleting_dtor_identifier, 1 },
3232 { IN_CHARGE_NAME, &in_charge_identifier, 0 },
3233 { "nelts", &nelts_identifier, 0 },
3234 { THIS_NAME, &this_identifier, 0 },
3235 { VTABLE_DELTA_NAME, &delta_identifier, 0 },
3236 { VTABLE_PFN_NAME, &pfn_identifier, 0 },
3237 { "_vptr", &vptr_identifier, 0 },
3238 { "__vtt_parm", &vtt_parm_identifier, 0 },
3239 { "::", &global_scope_name, 0 },
3240 { "std", &std_identifier, 0 },
3244 for (pid = predefined_identifiers; pid->name; ++pid)
3246 *pid->node = get_identifier (pid->name);
3247 if (pid->ctor_or_dtor_p)
3248 IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
3252 /* Create the predefined scalar types of C,
3253 and some nodes representing standard constants (0, 1, (void *)0).
3254 Initialize the global binding level.
3255 Make definitions for built-in primitive functions. */
3258 cxx_init_decl_processing (void)
3261 tree void_ftype_ptr;
3263 build_common_tree_nodes (flag_signed_char, false);
3265 /* Create all the identifiers we need. */
3266 initialize_predefined_identifiers ();
3268 /* Create the global variables. */
3269 push_to_top_level ();
3271 current_function_decl = NULL_TREE;
3272 current_binding_level = NULL;
3273 /* Enter the global namespace. */
3274 gcc_assert (global_namespace == NULL_TREE);
3275 global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name,
3277 TREE_PUBLIC (global_namespace) = 1;
3278 begin_scope (sk_namespace, global_namespace);
3280 current_lang_name = NULL_TREE;
3282 if (flag_visibility_ms_compat)
3283 default_visibility = VISIBILITY_HIDDEN;
3286 current_lang_name = lang_name_c;
3288 /* Create the `std' namespace. */
3289 push_namespace (std_identifier);
3290 std_node = current_namespace;
3293 c_common_nodes_and_builtins ();
3295 java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
3296 java_short_type_node = record_builtin_java_type ("__java_short", 16);
3297 java_int_type_node = record_builtin_java_type ("__java_int", 32);
3298 java_long_type_node = record_builtin_java_type ("__java_long", 64);
3299 java_float_type_node = record_builtin_java_type ("__java_float", -32);
3300 java_double_type_node = record_builtin_java_type ("__java_double", -64);
3301 java_char_type_node = record_builtin_java_type ("__java_char", -16);
3302 java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
3304 integer_two_node = build_int_cst (NULL_TREE, 2);
3305 integer_three_node = build_int_cst (NULL_TREE, 3);
3307 record_builtin_type (RID_BOOL, "bool", boolean_type_node);
3308 truthvalue_type_node = boolean_type_node;
3309 truthvalue_false_node = boolean_false_node;
3310 truthvalue_true_node = boolean_true_node;
3312 empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
3315 record_builtin_type (RID_MAX, NULL, string_type_node);
3318 delta_type_node = ptrdiff_type_node;
3319 vtable_index_type = ptrdiff_type_node;
3321 vtt_parm_type = build_pointer_type (const_ptr_type_node);
3322 void_ftype = build_function_type (void_type_node, void_list_node);
3323 void_ftype_ptr = build_function_type (void_type_node,
3324 tree_cons (NULL_TREE,
3328 = build_exception_variant (void_ftype_ptr, empty_except_spec);
3330 /* C++ extensions */
3332 unknown_type_node = make_node (UNKNOWN_TYPE);
3333 record_unknown_type (unknown_type_node, "unknown type");
3335 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3336 TREE_TYPE (unknown_type_node) = unknown_type_node;
3338 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3340 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
3341 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
3344 /* Make sure we get a unique function type, so we can give
3345 its pointer type a name. (This wins for gdb.) */
3346 tree vfunc_type = make_node (FUNCTION_TYPE);
3347 TREE_TYPE (vfunc_type) = integer_type_node;
3348 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
3349 layout_type (vfunc_type);
3351 vtable_entry_type = build_pointer_type (vfunc_type);
3353 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
3356 = build_cplus_array_type (vtable_entry_type, NULL_TREE);
3357 layout_type (vtbl_type_node);
3358 vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
3359 record_builtin_type (RID_MAX, NULL, vtbl_type_node);
3360 vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
3361 layout_type (vtbl_ptr_type_node);
3362 record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
3364 push_namespace (get_identifier ("__cxxabiv1"));
3365 abi_node = current_namespace;
3368 global_type_node = make_node (LANG_TYPE);
3369 record_unknown_type (global_type_node, "global type");
3372 current_lang_name = lang_name_cplusplus;
3376 tree bad_alloc_type_node;
3377 tree bad_alloc_decl;
3378 tree newtype, deltype;
3379 tree ptr_ftype_sizetype;
3381 push_namespace (std_identifier);
3382 bad_alloc_id = get_identifier ("bad_alloc");
3383 bad_alloc_type_node = make_aggr_type (RECORD_TYPE);
3384 TYPE_CONTEXT (bad_alloc_type_node) = current_namespace;
3386 = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node);
3387 DECL_CONTEXT (bad_alloc_decl) = current_namespace;
3388 TYPE_STUB_DECL (bad_alloc_type_node) = bad_alloc_decl;
3392 = build_function_type (ptr_type_node,
3393 tree_cons (NULL_TREE,
3396 newtype = build_exception_variant
3397 (ptr_ftype_sizetype, add_exception_specifier
3398 (NULL_TREE, bad_alloc_type_node, -1));
3399 deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
3400 push_cp_library_fn (NEW_EXPR, newtype);
3401 push_cp_library_fn (VEC_NEW_EXPR, newtype);
3402 global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
3403 push_cp_library_fn (VEC_DELETE_EXPR, deltype);
3407 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
3409 /* Perform other language dependent initializations. */
3410 init_class_processing ();
3411 init_rtti_processing ();
3413 if (flag_exceptions)
3414 init_exception_processing ();
3416 if (! supports_one_only ())
3419 make_fname_decl = cp_make_fname_decl;
3420 start_fname_decls ();
3422 /* Show we use EH for cleanups. */
3423 if (flag_exceptions)
3424 using_eh_for_cleanups ();
3427 /* Generate an initializer for a function naming variable from
3428 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3429 filled in with the type of the init. */
3432 cp_fname_init (const char* name, tree *type_p)
3434 tree domain = NULL_TREE;
3436 tree init = NULL_TREE;
3441 length = strlen (name);
3442 domain = build_index_type (size_int (length));
3443 init = build_string (length + 1, name);
3446 type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
3447 type = build_cplus_array_type (type, domain);
3452 TREE_TYPE (init) = type;
3454 init = error_mark_node;
3459 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
3460 decl, NAME is the initialization string and TYPE_DEP indicates whether
3461 NAME depended on the type of the function. We make use of that to detect
3462 __PRETTY_FUNCTION__ inside a template fn. This is being done
3463 lazily at the point of first use, so we mustn't push the decl now. */
3466 cp_make_fname_decl (tree id, int type_dep)
3468 const char *const name = (type_dep && processing_template_decl
3469 ? NULL : fname_as_string (type_dep));
3471 tree init = cp_fname_init (name, &type);
3472 tree decl = build_decl (VAR_DECL, id, type);
3475 free (CONST_CAST (char *, name));
3477 /* As we're using pushdecl_with_scope, we must set the context. */
3478 DECL_CONTEXT (decl) = current_function_decl;
3479 DECL_PRETTY_FUNCTION_P (decl) = type_dep;
3481 TREE_STATIC (decl) = 1;
3482 TREE_READONLY (decl) = 1;
3483 DECL_ARTIFICIAL (decl) = 1;
3485 TREE_USED (decl) = 1;
3487 if (current_function_decl)
3489 struct cp_binding_level *b = current_binding_level;
3490 while (b->level_chain->kind != sk_function_parms)
3492 pushdecl_with_scope (decl, b, /*is_friend=*/false);
3493 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE,
3494 LOOKUP_ONLYCONVERTING);
3497 pushdecl_top_level_and_finish (decl, init);
3503 builtin_function_1 (tree decl, tree context)
3505 tree id = DECL_NAME (decl);
3506 const char *name = IDENTIFIER_POINTER (id);
3508 retrofit_lang_decl (decl);
3510 /* All nesting of C++ functions is lexical; there is never a "static
3511 chain" in the sense of GNU C nested functions. */
3512 DECL_NO_STATIC_CHAIN (decl) = 1;
3514 DECL_ARTIFICIAL (decl) = 1;
3515 SET_OVERLOADED_OPERATOR_CODE (decl, ERROR_MARK);
3516 SET_DECL_LANGUAGE (decl, lang_c);
3517 /* Runtime library routines are, by definition, available in an
3518 external shared object. */
3519 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
3520 DECL_VISIBILITY_SPECIFIED (decl) = 1;
3522 DECL_CONTEXT (decl) = context;
3526 /* A function in the user's namespace should have an explicit
3527 declaration before it is used. Mark the built-in function as
3528 anticipated but not actually declared. */
3529 if (name[0] != '_' || name[1] != '_')
3530 DECL_ANTICIPATED (decl) = 1;
3531 else if (strncmp (name + 2, "builtin_", strlen ("builtin_")) != 0)
3533 size_t len = strlen (name);
3535 /* Treat __*_chk fortification functions as anticipated as well,
3536 unless they are __builtin_*. */
3537 if (len > strlen ("___chk")
3538 && memcmp (name + len - strlen ("_chk"),
3539 "_chk", strlen ("_chk") + 1) == 0)
3540 DECL_ANTICIPATED (decl) = 1;
3547 cxx_builtin_function (tree decl)
3549 tree id = DECL_NAME (decl);
3550 const char *name = IDENTIFIER_POINTER (id);
3551 /* All builtins that don't begin with an '_' should additionally
3552 go in the 'std' namespace. */
3555 tree decl2 = copy_node(decl);
3556 push_namespace (std_identifier);
3557 builtin_function_1 (decl2, std_node);
3561 return builtin_function_1 (decl, NULL_TREE);
3564 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
3565 function. Not called directly. */
3568 build_library_fn_1 (tree name, enum tree_code operator_code, tree type)
3570 tree fn = build_lang_decl (FUNCTION_DECL, name, type);
3571 DECL_EXTERNAL (fn) = 1;
3572 TREE_PUBLIC (fn) = 1;
3573 DECL_ARTIFICIAL (fn) = 1;
3574 SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
3575 SET_DECL_LANGUAGE (fn, lang_c);
3576 /* Runtime library routines are, by definition, available in an
3577 external shared object. */
3578 DECL_VISIBILITY (fn) = VISIBILITY_DEFAULT;
3579 DECL_VISIBILITY_SPECIFIED (fn) = 1;
3583 /* Returns the _DECL for a library function with C linkage.
3584 We assume that such functions never throw; if this is incorrect,
3585 callers should unset TREE_NOTHROW. */
3588 build_library_fn (tree name, tree type)
3590 tree fn = build_library_fn_1 (name, ERROR_MARK, type);
3591 TREE_NOTHROW (fn) = 1;
3595 /* Returns the _DECL for a library function with C++ linkage. */
3598 build_cp_library_fn (tree name, enum tree_code operator_code, tree type)
3600 tree fn = build_library_fn_1 (name, operator_code, type);
3601 TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
3602 DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
3603 SET_DECL_LANGUAGE (fn, lang_cplusplus);
3607 /* Like build_library_fn, but takes a C string instead of an
3611 build_library_fn_ptr (const char* name, tree type)
3613 return build_library_fn (get_identifier (name), type);
3616 /* Like build_cp_library_fn, but takes a C string instead of an
3620 build_cp_library_fn_ptr (const char* name, tree type)
3622 return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
3625 /* Like build_library_fn, but also pushes the function so that we will
3626 be able to find it via IDENTIFIER_GLOBAL_VALUE. */
3629 push_library_fn (tree name, tree type)
3631 tree fn = build_library_fn (name, type);
3632 pushdecl_top_level (fn);
3636 /* Like build_cp_library_fn, but also pushes the function so that it
3637 will be found by normal lookup. */
3640 push_cp_library_fn (enum tree_code operator_code, tree type)
3642 tree fn = build_cp_library_fn (ansi_opname (operator_code),
3649 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
3653 push_void_library_fn (tree name, tree parmtypes)
3655 tree type = build_function_type (void_type_node, parmtypes);
3656 return push_library_fn (name, type);
3659 /* Like push_library_fn, but also note that this function throws
3660 and does not return. Used for __throw_foo and the like. */
3663 push_throw_library_fn (tree name, tree type)
3665 tree fn = push_library_fn (name, type);
3666 TREE_THIS_VOLATILE (fn) = 1;
3667 TREE_NOTHROW (fn) = 0;
3671 /* When we call finish_struct for an anonymous union, we create
3672 default copy constructors and such. But, an anonymous union
3673 shouldn't have such things; this function undoes the damage to the
3674 anonymous union type T.
3676 (The reason that we create the synthesized methods is that we don't
3677 distinguish `union { int i; }' from `typedef union { int i; } U'.
3678 The first is an anonymous union; the second is just an ordinary
3682 fixup_anonymous_aggr (tree t)
3686 /* Wipe out memory of synthesized methods. */
3687 TYPE_HAS_CONSTRUCTOR (t) = 0;
3688 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
3689 TYPE_HAS_INIT_REF (t) = 0;
3690 TYPE_HAS_CONST_INIT_REF (t) = 0;
3691 TYPE_HAS_ASSIGN_REF (t) = 0;
3692 TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
3694 /* Splice the implicitly generated functions out of the TYPE_METHODS
3696 q = &TYPE_METHODS (t);
3699 if (DECL_ARTIFICIAL (*q))
3700 *q = TREE_CHAIN (*q);
3702 q = &TREE_CHAIN (*q);
3705 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
3706 if (TYPE_METHODS (t))
3708 tree decl = TYPE_MAIN_DECL (t);
3710 if (TREE_CODE (t) != UNION_TYPE)
3711 error ("%Jan anonymous struct cannot have function members", decl);
3713 error ("%Jan anonymous union cannot have function members", decl);
3716 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
3717 assignment operators (because they cannot have these methods themselves).
3718 For anonymous unions this is already checked because they are not allowed
3719 in any union, otherwise we have to check it. */
3720 if (TREE_CODE (t) != UNION_TYPE)
3724 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
3725 if (TREE_CODE (field) == FIELD_DECL)
3727 type = TREE_TYPE (field);
3728 if (CLASS_TYPE_P (type))
3730 if (TYPE_NEEDS_CONSTRUCTING (type))
3731 error ("member %q+#D with constructor not allowed "
3732 "in anonymous aggregate", field);
3733 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
3734 error ("member %q+#D with destructor not allowed "
3735 "in anonymous aggregate", field);
3736 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
3737 error ("member %q+#D with copy assignment operator "
3738 "not allowed in anonymous aggregate", field);
3744 /* Make sure that a declaration with no declarator is well-formed, i.e.
3745 just declares a tagged type or anonymous union.
3747 Returns the type declared; or NULL_TREE if none. */
3750 check_tag_decl (cp_decl_specifier_seq *declspecs)
3752 int saw_friend = declspecs->specs[(int)ds_friend] != 0;
3753 int saw_typedef = declspecs->specs[(int)ds_typedef] != 0;
3754 /* If a class, struct, or enum type is declared by the DECLSPECS
3755 (i.e, if a class-specifier, enum-specifier, or non-typename
3756 elaborated-type-specifier appears in the DECLSPECS),
3757 DECLARED_TYPE is set to the corresponding type. */
3758 tree declared_type = NULL_TREE;
3759 bool error_p = false;
3761 if (declspecs->multiple_types_p)
3762 error ("multiple types in one declaration");
3763 else if (declspecs->redefined_builtin_type)
3765 if (!in_system_header)
3766 pedwarn ("redeclaration of C++ built-in type %qT",
3767 declspecs->redefined_builtin_type);
3772 && TYPE_P (declspecs->type)
3773 && ((TREE_CODE (declspecs->type) != TYPENAME_TYPE
3774 && IS_AGGR_TYPE (declspecs->type))
3775 || TREE_CODE (declspecs->type) == ENUMERAL_TYPE))
3776 declared_type = declspecs->type;
3777 else if (declspecs->type == error_mark_node)
3779 if (declared_type == NULL_TREE && ! saw_friend && !error_p)
3780 pedwarn ("declaration does not declare anything");
3781 /* Check for an anonymous union. */
3782 else if (declared_type && IS_AGGR_TYPE_CODE (TREE_CODE (declared_type))
3783 && TYPE_ANONYMOUS_P (declared_type))
3785 /* 7/3 In a simple-declaration, the optional init-declarator-list
3786 can be omitted only when declaring a class (clause 9) or
3787 enumeration (7.2), that is, when the decl-specifier-seq contains
3788 either a class-specifier, an elaborated-type-specifier with
3789 a class-key (9.1), or an enum-specifier. In these cases and
3790 whenever a class-specifier or enum-specifier is present in the
3791 decl-specifier-seq, the identifiers in these specifiers are among
3792 the names being declared by the declaration (as class-name,
3793 enum-names, or enumerators, depending on the syntax). In such
3794 cases, and except for the declaration of an unnamed bit-field (9.6),
3795 the decl-specifier-seq shall introduce one or more names into the
3796 program, or shall redeclare a name introduced by a previous
3797 declaration. [Example:
3798 enum { }; // ill-formed
3799 typedef class { }; // ill-formed
3803 error ("missing type-name in typedef-declaration");
3806 /* Anonymous unions are objects, so they can have specifiers. */;
3807 SET_ANON_AGGR_TYPE_P (declared_type);
3809 if (TREE_CODE (declared_type) != UNION_TYPE && pedantic
3810 && !in_system_header)
3811 pedwarn ("ISO C++ prohibits anonymous structs");
3816 if (declspecs->specs[(int)ds_inline]
3817 || declspecs->specs[(int)ds_virtual])
3818 error ("%qs can only be specified for functions",
3819 declspecs->specs[(int)ds_inline]
3820 ? "inline" : "virtual");
3822 && (!current_class_type
3823 || current_scope () != current_class_type))
3824 error ("%<friend%> can only be specified inside a class");
3825 else if (declspecs->specs[(int)ds_explicit])
3826 error ("%<explicit%> can only be specified for constructors");
3827 else if (declspecs->storage_class)
3828 error ("a storage class can only be specified for objects "
3830 else if (declspecs->specs[(int)ds_const]
3831 || declspecs->specs[(int)ds_volatile]
3832 || declspecs->specs[(int)ds_restrict]
3833 || declspecs->specs[(int)ds_thread])
3834 error ("qualifiers can only be specified for objects "
3836 else if (saw_typedef)
3837 warning (0, "%<typedef%> was ignored in this declaration");
3840 return declared_type;
3843 /* Called when a declaration is seen that contains no names to declare.
3844 If its type is a reference to a structure, union or enum inherited
3845 from a containing scope, shadow that tag name for the current scope
3846 with a forward reference.
3847 If its type defines a new named structure or union
3848 or defines an enum, it is valid but we need not do anything here.
3849 Otherwise, it is an error.
3851 C++: may have to grok the declspecs to learn about static,
3852 complain for anonymous unions.
3854 Returns the TYPE declared -- or NULL_TREE if none. */
3857 shadow_tag (cp_decl_specifier_seq *declspecs)
3859 tree t = check_tag_decl (declspecs);
3864 if (declspecs->attributes)
3866 warning (0, "attribute ignored in declaration of %q+#T", t);
3867 warning (0, "attribute for %q+#T must follow the %qs keyword",
3868 t, class_key_or_enum_as_string (t));
3872 if (maybe_process_partial_specialization (t) == error_mark_node)
3875 /* This is where the variables in an anonymous union are
3876 declared. An anonymous union declaration looks like:
3878 because there is no declarator after the union, the parser
3879 sends that declaration here. */
3880 if (ANON_AGGR_TYPE_P (t))
3882 fixup_anonymous_aggr (t);
3884 if (TYPE_FIELDS (t))
3886 tree decl = grokdeclarator (/*declarator=*/NULL,
3887 declspecs, NORMAL, 0, NULL);
3888 finish_anon_union (decl);
3895 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
3898 groktypename (cp_decl_specifier_seq *type_specifiers,
3899 const cp_declarator *declarator)
3903 attrs = type_specifiers->attributes;
3904 type_specifiers->attributes = NULL_TREE;
3905 type = grokdeclarator (declarator, type_specifiers, TYPENAME, 0, &attrs);
3908 if (CLASS_TYPE_P (type))
3909 warning (OPT_Wattributes, "ignoring attributes applied to class type "
3910 "outside of definition");
3912 cplus_decl_attributes (&type, attrs, 0);
3917 /* Decode a declarator in an ordinary declaration or data definition.
3918 This is called as soon as the type information and variable name
3919 have been parsed, before parsing the initializer if any.
3920 Here we create the ..._DECL node, fill in its type,
3921 and put it on the list of decls for the current context.
3922 The ..._DECL node is returned as the value.
3924 Exception: for arrays where the length is not specified,
3925 the type is left null, to be filled in by `cp_finish_decl'.
3927 Function definitions do not come here; they go to start_function
3928 instead. However, external and forward declarations of functions
3929 do go through here. Structure field declarations are done by
3930 grokfield and not through here. */
3933 start_decl (const cp_declarator *declarator,
3934 cp_decl_specifier_seq *declspecs,
3937 tree prefix_attributes,
3938 tree *pushed_scope_p)
3945 *pushed_scope_p = NULL_TREE;
3947 /* An object declared as __attribute__((deprecated)) suppresses
3948 warnings of uses of other deprecated items. */
3949 if (lookup_attribute ("deprecated", attributes))
3950 deprecated_state = DEPRECATED_SUPPRESS;
3952 attributes = chainon (attributes, prefix_attributes);
3954 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
3957 deprecated_state = DEPRECATED_NORMAL;
3959 if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE
3960 || decl == error_mark_node)
3961 return error_mark_node;
3963 type = TREE_TYPE (decl);
3965 context = DECL_CONTEXT (decl);
3969 *pushed_scope_p = push_scope (context);
3971 /* We are only interested in class contexts, later. */
3972 if (TREE_CODE (context) == NAMESPACE_DECL)
3973 context = NULL_TREE;
3977 /* Is it valid for this decl to have an initializer at all?
3978 If not, set INITIALIZED to zero, which will indirectly
3979 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
3980 switch (TREE_CODE (decl))
3983 error ("typedef %qD is initialized (use __typeof__ instead)", decl);
3984 return error_mark_node;
3987 error ("function %q#D is initialized like a variable", decl);
3988 return error_mark_node;
3996 if (! toplevel_bindings_p ()
3997 && DECL_EXTERNAL (decl))
3998 warning (0, "declaration of %q#D has %<extern%> and is initialized",
4000 DECL_EXTERNAL (decl) = 0;
4001 if (toplevel_bindings_p ())
4002 TREE_STATIC (decl) = 1;
4005 /* Set attributes here so if duplicate decl, will have proper attributes. */
4006 cplus_decl_attributes (&decl, attributes, 0);
4008 /* Dllimported symbols cannot be defined. Static data members (which
4009 can be initialized in-class and dllimported) go through grokfield,
4010 not here, so we don't need to exclude those decls when checking for
4012 if (initialized && DECL_DLLIMPORT_P (decl))
4014 error ("definition of %q#D is marked %<dllimport%>", decl);
4015 DECL_DLLIMPORT_P (decl) = 0;
4018 /* If #pragma weak was used, mark the decl weak now. */
4019 maybe_apply_pragma_weak (decl);
4021 if (TREE_CODE (decl) == FUNCTION_DECL
4022 && DECL_DECLARED_INLINE_P (decl)
4023 && DECL_UNINLINABLE (decl)
4024 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
4025 warning (0, "inline function %q+D given attribute noinline", decl);
4027 if (context && COMPLETE_TYPE_P (complete_type (context)))
4029 if (TREE_CODE (decl) == VAR_DECL)
4031 tree field = lookup_field (context, DECL_NAME (decl), 0, false);
4032 if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
4033 error ("%q#D is not a static member of %q#T", decl, context);
4036 if (DECL_CONTEXT (field) != context)
4038 if (!same_type_p (DECL_CONTEXT (field), context))
4039 pedwarn ("ISO C++ does not permit %<%T::%D%> "
4040 "to be defined as %<%T::%D%>",
4041 DECL_CONTEXT (field), DECL_NAME (decl),
4042 context, DECL_NAME (decl));
4043 DECL_CONTEXT (decl) = DECL_CONTEXT (field);
4045 if (processing_specialization
4046 && template_class_depth (context) == 0
4047 && CLASSTYPE_TEMPLATE_SPECIALIZATION (context))
4048 error ("template header not allowed in member definition "
4049 "of explicitly specialized class");
4050 /* Static data member are tricky; an in-class initialization
4051 still doesn't provide a definition, so the in-class
4052 declaration will have DECL_EXTERNAL set, but will have an
4053 initialization. Thus, duplicate_decls won't warn
4054 about this situation, and so we check here. */
4055 if (initialized && DECL_INITIALIZED_IN_CLASS_P (field))
4056 error ("duplicate initialization of %qD", decl);
4057 if (duplicate_decls (decl, field, /*newdecl_is_friend=*/false))
4063 tree field = check_classfn (context, decl,
4064 (processing_template_decl
4065 > template_class_depth (context))
4066 ? current_template_parms
4068 if (field && field != error_mark_node
4069 && duplicate_decls (decl, field,
4070 /*newdecl_is_friend=*/false))
4074 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
4075 DECL_IN_AGGR_P (decl) = 0;
4076 /* Do not mark DECL as an explicit specialization if it was not
4077 already marked as an instantiation; a declaration should
4078 never be marked as a specialization unless we know what
4079 template is being specialized. */
4080 if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
4082 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
4084 /* [temp.expl.spec] An explicit specialization of a static data
4085 member of a template is a definition if the declaration
4086 includes an initializer; otherwise, it is a declaration.
4088 We check for processing_specialization so this only applies
4089 to the new specialization syntax. */
4090 if (!initialized && processing_specialization)
4091 DECL_EXTERNAL (decl) = 1;
4094 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
4095 pedwarn ("declaration of %q#D outside of class is not definition",
4099 was_public = TREE_PUBLIC (decl);
4101 /* Enter this declaration into the symbol table. */
4102 tem = maybe_push_decl (decl);
4104 if (processing_template_decl)
4105 tem = push_template_decl (tem);
4106 if (tem == error_mark_node)
4107 return error_mark_node;
4109 /* Tell the back end to use or not use .common as appropriate. If we say
4110 -fconserve-space, we want this to save .data space, at the expense of
4111 wrong semantics. If we say -fno-conserve-space, we want this to
4112 produce errors about redefs; to do this we force variables into the
4114 if (flag_conserve_space
4115 && TREE_CODE (tem) == VAR_DECL
4116 && TREE_PUBLIC (tem)
4117 && !DECL_THREAD_LOCAL_P (tem)
4118 && !have_global_bss_p ())
4119 DECL_COMMON (tem) = 1;
4121 if (TREE_CODE (tem) == VAR_DECL
4122 && DECL_NAMESPACE_SCOPE_P (tem) && !TREE_PUBLIC (tem) && !was_public
4123 && !DECL_THIS_STATIC (tem) && !DECL_ARTIFICIAL (tem))
4125 /* This is a const variable with implicit 'static'. Set
4126 DECL_THIS_STATIC so we can tell it from variables that are
4127 !TREE_PUBLIC because of the anonymous namespace. */
4128 gcc_assert (cp_type_readonly (TREE_TYPE (tem)));
4129 DECL_THIS_STATIC (tem) = 1;
4132 if (!processing_template_decl && TREE_CODE (tem) == VAR_DECL)
4133 start_decl_1 (tem, initialized);
4139 start_decl_1 (tree decl, bool initialized)
4143 gcc_assert (!processing_template_decl);
4145 if (error_operand_p (decl))
4148 gcc_assert (TREE_CODE (decl) == VAR_DECL);
4149 type = TREE_TYPE (decl);
4152 /* Is it valid for this decl to have an initializer at all?
4153 If not, set INITIALIZED to zero, which will indirectly
4154 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
4156 /* Don't allow initializations for incomplete types except for
4157 arrays which might be completed by the initialization. */
4158 if (COMPLETE_TYPE_P (complete_type (type)))
4159 ; /* A complete type is ok. */
4160 else if (TREE_CODE (type) != ARRAY_TYPE)
4162 error ("variable %q#D has initializer but incomplete type", decl);
4164 type = TREE_TYPE (decl) = error_mark_node;
4166 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
4168 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
4169 error ("elements of array %q#D have incomplete type", decl);
4170 /* else we already gave an error in start_decl. */
4174 else if (IS_AGGR_TYPE (type)
4175 && ! DECL_EXTERNAL (decl))
4177 if (!COMPLETE_TYPE_P (complete_type (type)))
4179 error ("aggregate %q#D has incomplete type and cannot be defined",
4181 /* Change the type so that assemble_variable will give
4182 DECL an rtl we can live with: (mem (const_int 0)). */
4183 type = TREE_TYPE (decl) = error_mark_node;
4187 /* If any base type in the hierarchy of TYPE needs a constructor,
4188 then we set initialized to 1. This way any nodes which are
4189 created for the purposes of initializing this aggregate
4190 will live as long as it does. This is necessary for global
4191 aggregates which do not have their initializers processed until
4192 the end of the file. */
4193 initialized = TYPE_NEEDS_CONSTRUCTING (type);
4197 /* Create a new scope to hold this declaration if necessary.
4198 Whether or not a new scope is necessary cannot be determined
4199 until after the type has been completed; if the type is a
4200 specialization of a class template it is not until after
4201 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4202 will be set correctly. */
4203 maybe_push_cleanup_level (type);
4206 /* Handle initialization of references. DECL, TYPE, and INIT have the
4207 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
4208 but will be set to a new CLEANUP_STMT if a temporary is created
4209 that must be destroyed subsequently.
4211 Returns an initializer expression to use to initialize DECL, or
4212 NULL if the initialization can be performed statically.
4214 Quotes on semantics can be found in ARM 8.4.3. */
4217 grok_reference_init (tree decl, tree type, tree init, tree *cleanup)
4221 if (init == NULL_TREE)
4223 if ((DECL_LANG_SPECIFIC (decl) == 0
4224 || DECL_IN_AGGR_P (decl) == 0)
4225 && ! DECL_THIS_EXTERN (decl))
4226 error ("%qD declared as reference but not initialized", decl);
4230 if (TREE_CODE (init) == CONSTRUCTOR)
4232 error ("ISO C++ forbids use of initializer list to "
4233 "initialize reference %qD", decl);
4237 if (TREE_CODE (init) == TREE_LIST)
4238 init = build_x_compound_expr_from_list (init, "initializer");
4240 if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
4241 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
4242 /* Note: default conversion is only called in very special cases. */
4243 init = decay_conversion (init);
4245 /* Convert INIT to the reference type TYPE. This may involve the
4246 creation of a temporary, whose lifetime must be the same as that
4247 of the reference. If so, a DECL_EXPR for the temporary will be
4248 added just after the DECL_EXPR for DECL. That's why we don't set
4249 DECL_INITIAL for local references (instead assigning to them
4250 explicitly); we need to allow the temporary to be initialized
4252 tmp = initialize_reference (type, init, decl, cleanup);
4254 if (tmp == error_mark_node)
4256 else if (tmp == NULL_TREE)
4258 error ("cannot initialize %qT from %qT", type, TREE_TYPE (init));
4262 if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
4265 DECL_INITIAL (decl) = tmp;
4270 /* Designated initializers in arrays are not supported in GNU C++.
4271 The parser cannot detect this error since it does not know whether
4272 a given brace-enclosed initializer is for a class type or for an
4273 array. This function checks that CE does not use a designated
4274 initializer. If it does, an error is issued. Returns true if CE
4275 is valid, i.e., does not have a designated initializer. */
4278 check_array_designated_initializer (const constructor_elt *ce)
4280 /* Designated initializers for array elements are not supported. */
4283 /* The parser only allows identifiers as designated
4285 gcc_assert (TREE_CODE (ce->index) == IDENTIFIER_NODE);
4286 error ("name %qD used in a GNU-style designated "
4287 "initializer for an array", ce->index);
4294 /* When parsing `int a[] = {1, 2};' we don't know the size of the
4295 array until we finish parsing the initializer. If that's the
4296 situation we're in, update DECL accordingly. */
4299 maybe_deduce_size_from_array_init (tree decl, tree init)
4301 tree type = TREE_TYPE (decl);
4303 if (TREE_CODE (type) == ARRAY_TYPE
4304 && TYPE_DOMAIN (type) == NULL_TREE
4305 && TREE_CODE (decl) != TYPE_DECL)
4307 /* do_default is really a C-ism to deal with tentative definitions.
4308 But let's leave it here to ease the eventual merge. */
4309 int do_default = !DECL_EXTERNAL (decl);
4310 tree initializer = init ? init : DECL_INITIAL (decl);
4313 /* Check that there are no designated initializers in INIT, as
4314 those are not supported in GNU C++, and as the middle-end
4315 will crash if presented with a non-numeric designated
4317 if (initializer && TREE_CODE (initializer) == CONSTRUCTOR)
4319 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initializer);
4320 constructor_elt *ce;
4323 VEC_iterate (constructor_elt, v, i, ce);
4325 if (!check_array_designated_initializer (ce))
4331 failure = cp_complete_array_type (&TREE_TYPE (decl), initializer,
4335 error ("initializer fails to determine size of %qD", decl);
4336 TREE_TYPE (decl) = error_mark_node;
4338 else if (failure == 2)
4342 error ("array size missing in %qD", decl);
4343 TREE_TYPE (decl) = error_mark_node;
4345 /* If a `static' var's size isn't known, make it extern as
4346 well as static, so it does not get allocated. If it's not
4347 `static', then don't mark it extern; finish_incomplete_decl
4348 will give it a default size and it will get allocated. */
4349 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
4350 DECL_EXTERNAL (decl) = 1;
4352 else if (failure == 3)
4354 error ("zero-size array %qD", decl);
4355 TREE_TYPE (decl) = error_mark_node;
4359 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl)), decl);
4361 layout_decl (decl, 0);
4365 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
4366 any appropriate error messages regarding the layout. */
4369 layout_var_decl (tree decl)
4373 type = TREE_TYPE (decl);
4374 if (type == error_mark_node)
4377 /* If we haven't already layed out this declaration, do so now.
4378 Note that we must not call complete type for an external object
4379 because it's type might involve templates that we are not
4380 supposed to instantiate yet. (And it's perfectly valid to say
4381 `extern X x' for some incomplete type `X'.) */
4382 if (!DECL_EXTERNAL (decl))
4383 complete_type (type);
4384 if (!DECL_SIZE (decl)
4385 && TREE_TYPE (decl) != error_mark_node
4386 && (COMPLETE_TYPE_P (type)
4387 || (TREE_CODE (type) == ARRAY_TYPE
4388 && !TYPE_DOMAIN (type)
4389 && COMPLETE_TYPE_P (TREE_TYPE (type)))))
4390 layout_decl (decl, 0);
4392 if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
4394 /* An automatic variable with an incomplete type: that is an error.
4395 Don't talk about array types here, since we took care of that
4396 message in grokdeclarator. */
4397 error ("storage size of %qD isn't known", decl);
4398 TREE_TYPE (decl) = error_mark_node;
4401 /* Keep this code around in case we later want to control debug info
4402 based on whether a type is "used". (jason 1999-11-11) */
4404 else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
4405 /* Let debugger know it should output info for this type. */
4406 note_debug_info_needed (ttype);
4408 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
4409 note_debug_info_needed (DECL_CONTEXT (decl));
4412 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
4413 && DECL_SIZE (decl) != NULL_TREE
4414 && ! TREE_CONSTANT (DECL_SIZE (decl)))
4416 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
4417 constant_expression_warning (DECL_SIZE (decl));
4419 error ("storage size of %qD isn't constant", decl);
4423 /* If a local static variable is declared in an inline function, or if
4424 we have a weak definition, we must endeavor to create only one
4425 instance of the variable at link-time. */
4428 maybe_commonize_var (tree decl)
4430 /* Static data in a function with comdat linkage also has comdat
4432 if (TREE_STATIC (decl)
4433 /* Don't mess with __FUNCTION__. */
4434 && ! DECL_ARTIFICIAL (decl)
4435 && DECL_FUNCTION_SCOPE_P (decl)
4436 /* Unfortunately, import_export_decl has not always been called
4437 before the function is processed, so we cannot simply check
4439 && (DECL_COMDAT (DECL_CONTEXT (decl))
4440 || ((DECL_DECLARED_INLINE_P (DECL_CONTEXT (decl))
4441 || DECL_TEMPLATE_INSTANTIATION (DECL_CONTEXT (decl)))
4442 && TREE_PUBLIC (DECL_CONTEXT (decl)))))
4446 /* With weak symbols, we simply make the variable COMDAT;
4447 that will cause copies in multiple translations units to
4449 comdat_linkage (decl);
4453 if (DECL_INITIAL (decl) == NULL_TREE
4454 || DECL_INITIAL (decl) == error_mark_node)
4456 /* Without weak symbols, we can use COMMON to merge
4457 uninitialized variables. */
4458 TREE_PUBLIC (decl) = 1;
4459 DECL_COMMON (decl) = 1;
4463 /* While for initialized variables, we must use internal
4464 linkage -- which means that multiple copies will not
4466 TREE_PUBLIC (decl) = 0;
4467 DECL_COMMON (decl) = 0;
4468 warning (0, "sorry: semantics of inline function static "
4469 "data %q+#D are wrong (you'll wind up "
4470 "with multiple copies)", decl);
4471 warning (0, "%J you can work around this by removing "
4477 else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
4478 /* Set it up again; we might have set DECL_INITIAL since the last
4480 comdat_linkage (decl);
4483 /* Issue an error message if DECL is an uninitialized const variable. */
4486 check_for_uninitialized_const_var (tree decl)
4488 tree type = TREE_TYPE (decl);
4490 /* ``Unless explicitly declared extern, a const object does not have
4491 external linkage and must be initialized. ($8.4; $12.1)'' ARM
4493 if (TREE_CODE (decl) == VAR_DECL
4494 && TREE_CODE (type) != REFERENCE_TYPE
4495 && CP_TYPE_CONST_P (type)
4496 && !TYPE_NEEDS_CONSTRUCTING (type)
4497 && !DECL_INITIAL (decl))
4498 error ("uninitialized const %qD", decl);
4502 /* Structure holding the current initializer being processed by reshape_init.
4503 CUR is a pointer to the current element being processed, END is a pointer
4504 after the last element present in the initializer. */
4505 typedef struct reshape_iterator_t
4507 constructor_elt *cur;
4508 constructor_elt *end;
4511 static tree reshape_init_r (tree, reshape_iter *, bool);
4513 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
4514 returned is the next FIELD_DECL (possibly FIELD itself) that can be
4515 initialized. If there are no more such fields, the return value
4519 next_initializable_field (tree field)
4522 && (TREE_CODE (field) != FIELD_DECL
4523 || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
4524 || DECL_ARTIFICIAL (field)))
4525 field = TREE_CHAIN (field);
4530 /* Subroutine of reshape_init_array and reshape_init_vector, which does
4531 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
4532 INTEGER_CST representing the size of the array minus one (the maximum index),
4533 or NULL_TREE if the array was declared without specifying the size. D is
4534 the iterator within the constructor. */
4537 reshape_init_array_1 (tree elt_type, tree max_index, reshape_iter *d)
4540 bool sized_array_p = (max_index != NULL_TREE);
4541 unsigned HOST_WIDE_INT max_index_cst = 0;
4542 unsigned HOST_WIDE_INT index;
4544 /* The initializer for an array is always a CONSTRUCTOR. */
4545 new_init = build_constructor (NULL_TREE, NULL);
4549 /* Minus 1 is used for zero sized arrays. */
4550 if (integer_all_onesp (max_index))
4553 if (host_integerp (max_index, 1))
4554 max_index_cst = tree_low_cst (max_index, 1);
4555 /* sizetype is sign extended, not zero extended. */
4557 max_index_cst = tree_low_cst (fold_convert (size_type_node, max_index),
4561 /* Loop until there are no more initializers. */
4563 d->cur != d->end && (!sized_array_p || index <= max_index_cst);
4568 check_array_designated_initializer (d->cur);
4569 elt_init = reshape_init_r (elt_type, d, /*first_initializer_p=*/false);
4570 if (elt_init == error_mark_node)
4571 return error_mark_node;
4572 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), NULL_TREE, elt_init);
4578 /* Subroutine of reshape_init_r, processes the initializers for arrays.
4579 Parameters are the same of reshape_init_r. */
4582 reshape_init_array (tree type, reshape_iter *d)
4584 tree max_index = NULL_TREE;
4586 gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
4588 if (TYPE_DOMAIN (type))
4589 max_index = array_type_nelts (type);
4591 return reshape_init_array_1 (TREE_TYPE (type), max_index, d);
4594 /* Subroutine of reshape_init_r, processes the initializers for vectors.
4595 Parameters are the same of reshape_init_r. */
4598 reshape_init_vector (tree type, reshape_iter *d)
4600 tree max_index = NULL_TREE;
4603 gcc_assert (TREE_CODE (type) == VECTOR_TYPE);
4605 if (COMPOUND_LITERAL_P (d->cur->value))
4607 tree value = d->cur->value;
4608 if (!same_type_p (TREE_TYPE (value), type))
4610 error ("invalid type %qT as initializer for a vector of type %qT",
4611 TREE_TYPE (d->cur->value), type);
4612 value = error_mark_node;
4618 /* For a vector, the representation type is a struct
4619 containing a single member which is an array of the
4620 appropriate size. */
4621 rtype = TYPE_DEBUG_REPRESENTATION_TYPE (type);
4622 if (rtype && TYPE_DOMAIN (TREE_TYPE (TYPE_FIELDS (rtype))))
4623 max_index = array_type_nelts (TREE_TYPE (TYPE_FIELDS (rtype)));
4625 return reshape_init_array_1 (TREE_TYPE (type), max_index, d);
4628 /* Subroutine of reshape_init_r, processes the initializers for classes
4629 or union. Parameters are the same of reshape_init_r. */
4632 reshape_init_class (tree type, reshape_iter *d, bool first_initializer_p)
4637 gcc_assert (CLASS_TYPE_P (type));
4639 /* The initializer for a class is always a CONSTRUCTOR. */
4640 new_init = build_constructor (NULL_TREE, NULL);
4641 field = next_initializable_field (TYPE_FIELDS (type));
4647 An initializer for an aggregate member that is an
4648 empty class shall have the form of an empty
4649 initializer-list {}. */
4650 if (!first_initializer_p)
4652 error ("initializer for %qT must be brace-enclosed", type);
4653 return error_mark_node;
4658 /* Loop through the initializable fields, gathering initializers. */
4659 while (d->cur != d->end)
4663 /* Handle designated initializers, as an extension. */
4666 field = lookup_field_1 (type, d->cur->index, /*want_type=*/false);
4668 if (!field || TREE_CODE (field) != FIELD_DECL)
4670 error ("%qT has no non-static data member named %qD", type,
4672 return error_mark_node;
4676 /* If we processed all the member of the class, we are done. */
4680 field_init = reshape_init_r (TREE_TYPE (field), d,
4681 /*first_initializer_p=*/false);
4682 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), field, field_init);
4686 When a union is initialized with a brace-enclosed
4687 initializer, the braces shall only contain an
4688 initializer for the first member of the union. */
4689 if (TREE_CODE (type) == UNION_TYPE)
4692 field = next_initializable_field (TREE_CHAIN (field));
4698 /* Subroutine of reshape_init, which processes a single initializer (part of
4699 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
4700 iterator within the CONSTRUCTOR which points to the initializer to process.
4701 FIRST_INITIALIZER_P is true if this is the first initializer of the
4702 CONSTRUCTOR node. */
4705 reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p)
4707 tree init = d->cur->value;
4709 /* A non-aggregate type is always initialized with a single
4711 if (!CP_AGGREGATE_TYPE_P (type))
4713 /* It is invalid to initialize a non-aggregate type with a
4714 brace-enclosed initializer.
4715 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
4716 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
4717 a CONSTRUCTOR (with a record type). */
4718 if (TREE_CODE (init) == CONSTRUCTOR
4719 && BRACE_ENCLOSED_INITIALIZER_P (init)) /* p7626.C */
4721 error ("braces around scalar initializer for type %qT", type);
4722 init = error_mark_node;
4731 All implicit type conversions (clause _conv_) are considered when
4732 initializing the aggregate member with an initializer from an
4733 initializer-list. If the initializer can initialize a member,
4734 the member is initialized. Otherwise, if the member is itself a
4735 non-empty subaggregate, brace elision is assumed and the
4736 initializer is considered for the initialization of the first
4737 member of the subaggregate. */
4738 if (TREE_CODE (init) != CONSTRUCTOR
4739 && can_convert_arg (type, TREE_TYPE (init), init, LOOKUP_NORMAL))
4745 /* [dcl.init.string]
4747 A char array (whether plain char, signed char, or unsigned char)
4748 can be initialized by a string-literal (optionally enclosed in
4749 braces); a wchar_t array can be initialized by a wide
4750 string-literal (optionally enclosed in braces). */
4751 if (TREE_CODE (type) == ARRAY_TYPE
4752 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
4754 tree str_init = init;
4756 /* Strip one level of braces if and only if they enclose a single
4757 element (as allowed by [dcl.init.string]). */
4758 if (!first_initializer_p
4759 && TREE_CODE (str_init) == CONSTRUCTOR
4760 && VEC_length (constructor_elt, CONSTRUCTOR_ELTS (str_init)) == 1)
4762 str_init = VEC_index (constructor_elt,
4763 CONSTRUCTOR_ELTS (str_init), 0)->value;
4766 /* If it's a string literal, then it's the initializer for the array
4767 as a whole. Otherwise, continue with normal initialization for
4768 array types (one value per array element). */
4769 if (TREE_CODE (str_init) == STRING_CST)
4776 /* The following cases are about aggregates. If we are not within a full
4777 initializer already, and there is not a CONSTRUCTOR, it means that there
4778 is a missing set of braces (that is, we are processing the case for
4779 which reshape_init exists). */
4780 if (!first_initializer_p)
4782 if (TREE_CODE (init) == CONSTRUCTOR)
4784 if (TREE_TYPE (init) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init)))
4785 /* There is no need to reshape pointer-to-member function
4786 initializers, as they are always constructed correctly
4787 by the front end. */
4789 else if (COMPOUND_LITERAL_P (init))
4790 /* For a nested compound literal, there is no need to reshape since
4791 brace elision is not allowed. Even if we decided to allow it,
4792 we should add a call to reshape_init in finish_compound_literal,
4793 before calling digest_init, so changing this code would still
4794 not be necessary. */
4795 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init));
4799 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
4800 return reshape_init (type, init);
4804 warning (OPT_Wmissing_braces, "missing braces around initializer for %qT",
4808 /* Dispatch to specialized routines. */
4809 if (CLASS_TYPE_P (type))
4810 return reshape_init_class (type, d, first_initializer_p);
4811 else if (TREE_CODE (type) == ARRAY_TYPE)
4812 return reshape_init_array (type, d);
4813 else if (TREE_CODE (type) == VECTOR_TYPE)
4814 return reshape_init_vector (type, d);
4819 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
4820 brace-enclosed aggregate initializer.
4822 INIT is the CONSTRUCTOR containing the list of initializers describing
4823 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
4824 It may not presently match the shape of the TYPE; for example:
4826 struct S { int a; int b; };
4827 struct S a[] = { 1, 2, 3, 4 };
4829 Here INIT will hold a VEC of four elements, rather than a
4830 VEC of two elements, each itself a VEC of two elements. This
4831 routine transforms INIT from the former form into the latter. The
4832 revised CONSTRUCTOR node is returned. */
4835 reshape_init (tree type, tree init)
4837 VEC(constructor_elt, gc) *v;
4841 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
4843 v = CONSTRUCTOR_ELTS (init);
4845 /* An empty constructor does not need reshaping, and it is always a valid
4847 if (VEC_empty (constructor_elt, v))
4850 /* Recurse on this CONSTRUCTOR. */
4851 d.cur = VEC_index (constructor_elt, v, 0);
4852 d.end = d.cur + VEC_length (constructor_elt, v);
4854 new_init = reshape_init_r (type, &d, true);
4855 if (new_init == error_mark_node)
4856 return error_mark_node;
4858 /* Make sure all the element of the constructor were used. Otherwise,
4859 issue an error about exceeding initializers. */
4861 error ("too many initializers for %qT", type);
4866 /* Verify INIT (the initializer for DECL), and record the
4867 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
4868 grok_reference_init.
4870 If the return value is non-NULL, it is an expression that must be
4871 evaluated dynamically to initialize DECL. */
4874 check_initializer (tree decl, tree init, int flags, tree *cleanup)
4876 tree type = TREE_TYPE (decl);
4877 tree init_code = NULL;
4879 /* Things that are going to be initialized need to have complete
4881 TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
4883 if (type == error_mark_node)
4884 /* We will have already complained. */
4887 if (TREE_CODE (type) == ARRAY_TYPE)
4889 tree element_type = TREE_TYPE (type);
4891 /* The array type itself need not be complete, because the
4892 initializer may tell us how many elements are in the array.
4893 But, the elements of the array must be complete. */
4894 if (!COMPLETE_TYPE_P (complete_type (element_type)))
4896 error ("elements of array %q#D have incomplete type", decl);
4899 /* It is not valid to initialize a VLA. */
4901 && ((COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
4902 || !TREE_CONSTANT (TYPE_SIZE (element_type))))
4904 error ("variable-sized object %qD may not be initialized", decl);
4908 else if (!COMPLETE_TYPE_P (type))
4910 error ("%qD has incomplete type", decl);
4911 TREE_TYPE (decl) = error_mark_node;
4915 /* There is no way to make a variable-sized class type in GNU C++. */
4916 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type)));
4918 if (init && BRACE_ENCLOSED_INITIALIZER_P (init))
4920 int init_len = VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init));
4921 if (SCALAR_TYPE_P (type))
4925 error ("scalar object %qD requires one element in initializer",
4927 TREE_TYPE (decl) = error_mark_node;
4931 else if ((cxx_dialect == cxx98) && !CP_AGGREGATE_TYPE_P (type))
4933 /* A non-aggregate that is not a scalar cannot be initialized
4934 via an initializer-list in C++98. */
4935 error ("braces around initializer for non-aggregate type %qT",
4937 TREE_TYPE (decl) = error_mark_node;
4942 if (TREE_CODE (decl) == CONST_DECL)
4944 gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);
4946 DECL_INITIAL (decl) = init;
4948 gcc_assert (init != NULL_TREE);
4951 else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
4952 init = grok_reference_init (decl, type, init, cleanup);
4955 /* Do not reshape constructors of vectors (they don't need to be
4957 if (TREE_CODE (init) == CONSTRUCTOR
4958 && !COMPOUND_LITERAL_P (init)
4959 && !TREE_TYPE (init)) /* ptrmemfunc */
4961 init = reshape_init (type, init);
4963 if ((*targetm.vector_opaque_p) (type))
4965 error ("opaque vector types cannot be initialized");
4966 init = error_mark_node;
4970 /* If DECL has an array type without a specific bound, deduce the
4971 array size from the initializer. */
4972 maybe_deduce_size_from_array_init (decl, init);
4973 type = TREE_TYPE (decl);
4974 if (type == error_mark_node)
4977 if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
4979 if (TREE_CODE (type) == ARRAY_TYPE)
4980 goto initialize_aggr;
4981 else if (TREE_CODE (init) == CONSTRUCTOR)
4983 if (TYPE_NON_AGGREGATE_CLASS (type))
4985 error ("%qD must be initialized by constructor, "
4988 init = error_mark_node;
4991 goto dont_use_constructor;
4995 int saved_stmts_are_full_exprs_p;
4998 saved_stmts_are_full_exprs_p = 0;
4999 if (building_stmt_tree ())
5001 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
5002 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
5004 init = build_aggr_init (decl, init, flags);
5005 if (building_stmt_tree ())
5006 current_stmt_tree ()->stmts_are_full_exprs_p =
5007 saved_stmts_are_full_exprs_p;
5013 dont_use_constructor:
5014 if (TREE_CODE (init) != TREE_VEC)
5016 init_code = store_init_value (decl, init);
5017 if (pedantic && TREE_CODE (type) == ARRAY_TYPE
5018 && DECL_INITIAL (decl)
5019 && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST
5020 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl)))
5021 warning (0, "array %qD initialized by parenthesized string literal %qE",
5022 decl, DECL_INITIAL (decl));
5027 else if (DECL_EXTERNAL (decl))
5029 else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
5030 goto initialize_aggr;
5031 else if (IS_AGGR_TYPE (type))
5033 tree core_type = strip_array_types (type);
5035 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
5036 error ("structure %qD with uninitialized const members", decl);
5037 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
5038 error ("structure %qD with uninitialized reference members", decl);
5040 check_for_uninitialized_const_var (decl);
5043 check_for_uninitialized_const_var (decl);
5045 if (init && init != error_mark_node)
5046 init_code = build2 (INIT_EXPR, type, decl, init);
5051 /* If DECL is not a local variable, give it RTL. */
5054 make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
5056 int toplev = toplevel_bindings_p ();
5058 const char *filename;
5060 /* Set the DECL_ASSEMBLER_NAME for the object. */
5063 /* The `register' keyword, when used together with an
5064 asm-specification, indicates that the variable should be
5065 placed in a particular register. */
5066 if (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
5068 set_user_assembler_name (decl, asmspec);
5069 DECL_HARD_REGISTER (decl) = 1;
5073 if (TREE_CODE (decl) == FUNCTION_DECL
5074 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
5075 set_builtin_user_assembler_name (decl, asmspec);
5076 set_user_assembler_name (decl, asmspec);
5080 /* Handle non-variables up front. */
5081 if (TREE_CODE (decl) != VAR_DECL)
5083 rest_of_decl_compilation (decl, toplev, at_eof);
5087 /* If we see a class member here, it should be a static data
5089 if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
5091 gcc_assert (TREE_STATIC (decl));
5092 /* An in-class declaration of a static data member should be
5093 external; it is only a declaration, and not a definition. */
5094 if (init == NULL_TREE)
5095 gcc_assert (DECL_EXTERNAL (decl));
5098 /* We don't create any RTL for local variables. */
5099 if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
5102 /* We defer emission of local statics until the corresponding
5103 DECL_EXPR is expanded. */
5104 defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
5106 /* We try to defer namespace-scope static constants so that they are
5107 not emitted into the object file unnecessarily. */
5108 filename = input_filename;
5109 if (!DECL_VIRTUAL_P (decl)
5110 && TREE_READONLY (decl)
5111 && DECL_INITIAL (decl) != NULL_TREE
5112 && DECL_INITIAL (decl) != error_mark_node
5114 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
5116 && !TREE_PUBLIC (decl))
5118 /* Fool with the linkage of static consts according to #pragma
5120 struct c_fileinfo *finfo = get_fileinfo (filename);
5121 if (!finfo->interface_unknown && !TREE_PUBLIC (decl))
5123 TREE_PUBLIC (decl) = 1;
5124 DECL_EXTERNAL (decl) = finfo->interface_only;
5129 /* Likewise for template instantiations. */
5130 else if (DECL_LANG_SPECIFIC (decl)
5131 && DECL_IMPLICIT_INSTANTIATION (decl))
5134 /* If we're not deferring, go ahead and assemble the variable. */
5136 rest_of_decl_compilation (decl, toplev, at_eof);
5139 /* Generate code to initialize DECL (a local variable). */
5142 initialize_local_var (tree decl, tree init)
5144 tree type = TREE_TYPE (decl);
5147 gcc_assert (TREE_CODE (decl) == VAR_DECL
5148 || TREE_CODE (decl) == RESULT_DECL);
5149 gcc_assert (!TREE_STATIC (decl));
5151 if (DECL_SIZE (decl) == NULL_TREE)
5153 /* If we used it already as memory, it must stay in memory. */
5154 DECL_INITIAL (decl) = NULL_TREE;
5155 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
5158 if (DECL_SIZE (decl) && type != error_mark_node)
5162 /* Compute and store the initial value. */
5163 already_used = TREE_USED (decl) || TREE_USED (type);
5165 /* Perform the initialization. */
5168 int saved_stmts_are_full_exprs_p;
5170 gcc_assert (building_stmt_tree ());
5171 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
5172 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
5173 finish_expr_stmt (init);
5174 current_stmt_tree ()->stmts_are_full_exprs_p =
5175 saved_stmts_are_full_exprs_p;
5178 /* Set this to 0 so we can tell whether an aggregate which was
5179 initialized was ever used. Don't do this if it has a
5180 destructor, so we don't complain about the 'resource
5181 allocation is initialization' idiom. Now set
5182 attribute((unused)) on types so decls of that type will be
5183 marked used. (see TREE_USED, above.) */
5184 if (TYPE_NEEDS_CONSTRUCTING (type)
5186 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
5187 && DECL_NAME (decl))
5188 TREE_USED (decl) = 0;
5189 else if (already_used)
5190 TREE_USED (decl) = 1;
5193 /* Generate a cleanup, if necessary. */
5194 cleanup = cxx_maybe_build_cleanup (decl);
5195 if (DECL_SIZE (decl) && cleanup)
5196 finish_decl_cleanup (decl, cleanup);
5199 /* DECL is a VAR_DECL for a compiler-generated variable with static
5200 storage duration (like a virtual table) whose initializer is a
5201 compile-time constant. INIT must be either a TREE_LIST of values,
5202 or a CONSTRUCTOR. Initialize the variable and provide it to the
5206 initialize_artificial_var (tree decl, tree init)
5208 gcc_assert (DECL_ARTIFICIAL (decl));
5209 if (TREE_CODE (init) == TREE_LIST)
5210 init = build_constructor_from_list (NULL_TREE, init);
5211 gcc_assert (TREE_CODE (init) == CONSTRUCTOR);
5212 DECL_INITIAL (decl) = init;
5213 DECL_INITIALIZED_P (decl) = 1;
5214 determine_visibility (decl);
5215 layout_var_decl (decl);
5216 maybe_commonize_var (decl);
5217 make_rtl_for_nonlocal_decl (decl, init, /*asmspec=*/NULL);
5220 /* INIT is the initializer for a variable, as represented by the
5221 parser. Returns true iff INIT is value-dependent. */
5224 value_dependent_init_p (tree init)
5226 if (TREE_CODE (init) == TREE_LIST)
5227 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
5228 return any_value_dependent_elements_p (init);
5229 else if (TREE_CODE (init) == CONSTRUCTOR)
5230 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
5232 VEC(constructor_elt, gc) *elts;
5236 elts = CONSTRUCTOR_ELTS (init);
5237 nelts = VEC_length (constructor_elt, elts);
5238 for (i = 0; i < nelts; ++i)
5239 if (value_dependent_init_p (VEC_index (constructor_elt,
5244 /* It must be a simple expression, e.g., int i = 3; */
5245 return value_dependent_expression_p (init);
5250 /* Finish processing of a declaration;
5251 install its line number and initial value.
5252 If the length of an array type is not known before,
5253 it must be determined now, from the initial value, or it is an error.
5255 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
5256 true, then INIT is an integral constant expression.
5258 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
5259 if the (init) syntax was used. */
5262 cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
5263 tree asmspec_tree, int flags)
5267 const char *asmspec = NULL;
5268 int was_readonly = 0;
5269 bool var_definition_p = false;
5270 int saved_processing_template_decl;
5272 if (decl == error_mark_node)
5277 error ("assignment (not initialization) in declaration");
5281 gcc_assert (TREE_CODE (decl) != RESULT_DECL);
5282 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
5283 gcc_assert (TREE_CODE (decl) != PARM_DECL);
5285 type = TREE_TYPE (decl);
5286 if (type == error_mark_node)
5289 /* Assume no cleanup is required. */
5290 cleanup = NULL_TREE;
5291 saved_processing_template_decl = processing_template_decl;
5293 /* If a name was specified, get the string. */
5294 if (global_scope_p (current_binding_level))
5295 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
5296 if (asmspec_tree && asmspec_tree != error_mark_node)
5297 asmspec = TREE_STRING_POINTER (asmspec_tree);
5299 if (current_class_type
5300 && CP_DECL_CONTEXT (decl) == current_class_type
5301 && TYPE_BEING_DEFINED (current_class_type)
5302 && (DECL_INITIAL (decl) || init))
5303 DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
5305 if (processing_template_decl)
5307 bool type_dependent_p;
5309 /* Add this declaration to the statement-tree. */
5310 if (at_function_scope_p ())
5311 add_decl_expr (decl);
5313 type_dependent_p = dependent_type_p (type);
5315 if (init && init_const_expr_p)
5317 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
5318 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl))
5319 TREE_CONSTANT (decl) = 1;
5322 /* Generally, initializers in templates are expanded when the
5323 template is instantiated. But, if DECL is an integral
5324 constant static data member, then it can be used in future
5325 integral constant expressions, and its value must be
5328 && DECL_CLASS_SCOPE_P (decl)
5329 && DECL_INTEGRAL_CONSTANT_VAR_P (decl)
5330 && !type_dependent_p
5331 && !value_dependent_init_p (init)))
5334 DECL_INITIAL (decl) = init;
5335 if (TREE_CODE (decl) == VAR_DECL
5336 && !DECL_PRETTY_FUNCTION_P (decl)
5337 && !type_dependent_p)
5338 maybe_deduce_size_from_array_init (decl, init);
5342 if (TREE_CODE (init) == TREE_LIST)
5344 /* If the parenthesized-initializer form was used (e.g.,
5345 "int A<N>::i(X)"), then INIT will be a TREE_LIST of initializer
5346 arguments. (There is generally only one.) We convert them
5349 for (; list; list = TREE_CHAIN (list))
5351 tree elt = TREE_VALUE (list);
5352 TREE_VALUE (list) = fold_non_dependent_expr (elt);
5356 init = fold_non_dependent_expr (init);
5357 processing_template_decl = 0;
5360 /* Take care of TYPE_DECLs up front. */
5361 if (TREE_CODE (decl) == TYPE_DECL)
5363 if (type != error_mark_node
5364 && IS_AGGR_TYPE (type) && DECL_NAME (decl))
5366 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
5367 warning (0, "shadowing previous type declaration of %q#D", decl);
5368 set_identifier_type_value (DECL_NAME (decl), decl);
5371 /* If we have installed this as the canonical typedef for this
5372 type, and that type has not been defined yet, delay emitting
5373 the debug information for it, as we will emit it later. */
5374 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
5375 && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
5376 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
5378 rest_of_decl_compilation (decl, DECL_CONTEXT (decl) == NULL_TREE,
5383 /* A reference will be modified here, as it is initialized. */
5384 if (! DECL_EXTERNAL (decl)
5385 && TREE_READONLY (decl)
5386 && TREE_CODE (type) == REFERENCE_TYPE)
5389 TREE_READONLY (decl) = 0;
5392 if (TREE_CODE (decl) == VAR_DECL)
5394 /* Only PODs can have thread-local storage. Other types may require
5395 various kinds of non-trivial initialization. */
5396 if (DECL_THREAD_LOCAL_P (decl) && !pod_type_p (TREE_TYPE (decl)))
5397 error ("%qD cannot be thread-local because it has non-POD type %qT",
5398 decl, TREE_TYPE (decl));
5399 /* If this is a local variable that will need a mangled name,
5400 register it now. We must do this before processing the
5401 initializer for the variable, since the initialization might
5402 require a guard variable, and since the mangled name of the
5403 guard variable will depend on the mangled name of this
5405 if (!processing_template_decl
5406 && DECL_FUNCTION_SCOPE_P (decl)
5407 && TREE_STATIC (decl)
5408 && !DECL_ARTIFICIAL (decl))
5409 push_local_name (decl);
5410 /* Convert the initializer to the type of DECL, if we have not
5411 already initialized DECL. */
5412 if (!DECL_INITIALIZED_P (decl)
5413 /* If !DECL_EXTERNAL then DECL is being defined. In the
5414 case of a static data member initialized inside the
5415 class-specifier, there can be an initializer even if DECL
5416 is *not* defined. */
5417 && (!DECL_EXTERNAL (decl) || init))
5421 DECL_NONTRIVIALLY_INITIALIZED_P (decl) = 1;
5422 if (init_const_expr_p)
5424 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
5425 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl))
5426 TREE_CONSTANT (decl) = 1;
5429 init = check_initializer (decl, init, flags, &cleanup);
5430 /* Thread-local storage cannot be dynamically initialized. */
5431 if (DECL_THREAD_LOCAL_P (decl) && init)
5433 error ("%qD is thread-local and so cannot be dynamically "
5434 "initialized", decl);
5438 /* Check that the initializer for a static data member was a
5439 constant. Although we check in the parser that the
5440 initializer is an integral constant expression, we do not
5441 simplify division-by-zero at the point at which it
5442 occurs. Therefore, in:
5444 struct S { static const int i = 7 / 0; };
5446 we issue an error at this point. It would
5447 probably be better to forbid division by zero in
5448 integral constant expressions. */
5449 if (DECL_EXTERNAL (decl) && init)
5451 error ("%qD cannot be initialized by a non-constant expression"
5452 " when being declared", decl);
5453 DECL_INITIALIZED_IN_CLASS_P (decl) = 0;
5461 The memory occupied by any object of static storage
5462 duration is zero-initialized at program startup before
5463 any other initialization takes place.
5465 We cannot create an appropriate initializer until after
5466 the type of DECL is finalized. If DECL_INITIAL is set,
5467 then the DECL is statically initialized, and any
5468 necessary zero-initialization has already been performed. */
5469 if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
5470 DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
5471 /*nelts=*/NULL_TREE,
5472 /*static_storage_p=*/true);
5473 /* Remember that the initialization for this variable has
5475 DECL_INITIALIZED_P (decl) = 1;
5476 /* This declaration is the definition of this variable,
5477 unless we are initializing a static data member within
5478 the class specifier. */
5479 if (!DECL_EXTERNAL (decl))
5480 var_definition_p = true;
5482 /* If the variable has an array type, lay out the type, even if
5483 there is no initializer. It is valid to index through the
5484 array, and we must get TYPE_ALIGN set correctly on the array
5486 else if (TREE_CODE (type) == ARRAY_TYPE)
5490 /* Add this declaration to the statement-tree. This needs to happen
5491 after the call to check_initializer so that the DECL_EXPR for a
5492 reference temp is added before the DECL_EXPR for the reference itself. */
5493 if (at_function_scope_p ())
5494 add_decl_expr (decl);
5496 /* Let the middle end know about variables and functions -- but not
5497 static data members in uninstantiated class templates. */
5498 if (!saved_processing_template_decl
5499 && (TREE_CODE (decl) == VAR_DECL
5500 || TREE_CODE (decl) == FUNCTION_DECL))
5502 if (TREE_CODE (decl) == VAR_DECL)
5504 layout_var_decl (decl);
5505 maybe_commonize_var (decl);
5508 /* This needs to happen after the linkage is set. */
5509 determine_visibility (decl);
5511 make_rtl_for_nonlocal_decl (decl, init, asmspec);
5513 /* Check for abstractness of the type. Notice that there is no
5514 need to strip array types here since the check for those types
5515 is already done within create_array_type_for_decl. */
5516 if (TREE_CODE (type) == FUNCTION_TYPE
5517 || TREE_CODE (type) == METHOD_TYPE)
5518 abstract_virtuals_error (decl, TREE_TYPE (type));
5520 abstract_virtuals_error (decl, type);
5522 if (TREE_CODE (decl) == FUNCTION_DECL
5523 || TREE_TYPE (decl) == error_mark_node)
5524 /* No initialization required. */
5526 else if (DECL_EXTERNAL (decl)
5527 && ! (DECL_LANG_SPECIFIC (decl)
5528 && DECL_NOT_REALLY_EXTERN (decl)))
5531 DECL_INITIAL (decl) = init;
5535 /* A variable definition. */
5536 if (DECL_FUNCTION_SCOPE_P (decl))
5538 /* Initialize the local variable. */
5539 if (processing_template_decl)
5540 DECL_INITIAL (decl) = init;
5541 else if (!TREE_STATIC (decl))
5542 initialize_local_var (decl, init);
5545 /* If a variable is defined, and then a subsequent
5546 definition with external linkage is encountered, we will
5547 get here twice for the same variable. We want to avoid
5548 calling expand_static_init more than once. For variables
5549 that are not static data members, we can call
5550 expand_static_init only when we actually process the
5551 initializer. It is not legal to redeclare a static data
5552 member, so this issue does not arise in that case. */
5553 if (var_definition_p && TREE_STATIC (decl))
5555 /* If a TREE_READONLY variable needs initialization
5556 at runtime, it is no longer readonly and we need to
5557 avoid MEM_READONLY_P being set on RTL created for it. */
5560 if (TREE_READONLY (decl))
5561 TREE_READONLY (decl) = 0;
5564 expand_static_init (decl, init);
5569 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
5570 reference, insert it in the statement-tree now. */
5572 push_cleanup (decl, cleanup, false);
5575 processing_template_decl = saved_processing_template_decl;
5578 TREE_READONLY (decl) = 1;
5580 /* If this was marked 'used', be sure it will be output. */
5581 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
5582 mark_decl_referenced (decl);
5585 /* This is here for a midend callback from c-common.c. */
5588 finish_decl (tree decl, tree init, tree asmspec_tree)
5590 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, asmspec_tree, 0);
5593 /* Returns a declaration for a VAR_DECL as if:
5595 extern "C" TYPE NAME;
5597 had been seen. Used to create compiler-generated global
5601 declare_global_var (tree name, tree type)
5605 push_to_top_level ();
5606 decl = build_decl (VAR_DECL, name, type);
5607 TREE_PUBLIC (decl) = 1;
5608 DECL_EXTERNAL (decl) = 1;
5609 DECL_ARTIFICIAL (decl) = 1;
5610 /* If the user has explicitly declared this variable (perhaps
5611 because the code we are compiling is part of a low-level runtime
5612 library), then it is possible that our declaration will be merged
5613 with theirs by pushdecl. */
5614 decl = pushdecl (decl);
5615 finish_decl (decl, NULL_TREE, NULL_TREE);
5616 pop_from_top_level ();
5621 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
5622 if "__cxa_atexit" is not being used) corresponding to the function
5623 to be called when the program exits. */
5626 get_atexit_fn_ptr_type (void)
5631 if (!atexit_fn_ptr_type_node)
5633 if (flag_use_cxa_atexit
5634 && !targetm.cxx.use_atexit_for_cxa_atexit ())
5635 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
5636 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5638 /* The parameter to "atexit" is "void (*)(void)". */
5639 arg_types = void_list_node;
5641 fn_type = build_function_type (void_type_node, arg_types);
5642 atexit_fn_ptr_type_node = build_pointer_type (fn_type);
5645 return atexit_fn_ptr_type_node;
5648 /* Returns a pointer to the `atexit' function. Note that if
5649 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
5650 `__cxa_atexit' function specified in the IA64 C++ ABI. */
5653 get_atexit_node (void)
5660 bool use_aeabi_atexit;
5665 if (flag_use_cxa_atexit && !targetm.cxx.use_atexit_for_cxa_atexit ())
5667 /* The declaration for `__cxa_atexit' is:
5669 int __cxa_atexit (void (*)(void *), void *, void *)
5671 We build up the argument types and then then function type
5674 use_aeabi_atexit = targetm.cxx.use_aeabi_atexit ();
5675 /* First, build the pointer-to-function type for the first
5677 fn_ptr_type = get_atexit_fn_ptr_type ();
5678 /* Then, build the rest of the argument types. */
5679 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5680 if (use_aeabi_atexit)
5682 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
5683 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
5687 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
5688 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
5690 /* And the final __cxa_atexit type. */
5691 fn_type = build_function_type (integer_type_node, arg_types);
5692 fn_ptr_type = build_pointer_type (fn_type);
5693 if (use_aeabi_atexit)
5694 name = "__aeabi_atexit";
5696 name = "__cxa_atexit";
5700 /* The declaration for `atexit' is:
5702 int atexit (void (*)());
5704 We build up the argument types and then then function type
5706 fn_ptr_type = get_atexit_fn_ptr_type ();
5707 arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
5708 /* Build the final atexit type. */
5709 fn_type = build_function_type (integer_type_node, arg_types);
5713 /* Now, build the function declaration. */
5714 push_lang_context (lang_name_c);
5715 atexit_fndecl = build_library_fn_ptr (name, fn_type);
5716 mark_used (atexit_fndecl);
5717 pop_lang_context ();
5718 atexit_node = decay_conversion (atexit_fndecl);
5723 /* Returns the __dso_handle VAR_DECL. */
5726 get_dso_handle_node (void)
5728 if (dso_handle_node)
5729 return dso_handle_node;
5731 /* Declare the variable. */
5732 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
5735 return dso_handle_node;
5738 /* Begin a new function with internal linkage whose job will be simply
5739 to destroy some particular variable. */
5741 static GTY(()) int start_cleanup_cnt;
5744 start_cleanup_fn (void)
5749 bool use_cxa_atexit = flag_use_cxa_atexit
5750 && !targetm.cxx.use_atexit_for_cxa_atexit ();
5752 push_to_top_level ();
5754 /* No need to mangle this. */
5755 push_lang_context (lang_name_c);
5757 /* Build the name of the function. */
5758 sprintf (name, "__tcf_%d", start_cleanup_cnt++);
5759 /* Build the function declaration. */
5760 fntype = TREE_TYPE (get_atexit_fn_ptr_type ());
5761 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
5762 /* It's a function with internal linkage, generated by the
5764 TREE_PUBLIC (fndecl) = 0;
5765 DECL_ARTIFICIAL (fndecl) = 1;
5766 /* Make the function `inline' so that it is only emitted if it is
5767 actually needed. It is unlikely that it will be inlined, since
5768 it is only called via a function pointer, but we avoid unnecessary
5769 emissions this way. */
5770 DECL_INLINE (fndecl) = 1;
5771 DECL_DECLARED_INLINE_P (fndecl) = 1;
5772 DECL_INTERFACE_KNOWN (fndecl) = 1;
5773 /* Build the parameter. */
5778 parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
5779 DECL_CONTEXT (parmdecl) = fndecl;
5780 TREE_USED (parmdecl) = 1;
5781 DECL_ARGUMENTS (fndecl) = parmdecl;
5785 start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED);
5787 pop_lang_context ();
5789 return current_function_decl;
5792 /* Finish the cleanup function begun by start_cleanup_fn. */
5795 end_cleanup_fn (void)
5797 expand_or_defer_fn (finish_function (0));
5799 pop_from_top_level ();
5802 /* Generate code to handle the destruction of DECL, an object with
5803 static storage duration. */
5806 register_dtor_fn (tree decl)
5815 type = TREE_TYPE (decl);
5816 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
5817 return void_zero_node;
5819 /* If we're using "__cxa_atexit" (or "__aeabi_atexit"), and DECL is
5820 a class object, we can just pass the destructor to
5821 "__cxa_atexit"; we don't have to build a temporary function to do
5823 use_dtor = (flag_use_cxa_atexit
5824 && !targetm.cxx.use_atexit_for_cxa_atexit ()
5825 && CLASS_TYPE_P (type));
5830 /* Find the destructor. */
5831 idx = lookup_fnfields_1 (type, complete_dtor_identifier);
5832 gcc_assert (idx >= 0);
5833 cleanup = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), idx);
5834 /* Make sure it is accessible. */
5835 perform_or_defer_access_check (TYPE_BINFO (type), cleanup, cleanup);
5839 /* Call build_cleanup before we enter the anonymous function so
5840 that any access checks will be done relative to the current
5841 scope, rather than the scope of the anonymous function. */
5842 build_cleanup (decl);
5844 /* Now start the function. */
5845 cleanup = start_cleanup_fn ();
5847 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
5848 to the original function, rather than the anonymous one. That
5849 will make the back end think that nested functions are in use,
5850 which causes confusion. */
5851 push_deferring_access_checks (dk_no_check);
5852 fcall = build_cleanup (decl);
5853 pop_deferring_access_checks ();
5855 /* Create the body of the anonymous function. */
5856 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
5857 finish_expr_stmt (fcall);
5858 finish_compound_stmt (compound_stmt);
5862 /* Call atexit with the cleanup function. */
5863 mark_used (cleanup);
5864 cleanup = build_address (cleanup);
5865 if (flag_use_cxa_atexit && !targetm.cxx.use_atexit_for_cxa_atexit ())
5871 /* We must convert CLEANUP to the type that "__cxa_atexit"
5873 cleanup = build_nop (get_atexit_fn_ptr_type (), cleanup);
5874 /* "__cxa_atexit" will pass the address of DECL to the
5875 cleanup function. */
5877 addr = build_address (decl);
5878 /* The declared type of the parameter to "__cxa_atexit" is
5879 "void *". For plain "T*", we could just let the
5880 machinery in build_function_call convert it -- but if the
5881 type is "cv-qualified T *", then we need to convert it
5882 before passing it in, to avoid spurious errors. */
5883 addr = build_nop (ptr_type_node, addr);
5886 /* Since the cleanup functions we build ignore the address
5887 they're given, there's no reason to pass the actual address
5888 in, and, in general, it's cheaper to pass NULL than any
5890 addr = null_pointer_node;
5891 args = tree_cons (NULL_TREE,
5892 build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0),
5894 if (targetm.cxx.use_aeabi_atexit ())
5896 args = tree_cons (NULL_TREE, cleanup, args);
5897 args = tree_cons (NULL_TREE, addr, args);
5901 args = tree_cons (NULL_TREE, addr, args);
5902 args = tree_cons (NULL_TREE, cleanup, args);
5906 args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
5907 return build_function_call (get_atexit_node (), args);
5910 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
5911 is its initializer. Generate code to handle the construction
5912 and destruction of DECL. */
5915 expand_static_init (tree decl, tree init)
5917 gcc_assert (TREE_CODE (decl) == VAR_DECL);
5918 gcc_assert (TREE_STATIC (decl));
5920 /* Some variables require no initialization. */
5922 && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
5923 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
5926 if (DECL_FUNCTION_SCOPE_P (decl))
5928 /* Emit code to perform this initialization but once. */
5929 tree if_stmt = NULL_TREE, inner_if_stmt = NULL_TREE;
5930 tree then_clause = NULL_TREE, inner_then_clause = NULL_TREE;
5931 tree guard, guard_addr;
5932 tree acquire_fn, release_fn, abort_fn;
5935 /* Emit code to perform this initialization but once. This code
5938 static <type> guard;
5939 if (!guard.first_byte) {
5940 if (__cxa_guard_acquire (&guard)) {
5943 // Do initialization.
5944 flag = true; __cxa_guard_release (&guard);
5945 // Register variable for destruction at end of program.
5947 if (!flag) __cxa_guard_abort (&guard);
5951 Note that the `flag' variable is only set to 1 *after* the
5952 initialization is complete. This ensures that an exception,
5953 thrown during the construction, will cause the variable to
5954 reinitialized when we pass through this code again, as per:
5958 If the initialization exits by throwing an exception, the
5959 initialization is not complete, so it will be tried again
5960 the next time control enters the declaration.
5962 This process should be thread-safe, too; multiple threads
5963 should not be able to initialize the variable more than
5966 /* Create the guard variable. */
5967 guard = get_guard (decl);
5969 /* This optimization isn't safe on targets with relaxed memory
5970 consistency. On such targets we force synchronization in
5971 __cxa_guard_acquire. */
5972 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
5974 /* Begin the conditional initialization. */
5975 if_stmt = begin_if_stmt ();
5976 finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
5977 then_clause = begin_compound_stmt (BCS_NO_SCOPE);
5980 if (flag_threadsafe_statics)
5982 guard_addr = build_address (guard);
5984 acquire_fn = get_identifier ("__cxa_guard_acquire");
5985 release_fn = get_identifier ("__cxa_guard_release");
5986 abort_fn = get_identifier ("__cxa_guard_abort");
5987 if (!get_global_value_if_present (acquire_fn, &acquire_fn))
5989 tree argtypes = tree_cons (NULL_TREE, TREE_TYPE (guard_addr),
5991 tree vfntype = build_function_type (void_type_node, argtypes);
5992 acquire_fn = push_library_fn
5993 (acquire_fn, build_function_type (integer_type_node, argtypes));
5994 release_fn = push_library_fn (release_fn, vfntype);
5995 abort_fn = push_library_fn (abort_fn, vfntype);
5999 release_fn = identifier_global_value (release_fn);
6000 abort_fn = identifier_global_value (abort_fn);
6003 inner_if_stmt = begin_if_stmt ();
6004 finish_if_stmt_cond (build_call_n (acquire_fn, 1, guard_addr),
6007 inner_then_clause = begin_compound_stmt (BCS_NO_SCOPE);
6008 begin = get_target_expr (boolean_false_node);
6009 flag = TARGET_EXPR_SLOT (begin);
6011 TARGET_EXPR_CLEANUP (begin)
6012 = build3 (COND_EXPR, void_type_node, flag,
6014 build_call_n (abort_fn, 1, guard_addr));
6015 CLEANUP_EH_ONLY (begin) = 1;
6017 /* Do the initialization itself. */
6018 init = add_stmt_to_compound (begin, init);
6019 init = add_stmt_to_compound
6020 (init, build2 (MODIFY_EXPR, void_type_node, flag, boolean_true_node));
6021 init = add_stmt_to_compound
6022 (init, build_call_n (release_fn, 1, guard_addr));
6025 init = add_stmt_to_compound (init, set_guard (guard));
6027 /* Use atexit to register a function for destroying this static
6029 init = add_stmt_to_compound (init, register_dtor_fn (decl));
6031 finish_expr_stmt (init);
6033 if (flag_threadsafe_statics)
6035 finish_compound_stmt (inner_then_clause);
6036 finish_then_clause (inner_if_stmt);
6037 finish_if_stmt (inner_if_stmt);
6040 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
6042 finish_compound_stmt (then_clause);
6043 finish_then_clause (if_stmt);
6044 finish_if_stmt (if_stmt);
6048 static_aggregates = tree_cons (init, decl, static_aggregates);
6052 /* Make TYPE a complete type based on INITIAL_VALUE.
6053 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6054 2 if there was no information (in which case assume 0 if DO_DEFAULT),
6055 3 if the initializer list is empty (in pedantic mode). */
6058 cp_complete_array_type (tree *ptype, tree initial_value, bool do_default)
6061 tree type, elt_type;
6065 /* An array of character type can be initialized from a
6066 brace-enclosed string constant.
6068 FIXME: this code is duplicated from reshape_init. Probably
6069 we should just call reshape_init here? */
6070 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype)))
6071 && TREE_CODE (initial_value) == CONSTRUCTOR
6072 && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (initial_value)))
6074 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
6075 tree value = VEC_index (constructor_elt, v, 0)->value;
6077 if (TREE_CODE (value) == STRING_CST
6078 && VEC_length (constructor_elt, v) == 1)
6079 initial_value = value;
6083 failure = complete_array_type (ptype, initial_value, do_default);
6085 /* We can create the array before the element type is complete, which
6086 means that we didn't have these two bits set in the original type
6087 either. In completing the type, we are expected to propagate these
6088 bits. See also complete_type which does the same thing for arrays
6091 if (TYPE_DOMAIN (type))
6093 elt_type = TREE_TYPE (type);
6094 TYPE_NEEDS_CONSTRUCTING (type) = TYPE_NEEDS_CONSTRUCTING (elt_type);
6095 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
6096 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type);
6102 /* Return zero if something is declared to be a member of type
6103 CTYPE when in the context of CUR_TYPE. STRING is the error
6104 message to print in that case. Otherwise, quietly return 1. */
6107 member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
6109 if (ctype && ctype != cur_type)
6111 if (flags == DTOR_FLAG)
6112 error ("destructor for alien class %qT cannot be a member", ctype);
6114 error ("constructor for alien class %qT cannot be a member", ctype);
6120 /* Subroutine of `grokdeclarator'. */
6122 /* Generate errors possibly applicable for a given set of specifiers.
6123 This is for ARM $7.1.2. */
6126 bad_specifiers (tree object,
6135 error ("%qD declared as a %<virtual%> %s", object, type);
6137 error ("%qD declared as an %<inline%> %s", object, type);
6139 error ("%<const%> and %<volatile%> function specifiers on "
6140 "%qD invalid in %s declaration",
6143 error ("%q+D declared as a friend", object);
6145 && (TREE_CODE (object) == TYPE_DECL
6146 || (!TYPE_PTRFN_P (TREE_TYPE (object))
6147 && !TYPE_REFFN_P (TREE_TYPE (object))
6148 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
6149 error ("%q+D declared with an exception specification", object);
6152 /* DECL is a member function or static data member and is presently
6153 being defined. Check that the definition is taking place in a
6157 check_class_member_definition_namespace (tree decl)
6159 /* These checks only apply to member functions and static data
6161 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
6162 || TREE_CODE (decl) == VAR_DECL);
6163 /* We check for problems with specializations in pt.c in
6164 check_specialization_namespace, where we can issue better
6166 if (processing_specialization)
6168 /* There are no restrictions on the placement of
6169 explicit instantiations. */
6170 if (processing_explicit_instantiation)
6174 A member function definition that appears outside of the
6175 class definition shall appear in a namespace scope enclosing
6176 the class definition.
6180 The definition for a static data member shall appear in a
6181 namespace scope enclosing the member's class definition. */
6182 if (!is_ancestor (current_namespace, DECL_CONTEXT (decl)))
6183 pedwarn ("definition of %qD is not in namespace enclosing %qT",
6184 decl, DECL_CONTEXT (decl));
6187 /* Build a PARM_DECL for the "this" parameter. TYPE is the
6188 METHOD_TYPE for a non-static member function; QUALS are the
6189 cv-qualifiers that apply to the function. */
6192 build_this_parm (tree type, cp_cv_quals quals)
6197 cp_cv_quals this_quals;
6199 this_type = TREE_VALUE (TYPE_ARG_TYPES (type));
6200 /* The `this' parameter is implicitly `const'; it cannot be
6202 this_quals = (quals & TYPE_QUAL_RESTRICT) | TYPE_QUAL_CONST;
6203 qual_type = cp_build_qualified_type (this_type, this_quals);
6204 parm = build_artificial_parm (this_identifier, qual_type);
6205 cp_apply_type_quals_to_decl (this_quals, parm);
6209 /* CTYPE is class type, or null if non-class.
6210 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
6212 DECLARATOR is the function's name.
6213 PARMS is a chain of PARM_DECLs for the function.
6214 VIRTUALP is truthvalue of whether the function is virtual or not.
6215 FLAGS are to be passed through to `grokclassfn'.
6216 QUALS are qualifiers indicating whether the function is `const'
6218 RAISES is a list of exceptions that this function can raise.
6219 CHECK is 1 if we must find this method in CTYPE, 0 if we should
6220 not look, and -1 if we should not call `grokclassfn' at all.
6222 SFK is the kind of special function (if any) for the new function.
6224 Returns `NULL_TREE' if something goes wrong, after issuing
6225 applicable error messages. */
6228 grokfndecl (tree ctype,
6232 tree orig_declarator,
6234 enum overload_flags flags,
6241 special_function_kind sfk,
6248 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
6252 type = build_exception_variant (type, raises);
6254 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
6255 if (TREE_CODE (type) == METHOD_TYPE)
6258 parm = build_this_parm (type, quals);
6259 TREE_CHAIN (parm) = parms;
6262 DECL_ARGUMENTS (decl) = parms;
6263 /* Propagate volatile out from type to decl. */
6264 if (TYPE_VOLATILE (type))
6265 TREE_THIS_VOLATILE (decl) = 1;
6267 /* Setup decl according to sfk. */
6270 case sfk_constructor:
6271 case sfk_copy_constructor:
6272 DECL_CONSTRUCTOR_P (decl) = 1;
6274 case sfk_destructor:
6275 DECL_DESTRUCTOR_P (decl) = 1;
6281 /* If pointers to member functions use the least significant bit to
6282 indicate whether a function is virtual, ensure a pointer
6283 to this function will have that bit clear. */
6284 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
6285 && TREE_CODE (type) == METHOD_TYPE
6286 && DECL_ALIGN (decl) < 2 * BITS_PER_UNIT)
6287 DECL_ALIGN (decl) = 2 * BITS_PER_UNIT;
6290 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
6294 ("defining explicit specialization %qD in friend declaration",
6298 tree fns = TREE_OPERAND (orig_declarator, 0);
6299 tree args = TREE_OPERAND (orig_declarator, 1);
6301 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
6303 /* Something like `template <class T> friend void f<T>()'. */
6304 error ("invalid use of template-id %qD in declaration "
6305 "of primary template",
6311 /* A friend declaration of the form friend void f<>(). Record
6312 the information in the TEMPLATE_ID_EXPR. */
6313 SET_DECL_IMPLICIT_INSTANTIATION (decl);
6315 if (TREE_CODE (fns) == COMPONENT_REF)
6317 /* Due to bison parser ickiness, we will have already looked
6318 up an operator_name or PFUNCNAME within the current class
6319 (see template_id in parse.y). If the current class contains
6320 such a name, we'll get a COMPONENT_REF here. Undo that. */
6322 gcc_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
6323 == current_class_type);
6324 fns = TREE_OPERAND (fns, 1);
6326 gcc_assert (TREE_CODE (fns) == IDENTIFIER_NODE
6327 || TREE_CODE (fns) == OVERLOAD);
6328 DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
6330 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
6331 if (TREE_PURPOSE (t)
6332 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
6334 error ("default arguments are not allowed in declaration "
6335 "of friend template specialization %qD",
6342 error ("%<inline%> is not allowed in declaration of friend "
6343 "template specialization %qD",
6350 /* If this decl has namespace scope, set that up. */
6352 set_decl_namespace (decl, in_namespace, friendp);
6354 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
6356 /* `main' and builtins have implicit 'C' linkage. */
6357 if ((MAIN_NAME_P (declarator)
6358 || (IDENTIFIER_LENGTH (declarator) > 10
6359 && IDENTIFIER_POINTER (declarator)[0] == '_'
6360 && IDENTIFIER_POINTER (declarator)[1] == '_'
6361 && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
6362 && current_lang_name == lang_name_cplusplus
6363 && ctype == NULL_TREE
6364 /* NULL_TREE means global namespace. */
6365 && DECL_CONTEXT (decl) == NULL_TREE)
6366 SET_DECL_LANGUAGE (decl, lang_c);
6368 /* Should probably propagate const out from type to decl I bet (mrs). */
6371 DECL_STATIC_FUNCTION_P (decl) = 1;
6372 DECL_CONTEXT (decl) = ctype;
6377 DECL_CONTEXT (decl) = ctype;
6379 check_class_member_definition_namespace (decl);
6382 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
6384 if (processing_template_decl)
6385 error ("cannot declare %<::main%> to be a template");
6387 error ("cannot declare %<::main%> to be inline");
6389 error ("cannot declare %<::main%> to be static");
6394 /* Members of anonymous types and local classes have no linkage; make
6395 them internal. If a typedef is made later, this will be changed. */
6396 if (ctype && (TYPE_ANONYMOUS_P (ctype)
6397 || decl_function_context (TYPE_MAIN_DECL (ctype))))
6402 /* [basic.link]: A name with no linkage (notably, the name of a class
6403 or enumeration declared in a local scope) shall not be used to
6404 declare an entity with linkage.
6406 Only check this for public decls for now. See core 319, 389. */
6407 t = no_linkage_check (TREE_TYPE (decl),
6408 /*relaxed_p=*/false);
6411 if (TYPE_ANONYMOUS_P (t))
6413 if (DECL_EXTERN_C_P (decl))
6414 /* Allow this; it's pretty common in C. */;
6417 pedwarn ("non-local function %q#D uses anonymous type",
6419 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
6420 pedwarn ("%q+#D does not refer to the unqualified "
6421 "type, so it is not used for linkage",
6426 pedwarn ("non-local function %q#D uses local type %qT", decl, t);
6430 TREE_PUBLIC (decl) = publicp;
6433 DECL_INTERFACE_KNOWN (decl) = 1;
6434 DECL_NOT_REALLY_EXTERN (decl) = 1;
6437 /* If the declaration was declared inline, mark it as such. */
6439 DECL_DECLARED_INLINE_P (decl) = 1;
6440 /* We inline functions that are explicitly declared inline, or, when
6441 the user explicitly asks us to, all functions. */
6442 if (DECL_DECLARED_INLINE_P (decl)
6443 || (flag_inline_trees == 2 && !DECL_INLINE (decl) && funcdef_flag))
6444 DECL_INLINE (decl) = 1;
6446 DECL_EXTERNAL (decl) = 1;
6447 if (quals && TREE_CODE (type) == FUNCTION_TYPE)
6450 ? G_("static member function %qD cannot have cv-qualifier")
6451 : G_("non-member function %qD cannot have cv-qualifier"),
6453 quals = TYPE_UNQUALIFIED;
6456 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl))
6457 && !grok_op_properties (decl, /*complain=*/true))
6460 if (ctype && decl_function_context (decl))
6461 DECL_NO_STATIC_CHAIN (decl) = 1;
6464 /* Make the init_value nonzero so pushdecl knows this is not
6465 tentative. error_mark_node is replaced later with the BLOCK. */
6466 DECL_INITIAL (decl) = error_mark_node;
6468 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
6469 TREE_NOTHROW (decl) = 1;
6471 /* Caller will do the rest of this. */
6475 if (ctype != NULL_TREE)
6476 grokclassfn (ctype, decl, flags);
6478 decl = check_explicit_specialization (orig_declarator, decl,
6481 4 * (friendp != 0));
6482 if (decl == error_mark_node)
6487 cplus_decl_attributes (&decl, *attrlist, 0);
6488 *attrlist = NULL_TREE;
6491 /* Check main's type after attributes have been applied. */
6492 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
6494 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
6497 tree oldtypeargs = TYPE_ARG_TYPES (TREE_TYPE (decl));
6499 error ("%<::main%> must return %<int%>");
6500 newtype = build_function_type (integer_type_node, oldtypeargs);
6501 TREE_TYPE (decl) = newtype;
6503 check_main_parameter_types (decl);
6506 if (ctype != NULL_TREE
6507 && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
6510 tree old_decl = check_classfn (ctype, decl,
6511 (processing_template_decl
6512 > template_class_depth (ctype))
6513 ? current_template_parms
6516 if (old_decl == error_mark_node)
6524 if (TREE_CODE (old_decl) == TEMPLATE_DECL)
6525 /* Because grokfndecl is always supposed to return a
6526 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
6527 here. We depend on our callers to figure out that its
6528 really a template that's being returned. */
6529 old_decl = DECL_TEMPLATE_RESULT (old_decl);
6531 if (DECL_STATIC_FUNCTION_P (old_decl)
6532 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
6533 /* Remove the `this' parm added by grokclassfn.
6534 XXX Isn't this done in start_function, too? */
6535 revert_static_member_fn (decl);
6536 if (DECL_ARTIFICIAL (old_decl))
6537 error ("definition of implicitly-declared %qD", old_decl);
6539 /* Since we've smashed OLD_DECL to its
6540 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
6541 if (TREE_CODE (decl) == TEMPLATE_DECL)
6542 decl = DECL_TEMPLATE_RESULT (decl);
6544 /* Attempt to merge the declarations. This can fail, in
6545 the case of some invalid specialization declarations. */
6546 pushed_scope = push_scope (ctype);
6547 ok = duplicate_decls (decl, old_decl, friendp);
6549 pop_scope (pushed_scope);
6552 error ("no %q#D member function declared in class %qT",
6560 if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
6563 if (ctype == NULL_TREE || check)
6567 DECL_VIRTUAL_P (decl) = 1;
6572 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
6573 the linkage that DECL will receive in the object file. */
6576 set_linkage_for_static_data_member (tree decl)
6578 /* A static data member always has static storage duration and
6579 external linkage. Note that static data members are forbidden in
6580 local classes -- the only situation in which a class has
6581 non-external linkage. */
6582 TREE_PUBLIC (decl) = 1;
6583 TREE_STATIC (decl) = 1;
6584 /* For non-template classes, static data members are always put
6585 out in exactly those files where they are defined, just as
6586 with ordinary namespace-scope variables. */
6587 if (!processing_template_decl)
6588 DECL_INTERFACE_KNOWN (decl) = 1;
6591 /* Create a VAR_DECL named NAME with the indicated TYPE.
6593 If SCOPE is non-NULL, it is the class type or namespace containing
6594 the variable. If SCOPE is NULL, the variable should is created in
6595 the innermost enclosings scope. */
6598 grokvardecl (tree type,
6600 const cp_decl_specifier_seq *declspecs,
6606 tree explicit_scope;
6608 gcc_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE);
6610 /* Compute the scope in which to place the variable, but remember
6611 whether or not that scope was explicitly specified by the user. */
6612 explicit_scope = scope;
6615 /* An explicit "extern" specifier indicates a namespace-scope
6617 if (declspecs->storage_class == sc_extern)
6618 scope = current_namespace;
6619 else if (!at_function_scope_p ())
6620 scope = current_scope ();
6624 && (/* If the variable is a namespace-scope variable declared in a
6625 template, we need DECL_LANG_SPECIFIC. */
6626 (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
6627 /* Similarly for namespace-scope variables with language linkage
6629 || (TREE_CODE (scope) == NAMESPACE_DECL
6630 && current_lang_name != lang_name_cplusplus)
6631 /* Similarly for static data members. */
6633 decl = build_lang_decl (VAR_DECL, name, type);
6635 decl = build_decl (VAR_DECL, name, type);
6637 if (explicit_scope && TREE_CODE (explicit_scope) == NAMESPACE_DECL)
6638 set_decl_namespace (decl, explicit_scope, 0);
6640 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
6642 if (declspecs->storage_class == sc_extern)
6644 DECL_THIS_EXTERN (decl) = 1;
6645 DECL_EXTERNAL (decl) = !initialized;
6648 if (DECL_CLASS_SCOPE_P (decl))
6650 set_linkage_for_static_data_member (decl);
6651 /* This function is only called with out-of-class definitions. */
6652 DECL_EXTERNAL (decl) = 0;
6653 check_class_member_definition_namespace (decl);
6655 /* At top level, either `static' or no s.c. makes a definition
6656 (perhaps tentative), and absence of `static' makes it public. */
6657 else if (toplevel_bindings_p ())
6659 TREE_PUBLIC (decl) = (declspecs->storage_class != sc_static
6660 && (DECL_THIS_EXTERN (decl) || ! constp));
6661 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
6663 /* Not at top level, only `static' makes a static definition. */
6666 TREE_STATIC (decl) = declspecs->storage_class == sc_static;
6667 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
6670 if (declspecs->specs[(int)ds_thread])
6671 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
6673 if (TREE_PUBLIC (decl))
6675 /* [basic.link]: A name with no linkage (notably, the name of a class
6676 or enumeration declared in a local scope) shall not be used to
6677 declare an entity with linkage.
6679 Only check this for public decls for now. */
6680 tree t = no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false);
6683 if (TYPE_ANONYMOUS_P (t))
6685 if (DECL_EXTERN_C_P (decl))
6686 /* Allow this; it's pretty common in C. */
6690 /* DRs 132, 319 and 389 seem to indicate types with
6691 no linkage can only be used to declare extern "C"
6692 entities. Since it's not always an error in the
6693 ISO C++ 90 Standard, we only issue a warning. */
6694 warning (0, "non-local variable %q#D uses anonymous type",
6696 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
6697 warning (0, "%q+#D does not refer to the unqualified "
6698 "type, so it is not used for linkage",
6703 warning (0, "non-local variable %q#D uses local type %qT", decl, t);
6707 DECL_INTERFACE_KNOWN (decl) = 1;
6712 /* Create and return a canonical pointer to member function type, for
6713 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
6716 build_ptrmemfunc_type (tree type)
6720 tree unqualified_variant = NULL_TREE;
6722 if (type == error_mark_node)
6725 /* If a canonical type already exists for this type, use it. We use
6726 this method instead of type_hash_canon, because it only does a
6727 simple equality check on the list of field members. */
6729 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
6732 /* Make sure that we always have the unqualified pointer-to-member
6734 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
6736 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
6738 t = make_aggr_type (RECORD_TYPE);
6739 xref_basetypes (t, NULL_TREE);
6741 /* Let the front end know this is a pointer to member function... */
6742 TYPE_PTRMEMFUNC_FLAG (t) = 1;
6743 /* ... and not really an aggregate. */
6744 SET_IS_AGGR_TYPE (t, 0);
6746 field = build_decl (FIELD_DECL, pfn_identifier, type);
6749 field = build_decl (FIELD_DECL, delta_identifier, delta_type_node);
6750 TREE_CHAIN (field) = fields;
6753 finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
6755 /* Zap out the name so that the back end will give us the debugging
6756 information for this anonymous RECORD_TYPE. */
6757 TYPE_NAME (t) = NULL_TREE;
6759 /* If this is not the unqualified form of this pointer-to-member
6760 type, set the TYPE_MAIN_VARIANT for this type to be the
6761 unqualified type. Since they are actually RECORD_TYPEs that are
6762 not variants of each other, we must do this manually. */
6763 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
6765 t = build_qualified_type (t, cp_type_quals (type));
6766 TYPE_MAIN_VARIANT (t) = unqualified_variant;
6767 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
6768 TYPE_NEXT_VARIANT (unqualified_variant) = t;
6771 /* Cache this pointer-to-member type so that we can find it again
6773 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
6775 /* Managing canonical types for the RECORD_TYPE behind a
6776 pointer-to-member function is a nightmare, so use structural
6777 equality for now. */
6778 SET_TYPE_STRUCTURAL_EQUALITY (t);
6783 /* Create and return a pointer to data member type. */
6786 build_ptrmem_type (tree class_type, tree member_type)
6788 if (TREE_CODE (member_type) == METHOD_TYPE)
6792 arg_types = TYPE_ARG_TYPES (member_type);
6793 class_type = (cp_build_qualified_type
6795 cp_type_quals (TREE_TYPE (TREE_VALUE (arg_types)))));
6797 = build_method_type_directly (class_type,
6798 TREE_TYPE (member_type),
6799 TREE_CHAIN (arg_types));
6800 return build_ptrmemfunc_type (build_pointer_type (member_type));
6804 gcc_assert (TREE_CODE (member_type) != FUNCTION_TYPE);
6805 return build_offset_type (class_type, member_type);
6809 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
6810 Check to see that the definition is valid. Issue appropriate error
6811 messages. Return 1 if the definition is particularly bad, or 0
6815 check_static_variable_definition (tree decl, tree type)
6817 /* Motion 10 at San Diego: If a static const integral data member is
6818 initialized with an integral constant expression, the initializer
6819 may appear either in the declaration (within the class), or in
6820 the definition, but not both. If it appears in the class, the
6821 member is a member constant. The file-scope definition is always
6823 if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
6825 error ("invalid in-class initialization of static data member "
6826 "of non-integral type %qT",
6828 /* If we just return the declaration, crashes will sometimes
6829 occur. We therefore return void_type_node, as if this were a
6830 friend declaration, to cause callers to completely ignore
6831 this declaration. */
6834 else if (!CP_TYPE_CONST_P (type))
6835 error ("ISO C++ forbids in-class initialization of non-const "
6836 "static member %qD",
6838 else if (pedantic && !INTEGRAL_TYPE_P (type))
6839 pedwarn ("ISO C++ forbids initialization of member constant "
6840 "%qD of non-integral type %qT", decl, type);
6845 /* Given the SIZE (i.e., number of elements) in an array, compute an
6846 appropriate index type for the array. If non-NULL, NAME is the
6847 name of the thing being declared. */
6850 compute_array_index_type (tree name, tree size)
6854 tree abi_1_itype = NULL_TREE;
6856 if (error_operand_p (size))
6857 return error_mark_node;
6859 type = TREE_TYPE (size);
6860 /* The array bound must be an integer type. */
6861 if (!dependent_type_p (type) && !INTEGRAL_TYPE_P (type))
6864 error ("size of array %qD has non-integral type %qT", name, type);
6866 error ("size of array has non-integral type %qT", type);
6867 size = integer_one_node;
6868 type = TREE_TYPE (size);
6871 if (value_dependent_expression_p (size))
6873 /* We cannot do any checking for a value-dependent SIZE. Just
6874 build the index type and mark that it requires structural
6876 itype = build_index_type (build_min (MINUS_EXPR, sizetype,
6877 size, integer_one_node));
6878 SET_TYPE_STRUCTURAL_EQUALITY (itype);
6882 if (!abi_version_at_least (2) && processing_template_decl)
6883 /* For abi-1, we handled all instances in templates the same way,
6884 even when they were non-dependent. This effects the manglings
6885 produced. So, we do the normal checking for non-dependent
6886 sizes, but at the end we'll return the same type that abi-1
6887 would have, but with TYPE_CANONICAL set to the "right"
6888 value that the current ABI would provide. */
6889 abi_1_itype = build_index_type (build_min (MINUS_EXPR, sizetype,
6890 size, integer_one_node));
6892 /* The size might be the result of a cast. */
6893 STRIP_TYPE_NOPS (size);
6895 /* It might be a const variable or enumeration constant. */
6896 size = integral_constant_value (size);
6898 /* Normally, the array-bound will be a constant. */
6899 if (TREE_CODE (size) == INTEGER_CST)
6901 /* Check to see if the array bound overflowed. Make that an
6902 error, no matter how generous we're being. */
6903 int old_flag_pedantic_errors = flag_pedantic_errors;
6904 int old_pedantic = pedantic;
6905 pedantic = flag_pedantic_errors = 1;
6906 constant_expression_warning (size);
6907 pedantic = old_pedantic;
6908 flag_pedantic_errors = old_flag_pedantic_errors;
6910 /* An array must have a positive number of elements. */
6911 if (INT_CST_LT (size, integer_zero_node))
6914 error ("size of array %qD is negative", name);
6916 error ("size of array is negative");
6917 size = integer_one_node;
6919 /* As an extension we allow zero-sized arrays. We always allow
6920 them in system headers because glibc uses them. */
6921 else if (integer_zerop (size) && pedantic && !in_system_header)
6924 pedwarn ("ISO C++ forbids zero-size array %qD", name);
6926 pedwarn ("ISO C++ forbids zero-size array");
6929 else if (TREE_CONSTANT (size))
6931 /* `(int) &fn' is not a valid array bound. */
6933 error ("size of array %qD is not an integral constant-expression",
6936 error ("size of array is not an integral constant-expression");
6937 size = integer_one_node;
6939 else if (pedantic && warn_vla != 0)
6942 pedwarn ("ISO C++ forbids variable length array %qD", name);
6944 pedwarn ("ISO C++ forbids variable length array");
6946 else if (warn_vla > 0)
6950 "variable length array %qD is used", name);
6953 "variable length array is used");
6956 if (processing_template_decl && !TREE_CONSTANT (size))
6957 /* A variable sized array. */
6958 itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node);
6961 HOST_WIDE_INT saved_processing_template_decl;
6963 /* Compute the index of the largest element in the array. It is
6964 one less than the number of elements in the array. We save
6965 and restore PROCESSING_TEMPLATE_DECL so that computations in
6966 cp_build_binary_op will be appropriately folded. */
6967 saved_processing_template_decl = processing_template_decl;
6968 processing_template_decl = 0;
6969 itype = cp_build_binary_op (MINUS_EXPR,
6970 cp_convert (ssizetype, size),
6971 cp_convert (ssizetype, integer_one_node));
6972 itype = fold (itype);
6973 processing_template_decl = saved_processing_template_decl;
6975 if (!TREE_CONSTANT (itype))
6976 /* A variable sized array. */
6977 itype = variable_size (itype);
6978 /* Make sure that there was no overflow when creating to a signed
6979 index type. (For example, on a 32-bit machine, an array with
6980 size 2^32 - 1 is too big.) */
6981 else if (TREE_CODE (itype) == INTEGER_CST
6982 && TREE_OVERFLOW (itype))
6984 error ("overflow in array dimension");
6985 TREE_OVERFLOW (itype) = 0;
6989 /* Create and return the appropriate index type. */
6992 tree t = build_index_type (itype);
6993 TYPE_CANONICAL (abi_1_itype) = TYPE_CANONICAL (t);
6997 return build_index_type (itype);
7000 /* Returns the scope (if any) in which the entity declared by
7001 DECLARATOR will be located. If the entity was declared with an
7002 unqualified name, NULL_TREE is returned. */
7005 get_scope_of_declarator (const cp_declarator *declarator)
7007 while (declarator && declarator->kind != cdk_id)
7008 declarator = declarator->declarator;
7010 /* If the declarator-id is a SCOPE_REF, the scope in which the
7011 declaration occurs is the first operand. */
7013 && declarator->u.id.qualifying_scope)
7014 return declarator->u.id.qualifying_scope;
7016 /* Otherwise, the declarator is not a qualified name; the entity will
7017 be declared in the current scope. */
7021 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
7022 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
7026 create_array_type_for_decl (tree name, tree type, tree size)
7028 tree itype = NULL_TREE;
7029 const char* error_msg;
7031 /* If things have already gone awry, bail now. */
7032 if (type == error_mark_node || size == error_mark_node)
7033 return error_mark_node;
7035 /* Assume that everything will go OK. */
7038 /* There are some types which cannot be array elements. */
7039 switch (TREE_CODE (type))
7042 error_msg = "array of void";
7046 error_msg = "array of functions";
7049 case REFERENCE_TYPE:
7050 error_msg = "array of references";
7054 error_msg = "array of function members";
7061 /* If something went wrong, issue an error-message and return. */
7065 error ("declaration of %qD as %s", name, error_msg);
7067 error ("creating %s", error_msg);
7069 return error_mark_node;
7074 The constant expressions that specify the bounds of the arrays
7075 can be omitted only for the first member of the sequence. */
7076 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
7079 error ("declaration of %qD as multidimensional array must "
7080 "have bounds for all dimensions except the first",
7083 error ("multidimensional array must have bounds for all "
7084 "dimensions except the first");
7086 return error_mark_node;
7089 /* Figure out the index type for the array. */
7091 itype = compute_array_index_type (name, size);
7094 T is called the array element type; this type shall not be [...] an
7095 abstract class type. */
7096 abstract_virtuals_error (name, type);
7098 return build_cplus_array_type (type, itype);
7101 /* Check that it's OK to declare a function with the indicated TYPE.
7102 SFK indicates the kind of special function (if any) that this
7103 function is. OPTYPE is the type given in a conversion operator
7104 declaration, or the class type for a constructor/destructor.
7105 Returns the actual return type of the function; that
7106 may be different than TYPE if an error occurs, or for certain
7107 special functions. */
7110 check_special_function_return_type (special_function_kind sfk,
7116 case sfk_constructor:
7118 error ("return type specification for constructor invalid");
7120 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
7121 type = build_pointer_type (optype);
7123 type = void_type_node;
7126 case sfk_destructor:
7128 error ("return type specification for destructor invalid");
7129 /* We can't use the proper return type here because we run into
7130 problems with ambiguous bases and covariant returns.
7131 Java classes are left unchanged because (void *) isn't a valid
7132 Java type, and we don't want to change the Java ABI. */
7133 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
7134 type = build_pointer_type (void_type_node);
7136 type = void_type_node;
7139 case sfk_conversion:
7141 error ("return type specified for %<operator %T%>", optype);
7152 /* A variable or data member (whose unqualified name is IDENTIFIER)
7153 has been declared with the indicated TYPE. If the TYPE is not
7154 acceptable, issue an error message and return a type to use for
7155 error-recovery purposes. */
7158 check_var_type (tree identifier, tree type)
7160 if (VOID_TYPE_P (type))
7163 error ("unnamed variable or field declared void");
7164 else if (TREE_CODE (identifier) == IDENTIFIER_NODE)
7166 gcc_assert (!IDENTIFIER_OPNAME_P (identifier));
7167 error ("variable or field %qE declared void", identifier);
7170 error ("variable or field declared void");
7171 type = error_mark_node;
7177 /* Given declspecs and a declarator (abstract or otherwise), determine
7178 the name and type of the object declared and construct a DECL node
7181 DECLSPECS points to the representation of declaration-specifier
7182 sequence that precedes declarator.
7184 DECL_CONTEXT says which syntactic context this declaration is in:
7185 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
7186 FUNCDEF for a function definition. Like NORMAL but a few different
7187 error messages in each case. Return value may be zero meaning
7188 this definition is too screwy to try to parse.
7189 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
7190 handle member functions (which have FIELD context).
7191 Return value may be zero meaning this definition is too screwy to
7193 PARM for a parameter declaration (either within a function prototype
7194 or before a function body). Make a PARM_DECL, or return void_type_node.
7195 CATCHPARM for a parameter declaration before a catch clause.
7196 TYPENAME if for a typename (in a cast or sizeof).
7197 Don't make a DECL node; just return the ..._TYPE node.
7198 FIELD for a struct or union field; make a FIELD_DECL.
7199 BITFIELD for a field with specified width.
7200 INITIALIZED is 1 if the decl has an initializer.
7202 ATTRLIST is a pointer to the list of attributes, which may be NULL
7203 if there are none; *ATTRLIST may be modified if attributes from inside
7204 the declarator should be applied to the declaration.
7206 When this function is called, scoping variables (such as
7207 CURRENT_CLASS_TYPE) should reflect the scope in which the
7208 declaration occurs, not the scope in which the new declaration will
7209 be placed. For example, on:
7213 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
7216 Returns a DECL (if a declarator is present), a TYPE (if there is no
7217 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
7221 grokdeclarator (const cp_declarator *declarator,
7222 const cp_decl_specifier_seq *declspecs,
7223 enum decl_context decl_context,
7227 tree type = NULL_TREE;
7229 int virtualp, explicitp, friendp, inlinep, staticp;
7230 int explicit_int = 0;
7231 int explicit_char = 0;
7232 int defaulted_int = 0;
7233 tree dependent_name = NULL_TREE;
7235 tree typedef_decl = NULL_TREE;
7236 const char *name = NULL;
7237 tree typedef_type = NULL_TREE;
7238 /* True if this declarator is a function definition. */
7239 bool funcdef_flag = false;
7240 cp_declarator_kind innermost_code = cdk_error;
7243 /* See the code below that used this. */
7244 tree decl_attr = NULL_TREE;
7247 /* Keep track of what sort of function is being processed
7248 so that we can warn about default return values, or explicit
7249 return values which do not match prescribed defaults. */
7250 special_function_kind sfk = sfk_none;
7252 tree dname = NULL_TREE;
7253 tree ctor_return_type = NULL_TREE;
7254 enum overload_flags flags = NO_SPECIAL;
7255 /* cv-qualifiers that apply to the declarator, for a declaration of
7256 a member function. */
7257 cp_cv_quals memfn_quals = TYPE_UNQUALIFIED;
7258 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
7260 tree raises = NULL_TREE;
7261 int template_count = 0;
7262 tree returned_attrs = NULL_TREE;
7263 tree parms = NULL_TREE;
7264 const cp_declarator *id_declarator;
7265 /* The unqualified name of the declarator; either an
7266 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
7267 tree unqualified_id;
7268 /* The class type, if any, in which this entity is located,
7269 or NULL_TREE if none. Note that this value may be different from
7270 the current class type; for example if an attempt is made to declare
7271 "A::f" inside "B", this value will be "A". */
7272 tree ctype = current_class_type;
7273 /* The NAMESPACE_DECL for the namespace in which this entity is
7274 located. If an unqualified name is used to declare the entity,
7275 this value will be NULL_TREE, even if the entity is located at
7277 tree in_namespace = NULL_TREE;
7278 cp_storage_class storage_class;
7279 bool unsigned_p, signed_p, short_p, long_p, thread_p;
7280 bool type_was_error_mark_node = false;
7281 bool parameter_pack_p = declarator? declarator->parameter_pack_p : false;
7282 bool set_no_warning = false;
7284 signed_p = declspecs->specs[(int)ds_signed];
7285 unsigned_p = declspecs->specs[(int)ds_unsigned];
7286 short_p = declspecs->specs[(int)ds_short];
7287 long_p = declspecs->specs[(int)ds_long];
7288 longlong = declspecs->specs[(int)ds_long] >= 2;
7289 thread_p = declspecs->specs[(int)ds_thread];
7291 if (decl_context == FUNCDEF)
7292 funcdef_flag = true, decl_context = NORMAL;
7293 else if (decl_context == MEMFUNCDEF)
7294 funcdef_flag = true, decl_context = FIELD;
7295 else if (decl_context == BITFIELD)
7296 bitfield = 1, decl_context = FIELD;
7298 /* Look inside a declarator for the name being declared
7299 and get it as a string, for an error message. */
7300 for (id_declarator = declarator;
7302 id_declarator = id_declarator->declarator)
7304 if (id_declarator->kind != cdk_id)
7305 innermost_code = id_declarator->kind;
7307 switch (id_declarator->kind)
7310 if (id_declarator->declarator
7311 && id_declarator->declarator->kind == cdk_id)
7313 sfk = id_declarator->declarator->u.id.sfk;
7314 if (sfk == sfk_destructor)
7321 tree qualifying_scope = id_declarator->u.id.qualifying_scope;
7322 tree decl = id_declarator->u.id.unqualified_name;
7325 if (qualifying_scope)
7327 if (at_function_scope_p ())
7331 A declarator-id shall not be qualified except
7334 None of the cases are permitted in block
7336 if (qualifying_scope == global_namespace)
7337 error ("invalid use of qualified-name %<::%D%>",
7339 else if (TYPE_P (qualifying_scope))
7340 error ("invalid use of qualified-name %<%T::%D%>",
7341 qualifying_scope, decl);
7343 error ("invalid use of qualified-name %<%D::%D%>",
7344 qualifying_scope, decl);
7345 return error_mark_node;
7347 else if (TYPE_P (qualifying_scope))
7349 ctype = qualifying_scope;
7350 if (innermost_code != cdk_function
7351 && current_class_type
7352 && !UNIQUELY_DERIVED_FROM_P (ctype,
7353 current_class_type))
7355 error ("type %qT is not derived from type %qT",
7356 ctype, current_class_type);
7357 return error_mark_node;
7360 else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL)
7361 in_namespace = qualifying_scope;
7363 switch (TREE_CODE (decl))
7369 if (innermost_code != cdk_function)
7371 error ("declaration of %qD as non-function", decl);
7372 return error_mark_node;
7374 else if (!qualifying_scope
7375 && !(current_class_type && at_class_scope_p ()))
7377 error ("declaration of %qD as non-member", decl);
7378 return error_mark_node;
7381 type = TREE_OPERAND (decl, 0);
7382 name = IDENTIFIER_POINTER (constructor_name (type));
7387 case TEMPLATE_ID_EXPR:
7389 tree fns = TREE_OPERAND (decl, 0);
7392 if (TREE_CODE (dname) != IDENTIFIER_NODE)
7394 gcc_assert (is_overloaded_fn (dname));
7395 dname = DECL_NAME (get_first_fn (dname));
7400 case IDENTIFIER_NODE:
7401 if (TREE_CODE (decl) == IDENTIFIER_NODE)
7404 if (C_IS_RESERVED_WORD (dname))
7406 error ("declarator-id missing; using reserved word %qD",
7408 name = IDENTIFIER_POINTER (dname);
7410 else if (!IDENTIFIER_TYPENAME_P (dname))
7411 name = IDENTIFIER_POINTER (dname);
7414 gcc_assert (flags == NO_SPECIAL);
7415 flags = TYPENAME_FLAG;
7416 ctor_return_type = TREE_TYPE (dname);
7417 sfk = sfk_conversion;
7418 if (is_typename_at_global_scope (dname))
7419 name = IDENTIFIER_POINTER (dname);
7421 name = "<invalid operator>";
7438 return error_mark_node;
7443 if (id_declarator->kind == cdk_id)
7449 The declarator in a function-definition shall have the form
7450 D1 ( parameter-declaration-clause) ... */
7451 if (funcdef_flag && innermost_code != cdk_function)
7453 error ("function definition does not declare parameters");
7454 return error_mark_node;
7457 if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
7458 && innermost_code != cdk_function
7459 && ! (ctype && !declspecs->any_specifiers_p))
7461 error ("declaration of %qD as non-function", dname);
7462 return error_mark_node;
7465 /* Anything declared one level down from the top level
7466 must be one of the parameters of a function
7467 (because the body is at least two levels down). */
7469 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
7470 by not allowing C++ class definitions to specify their parameters
7471 with xdecls (must be spec.d in the parmlist).
7473 Since we now wait to push a class scope until we are sure that
7474 we are in a legitimate method context, we must set oldcname
7475 explicitly (since current_class_name is not yet alive).
7477 We also want to avoid calling this a PARM if it is in a namespace. */
7479 if (decl_context == NORMAL && !toplevel_bindings_p ())
7481 struct cp_binding_level *b = current_binding_level;
7482 current_binding_level = b->level_chain;
7483 if (current_binding_level != 0 && toplevel_bindings_p ())
7484 decl_context = PARM;
7485 current_binding_level = b;
7489 name = decl_context == PARM ? "parameter" : "type name";
7491 /* If there were multiple types specified in the decl-specifier-seq,
7492 issue an error message. */
7493 if (declspecs->multiple_types_p)
7495 error ("two or more data types in declaration of %qs", name);
7496 return error_mark_node;
7499 /* Extract the basic type from the decl-specifier-seq. */
7500 type = declspecs->type;
7501 if (type == error_mark_node)
7504 type_was_error_mark_node = true;
7506 /* If the entire declaration is itself tagged as deprecated then
7507 suppress reports of deprecated items. */
7508 if (type && TREE_DEPRECATED (type)
7509 && deprecated_state != DEPRECATED_SUPPRESS)
7510 warn_deprecated_use (type);
7511 if (type && TREE_CODE (type) == TYPE_DECL)
7513 typedef_decl = type;
7514 type = TREE_TYPE (typedef_decl);
7516 /* No type at all: default to `int', and set DEFAULTED_INT
7517 because it was not a user-defined typedef. */
7518 if (type == NULL_TREE && (signed_p || unsigned_p || long_p || short_p))
7520 /* These imply 'int'. */
7521 type = integer_type_node;
7525 explicit_int = declspecs->explicit_int_p;
7526 explicit_char = declspecs->explicit_char_p;
7529 /* See the code below that used this. */
7531 decl_attr = DECL_ATTRIBUTES (typedef_decl);
7533 typedef_type = type;
7536 if (sfk != sfk_conversion)
7537 ctor_return_type = ctype;
7539 if (sfk != sfk_none)
7540 type = check_special_function_return_type (sfk, type,
7542 else if (type == NULL_TREE)
7548 /* We handle `main' specially here, because 'main () { }' is so
7549 common. With no options, it is allowed. With -Wreturn-type,
7550 it is a warning. It is only an error with -pedantic-errors. */
7551 is_main = (funcdef_flag
7552 && dname && MAIN_NAME_P (dname)
7553 && ctype == NULL_TREE
7554 && in_namespace == NULL_TREE
7555 && current_namespace == global_namespace);
7557 if (type_was_error_mark_node)
7558 /* We've already issued an error, don't complain more. */;
7559 else if (in_system_header || flag_ms_extensions)
7560 /* Allow it, sigh. */;
7561 else if (pedantic || ! is_main)
7562 pedwarn ("ISO C++ forbids declaration of %qs with no type", name);
7564 warning (OPT_Wreturn_type,
7565 "ISO C++ forbids declaration of %qs with no type", name);
7567 type = integer_type_node;
7572 /* Now process the modifiers that were specified
7573 and check for invalid combinations. */
7575 /* Long double is a special combination. */
7576 if (long_p && !longlong && TYPE_MAIN_VARIANT (type) == double_type_node)
7579 type = build_qualified_type (long_double_type_node,
7580 cp_type_quals (type));
7583 /* Check all other uses of type modifiers. */
7585 if (unsigned_p || signed_p || long_p || short_p)
7589 if ((signed_p || unsigned_p) && TREE_CODE (type) != INTEGER_TYPE)
7590 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
7591 else if (signed_p && unsigned_p)
7592 error ("%<signed%> and %<unsigned%> specified together for %qs", name);
7593 else if (longlong && TREE_CODE (type) != INTEGER_TYPE)
7594 error ("%<long long%> invalid for %qs", name);
7595 else if (long_p && TREE_CODE (type) == REAL_TYPE)
7596 error ("%<long%> invalid for %qs", name);
7597 else if (short_p && TREE_CODE (type) == REAL_TYPE)
7598 error ("%<short%> invalid for %qs", name);
7599 else if ((long_p || short_p) && TREE_CODE (type) != INTEGER_TYPE)
7600 error ("%<long%> or %<short%> invalid for %qs", name);
7601 else if ((long_p || short_p) && explicit_char)
7602 error ("%<long%> or %<short%> specified with char for %qs", name);
7603 else if (long_p && short_p)
7604 error ("%<long%> and %<short%> specified together for %qs", name);
7608 if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
7610 pedwarn ("long, short, signed or unsigned used invalidly for %qs",
7612 if (flag_pedantic_errors)
7617 /* Discard the type modifiers if they are invalid. */
7628 /* Decide whether an integer type is signed or not.
7629 Optionally treat bitfields as signed by default. */
7633 It is implementation-defined whether a plain (neither
7634 explicitly signed or unsigned) char, short, int, or long
7635 bit-field is signed or unsigned.
7637 Naturally, we extend this to long long as well. Note that
7638 this does not include wchar_t. */
7639 || (bitfield && !flag_signed_bitfields
7641 /* A typedef for plain `int' without `signed' can be
7642 controlled just like plain `int', but a typedef for
7643 `signed int' cannot be so controlled. */
7645 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
7646 && TREE_CODE (type) == INTEGER_TYPE
7647 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
7650 type = long_long_unsigned_type_node;
7652 type = long_unsigned_type_node;
7654 type = short_unsigned_type_node;
7655 else if (type == char_type_node)
7656 type = unsigned_char_type_node;
7657 else if (typedef_decl)
7658 type = unsigned_type_for (type);
7660 type = unsigned_type_node;
7662 else if (signed_p && type == char_type_node)
7663 type = signed_char_type_node;
7665 type = long_long_integer_type_node;
7667 type = long_integer_type_node;
7669 type = short_integer_type_node;
7671 if (declspecs->specs[(int)ds_complex])
7673 if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
7674 error ("complex invalid for %qs", name);
7675 /* If we just have "complex", it is equivalent to
7676 "complex double", but if any modifiers at all are specified it is
7677 the complex form of TYPE. E.g, "complex short" is
7678 "complex short int". */
7680 else if (defaulted_int && ! longlong
7681 && ! (long_p || short_p || signed_p || unsigned_p))
7682 type = complex_double_type_node;
7683 else if (type == integer_type_node)
7684 type = complex_integer_type_node;
7685 else if (type == float_type_node)
7686 type = complex_float_type_node;
7687 else if (type == double_type_node)
7688 type = complex_double_type_node;
7689 else if (type == long_double_type_node)
7690 type = complex_long_double_type_node;
7692 type = build_complex_type (type);
7695 type_quals = TYPE_UNQUALIFIED;
7696 if (declspecs->specs[(int)ds_const])
7697 type_quals |= TYPE_QUAL_CONST;
7698 if (declspecs->specs[(int)ds_volatile])
7699 type_quals |= TYPE_QUAL_VOLATILE;
7700 if (declspecs->specs[(int)ds_restrict])
7701 type_quals |= TYPE_QUAL_RESTRICT;
7702 if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
7703 error ("qualifiers are not allowed on declaration of %<operator %T%>",
7706 if (TREE_CODE (type) == FUNCTION_TYPE
7707 && type_quals != TYPE_UNQUALIFIED)
7709 /* This was an error in C++98 (cv-qualifiers cannot be added to
7710 a function type), but DR 295 makes the code well-formed by
7711 dropping the extra qualifiers. */
7714 tree bad_type = build_qualified_type (type, type_quals);
7715 pedwarn ("ignoring %qV qualifiers added to function type %qT",
7718 type_quals = TYPE_UNQUALIFIED;
7720 type_quals |= cp_type_quals (type);
7721 type = cp_build_qualified_type_real
7722 (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
7723 ? tf_ignore_bad_quals : 0) | tf_warning_or_error));
7724 /* We might have ignored or rejected some of the qualifiers. */
7725 type_quals = cp_type_quals (type);
7728 inlinep = !! declspecs->specs[(int)ds_inline];
7729 virtualp = !! declspecs->specs[(int)ds_virtual];
7730 explicitp = !! declspecs->specs[(int)ds_explicit];
7732 storage_class = declspecs->storage_class;
7733 if (storage_class == sc_static)
7734 staticp = 1 + (decl_context == FIELD);
7736 if (virtualp && staticp == 2)
7738 error ("member %qD cannot be declared both virtual and static", dname);
7739 storage_class = sc_none;
7742 friendp = !! declspecs->specs[(int)ds_friend];
7744 if (dependent_name && !friendp)
7746 error ("%<%T::%D%> is not a valid declarator", ctype, dependent_name);
7747 return error_mark_node;
7750 /* Issue errors about use of storage classes for parameters. */
7751 if (decl_context == PARM)
7753 if (declspecs->specs[(int)ds_typedef])
7755 error ("typedef declaration invalid in parameter declaration");
7756 return error_mark_node;
7758 else if (storage_class == sc_static
7759 || storage_class == sc_extern
7761 error ("storage class specifiers invalid in parameter declarations");
7764 /* Give error if `virtual' is used outside of class declaration. */
7766 && (current_class_name == NULL_TREE || decl_context != FIELD))
7768 error ("virtual outside class declaration");
7772 /* Static anonymous unions are dealt with here. */
7773 if (staticp && decl_context == TYPENAME
7775 && ANON_AGGR_TYPE_P (declspecs->type))
7776 decl_context = FIELD;
7778 /* Warn about storage classes that are invalid for certain
7779 kinds of declarations (parameters, typenames, etc.). */
7782 && storage_class != sc_extern
7783 && storage_class != sc_static)
7784 || declspecs->specs[(int)ds_typedef]))
7786 error ("multiple storage classes in declaration of %qs", name);
7789 if (declspecs->conflicting_specifiers_p)
7791 error ("conflicting specifiers in declaration of %qs", name);
7792 storage_class = sc_none;
7794 else if (decl_context != NORMAL
7795 && ((storage_class != sc_none
7796 && storage_class != sc_mutable)
7799 if ((decl_context == PARM || decl_context == CATCHPARM)
7800 && (storage_class == sc_register
7801 || storage_class == sc_auto))
7803 else if (declspecs->specs[(int)ds_typedef])
7805 else if (decl_context == FIELD
7806 /* C++ allows static class elements. */
7807 && storage_class == sc_static)
7808 /* C++ also allows inlines and signed and unsigned elements,
7809 but in those cases we don't come in here. */
7813 if (decl_context == FIELD)
7814 error ("storage class specified for %qs", name);
7817 if (decl_context == PARM || decl_context == CATCHPARM)
7818 error ("storage class specified for parameter %qs", name);
7820 error ("storage class specified for typename");
7822 if (storage_class == sc_register
7823 || storage_class == sc_auto
7824 || storage_class == sc_extern
7826 storage_class = sc_none;
7829 else if (storage_class == sc_extern && initialized
7832 if (toplevel_bindings_p ())
7834 /* It's common practice (and completely valid) to have a const
7835 be initialized and declared extern. */
7836 if (!(type_quals & TYPE_QUAL_CONST))
7837 warning (0, "%qs initialized and declared %<extern%>", name);
7840 error ("%qs has both %<extern%> and initializer", name);
7842 else if (storage_class == sc_extern && funcdef_flag
7843 && ! toplevel_bindings_p ())
7844 error ("nested function %qs declared %<extern%>", name);
7845 else if (toplevel_bindings_p ())
7847 if (storage_class == sc_auto)
7848 error ("top-level declaration of %qs specifies %<auto%>", name);
7851 && storage_class != sc_extern
7852 && storage_class != sc_static)
7854 error ("function-scope %qs implicitly auto and declared %<__thread%>",
7859 if (storage_class && friendp)
7860 error ("storage class specifiers invalid in friend function declarations");
7863 unqualified_id = NULL_TREE;
7866 unqualified_id = id_declarator->u.id.unqualified_name;
7867 switch (TREE_CODE (unqualified_id))
7871 = constructor_name (TREE_OPERAND (unqualified_id, 0));
7874 case IDENTIFIER_NODE:
7875 case TEMPLATE_ID_EXPR:
7883 /* Determine the type of the entity declared by recurring on the
7885 for (; declarator; declarator = declarator->declarator)
7887 const cp_declarator *inner_declarator;
7890 if (type == error_mark_node)
7891 return error_mark_node;
7893 attrs = declarator->attributes;
7899 if (declarator == NULL || declarator->kind == cdk_id)
7900 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
7901 if (declarator->kind == cdk_function)
7902 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
7903 if (declarator->kind == cdk_array)
7904 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
7905 returned_attrs = decl_attributes (&type,
7906 chainon (returned_attrs, attrs),
7910 if (declarator->kind == cdk_id)
7913 inner_declarator = declarator->declarator;
7915 switch (declarator->kind)
7918 type = create_array_type_for_decl (dname, type,
7919 declarator->u.array.bounds);
7927 /* Declaring a function type.
7928 Make sure we have a valid type for the function to return. */
7930 if (type_quals != TYPE_UNQUALIFIED)
7932 if (SCALAR_TYPE_P (type) || VOID_TYPE_P (type))
7933 warning (OPT_Wreturn_type,
7934 "type qualifiers ignored on function return type");
7935 /* We now know that the TYPE_QUALS don't apply to the
7936 decl, but to its return type. */
7937 type_quals = TYPE_UNQUALIFIED;
7938 set_no_warning = true;
7941 /* Warn about some types functions can't return. */
7943 if (TREE_CODE (type) == FUNCTION_TYPE)
7945 error ("%qs declared as function returning a function", name);
7946 type = integer_type_node;
7948 if (TREE_CODE (type) == ARRAY_TYPE)
7950 error ("%qs declared as function returning an array", name);
7951 type = integer_type_node;
7954 /* Pick up type qualifiers which should be applied to `this'. */
7955 memfn_quals = declarator->u.function.qualifiers;
7957 /* Pick up the exception specifications. */
7958 raises = declarator->u.function.exception_specification;
7960 /* Say it's a definition only for the CALL_EXPR
7961 closest to the identifier. */
7962 funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id;
7964 if (ctype == NULL_TREE
7965 && decl_context == FIELD
7967 && (friendp == 0 || dname == current_class_name))
7968 ctype = current_class_type;
7970 if (ctype && (sfk == sfk_constructor
7971 || sfk == sfk_destructor))
7973 /* We are within a class's scope. If our declarator name
7974 is the same as the class name, and we are defining
7975 a function, then it is a constructor/destructor, and
7976 therefore returns a void type. */
7978 /* ISO C++ 12.4/2. A destructor may not be declared
7979 const or volatile. A destructor may not be
7982 ISO C++ 12.1. A constructor may not be declared
7983 const or volatile. A constructor may not be
7984 virtual. A constructor may not be static. */
7986 error ((flags == DTOR_FLAG)
7987 ? "destructor cannot be static member function"
7988 : "constructor cannot be static member function");
7991 error ((flags == DTOR_FLAG)
7992 ? "destructors may not be cv-qualified"
7993 : "constructors may not be cv-qualified");
7994 memfn_quals = TYPE_UNQUALIFIED;
7997 if (decl_context == FIELD
7998 && !member_function_or_else (ctype,
8001 return error_mark_node;
8003 if (flags != DTOR_FLAG)
8005 /* It's a constructor. */
8010 pedwarn ("constructors cannot be declared virtual");
8013 if (decl_context == FIELD
8014 && sfk != sfk_constructor)
8015 return error_mark_node;
8017 if (decl_context == FIELD)
8023 error ("can't initialize friend function %qs", name);
8026 /* Cannot be both friend and virtual. */
8027 error ("virtual functions cannot be friends");
8030 if (decl_context == NORMAL)
8031 error ("friend declaration not in class definition");
8032 if (current_function_decl && funcdef_flag)
8033 error ("can't define friend function %qs in a local "
8038 arg_types = grokparms (declarator->u.function.parameters,
8041 if (inner_declarator
8042 && inner_declarator->kind == cdk_id
8043 && inner_declarator->u.id.sfk == sfk_destructor
8044 && arg_types != void_list_node)
8046 error ("destructors may not have parameters");
8047 arg_types = void_list_node;
8051 type = build_function_type (type, arg_types);
8058 /* Filter out pointers-to-references and references-to-references.
8059 We can get these if a TYPE_DECL is used. */
8061 if (TREE_CODE (type) == REFERENCE_TYPE)
8063 if (declarator->kind != cdk_reference)
8065 error ("cannot declare pointer to %q#T", type);
8066 type = TREE_TYPE (type);
8069 /* In C++0x, we allow reference to reference declarations
8070 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
8071 and template type arguments [14.3.1/4 temp.arg.type]. The
8072 check for direct reference to reference declarations, which
8073 are still forbidden, occurs below. Reasoning behind the change
8074 can be found in DR106, DR540, and the rvalue reference
8076 else if (cxx_dialect == cxx98)
8078 error ("cannot declare reference to %q#T", type);
8079 type = TREE_TYPE (type);
8082 else if (VOID_TYPE_P (type))
8084 if (declarator->kind == cdk_reference)
8085 error ("cannot declare reference to %q#T", type);
8086 else if (declarator->kind == cdk_ptrmem)
8087 error ("cannot declare pointer to %q#T member", type);
8090 /* We now know that the TYPE_QUALS don't apply to the decl,
8091 but to the target of the pointer. */
8092 type_quals = TYPE_UNQUALIFIED;
8094 if (declarator->kind == cdk_ptrmem
8095 && (TREE_CODE (type) == FUNCTION_TYPE || memfn_quals))
8097 memfn_quals |= cp_type_quals (type);
8098 type = build_memfn_type (type,
8099 declarator->u.pointer.class_type,
8101 memfn_quals = TYPE_UNQUALIFIED;
8104 if (declarator->kind == cdk_reference)
8106 /* In C++0x, the type we are creating a reference to might be
8107 a typedef which is itself a reference type. In that case,
8108 we follow the reference collapsing rules in
8109 [7.1.3/8 dcl.typedef] to create the final reference type:
8111 "If a typedef TD names a type that is a reference to a type
8112 T, an attempt to create the type 'lvalue reference to cv TD'
8113 creates the type 'lvalue reference to T,' while an attempt
8114 to create the type "rvalue reference to cv TD' creates the
8117 if (!VOID_TYPE_P (type))
8118 type = cp_build_reference_type
8119 ((TREE_CODE (type) == REFERENCE_TYPE
8120 ? TREE_TYPE (type) : type),
8121 (declarator->u.reference.rvalue_ref
8122 && (TREE_CODE(type) != REFERENCE_TYPE
8123 || TYPE_REF_IS_RVALUE (type))));
8125 /* In C++0x, we need this check for direct reference to
8126 reference declarations, which are forbidden by
8127 [8.3.2/5 dcl.ref]. Reference to reference declarations
8128 are only allowed indirectly through typedefs and template
8129 type arguments. Example:
8131 void foo(int & &); // invalid ref-to-ref decl
8133 typedef int & int_ref;
8134 void foo(int_ref &); // valid ref-to-ref decl
8136 if (inner_declarator && inner_declarator->kind == cdk_reference)
8137 error ("cannot declare reference to %q#T, which is not "
8138 "a typedef or a template type argument", type);
8140 else if (TREE_CODE (type) == METHOD_TYPE)
8141 type = build_ptrmemfunc_type (build_pointer_type (type));
8142 else if (declarator->kind == cdk_ptrmem)
8144 gcc_assert (TREE_CODE (declarator->u.pointer.class_type)
8146 if (declarator->u.pointer.class_type == error_mark_node)
8147 /* We will already have complained. */
8148 type = error_mark_node;
8150 type = build_ptrmem_type (declarator->u.pointer.class_type,
8154 type = build_pointer_type (type);
8156 /* Process a list of type modifier keywords (such as
8157 const or volatile) that were given inside the `*' or `&'. */
8159 if (declarator->u.pointer.qualifiers)
8162 = cp_build_qualified_type (type,
8163 declarator->u.pointer.qualifiers);
8164 type_quals = cp_type_quals (type);
8177 if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR
8178 && TREE_CODE (type) != FUNCTION_TYPE
8179 && TREE_CODE (type) != METHOD_TYPE)
8181 error ("template-id %qD used as a declarator",
8183 unqualified_id = dname;
8186 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
8187 qualified with a class-name, turn it into a METHOD_TYPE, unless
8188 we know that the function is static. We take advantage of this
8189 opportunity to do other processing that pertains to entities
8190 explicitly declared to be class members. Note that if DECLARATOR
8191 is non-NULL, we know it is a cdk_id declarator; otherwise, we
8192 would not have exited the loop above. */
8194 && declarator->u.id.qualifying_scope
8195 && TYPE_P (declarator->u.id.qualifying_scope))
8199 ctype = declarator->u.id.qualifying_scope;
8200 ctype = TYPE_MAIN_VARIANT (ctype);
8202 while (t != NULL_TREE && CLASS_TYPE_P (t))
8204 /* You're supposed to have one `template <...>' for every
8205 template class, but you don't need one for a full
8206 specialization. For example:
8208 template <class T> struct S{};
8209 template <> struct S<int> { void f(); };
8210 void S<int>::f () {}
8212 is correct; there shouldn't be a `template <>' for the
8213 definition of `S<int>::f'. */
8214 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t)
8215 && !any_dependent_template_arguments_p (CLASSTYPE_TI_ARGS (t)))
8216 /* T is an explicit (not partial) specialization. All
8217 containing classes must therefore also be explicitly
8220 if ((CLASSTYPE_USE_TEMPLATE (t) || CLASSTYPE_IS_TEMPLATE (t))
8221 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
8222 template_count += 1;
8224 t = TYPE_MAIN_DECL (t);
8225 t = DECL_CONTEXT (t);
8228 if (ctype == current_class_type)
8232 pedwarn ("member functions are implicitly friends of their class");
8236 pedwarn ("extra qualification %<%T::%> on member %qs",
8239 else if (/* If the qualifying type is already complete, then we
8240 can skip the following checks. */
8241 !COMPLETE_TYPE_P (ctype)
8242 && (/* If the function is being defined, then
8243 qualifying type must certainly be complete. */
8245 /* A friend declaration of "T::f" is OK, even if
8246 "T" is a template parameter. But, if this
8247 function is not a friend, the qualifying type
8249 || (!friendp && !CLASS_TYPE_P (ctype))
8250 /* For a declaration, the type need not be
8251 complete, if either it is dependent (since there
8252 is no meaningful definition of complete in that
8253 case) or the qualifying class is currently being
8255 || !(dependent_type_p (ctype)
8256 || currently_open_class (ctype)))
8257 /* Check that the qualifying type is complete. */
8258 && !complete_type_or_else (ctype, NULL_TREE))
8259 return error_mark_node;
8260 else if (TREE_CODE (type) == FUNCTION_TYPE)
8262 tree sname = declarator->u.id.unqualified_name;
8264 if (current_class_type
8265 && (!friendp || funcdef_flag))
8268 ? "cannot define member function %<%T::%s%> within %<%T%>"
8269 : "cannot declare member function %<%T::%s%> within %<%T%>",
8270 ctype, name, current_class_type);
8271 return error_mark_node;
8274 if (TREE_CODE (sname) == IDENTIFIER_NODE
8275 && NEW_DELETE_OPNAME_P (sname))
8276 /* Overloaded operator new and operator delete
8277 are always static functions. */
8280 type = build_memfn_type (type, ctype, memfn_quals);
8282 else if (declspecs->specs[(int)ds_typedef]
8283 && current_class_type)
8285 error ("cannot declare member %<%T::%s%> within %qT",
8286 ctype, name, current_class_type);
8287 return error_mark_node;
8291 /* Now TYPE has the actual type. */
8296 *attrlist = chainon (returned_attrs, *attrlist);
8298 attrlist = &returned_attrs;
8301 /* Handle parameter packs. */
8302 if (parameter_pack_p)
8304 if (decl_context == PARM)
8305 /* Turn the type into a pack expansion.*/
8306 type = make_pack_expansion (type);
8308 error ("non-parameter %qs cannot be a parameter pack", name);
8311 /* Did array size calculations overflow? */
8313 if (TREE_CODE (type) == ARRAY_TYPE
8314 && COMPLETE_TYPE_P (type)
8315 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
8316 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
8318 error ("size of array %qs is too large", name);
8319 /* If we proceed with the array type as it is, we'll eventually
8320 crash in tree_low_cst(). */
8321 type = error_mark_node;
8324 if ((decl_context == FIELD || decl_context == PARM)
8325 && !processing_template_decl
8326 && variably_modified_type_p (type, NULL_TREE))
8328 if (decl_context == FIELD)
8329 error ("data member may not have variably modified type %qT", type);
8331 error ("parameter may not have variably modified type %qT", type);
8332 type = error_mark_node;
8335 if (explicitp == 1 || (explicitp && friendp))
8337 /* [dcl.fct.spec] The explicit specifier shall only be used in
8338 declarations of constructors within a class definition. */
8339 error ("only declarations of constructors can be %<explicit%>");
8343 if (storage_class == sc_mutable)
8345 if (decl_context != FIELD || friendp)
8347 error ("non-member %qs cannot be declared %<mutable%>", name);
8348 storage_class = sc_none;
8350 else if (decl_context == TYPENAME || declspecs->specs[(int)ds_typedef])
8352 error ("non-object member %qs cannot be declared %<mutable%>", name);
8353 storage_class = sc_none;
8355 else if (TREE_CODE (type) == FUNCTION_TYPE
8356 || TREE_CODE (type) == METHOD_TYPE)
8358 error ("function %qs cannot be declared %<mutable%>", name);
8359 storage_class = sc_none;
8363 error ("static %qs cannot be declared %<mutable%>", name);
8364 storage_class = sc_none;
8366 else if (type_quals & TYPE_QUAL_CONST)
8368 error ("const %qs cannot be declared %<mutable%>", name);
8369 storage_class = sc_none;
8373 /* If this is declaring a typedef name, return a TYPE_DECL. */
8374 if (declspecs->specs[(int)ds_typedef] && decl_context != TYPENAME)
8378 /* Note that the grammar rejects storage classes
8379 in typenames, fields or parameters. */
8380 if (current_lang_name == lang_name_java)
8381 TYPE_FOR_JAVA (type) = 1;
8383 /* This declaration:
8385 typedef void f(int) const;
8387 declares a function type which is not a member of any
8388 particular class, but which is cv-qualified; for
8389 example "f S::*" declares a pointer to a const-qualified
8390 member function of S. We record the cv-qualification in the
8392 if (memfn_quals && TREE_CODE (type) == FUNCTION_TYPE)
8394 type = cp_build_qualified_type (type, memfn_quals);
8396 /* We have now dealt with these qualifiers. */
8397 memfn_quals = TYPE_UNQUALIFIED;
8400 if (decl_context == FIELD)
8401 decl = build_lang_decl (TYPE_DECL, unqualified_id, type);
8403 decl = build_decl (TYPE_DECL, unqualified_id, type);
8404 if (id_declarator && declarator->u.id.qualifying_scope)
8405 error ("%Jtypedef name may not be a nested-name-specifier", decl);
8407 if (decl_context != FIELD)
8409 if (!current_function_decl)
8410 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8411 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl)
8412 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
8413 (current_function_decl)))
8414 /* The TYPE_DECL is "abstract" because there will be
8415 clones of this constructor/destructor, and there will
8416 be copies of this TYPE_DECL generated in those
8418 DECL_ABSTRACT (decl) = 1;
8420 else if (constructor_name_p (unqualified_id, current_class_type))
8421 pedwarn ("ISO C++ forbids nested type %qD with same name "
8422 "as enclosing class",
8425 /* If the user declares "typedef struct {...} foo" then the
8426 struct will have an anonymous name. Fill that name in now.
8427 Nothing can refer to it, so nothing needs know about the name
8429 if (type != error_mark_node
8432 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
8433 && TYPE_ANONYMOUS_P (type)
8434 /* Don't do this if there are attributes. */
8435 && (!attrlist || !*attrlist)
8436 && cp_type_quals (type) == TYPE_UNQUALIFIED)
8438 tree oldname = TYPE_NAME (type);
8441 /* Replace the anonymous name with the real name everywhere. */
8442 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
8443 if (TYPE_NAME (t) == oldname)
8444 TYPE_NAME (t) = decl;
8446 if (TYPE_LANG_SPECIFIC (type))
8447 TYPE_WAS_ANONYMOUS (type) = 1;
8449 /* If this is a typedef within a template class, the nested
8450 type is a (non-primary) template. The name for the
8451 template needs updating as well. */
8452 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
8453 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
8454 = TYPE_IDENTIFIER (type);
8456 /* FIXME remangle member functions; member functions of a
8457 type with external linkage have external linkage. */
8461 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
8462 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
8464 bad_specifiers (decl, "type", virtualp,
8465 memfn_quals != TYPE_UNQUALIFIED,
8466 inlinep, friendp, raises != NULL_TREE);
8471 /* Detect the case of an array type of unspecified size
8472 which came, as such, direct from a typedef name.
8473 We must copy the type, so that the array's domain can be
8474 individually set by the object's initializer. */
8476 if (type && typedef_type
8477 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
8478 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
8479 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
8481 /* Detect where we're using a typedef of function type to declare a
8482 function. PARMS will not be set, so we must create it now. */
8484 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
8486 tree decls = NULL_TREE;
8489 for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
8491 tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
8493 TREE_CHAIN (decl) = decls;
8497 parms = nreverse (decls);
8499 if (decl_context != TYPENAME)
8501 /* A cv-qualifier-seq shall only be part of the function type
8502 for a non-static member function. [8.3.5/4 dcl.fct] */
8503 if (cp_type_quals (type) != TYPE_UNQUALIFIED
8504 && (current_class_type == NULL_TREE || staticp) )
8507 ? G_("qualified function types cannot be used to "
8508 "declare static member functions")
8509 : G_("qualified function types cannot be used to "
8510 "declare free functions"));
8511 type = TYPE_MAIN_VARIANT (type);
8514 /* The qualifiers on the function type become the qualifiers on
8515 the non-static member function. */
8516 memfn_quals |= cp_type_quals (type);
8520 /* If this is a type name (such as, in a cast or sizeof),
8521 compute the type and return it now. */
8523 if (decl_context == TYPENAME)
8525 /* Note that the grammar rejects storage classes
8526 in typenames, fields or parameters. */
8527 if (type_quals != TYPE_UNQUALIFIED)
8528 type_quals = TYPE_UNQUALIFIED;
8530 /* Special case: "friend class foo" looks like a TYPENAME context. */
8533 if (type_quals != TYPE_UNQUALIFIED)
8535 error ("type qualifiers specified for friend class declaration");
8536 type_quals = TYPE_UNQUALIFIED;
8540 error ("%<inline%> specified for friend class declaration");
8546 /* Don't allow friend declaration without a class-key. */
8547 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
8548 pedwarn ("template parameters cannot be friends");
8549 else if (TREE_CODE (type) == TYPENAME_TYPE)
8550 pedwarn ("friend declaration requires class-key, "
8551 "i.e. %<friend class %T::%D%>",
8552 TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
8554 pedwarn ("friend declaration requires class-key, "
8555 "i.e. %<friend %#T%>",
8559 /* Only try to do this stuff if we didn't already give up. */
8560 if (type != integer_type_node)
8562 /* A friendly class? */
8563 if (current_class_type)
8564 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
8567 error ("trying to make class %qT a friend of global scope",
8570 type = void_type_node;
8573 else if (memfn_quals)
8575 if (ctype == NULL_TREE)
8577 if (TREE_CODE (type) != METHOD_TYPE)
8578 error ("invalid qualifiers on non-member function type");
8580 ctype = TYPE_METHOD_BASETYPE (type);
8583 type = build_memfn_type (type, ctype, memfn_quals);
8588 else if (unqualified_id == NULL_TREE && decl_context != PARM
8589 && decl_context != CATCHPARM
8590 && TREE_CODE (type) != UNION_TYPE
8593 error ("abstract declarator %qT used as declaration", type);
8594 return error_mark_node;
8597 /* Only functions may be declared using an operator-function-id. */
8599 && IDENTIFIER_OPNAME_P (unqualified_id)
8600 && TREE_CODE (type) != FUNCTION_TYPE
8601 && TREE_CODE (type) != METHOD_TYPE)
8603 error ("declaration of %qD as non-function", unqualified_id);
8604 return error_mark_node;
8607 /* We don't check parameter types here because we can emit a better
8608 error message later. */
8609 if (decl_context != PARM)
8611 type = check_var_type (unqualified_id, type);
8612 if (type == error_mark_node)
8613 return error_mark_node;
8616 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
8617 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
8619 if (decl_context == PARM || decl_context == CATCHPARM)
8621 if (ctype || in_namespace)
8622 error ("cannot use %<::%> in parameter declaration");
8624 /* A parameter declared as an array of T is really a pointer to T.
8625 One declared as a function is really a pointer to a function.
8626 One declared as a member is really a pointer to member. */
8628 if (TREE_CODE (type) == ARRAY_TYPE)
8630 /* Transfer const-ness of array into that of type pointed to. */
8631 type = build_pointer_type (TREE_TYPE (type));
8632 type_quals = TYPE_UNQUALIFIED;
8634 else if (TREE_CODE (type) == FUNCTION_TYPE)
8635 type = build_pointer_type (type);
8641 if (decl_context == PARM)
8643 decl = cp_build_parm_decl (unqualified_id, type);
8645 bad_specifiers (decl, "parameter", virtualp,
8646 memfn_quals != TYPE_UNQUALIFIED,
8647 inlinep, friendp, raises != NULL_TREE);
8649 else if (decl_context == FIELD)
8651 /* The C99 flexible array extension. */
8652 if (!staticp && TREE_CODE (type) == ARRAY_TYPE
8653 && TYPE_DOMAIN (type) == NULL_TREE)
8655 tree itype = compute_array_index_type (dname, integer_zero_node);
8656 type = build_cplus_array_type (TREE_TYPE (type), itype);
8659 if (type == error_mark_node)
8661 /* Happens when declaring arrays of sizes which
8662 are error_mark_node, for example. */
8665 else if (in_namespace && !friendp)
8667 /* Something like struct S { int N::j; }; */
8668 error ("invalid use of %<::%>");
8669 return error_mark_node;
8671 else if (TREE_CODE (type) == FUNCTION_TYPE)
8674 tree function_context;
8678 if (ctype == NULL_TREE)
8679 ctype = current_class_type;
8681 if (ctype == NULL_TREE)
8683 error ("can't make %qD into a method -- not in a class",
8685 return error_mark_node;
8688 /* ``A union may [ ... ] not [ have ] virtual functions.''
8690 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
8692 error ("function %qD declared virtual inside a union",
8694 return error_mark_node;
8697 if (NEW_DELETE_OPNAME_P (unqualified_id))
8701 error ("%qD cannot be declared virtual, since it "
8707 else if (staticp < 2)
8708 type = build_memfn_type (type, ctype, memfn_quals);
8711 /* Check that the name used for a destructor makes sense. */
8712 if (sfk == sfk_destructor)
8716 gcc_assert (friendp);
8717 error ("expected qualified name in friend declaration "
8718 "for destructor %qD",
8719 id_declarator->u.id.unqualified_name);
8720 return error_mark_node;
8723 if (!same_type_p (TREE_OPERAND
8724 (id_declarator->u.id.unqualified_name, 0),
8727 error ("declaration of %qD as member of %qT",
8728 id_declarator->u.id.unqualified_name, ctype);
8729 return error_mark_node;
8733 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
8734 function_context = (ctype != NULL_TREE) ?
8735 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
8736 publicp = (! friendp || ! staticp)
8737 && function_context == NULL_TREE;
8738 decl = grokfndecl (ctype, type,
8739 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
8740 ? unqualified_id : dname,
8743 virtualp, flags, memfn_quals, raises,
8744 friendp ? -1 : 0, friendp, publicp, inlinep,
8746 funcdef_flag, template_count, in_namespace, attrlist);
8747 if (decl == NULL_TREE)
8748 return error_mark_node;
8750 /* This clobbers the attrs stored in `decl' from `attrlist'. */
8751 /* The decl and setting of decl_attr is also turned off. */
8752 decl = build_decl_attribute_variant (decl, decl_attr);
8755 /* [class.conv.ctor]
8757 A constructor declared without the function-specifier
8758 explicit that can be called with a single parameter
8759 specifies a conversion from the type of its first
8760 parameter to the type of its class. Such a constructor
8761 is called a converting constructor. */
8763 DECL_NONCONVERTING_P (decl) = 1;
8764 else if (DECL_CONSTRUCTOR_P (decl))
8766 /* The constructor can be called with exactly one
8767 parameter if there is at least one parameter, and
8768 any subsequent parameters have default arguments.
8769 Ignore any compiler-added parms. */
8770 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
8772 if (arg_types == void_list_node
8774 && TREE_CHAIN (arg_types)
8775 && TREE_CHAIN (arg_types) != void_list_node
8776 && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
8777 DECL_NONCONVERTING_P (decl) = 1;
8780 else if (TREE_CODE (type) == METHOD_TYPE)
8782 /* We only get here for friend declarations of
8783 members of other classes. */
8784 /* All method decls are public, so tell grokfndecl to set
8785 TREE_PUBLIC, also. */
8786 decl = grokfndecl (ctype, type,
8787 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
8788 ? unqualified_id : dname,
8791 virtualp, flags, memfn_quals, raises,
8792 friendp ? -1 : 0, friendp, 1, 0, sfk,
8793 funcdef_flag, template_count, in_namespace,
8795 if (decl == NULL_TREE)
8796 return error_mark_node;
8798 else if (!staticp && !dependent_type_p (type)
8799 && !COMPLETE_TYPE_P (complete_type (type))
8800 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
8803 error ("field %qD has incomplete type", unqualified_id);
8805 error ("name %qT has incomplete type", type);
8807 /* If we're instantiating a template, tell them which
8808 instantiation made the field's type be incomplete. */
8809 if (current_class_type
8810 && TYPE_NAME (current_class_type)
8811 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
8813 && declspecs->type == type)
8814 error (" in instantiation of template %qT",
8815 current_class_type);
8817 return error_mark_node;
8823 error ("%qE is neither function nor member function; "
8824 "cannot be declared friend", unqualified_id);
8832 /* Friends are treated specially. */
8833 if (ctype == current_class_type)
8834 ; /* We already issued a pedwarn. */
8835 else if (decl && DECL_NAME (decl))
8837 if (template_class_depth (current_class_type) == 0)
8839 decl = check_explicit_specialization
8840 (unqualified_id, decl, template_count,
8841 2 * funcdef_flag + 4);
8842 if (decl == error_mark_node)
8843 return error_mark_node;
8846 decl = do_friend (ctype, unqualified_id, decl,
8852 return error_mark_node;
8855 /* Structure field. It may not be a function, except for C++. */
8857 if (decl == NULL_TREE)
8863 /* An attempt is being made to initialize a non-static
8864 member. But, from [class.mem]:
8866 4 A member-declarator can contain a
8867 constant-initializer only if it declares a static
8868 member (_class.static_) of integral or enumeration
8869 type, see _class.static.data_.
8871 This used to be relatively common practice, but
8872 the rest of the compiler does not correctly
8873 handle the initialization unless the member is
8874 static so we make it static below. */
8875 pedwarn ("ISO C++ forbids initialization of member %qD",
8877 pedwarn ("making %qD static", unqualified_id);
8881 if (uses_template_parms (type))
8882 /* We'll check at instantiation time. */
8884 else if (check_static_variable_definition (unqualified_id,
8886 /* If we just return the declaration, crashes
8887 will sometimes occur. We therefore return
8888 void_type_node, as if this was a friend
8889 declaration, to cause callers to completely
8890 ignore this declaration. */
8891 return error_mark_node;
8896 /* C++ allows static class members. All other work
8897 for this is done by grokfield. */
8898 decl = build_lang_decl (VAR_DECL, unqualified_id, type);
8899 set_linkage_for_static_data_member (decl);
8900 /* Even if there is an in-class initialization, DECL
8901 is considered undefined until an out-of-class
8902 definition is provided. */
8903 DECL_EXTERNAL (decl) = 1;
8906 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
8910 decl = build_decl (FIELD_DECL, unqualified_id, type);
8911 DECL_NONADDRESSABLE_P (decl) = bitfield;
8912 if (bitfield && !unqualified_id)
8913 TREE_NO_WARNING (decl) = 1;
8915 if (storage_class == sc_mutable)
8917 DECL_MUTABLE_P (decl) = 1;
8918 storage_class = sc_none;
8922 bad_specifiers (decl, "field", virtualp,
8923 memfn_quals != TYPE_UNQUALIFIED,
8924 inlinep, friendp, raises != NULL_TREE);
8927 else if (TREE_CODE (type) == FUNCTION_TYPE
8928 || TREE_CODE (type) == METHOD_TYPE)
8933 if (!unqualified_id)
8934 return error_mark_node;
8936 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
8937 original_name = dname;
8939 original_name = unqualified_id;
8941 if (storage_class == sc_auto)
8942 error ("storage class %<auto%> invalid for function %qs", name);
8943 else if (storage_class == sc_register)
8944 error ("storage class %<register%> invalid for function %qs", name);
8946 error ("storage class %<__thread%> invalid for function %qs", name);
8948 /* Function declaration not at top level.
8949 Storage classes other than `extern' are not allowed
8950 and `extern' makes no difference. */
8951 if (! toplevel_bindings_p ()
8952 && (storage_class == sc_static
8953 || declspecs->specs[(int)ds_inline])
8956 if (storage_class == sc_static)
8957 pedwarn ("%<static%> specified invalid for function %qs "
8958 "declared out of global scope", name);
8960 pedwarn ("%<inline%> specifier invalid for function %qs "
8961 "declared out of global scope", name);
8964 if (ctype == NULL_TREE)
8968 error ("virtual non-class function %qs", name);
8972 else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2
8973 && !NEW_DELETE_OPNAME_P (original_name))
8974 type = build_method_type_directly (ctype,
8976 TYPE_ARG_TYPES (type));
8978 /* Record presence of `static'. */
8979 publicp = (ctype != NULL_TREE
8980 || storage_class == sc_extern
8981 || storage_class != sc_static);
8983 decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
8984 virtualp, flags, memfn_quals, raises,
8986 publicp, inlinep, sfk, funcdef_flag,
8987 template_count, in_namespace, attrlist);
8988 if (decl == NULL_TREE)
8989 return error_mark_node;
8993 int invalid_static = 0;
8995 /* Don't allow a static member function in a class, and forbid
8996 declaring main to be static. */
8997 if (TREE_CODE (type) == METHOD_TYPE)
8999 pedwarn ("cannot declare member function %qD to have "
9000 "static linkage", decl);
9003 else if (current_function_decl)
9005 /* FIXME need arm citation */
9006 error ("cannot declare static function inside another function");
9013 storage_class = sc_none;
9019 /* It's a variable. */
9021 /* An uninitialized decl with `extern' is a reference. */
9022 decl = grokvardecl (type, unqualified_id,
9025 (type_quals & TYPE_QUAL_CONST) != 0,
9026 ctype ? ctype : in_namespace);
9027 bad_specifiers (decl, "variable", virtualp,
9028 memfn_quals != TYPE_UNQUALIFIED,
9029 inlinep, friendp, raises != NULL_TREE);
9033 DECL_CONTEXT (decl) = ctype;
9036 pedwarn ("%<static%> may not be used when defining "
9037 "(as opposed to declaring) a static data member");
9039 storage_class = sc_none;
9041 if (storage_class == sc_register && TREE_STATIC (decl))
9043 error ("static member %qD declared %<register%>", decl);
9044 storage_class = sc_none;
9046 if (storage_class == sc_extern && pedantic)
9048 pedwarn ("cannot explicitly declare member %q#D to have "
9051 storage_class = sc_none;
9056 /* Record `register' declaration for warnings on &
9057 and in case doing stupid register allocation. */
9059 if (storage_class == sc_register)
9060 DECL_REGISTER (decl) = 1;
9061 else if (storage_class == sc_extern)
9062 DECL_THIS_EXTERN (decl) = 1;
9063 else if (storage_class == sc_static)
9064 DECL_THIS_STATIC (decl) = 1;
9066 /* Record constancy and volatility. There's no need to do this
9067 when processing a template; we'll do this for the instantiated
9068 declaration based on the type of DECL. */
9069 if (!processing_template_decl)
9070 cp_apply_type_quals_to_decl (type_quals, decl);
9073 TREE_NO_WARNING (decl) = 1;
9079 /* Subroutine of start_function. Ensure that each of the parameter
9080 types (as listed in PARMS) is complete, as is required for a
9081 function definition. */
9084 require_complete_types_for_parms (tree parms)
9086 for (; parms; parms = TREE_CHAIN (parms))
9088 if (dependent_type_p (TREE_TYPE (parms)))
9090 if (!VOID_TYPE_P (TREE_TYPE (parms))
9091 && complete_type_or_else (TREE_TYPE (parms), parms))
9093 relayout_decl (parms);
9094 DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
9097 /* grokparms or complete_type_or_else will have already issued
9099 TREE_TYPE (parms) = error_mark_node;
9103 /* Returns nonzero if T is a local variable. */
9106 local_variable_p (const_tree t)
9108 if ((TREE_CODE (t) == VAR_DECL
9109 /* A VAR_DECL with a context that is a _TYPE is a static data
9111 && !TYPE_P (CP_DECL_CONTEXT (t))
9112 /* Any other non-local variable must be at namespace scope. */
9113 && !DECL_NAMESPACE_SCOPE_P (t))
9114 || (TREE_CODE (t) == PARM_DECL))
9120 /* Like local_variable_p, but suitable for use as a tree-walking
9124 local_variable_p_walkfn (tree *tp, int *walk_subtrees,
9125 void *data ATTRIBUTE_UNUSED)
9127 if (local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
9129 else if (TYPE_P (*tp))
9136 /* Check that ARG, which is a default-argument expression for a
9137 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
9138 something goes wrong. DECL may also be a _TYPE node, rather than a
9139 DECL, if there is no DECL available. */
9142 check_default_argument (tree decl, tree arg)
9147 if (TREE_CODE (arg) == DEFAULT_ARG)
9148 /* We get a DEFAULT_ARG when looking at an in-class declaration
9149 with a default argument. Ignore the argument for now; we'll
9150 deal with it after the class is complete. */
9159 decl_type = TREE_TYPE (decl);
9161 if (arg == error_mark_node
9162 || decl == error_mark_node
9163 || TREE_TYPE (arg) == error_mark_node
9164 || decl_type == error_mark_node)
9165 /* Something already went wrong. There's no need to check
9167 return error_mark_node;
9169 /* [dcl.fct.default]
9171 A default argument expression is implicitly converted to the
9173 if (!TREE_TYPE (arg)
9174 || !can_convert_arg (decl_type, TREE_TYPE (arg), arg, LOOKUP_NORMAL))
9177 error ("default argument for %q#D has type %qT",
9178 decl, TREE_TYPE (arg));
9180 error ("default argument for parameter of type %qT has type %qT",
9181 decl_type, TREE_TYPE (arg));
9183 return error_mark_node;
9186 /* [dcl.fct.default]
9188 Local variables shall not be used in default argument
9191 The keyword `this' shall not be used in a default argument of a
9193 var = cp_walk_tree_without_duplicates (&arg, local_variable_p_walkfn, NULL);
9196 error ("default argument %qE uses local variable %qD", arg, var);
9197 return error_mark_node;
9204 /* Decode the list of parameter types for a function type.
9205 Given the list of things declared inside the parens,
9206 return a list of types.
9208 If this parameter does not end with an ellipsis, we append
9211 *PARMS is set to the chain of PARM_DECLs created. */
9214 grokparms (cp_parameter_declarator *first_parm, tree *parms)
9216 tree result = NULL_TREE;
9217 tree decls = NULL_TREE;
9218 int ellipsis = !first_parm || first_parm->ellipsis_p;
9219 cp_parameter_declarator *parm;
9221 struct pointer_set_t *unique_decls = pointer_set_create ();
9223 for (parm = first_parm; parm != NULL; parm = parm->next)
9225 tree type = NULL_TREE;
9226 tree init = parm->default_argument;
9230 if (parm == no_parameters)
9233 attrs = parm->decl_specifiers.attributes;
9234 parm->decl_specifiers.attributes = NULL_TREE;
9235 decl = grokdeclarator (parm->declarator, &parm->decl_specifiers,
9236 PARM, init != NULL_TREE, &attrs);
9237 if (! decl || TREE_TYPE (decl) == error_mark_node)
9241 cplus_decl_attributes (&decl, attrs, 0);
9243 type = TREE_TYPE (decl);
9244 if (VOID_TYPE_P (type))
9246 if (same_type_p (type, void_type_node)
9247 && DECL_SELF_REFERENCE_P (type)
9248 && !DECL_NAME (decl) && !result && !parm->next && !ellipsis)
9249 /* this is a parmlist of `(void)', which is ok. */
9251 cxx_incomplete_type_error (decl, type);
9252 /* It's not a good idea to actually create parameters of
9253 type `void'; other parts of the compiler assume that a
9254 void type terminates the parameter list. */
9255 type = error_mark_node;
9256 TREE_TYPE (decl) = error_mark_node;
9259 if (type != error_mark_node)
9261 /* Top-level qualifiers on the parameters are
9262 ignored for function types. */
9263 type = cp_build_qualified_type (type, 0);
9264 if (TREE_CODE (type) == METHOD_TYPE)
9266 error ("parameter %qD invalidly declared method type", decl);
9267 type = build_pointer_type (type);
9268 TREE_TYPE (decl) = type;
9270 else if (abstract_virtuals_error (decl, type))
9271 any_error = 1; /* Seems like a good idea. */
9272 else if (POINTER_TYPE_P (type))
9274 /* [dcl.fct]/6, parameter types cannot contain pointers
9275 (references) to arrays of unknown bound. */
9276 tree t = TREE_TYPE (type);
9277 int ptr = TYPE_PTR_P (type);
9283 else if (TREE_CODE (t) != ARRAY_TYPE)
9285 else if (!TYPE_DOMAIN (t))
9289 if (TREE_CODE (t) == ARRAY_TYPE)
9290 error ("parameter %qD includes %s to array of unknown "
9292 decl, ptr ? "pointer" : "reference", t);
9297 else if (init && !processing_template_decl)
9298 init = check_default_argument (decl, init);
9301 if (TREE_CODE (decl) == PARM_DECL
9302 && FUNCTION_PARAMETER_PACK_P (decl)
9304 error ("parameter packs must be at the end of the parameter list");
9306 if (DECL_NAME (decl))
9308 if (pointer_set_contains (unique_decls, DECL_NAME (decl)))
9309 error ("multiple parameters named %qE", DECL_NAME (decl));
9311 pointer_set_insert (unique_decls, DECL_NAME (decl));
9314 TREE_CHAIN (decl) = decls;
9316 result = tree_cons (init, type, result);
9318 decls = nreverse (decls);
9319 result = nreverse (result);
9321 result = chainon (result, void_list_node);
9324 pointer_set_destroy (unique_decls);
9329 /* D is a constructor or overloaded `operator='.
9331 Let T be the class in which D is declared. Then, this function
9334 -1 if D's is an ill-formed constructor or copy assignment operator
9335 whose first parameter is of type `T'.
9336 0 if D is not a copy constructor or copy assignment
9338 1 if D is a copy constructor or copy assignment operator whose
9339 first parameter is a reference to const qualified T.
9340 2 if D is a copy constructor or copy assignment operator whose
9341 first parameter is a reference to non-const qualified T.
9343 This function can be used as a predicate. Positive values indicate
9344 a copy constructor and nonzero values indicate a copy assignment
9348 copy_fn_p (const_tree d)
9354 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
9356 if (TREE_CODE (d) == TEMPLATE_DECL
9357 || (DECL_TEMPLATE_INFO (d)
9358 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
9359 /* Instantiations of template member functions are never copy
9360 functions. Note that member functions of templated classes are
9361 represented as template functions internally, and we must
9362 accept those as copy functions. */
9365 args = FUNCTION_FIRST_USER_PARMTYPE (d);
9369 arg_type = TREE_VALUE (args);
9370 if (arg_type == error_mark_node)
9373 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
9375 /* Pass by value copy assignment operator. */
9378 else if (TREE_CODE (arg_type) == REFERENCE_TYPE
9379 && !TYPE_REF_IS_RVALUE (arg_type)
9380 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
9382 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
9388 args = TREE_CHAIN (args);
9390 if (args && args != void_list_node && !TREE_PURPOSE (args))
9391 /* There are more non-optional args. */
9397 /* D is a constructor or overloaded `operator='.
9399 Let T be the class in which D is declared. Then, this function
9400 returns true when D is a move constructor or move assignment
9401 operator, false otherwise. */
9404 move_fn_p (const_tree d)
9408 bool result = false;
9410 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
9412 if (cxx_dialect == cxx98)
9413 /* There are no move constructors if we are in C++98 mode. */
9416 if (TREE_CODE (d) == TEMPLATE_DECL
9417 || (DECL_TEMPLATE_INFO (d)
9418 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
9419 /* Instantiations of template member functions are never copy
9420 functions. Note that member functions of templated classes are
9421 represented as template functions internally, and we must
9422 accept those as copy functions. */
9425 args = FUNCTION_FIRST_USER_PARMTYPE (d);
9429 arg_type = TREE_VALUE (args);
9430 if (arg_type == error_mark_node)
9433 if (TREE_CODE (arg_type) == REFERENCE_TYPE
9434 && TYPE_REF_IS_RVALUE (arg_type)
9435 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)),
9439 args = TREE_CHAIN (args);
9441 if (args && args != void_list_node && !TREE_PURPOSE (args))
9442 /* There are more non-optional args. */
9448 /* Remember any special properties of member function DECL. */
9450 void grok_special_member_properties (tree decl)
9454 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
9457 class_type = DECL_CONTEXT (decl);
9458 if (DECL_CONSTRUCTOR_P (decl))
9460 int ctor = copy_fn_p (decl);
9462 TYPE_HAS_CONSTRUCTOR (class_type) = 1;
9468 A non-template constructor for class X is a copy
9469 constructor if its first parameter is of type X&, const
9470 X&, volatile X& or const volatile X&, and either there
9471 are no other parameters or else all other parameters have
9472 default arguments. */
9473 TYPE_HAS_INIT_REF (class_type) = 1;
9475 TYPE_HAS_CONST_INIT_REF (class_type) = 1;
9477 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
9478 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type) = 1;
9480 else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
9484 A non-template assignment operator for class X is a copy
9485 assignment operator if its parameter is of type X, X&, const
9486 X&, volatile X& or const volatile X&. */
9488 int assop = copy_fn_p (decl);
9492 TYPE_HAS_ASSIGN_REF (class_type) = 1;
9494 TYPE_HAS_CONST_ASSIGN_REF (class_type) = 1;
9499 /* Check a constructor DECL has the correct form. Complains
9500 if the class has a constructor of the form X(X). */
9503 grok_ctor_properties (const_tree ctype, const_tree decl)
9505 int ctor_parm = copy_fn_p (decl);
9511 A declaration of a constructor for a class X is ill-formed if
9512 its first parameter is of type (optionally cv-qualified) X
9513 and either there are no other parameters or else all other
9514 parameters have default arguments.
9516 We *don't* complain about member template instantiations that
9517 have this form, though; they can occur as we try to decide
9518 what constructor to use during overload resolution. Since
9519 overload resolution will never prefer such a constructor to
9520 the non-template copy constructor (which is either explicitly
9521 or implicitly defined), there's no need to worry about their
9522 existence. Theoretically, they should never even be
9523 instantiated, but that's hard to forestall. */
9524 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
9532 /* An operator with this code is unary, but can also be binary. */
9535 ambi_op_p (enum tree_code code)
9537 return (code == INDIRECT_REF
9538 || code == ADDR_EXPR
9539 || code == UNARY_PLUS_EXPR
9540 || code == NEGATE_EXPR
9541 || code == PREINCREMENT_EXPR
9542 || code == PREDECREMENT_EXPR);
9545 /* An operator with this name can only be unary. */
9548 unary_op_p (enum tree_code code)
9550 return (code == TRUTH_NOT_EXPR
9551 || code == BIT_NOT_EXPR
9552 || code == COMPONENT_REF
9553 || code == TYPE_EXPR);
9556 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
9557 errors are issued for invalid declarations. */
9560 grok_op_properties (tree decl, bool complain)
9562 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
9564 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
9565 tree name = DECL_NAME (decl);
9566 enum tree_code operator_code;
9571 /* Count the number of arguments and check for ellipsis. */
9572 for (argtype = argtypes, arity = 0;
9573 argtype && argtype != void_list_node;
9574 argtype = TREE_CHAIN (argtype))
9576 ellipsis_p = !argtype;
9578 class_type = DECL_CONTEXT (decl);
9579 if (class_type && !CLASS_TYPE_P (class_type))
9580 class_type = NULL_TREE;
9582 if (DECL_CONV_FN_P (decl))
9583 operator_code = TYPE_EXPR;
9587 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
9588 if (ansi_opname (CODE) == name) \
9590 operator_code = (CODE); \
9593 else if (ansi_assopname (CODE) == name) \
9595 operator_code = (CODE); \
9596 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
9600 #include "operators.def"
9606 gcc_assert (operator_code != LAST_CPLUS_TREE_CODE);
9607 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
9610 switch (operator_code)
9613 TYPE_HAS_NEW_OPERATOR (class_type) = 1;
9617 TYPE_GETS_DELETE (class_type) |= 1;
9621 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type) = 1;
9624 case VEC_DELETE_EXPR:
9625 TYPE_GETS_DELETE (class_type) |= 2;
9632 /* [basic.std.dynamic.allocation]/1:
9634 A program is ill-formed if an allocation function is declared
9635 in a namespace scope other than global scope or declared static
9638 The same also holds true for deallocation functions. */
9639 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR
9640 || operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
9642 if (DECL_NAMESPACE_SCOPE_P (decl))
9644 if (CP_DECL_CONTEXT (decl) != global_namespace)
9646 error ("%qD may not be declared within a namespace", decl);
9649 else if (!TREE_PUBLIC (decl))
9651 error ("%qD may not be declared as static", decl);
9657 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
9658 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
9659 else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
9660 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
9663 /* An operator function must either be a non-static member function
9664 or have at least one parameter of a class, a reference to a class,
9665 an enumeration, or a reference to an enumeration. 13.4.0.6 */
9666 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
9668 if (operator_code == TYPE_EXPR
9669 || operator_code == CALL_EXPR
9670 || operator_code == COMPONENT_REF
9671 || operator_code == ARRAY_REF
9672 || operator_code == NOP_EXPR)
9674 error ("%qD must be a nonstatic member function", decl);
9681 if (DECL_STATIC_FUNCTION_P (decl))
9683 error ("%qD must be either a non-static member "
9684 "function or a non-member function", decl);
9688 for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
9690 tree arg = non_reference (TREE_VALUE (p));
9691 if (arg == error_mark_node)
9694 /* IS_AGGR_TYPE, rather than CLASS_TYPE_P, is used
9695 because these checks are performed even on
9696 template functions. */
9697 if (IS_AGGR_TYPE (arg) || TREE_CODE (arg) == ENUMERAL_TYPE)
9701 if (!p || p == void_list_node)
9704 error ("%qD must have an argument of class or "
9705 "enumerated type", decl);
9711 /* There are no restrictions on the arguments to an overloaded
9713 if (operator_code == CALL_EXPR)
9716 /* Warn about conversion operators that will never be used. */
9717 if (IDENTIFIER_TYPENAME_P (name)
9718 && ! DECL_TEMPLATE_INFO (decl)
9720 /* Warn only declaring the function; there is no need to
9721 warn again about out-of-class definitions. */
9722 && class_type == current_class_type)
9724 tree t = TREE_TYPE (name);
9725 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
9726 const char *what = 0;
9729 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
9731 if (TREE_CODE (t) == VOID_TYPE)
9733 else if (class_type)
9735 if (t == class_type)
9736 what = "the same type";
9737 /* Don't force t to be complete here. */
9738 else if (IS_AGGR_TYPE (t)
9739 && COMPLETE_TYPE_P (t)
9740 && DERIVED_FROM_P (t, class_type))
9741 what = "a base class";
9745 warning (OPT_Wconversion, "conversion to %s%s will never use a type "
9746 "conversion operator",
9747 ref ? "a reference to " : "", what);
9750 if (operator_code == COND_EXPR)
9753 error ("ISO C++ prohibits overloading operator ?:");
9756 else if (ellipsis_p)
9758 error ("%qD must not have variable number of arguments", decl);
9761 else if (ambi_op_p (operator_code))
9764 /* We pick the one-argument operator codes by default, so
9765 we don't have to change anything. */
9767 else if (arity == 2)
9769 /* If we thought this was a unary operator, we now know
9770 it to be a binary operator. */
9771 switch (operator_code)
9774 operator_code = MULT_EXPR;
9778 operator_code = BIT_AND_EXPR;
9781 case UNARY_PLUS_EXPR:
9782 operator_code = PLUS_EXPR;
9786 operator_code = MINUS_EXPR;
9789 case PREINCREMENT_EXPR:
9790 operator_code = POSTINCREMENT_EXPR;
9793 case PREDECREMENT_EXPR:
9794 operator_code = POSTDECREMENT_EXPR;
9801 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
9803 if ((operator_code == POSTINCREMENT_EXPR
9804 || operator_code == POSTDECREMENT_EXPR)
9805 && ! processing_template_decl
9806 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
9809 error ("postfix %qD must take %<int%> as its argument",
9812 error ("postfix %qD must take %<int%> as its second "
9820 error ("%qD must take either zero or one argument", decl);
9822 error ("%qD must take either one or two arguments", decl);
9826 /* More Effective C++ rule 6. */
9828 && (operator_code == POSTINCREMENT_EXPR
9829 || operator_code == POSTDECREMENT_EXPR
9830 || operator_code == PREINCREMENT_EXPR
9831 || operator_code == PREDECREMENT_EXPR))
9833 tree arg = TREE_VALUE (argtypes);
9834 tree ret = TREE_TYPE (TREE_TYPE (decl));
9835 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
9836 arg = TREE_TYPE (arg);
9837 arg = TYPE_MAIN_VARIANT (arg);
9838 if (operator_code == PREINCREMENT_EXPR
9839 || operator_code == PREDECREMENT_EXPR)
9841 if (TREE_CODE (ret) != REFERENCE_TYPE
9842 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
9844 warning (OPT_Weffc__, "prefix %qD should return %qT", decl,
9845 build_reference_type (arg));
9849 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
9850 warning (OPT_Weffc__, "postfix %qD should return %qT", decl, arg);
9854 else if (unary_op_p (operator_code))
9859 error ("%qD must take %<void%>", decl);
9861 error ("%qD must take exactly one argument", decl);
9865 else /* if (binary_op_p (operator_code)) */
9870 error ("%qD must take exactly one argument", decl);
9872 error ("%qD must take exactly two arguments", decl);
9876 /* More Effective C++ rule 7. */
9878 && (operator_code == TRUTH_ANDIF_EXPR
9879 || operator_code == TRUTH_ORIF_EXPR
9880 || operator_code == COMPOUND_EXPR))
9881 warning (OPT_Weffc__, "user-defined %qD always evaluates both arguments",
9885 /* Effective C++ rule 23. */
9888 && !DECL_ASSIGNMENT_OPERATOR_P (decl)
9889 && (operator_code == PLUS_EXPR
9890 || operator_code == MINUS_EXPR
9891 || operator_code == TRUNC_DIV_EXPR
9892 || operator_code == MULT_EXPR
9893 || operator_code == TRUNC_MOD_EXPR)
9894 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
9895 warning (OPT_Weffc__, "%qD should return by value", decl);
9898 for (; argtypes && argtypes != void_list_node;
9899 argtypes = TREE_CHAIN (argtypes))
9900 if (TREE_PURPOSE (argtypes))
9902 TREE_PURPOSE (argtypes) = NULL_TREE;
9903 if (operator_code == POSTINCREMENT_EXPR
9904 || operator_code == POSTDECREMENT_EXPR)
9907 pedwarn ("%qD cannot have default arguments", decl);
9911 error ("%qD cannot have default arguments", decl);
9919 /* Return a string giving the keyword associate with CODE. */
9922 tag_name (enum tag_types code)
9941 /* Name lookup in an elaborated-type-specifier (after the keyword
9942 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
9943 elaborated-type-specifier is invalid, issue a diagnostic and return
9944 error_mark_node; otherwise, return the *_TYPE to which it referred.
9945 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
9948 check_elaborated_type_specifier (enum tag_types tag_code,
9950 bool allow_template_p)
9956 struct S { struct S *p; };
9958 name lookup will find the TYPE_DECL for the implicit "S::S"
9959 typedef. Adjust for that here. */
9960 if (DECL_SELF_REFERENCE_P (decl))
9961 decl = TYPE_NAME (TREE_TYPE (decl));
9963 type = TREE_TYPE (decl);
9965 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
9966 is false for this case as well. */
9967 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
9969 error ("using template type parameter %qT after %qs",
9970 type, tag_name (tag_code));
9971 return error_mark_node;
9975 If the identifier resolves to a typedef-name or a template
9976 type-parameter, the elaborated-type-specifier is ill-formed.
9978 In other words, the only legitimate declaration to use in the
9979 elaborated type specifier is the implicit typedef created when
9980 the type is declared. */
9981 else if (!DECL_IMPLICIT_TYPEDEF_P (decl)
9982 && tag_code != typename_type)
9984 error ("using typedef-name %qD after %qs", decl, tag_name (tag_code));
9985 error ("%q+D has a previous declaration here", decl);
9986 return error_mark_node;
9988 else if (TREE_CODE (type) != RECORD_TYPE
9989 && TREE_CODE (type) != UNION_TYPE
9990 && tag_code != enum_type
9991 && tag_code != typename_type)
9993 error ("%qT referred to as %qs", type, tag_name (tag_code));
9994 error ("%q+T has a previous declaration here", type);
9995 return error_mark_node;
9997 else if (TREE_CODE (type) != ENUMERAL_TYPE
9998 && tag_code == enum_type)
10000 error ("%qT referred to as enum", type);
10001 error ("%q+T has a previous declaration here", type);
10002 return error_mark_node;
10004 else if (!allow_template_p
10005 && TREE_CODE (type) == RECORD_TYPE
10006 && CLASSTYPE_IS_TEMPLATE (type))
10008 /* If a class template appears as elaborated type specifier
10009 without a template header such as:
10011 template <class T> class C {};
10012 void f(class C); // No template header here
10014 then the required template argument is missing. */
10015 error ("template argument required for %<%s %T%>",
10016 tag_name (tag_code),
10017 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
10018 return error_mark_node;
10024 /* Lookup NAME in elaborate type specifier in scope according to
10025 SCOPE and issue diagnostics if necessary.
10026 Return *_TYPE node upon success, NULL_TREE when the NAME is not
10027 found, and ERROR_MARK_NODE for type error. */
10030 lookup_and_check_tag (enum tag_types tag_code, tree name,
10031 tag_scope scope, bool template_header_p)
10035 if (scope == ts_global)
10037 /* First try ordinary name lookup, ignoring hidden class name
10038 injected via friend declaration. */
10039 decl = lookup_name_prefer_type (name, 2);
10040 /* If that fails, the name will be placed in the smallest
10041 non-class, non-function-prototype scope according to 3.3.1/5.
10042 We may already have a hidden name declared as friend in this
10043 scope. So lookup again but not ignoring hidden names.
10044 If we find one, that name will be made visible rather than
10045 creating a new tag. */
10047 decl = lookup_type_scope (name, ts_within_enclosing_non_class);
10050 decl = lookup_type_scope (name, scope);
10052 if (decl && DECL_CLASS_TEMPLATE_P (decl))
10053 decl = DECL_TEMPLATE_RESULT (decl);
10055 if (decl && TREE_CODE (decl) == TYPE_DECL)
10057 /* Look for invalid nested type:
10061 if (scope == ts_current && DECL_SELF_REFERENCE_P (decl))
10063 error ("%qD has the same name as the class in which it is "
10066 return error_mark_node;
10069 /* Two cases we need to consider when deciding if a class
10070 template is allowed as an elaborated type specifier:
10071 1. It is a self reference to its own class.
10072 2. It comes with a template header.
10076 template <class T> class C {
10077 class C *c1; // DECL_SELF_REFERENCE_P is true
10080 template <class U> class C; // template_header_p is true
10081 template <class T> class C<T>::D {
10082 class C *c2; // DECL_SELF_REFERENCE_P is true
10085 t = check_elaborated_type_specifier (tag_code,
10088 | DECL_SELF_REFERENCE_P (decl));
10091 else if (decl && TREE_CODE (decl) == TREE_LIST)
10093 error ("reference to %qD is ambiguous", name);
10094 print_candidates (decl);
10095 return error_mark_node;
10101 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
10102 Define the tag as a forward-reference if it is not defined.
10104 If a declaration is given, process it here, and report an error if
10105 multiple declarations are not identical.
10107 SCOPE is TS_CURRENT when this is also a definition. Only look in
10108 the current frame for the name (since C++ allows new names in any
10109 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
10110 declaration. Only look beginning from the current scope outward up
10111 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
10113 TEMPLATE_HEADER_P is true when this declaration is preceded by
10114 a set of template parameters. */
10117 xref_tag (enum tag_types tag_code, tree name,
10118 tag_scope scope, bool template_header_p)
10120 enum tree_code code;
10122 tree context = NULL_TREE;
10124 timevar_push (TV_NAME_LOOKUP);
10126 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
10132 code = RECORD_TYPE;
10138 code = ENUMERAL_TYPE;
10141 gcc_unreachable ();
10144 /* In case of anonymous name, xref_tag is only called to
10145 make type node and push name. Name lookup is not required. */
10146 if (ANON_AGGRNAME_P (name))
10149 t = lookup_and_check_tag (tag_code, name,
10150 scope, template_header_p);
10152 if (t == error_mark_node)
10153 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10155 if (scope != ts_current && t && current_class_type
10156 && template_class_depth (current_class_type)
10157 && template_header_p)
10159 /* Since SCOPE is not TS_CURRENT, we are not looking at a
10160 definition of this tag. Since, in addition, we are currently
10161 processing a (member) template declaration of a template
10162 class, we must be very careful; consider:
10169 { template <class V>
10170 friend struct S1; };
10172 Here, the S2::S1 declaration should not be confused with the
10173 outer declaration. In particular, the inner version should
10174 have a template parameter of level 2, not level 1. This
10175 would be particularly important if the member declaration
10178 template <class V = U> friend struct S1;
10180 say, when we should tsubst into `U' when instantiating
10181 S2. On the other hand, when presented with:
10191 we must find the inner binding eventually. We
10192 accomplish this by making sure that the new type we
10193 create to represent this declaration has the right
10195 context = TYPE_CONTEXT (t);
10201 /* If no such tag is yet defined, create a forward-reference node
10202 and record it as the "definition".
10203 When a real declaration of this type is found,
10204 the forward-reference will be altered into a real type. */
10205 if (code == ENUMERAL_TYPE)
10207 error ("use of enum %q#D without previous declaration", name);
10208 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10212 t = make_aggr_type (code);
10213 TYPE_CONTEXT (t) = context;
10214 t = pushtag (name, t, scope);
10219 if (template_header_p && IS_AGGR_TYPE (t))
10221 if (!redeclare_class_template (t, current_template_parms))
10222 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10224 else if (!processing_template_decl
10225 && CLASS_TYPE_P (t)
10226 && CLASSTYPE_IS_TEMPLATE (t))
10228 error ("redeclaration of %qT as a non-template", t);
10229 error ("previous declaration %q+D", t);
10230 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10233 /* Make injected friend class visible. */
10234 if (scope != ts_within_enclosing_non_class
10235 && hidden_name_p (TYPE_NAME (t)))
10237 DECL_ANTICIPATED (TYPE_NAME (t)) = 0;
10238 DECL_FRIEND_P (TYPE_NAME (t)) = 0;
10240 if (TYPE_TEMPLATE_INFO (t))
10242 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t)) = 0;
10243 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t)) = 0;
10248 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
10252 xref_tag_from_type (tree old, tree id, tag_scope scope)
10254 enum tag_types tag_kind;
10256 if (TREE_CODE (old) == RECORD_TYPE)
10257 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
10259 tag_kind = union_type;
10261 if (id == NULL_TREE)
10262 id = TYPE_IDENTIFIER (old);
10264 return xref_tag (tag_kind, id, scope, false);
10267 /* Create the binfo hierarchy for REF with (possibly NULL) base list
10268 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
10269 access_* node, and the TREE_VALUE is the type of the base-class.
10270 Non-NULL TREE_TYPE indicates virtual inheritance.
10272 Returns true if the binfo hierarchy was successfully created,
10273 false if an error was detected. */
10276 xref_basetypes (tree ref, tree base_list)
10279 tree binfo, base_binfo;
10280 unsigned max_vbases = 0; /* Maximum direct & indirect virtual bases. */
10281 unsigned max_bases = 0; /* Maximum direct bases. */
10283 tree default_access;
10284 tree igo_prev; /* Track Inheritance Graph Order. */
10286 if (ref == error_mark_node)
10289 /* The base of a derived class is private by default, all others are
10291 default_access = (TREE_CODE (ref) == RECORD_TYPE
10292 && CLASSTYPE_DECLARED_CLASS (ref)
10293 ? access_private_node : access_public_node);
10295 /* First, make sure that any templates in base-classes are
10296 instantiated. This ensures that if we call ourselves recursively
10297 we do not get confused about which classes are marked and which
10299 basep = &base_list;
10302 tree basetype = TREE_VALUE (*basep);
10304 if (!(processing_template_decl && uses_template_parms (basetype))
10305 && !complete_type_or_else (basetype, NULL))
10306 /* An incomplete type. Remove it from the list. */
10307 *basep = TREE_CHAIN (*basep);
10311 if (TREE_TYPE (*basep))
10313 if (CLASS_TYPE_P (basetype))
10314 max_vbases += VEC_length (tree, CLASSTYPE_VBASECLASSES (basetype));
10315 basep = &TREE_CHAIN (*basep);
10319 TYPE_MARKED_P (ref) = 1;
10321 /* The binfo slot should be empty, unless this is an (ill-formed)
10323 gcc_assert (!TYPE_BINFO (ref) || TYPE_SIZE (ref));
10324 gcc_assert (TYPE_MAIN_VARIANT (ref) == ref);
10326 binfo = make_tree_binfo (max_bases);
10328 TYPE_BINFO (ref) = binfo;
10329 BINFO_OFFSET (binfo) = size_zero_node;
10330 BINFO_TYPE (binfo) = ref;
10334 BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, gc, max_bases);
10335 /* An aggregate cannot have baseclasses. */
10336 CLASSTYPE_NON_AGGREGATE (ref) = 1;
10338 if (TREE_CODE (ref) == UNION_TYPE)
10340 error ("derived union %qT invalid", ref);
10347 if (TYPE_FOR_JAVA (ref))
10349 error ("Java class %qT cannot have multiple bases", ref);
10356 CLASSTYPE_VBASECLASSES (ref) = VEC_alloc (tree, gc, max_vbases);
10358 if (TYPE_FOR_JAVA (ref))
10360 error ("Java class %qT cannot have virtual bases", ref);
10365 for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list))
10367 tree access = TREE_PURPOSE (base_list);
10368 int via_virtual = TREE_TYPE (base_list) != NULL_TREE;
10369 tree basetype = TREE_VALUE (base_list);
10371 if (access == access_default_node)
10372 access = default_access;
10374 if (PACK_EXPANSION_P (basetype))
10375 basetype = PACK_EXPANSION_PATTERN (basetype);
10376 if (TREE_CODE (basetype) == TYPE_DECL)
10377 basetype = TREE_TYPE (basetype);
10378 if (TREE_CODE (basetype) != RECORD_TYPE
10379 && TREE_CODE (basetype) != TYPENAME_TYPE
10380 && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
10381 && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM)
10383 error ("base type %qT fails to be a struct or class type",
10388 if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0))
10389 TYPE_FOR_JAVA (ref) = 1;
10391 base_binfo = NULL_TREE;
10392 if (CLASS_TYPE_P (basetype) && !dependent_type_p (basetype))
10394 base_binfo = TYPE_BINFO (basetype);
10395 /* The original basetype could have been a typedef'd type. */
10396 basetype = BINFO_TYPE (base_binfo);
10398 /* Inherit flags from the base. */
10399 TYPE_HAS_NEW_OPERATOR (ref)
10400 |= TYPE_HAS_NEW_OPERATOR (basetype);
10401 TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
10402 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
10403 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
10404 TYPE_HAS_CONVERSION (ref) |= TYPE_HAS_CONVERSION (basetype);
10405 CLASSTYPE_DIAMOND_SHAPED_P (ref)
10406 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype);
10407 CLASSTYPE_REPEATED_BASE_P (ref)
10408 |= CLASSTYPE_REPEATED_BASE_P (basetype);
10411 /* We must do this test after we've seen through a typedef
10413 if (TYPE_MARKED_P (basetype))
10415 if (basetype == ref)
10416 error ("recursive type %qT undefined", basetype);
10418 error ("duplicate base type %qT invalid", basetype);
10422 if (PACK_EXPANSION_P (TREE_VALUE (base_list)))
10423 /* Regenerate the pack expansion for the bases. */
10424 basetype = make_pack_expansion (basetype);
10426 TYPE_MARKED_P (basetype) = 1;
10428 base_binfo = copy_binfo (base_binfo, basetype, ref,
10429 &igo_prev, via_virtual);
10430 if (!BINFO_INHERITANCE_CHAIN (base_binfo))
10431 BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
10433 BINFO_BASE_APPEND (binfo, base_binfo);
10434 BINFO_BASE_ACCESS_APPEND (binfo, access);
10437 if (VEC_space (tree, CLASSTYPE_VBASECLASSES (ref), 1))
10438 /* If we have space in the vbase vector, we must have shared at
10439 least one of them, and are therefore diamond shaped. */
10440 CLASSTYPE_DIAMOND_SHAPED_P (ref) = 1;
10442 /* Unmark all the types. */
10443 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
10444 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
10445 TYPE_MARKED_P (ref) = 0;
10447 /* Now see if we have a repeated base type. */
10448 if (!CLASSTYPE_REPEATED_BASE_P (ref))
10450 for (base_binfo = binfo; base_binfo;
10451 base_binfo = TREE_CHAIN (base_binfo))
10453 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
10455 CLASSTYPE_REPEATED_BASE_P (ref) = 1;
10458 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 1;
10460 for (base_binfo = binfo; base_binfo;
10461 base_binfo = TREE_CHAIN (base_binfo))
10462 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
10463 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
10472 /* Begin compiling the definition of an enumeration type.
10474 Returns the type object, as yet incomplete.
10475 Also records info about it so that build_enumerator
10476 may be used to declare the individual values as they are read. */
10479 start_enum (tree name)
10483 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
10485 /* If this is the real definition for a previous forward reference,
10486 fill in the contents in the same object that used to be the
10487 forward reference. */
10489 enumtype = lookup_and_check_tag (enum_type, name,
10490 /*tag_scope=*/ts_current,
10491 /*template_header_p=*/false);
10493 if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
10495 error ("multiple definition of %q#T", enumtype);
10496 error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype));
10497 /* Clear out TYPE_VALUES, and start again. */
10498 TYPE_VALUES (enumtype) = NULL_TREE;
10502 /* In case of error, make a dummy enum to allow parsing to
10504 if (enumtype == error_mark_node)
10505 name = make_anon_name ();
10507 enumtype = make_node (ENUMERAL_TYPE);
10508 enumtype = pushtag (name, enumtype, /*tag_scope=*/ts_current);
10514 /* After processing and defining all the values of an enumeration type,
10515 install their decls in the enumeration type and finish it off.
10516 ENUMTYPE is the type object and VALUES a list of name-value pairs. */
10519 finish_enum (tree enumtype)
10528 bool use_short_enum;
10532 integer_type_kind itk;
10533 tree underlying_type = NULL_TREE;
10535 /* We built up the VALUES in reverse order. */
10536 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
10538 /* For an enum defined in a template, just set the type of the values;
10539 all further processing is postponed until the template is
10540 instantiated. We need to set the type so that tsubst of a CONST_DECL
10542 if (processing_template_decl)
10544 for (values = TYPE_VALUES (enumtype);
10546 values = TREE_CHAIN (values))
10547 TREE_TYPE (TREE_VALUE (values)) = enumtype;
10548 if (at_function_scope_p ())
10549 add_stmt (build_min (TAG_DEFN, enumtype));
10553 /* Determine the minimum and maximum values of the enumerators. */
10554 if (TYPE_VALUES (enumtype))
10556 minnode = maxnode = NULL_TREE;
10558 for (values = TYPE_VALUES (enumtype);
10560 values = TREE_CHAIN (values))
10562 decl = TREE_VALUE (values);
10564 /* [dcl.enum]: Following the closing brace of an enum-specifier,
10565 each enumerator has the type of its enumeration. Prior to the
10566 closing brace, the type of each enumerator is the type of its
10567 initializing value. */
10568 TREE_TYPE (decl) = enumtype;
10570 /* Update the minimum and maximum values, if appropriate. */
10571 value = DECL_INITIAL (decl);
10572 if (value == error_mark_node)
10573 value = integer_zero_node;
10574 /* Figure out what the minimum and maximum values of the
10575 enumerators are. */
10577 minnode = maxnode = value;
10578 else if (tree_int_cst_lt (maxnode, value))
10580 else if (tree_int_cst_lt (value, minnode))
10587 If the enumerator-list is empty, the underlying type is as if
10588 the enumeration had a single enumerator with value 0. */
10589 minnode = maxnode = integer_zero_node;
10591 /* Compute the number of bits require to represent all values of the
10592 enumeration. We must do this before the type of MINNODE and
10593 MAXNODE are transformed, since min_precision relies on the
10594 TREE_TYPE of the value it is passed. */
10595 unsignedp = tree_int_cst_sgn (minnode) >= 0;
10596 lowprec = min_precision (minnode, unsignedp);
10597 highprec = min_precision (maxnode, unsignedp);
10598 precision = MAX (lowprec, highprec);
10600 /* Determine the underlying type of the enumeration.
10604 The underlying type of an enumeration is an integral type that
10605 can represent all the enumerator values defined in the
10606 enumeration. It is implementation-defined which integral type is
10607 used as the underlying type for an enumeration except that the
10608 underlying type shall not be larger than int unless the value of
10609 an enumerator cannot fit in an int or unsigned int.
10611 We use "int" or an "unsigned int" as the underlying type, even if
10612 a smaller integral type would work, unless the user has
10613 explicitly requested that we use the smallest possible type. The
10614 user can request that for all enumerations with a command line
10615 flag, or for just one enumeration with an attribute. */
10617 use_short_enum = flag_short_enums
10618 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype));
10620 for (itk = (use_short_enum ? itk_char : itk_int);
10624 underlying_type = integer_types[itk];
10625 if (TYPE_PRECISION (underlying_type) >= precision
10626 && TYPE_UNSIGNED (underlying_type) == unsignedp)
10629 if (itk == itk_none)
10633 IF no integral type can represent all the enumerator values, the
10634 enumeration is ill-formed. */
10635 error ("no integral type can represent all of the enumerator values "
10636 "for %qT", enumtype);
10637 precision = TYPE_PRECISION (long_long_integer_type_node);
10638 underlying_type = integer_types[itk_unsigned_long_long];
10641 /* Compute the minium and maximum values for the type.
10645 For an enumeration where emin is the smallest enumerator and emax
10646 is the largest, the values of the enumeration are the values of the
10647 underlying type in the range bmin to bmax, where bmin and bmax are,
10648 respectively, the smallest and largest values of the smallest bit-
10649 field that can store emin and emax. */
10651 /* The middle-end currently assumes that types with TYPE_PRECISION
10652 narrower than their underlying type are suitably zero or sign
10653 extended to fill their mode. g++ doesn't make these guarantees.
10654 Until the middle-end can represent such paradoxical types, we
10655 set the TYPE_PRECISION to the width of the underlying type. */
10656 TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type);
10658 set_min_and_max_values_for_integral_type (enumtype, precision, unsignedp);
10662 The value of sizeof() applied to an enumeration type, an object
10663 of an enumeration type, or an enumerator, is the value of sizeof()
10664 applied to the underlying type. */
10665 TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
10666 TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
10667 TYPE_MODE (enumtype) = TYPE_MODE (underlying_type);
10668 TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
10669 TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
10670 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);
10672 /* Convert each of the enumerators to the type of the underlying
10673 type of the enumeration. */
10674 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
10676 location_t saved_location;
10678 decl = TREE_VALUE (values);
10679 saved_location = input_location;
10680 input_location = DECL_SOURCE_LOCATION (decl);
10681 value = perform_implicit_conversion (underlying_type,
10682 DECL_INITIAL (decl));
10683 input_location = saved_location;
10685 /* Do not clobber shared ints. */
10686 value = copy_node (value);
10688 TREE_TYPE (value) = enumtype;
10689 DECL_INITIAL (decl) = value;
10690 TREE_VALUE (values) = value;
10693 /* Fix up all variant types of this enum type. */
10694 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
10696 TYPE_VALUES (t) = TYPE_VALUES (enumtype);
10697 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
10698 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
10699 TYPE_SIZE (t) = TYPE_SIZE (enumtype);
10700 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
10701 TYPE_MODE (t) = TYPE_MODE (enumtype);
10702 TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
10703 TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
10704 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
10705 TYPE_UNSIGNED (t) = TYPE_UNSIGNED (enumtype);
10708 /* Finish debugging output for this type. */
10709 rest_of_type_compilation (enumtype, namespace_bindings_p ());
10712 /* Build and install a CONST_DECL for an enumeration constant of the
10713 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
10714 Assignment of sequential values by default is handled here. */
10717 build_enumerator (tree name, tree value, tree enumtype)
10723 /* If the VALUE was erroneous, pretend it wasn't there; that will
10724 result in the enum being assigned the next value in sequence. */
10725 if (value == error_mark_node)
10728 /* Remove no-op casts from the value. */
10730 STRIP_TYPE_NOPS (value);
10732 if (! processing_template_decl)
10734 /* Validate and default VALUE. */
10735 if (value != NULL_TREE)
10737 value = integral_constant_value (value);
10739 if (TREE_CODE (value) == INTEGER_CST)
10741 value = perform_integral_promotions (value);
10742 constant_expression_warning (value);
10746 error ("enumerator value for %qD is not an integer constant", name);
10751 /* Default based on previous value. */
10752 if (value == NULL_TREE)
10754 if (TYPE_VALUES (enumtype))
10757 unsigned HOST_WIDE_INT lo;
10761 /* The next value is the previous value plus one. We can
10762 safely assume that the previous value is an INTEGER_CST.
10763 add_double doesn't know the type of the target expression,
10764 so we must check with int_fits_type_p as well. */
10765 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
10766 overflowed = add_double (TREE_INT_CST_LOW (prev_value),
10767 TREE_INT_CST_HIGH (prev_value),
10769 value = build_int_cst_wide (TREE_TYPE (prev_value), lo, hi);
10770 overflowed |= !int_fits_type_p (value, TREE_TYPE (prev_value));
10774 error ("overflow in enumeration values at %qD", name);
10775 value = error_mark_node;
10779 value = integer_zero_node;
10782 /* Remove no-op casts from the value. */
10783 STRIP_TYPE_NOPS (value);
10786 /* C++ associates enums with global, function, or class declarations. */
10787 context = current_scope ();
10789 /* Build the actual enumeration constant. Note that the enumeration
10790 constants have the type of their initializers until the
10791 enumeration is complete:
10795 Following the closing brace of an enum-specifier, each enumer-
10796 ator has the type of its enumeration. Prior to the closing
10797 brace, the type of each enumerator is the type of its
10798 initializing value.
10800 In finish_enum we will reset the type. Of course, if we're
10801 processing a template, there may be no value. */
10802 type = value ? TREE_TYPE (value) : NULL_TREE;
10804 if (context && context == current_class_type)
10805 /* This enum declaration is local to the class. We need the full
10806 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
10807 decl = build_lang_decl (CONST_DECL, name, type);
10809 /* It's a global enum, or it's local to a function. (Note local to
10810 a function could mean local to a class method. */
10811 decl = build_decl (CONST_DECL, name, type);
10813 DECL_CONTEXT (decl) = FROB_CONTEXT (context);
10814 TREE_CONSTANT (decl) = 1;
10815 TREE_INVARIANT (decl) = 1;
10816 TREE_READONLY (decl) = 1;
10817 DECL_INITIAL (decl) = value;
10819 if (context && context == current_class_type)
10820 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
10821 on the TYPE_FIELDS list for `S'. (That's so that you can say
10822 things like `S::i' later.) */
10823 finish_member_declaration (decl);
10827 /* Add this enumeration constant to the list for this type. */
10828 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
10832 /* We're defining DECL. Make sure that it's type is OK. */
10835 check_function_type (tree decl, tree current_function_parms)
10837 tree fntype = TREE_TYPE (decl);
10838 tree return_type = complete_type (TREE_TYPE (fntype));
10840 /* In a function definition, arg types must be complete. */
10841 require_complete_types_for_parms (current_function_parms);
10843 if (dependent_type_p (return_type))
10845 if (!COMPLETE_OR_VOID_TYPE_P (return_type))
10847 tree args = TYPE_ARG_TYPES (fntype);
10849 error ("return type %q#T is incomplete", return_type);
10851 /* Make it return void instead. */
10852 if (TREE_CODE (fntype) == METHOD_TYPE)
10853 fntype = build_method_type_directly (TREE_TYPE (TREE_VALUE (args)),
10855 TREE_CHAIN (args));
10857 fntype = build_function_type (void_type_node, args);
10859 = build_exception_variant (fntype,
10860 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)));
10863 abstract_virtuals_error (decl, TREE_TYPE (fntype));
10866 /* Create the FUNCTION_DECL for a function definition.
10867 DECLSPECS and DECLARATOR are the parts of the declaration;
10868 they describe the function's name and the type it returns,
10869 but twisted together in a fashion that parallels the syntax of C.
10871 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
10872 DECLARATOR is really the DECL for the function we are about to
10873 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
10874 indicating that the function is an inline defined in-class.
10876 This function creates a binding context for the function body
10877 as well as setting up the FUNCTION_DECL in current_function_decl.
10879 For C++, we must first check whether that datum makes any sense.
10880 For example, "class A local_a(1,2);" means that variable local_a
10881 is an aggregate of type A, which should have a constructor
10882 applied to it with the argument list [1, 2].
10884 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
10885 or may be a BLOCK if the function has been defined previously
10886 in this translation unit. On exit, DECL_INITIAL (decl1) will be
10887 error_mark_node if the function has never been defined, or
10888 a BLOCK if the function has been defined somewhere. */
10891 start_preparsed_function (tree decl1, tree attrs, int flags)
10893 tree ctype = NULL_TREE;
10896 int doing_friend = 0;
10897 struct cp_binding_level *bl;
10898 tree current_function_parms;
10899 struct c_fileinfo *finfo
10900 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1)));
10901 bool honor_interface;
10903 /* Sanity check. */
10904 gcc_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE);
10905 gcc_assert (TREE_CHAIN (void_list_node) == NULL_TREE);
10907 fntype = TREE_TYPE (decl1);
10908 if (TREE_CODE (fntype) == METHOD_TYPE)
10909 ctype = TYPE_METHOD_BASETYPE (fntype);
10911 /* ISO C++ 11.4/5. A friend function defined in a class is in
10912 the (lexical) scope of the class in which it is defined. */
10913 if (!ctype && DECL_FRIEND_P (decl1))
10915 ctype = DECL_FRIEND_CONTEXT (decl1);
10917 /* CTYPE could be null here if we're dealing with a template;
10918 for example, `inline friend float foo()' inside a template
10919 will have no CTYPE set. */
10920 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
10926 if (DECL_DECLARED_INLINE_P (decl1)
10927 && lookup_attribute ("noinline", attrs))
10928 warning (0, "inline function %q+D given attribute noinline", decl1);
10930 /* Handle gnu_inline attribute. */
10931 if (GNU_INLINE_P (decl1))
10933 DECL_EXTERNAL (decl1) = 1;
10934 DECL_NOT_REALLY_EXTERN (decl1) = 0;
10935 DECL_INTERFACE_KNOWN (decl1) = 1;
10936 DECL_DISREGARD_INLINE_LIMITS (decl1) = 1;
10939 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
10940 /* This is a constructor, we must ensure that any default args
10941 introduced by this definition are propagated to the clones
10942 now. The clones are used directly in overload resolution. */
10943 adjust_clone_args (decl1);
10945 /* Sometimes we don't notice that a function is a static member, and
10946 build a METHOD_TYPE for it. Fix that up now. */
10947 if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
10948 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
10950 revert_static_member_fn (decl1);
10954 /* Set up current_class_type, and enter the scope of the class, if
10957 push_nested_class (ctype);
10958 else if (DECL_STATIC_FUNCTION_P (decl1))
10959 push_nested_class (DECL_CONTEXT (decl1));
10961 /* Now that we have entered the scope of the class, we must restore
10962 the bindings for any template parameters surrounding DECL1, if it
10963 is an inline member template. (Order is important; consider the
10964 case where a template parameter has the same name as a field of
10965 the class.) It is not until after this point that
10966 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
10967 if (flags & SF_INCLASS_INLINE)
10968 maybe_begin_member_template_processing (decl1);
10970 /* Effective C++ rule 15. */
10972 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
10973 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
10974 warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");
10976 /* Make the init_value nonzero so pushdecl knows this is not tentative.
10977 error_mark_node is replaced below (in poplevel) with the BLOCK. */
10978 if (!DECL_INITIAL (decl1))
10979 DECL_INITIAL (decl1) = error_mark_node;
10981 /* This function exists in static storage.
10982 (This does not mean `static' in the C sense!) */
10983 TREE_STATIC (decl1) = 1;
10985 /* We must call push_template_decl after current_class_type is set
10986 up. (If we are processing inline definitions after exiting a
10987 class scope, current_class_type will be NULL_TREE until set above
10988 by push_nested_class.) */
10989 if (processing_template_decl)
10991 /* FIXME: Handle error_mark_node more gracefully. */
10992 tree newdecl1 = push_template_decl (decl1);
10993 if (newdecl1 != error_mark_node)
10997 /* We are now in the scope of the function being defined. */
10998 current_function_decl = decl1;
11000 /* Save the parm names or decls from this function's declarator
11001 where store_parm_decls will find them. */
11002 current_function_parms = DECL_ARGUMENTS (decl1);
11004 /* Make sure the parameter and return types are reasonable. When
11005 you declare a function, these types can be incomplete, but they
11006 must be complete when you define the function. */
11007 check_function_type (decl1, current_function_parms);
11009 /* Build the return declaration for the function. */
11010 restype = TREE_TYPE (fntype);
11011 if (DECL_RESULT (decl1) == NULL_TREE)
11015 resdecl = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
11016 DECL_ARTIFICIAL (resdecl) = 1;
11017 DECL_IGNORED_P (resdecl) = 1;
11018 DECL_RESULT (decl1) = resdecl;
11020 cp_apply_type_quals_to_decl (cp_type_quals (restype), resdecl);
11023 /* Let the user know we're compiling this function. */
11024 announce_function (decl1);
11026 /* Record the decl so that the function name is defined.
11027 If we already have a decl for this name, and it is a FUNCTION_DECL,
11028 use the old decl. */
11029 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
11031 /* A specialization is not used to guide overload resolution. */
11032 if (!DECL_FUNCTION_MEMBER_P (decl1)
11033 && !(DECL_USE_TEMPLATE (decl1) &&
11034 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1))))
11036 tree olddecl = pushdecl (decl1);
11038 if (olddecl == error_mark_node)
11039 /* If something went wrong when registering the declaration,
11040 use DECL1; we have to have a FUNCTION_DECL to use when
11041 parsing the body of the function. */
11045 /* Otherwise, OLDDECL is either a previous declaration
11046 of the same function or DECL1 itself. */
11048 if (warn_missing_declarations
11049 && olddecl == decl1
11050 && !DECL_MAIN_P (decl1)
11051 && TREE_PUBLIC (decl1)
11052 && !DECL_DECLARED_INLINE_P (decl1))
11056 /* Check whether DECL1 is in an anonymous
11058 for (context = DECL_CONTEXT (decl1);
11060 context = DECL_CONTEXT (context))
11062 if (TREE_CODE (context) == NAMESPACE_DECL
11063 && DECL_NAME (context) == NULL_TREE)
11067 if (context == NULL)
11068 warning (OPT_Wmissing_declarations,
11069 "no previous declaration for %q+D", decl1);
11077 /* We need to set the DECL_CONTEXT. */
11078 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
11079 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
11081 fntype = TREE_TYPE (decl1);
11083 /* If #pragma weak applies, mark the decl appropriately now.
11084 The pragma only applies to global functions. Because
11085 determining whether or not the #pragma applies involves
11086 computing the mangled name for the declaration, we cannot
11087 apply the pragma until after we have merged this declaration
11088 with any previous declarations; if the original declaration
11089 has a linkage specification, that specification applies to
11090 the definition as well, and may affect the mangled name. */
11091 if (!DECL_CONTEXT (decl1))
11092 maybe_apply_pragma_weak (decl1);
11095 /* Reset this in case the call to pushdecl changed it. */
11096 current_function_decl = decl1;
11098 gcc_assert (DECL_INITIAL (decl1));
11100 /* This function may already have been parsed, in which case just
11101 return; our caller will skip over the body without parsing. */
11102 if (DECL_INITIAL (decl1) != error_mark_node)
11105 /* Initialize RTL machinery. We cannot do this until
11106 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
11107 even when processing a template; this is how we get
11108 CFUN set up, and our per-function variables initialized.
11109 FIXME factor out the non-RTL stuff. */
11110 bl = current_binding_level;
11111 allocate_struct_function (decl1);
11112 current_binding_level = bl;
11114 /* Even though we're inside a function body, we still don't want to
11115 call expand_expr to calculate the size of a variable-sized array.
11116 We haven't necessarily assigned RTL to all variables yet, so it's
11117 not safe to try to expand expressions involving them. */
11118 cfun->x_dont_save_pending_sizes_p = 1;
11120 /* Start the statement-tree, start the tree now. */
11121 DECL_SAVED_TREE (decl1) = push_stmt_list ();
11123 /* If we are (erroneously) defining a function that we have already
11124 defined before, wipe out what we knew before. */
11125 if (!DECL_PENDING_INLINE_P (decl1))
11126 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
11128 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
11130 /* We know that this was set up by `grokclassfn'. We do not
11131 wait until `store_parm_decls', since evil parse errors may
11132 never get us to that point. Here we keep the consistency
11133 between `current_class_type' and `current_class_ptr'. */
11134 tree t = DECL_ARGUMENTS (decl1);
11136 gcc_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL);
11137 gcc_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE);
11139 cp_function_chain->x_current_class_ref
11140 = build_indirect_ref (t, NULL);
11141 cp_function_chain->x_current_class_ptr = t;
11143 /* Constructors and destructors need to know whether they're "in
11144 charge" of initializing virtual base classes. */
11145 t = TREE_CHAIN (t);
11146 if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
11148 current_in_charge_parm = t;
11149 t = TREE_CHAIN (t);
11151 if (DECL_HAS_VTT_PARM_P (decl1))
11153 gcc_assert (DECL_NAME (t) == vtt_parm_identifier);
11154 current_vtt_parm = t;
11158 honor_interface = (!DECL_TEMPLATE_INSTANTIATION (decl1)
11159 /* Implicitly-defined methods (like the
11160 destructor for a class in which no destructor
11161 is explicitly declared) must not be defined
11162 until their definition is needed. So, we
11163 ignore interface specifications for
11164 compiler-generated functions. */
11165 && !DECL_ARTIFICIAL (decl1));
11167 if (DECL_INTERFACE_KNOWN (decl1))
11169 tree ctx = decl_function_context (decl1);
11171 if (DECL_NOT_REALLY_EXTERN (decl1))
11172 DECL_EXTERNAL (decl1) = 0;
11174 if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
11175 && TREE_PUBLIC (ctx))
11176 /* This is a function in a local class in an extern inline
11178 comdat_linkage (decl1);
11180 /* If this function belongs to an interface, it is public.
11181 If it belongs to someone else's interface, it is also external.
11182 This only affects inlines and template instantiations. */
11183 else if (!finfo->interface_unknown && honor_interface)
11185 if (DECL_DECLARED_INLINE_P (decl1)
11186 || DECL_TEMPLATE_INSTANTIATION (decl1)
11187 || processing_template_decl)
11189 DECL_EXTERNAL (decl1)
11190 = (finfo->interface_only
11191 || (DECL_DECLARED_INLINE_P (decl1)
11192 && ! flag_implement_inlines
11193 && !DECL_VINDEX (decl1)));
11195 /* For WIN32 we also want to put these in linkonce sections. */
11196 maybe_make_one_only (decl1);
11199 DECL_EXTERNAL (decl1) = 0;
11200 DECL_INTERFACE_KNOWN (decl1) = 1;
11201 /* If this function is in an interface implemented in this file,
11202 make sure that the back end knows to emit this function
11204 if (!DECL_EXTERNAL (decl1))
11205 mark_needed (decl1);
11207 else if (finfo->interface_unknown && finfo->interface_only
11208 && honor_interface)
11210 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
11211 interface, we will have both finfo->interface_unknown and
11212 finfo->interface_only set. In that case, we don't want to
11213 use the normal heuristics because someone will supply a
11214 #pragma implementation elsewhere, and deducing it here would
11215 produce a conflict. */
11216 comdat_linkage (decl1);
11217 DECL_EXTERNAL (decl1) = 0;
11218 DECL_INTERFACE_KNOWN (decl1) = 1;
11219 DECL_DEFER_OUTPUT (decl1) = 1;
11223 /* This is a definition, not a reference.
11224 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
11225 if (!GNU_INLINE_P (decl1))
11226 DECL_EXTERNAL (decl1) = 0;
11228 if ((DECL_DECLARED_INLINE_P (decl1)
11229 || DECL_TEMPLATE_INSTANTIATION (decl1))
11230 && ! DECL_INTERFACE_KNOWN (decl1)
11231 /* Don't try to defer nested functions for now. */
11232 && ! decl_function_context (decl1))
11233 DECL_DEFER_OUTPUT (decl1) = 1;
11235 DECL_INTERFACE_KNOWN (decl1) = 1;
11238 /* Determine the ELF visibility attribute for the function. We must not
11239 do this before calling "pushdecl", as we must allow "duplicate_decls"
11240 to merge any attributes appropriately. We also need to wait until
11242 if (!DECL_CLONED_FUNCTION_P (decl1))
11243 determine_visibility (decl1);
11245 begin_scope (sk_function_parms, decl1);
11249 if (DECL_DESTRUCTOR_P (decl1)
11250 || (DECL_CONSTRUCTOR_P (decl1)
11251 && targetm.cxx.cdtor_returns_this ()))
11253 cdtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
11254 DECL_CONTEXT (cdtor_label) = current_function_decl;
11257 start_fname_decls ();
11259 store_parm_decls (current_function_parms);
11263 /* Like start_preparsed_function, except that instead of a
11264 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
11266 Returns 1 on success. If the DECLARATOR is not suitable for a function
11267 (it defines a datum instead), we return 0, which tells
11268 yyparse to report a parse error. */
11271 start_function (cp_decl_specifier_seq *declspecs,
11272 const cp_declarator *declarator,
11277 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
11278 /* If the declarator is not suitable for a function definition,
11279 cause a syntax error. */
11280 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
11283 if (DECL_MAIN_P (decl1))
11284 /* main must return int. grokfndecl should have corrected it
11285 (and issued a diagnostic) if the user got it wrong. */
11286 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1)),
11287 integer_type_node));
11289 start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT);
11294 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
11298 use_eh_spec_block (tree fn)
11300 return (flag_exceptions && flag_enforce_eh_specs
11301 && !processing_template_decl
11302 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn))
11303 /* We insert the EH_SPEC_BLOCK only in the original
11304 function; then, it is copied automatically to the
11306 && !DECL_CLONED_FUNCTION_P (fn)
11307 /* Implicitly-generated constructors and destructors have
11308 exception specifications. However, those specifications
11309 are the union of the possible exceptions specified by the
11310 constructors/destructors for bases and members, so no
11311 unallowed exception will ever reach this function. By
11312 not creating the EH_SPEC_BLOCK we save a little memory,
11313 and we avoid spurious warnings about unreachable
11315 && !DECL_ARTIFICIAL (fn));
11318 /* Store the parameter declarations into the current function declaration.
11319 This is called after parsing the parameter declarations, before
11320 digesting the body of the function.
11322 Also install to binding contour return value identifier, if any. */
11325 store_parm_decls (tree current_function_parms)
11327 tree fndecl = current_function_decl;
11330 /* This is a chain of any other decls that came in among the parm
11331 declarations. If a parm is declared with enum {foo, bar} x;
11332 then CONST_DECLs for foo and bar are put here. */
11333 tree nonparms = NULL_TREE;
11335 if (current_function_parms)
11337 /* This case is when the function was defined with an ANSI prototype.
11338 The parms already have decls, so we need not do anything here
11339 except record them as in effect
11340 and complain if any redundant old-style parm decls were written. */
11342 tree specparms = current_function_parms;
11345 /* Must clear this because it might contain TYPE_DECLs declared
11347 current_binding_level->names = NULL;
11349 /* If we're doing semantic analysis, then we'll call pushdecl
11350 for each of these. We must do them in reverse order so that
11351 they end in the correct forward order. */
11352 specparms = nreverse (specparms);
11354 for (parm = specparms; parm; parm = next)
11356 next = TREE_CHAIN (parm);
11357 if (TREE_CODE (parm) == PARM_DECL)
11359 if (DECL_NAME (parm) == NULL_TREE
11360 || TREE_CODE (parm) != VOID_TYPE)
11363 error ("parameter %qD declared void", parm);
11367 /* If we find an enum constant or a type tag,
11368 put it aside for the moment. */
11369 TREE_CHAIN (parm) = NULL_TREE;
11370 nonparms = chainon (nonparms, parm);
11374 /* Get the decls in their original chain order and record in the
11375 function. This is all and only the PARM_DECLs that were
11376 pushed into scope by the loop above. */
11377 DECL_ARGUMENTS (fndecl) = getdecls ();
11380 DECL_ARGUMENTS (fndecl) = NULL_TREE;
11382 /* Now store the final chain of decls for the arguments
11383 as the decl-chain of the current lexical scope.
11384 Put the enumerators in as well, at the front so that
11385 DECL_ARGUMENTS is not modified. */
11386 current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));
11388 if (use_eh_spec_block (current_function_decl))
11389 current_eh_spec_block = begin_eh_spec_block ();
11393 /* We have finished doing semantic analysis on DECL, but have not yet
11394 generated RTL for its body. Save away our current state, so that
11395 when we want to generate RTL later we know what to do. */
11398 save_function_data (tree decl)
11400 struct language_function *f;
11402 /* Save the language-specific per-function data so that we can
11403 get it back when we really expand this function. */
11404 gcc_assert (!DECL_PENDING_INLINE_P (decl));
11407 f = GGC_NEW (struct language_function);
11408 memcpy (f, cp_function_chain, sizeof (struct language_function));
11409 DECL_SAVED_FUNCTION_DATA (decl) = f;
11411 /* Clear out the bits we don't need. */
11412 f->base.x_stmt_tree.x_cur_stmt_list = NULL_TREE;
11413 f->bindings = NULL;
11414 f->x_local_names = NULL;
11418 /* Set the return value of the constructor (if present). */
11421 finish_constructor_body (void)
11426 if (targetm.cxx.cdtor_returns_this ())
11428 /* Any return from a constructor will end up here. */
11429 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
11431 val = DECL_ARGUMENTS (current_function_decl);
11432 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
11433 DECL_RESULT (current_function_decl), val);
11434 /* Return the address of the object. */
11435 exprstmt = build_stmt (RETURN_EXPR, val);
11436 add_stmt (exprstmt);
11440 /* Do all the processing for the beginning of a destructor; set up the
11441 vtable pointers and cleanups for bases and members. */
11444 begin_destructor_body (void)
11446 tree compound_stmt;
11448 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
11449 issued an error message. We still want to try to process the
11450 body of the function, but initialize_vtbl_ptrs will crash if
11451 TYPE_BINFO is NULL. */
11452 if (COMPLETE_TYPE_P (current_class_type))
11454 compound_stmt = begin_compound_stmt (0);
11455 /* Make all virtual function table pointers in non-virtual base
11456 classes point to CURRENT_CLASS_TYPE's virtual function
11458 initialize_vtbl_ptrs (current_class_ptr);
11459 finish_compound_stmt (compound_stmt);
11461 /* And insert cleanups for our bases and members so that they
11462 will be properly destroyed if we throw. */
11463 push_base_cleanups ();
11467 /* At the end of every destructor we generate code to delete the object if
11468 necessary. Do that now. */
11471 finish_destructor_body (void)
11475 /* Any return from a destructor will end up here; that way all base
11476 and member cleanups will be run when the function returns. */
11477 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
11479 /* In a virtual destructor, we must call delete. */
11480 if (DECL_VIRTUAL_P (current_function_decl))
11483 tree virtual_size = cxx_sizeof (current_class_type);
11487 At the point of definition of a virtual destructor (including
11488 an implicit definition), non-placement operator delete shall
11489 be looked up in the scope of the destructor's class and if
11490 found shall be accessible and unambiguous. */
11491 exprstmt = build_op_delete_call(DELETE_EXPR, current_class_ptr,
11493 /*global_p=*/false,
11494 /*placement=*/NULL_TREE,
11495 /*alloc_fn=*/NULL_TREE);
11497 if_stmt = begin_if_stmt ();
11498 finish_if_stmt_cond (build2 (BIT_AND_EXPR, integer_type_node,
11499 current_in_charge_parm,
11502 finish_expr_stmt (exprstmt);
11503 finish_then_clause (if_stmt);
11504 finish_if_stmt (if_stmt);
11507 if (targetm.cxx.cdtor_returns_this ())
11511 val = DECL_ARGUMENTS (current_function_decl);
11512 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
11513 DECL_RESULT (current_function_decl), val);
11514 /* Return the address of the object. */
11515 exprstmt = build_stmt (RETURN_EXPR, val);
11516 add_stmt (exprstmt);
11520 /* Do the necessary processing for the beginning of a function body, which
11521 in this case includes member-initializers, but not the catch clauses of
11522 a function-try-block. Currently, this means opening a binding level
11523 for the member-initializers (in a ctor) and member cleanups (in a dtor). */
11526 begin_function_body (void)
11530 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
11533 if (processing_template_decl)
11534 /* Do nothing now. */;
11536 /* Always keep the BLOCK node associated with the outermost pair of
11537 curly braces of a function. These are needed for correct
11538 operation of dwarfout.c. */
11539 keep_next_level (true);
11541 stmt = begin_compound_stmt (BCS_FN_BODY);
11543 if (processing_template_decl)
11544 /* Do nothing now. */;
11545 else if (DECL_DESTRUCTOR_P (current_function_decl))
11546 begin_destructor_body ();
11551 /* Do the processing for the end of a function body. Currently, this means
11552 closing out the cleanups for fully-constructed bases and members, and in
11553 the case of the destructor, deleting the object if desired. Again, this
11554 is only meaningful for [cd]tors, since they are the only functions where
11555 there is a significant distinction between the main body and any
11556 function catch clauses. Handling, say, main() return semantics here
11557 would be wrong, as flowing off the end of a function catch clause for
11558 main() would also need to return 0. */
11561 finish_function_body (tree compstmt)
11563 if (compstmt == NULL_TREE)
11566 /* Close the block. */
11567 finish_compound_stmt (compstmt);
11569 if (processing_template_decl)
11570 /* Do nothing now. */;
11571 else if (DECL_CONSTRUCTOR_P (current_function_decl))
11572 finish_constructor_body ();
11573 else if (DECL_DESTRUCTOR_P (current_function_decl))
11574 finish_destructor_body ();
11577 /* Given a function, returns the BLOCK corresponding to the outermost level
11578 of curly braces, skipping the artificial block created for constructor
11582 outer_curly_brace_block (tree fndecl)
11584 tree block = BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl));
11585 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
11586 /* Skip the artificial function body block. */
11587 block = BLOCK_SUBBLOCKS (block);
11591 /* Finish up a function declaration and compile that function
11592 all the way to assembler language output. The free the storage
11593 for the function definition.
11595 FLAGS is a bitwise or of the following values:
11597 We just finished processing the body of an in-class inline
11598 function definition. (This processing will have taken place
11599 after the class definition is complete.) */
11602 finish_function (int flags)
11604 tree fndecl = current_function_decl;
11605 tree fntype, ctype = NULL_TREE;
11606 int inclass_inline = (flags & 2) != 0;
11609 /* When we get some parse errors, we can end up without a
11610 current_function_decl, so cope. */
11611 if (fndecl == NULL_TREE)
11612 return error_mark_node;
11614 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
11615 && DECL_VIRTUAL_P (fndecl)
11616 && !processing_template_decl)
11618 tree fnclass = DECL_CONTEXT (fndecl);
11619 if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
11620 keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
11623 nested = function_depth > 1;
11624 fntype = TREE_TYPE (fndecl);
11626 /* TREE_READONLY (fndecl) = 1;
11627 This caused &foo to be of type ptr-to-const-function
11628 which then got a warning when stored in a ptr-to-function variable. */
11630 gcc_assert (building_stmt_tree ());
11631 /* The current function is being defined, so its DECL_INITIAL should
11632 be set, and unless there's a multiple definition, it should be
11633 error_mark_node. */
11634 gcc_assert (DECL_INITIAL (fndecl) == error_mark_node);
11636 /* For a cloned function, we've already got all the code we need;
11637 there's no need to add any extra bits. */
11638 if (!DECL_CLONED_FUNCTION_P (fndecl))
11640 if (DECL_MAIN_P (current_function_decl))
11644 /* Make it so that `main' always returns 0 by default (or
11647 stmt = finish_return_stmt (integer_one_node);
11649 stmt = finish_return_stmt (integer_zero_node);
11651 /* Hack. We don't want the middle-end to warn that this
11652 return is unreachable, so put the statement on the
11654 #ifdef USE_MAPPED_LOCATION
11656 location_t linezero = linemap_line_start (line_table, 0, 1);
11657 SET_EXPR_LOCATION (stmt, linezero);
11660 annotate_with_file_line (stmt, input_filename, 0);
11664 if (use_eh_spec_block (current_function_decl))
11665 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
11666 (TREE_TYPE (current_function_decl)),
11667 current_eh_spec_block);
11670 /* If we're saving up tree structure, tie off the function now. */
11671 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
11673 finish_fname_decls ();
11675 /* If this function can't throw any exceptions, remember that. */
11676 if (!processing_template_decl
11677 && !cp_function_chain->can_throw
11678 && !flag_non_call_exceptions
11679 && !DECL_REPLACEABLE_P (fndecl))
11680 TREE_NOTHROW (fndecl) = 1;
11682 /* This must come after expand_function_end because cleanups might
11683 have declarations (from inline functions) that need to go into
11684 this function's blocks. */
11686 /* If the current binding level isn't the outermost binding level
11687 for this function, either there is a bug, or we have experienced
11688 syntax errors and the statement tree is malformed. */
11689 if (current_binding_level->kind != sk_function_parms)
11691 /* Make sure we have already experienced errors. */
11692 gcc_assert (errorcount);
11694 /* Throw away the broken statement tree and extra binding
11696 DECL_SAVED_TREE (fndecl) = alloc_stmt_list ();
11698 while (current_binding_level->kind != sk_function_parms)
11700 if (current_binding_level->kind == sk_class)
11701 pop_nested_class ();
11703 poplevel (0, 0, 0);
11706 poplevel (1, 0, 1);
11708 /* Statements should always be full-expressions at the outermost set
11709 of curly braces for a function. */
11710 gcc_assert (stmts_are_full_exprs_p ());
11712 /* Set up the named return value optimization, if we can. Candidate
11713 variables are selected in check_return_expr. */
11714 if (current_function_return_value)
11716 tree r = current_function_return_value;
11719 if (r != error_mark_node
11720 /* This is only worth doing for fns that return in memory--and
11721 simpler, since we don't have to worry about promoted modes. */
11722 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
11723 /* Only allow this for variables declared in the outer scope of
11724 the function so we know that their lifetime always ends with a
11725 return; see g++.dg/opt/nrv6.C. We could be more flexible if
11726 we were to do this optimization in tree-ssa. */
11727 && (outer = outer_curly_brace_block (fndecl))
11728 && chain_member (r, BLOCK_VARS (outer)))
11729 finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));
11731 current_function_return_value = NULL_TREE;
11734 /* Remember that we were in class scope. */
11735 if (current_class_name)
11736 ctype = current_class_type;
11738 /* Must mark the RESULT_DECL as being in this function. */
11739 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
11741 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
11742 to the FUNCTION_DECL node itself. */
11743 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
11745 /* Save away current state, if appropriate. */
11746 if (!processing_template_decl)
11747 save_function_data (fndecl);
11749 /* Complain if there's just no return statement. */
11750 if (warn_return_type
11751 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
11752 && !dependent_type_p (TREE_TYPE (fntype))
11753 && !current_function_returns_value && !current_function_returns_null
11754 /* Don't complain if we abort or throw. */
11755 && !current_function_returns_abnormally
11756 && !DECL_NAME (DECL_RESULT (fndecl))
11757 /* Normally, with -Wreturn-type, flow will complain. Unless we're an
11758 inline function, as we might never be compiled separately. */
11759 && (DECL_INLINE (fndecl) || processing_template_decl)
11760 /* Structor return values (if any) are set by the compiler. */
11761 && !DECL_CONSTRUCTOR_P (fndecl)
11762 && !DECL_DESTRUCTOR_P (fndecl))
11763 warning (OPT_Wreturn_type, "no return statement in function returning non-void");
11765 /* Store the end of the function, so that we get good line number
11766 info for the epilogue. */
11767 cfun->function_end_locus = input_location;
11769 /* Genericize before inlining. */
11770 if (!processing_template_decl)
11772 struct language_function *f = DECL_SAVED_FUNCTION_DATA (fndecl);
11773 cp_genericize (fndecl);
11774 /* Clear out the bits we don't need. */
11775 f->x_current_class_ptr = NULL;
11776 f->x_current_class_ref = NULL;
11777 f->x_eh_spec_block = NULL;
11778 f->x_in_charge_parm = NULL;
11779 f->x_vtt_parm = NULL;
11780 f->x_return_value = NULL;
11781 f->bindings = NULL;
11782 f->extern_decl_map = NULL;
11784 /* Handle attribute((warn_unused_result)). Relies on gimple input. */
11785 c_warn_unused_result (&DECL_SAVED_TREE (fndecl));
11787 /* Clear out the bits we don't need. */
11788 local_names = NULL;
11790 /* We're leaving the context of this function, so zap cfun. It's still in
11791 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
11793 current_function_decl = NULL;
11795 /* If this is an in-class inline definition, we may have to pop the
11796 bindings for the template parameters that we added in
11797 maybe_begin_member_template_processing when start_function was
11799 if (inclass_inline)
11800 maybe_end_member_template_processing ();
11802 /* Leave the scope of the class. */
11804 pop_nested_class ();
11810 /* Let the error reporting routines know that we're outside a
11811 function. For a nested function, this value is used in
11812 cxx_pop_function_context and then reset via pop_function_context. */
11813 current_function_decl = NULL_TREE;
11818 /* Create the FUNCTION_DECL for a function definition.
11819 DECLSPECS and DECLARATOR are the parts of the declaration;
11820 they describe the return type and the name of the function,
11821 but twisted together in a fashion that parallels the syntax of C.
11823 This function creates a binding context for the function body
11824 as well as setting up the FUNCTION_DECL in current_function_decl.
11826 Returns a FUNCTION_DECL on success.
11828 If the DECLARATOR is not suitable for a function (it defines a datum
11829 instead), we return 0, which tells yyparse to report a parse error.
11831 May return void_type_node indicating that this method is actually
11832 a friend. See grokfield for more details.
11834 Came here with a `.pushlevel' .
11836 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
11837 CHANGES TO CODE IN `grokfield'. */
11840 start_method (cp_decl_specifier_seq *declspecs,
11841 const cp_declarator *declarator, tree attrlist)
11843 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
11846 if (fndecl == error_mark_node)
11847 return error_mark_node;
11849 if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
11851 error ("invalid member function declaration");
11852 return error_mark_node;
11856 cplus_decl_attributes (&fndecl, attrlist, 0);
11858 /* Pass friends other than inline friend functions back. */
11859 if (fndecl == void_type_node)
11862 if (DECL_IN_AGGR_P (fndecl))
11864 if (DECL_CONTEXT (fndecl)
11865 && TREE_CODE (DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
11866 error ("%qD is already defined in class %qT", fndecl,
11867 DECL_CONTEXT (fndecl));
11868 return error_mark_node;
11871 check_template_shadow (fndecl);
11873 DECL_DECLARED_INLINE_P (fndecl) = 1;
11874 if (flag_default_inline)
11875 DECL_INLINE (fndecl) = 1;
11877 /* We process method specializations in finish_struct_1. */
11878 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
11880 fndecl = push_template_decl (fndecl);
11881 if (fndecl == error_mark_node)
11885 if (! DECL_FRIEND_P (fndecl))
11887 if (TREE_CHAIN (fndecl))
11889 fndecl = copy_node (fndecl);
11890 TREE_CHAIN (fndecl) = NULL_TREE;
11894 finish_decl (fndecl, NULL_TREE, NULL_TREE);
11896 /* Make a place for the parms. */
11897 begin_scope (sk_function_parms, fndecl);
11899 DECL_IN_AGGR_P (fndecl) = 1;
11903 /* Go through the motions of finishing a function definition.
11904 We don't compile this method until after the whole class has
11907 FINISH_METHOD must return something that looks as though it
11908 came from GROKFIELD (since we are defining a method, after all).
11910 This is called after parsing the body of the function definition.
11911 STMTS is the chain of statements that makes up the function body.
11913 DECL is the ..._DECL that `start_method' provided. */
11916 finish_method (tree decl)
11918 tree fndecl = decl;
11923 if (decl == void_type_node)
11926 old_initial = DECL_INITIAL (fndecl);
11928 /* Undo the level for the parms (from start_method).
11929 This is like poplevel, but it causes nothing to be
11930 saved. Saving information here confuses symbol-table
11931 output routines. Besides, this information will
11932 be correctly output when this method is actually
11935 /* Clear out the meanings of the local variables of this level;
11936 also record in each decl which block it belongs to. */
11938 for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
11940 if (DECL_NAME (link) != NULL_TREE)
11941 pop_binding (DECL_NAME (link), link);
11942 gcc_assert (TREE_CODE (link) != FUNCTION_DECL);
11943 DECL_CONTEXT (link) = NULL_TREE;
11946 poplevel (0, 0, 0);
11948 DECL_INITIAL (fndecl) = old_initial;
11950 /* We used to check if the context of FNDECL was different from
11951 current_class_type as another way to get inside here. This didn't work
11952 for String.cc in libg++. */
11953 if (DECL_FRIEND_P (fndecl))
11955 VEC_safe_push (tree, gc, CLASSTYPE_INLINE_FRIENDS (current_class_type),
11957 decl = void_type_node;
11964 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
11965 we can lay it out later, when and if its type becomes complete. */
11968 maybe_register_incomplete_var (tree var)
11970 gcc_assert (TREE_CODE (var) == VAR_DECL);
11972 /* Keep track of variables with incomplete types. */
11973 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
11974 && DECL_EXTERNAL (var))
11976 tree inner_type = TREE_TYPE (var);
11978 while (TREE_CODE (inner_type) == ARRAY_TYPE)
11979 inner_type = TREE_TYPE (inner_type);
11980 inner_type = TYPE_MAIN_VARIANT (inner_type);
11982 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
11983 /* RTTI TD entries are created while defining the type_info. */
11984 || (TYPE_LANG_SPECIFIC (inner_type)
11985 && TYPE_BEING_DEFINED (inner_type)))
11986 incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
11990 /* Called when a class type (given by TYPE) is defined. If there are
11991 any existing VAR_DECLs whose type hsa been completed by this
11992 declaration, update them now. */
11995 complete_vars (tree type)
11997 tree *list = &incomplete_vars;
11999 gcc_assert (CLASS_TYPE_P (type));
12002 if (same_type_p (type, TREE_PURPOSE (*list)))
12004 tree var = TREE_VALUE (*list);
12005 tree type = TREE_TYPE (var);
12006 /* Complete the type of the variable. The VAR_DECL itself
12007 will be laid out in expand_expr. */
12008 complete_type (type);
12009 cp_apply_type_quals_to_decl (cp_type_quals (type), var);
12010 /* Remove this entry from the list. */
12011 *list = TREE_CHAIN (*list);
12014 list = &TREE_CHAIN (*list);
12017 /* Check for pending declarations which may have abstract type. */
12018 complete_type_check_abstract (type);
12021 /* If DECL is of a type which needs a cleanup, build and return an
12022 expression to perform that cleanup here. Return NULL_TREE if no
12023 cleanup need be done. */
12026 cxx_maybe_build_cleanup (tree decl)
12032 /* Assume no cleanup is required. */
12033 cleanup = NULL_TREE;
12035 if (error_operand_p (decl))
12038 /* Handle "__attribute__((cleanup))". We run the cleanup function
12039 before the destructor since the destructor is what actually
12040 terminates the lifetime of the object. */
12041 attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
12048 /* Get the name specified by the user for the cleanup function. */
12049 id = TREE_VALUE (TREE_VALUE (attr));
12050 /* Look up the name to find the cleanup function to call. It is
12051 important to use lookup_name here because that is what is
12052 used in c-common.c:handle_cleanup_attribute when performing
12053 initial checks on the attribute. Note that those checks
12054 include ensuring that the function found is not an overloaded
12055 function, or an object with an overloaded call operator,
12056 etc.; we can rely on the fact that the functionfound is an
12057 ordinary FUNCTION_DECL. */
12058 fn = lookup_name (id);
12059 arg = build_address (decl);
12061 cleanup = build_function_call (fn, build_tree_list (NULL_TREE,
12064 /* Handle ordinary C++ destructors. */
12065 type = TREE_TYPE (decl);
12066 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
12068 int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
12069 bool has_vbases = (TREE_CODE (type) == RECORD_TYPE
12070 && CLASSTYPE_VBASECLASSES (type));
12074 if (TREE_CODE (type) == ARRAY_TYPE)
12078 cxx_mark_addressable (decl);
12079 addr = build_unary_op (ADDR_EXPR, decl, 0);
12082 /* Optimize for space over speed here. */
12083 if (!has_vbases || flag_expensive_optimizations)
12084 flags |= LOOKUP_NONVIRTUAL;
12086 call = build_delete (TREE_TYPE (addr), addr,
12087 sfk_complete_destructor, flags, 0);
12089 cleanup = build_compound_expr (cleanup, call);
12097 /* When a stmt has been parsed, this function is called. */
12104 /* DECL was originally constructed as a non-static member function,
12105 but turned out to be static. Update it accordingly. */
12108 revert_static_member_fn (tree decl)
12111 tree function = TREE_TYPE (decl);
12112 tree args = TYPE_ARG_TYPES (function);
12114 if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
12115 != TYPE_UNQUALIFIED)
12116 error ("static member function %q#D declared with type qualifiers", decl);
12118 args = TREE_CHAIN (args);
12119 tmp = build_function_type (TREE_TYPE (function), args);
12120 tmp = build_qualified_type (tmp, cp_type_quals (function));
12121 tmp = build_exception_variant (tmp,
12122 TYPE_RAISES_EXCEPTIONS (function));
12123 TREE_TYPE (decl) = tmp;
12124 if (DECL_ARGUMENTS (decl))
12125 DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
12126 DECL_STATIC_FUNCTION_P (decl) = 1;
12129 /* Initialize the variables used during compilation of a C++
12133 cxx_push_function_context (struct function * f)
12135 struct language_function *p = GGC_CNEW (struct language_function);
12138 /* Whenever we start a new function, we destroy temporaries in the
12140 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
12146 if (DECL_SAVED_FUNCTION_DATA (fn))
12148 /* If we already parsed this function, and we're just expanding it
12149 now, restore saved state. */
12150 *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (fn);
12152 /* We don't need the saved data anymore. Unless this is an inline
12153 function; we need the named return value info for
12154 declare_return_variable. */
12155 if (! DECL_INLINE (fn))
12156 DECL_SAVED_FUNCTION_DATA (fn) = NULL;
12161 /* Free the language-specific parts of F, now that we've finished
12162 compiling the function. */
12165 cxx_pop_function_context (struct function * f)
12170 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
12171 one of the language-independent trees. */
12173 enum cp_tree_node_structure_enum
12174 cp_tree_node_structure (union lang_tree_node * t)
12176 switch (TREE_CODE (&t->generic))
12178 case DEFAULT_ARG: return TS_CP_DEFAULT_ARG;
12179 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER;
12180 case OVERLOAD: return TS_CP_OVERLOAD;
12181 case TEMPLATE_PARM_INDEX: return TS_CP_TPI;
12182 case PTRMEM_CST: return TS_CP_PTRMEM;
12183 case BASELINK: return TS_CP_BASELINK;
12184 case STATIC_ASSERT: return TS_CP_STATIC_ASSERT;
12185 case ARGUMENT_PACK_SELECT: return TS_CP_ARGUMENT_PACK_SELECT;
12186 case TRAIT_EXPR: return TS_CP_TRAIT_EXPR;
12187 default: return TS_CP_GENERIC;
12191 /* Build the void_list_node (void_type_node having been created). */
12193 build_void_list_node (void)
12195 tree t = build_tree_list (NULL_TREE, void_type_node);
12200 cp_missing_noreturn_ok_p (tree decl)
12202 /* A missing noreturn is ok for the `main' function. */
12203 return DECL_MAIN_P (decl);
12206 /* Return the COMDAT group into which DECL should be placed. */
12209 cxx_comdat_group (tree decl)
12213 /* Virtual tables, construction virtual tables, and virtual table
12214 tables all go in a single COMDAT group, named after the primary
12216 if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
12217 name = DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl)));
12218 /* For all other DECLs, the COMDAT group is the mangled name of the
12219 declaration itself. */
12222 while (DECL_THUNK_P (decl))
12224 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
12225 into the same section as the target function. In that case
12226 we must return target's name. */
12227 tree target = THUNK_TARGET (decl);
12228 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target)
12229 && DECL_SECTION_NAME (target) != NULL
12230 && DECL_ONE_ONLY (target))
12235 name = DECL_ASSEMBLER_NAME (decl);
12238 return IDENTIFIER_POINTER (name);
12241 #include "gt-cp-decl.h"