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) || !TREE_PUBLIC (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);
7515 if (TREE_DEPRECATED (type)
7516 && DECL_ARTIFICIAL (typedef_decl)
7517 && deprecated_state != DEPRECATED_SUPPRESS)
7518 warn_deprecated_use (type);
7520 /* No type at all: default to `int', and set DEFAULTED_INT
7521 because it was not a user-defined typedef. */
7522 if (type == NULL_TREE && (signed_p || unsigned_p || long_p || short_p))
7524 /* These imply 'int'. */
7525 type = integer_type_node;
7529 explicit_int = declspecs->explicit_int_p;
7530 explicit_char = declspecs->explicit_char_p;
7533 /* See the code below that used this. */
7535 decl_attr = DECL_ATTRIBUTES (typedef_decl);
7537 typedef_type = type;
7540 if (sfk != sfk_conversion)
7541 ctor_return_type = ctype;
7543 if (sfk != sfk_none)
7544 type = check_special_function_return_type (sfk, type,
7546 else if (type == NULL_TREE)
7552 /* We handle `main' specially here, because 'main () { }' is so
7553 common. With no options, it is allowed. With -Wreturn-type,
7554 it is a warning. It is only an error with -pedantic-errors. */
7555 is_main = (funcdef_flag
7556 && dname && MAIN_NAME_P (dname)
7557 && ctype == NULL_TREE
7558 && in_namespace == NULL_TREE
7559 && current_namespace == global_namespace);
7561 if (type_was_error_mark_node)
7562 /* We've already issued an error, don't complain more. */;
7563 else if (in_system_header || flag_ms_extensions)
7564 /* Allow it, sigh. */;
7565 else if (pedantic || ! is_main)
7566 pedwarn ("ISO C++ forbids declaration of %qs with no type", name);
7568 warning (OPT_Wreturn_type,
7569 "ISO C++ forbids declaration of %qs with no type", name);
7571 type = integer_type_node;
7576 /* Now process the modifiers that were specified
7577 and check for invalid combinations. */
7579 /* Long double is a special combination. */
7580 if (long_p && !longlong && TYPE_MAIN_VARIANT (type) == double_type_node)
7583 type = build_qualified_type (long_double_type_node,
7584 cp_type_quals (type));
7587 /* Check all other uses of type modifiers. */
7589 if (unsigned_p || signed_p || long_p || short_p)
7593 if ((signed_p || unsigned_p) && TREE_CODE (type) != INTEGER_TYPE)
7594 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
7595 else if (signed_p && unsigned_p)
7596 error ("%<signed%> and %<unsigned%> specified together for %qs", name);
7597 else if (longlong && TREE_CODE (type) != INTEGER_TYPE)
7598 error ("%<long long%> invalid for %qs", name);
7599 else if (long_p && TREE_CODE (type) == REAL_TYPE)
7600 error ("%<long%> invalid for %qs", name);
7601 else if (short_p && TREE_CODE (type) == REAL_TYPE)
7602 error ("%<short%> invalid for %qs", name);
7603 else if ((long_p || short_p) && TREE_CODE (type) != INTEGER_TYPE)
7604 error ("%<long%> or %<short%> invalid for %qs", name);
7605 else if ((long_p || short_p) && explicit_char)
7606 error ("%<long%> or %<short%> specified with char for %qs", name);
7607 else if (long_p && short_p)
7608 error ("%<long%> and %<short%> specified together for %qs", name);
7612 if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
7614 pedwarn ("long, short, signed or unsigned used invalidly for %qs",
7616 if (flag_pedantic_errors)
7621 /* Discard the type modifiers if they are invalid. */
7632 /* Decide whether an integer type is signed or not.
7633 Optionally treat bitfields as signed by default. */
7637 It is implementation-defined whether a plain (neither
7638 explicitly signed or unsigned) char, short, int, or long
7639 bit-field is signed or unsigned.
7641 Naturally, we extend this to long long as well. Note that
7642 this does not include wchar_t. */
7643 || (bitfield && !flag_signed_bitfields
7645 /* A typedef for plain `int' without `signed' can be
7646 controlled just like plain `int', but a typedef for
7647 `signed int' cannot be so controlled. */
7649 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
7650 && TREE_CODE (type) == INTEGER_TYPE
7651 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
7654 type = long_long_unsigned_type_node;
7656 type = long_unsigned_type_node;
7658 type = short_unsigned_type_node;
7659 else if (type == char_type_node)
7660 type = unsigned_char_type_node;
7661 else if (typedef_decl)
7662 type = unsigned_type_for (type);
7664 type = unsigned_type_node;
7666 else if (signed_p && type == char_type_node)
7667 type = signed_char_type_node;
7669 type = long_long_integer_type_node;
7671 type = long_integer_type_node;
7673 type = short_integer_type_node;
7675 if (declspecs->specs[(int)ds_complex])
7677 if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
7678 error ("complex invalid for %qs", name);
7679 /* If we just have "complex", it is equivalent to
7680 "complex double", but if any modifiers at all are specified it is
7681 the complex form of TYPE. E.g, "complex short" is
7682 "complex short int". */
7684 else if (defaulted_int && ! longlong
7685 && ! (long_p || short_p || signed_p || unsigned_p))
7686 type = complex_double_type_node;
7687 else if (type == integer_type_node)
7688 type = complex_integer_type_node;
7689 else if (type == float_type_node)
7690 type = complex_float_type_node;
7691 else if (type == double_type_node)
7692 type = complex_double_type_node;
7693 else if (type == long_double_type_node)
7694 type = complex_long_double_type_node;
7696 type = build_complex_type (type);
7699 type_quals = TYPE_UNQUALIFIED;
7700 if (declspecs->specs[(int)ds_const])
7701 type_quals |= TYPE_QUAL_CONST;
7702 if (declspecs->specs[(int)ds_volatile])
7703 type_quals |= TYPE_QUAL_VOLATILE;
7704 if (declspecs->specs[(int)ds_restrict])
7705 type_quals |= TYPE_QUAL_RESTRICT;
7706 if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
7707 error ("qualifiers are not allowed on declaration of %<operator %T%>",
7710 if (TREE_CODE (type) == FUNCTION_TYPE
7711 && type_quals != TYPE_UNQUALIFIED)
7713 /* This was an error in C++98 (cv-qualifiers cannot be added to
7714 a function type), but DR 295 makes the code well-formed by
7715 dropping the extra qualifiers. */
7718 tree bad_type = build_qualified_type (type, type_quals);
7719 pedwarn ("ignoring %qV qualifiers added to function type %qT",
7722 type_quals = TYPE_UNQUALIFIED;
7724 type_quals |= cp_type_quals (type);
7725 type = cp_build_qualified_type_real
7726 (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
7727 ? tf_ignore_bad_quals : 0) | tf_warning_or_error));
7728 /* We might have ignored or rejected some of the qualifiers. */
7729 type_quals = cp_type_quals (type);
7732 inlinep = !! declspecs->specs[(int)ds_inline];
7733 virtualp = !! declspecs->specs[(int)ds_virtual];
7734 explicitp = !! declspecs->specs[(int)ds_explicit];
7736 storage_class = declspecs->storage_class;
7737 if (storage_class == sc_static)
7738 staticp = 1 + (decl_context == FIELD);
7740 if (virtualp && staticp == 2)
7742 error ("member %qD cannot be declared both virtual and static", dname);
7743 storage_class = sc_none;
7746 friendp = !! declspecs->specs[(int)ds_friend];
7748 if (dependent_name && !friendp)
7750 error ("%<%T::%D%> is not a valid declarator", ctype, dependent_name);
7751 return error_mark_node;
7754 /* Issue errors about use of storage classes for parameters. */
7755 if (decl_context == PARM)
7757 if (declspecs->specs[(int)ds_typedef])
7759 error ("typedef declaration invalid in parameter declaration");
7760 return error_mark_node;
7762 else if (storage_class == sc_static
7763 || storage_class == sc_extern
7765 error ("storage class specifiers invalid in parameter declarations");
7768 /* Give error if `virtual' is used outside of class declaration. */
7770 && (current_class_name == NULL_TREE || decl_context != FIELD))
7772 error ("virtual outside class declaration");
7776 /* Static anonymous unions are dealt with here. */
7777 if (staticp && decl_context == TYPENAME
7779 && ANON_AGGR_TYPE_P (declspecs->type))
7780 decl_context = FIELD;
7782 /* Warn about storage classes that are invalid for certain
7783 kinds of declarations (parameters, typenames, etc.). */
7786 && storage_class != sc_extern
7787 && storage_class != sc_static)
7788 || declspecs->specs[(int)ds_typedef]))
7790 error ("multiple storage classes in declaration of %qs", name);
7793 if (declspecs->conflicting_specifiers_p)
7795 error ("conflicting specifiers in declaration of %qs", name);
7796 storage_class = sc_none;
7798 else if (decl_context != NORMAL
7799 && ((storage_class != sc_none
7800 && storage_class != sc_mutable)
7803 if ((decl_context == PARM || decl_context == CATCHPARM)
7804 && (storage_class == sc_register
7805 || storage_class == sc_auto))
7807 else if (declspecs->specs[(int)ds_typedef])
7809 else if (decl_context == FIELD
7810 /* C++ allows static class elements. */
7811 && storage_class == sc_static)
7812 /* C++ also allows inlines and signed and unsigned elements,
7813 but in those cases we don't come in here. */
7817 if (decl_context == FIELD)
7818 error ("storage class specified for %qs", name);
7821 if (decl_context == PARM || decl_context == CATCHPARM)
7822 error ("storage class specified for parameter %qs", name);
7824 error ("storage class specified for typename");
7826 if (storage_class == sc_register
7827 || storage_class == sc_auto
7828 || storage_class == sc_extern
7830 storage_class = sc_none;
7833 else if (storage_class == sc_extern && initialized
7836 if (toplevel_bindings_p ())
7838 /* It's common practice (and completely valid) to have a const
7839 be initialized and declared extern. */
7840 if (!(type_quals & TYPE_QUAL_CONST))
7841 warning (0, "%qs initialized and declared %<extern%>", name);
7844 error ("%qs has both %<extern%> and initializer", name);
7846 else if (storage_class == sc_extern && funcdef_flag
7847 && ! toplevel_bindings_p ())
7848 error ("nested function %qs declared %<extern%>", name);
7849 else if (toplevel_bindings_p ())
7851 if (storage_class == sc_auto)
7852 error ("top-level declaration of %qs specifies %<auto%>", name);
7855 && storage_class != sc_extern
7856 && storage_class != sc_static)
7858 error ("function-scope %qs implicitly auto and declared %<__thread%>",
7863 if (storage_class && friendp)
7864 error ("storage class specifiers invalid in friend function declarations");
7867 unqualified_id = NULL_TREE;
7870 unqualified_id = id_declarator->u.id.unqualified_name;
7871 switch (TREE_CODE (unqualified_id))
7875 = constructor_name (TREE_OPERAND (unqualified_id, 0));
7878 case IDENTIFIER_NODE:
7879 case TEMPLATE_ID_EXPR:
7887 /* Determine the type of the entity declared by recurring on the
7889 for (; declarator; declarator = declarator->declarator)
7891 const cp_declarator *inner_declarator;
7894 if (type == error_mark_node)
7895 return error_mark_node;
7897 attrs = declarator->attributes;
7903 if (declarator == NULL || declarator->kind == cdk_id)
7904 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
7905 if (declarator->kind == cdk_function)
7906 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
7907 if (declarator->kind == cdk_array)
7908 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
7909 returned_attrs = decl_attributes (&type,
7910 chainon (returned_attrs, attrs),
7914 if (declarator->kind == cdk_id)
7917 inner_declarator = declarator->declarator;
7919 switch (declarator->kind)
7922 type = create_array_type_for_decl (dname, type,
7923 declarator->u.array.bounds);
7931 /* Declaring a function type.
7932 Make sure we have a valid type for the function to return. */
7934 if (type_quals != TYPE_UNQUALIFIED)
7936 if (SCALAR_TYPE_P (type) || VOID_TYPE_P (type))
7937 warning (OPT_Wreturn_type,
7938 "type qualifiers ignored on function return type");
7939 /* We now know that the TYPE_QUALS don't apply to the
7940 decl, but to its return type. */
7941 type_quals = TYPE_UNQUALIFIED;
7942 set_no_warning = true;
7945 /* Warn about some types functions can't return. */
7947 if (TREE_CODE (type) == FUNCTION_TYPE)
7949 error ("%qs declared as function returning a function", name);
7950 type = integer_type_node;
7952 if (TREE_CODE (type) == ARRAY_TYPE)
7954 error ("%qs declared as function returning an array", name);
7955 type = integer_type_node;
7958 /* Pick up type qualifiers which should be applied to `this'. */
7959 memfn_quals = declarator->u.function.qualifiers;
7961 /* Pick up the exception specifications. */
7962 raises = declarator->u.function.exception_specification;
7964 /* Say it's a definition only for the CALL_EXPR
7965 closest to the identifier. */
7966 funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id;
7968 if (ctype == NULL_TREE
7969 && decl_context == FIELD
7971 && (friendp == 0 || dname == current_class_name))
7972 ctype = current_class_type;
7974 if (ctype && (sfk == sfk_constructor
7975 || sfk == sfk_destructor))
7977 /* We are within a class's scope. If our declarator name
7978 is the same as the class name, and we are defining
7979 a function, then it is a constructor/destructor, and
7980 therefore returns a void type. */
7982 /* ISO C++ 12.4/2. A destructor may not be declared
7983 const or volatile. A destructor may not be
7986 ISO C++ 12.1. A constructor may not be declared
7987 const or volatile. A constructor may not be
7988 virtual. A constructor may not be static. */
7990 error ((flags == DTOR_FLAG)
7991 ? "destructor cannot be static member function"
7992 : "constructor cannot be static member function");
7995 error ((flags == DTOR_FLAG)
7996 ? "destructors may not be cv-qualified"
7997 : "constructors may not be cv-qualified");
7998 memfn_quals = TYPE_UNQUALIFIED;
8001 if (decl_context == FIELD
8002 && !member_function_or_else (ctype,
8005 return error_mark_node;
8007 if (flags != DTOR_FLAG)
8009 /* It's a constructor. */
8014 pedwarn ("constructors cannot be declared virtual");
8017 if (decl_context == FIELD
8018 && sfk != sfk_constructor)
8019 return error_mark_node;
8021 if (decl_context == FIELD)
8027 error ("can't initialize friend function %qs", name);
8030 /* Cannot be both friend and virtual. */
8031 error ("virtual functions cannot be friends");
8034 if (decl_context == NORMAL)
8035 error ("friend declaration not in class definition");
8036 if (current_function_decl && funcdef_flag)
8037 error ("can't define friend function %qs in a local "
8042 arg_types = grokparms (declarator->u.function.parameters,
8045 if (inner_declarator
8046 && inner_declarator->kind == cdk_id
8047 && inner_declarator->u.id.sfk == sfk_destructor
8048 && arg_types != void_list_node)
8050 error ("destructors may not have parameters");
8051 arg_types = void_list_node;
8055 type = build_function_type (type, arg_types);
8062 /* Filter out pointers-to-references and references-to-references.
8063 We can get these if a TYPE_DECL is used. */
8065 if (TREE_CODE (type) == REFERENCE_TYPE)
8067 if (declarator->kind != cdk_reference)
8069 error ("cannot declare pointer to %q#T", type);
8070 type = TREE_TYPE (type);
8073 /* In C++0x, we allow reference to reference declarations
8074 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
8075 and template type arguments [14.3.1/4 temp.arg.type]. The
8076 check for direct reference to reference declarations, which
8077 are still forbidden, occurs below. Reasoning behind the change
8078 can be found in DR106, DR540, and the rvalue reference
8080 else if (cxx_dialect == cxx98)
8082 error ("cannot declare reference to %q#T", type);
8083 type = TREE_TYPE (type);
8086 else if (VOID_TYPE_P (type))
8088 if (declarator->kind == cdk_reference)
8089 error ("cannot declare reference to %q#T", type);
8090 else if (declarator->kind == cdk_ptrmem)
8091 error ("cannot declare pointer to %q#T member", type);
8094 /* We now know that the TYPE_QUALS don't apply to the decl,
8095 but to the target of the pointer. */
8096 type_quals = TYPE_UNQUALIFIED;
8098 if (declarator->kind == cdk_ptrmem
8099 && (TREE_CODE (type) == FUNCTION_TYPE || memfn_quals))
8101 memfn_quals |= cp_type_quals (type);
8102 type = build_memfn_type (type,
8103 declarator->u.pointer.class_type,
8105 memfn_quals = TYPE_UNQUALIFIED;
8108 if (declarator->kind == cdk_reference)
8110 /* In C++0x, the type we are creating a reference to might be
8111 a typedef which is itself a reference type. In that case,
8112 we follow the reference collapsing rules in
8113 [7.1.3/8 dcl.typedef] to create the final reference type:
8115 "If a typedef TD names a type that is a reference to a type
8116 T, an attempt to create the type 'lvalue reference to cv TD'
8117 creates the type 'lvalue reference to T,' while an attempt
8118 to create the type "rvalue reference to cv TD' creates the
8121 if (!VOID_TYPE_P (type))
8122 type = cp_build_reference_type
8123 ((TREE_CODE (type) == REFERENCE_TYPE
8124 ? TREE_TYPE (type) : type),
8125 (declarator->u.reference.rvalue_ref
8126 && (TREE_CODE(type) != REFERENCE_TYPE
8127 || TYPE_REF_IS_RVALUE (type))));
8129 /* In C++0x, we need this check for direct reference to
8130 reference declarations, which are forbidden by
8131 [8.3.2/5 dcl.ref]. Reference to reference declarations
8132 are only allowed indirectly through typedefs and template
8133 type arguments. Example:
8135 void foo(int & &); // invalid ref-to-ref decl
8137 typedef int & int_ref;
8138 void foo(int_ref &); // valid ref-to-ref decl
8140 if (inner_declarator && inner_declarator->kind == cdk_reference)
8141 error ("cannot declare reference to %q#T, which is not "
8142 "a typedef or a template type argument", type);
8144 else if (TREE_CODE (type) == METHOD_TYPE)
8145 type = build_ptrmemfunc_type (build_pointer_type (type));
8146 else if (declarator->kind == cdk_ptrmem)
8148 gcc_assert (TREE_CODE (declarator->u.pointer.class_type)
8150 if (declarator->u.pointer.class_type == error_mark_node)
8151 /* We will already have complained. */
8152 type = error_mark_node;
8154 type = build_ptrmem_type (declarator->u.pointer.class_type,
8158 type = build_pointer_type (type);
8160 /* Process a list of type modifier keywords (such as
8161 const or volatile) that were given inside the `*' or `&'. */
8163 if (declarator->u.pointer.qualifiers)
8166 = cp_build_qualified_type (type,
8167 declarator->u.pointer.qualifiers);
8168 type_quals = cp_type_quals (type);
8181 if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR
8182 && TREE_CODE (type) != FUNCTION_TYPE
8183 && TREE_CODE (type) != METHOD_TYPE)
8185 error ("template-id %qD used as a declarator",
8187 unqualified_id = dname;
8190 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
8191 qualified with a class-name, turn it into a METHOD_TYPE, unless
8192 we know that the function is static. We take advantage of this
8193 opportunity to do other processing that pertains to entities
8194 explicitly declared to be class members. Note that if DECLARATOR
8195 is non-NULL, we know it is a cdk_id declarator; otherwise, we
8196 would not have exited the loop above. */
8198 && declarator->u.id.qualifying_scope
8199 && TYPE_P (declarator->u.id.qualifying_scope))
8203 ctype = declarator->u.id.qualifying_scope;
8204 ctype = TYPE_MAIN_VARIANT (ctype);
8206 while (t != NULL_TREE && CLASS_TYPE_P (t))
8208 /* You're supposed to have one `template <...>' for every
8209 template class, but you don't need one for a full
8210 specialization. For example:
8212 template <class T> struct S{};
8213 template <> struct S<int> { void f(); };
8214 void S<int>::f () {}
8216 is correct; there shouldn't be a `template <>' for the
8217 definition of `S<int>::f'. */
8218 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t)
8219 && !any_dependent_template_arguments_p (CLASSTYPE_TI_ARGS (t)))
8220 /* T is an explicit (not partial) specialization. All
8221 containing classes must therefore also be explicitly
8224 if ((CLASSTYPE_USE_TEMPLATE (t) || CLASSTYPE_IS_TEMPLATE (t))
8225 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
8226 template_count += 1;
8228 t = TYPE_MAIN_DECL (t);
8229 t = DECL_CONTEXT (t);
8232 if (ctype == current_class_type)
8236 pedwarn ("member functions are implicitly friends of their class");
8240 pedwarn ("extra qualification %<%T::%> on member %qs",
8243 else if (/* If the qualifying type is already complete, then we
8244 can skip the following checks. */
8245 !COMPLETE_TYPE_P (ctype)
8246 && (/* If the function is being defined, then
8247 qualifying type must certainly be complete. */
8249 /* A friend declaration of "T::f" is OK, even if
8250 "T" is a template parameter. But, if this
8251 function is not a friend, the qualifying type
8253 || (!friendp && !CLASS_TYPE_P (ctype))
8254 /* For a declaration, the type need not be
8255 complete, if either it is dependent (since there
8256 is no meaningful definition of complete in that
8257 case) or the qualifying class is currently being
8259 || !(dependent_type_p (ctype)
8260 || currently_open_class (ctype)))
8261 /* Check that the qualifying type is complete. */
8262 && !complete_type_or_else (ctype, NULL_TREE))
8263 return error_mark_node;
8264 else if (TREE_CODE (type) == FUNCTION_TYPE)
8266 tree sname = declarator->u.id.unqualified_name;
8268 if (current_class_type
8269 && (!friendp || funcdef_flag))
8272 ? "cannot define member function %<%T::%s%> within %<%T%>"
8273 : "cannot declare member function %<%T::%s%> within %<%T%>",
8274 ctype, name, current_class_type);
8275 return error_mark_node;
8278 if (TREE_CODE (sname) == IDENTIFIER_NODE
8279 && NEW_DELETE_OPNAME_P (sname))
8280 /* Overloaded operator new and operator delete
8281 are always static functions. */
8284 type = build_memfn_type (type, ctype, memfn_quals);
8286 else if (declspecs->specs[(int)ds_typedef]
8287 && current_class_type)
8289 error ("cannot declare member %<%T::%s%> within %qT",
8290 ctype, name, current_class_type);
8291 return error_mark_node;
8295 /* Now TYPE has the actual type. */
8300 *attrlist = chainon (returned_attrs, *attrlist);
8302 attrlist = &returned_attrs;
8305 /* Handle parameter packs. */
8306 if (parameter_pack_p)
8308 if (decl_context == PARM)
8309 /* Turn the type into a pack expansion.*/
8310 type = make_pack_expansion (type);
8312 error ("non-parameter %qs cannot be a parameter pack", name);
8315 /* Did array size calculations overflow? */
8317 if (TREE_CODE (type) == ARRAY_TYPE
8318 && COMPLETE_TYPE_P (type)
8319 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
8320 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
8322 error ("size of array %qs is too large", name);
8323 /* If we proceed with the array type as it is, we'll eventually
8324 crash in tree_low_cst(). */
8325 type = error_mark_node;
8328 if ((decl_context == FIELD || decl_context == PARM)
8329 && !processing_template_decl
8330 && variably_modified_type_p (type, NULL_TREE))
8332 if (decl_context == FIELD)
8333 error ("data member may not have variably modified type %qT", type);
8335 error ("parameter may not have variably modified type %qT", type);
8336 type = error_mark_node;
8339 if (explicitp == 1 || (explicitp && friendp))
8341 /* [dcl.fct.spec] The explicit specifier shall only be used in
8342 declarations of constructors within a class definition. */
8343 error ("only declarations of constructors can be %<explicit%>");
8347 if (storage_class == sc_mutable)
8349 if (decl_context != FIELD || friendp)
8351 error ("non-member %qs cannot be declared %<mutable%>", name);
8352 storage_class = sc_none;
8354 else if (decl_context == TYPENAME || declspecs->specs[(int)ds_typedef])
8356 error ("non-object member %qs cannot be declared %<mutable%>", name);
8357 storage_class = sc_none;
8359 else if (TREE_CODE (type) == FUNCTION_TYPE
8360 || TREE_CODE (type) == METHOD_TYPE)
8362 error ("function %qs cannot be declared %<mutable%>", name);
8363 storage_class = sc_none;
8367 error ("static %qs cannot be declared %<mutable%>", name);
8368 storage_class = sc_none;
8370 else if (type_quals & TYPE_QUAL_CONST)
8372 error ("const %qs cannot be declared %<mutable%>", name);
8373 storage_class = sc_none;
8377 /* If this is declaring a typedef name, return a TYPE_DECL. */
8378 if (declspecs->specs[(int)ds_typedef] && decl_context != TYPENAME)
8382 /* Note that the grammar rejects storage classes
8383 in typenames, fields or parameters. */
8384 if (current_lang_name == lang_name_java)
8385 TYPE_FOR_JAVA (type) = 1;
8387 /* This declaration:
8389 typedef void f(int) const;
8391 declares a function type which is not a member of any
8392 particular class, but which is cv-qualified; for
8393 example "f S::*" declares a pointer to a const-qualified
8394 member function of S. We record the cv-qualification in the
8396 if (memfn_quals && TREE_CODE (type) == FUNCTION_TYPE)
8398 type = cp_build_qualified_type (type, memfn_quals);
8400 /* We have now dealt with these qualifiers. */
8401 memfn_quals = TYPE_UNQUALIFIED;
8404 if (decl_context == FIELD)
8405 decl = build_lang_decl (TYPE_DECL, unqualified_id, type);
8407 decl = build_decl (TYPE_DECL, unqualified_id, type);
8408 if (id_declarator && declarator->u.id.qualifying_scope)
8409 error ("%Jtypedef name may not be a nested-name-specifier", decl);
8411 if (decl_context != FIELD)
8413 if (!current_function_decl)
8414 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8415 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl)
8416 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
8417 (current_function_decl)))
8418 /* The TYPE_DECL is "abstract" because there will be
8419 clones of this constructor/destructor, and there will
8420 be copies of this TYPE_DECL generated in those
8422 DECL_ABSTRACT (decl) = 1;
8424 else if (constructor_name_p (unqualified_id, current_class_type))
8425 pedwarn ("ISO C++ forbids nested type %qD with same name "
8426 "as enclosing class",
8429 /* If the user declares "typedef struct {...} foo" then the
8430 struct will have an anonymous name. Fill that name in now.
8431 Nothing can refer to it, so nothing needs know about the name
8433 if (type != error_mark_node
8436 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
8437 && TYPE_ANONYMOUS_P (type)
8438 /* Don't do this if there are attributes. */
8439 && (!attrlist || !*attrlist)
8440 && cp_type_quals (type) == TYPE_UNQUALIFIED)
8442 tree oldname = TYPE_NAME (type);
8445 /* Replace the anonymous name with the real name everywhere. */
8446 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
8447 if (TYPE_NAME (t) == oldname)
8448 TYPE_NAME (t) = decl;
8450 if (TYPE_LANG_SPECIFIC (type))
8451 TYPE_WAS_ANONYMOUS (type) = 1;
8453 /* If this is a typedef within a template class, the nested
8454 type is a (non-primary) template. The name for the
8455 template needs updating as well. */
8456 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
8457 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
8458 = TYPE_IDENTIFIER (type);
8460 /* FIXME remangle member functions; member functions of a
8461 type with external linkage have external linkage. */
8465 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
8466 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
8468 bad_specifiers (decl, "type", virtualp,
8469 memfn_quals != TYPE_UNQUALIFIED,
8470 inlinep, friendp, raises != NULL_TREE);
8475 /* Detect the case of an array type of unspecified size
8476 which came, as such, direct from a typedef name.
8477 We must copy the type, so that the array's domain can be
8478 individually set by the object's initializer. */
8480 if (type && typedef_type
8481 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
8482 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
8483 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
8485 /* Detect where we're using a typedef of function type to declare a
8486 function. PARMS will not be set, so we must create it now. */
8488 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
8490 tree decls = NULL_TREE;
8493 for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
8495 tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
8497 TREE_CHAIN (decl) = decls;
8501 parms = nreverse (decls);
8503 if (decl_context != TYPENAME)
8505 /* A cv-qualifier-seq shall only be part of the function type
8506 for a non-static member function. [8.3.5/4 dcl.fct] */
8507 if (cp_type_quals (type) != TYPE_UNQUALIFIED
8508 && (current_class_type == NULL_TREE || staticp) )
8511 ? G_("qualified function types cannot be used to "
8512 "declare static member functions")
8513 : G_("qualified function types cannot be used to "
8514 "declare free functions"));
8515 type = TYPE_MAIN_VARIANT (type);
8518 /* The qualifiers on the function type become the qualifiers on
8519 the non-static member function. */
8520 memfn_quals |= cp_type_quals (type);
8524 /* If this is a type name (such as, in a cast or sizeof),
8525 compute the type and return it now. */
8527 if (decl_context == TYPENAME)
8529 /* Note that the grammar rejects storage classes
8530 in typenames, fields or parameters. */
8531 if (type_quals != TYPE_UNQUALIFIED)
8532 type_quals = TYPE_UNQUALIFIED;
8534 /* Special case: "friend class foo" looks like a TYPENAME context. */
8537 if (type_quals != TYPE_UNQUALIFIED)
8539 error ("type qualifiers specified for friend class declaration");
8540 type_quals = TYPE_UNQUALIFIED;
8544 error ("%<inline%> specified for friend class declaration");
8550 /* Don't allow friend declaration without a class-key. */
8551 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
8552 pedwarn ("template parameters cannot be friends");
8553 else if (TREE_CODE (type) == TYPENAME_TYPE)
8554 pedwarn ("friend declaration requires class-key, "
8555 "i.e. %<friend class %T::%D%>",
8556 TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
8558 pedwarn ("friend declaration requires class-key, "
8559 "i.e. %<friend %#T%>",
8563 /* Only try to do this stuff if we didn't already give up. */
8564 if (type != integer_type_node)
8566 /* A friendly class? */
8567 if (current_class_type)
8568 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
8571 error ("trying to make class %qT a friend of global scope",
8574 type = void_type_node;
8577 else if (memfn_quals)
8579 if (ctype == NULL_TREE)
8581 if (TREE_CODE (type) != METHOD_TYPE)
8582 error ("invalid qualifiers on non-member function type");
8584 ctype = TYPE_METHOD_BASETYPE (type);
8587 type = build_memfn_type (type, ctype, memfn_quals);
8592 else if (unqualified_id == NULL_TREE && decl_context != PARM
8593 && decl_context != CATCHPARM
8594 && TREE_CODE (type) != UNION_TYPE
8597 error ("abstract declarator %qT used as declaration", type);
8598 return error_mark_node;
8601 /* Only functions may be declared using an operator-function-id. */
8603 && IDENTIFIER_OPNAME_P (unqualified_id)
8604 && TREE_CODE (type) != FUNCTION_TYPE
8605 && TREE_CODE (type) != METHOD_TYPE)
8607 error ("declaration of %qD as non-function", unqualified_id);
8608 return error_mark_node;
8611 /* We don't check parameter types here because we can emit a better
8612 error message later. */
8613 if (decl_context != PARM)
8615 type = check_var_type (unqualified_id, type);
8616 if (type == error_mark_node)
8617 return error_mark_node;
8620 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
8621 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
8623 if (decl_context == PARM || decl_context == CATCHPARM)
8625 if (ctype || in_namespace)
8626 error ("cannot use %<::%> in parameter declaration");
8628 /* A parameter declared as an array of T is really a pointer to T.
8629 One declared as a function is really a pointer to a function.
8630 One declared as a member is really a pointer to member. */
8632 if (TREE_CODE (type) == ARRAY_TYPE)
8634 /* Transfer const-ness of array into that of type pointed to. */
8635 type = build_pointer_type (TREE_TYPE (type));
8636 type_quals = TYPE_UNQUALIFIED;
8638 else if (TREE_CODE (type) == FUNCTION_TYPE)
8639 type = build_pointer_type (type);
8645 if (decl_context == PARM)
8647 decl = cp_build_parm_decl (unqualified_id, type);
8649 bad_specifiers (decl, "parameter", virtualp,
8650 memfn_quals != TYPE_UNQUALIFIED,
8651 inlinep, friendp, raises != NULL_TREE);
8653 else if (decl_context == FIELD)
8655 /* The C99 flexible array extension. */
8656 if (!staticp && TREE_CODE (type) == ARRAY_TYPE
8657 && TYPE_DOMAIN (type) == NULL_TREE)
8659 tree itype = compute_array_index_type (dname, integer_zero_node);
8660 type = build_cplus_array_type (TREE_TYPE (type), itype);
8663 if (type == error_mark_node)
8665 /* Happens when declaring arrays of sizes which
8666 are error_mark_node, for example. */
8669 else if (in_namespace && !friendp)
8671 /* Something like struct S { int N::j; }; */
8672 error ("invalid use of %<::%>");
8673 return error_mark_node;
8675 else if (TREE_CODE (type) == FUNCTION_TYPE)
8678 tree function_context;
8682 if (ctype == NULL_TREE)
8683 ctype = current_class_type;
8685 if (ctype == NULL_TREE)
8687 error ("can't make %qD into a method -- not in a class",
8689 return error_mark_node;
8692 /* ``A union may [ ... ] not [ have ] virtual functions.''
8694 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
8696 error ("function %qD declared virtual inside a union",
8698 return error_mark_node;
8701 if (NEW_DELETE_OPNAME_P (unqualified_id))
8705 error ("%qD cannot be declared virtual, since it "
8711 else if (staticp < 2)
8712 type = build_memfn_type (type, ctype, memfn_quals);
8715 /* Check that the name used for a destructor makes sense. */
8716 if (sfk == sfk_destructor)
8720 gcc_assert (friendp);
8721 error ("expected qualified name in friend declaration "
8722 "for destructor %qD",
8723 id_declarator->u.id.unqualified_name);
8724 return error_mark_node;
8727 if (!same_type_p (TREE_OPERAND
8728 (id_declarator->u.id.unqualified_name, 0),
8731 error ("declaration of %qD as member of %qT",
8732 id_declarator->u.id.unqualified_name, ctype);
8733 return error_mark_node;
8737 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
8738 function_context = (ctype != NULL_TREE) ?
8739 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
8740 publicp = (! friendp || ! staticp)
8741 && function_context == NULL_TREE;
8742 decl = grokfndecl (ctype, type,
8743 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
8744 ? unqualified_id : dname,
8747 virtualp, flags, memfn_quals, raises,
8748 friendp ? -1 : 0, friendp, publicp, inlinep,
8750 funcdef_flag, template_count, in_namespace, attrlist);
8751 if (decl == NULL_TREE)
8752 return error_mark_node;
8754 /* This clobbers the attrs stored in `decl' from `attrlist'. */
8755 /* The decl and setting of decl_attr is also turned off. */
8756 decl = build_decl_attribute_variant (decl, decl_attr);
8759 /* [class.conv.ctor]
8761 A constructor declared without the function-specifier
8762 explicit that can be called with a single parameter
8763 specifies a conversion from the type of its first
8764 parameter to the type of its class. Such a constructor
8765 is called a converting constructor. */
8767 DECL_NONCONVERTING_P (decl) = 1;
8768 else if (DECL_CONSTRUCTOR_P (decl))
8770 /* The constructor can be called with exactly one
8771 parameter if there is at least one parameter, and
8772 any subsequent parameters have default arguments.
8773 Ignore any compiler-added parms. */
8774 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
8776 if (arg_types == void_list_node
8778 && TREE_CHAIN (arg_types)
8779 && TREE_CHAIN (arg_types) != void_list_node
8780 && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
8781 DECL_NONCONVERTING_P (decl) = 1;
8784 else if (TREE_CODE (type) == METHOD_TYPE)
8786 /* We only get here for friend declarations of
8787 members of other classes. */
8788 /* All method decls are public, so tell grokfndecl to set
8789 TREE_PUBLIC, also. */
8790 decl = grokfndecl (ctype, type,
8791 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
8792 ? unqualified_id : dname,
8795 virtualp, flags, memfn_quals, raises,
8796 friendp ? -1 : 0, friendp, 1, 0, sfk,
8797 funcdef_flag, template_count, in_namespace,
8799 if (decl == NULL_TREE)
8800 return error_mark_node;
8802 else if (!staticp && !dependent_type_p (type)
8803 && !COMPLETE_TYPE_P (complete_type (type))
8804 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
8807 error ("field %qD has incomplete type", unqualified_id);
8809 error ("name %qT has incomplete type", type);
8811 /* If we're instantiating a template, tell them which
8812 instantiation made the field's type be incomplete. */
8813 if (current_class_type
8814 && TYPE_NAME (current_class_type)
8815 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
8817 && declspecs->type == type)
8818 error (" in instantiation of template %qT",
8819 current_class_type);
8821 return error_mark_node;
8827 error ("%qE is neither function nor member function; "
8828 "cannot be declared friend", unqualified_id);
8836 /* Friends are treated specially. */
8837 if (ctype == current_class_type)
8838 ; /* We already issued a pedwarn. */
8839 else if (decl && DECL_NAME (decl))
8841 if (template_class_depth (current_class_type) == 0)
8843 decl = check_explicit_specialization
8844 (unqualified_id, decl, template_count,
8845 2 * funcdef_flag + 4);
8846 if (decl == error_mark_node)
8847 return error_mark_node;
8850 decl = do_friend (ctype, unqualified_id, decl,
8856 return error_mark_node;
8859 /* Structure field. It may not be a function, except for C++. */
8861 if (decl == NULL_TREE)
8867 /* An attempt is being made to initialize a non-static
8868 member. But, from [class.mem]:
8870 4 A member-declarator can contain a
8871 constant-initializer only if it declares a static
8872 member (_class.static_) of integral or enumeration
8873 type, see _class.static.data_.
8875 This used to be relatively common practice, but
8876 the rest of the compiler does not correctly
8877 handle the initialization unless the member is
8878 static so we make it static below. */
8879 pedwarn ("ISO C++ forbids initialization of member %qD",
8881 pedwarn ("making %qD static", unqualified_id);
8885 if (uses_template_parms (type))
8886 /* We'll check at instantiation time. */
8888 else if (check_static_variable_definition (unqualified_id,
8890 /* If we just return the declaration, crashes
8891 will sometimes occur. We therefore return
8892 void_type_node, as if this was a friend
8893 declaration, to cause callers to completely
8894 ignore this declaration. */
8895 return error_mark_node;
8900 /* C++ allows static class members. All other work
8901 for this is done by grokfield. */
8902 decl = build_lang_decl (VAR_DECL, unqualified_id, type);
8903 set_linkage_for_static_data_member (decl);
8904 /* Even if there is an in-class initialization, DECL
8905 is considered undefined until an out-of-class
8906 definition is provided. */
8907 DECL_EXTERNAL (decl) = 1;
8910 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
8914 decl = build_decl (FIELD_DECL, unqualified_id, type);
8915 DECL_NONADDRESSABLE_P (decl) = bitfield;
8916 if (bitfield && !unqualified_id)
8917 TREE_NO_WARNING (decl) = 1;
8919 if (storage_class == sc_mutable)
8921 DECL_MUTABLE_P (decl) = 1;
8922 storage_class = sc_none;
8926 bad_specifiers (decl, "field", virtualp,
8927 memfn_quals != TYPE_UNQUALIFIED,
8928 inlinep, friendp, raises != NULL_TREE);
8931 else if (TREE_CODE (type) == FUNCTION_TYPE
8932 || TREE_CODE (type) == METHOD_TYPE)
8937 if (!unqualified_id)
8938 return error_mark_node;
8940 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
8941 original_name = dname;
8943 original_name = unqualified_id;
8945 if (storage_class == sc_auto)
8946 error ("storage class %<auto%> invalid for function %qs", name);
8947 else if (storage_class == sc_register)
8948 error ("storage class %<register%> invalid for function %qs", name);
8950 error ("storage class %<__thread%> invalid for function %qs", name);
8952 /* Function declaration not at top level.
8953 Storage classes other than `extern' are not allowed
8954 and `extern' makes no difference. */
8955 if (! toplevel_bindings_p ()
8956 && (storage_class == sc_static
8957 || declspecs->specs[(int)ds_inline])
8960 if (storage_class == sc_static)
8961 pedwarn ("%<static%> specified invalid for function %qs "
8962 "declared out of global scope", name);
8964 pedwarn ("%<inline%> specifier invalid for function %qs "
8965 "declared out of global scope", name);
8968 if (ctype == NULL_TREE)
8972 error ("virtual non-class function %qs", name);
8976 else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2
8977 && !NEW_DELETE_OPNAME_P (original_name))
8978 type = build_method_type_directly (ctype,
8980 TYPE_ARG_TYPES (type));
8982 /* Record presence of `static'. */
8983 publicp = (ctype != NULL_TREE
8984 || storage_class == sc_extern
8985 || storage_class != sc_static);
8987 decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
8988 virtualp, flags, memfn_quals, raises,
8990 publicp, inlinep, sfk, funcdef_flag,
8991 template_count, in_namespace, attrlist);
8992 if (decl == NULL_TREE)
8993 return error_mark_node;
8997 int invalid_static = 0;
8999 /* Don't allow a static member function in a class, and forbid
9000 declaring main to be static. */
9001 if (TREE_CODE (type) == METHOD_TYPE)
9003 pedwarn ("cannot declare member function %qD to have "
9004 "static linkage", decl);
9007 else if (current_function_decl)
9009 /* FIXME need arm citation */
9010 error ("cannot declare static function inside another function");
9017 storage_class = sc_none;
9023 /* It's a variable. */
9025 /* An uninitialized decl with `extern' is a reference. */
9026 decl = grokvardecl (type, unqualified_id,
9029 (type_quals & TYPE_QUAL_CONST) != 0,
9030 ctype ? ctype : in_namespace);
9031 bad_specifiers (decl, "variable", virtualp,
9032 memfn_quals != TYPE_UNQUALIFIED,
9033 inlinep, friendp, raises != NULL_TREE);
9037 DECL_CONTEXT (decl) = ctype;
9040 pedwarn ("%<static%> may not be used when defining "
9041 "(as opposed to declaring) a static data member");
9043 storage_class = sc_none;
9045 if (storage_class == sc_register && TREE_STATIC (decl))
9047 error ("static member %qD declared %<register%>", decl);
9048 storage_class = sc_none;
9050 if (storage_class == sc_extern && pedantic)
9052 pedwarn ("cannot explicitly declare member %q#D to have "
9055 storage_class = sc_none;
9060 /* Record `register' declaration for warnings on &
9061 and in case doing stupid register allocation. */
9063 if (storage_class == sc_register)
9064 DECL_REGISTER (decl) = 1;
9065 else if (storage_class == sc_extern)
9066 DECL_THIS_EXTERN (decl) = 1;
9067 else if (storage_class == sc_static)
9068 DECL_THIS_STATIC (decl) = 1;
9070 /* Record constancy and volatility. There's no need to do this
9071 when processing a template; we'll do this for the instantiated
9072 declaration based on the type of DECL. */
9073 if (!processing_template_decl)
9074 cp_apply_type_quals_to_decl (type_quals, decl);
9077 TREE_NO_WARNING (decl) = 1;
9083 /* Subroutine of start_function. Ensure that each of the parameter
9084 types (as listed in PARMS) is complete, as is required for a
9085 function definition. */
9088 require_complete_types_for_parms (tree parms)
9090 for (; parms; parms = TREE_CHAIN (parms))
9092 if (dependent_type_p (TREE_TYPE (parms)))
9094 if (!VOID_TYPE_P (TREE_TYPE (parms))
9095 && complete_type_or_else (TREE_TYPE (parms), parms))
9097 relayout_decl (parms);
9098 DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
9101 /* grokparms or complete_type_or_else will have already issued
9103 TREE_TYPE (parms) = error_mark_node;
9107 /* Returns nonzero if T is a local variable. */
9110 local_variable_p (const_tree t)
9112 if ((TREE_CODE (t) == VAR_DECL
9113 /* A VAR_DECL with a context that is a _TYPE is a static data
9115 && !TYPE_P (CP_DECL_CONTEXT (t))
9116 /* Any other non-local variable must be at namespace scope. */
9117 && !DECL_NAMESPACE_SCOPE_P (t))
9118 || (TREE_CODE (t) == PARM_DECL))
9124 /* Like local_variable_p, but suitable for use as a tree-walking
9128 local_variable_p_walkfn (tree *tp, int *walk_subtrees,
9129 void *data ATTRIBUTE_UNUSED)
9131 if (local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
9133 else if (TYPE_P (*tp))
9140 /* Check that ARG, which is a default-argument expression for a
9141 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
9142 something goes wrong. DECL may also be a _TYPE node, rather than a
9143 DECL, if there is no DECL available. */
9146 check_default_argument (tree decl, tree arg)
9151 if (TREE_CODE (arg) == DEFAULT_ARG)
9152 /* We get a DEFAULT_ARG when looking at an in-class declaration
9153 with a default argument. Ignore the argument for now; we'll
9154 deal with it after the class is complete. */
9163 decl_type = TREE_TYPE (decl);
9165 if (arg == error_mark_node
9166 || decl == error_mark_node
9167 || TREE_TYPE (arg) == error_mark_node
9168 || decl_type == error_mark_node)
9169 /* Something already went wrong. There's no need to check
9171 return error_mark_node;
9173 /* [dcl.fct.default]
9175 A default argument expression is implicitly converted to the
9177 if (!TREE_TYPE (arg)
9178 || !can_convert_arg (decl_type, TREE_TYPE (arg), arg, LOOKUP_NORMAL))
9181 error ("default argument for %q#D has type %qT",
9182 decl, TREE_TYPE (arg));
9184 error ("default argument for parameter of type %qT has type %qT",
9185 decl_type, TREE_TYPE (arg));
9187 return error_mark_node;
9190 /* [dcl.fct.default]
9192 Local variables shall not be used in default argument
9195 The keyword `this' shall not be used in a default argument of a
9197 var = cp_walk_tree_without_duplicates (&arg, local_variable_p_walkfn, NULL);
9200 error ("default argument %qE uses local variable %qD", arg, var);
9201 return error_mark_node;
9208 /* Decode the list of parameter types for a function type.
9209 Given the list of things declared inside the parens,
9210 return a list of types.
9212 If this parameter does not end with an ellipsis, we append
9215 *PARMS is set to the chain of PARM_DECLs created. */
9218 grokparms (cp_parameter_declarator *first_parm, tree *parms)
9220 tree result = NULL_TREE;
9221 tree decls = NULL_TREE;
9222 int ellipsis = !first_parm || first_parm->ellipsis_p;
9223 cp_parameter_declarator *parm;
9225 struct pointer_set_t *unique_decls = pointer_set_create ();
9227 for (parm = first_parm; parm != NULL; parm = parm->next)
9229 tree type = NULL_TREE;
9230 tree init = parm->default_argument;
9234 if (parm == no_parameters)
9237 attrs = parm->decl_specifiers.attributes;
9238 parm->decl_specifiers.attributes = NULL_TREE;
9239 decl = grokdeclarator (parm->declarator, &parm->decl_specifiers,
9240 PARM, init != NULL_TREE, &attrs);
9241 if (! decl || TREE_TYPE (decl) == error_mark_node)
9245 cplus_decl_attributes (&decl, attrs, 0);
9247 type = TREE_TYPE (decl);
9248 if (VOID_TYPE_P (type))
9250 if (same_type_p (type, void_type_node)
9251 && DECL_SELF_REFERENCE_P (type)
9252 && !DECL_NAME (decl) && !result && !parm->next && !ellipsis)
9253 /* this is a parmlist of `(void)', which is ok. */
9255 cxx_incomplete_type_error (decl, type);
9256 /* It's not a good idea to actually create parameters of
9257 type `void'; other parts of the compiler assume that a
9258 void type terminates the parameter list. */
9259 type = error_mark_node;
9260 TREE_TYPE (decl) = error_mark_node;
9263 if (type != error_mark_node)
9265 /* Top-level qualifiers on the parameters are
9266 ignored for function types. */
9267 type = cp_build_qualified_type (type, 0);
9268 if (TREE_CODE (type) == METHOD_TYPE)
9270 error ("parameter %qD invalidly declared method type", decl);
9271 type = build_pointer_type (type);
9272 TREE_TYPE (decl) = type;
9274 else if (abstract_virtuals_error (decl, type))
9275 any_error = 1; /* Seems like a good idea. */
9276 else if (POINTER_TYPE_P (type))
9278 /* [dcl.fct]/6, parameter types cannot contain pointers
9279 (references) to arrays of unknown bound. */
9280 tree t = TREE_TYPE (type);
9281 int ptr = TYPE_PTR_P (type);
9287 else if (TREE_CODE (t) != ARRAY_TYPE)
9289 else if (!TYPE_DOMAIN (t))
9293 if (TREE_CODE (t) == ARRAY_TYPE)
9294 error ("parameter %qD includes %s to array of unknown "
9296 decl, ptr ? "pointer" : "reference", t);
9301 else if (init && !processing_template_decl)
9302 init = check_default_argument (decl, init);
9305 if (TREE_CODE (decl) == PARM_DECL
9306 && FUNCTION_PARAMETER_PACK_P (decl)
9308 error ("parameter packs must be at the end of the parameter list");
9310 if (DECL_NAME (decl))
9312 if (pointer_set_contains (unique_decls, DECL_NAME (decl)))
9313 error ("multiple parameters named %qE", DECL_NAME (decl));
9315 pointer_set_insert (unique_decls, DECL_NAME (decl));
9318 TREE_CHAIN (decl) = decls;
9320 result = tree_cons (init, type, result);
9322 decls = nreverse (decls);
9323 result = nreverse (result);
9325 result = chainon (result, void_list_node);
9328 pointer_set_destroy (unique_decls);
9333 /* D is a constructor or overloaded `operator='.
9335 Let T be the class in which D is declared. Then, this function
9338 -1 if D's is an ill-formed constructor or copy assignment operator
9339 whose first parameter is of type `T'.
9340 0 if D is not a copy constructor or copy assignment
9342 1 if D is a copy constructor or copy assignment operator whose
9343 first parameter is a reference to const qualified T.
9344 2 if D is a copy constructor or copy assignment operator whose
9345 first parameter is a reference to non-const qualified T.
9347 This function can be used as a predicate. Positive values indicate
9348 a copy constructor and nonzero values indicate a copy assignment
9352 copy_fn_p (const_tree d)
9358 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
9360 if (TREE_CODE (d) == TEMPLATE_DECL
9361 || (DECL_TEMPLATE_INFO (d)
9362 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
9363 /* Instantiations of template member functions are never copy
9364 functions. Note that member functions of templated classes are
9365 represented as template functions internally, and we must
9366 accept those as copy functions. */
9369 args = FUNCTION_FIRST_USER_PARMTYPE (d);
9373 arg_type = TREE_VALUE (args);
9374 if (arg_type == error_mark_node)
9377 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
9379 /* Pass by value copy assignment operator. */
9382 else if (TREE_CODE (arg_type) == REFERENCE_TYPE
9383 && !TYPE_REF_IS_RVALUE (arg_type)
9384 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
9386 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
9392 args = TREE_CHAIN (args);
9394 if (args && args != void_list_node && !TREE_PURPOSE (args))
9395 /* There are more non-optional args. */
9401 /* D is a constructor or overloaded `operator='.
9403 Let T be the class in which D is declared. Then, this function
9404 returns true when D is a move constructor or move assignment
9405 operator, false otherwise. */
9408 move_fn_p (const_tree d)
9412 bool result = false;
9414 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
9416 if (cxx_dialect == cxx98)
9417 /* There are no move constructors if we are in C++98 mode. */
9420 if (TREE_CODE (d) == TEMPLATE_DECL
9421 || (DECL_TEMPLATE_INFO (d)
9422 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
9423 /* Instantiations of template member functions are never copy
9424 functions. Note that member functions of templated classes are
9425 represented as template functions internally, and we must
9426 accept those as copy functions. */
9429 args = FUNCTION_FIRST_USER_PARMTYPE (d);
9433 arg_type = TREE_VALUE (args);
9434 if (arg_type == error_mark_node)
9437 if (TREE_CODE (arg_type) == REFERENCE_TYPE
9438 && TYPE_REF_IS_RVALUE (arg_type)
9439 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)),
9443 args = TREE_CHAIN (args);
9445 if (args && args != void_list_node && !TREE_PURPOSE (args))
9446 /* There are more non-optional args. */
9452 /* Remember any special properties of member function DECL. */
9454 void grok_special_member_properties (tree decl)
9458 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
9461 class_type = DECL_CONTEXT (decl);
9462 if (DECL_CONSTRUCTOR_P (decl))
9464 int ctor = copy_fn_p (decl);
9466 TYPE_HAS_CONSTRUCTOR (class_type) = 1;
9472 A non-template constructor for class X is a copy
9473 constructor if its first parameter is of type X&, const
9474 X&, volatile X& or const volatile X&, and either there
9475 are no other parameters or else all other parameters have
9476 default arguments. */
9477 TYPE_HAS_INIT_REF (class_type) = 1;
9479 TYPE_HAS_CONST_INIT_REF (class_type) = 1;
9481 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
9482 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type) = 1;
9484 else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
9488 A non-template assignment operator for class X is a copy
9489 assignment operator if its parameter is of type X, X&, const
9490 X&, volatile X& or const volatile X&. */
9492 int assop = copy_fn_p (decl);
9496 TYPE_HAS_ASSIGN_REF (class_type) = 1;
9498 TYPE_HAS_CONST_ASSIGN_REF (class_type) = 1;
9503 /* Check a constructor DECL has the correct form. Complains
9504 if the class has a constructor of the form X(X). */
9507 grok_ctor_properties (const_tree ctype, const_tree decl)
9509 int ctor_parm = copy_fn_p (decl);
9515 A declaration of a constructor for a class X is ill-formed if
9516 its first parameter is of type (optionally cv-qualified) X
9517 and either there are no other parameters or else all other
9518 parameters have default arguments.
9520 We *don't* complain about member template instantiations that
9521 have this form, though; they can occur as we try to decide
9522 what constructor to use during overload resolution. Since
9523 overload resolution will never prefer such a constructor to
9524 the non-template copy constructor (which is either explicitly
9525 or implicitly defined), there's no need to worry about their
9526 existence. Theoretically, they should never even be
9527 instantiated, but that's hard to forestall. */
9528 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
9536 /* An operator with this code is unary, but can also be binary. */
9539 ambi_op_p (enum tree_code code)
9541 return (code == INDIRECT_REF
9542 || code == ADDR_EXPR
9543 || code == UNARY_PLUS_EXPR
9544 || code == NEGATE_EXPR
9545 || code == PREINCREMENT_EXPR
9546 || code == PREDECREMENT_EXPR);
9549 /* An operator with this name can only be unary. */
9552 unary_op_p (enum tree_code code)
9554 return (code == TRUTH_NOT_EXPR
9555 || code == BIT_NOT_EXPR
9556 || code == COMPONENT_REF
9557 || code == TYPE_EXPR);
9560 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
9561 errors are issued for invalid declarations. */
9564 grok_op_properties (tree decl, bool complain)
9566 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
9568 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
9569 tree name = DECL_NAME (decl);
9570 enum tree_code operator_code;
9575 /* Count the number of arguments and check for ellipsis. */
9576 for (argtype = argtypes, arity = 0;
9577 argtype && argtype != void_list_node;
9578 argtype = TREE_CHAIN (argtype))
9580 ellipsis_p = !argtype;
9582 class_type = DECL_CONTEXT (decl);
9583 if (class_type && !CLASS_TYPE_P (class_type))
9584 class_type = NULL_TREE;
9586 if (DECL_CONV_FN_P (decl))
9587 operator_code = TYPE_EXPR;
9591 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
9592 if (ansi_opname (CODE) == name) \
9594 operator_code = (CODE); \
9597 else if (ansi_assopname (CODE) == name) \
9599 operator_code = (CODE); \
9600 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
9604 #include "operators.def"
9610 gcc_assert (operator_code != LAST_CPLUS_TREE_CODE);
9611 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
9614 switch (operator_code)
9617 TYPE_HAS_NEW_OPERATOR (class_type) = 1;
9621 TYPE_GETS_DELETE (class_type) |= 1;
9625 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type) = 1;
9628 case VEC_DELETE_EXPR:
9629 TYPE_GETS_DELETE (class_type) |= 2;
9636 /* [basic.std.dynamic.allocation]/1:
9638 A program is ill-formed if an allocation function is declared
9639 in a namespace scope other than global scope or declared static
9642 The same also holds true for deallocation functions. */
9643 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR
9644 || operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
9646 if (DECL_NAMESPACE_SCOPE_P (decl))
9648 if (CP_DECL_CONTEXT (decl) != global_namespace)
9650 error ("%qD may not be declared within a namespace", decl);
9653 else if (!TREE_PUBLIC (decl))
9655 error ("%qD may not be declared as static", decl);
9661 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
9662 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
9663 else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
9664 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
9667 /* An operator function must either be a non-static member function
9668 or have at least one parameter of a class, a reference to a class,
9669 an enumeration, or a reference to an enumeration. 13.4.0.6 */
9670 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
9672 if (operator_code == TYPE_EXPR
9673 || operator_code == CALL_EXPR
9674 || operator_code == COMPONENT_REF
9675 || operator_code == ARRAY_REF
9676 || operator_code == NOP_EXPR)
9678 error ("%qD must be a nonstatic member function", decl);
9685 if (DECL_STATIC_FUNCTION_P (decl))
9687 error ("%qD must be either a non-static member "
9688 "function or a non-member function", decl);
9692 for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
9694 tree arg = non_reference (TREE_VALUE (p));
9695 if (arg == error_mark_node)
9698 /* IS_AGGR_TYPE, rather than CLASS_TYPE_P, is used
9699 because these checks are performed even on
9700 template functions. */
9701 if (IS_AGGR_TYPE (arg) || TREE_CODE (arg) == ENUMERAL_TYPE)
9705 if (!p || p == void_list_node)
9708 error ("%qD must have an argument of class or "
9709 "enumerated type", decl);
9715 /* There are no restrictions on the arguments to an overloaded
9717 if (operator_code == CALL_EXPR)
9720 /* Warn about conversion operators that will never be used. */
9721 if (IDENTIFIER_TYPENAME_P (name)
9722 && ! DECL_TEMPLATE_INFO (decl)
9724 /* Warn only declaring the function; there is no need to
9725 warn again about out-of-class definitions. */
9726 && class_type == current_class_type)
9728 tree t = TREE_TYPE (name);
9729 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
9730 const char *what = 0;
9733 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
9735 if (TREE_CODE (t) == VOID_TYPE)
9737 else if (class_type)
9739 if (t == class_type)
9740 what = "the same type";
9741 /* Don't force t to be complete here. */
9742 else if (IS_AGGR_TYPE (t)
9743 && COMPLETE_TYPE_P (t)
9744 && DERIVED_FROM_P (t, class_type))
9745 what = "a base class";
9749 warning (OPT_Wconversion, "conversion to %s%s will never use a type "
9750 "conversion operator",
9751 ref ? "a reference to " : "", what);
9754 if (operator_code == COND_EXPR)
9757 error ("ISO C++ prohibits overloading operator ?:");
9760 else if (ellipsis_p)
9762 error ("%qD must not have variable number of arguments", decl);
9765 else if (ambi_op_p (operator_code))
9768 /* We pick the one-argument operator codes by default, so
9769 we don't have to change anything. */
9771 else if (arity == 2)
9773 /* If we thought this was a unary operator, we now know
9774 it to be a binary operator. */
9775 switch (operator_code)
9778 operator_code = MULT_EXPR;
9782 operator_code = BIT_AND_EXPR;
9785 case UNARY_PLUS_EXPR:
9786 operator_code = PLUS_EXPR;
9790 operator_code = MINUS_EXPR;
9793 case PREINCREMENT_EXPR:
9794 operator_code = POSTINCREMENT_EXPR;
9797 case PREDECREMENT_EXPR:
9798 operator_code = POSTDECREMENT_EXPR;
9805 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
9807 if ((operator_code == POSTINCREMENT_EXPR
9808 || operator_code == POSTDECREMENT_EXPR)
9809 && ! processing_template_decl
9810 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
9813 error ("postfix %qD must take %<int%> as its argument",
9816 error ("postfix %qD must take %<int%> as its second "
9824 error ("%qD must take either zero or one argument", decl);
9826 error ("%qD must take either one or two arguments", decl);
9830 /* More Effective C++ rule 6. */
9832 && (operator_code == POSTINCREMENT_EXPR
9833 || operator_code == POSTDECREMENT_EXPR
9834 || operator_code == PREINCREMENT_EXPR
9835 || operator_code == PREDECREMENT_EXPR))
9837 tree arg = TREE_VALUE (argtypes);
9838 tree ret = TREE_TYPE (TREE_TYPE (decl));
9839 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
9840 arg = TREE_TYPE (arg);
9841 arg = TYPE_MAIN_VARIANT (arg);
9842 if (operator_code == PREINCREMENT_EXPR
9843 || operator_code == PREDECREMENT_EXPR)
9845 if (TREE_CODE (ret) != REFERENCE_TYPE
9846 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
9848 warning (OPT_Weffc__, "prefix %qD should return %qT", decl,
9849 build_reference_type (arg));
9853 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
9854 warning (OPT_Weffc__, "postfix %qD should return %qT", decl, arg);
9858 else if (unary_op_p (operator_code))
9863 error ("%qD must take %<void%>", decl);
9865 error ("%qD must take exactly one argument", decl);
9869 else /* if (binary_op_p (operator_code)) */
9874 error ("%qD must take exactly one argument", decl);
9876 error ("%qD must take exactly two arguments", decl);
9880 /* More Effective C++ rule 7. */
9882 && (operator_code == TRUTH_ANDIF_EXPR
9883 || operator_code == TRUTH_ORIF_EXPR
9884 || operator_code == COMPOUND_EXPR))
9885 warning (OPT_Weffc__, "user-defined %qD always evaluates both arguments",
9889 /* Effective C++ rule 23. */
9892 && !DECL_ASSIGNMENT_OPERATOR_P (decl)
9893 && (operator_code == PLUS_EXPR
9894 || operator_code == MINUS_EXPR
9895 || operator_code == TRUNC_DIV_EXPR
9896 || operator_code == MULT_EXPR
9897 || operator_code == TRUNC_MOD_EXPR)
9898 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
9899 warning (OPT_Weffc__, "%qD should return by value", decl);
9902 for (; argtypes && argtypes != void_list_node;
9903 argtypes = TREE_CHAIN (argtypes))
9904 if (TREE_PURPOSE (argtypes))
9906 TREE_PURPOSE (argtypes) = NULL_TREE;
9907 if (operator_code == POSTINCREMENT_EXPR
9908 || operator_code == POSTDECREMENT_EXPR)
9911 pedwarn ("%qD cannot have default arguments", decl);
9915 error ("%qD cannot have default arguments", decl);
9923 /* Return a string giving the keyword associate with CODE. */
9926 tag_name (enum tag_types code)
9945 /* Name lookup in an elaborated-type-specifier (after the keyword
9946 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
9947 elaborated-type-specifier is invalid, issue a diagnostic and return
9948 error_mark_node; otherwise, return the *_TYPE to which it referred.
9949 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
9952 check_elaborated_type_specifier (enum tag_types tag_code,
9954 bool allow_template_p)
9960 struct S { struct S *p; };
9962 name lookup will find the TYPE_DECL for the implicit "S::S"
9963 typedef. Adjust for that here. */
9964 if (DECL_SELF_REFERENCE_P (decl))
9965 decl = TYPE_NAME (TREE_TYPE (decl));
9967 type = TREE_TYPE (decl);
9969 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
9970 is false for this case as well. */
9971 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
9973 error ("using template type parameter %qT after %qs",
9974 type, tag_name (tag_code));
9975 return error_mark_node;
9979 If the identifier resolves to a typedef-name or a template
9980 type-parameter, the elaborated-type-specifier is ill-formed.
9982 In other words, the only legitimate declaration to use in the
9983 elaborated type specifier is the implicit typedef created when
9984 the type is declared. */
9985 else if (!DECL_IMPLICIT_TYPEDEF_P (decl)
9986 && tag_code != typename_type)
9988 error ("using typedef-name %qD after %qs", decl, tag_name (tag_code));
9989 error ("%q+D has a previous declaration here", decl);
9990 return error_mark_node;
9992 else if (TREE_CODE (type) != RECORD_TYPE
9993 && TREE_CODE (type) != UNION_TYPE
9994 && tag_code != enum_type
9995 && tag_code != typename_type)
9997 error ("%qT referred to as %qs", type, tag_name (tag_code));
9998 error ("%q+T has a previous declaration here", type);
9999 return error_mark_node;
10001 else if (TREE_CODE (type) != ENUMERAL_TYPE
10002 && tag_code == enum_type)
10004 error ("%qT referred to as enum", type);
10005 error ("%q+T has a previous declaration here", type);
10006 return error_mark_node;
10008 else if (!allow_template_p
10009 && TREE_CODE (type) == RECORD_TYPE
10010 && CLASSTYPE_IS_TEMPLATE (type))
10012 /* If a class template appears as elaborated type specifier
10013 without a template header such as:
10015 template <class T> class C {};
10016 void f(class C); // No template header here
10018 then the required template argument is missing. */
10019 error ("template argument required for %<%s %T%>",
10020 tag_name (tag_code),
10021 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
10022 return error_mark_node;
10028 /* Lookup NAME in elaborate type specifier in scope according to
10029 SCOPE and issue diagnostics if necessary.
10030 Return *_TYPE node upon success, NULL_TREE when the NAME is not
10031 found, and ERROR_MARK_NODE for type error. */
10034 lookup_and_check_tag (enum tag_types tag_code, tree name,
10035 tag_scope scope, bool template_header_p)
10039 if (scope == ts_global)
10041 /* First try ordinary name lookup, ignoring hidden class name
10042 injected via friend declaration. */
10043 decl = lookup_name_prefer_type (name, 2);
10044 /* If that fails, the name will be placed in the smallest
10045 non-class, non-function-prototype scope according to 3.3.1/5.
10046 We may already have a hidden name declared as friend in this
10047 scope. So lookup again but not ignoring hidden names.
10048 If we find one, that name will be made visible rather than
10049 creating a new tag. */
10051 decl = lookup_type_scope (name, ts_within_enclosing_non_class);
10054 decl = lookup_type_scope (name, scope);
10056 if (decl && DECL_CLASS_TEMPLATE_P (decl))
10057 decl = DECL_TEMPLATE_RESULT (decl);
10059 if (decl && TREE_CODE (decl) == TYPE_DECL)
10061 /* Look for invalid nested type:
10065 if (scope == ts_current && DECL_SELF_REFERENCE_P (decl))
10067 error ("%qD has the same name as the class in which it is "
10070 return error_mark_node;
10073 /* Two cases we need to consider when deciding if a class
10074 template is allowed as an elaborated type specifier:
10075 1. It is a self reference to its own class.
10076 2. It comes with a template header.
10080 template <class T> class C {
10081 class C *c1; // DECL_SELF_REFERENCE_P is true
10084 template <class U> class C; // template_header_p is true
10085 template <class T> class C<T>::D {
10086 class C *c2; // DECL_SELF_REFERENCE_P is true
10089 t = check_elaborated_type_specifier (tag_code,
10092 | DECL_SELF_REFERENCE_P (decl));
10095 else if (decl && TREE_CODE (decl) == TREE_LIST)
10097 error ("reference to %qD is ambiguous", name);
10098 print_candidates (decl);
10099 return error_mark_node;
10105 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
10106 Define the tag as a forward-reference if it is not defined.
10108 If a declaration is given, process it here, and report an error if
10109 multiple declarations are not identical.
10111 SCOPE is TS_CURRENT when this is also a definition. Only look in
10112 the current frame for the name (since C++ allows new names in any
10113 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
10114 declaration. Only look beginning from the current scope outward up
10115 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
10117 TEMPLATE_HEADER_P is true when this declaration is preceded by
10118 a set of template parameters. */
10121 xref_tag (enum tag_types tag_code, tree name,
10122 tag_scope scope, bool template_header_p)
10124 enum tree_code code;
10126 tree context = NULL_TREE;
10128 timevar_push (TV_NAME_LOOKUP);
10130 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
10136 code = RECORD_TYPE;
10142 code = ENUMERAL_TYPE;
10145 gcc_unreachable ();
10148 /* In case of anonymous name, xref_tag is only called to
10149 make type node and push name. Name lookup is not required. */
10150 if (ANON_AGGRNAME_P (name))
10153 t = lookup_and_check_tag (tag_code, name,
10154 scope, template_header_p);
10156 if (t == error_mark_node)
10157 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10159 if (scope != ts_current && t && current_class_type
10160 && template_class_depth (current_class_type)
10161 && template_header_p)
10163 /* Since SCOPE is not TS_CURRENT, we are not looking at a
10164 definition of this tag. Since, in addition, we are currently
10165 processing a (member) template declaration of a template
10166 class, we must be very careful; consider:
10173 { template <class V>
10174 friend struct S1; };
10176 Here, the S2::S1 declaration should not be confused with the
10177 outer declaration. In particular, the inner version should
10178 have a template parameter of level 2, not level 1. This
10179 would be particularly important if the member declaration
10182 template <class V = U> friend struct S1;
10184 say, when we should tsubst into `U' when instantiating
10185 S2. On the other hand, when presented with:
10195 we must find the inner binding eventually. We
10196 accomplish this by making sure that the new type we
10197 create to represent this declaration has the right
10199 context = TYPE_CONTEXT (t);
10205 /* If no such tag is yet defined, create a forward-reference node
10206 and record it as the "definition".
10207 When a real declaration of this type is found,
10208 the forward-reference will be altered into a real type. */
10209 if (code == ENUMERAL_TYPE)
10211 error ("use of enum %q#D without previous declaration", name);
10212 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10216 t = make_aggr_type (code);
10217 TYPE_CONTEXT (t) = context;
10218 t = pushtag (name, t, scope);
10223 if (template_header_p && IS_AGGR_TYPE (t))
10225 if (!redeclare_class_template (t, current_template_parms))
10226 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10228 else if (!processing_template_decl
10229 && CLASS_TYPE_P (t)
10230 && CLASSTYPE_IS_TEMPLATE (t))
10232 error ("redeclaration of %qT as a non-template", t);
10233 error ("previous declaration %q+D", t);
10234 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10237 /* Make injected friend class visible. */
10238 if (scope != ts_within_enclosing_non_class
10239 && hidden_name_p (TYPE_NAME (t)))
10241 DECL_ANTICIPATED (TYPE_NAME (t)) = 0;
10242 DECL_FRIEND_P (TYPE_NAME (t)) = 0;
10244 if (TYPE_TEMPLATE_INFO (t))
10246 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t)) = 0;
10247 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t)) = 0;
10252 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
10256 xref_tag_from_type (tree old, tree id, tag_scope scope)
10258 enum tag_types tag_kind;
10260 if (TREE_CODE (old) == RECORD_TYPE)
10261 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
10263 tag_kind = union_type;
10265 if (id == NULL_TREE)
10266 id = TYPE_IDENTIFIER (old);
10268 return xref_tag (tag_kind, id, scope, false);
10271 /* Create the binfo hierarchy for REF with (possibly NULL) base list
10272 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
10273 access_* node, and the TREE_VALUE is the type of the base-class.
10274 Non-NULL TREE_TYPE indicates virtual inheritance.
10276 Returns true if the binfo hierarchy was successfully created,
10277 false if an error was detected. */
10280 xref_basetypes (tree ref, tree base_list)
10283 tree binfo, base_binfo;
10284 unsigned max_vbases = 0; /* Maximum direct & indirect virtual bases. */
10285 unsigned max_bases = 0; /* Maximum direct bases. */
10287 tree default_access;
10288 tree igo_prev; /* Track Inheritance Graph Order. */
10290 if (ref == error_mark_node)
10293 /* The base of a derived class is private by default, all others are
10295 default_access = (TREE_CODE (ref) == RECORD_TYPE
10296 && CLASSTYPE_DECLARED_CLASS (ref)
10297 ? access_private_node : access_public_node);
10299 /* First, make sure that any templates in base-classes are
10300 instantiated. This ensures that if we call ourselves recursively
10301 we do not get confused about which classes are marked and which
10303 basep = &base_list;
10306 tree basetype = TREE_VALUE (*basep);
10308 if (!(processing_template_decl && uses_template_parms (basetype))
10309 && !complete_type_or_else (basetype, NULL))
10310 /* An incomplete type. Remove it from the list. */
10311 *basep = TREE_CHAIN (*basep);
10315 if (TREE_TYPE (*basep))
10317 if (CLASS_TYPE_P (basetype))
10318 max_vbases += VEC_length (tree, CLASSTYPE_VBASECLASSES (basetype));
10319 basep = &TREE_CHAIN (*basep);
10323 TYPE_MARKED_P (ref) = 1;
10325 /* The binfo slot should be empty, unless this is an (ill-formed)
10327 gcc_assert (!TYPE_BINFO (ref) || TYPE_SIZE (ref));
10328 gcc_assert (TYPE_MAIN_VARIANT (ref) == ref);
10330 binfo = make_tree_binfo (max_bases);
10332 TYPE_BINFO (ref) = binfo;
10333 BINFO_OFFSET (binfo) = size_zero_node;
10334 BINFO_TYPE (binfo) = ref;
10338 BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, gc, max_bases);
10339 /* An aggregate cannot have baseclasses. */
10340 CLASSTYPE_NON_AGGREGATE (ref) = 1;
10342 if (TREE_CODE (ref) == UNION_TYPE)
10344 error ("derived union %qT invalid", ref);
10351 if (TYPE_FOR_JAVA (ref))
10353 error ("Java class %qT cannot have multiple bases", ref);
10360 CLASSTYPE_VBASECLASSES (ref) = VEC_alloc (tree, gc, max_vbases);
10362 if (TYPE_FOR_JAVA (ref))
10364 error ("Java class %qT cannot have virtual bases", ref);
10369 for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list))
10371 tree access = TREE_PURPOSE (base_list);
10372 int via_virtual = TREE_TYPE (base_list) != NULL_TREE;
10373 tree basetype = TREE_VALUE (base_list);
10375 if (access == access_default_node)
10376 access = default_access;
10378 if (PACK_EXPANSION_P (basetype))
10379 basetype = PACK_EXPANSION_PATTERN (basetype);
10380 if (TREE_CODE (basetype) == TYPE_DECL)
10381 basetype = TREE_TYPE (basetype);
10382 if (TREE_CODE (basetype) != RECORD_TYPE
10383 && TREE_CODE (basetype) != TYPENAME_TYPE
10384 && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
10385 && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM)
10387 error ("base type %qT fails to be a struct or class type",
10392 if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0))
10393 TYPE_FOR_JAVA (ref) = 1;
10395 base_binfo = NULL_TREE;
10396 if (CLASS_TYPE_P (basetype) && !dependent_type_p (basetype))
10398 base_binfo = TYPE_BINFO (basetype);
10399 /* The original basetype could have been a typedef'd type. */
10400 basetype = BINFO_TYPE (base_binfo);
10402 /* Inherit flags from the base. */
10403 TYPE_HAS_NEW_OPERATOR (ref)
10404 |= TYPE_HAS_NEW_OPERATOR (basetype);
10405 TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
10406 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
10407 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
10408 TYPE_HAS_CONVERSION (ref) |= TYPE_HAS_CONVERSION (basetype);
10409 CLASSTYPE_DIAMOND_SHAPED_P (ref)
10410 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype);
10411 CLASSTYPE_REPEATED_BASE_P (ref)
10412 |= CLASSTYPE_REPEATED_BASE_P (basetype);
10415 /* We must do this test after we've seen through a typedef
10417 if (TYPE_MARKED_P (basetype))
10419 if (basetype == ref)
10420 error ("recursive type %qT undefined", basetype);
10422 error ("duplicate base type %qT invalid", basetype);
10426 if (PACK_EXPANSION_P (TREE_VALUE (base_list)))
10427 /* Regenerate the pack expansion for the bases. */
10428 basetype = make_pack_expansion (basetype);
10430 TYPE_MARKED_P (basetype) = 1;
10432 base_binfo = copy_binfo (base_binfo, basetype, ref,
10433 &igo_prev, via_virtual);
10434 if (!BINFO_INHERITANCE_CHAIN (base_binfo))
10435 BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
10437 BINFO_BASE_APPEND (binfo, base_binfo);
10438 BINFO_BASE_ACCESS_APPEND (binfo, access);
10441 if (VEC_space (tree, CLASSTYPE_VBASECLASSES (ref), 1))
10442 /* If we have space in the vbase vector, we must have shared at
10443 least one of them, and are therefore diamond shaped. */
10444 CLASSTYPE_DIAMOND_SHAPED_P (ref) = 1;
10446 /* Unmark all the types. */
10447 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
10448 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
10449 TYPE_MARKED_P (ref) = 0;
10451 /* Now see if we have a repeated base type. */
10452 if (!CLASSTYPE_REPEATED_BASE_P (ref))
10454 for (base_binfo = binfo; base_binfo;
10455 base_binfo = TREE_CHAIN (base_binfo))
10457 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
10459 CLASSTYPE_REPEATED_BASE_P (ref) = 1;
10462 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 1;
10464 for (base_binfo = binfo; base_binfo;
10465 base_binfo = TREE_CHAIN (base_binfo))
10466 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
10467 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
10476 /* Begin compiling the definition of an enumeration type.
10478 Returns the type object, as yet incomplete.
10479 Also records info about it so that build_enumerator
10480 may be used to declare the individual values as they are read. */
10483 start_enum (tree name)
10487 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
10489 /* If this is the real definition for a previous forward reference,
10490 fill in the contents in the same object that used to be the
10491 forward reference. */
10493 enumtype = lookup_and_check_tag (enum_type, name,
10494 /*tag_scope=*/ts_current,
10495 /*template_header_p=*/false);
10497 if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
10499 error ("multiple definition of %q#T", enumtype);
10500 error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype));
10501 /* Clear out TYPE_VALUES, and start again. */
10502 TYPE_VALUES (enumtype) = NULL_TREE;
10506 /* In case of error, make a dummy enum to allow parsing to
10508 if (enumtype == error_mark_node)
10509 name = make_anon_name ();
10511 enumtype = make_node (ENUMERAL_TYPE);
10512 enumtype = pushtag (name, enumtype, /*tag_scope=*/ts_current);
10518 /* After processing and defining all the values of an enumeration type,
10519 install their decls in the enumeration type and finish it off.
10520 ENUMTYPE is the type object and VALUES a list of name-value pairs. */
10523 finish_enum (tree enumtype)
10532 bool use_short_enum;
10536 integer_type_kind itk;
10537 tree underlying_type = NULL_TREE;
10539 /* We built up the VALUES in reverse order. */
10540 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
10542 /* For an enum defined in a template, just set the type of the values;
10543 all further processing is postponed until the template is
10544 instantiated. We need to set the type so that tsubst of a CONST_DECL
10546 if (processing_template_decl)
10548 for (values = TYPE_VALUES (enumtype);
10550 values = TREE_CHAIN (values))
10551 TREE_TYPE (TREE_VALUE (values)) = enumtype;
10552 if (at_function_scope_p ())
10553 add_stmt (build_min (TAG_DEFN, enumtype));
10557 /* Determine the minimum and maximum values of the enumerators. */
10558 if (TYPE_VALUES (enumtype))
10560 minnode = maxnode = NULL_TREE;
10562 for (values = TYPE_VALUES (enumtype);
10564 values = TREE_CHAIN (values))
10566 decl = TREE_VALUE (values);
10568 /* [dcl.enum]: Following the closing brace of an enum-specifier,
10569 each enumerator has the type of its enumeration. Prior to the
10570 closing brace, the type of each enumerator is the type of its
10571 initializing value. */
10572 TREE_TYPE (decl) = enumtype;
10574 /* Update the minimum and maximum values, if appropriate. */
10575 value = DECL_INITIAL (decl);
10576 if (value == error_mark_node)
10577 value = integer_zero_node;
10578 /* Figure out what the minimum and maximum values of the
10579 enumerators are. */
10581 minnode = maxnode = value;
10582 else if (tree_int_cst_lt (maxnode, value))
10584 else if (tree_int_cst_lt (value, minnode))
10591 If the enumerator-list is empty, the underlying type is as if
10592 the enumeration had a single enumerator with value 0. */
10593 minnode = maxnode = integer_zero_node;
10595 /* Compute the number of bits require to represent all values of the
10596 enumeration. We must do this before the type of MINNODE and
10597 MAXNODE are transformed, since min_precision relies on the
10598 TREE_TYPE of the value it is passed. */
10599 unsignedp = tree_int_cst_sgn (minnode) >= 0;
10600 lowprec = min_precision (minnode, unsignedp);
10601 highprec = min_precision (maxnode, unsignedp);
10602 precision = MAX (lowprec, highprec);
10604 /* Determine the underlying type of the enumeration.
10608 The underlying type of an enumeration is an integral type that
10609 can represent all the enumerator values defined in the
10610 enumeration. It is implementation-defined which integral type is
10611 used as the underlying type for an enumeration except that the
10612 underlying type shall not be larger than int unless the value of
10613 an enumerator cannot fit in an int or unsigned int.
10615 We use "int" or an "unsigned int" as the underlying type, even if
10616 a smaller integral type would work, unless the user has
10617 explicitly requested that we use the smallest possible type. The
10618 user can request that for all enumerations with a command line
10619 flag, or for just one enumeration with an attribute. */
10621 use_short_enum = flag_short_enums
10622 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype));
10624 for (itk = (use_short_enum ? itk_char : itk_int);
10628 underlying_type = integer_types[itk];
10629 if (TYPE_PRECISION (underlying_type) >= precision
10630 && TYPE_UNSIGNED (underlying_type) == unsignedp)
10633 if (itk == itk_none)
10637 IF no integral type can represent all the enumerator values, the
10638 enumeration is ill-formed. */
10639 error ("no integral type can represent all of the enumerator values "
10640 "for %qT", enumtype);
10641 precision = TYPE_PRECISION (long_long_integer_type_node);
10642 underlying_type = integer_types[itk_unsigned_long_long];
10645 /* Compute the minium and maximum values for the type.
10649 For an enumeration where emin is the smallest enumerator and emax
10650 is the largest, the values of the enumeration are the values of the
10651 underlying type in the range bmin to bmax, where bmin and bmax are,
10652 respectively, the smallest and largest values of the smallest bit-
10653 field that can store emin and emax. */
10655 /* The middle-end currently assumes that types with TYPE_PRECISION
10656 narrower than their underlying type are suitably zero or sign
10657 extended to fill their mode. g++ doesn't make these guarantees.
10658 Until the middle-end can represent such paradoxical types, we
10659 set the TYPE_PRECISION to the width of the underlying type. */
10660 TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type);
10662 set_min_and_max_values_for_integral_type (enumtype, precision, unsignedp);
10666 The value of sizeof() applied to an enumeration type, an object
10667 of an enumeration type, or an enumerator, is the value of sizeof()
10668 applied to the underlying type. */
10669 TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
10670 TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
10671 TYPE_MODE (enumtype) = TYPE_MODE (underlying_type);
10672 TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
10673 TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
10674 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);
10676 /* Convert each of the enumerators to the type of the underlying
10677 type of the enumeration. */
10678 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
10680 location_t saved_location;
10682 decl = TREE_VALUE (values);
10683 saved_location = input_location;
10684 input_location = DECL_SOURCE_LOCATION (decl);
10685 value = perform_implicit_conversion (underlying_type,
10686 DECL_INITIAL (decl));
10687 input_location = saved_location;
10689 /* Do not clobber shared ints. */
10690 value = copy_node (value);
10692 TREE_TYPE (value) = enumtype;
10693 DECL_INITIAL (decl) = value;
10694 TREE_VALUE (values) = value;
10697 /* Fix up all variant types of this enum type. */
10698 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
10700 TYPE_VALUES (t) = TYPE_VALUES (enumtype);
10701 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
10702 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
10703 TYPE_SIZE (t) = TYPE_SIZE (enumtype);
10704 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
10705 TYPE_MODE (t) = TYPE_MODE (enumtype);
10706 TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
10707 TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
10708 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
10709 TYPE_UNSIGNED (t) = TYPE_UNSIGNED (enumtype);
10712 /* Finish debugging output for this type. */
10713 rest_of_type_compilation (enumtype, namespace_bindings_p ());
10716 /* Build and install a CONST_DECL for an enumeration constant of the
10717 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
10718 Assignment of sequential values by default is handled here. */
10721 build_enumerator (tree name, tree value, tree enumtype)
10727 /* If the VALUE was erroneous, pretend it wasn't there; that will
10728 result in the enum being assigned the next value in sequence. */
10729 if (value == error_mark_node)
10732 /* Remove no-op casts from the value. */
10734 STRIP_TYPE_NOPS (value);
10736 if (! processing_template_decl)
10738 /* Validate and default VALUE. */
10739 if (value != NULL_TREE)
10741 value = integral_constant_value (value);
10743 if (TREE_CODE (value) == INTEGER_CST)
10745 value = perform_integral_promotions (value);
10746 constant_expression_warning (value);
10750 error ("enumerator value for %qD is not an integer constant", name);
10755 /* Default based on previous value. */
10756 if (value == NULL_TREE)
10758 if (TYPE_VALUES (enumtype))
10761 unsigned HOST_WIDE_INT lo;
10765 /* The next value is the previous value plus one. We can
10766 safely assume that the previous value is an INTEGER_CST.
10767 add_double doesn't know the type of the target expression,
10768 so we must check with int_fits_type_p as well. */
10769 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
10770 overflowed = add_double (TREE_INT_CST_LOW (prev_value),
10771 TREE_INT_CST_HIGH (prev_value),
10773 value = build_int_cst_wide (TREE_TYPE (prev_value), lo, hi);
10774 overflowed |= !int_fits_type_p (value, TREE_TYPE (prev_value));
10778 error ("overflow in enumeration values at %qD", name);
10779 value = error_mark_node;
10783 value = integer_zero_node;
10786 /* Remove no-op casts from the value. */
10787 STRIP_TYPE_NOPS (value);
10790 /* C++ associates enums with global, function, or class declarations. */
10791 context = current_scope ();
10793 /* Build the actual enumeration constant. Note that the enumeration
10794 constants have the type of their initializers until the
10795 enumeration is complete:
10799 Following the closing brace of an enum-specifier, each enumer-
10800 ator has the type of its enumeration. Prior to the closing
10801 brace, the type of each enumerator is the type of its
10802 initializing value.
10804 In finish_enum we will reset the type. Of course, if we're
10805 processing a template, there may be no value. */
10806 type = value ? TREE_TYPE (value) : NULL_TREE;
10808 if (context && context == current_class_type)
10809 /* This enum declaration is local to the class. We need the full
10810 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
10811 decl = build_lang_decl (CONST_DECL, name, type);
10813 /* It's a global enum, or it's local to a function. (Note local to
10814 a function could mean local to a class method. */
10815 decl = build_decl (CONST_DECL, name, type);
10817 DECL_CONTEXT (decl) = FROB_CONTEXT (context);
10818 TREE_CONSTANT (decl) = 1;
10819 TREE_INVARIANT (decl) = 1;
10820 TREE_READONLY (decl) = 1;
10821 DECL_INITIAL (decl) = value;
10823 if (context && context == current_class_type)
10824 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
10825 on the TYPE_FIELDS list for `S'. (That's so that you can say
10826 things like `S::i' later.) */
10827 finish_member_declaration (decl);
10831 /* Add this enumeration constant to the list for this type. */
10832 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
10836 /* We're defining DECL. Make sure that it's type is OK. */
10839 check_function_type (tree decl, tree current_function_parms)
10841 tree fntype = TREE_TYPE (decl);
10842 tree return_type = complete_type (TREE_TYPE (fntype));
10844 /* In a function definition, arg types must be complete. */
10845 require_complete_types_for_parms (current_function_parms);
10847 if (dependent_type_p (return_type))
10849 if (!COMPLETE_OR_VOID_TYPE_P (return_type))
10851 tree args = TYPE_ARG_TYPES (fntype);
10853 error ("return type %q#T is incomplete", return_type);
10855 /* Make it return void instead. */
10856 if (TREE_CODE (fntype) == METHOD_TYPE)
10857 fntype = build_method_type_directly (TREE_TYPE (TREE_VALUE (args)),
10859 TREE_CHAIN (args));
10861 fntype = build_function_type (void_type_node, args);
10863 = build_exception_variant (fntype,
10864 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)));
10867 abstract_virtuals_error (decl, TREE_TYPE (fntype));
10870 /* Create the FUNCTION_DECL for a function definition.
10871 DECLSPECS and DECLARATOR are the parts of the declaration;
10872 they describe the function's name and the type it returns,
10873 but twisted together in a fashion that parallels the syntax of C.
10875 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
10876 DECLARATOR is really the DECL for the function we are about to
10877 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
10878 indicating that the function is an inline defined in-class.
10880 This function creates a binding context for the function body
10881 as well as setting up the FUNCTION_DECL in current_function_decl.
10883 For C++, we must first check whether that datum makes any sense.
10884 For example, "class A local_a(1,2);" means that variable local_a
10885 is an aggregate of type A, which should have a constructor
10886 applied to it with the argument list [1, 2].
10888 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
10889 or may be a BLOCK if the function has been defined previously
10890 in this translation unit. On exit, DECL_INITIAL (decl1) will be
10891 error_mark_node if the function has never been defined, or
10892 a BLOCK if the function has been defined somewhere. */
10895 start_preparsed_function (tree decl1, tree attrs, int flags)
10897 tree ctype = NULL_TREE;
10900 int doing_friend = 0;
10901 struct cp_binding_level *bl;
10902 tree current_function_parms;
10903 struct c_fileinfo *finfo
10904 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1)));
10905 bool honor_interface;
10907 /* Sanity check. */
10908 gcc_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE);
10909 gcc_assert (TREE_CHAIN (void_list_node) == NULL_TREE);
10911 fntype = TREE_TYPE (decl1);
10912 if (TREE_CODE (fntype) == METHOD_TYPE)
10913 ctype = TYPE_METHOD_BASETYPE (fntype);
10915 /* ISO C++ 11.4/5. A friend function defined in a class is in
10916 the (lexical) scope of the class in which it is defined. */
10917 if (!ctype && DECL_FRIEND_P (decl1))
10919 ctype = DECL_FRIEND_CONTEXT (decl1);
10921 /* CTYPE could be null here if we're dealing with a template;
10922 for example, `inline friend float foo()' inside a template
10923 will have no CTYPE set. */
10924 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
10930 if (DECL_DECLARED_INLINE_P (decl1)
10931 && lookup_attribute ("noinline", attrs))
10932 warning (0, "inline function %q+D given attribute noinline", decl1);
10934 /* Handle gnu_inline attribute. */
10935 if (GNU_INLINE_P (decl1))
10937 DECL_EXTERNAL (decl1) = 1;
10938 DECL_NOT_REALLY_EXTERN (decl1) = 0;
10939 DECL_INTERFACE_KNOWN (decl1) = 1;
10940 DECL_DISREGARD_INLINE_LIMITS (decl1) = 1;
10943 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
10944 /* This is a constructor, we must ensure that any default args
10945 introduced by this definition are propagated to the clones
10946 now. The clones are used directly in overload resolution. */
10947 adjust_clone_args (decl1);
10949 /* Sometimes we don't notice that a function is a static member, and
10950 build a METHOD_TYPE for it. Fix that up now. */
10951 if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
10952 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
10954 revert_static_member_fn (decl1);
10958 /* Set up current_class_type, and enter the scope of the class, if
10961 push_nested_class (ctype);
10962 else if (DECL_STATIC_FUNCTION_P (decl1))
10963 push_nested_class (DECL_CONTEXT (decl1));
10965 /* Now that we have entered the scope of the class, we must restore
10966 the bindings for any template parameters surrounding DECL1, if it
10967 is an inline member template. (Order is important; consider the
10968 case where a template parameter has the same name as a field of
10969 the class.) It is not until after this point that
10970 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
10971 if (flags & SF_INCLASS_INLINE)
10972 maybe_begin_member_template_processing (decl1);
10974 /* Effective C++ rule 15. */
10976 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
10977 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
10978 warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");
10980 /* Make the init_value nonzero so pushdecl knows this is not tentative.
10981 error_mark_node is replaced below (in poplevel) with the BLOCK. */
10982 if (!DECL_INITIAL (decl1))
10983 DECL_INITIAL (decl1) = error_mark_node;
10985 /* This function exists in static storage.
10986 (This does not mean `static' in the C sense!) */
10987 TREE_STATIC (decl1) = 1;
10989 /* We must call push_template_decl after current_class_type is set
10990 up. (If we are processing inline definitions after exiting a
10991 class scope, current_class_type will be NULL_TREE until set above
10992 by push_nested_class.) */
10993 if (processing_template_decl)
10995 /* FIXME: Handle error_mark_node more gracefully. */
10996 tree newdecl1 = push_template_decl (decl1);
10997 if (newdecl1 != error_mark_node)
11001 /* We are now in the scope of the function being defined. */
11002 current_function_decl = decl1;
11004 /* Save the parm names or decls from this function's declarator
11005 where store_parm_decls will find them. */
11006 current_function_parms = DECL_ARGUMENTS (decl1);
11008 /* Make sure the parameter and return types are reasonable. When
11009 you declare a function, these types can be incomplete, but they
11010 must be complete when you define the function. */
11011 check_function_type (decl1, current_function_parms);
11013 /* Build the return declaration for the function. */
11014 restype = TREE_TYPE (fntype);
11015 if (DECL_RESULT (decl1) == NULL_TREE)
11019 resdecl = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
11020 DECL_ARTIFICIAL (resdecl) = 1;
11021 DECL_IGNORED_P (resdecl) = 1;
11022 DECL_RESULT (decl1) = resdecl;
11024 cp_apply_type_quals_to_decl (cp_type_quals (restype), resdecl);
11027 /* Let the user know we're compiling this function. */
11028 announce_function (decl1);
11030 /* Record the decl so that the function name is defined.
11031 If we already have a decl for this name, and it is a FUNCTION_DECL,
11032 use the old decl. */
11033 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
11035 /* A specialization is not used to guide overload resolution. */
11036 if (!DECL_FUNCTION_MEMBER_P (decl1)
11037 && !(DECL_USE_TEMPLATE (decl1) &&
11038 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1))))
11040 tree olddecl = pushdecl (decl1);
11042 if (olddecl == error_mark_node)
11043 /* If something went wrong when registering the declaration,
11044 use DECL1; we have to have a FUNCTION_DECL to use when
11045 parsing the body of the function. */
11049 /* Otherwise, OLDDECL is either a previous declaration
11050 of the same function or DECL1 itself. */
11052 if (warn_missing_declarations
11053 && olddecl == decl1
11054 && !DECL_MAIN_P (decl1)
11055 && TREE_PUBLIC (decl1)
11056 && !DECL_DECLARED_INLINE_P (decl1))
11060 /* Check whether DECL1 is in an anonymous
11062 for (context = DECL_CONTEXT (decl1);
11064 context = DECL_CONTEXT (context))
11066 if (TREE_CODE (context) == NAMESPACE_DECL
11067 && DECL_NAME (context) == NULL_TREE)
11071 if (context == NULL)
11072 warning (OPT_Wmissing_declarations,
11073 "no previous declaration for %q+D", decl1);
11081 /* We need to set the DECL_CONTEXT. */
11082 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
11083 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
11085 fntype = TREE_TYPE (decl1);
11087 /* If #pragma weak applies, mark the decl appropriately now.
11088 The pragma only applies to global functions. Because
11089 determining whether or not the #pragma applies involves
11090 computing the mangled name for the declaration, we cannot
11091 apply the pragma until after we have merged this declaration
11092 with any previous declarations; if the original declaration
11093 has a linkage specification, that specification applies to
11094 the definition as well, and may affect the mangled name. */
11095 if (!DECL_CONTEXT (decl1))
11096 maybe_apply_pragma_weak (decl1);
11099 /* Reset this in case the call to pushdecl changed it. */
11100 current_function_decl = decl1;
11102 gcc_assert (DECL_INITIAL (decl1));
11104 /* This function may already have been parsed, in which case just
11105 return; our caller will skip over the body without parsing. */
11106 if (DECL_INITIAL (decl1) != error_mark_node)
11109 /* Initialize RTL machinery. We cannot do this until
11110 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
11111 even when processing a template; this is how we get
11112 CFUN set up, and our per-function variables initialized.
11113 FIXME factor out the non-RTL stuff. */
11114 bl = current_binding_level;
11115 allocate_struct_function (decl1);
11116 current_binding_level = bl;
11118 /* Even though we're inside a function body, we still don't want to
11119 call expand_expr to calculate the size of a variable-sized array.
11120 We haven't necessarily assigned RTL to all variables yet, so it's
11121 not safe to try to expand expressions involving them. */
11122 cfun->x_dont_save_pending_sizes_p = 1;
11124 /* Start the statement-tree, start the tree now. */
11125 DECL_SAVED_TREE (decl1) = push_stmt_list ();
11127 /* If we are (erroneously) defining a function that we have already
11128 defined before, wipe out what we knew before. */
11129 if (!DECL_PENDING_INLINE_P (decl1))
11130 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
11132 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
11134 /* We know that this was set up by `grokclassfn'. We do not
11135 wait until `store_parm_decls', since evil parse errors may
11136 never get us to that point. Here we keep the consistency
11137 between `current_class_type' and `current_class_ptr'. */
11138 tree t = DECL_ARGUMENTS (decl1);
11140 gcc_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL);
11141 gcc_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE);
11143 cp_function_chain->x_current_class_ref
11144 = build_indirect_ref (t, NULL);
11145 cp_function_chain->x_current_class_ptr = t;
11147 /* Constructors and destructors need to know whether they're "in
11148 charge" of initializing virtual base classes. */
11149 t = TREE_CHAIN (t);
11150 if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
11152 current_in_charge_parm = t;
11153 t = TREE_CHAIN (t);
11155 if (DECL_HAS_VTT_PARM_P (decl1))
11157 gcc_assert (DECL_NAME (t) == vtt_parm_identifier);
11158 current_vtt_parm = t;
11162 honor_interface = (!DECL_TEMPLATE_INSTANTIATION (decl1)
11163 /* Implicitly-defined methods (like the
11164 destructor for a class in which no destructor
11165 is explicitly declared) must not be defined
11166 until their definition is needed. So, we
11167 ignore interface specifications for
11168 compiler-generated functions. */
11169 && !DECL_ARTIFICIAL (decl1));
11171 if (DECL_INTERFACE_KNOWN (decl1))
11173 tree ctx = decl_function_context (decl1);
11175 if (DECL_NOT_REALLY_EXTERN (decl1))
11176 DECL_EXTERNAL (decl1) = 0;
11178 if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
11179 && TREE_PUBLIC (ctx))
11180 /* This is a function in a local class in an extern inline
11182 comdat_linkage (decl1);
11184 /* If this function belongs to an interface, it is public.
11185 If it belongs to someone else's interface, it is also external.
11186 This only affects inlines and template instantiations. */
11187 else if (!finfo->interface_unknown && honor_interface)
11189 if (DECL_DECLARED_INLINE_P (decl1)
11190 || DECL_TEMPLATE_INSTANTIATION (decl1)
11191 || processing_template_decl)
11193 DECL_EXTERNAL (decl1)
11194 = (finfo->interface_only
11195 || (DECL_DECLARED_INLINE_P (decl1)
11196 && ! flag_implement_inlines
11197 && !DECL_VINDEX (decl1)));
11199 /* For WIN32 we also want to put these in linkonce sections. */
11200 maybe_make_one_only (decl1);
11203 DECL_EXTERNAL (decl1) = 0;
11204 DECL_INTERFACE_KNOWN (decl1) = 1;
11205 /* If this function is in an interface implemented in this file,
11206 make sure that the back end knows to emit this function
11208 if (!DECL_EXTERNAL (decl1))
11209 mark_needed (decl1);
11211 else if (finfo->interface_unknown && finfo->interface_only
11212 && honor_interface)
11214 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
11215 interface, we will have both finfo->interface_unknown and
11216 finfo->interface_only set. In that case, we don't want to
11217 use the normal heuristics because someone will supply a
11218 #pragma implementation elsewhere, and deducing it here would
11219 produce a conflict. */
11220 comdat_linkage (decl1);
11221 DECL_EXTERNAL (decl1) = 0;
11222 DECL_INTERFACE_KNOWN (decl1) = 1;
11223 DECL_DEFER_OUTPUT (decl1) = 1;
11227 /* This is a definition, not a reference.
11228 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
11229 if (!GNU_INLINE_P (decl1))
11230 DECL_EXTERNAL (decl1) = 0;
11232 if ((DECL_DECLARED_INLINE_P (decl1)
11233 || DECL_TEMPLATE_INSTANTIATION (decl1))
11234 && ! DECL_INTERFACE_KNOWN (decl1)
11235 /* Don't try to defer nested functions for now. */
11236 && ! decl_function_context (decl1))
11237 DECL_DEFER_OUTPUT (decl1) = 1;
11239 DECL_INTERFACE_KNOWN (decl1) = 1;
11242 /* Determine the ELF visibility attribute for the function. We must not
11243 do this before calling "pushdecl", as we must allow "duplicate_decls"
11244 to merge any attributes appropriately. We also need to wait until
11246 if (!DECL_CLONED_FUNCTION_P (decl1))
11247 determine_visibility (decl1);
11249 begin_scope (sk_function_parms, decl1);
11253 if (DECL_DESTRUCTOR_P (decl1)
11254 || (DECL_CONSTRUCTOR_P (decl1)
11255 && targetm.cxx.cdtor_returns_this ()))
11257 cdtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
11258 DECL_CONTEXT (cdtor_label) = current_function_decl;
11261 start_fname_decls ();
11263 store_parm_decls (current_function_parms);
11267 /* Like start_preparsed_function, except that instead of a
11268 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
11270 Returns 1 on success. If the DECLARATOR is not suitable for a function
11271 (it defines a datum instead), we return 0, which tells
11272 yyparse to report a parse error. */
11275 start_function (cp_decl_specifier_seq *declspecs,
11276 const cp_declarator *declarator,
11281 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
11282 /* If the declarator is not suitable for a function definition,
11283 cause a syntax error. */
11284 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
11287 if (DECL_MAIN_P (decl1))
11288 /* main must return int. grokfndecl should have corrected it
11289 (and issued a diagnostic) if the user got it wrong. */
11290 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1)),
11291 integer_type_node));
11293 start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT);
11298 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
11302 use_eh_spec_block (tree fn)
11304 return (flag_exceptions && flag_enforce_eh_specs
11305 && !processing_template_decl
11306 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn))
11307 /* We insert the EH_SPEC_BLOCK only in the original
11308 function; then, it is copied automatically to the
11310 && !DECL_CLONED_FUNCTION_P (fn)
11311 /* Implicitly-generated constructors and destructors have
11312 exception specifications. However, those specifications
11313 are the union of the possible exceptions specified by the
11314 constructors/destructors for bases and members, so no
11315 unallowed exception will ever reach this function. By
11316 not creating the EH_SPEC_BLOCK we save a little memory,
11317 and we avoid spurious warnings about unreachable
11319 && !DECL_ARTIFICIAL (fn));
11322 /* Store the parameter declarations into the current function declaration.
11323 This is called after parsing the parameter declarations, before
11324 digesting the body of the function.
11326 Also install to binding contour return value identifier, if any. */
11329 store_parm_decls (tree current_function_parms)
11331 tree fndecl = current_function_decl;
11334 /* This is a chain of any other decls that came in among the parm
11335 declarations. If a parm is declared with enum {foo, bar} x;
11336 then CONST_DECLs for foo and bar are put here. */
11337 tree nonparms = NULL_TREE;
11339 if (current_function_parms)
11341 /* This case is when the function was defined with an ANSI prototype.
11342 The parms already have decls, so we need not do anything here
11343 except record them as in effect
11344 and complain if any redundant old-style parm decls were written. */
11346 tree specparms = current_function_parms;
11349 /* Must clear this because it might contain TYPE_DECLs declared
11351 current_binding_level->names = NULL;
11353 /* If we're doing semantic analysis, then we'll call pushdecl
11354 for each of these. We must do them in reverse order so that
11355 they end in the correct forward order. */
11356 specparms = nreverse (specparms);
11358 for (parm = specparms; parm; parm = next)
11360 next = TREE_CHAIN (parm);
11361 if (TREE_CODE (parm) == PARM_DECL)
11363 if (DECL_NAME (parm) == NULL_TREE
11364 || TREE_CODE (parm) != VOID_TYPE)
11367 error ("parameter %qD declared void", parm);
11371 /* If we find an enum constant or a type tag,
11372 put it aside for the moment. */
11373 TREE_CHAIN (parm) = NULL_TREE;
11374 nonparms = chainon (nonparms, parm);
11378 /* Get the decls in their original chain order and record in the
11379 function. This is all and only the PARM_DECLs that were
11380 pushed into scope by the loop above. */
11381 DECL_ARGUMENTS (fndecl) = getdecls ();
11384 DECL_ARGUMENTS (fndecl) = NULL_TREE;
11386 /* Now store the final chain of decls for the arguments
11387 as the decl-chain of the current lexical scope.
11388 Put the enumerators in as well, at the front so that
11389 DECL_ARGUMENTS is not modified. */
11390 current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));
11392 if (use_eh_spec_block (current_function_decl))
11393 current_eh_spec_block = begin_eh_spec_block ();
11397 /* We have finished doing semantic analysis on DECL, but have not yet
11398 generated RTL for its body. Save away our current state, so that
11399 when we want to generate RTL later we know what to do. */
11402 save_function_data (tree decl)
11404 struct language_function *f;
11406 /* Save the language-specific per-function data so that we can
11407 get it back when we really expand this function. */
11408 gcc_assert (!DECL_PENDING_INLINE_P (decl));
11411 f = GGC_NEW (struct language_function);
11412 memcpy (f, cp_function_chain, sizeof (struct language_function));
11413 DECL_SAVED_FUNCTION_DATA (decl) = f;
11415 /* Clear out the bits we don't need. */
11416 f->base.x_stmt_tree.x_cur_stmt_list = NULL_TREE;
11417 f->bindings = NULL;
11418 f->x_local_names = NULL;
11422 /* Set the return value of the constructor (if present). */
11425 finish_constructor_body (void)
11430 if (targetm.cxx.cdtor_returns_this ())
11432 /* Any return from a constructor will end up here. */
11433 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
11435 val = DECL_ARGUMENTS (current_function_decl);
11436 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
11437 DECL_RESULT (current_function_decl), val);
11438 /* Return the address of the object. */
11439 exprstmt = build_stmt (RETURN_EXPR, val);
11440 add_stmt (exprstmt);
11444 /* Do all the processing for the beginning of a destructor; set up the
11445 vtable pointers and cleanups for bases and members. */
11448 begin_destructor_body (void)
11450 tree compound_stmt;
11452 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
11453 issued an error message. We still want to try to process the
11454 body of the function, but initialize_vtbl_ptrs will crash if
11455 TYPE_BINFO is NULL. */
11456 if (COMPLETE_TYPE_P (current_class_type))
11458 compound_stmt = begin_compound_stmt (0);
11459 /* Make all virtual function table pointers in non-virtual base
11460 classes point to CURRENT_CLASS_TYPE's virtual function
11462 initialize_vtbl_ptrs (current_class_ptr);
11463 finish_compound_stmt (compound_stmt);
11465 /* And insert cleanups for our bases and members so that they
11466 will be properly destroyed if we throw. */
11467 push_base_cleanups ();
11471 /* At the end of every destructor we generate code to delete the object if
11472 necessary. Do that now. */
11475 finish_destructor_body (void)
11479 /* Any return from a destructor will end up here; that way all base
11480 and member cleanups will be run when the function returns. */
11481 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
11483 /* In a virtual destructor, we must call delete. */
11484 if (DECL_VIRTUAL_P (current_function_decl))
11487 tree virtual_size = cxx_sizeof (current_class_type);
11491 At the point of definition of a virtual destructor (including
11492 an implicit definition), non-placement operator delete shall
11493 be looked up in the scope of the destructor's class and if
11494 found shall be accessible and unambiguous. */
11495 exprstmt = build_op_delete_call(DELETE_EXPR, current_class_ptr,
11497 /*global_p=*/false,
11498 /*placement=*/NULL_TREE,
11499 /*alloc_fn=*/NULL_TREE);
11501 if_stmt = begin_if_stmt ();
11502 finish_if_stmt_cond (build2 (BIT_AND_EXPR, integer_type_node,
11503 current_in_charge_parm,
11506 finish_expr_stmt (exprstmt);
11507 finish_then_clause (if_stmt);
11508 finish_if_stmt (if_stmt);
11511 if (targetm.cxx.cdtor_returns_this ())
11515 val = DECL_ARGUMENTS (current_function_decl);
11516 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
11517 DECL_RESULT (current_function_decl), val);
11518 /* Return the address of the object. */
11519 exprstmt = build_stmt (RETURN_EXPR, val);
11520 add_stmt (exprstmt);
11524 /* Do the necessary processing for the beginning of a function body, which
11525 in this case includes member-initializers, but not the catch clauses of
11526 a function-try-block. Currently, this means opening a binding level
11527 for the member-initializers (in a ctor) and member cleanups (in a dtor). */
11530 begin_function_body (void)
11534 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
11537 if (processing_template_decl)
11538 /* Do nothing now. */;
11540 /* Always keep the BLOCK node associated with the outermost pair of
11541 curly braces of a function. These are needed for correct
11542 operation of dwarfout.c. */
11543 keep_next_level (true);
11545 stmt = begin_compound_stmt (BCS_FN_BODY);
11547 if (processing_template_decl)
11548 /* Do nothing now. */;
11549 else if (DECL_DESTRUCTOR_P (current_function_decl))
11550 begin_destructor_body ();
11555 /* Do the processing for the end of a function body. Currently, this means
11556 closing out the cleanups for fully-constructed bases and members, and in
11557 the case of the destructor, deleting the object if desired. Again, this
11558 is only meaningful for [cd]tors, since they are the only functions where
11559 there is a significant distinction between the main body and any
11560 function catch clauses. Handling, say, main() return semantics here
11561 would be wrong, as flowing off the end of a function catch clause for
11562 main() would also need to return 0. */
11565 finish_function_body (tree compstmt)
11567 if (compstmt == NULL_TREE)
11570 /* Close the block. */
11571 finish_compound_stmt (compstmt);
11573 if (processing_template_decl)
11574 /* Do nothing now. */;
11575 else if (DECL_CONSTRUCTOR_P (current_function_decl))
11576 finish_constructor_body ();
11577 else if (DECL_DESTRUCTOR_P (current_function_decl))
11578 finish_destructor_body ();
11581 /* Given a function, returns the BLOCK corresponding to the outermost level
11582 of curly braces, skipping the artificial block created for constructor
11586 outer_curly_brace_block (tree fndecl)
11588 tree block = BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl));
11589 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
11590 /* Skip the artificial function body block. */
11591 block = BLOCK_SUBBLOCKS (block);
11595 /* Finish up a function declaration and compile that function
11596 all the way to assembler language output. The free the storage
11597 for the function definition.
11599 FLAGS is a bitwise or of the following values:
11601 We just finished processing the body of an in-class inline
11602 function definition. (This processing will have taken place
11603 after the class definition is complete.) */
11606 finish_function (int flags)
11608 tree fndecl = current_function_decl;
11609 tree fntype, ctype = NULL_TREE;
11610 int inclass_inline = (flags & 2) != 0;
11613 /* When we get some parse errors, we can end up without a
11614 current_function_decl, so cope. */
11615 if (fndecl == NULL_TREE)
11616 return error_mark_node;
11618 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
11619 && DECL_VIRTUAL_P (fndecl)
11620 && !processing_template_decl)
11622 tree fnclass = DECL_CONTEXT (fndecl);
11623 if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
11624 keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
11627 nested = function_depth > 1;
11628 fntype = TREE_TYPE (fndecl);
11630 /* TREE_READONLY (fndecl) = 1;
11631 This caused &foo to be of type ptr-to-const-function
11632 which then got a warning when stored in a ptr-to-function variable. */
11634 gcc_assert (building_stmt_tree ());
11635 /* The current function is being defined, so its DECL_INITIAL should
11636 be set, and unless there's a multiple definition, it should be
11637 error_mark_node. */
11638 gcc_assert (DECL_INITIAL (fndecl) == error_mark_node);
11640 /* For a cloned function, we've already got all the code we need;
11641 there's no need to add any extra bits. */
11642 if (!DECL_CLONED_FUNCTION_P (fndecl))
11644 if (DECL_MAIN_P (current_function_decl))
11648 /* Make it so that `main' always returns 0 by default (or
11651 stmt = finish_return_stmt (integer_one_node);
11653 stmt = finish_return_stmt (integer_zero_node);
11655 /* Hack. We don't want the middle-end to warn that this
11656 return is unreachable, so put the statement on the
11658 #ifdef USE_MAPPED_LOCATION
11660 location_t linezero = linemap_line_start (line_table, 0, 1);
11661 SET_EXPR_LOCATION (stmt, linezero);
11664 annotate_with_file_line (stmt, input_filename, 0);
11668 if (use_eh_spec_block (current_function_decl))
11669 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
11670 (TREE_TYPE (current_function_decl)),
11671 current_eh_spec_block);
11674 /* If we're saving up tree structure, tie off the function now. */
11675 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
11677 finish_fname_decls ();
11679 /* If this function can't throw any exceptions, remember that. */
11680 if (!processing_template_decl
11681 && !cp_function_chain->can_throw
11682 && !flag_non_call_exceptions
11683 && !DECL_REPLACEABLE_P (fndecl))
11684 TREE_NOTHROW (fndecl) = 1;
11686 /* This must come after expand_function_end because cleanups might
11687 have declarations (from inline functions) that need to go into
11688 this function's blocks. */
11690 /* If the current binding level isn't the outermost binding level
11691 for this function, either there is a bug, or we have experienced
11692 syntax errors and the statement tree is malformed. */
11693 if (current_binding_level->kind != sk_function_parms)
11695 /* Make sure we have already experienced errors. */
11696 gcc_assert (errorcount);
11698 /* Throw away the broken statement tree and extra binding
11700 DECL_SAVED_TREE (fndecl) = alloc_stmt_list ();
11702 while (current_binding_level->kind != sk_function_parms)
11704 if (current_binding_level->kind == sk_class)
11705 pop_nested_class ();
11707 poplevel (0, 0, 0);
11710 poplevel (1, 0, 1);
11712 /* Statements should always be full-expressions at the outermost set
11713 of curly braces for a function. */
11714 gcc_assert (stmts_are_full_exprs_p ());
11716 /* Set up the named return value optimization, if we can. Candidate
11717 variables are selected in check_return_expr. */
11718 if (current_function_return_value)
11720 tree r = current_function_return_value;
11723 if (r != error_mark_node
11724 /* This is only worth doing for fns that return in memory--and
11725 simpler, since we don't have to worry about promoted modes. */
11726 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
11727 /* Only allow this for variables declared in the outer scope of
11728 the function so we know that their lifetime always ends with a
11729 return; see g++.dg/opt/nrv6.C. We could be more flexible if
11730 we were to do this optimization in tree-ssa. */
11731 && (outer = outer_curly_brace_block (fndecl))
11732 && chain_member (r, BLOCK_VARS (outer)))
11733 finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));
11735 current_function_return_value = NULL_TREE;
11738 /* Remember that we were in class scope. */
11739 if (current_class_name)
11740 ctype = current_class_type;
11742 /* Must mark the RESULT_DECL as being in this function. */
11743 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
11745 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
11746 to the FUNCTION_DECL node itself. */
11747 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
11749 /* Save away current state, if appropriate. */
11750 if (!processing_template_decl)
11751 save_function_data (fndecl);
11753 /* Complain if there's just no return statement. */
11754 if (warn_return_type
11755 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
11756 && !dependent_type_p (TREE_TYPE (fntype))
11757 && !current_function_returns_value && !current_function_returns_null
11758 /* Don't complain if we abort or throw. */
11759 && !current_function_returns_abnormally
11760 && !DECL_NAME (DECL_RESULT (fndecl))
11761 /* Normally, with -Wreturn-type, flow will complain. Unless we're an
11762 inline function, as we might never be compiled separately. */
11763 && (DECL_INLINE (fndecl) || processing_template_decl)
11764 /* Structor return values (if any) are set by the compiler. */
11765 && !DECL_CONSTRUCTOR_P (fndecl)
11766 && !DECL_DESTRUCTOR_P (fndecl))
11767 warning (OPT_Wreturn_type, "no return statement in function returning non-void");
11769 /* Store the end of the function, so that we get good line number
11770 info for the epilogue. */
11771 cfun->function_end_locus = input_location;
11773 /* Genericize before inlining. */
11774 if (!processing_template_decl)
11776 struct language_function *f = DECL_SAVED_FUNCTION_DATA (fndecl);
11777 cp_genericize (fndecl);
11778 /* Clear out the bits we don't need. */
11779 f->x_current_class_ptr = NULL;
11780 f->x_current_class_ref = NULL;
11781 f->x_eh_spec_block = NULL;
11782 f->x_in_charge_parm = NULL;
11783 f->x_vtt_parm = NULL;
11784 f->x_return_value = NULL;
11785 f->bindings = NULL;
11786 f->extern_decl_map = NULL;
11788 /* Handle attribute((warn_unused_result)). Relies on gimple input. */
11789 c_warn_unused_result (&DECL_SAVED_TREE (fndecl));
11791 /* Clear out the bits we don't need. */
11792 local_names = NULL;
11794 /* We're leaving the context of this function, so zap cfun. It's still in
11795 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
11797 current_function_decl = NULL;
11799 /* If this is an in-class inline definition, we may have to pop the
11800 bindings for the template parameters that we added in
11801 maybe_begin_member_template_processing when start_function was
11803 if (inclass_inline)
11804 maybe_end_member_template_processing ();
11806 /* Leave the scope of the class. */
11808 pop_nested_class ();
11814 /* Let the error reporting routines know that we're outside a
11815 function. For a nested function, this value is used in
11816 cxx_pop_function_context and then reset via pop_function_context. */
11817 current_function_decl = NULL_TREE;
11822 /* Create the FUNCTION_DECL for a function definition.
11823 DECLSPECS and DECLARATOR are the parts of the declaration;
11824 they describe the return type and the name of the function,
11825 but twisted together in a fashion that parallels the syntax of C.
11827 This function creates a binding context for the function body
11828 as well as setting up the FUNCTION_DECL in current_function_decl.
11830 Returns a FUNCTION_DECL on success.
11832 If the DECLARATOR is not suitable for a function (it defines a datum
11833 instead), we return 0, which tells yyparse to report a parse error.
11835 May return void_type_node indicating that this method is actually
11836 a friend. See grokfield for more details.
11838 Came here with a `.pushlevel' .
11840 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
11841 CHANGES TO CODE IN `grokfield'. */
11844 start_method (cp_decl_specifier_seq *declspecs,
11845 const cp_declarator *declarator, tree attrlist)
11847 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
11850 if (fndecl == error_mark_node)
11851 return error_mark_node;
11853 if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
11855 error ("invalid member function declaration");
11856 return error_mark_node;
11860 cplus_decl_attributes (&fndecl, attrlist, 0);
11862 /* Pass friends other than inline friend functions back. */
11863 if (fndecl == void_type_node)
11866 if (DECL_IN_AGGR_P (fndecl))
11868 if (DECL_CONTEXT (fndecl)
11869 && TREE_CODE (DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
11870 error ("%qD is already defined in class %qT", fndecl,
11871 DECL_CONTEXT (fndecl));
11872 return error_mark_node;
11875 check_template_shadow (fndecl);
11877 DECL_DECLARED_INLINE_P (fndecl) = 1;
11878 if (flag_default_inline)
11879 DECL_INLINE (fndecl) = 1;
11881 /* We process method specializations in finish_struct_1. */
11882 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
11884 fndecl = push_template_decl (fndecl);
11885 if (fndecl == error_mark_node)
11889 if (! DECL_FRIEND_P (fndecl))
11891 if (TREE_CHAIN (fndecl))
11893 fndecl = copy_node (fndecl);
11894 TREE_CHAIN (fndecl) = NULL_TREE;
11898 finish_decl (fndecl, NULL_TREE, NULL_TREE);
11900 /* Make a place for the parms. */
11901 begin_scope (sk_function_parms, fndecl);
11903 DECL_IN_AGGR_P (fndecl) = 1;
11907 /* Go through the motions of finishing a function definition.
11908 We don't compile this method until after the whole class has
11911 FINISH_METHOD must return something that looks as though it
11912 came from GROKFIELD (since we are defining a method, after all).
11914 This is called after parsing the body of the function definition.
11915 STMTS is the chain of statements that makes up the function body.
11917 DECL is the ..._DECL that `start_method' provided. */
11920 finish_method (tree decl)
11922 tree fndecl = decl;
11927 if (decl == void_type_node)
11930 old_initial = DECL_INITIAL (fndecl);
11932 /* Undo the level for the parms (from start_method).
11933 This is like poplevel, but it causes nothing to be
11934 saved. Saving information here confuses symbol-table
11935 output routines. Besides, this information will
11936 be correctly output when this method is actually
11939 /* Clear out the meanings of the local variables of this level;
11940 also record in each decl which block it belongs to. */
11942 for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
11944 if (DECL_NAME (link) != NULL_TREE)
11945 pop_binding (DECL_NAME (link), link);
11946 gcc_assert (TREE_CODE (link) != FUNCTION_DECL);
11947 DECL_CONTEXT (link) = NULL_TREE;
11950 poplevel (0, 0, 0);
11952 DECL_INITIAL (fndecl) = old_initial;
11954 /* We used to check if the context of FNDECL was different from
11955 current_class_type as another way to get inside here. This didn't work
11956 for String.cc in libg++. */
11957 if (DECL_FRIEND_P (fndecl))
11959 VEC_safe_push (tree, gc, CLASSTYPE_INLINE_FRIENDS (current_class_type),
11961 decl = void_type_node;
11968 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
11969 we can lay it out later, when and if its type becomes complete. */
11972 maybe_register_incomplete_var (tree var)
11974 gcc_assert (TREE_CODE (var) == VAR_DECL);
11976 /* Keep track of variables with incomplete types. */
11977 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
11978 && DECL_EXTERNAL (var))
11980 tree inner_type = TREE_TYPE (var);
11982 while (TREE_CODE (inner_type) == ARRAY_TYPE)
11983 inner_type = TREE_TYPE (inner_type);
11984 inner_type = TYPE_MAIN_VARIANT (inner_type);
11986 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
11987 /* RTTI TD entries are created while defining the type_info. */
11988 || (TYPE_LANG_SPECIFIC (inner_type)
11989 && TYPE_BEING_DEFINED (inner_type)))
11990 incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
11994 /* Called when a class type (given by TYPE) is defined. If there are
11995 any existing VAR_DECLs whose type hsa been completed by this
11996 declaration, update them now. */
11999 complete_vars (tree type)
12001 tree *list = &incomplete_vars;
12003 gcc_assert (CLASS_TYPE_P (type));
12006 if (same_type_p (type, TREE_PURPOSE (*list)))
12008 tree var = TREE_VALUE (*list);
12009 tree type = TREE_TYPE (var);
12010 /* Complete the type of the variable. The VAR_DECL itself
12011 will be laid out in expand_expr. */
12012 complete_type (type);
12013 cp_apply_type_quals_to_decl (cp_type_quals (type), var);
12014 /* Remove this entry from the list. */
12015 *list = TREE_CHAIN (*list);
12018 list = &TREE_CHAIN (*list);
12021 /* Check for pending declarations which may have abstract type. */
12022 complete_type_check_abstract (type);
12025 /* If DECL is of a type which needs a cleanup, build and return an
12026 expression to perform that cleanup here. Return NULL_TREE if no
12027 cleanup need be done. */
12030 cxx_maybe_build_cleanup (tree decl)
12036 /* Assume no cleanup is required. */
12037 cleanup = NULL_TREE;
12039 if (error_operand_p (decl))
12042 /* Handle "__attribute__((cleanup))". We run the cleanup function
12043 before the destructor since the destructor is what actually
12044 terminates the lifetime of the object. */
12045 attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
12052 /* Get the name specified by the user for the cleanup function. */
12053 id = TREE_VALUE (TREE_VALUE (attr));
12054 /* Look up the name to find the cleanup function to call. It is
12055 important to use lookup_name here because that is what is
12056 used in c-common.c:handle_cleanup_attribute when performing
12057 initial checks on the attribute. Note that those checks
12058 include ensuring that the function found is not an overloaded
12059 function, or an object with an overloaded call operator,
12060 etc.; we can rely on the fact that the functionfound is an
12061 ordinary FUNCTION_DECL. */
12062 fn = lookup_name (id);
12063 arg = build_address (decl);
12065 cleanup = build_function_call (fn, build_tree_list (NULL_TREE,
12068 /* Handle ordinary C++ destructors. */
12069 type = TREE_TYPE (decl);
12070 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
12072 int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
12073 bool has_vbases = (TREE_CODE (type) == RECORD_TYPE
12074 && CLASSTYPE_VBASECLASSES (type));
12078 if (TREE_CODE (type) == ARRAY_TYPE)
12082 cxx_mark_addressable (decl);
12083 addr = build_unary_op (ADDR_EXPR, decl, 0);
12086 /* Optimize for space over speed here. */
12087 if (!has_vbases || flag_expensive_optimizations)
12088 flags |= LOOKUP_NONVIRTUAL;
12090 call = build_delete (TREE_TYPE (addr), addr,
12091 sfk_complete_destructor, flags, 0);
12093 cleanup = build_compound_expr (cleanup, call);
12101 /* When a stmt has been parsed, this function is called. */
12108 /* DECL was originally constructed as a non-static member function,
12109 but turned out to be static. Update it accordingly. */
12112 revert_static_member_fn (tree decl)
12115 tree function = TREE_TYPE (decl);
12116 tree args = TYPE_ARG_TYPES (function);
12118 if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
12119 != TYPE_UNQUALIFIED)
12120 error ("static member function %q#D declared with type qualifiers", decl);
12122 args = TREE_CHAIN (args);
12123 tmp = build_function_type (TREE_TYPE (function), args);
12124 tmp = build_qualified_type (tmp, cp_type_quals (function));
12125 tmp = build_exception_variant (tmp,
12126 TYPE_RAISES_EXCEPTIONS (function));
12127 TREE_TYPE (decl) = tmp;
12128 if (DECL_ARGUMENTS (decl))
12129 DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
12130 DECL_STATIC_FUNCTION_P (decl) = 1;
12133 /* Initialize the variables used during compilation of a C++
12137 cxx_push_function_context (struct function * f)
12139 struct language_function *p = GGC_CNEW (struct language_function);
12142 /* Whenever we start a new function, we destroy temporaries in the
12144 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
12150 if (DECL_SAVED_FUNCTION_DATA (fn))
12152 /* If we already parsed this function, and we're just expanding it
12153 now, restore saved state. */
12154 *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (fn);
12156 /* We don't need the saved data anymore. Unless this is an inline
12157 function; we need the named return value info for
12158 declare_return_variable. */
12159 if (! DECL_INLINE (fn))
12160 DECL_SAVED_FUNCTION_DATA (fn) = NULL;
12165 /* Free the language-specific parts of F, now that we've finished
12166 compiling the function. */
12169 cxx_pop_function_context (struct function * f)
12174 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
12175 one of the language-independent trees. */
12177 enum cp_tree_node_structure_enum
12178 cp_tree_node_structure (union lang_tree_node * t)
12180 switch (TREE_CODE (&t->generic))
12182 case DEFAULT_ARG: return TS_CP_DEFAULT_ARG;
12183 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER;
12184 case OVERLOAD: return TS_CP_OVERLOAD;
12185 case TEMPLATE_PARM_INDEX: return TS_CP_TPI;
12186 case PTRMEM_CST: return TS_CP_PTRMEM;
12187 case BASELINK: return TS_CP_BASELINK;
12188 case STATIC_ASSERT: return TS_CP_STATIC_ASSERT;
12189 case ARGUMENT_PACK_SELECT: return TS_CP_ARGUMENT_PACK_SELECT;
12190 case TRAIT_EXPR: return TS_CP_TRAIT_EXPR;
12191 default: return TS_CP_GENERIC;
12195 /* Build the void_list_node (void_type_node having been created). */
12197 build_void_list_node (void)
12199 tree t = build_tree_list (NULL_TREE, void_type_node);
12204 cp_missing_noreturn_ok_p (tree decl)
12206 /* A missing noreturn is ok for the `main' function. */
12207 return DECL_MAIN_P (decl);
12210 /* Return the COMDAT group into which DECL should be placed. */
12213 cxx_comdat_group (tree decl)
12217 /* Virtual tables, construction virtual tables, and virtual table
12218 tables all go in a single COMDAT group, named after the primary
12220 if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
12221 name = DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl)));
12222 /* For all other DECLs, the COMDAT group is the mangled name of the
12223 declaration itself. */
12226 while (DECL_THUNK_P (decl))
12228 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
12229 into the same section as the target function. In that case
12230 we must return target's name. */
12231 tree target = THUNK_TARGET (decl);
12232 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target)
12233 && DECL_SECTION_NAME (target) != NULL
12234 && DECL_ONE_ONLY (target))
12239 name = DECL_ASSEMBLER_NAME (decl);
12242 return IDENTIFIER_POINTER (name);
12245 #include "gt-cp-decl.h"