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 new_redefines_gnu_inline = false;
1851 if (new_defines_function
1852 && ((DECL_INTERFACE_KNOWN (olddecl)
1853 && TREE_CODE (olddecl) == FUNCTION_DECL)
1854 || (TREE_CODE (olddecl) == TEMPLATE_DECL
1855 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
1856 == FUNCTION_DECL))))
1860 if (TREE_CODE (fn) == TEMPLATE_DECL)
1861 fn = DECL_TEMPLATE_RESULT (olddecl);
1863 new_redefines_gnu_inline = GNU_INLINE_P (fn) && DECL_INITIAL (fn);
1866 if (!new_redefines_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 /* walk_tree helper for wrap_temporary_cleanups, below. */
5142 wrap_cleanups_r (tree *stmt_p, int *walk_subtrees, void *data)
5144 if (TYPE_P (*stmt_p))
5150 if (TREE_CODE (*stmt_p) == TARGET_EXPR)
5152 tree guard = (tree)data;
5153 tree tcleanup = TARGET_EXPR_CLEANUP (*stmt_p);
5155 tcleanup = build2 (TRY_CATCH_EXPR, void_type_node, tcleanup, guard);
5157 TARGET_EXPR_CLEANUP (*stmt_p) = tcleanup;
5163 /* We're initializing a local variable which has a cleanup GUARD. If there
5164 are any temporaries used in the initializer INIT of this variable, we
5165 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
5166 variable will be cleaned up properly if one of them throws. */
5169 wrap_temporary_cleanups (tree init, tree guard)
5171 cp_walk_tree_without_duplicates (&init, wrap_cleanups_r, (void *)guard);
5174 /* Generate code to initialize DECL (a local variable). */
5177 initialize_local_var (tree decl, tree init)
5179 tree type = TREE_TYPE (decl);
5183 gcc_assert (TREE_CODE (decl) == VAR_DECL
5184 || TREE_CODE (decl) == RESULT_DECL);
5185 gcc_assert (!TREE_STATIC (decl));
5187 if (DECL_SIZE (decl) == NULL_TREE)
5189 /* If we used it already as memory, it must stay in memory. */
5190 DECL_INITIAL (decl) = NULL_TREE;
5191 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
5195 if (type == error_mark_node)
5198 /* Compute and store the initial value. */
5199 already_used = TREE_USED (decl) || TREE_USED (type);
5201 /* Generate a cleanup, if necessary. */
5202 cleanup = cxx_maybe_build_cleanup (decl);
5204 /* Perform the initialization. */
5207 int saved_stmts_are_full_exprs_p;
5209 /* If we're only initializing a single object, guard the destructors
5210 of any temporaries used in its initializer with its destructor.
5211 This isn't right for arrays because each element initialization is
5212 a full-expression. */
5213 if (cleanup && TREE_CODE (type) != ARRAY_TYPE)
5214 wrap_temporary_cleanups (init, cleanup);
5216 gcc_assert (building_stmt_tree ());
5217 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
5218 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
5219 finish_expr_stmt (init);
5220 current_stmt_tree ()->stmts_are_full_exprs_p =
5221 saved_stmts_are_full_exprs_p;
5224 /* Set this to 0 so we can tell whether an aggregate which was
5225 initialized was ever used. Don't do this if it has a
5226 destructor, so we don't complain about the 'resource
5227 allocation is initialization' idiom. Now set
5228 attribute((unused)) on types so decls of that type will be
5229 marked used. (see TREE_USED, above.) */
5230 if (TYPE_NEEDS_CONSTRUCTING (type)
5232 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
5233 && DECL_NAME (decl))
5234 TREE_USED (decl) = 0;
5235 else if (already_used)
5236 TREE_USED (decl) = 1;
5239 finish_decl_cleanup (decl, cleanup);
5242 /* DECL is a VAR_DECL for a compiler-generated variable with static
5243 storage duration (like a virtual table) whose initializer is a
5244 compile-time constant. INIT must be either a TREE_LIST of values,
5245 or a CONSTRUCTOR. Initialize the variable and provide it to the
5249 initialize_artificial_var (tree decl, tree init)
5251 gcc_assert (DECL_ARTIFICIAL (decl));
5252 if (TREE_CODE (init) == TREE_LIST)
5253 init = build_constructor_from_list (NULL_TREE, init);
5254 gcc_assert (TREE_CODE (init) == CONSTRUCTOR);
5255 DECL_INITIAL (decl) = init;
5256 DECL_INITIALIZED_P (decl) = 1;
5257 determine_visibility (decl);
5258 layout_var_decl (decl);
5259 maybe_commonize_var (decl);
5260 make_rtl_for_nonlocal_decl (decl, init, /*asmspec=*/NULL);
5263 /* INIT is the initializer for a variable, as represented by the
5264 parser. Returns true iff INIT is value-dependent. */
5267 value_dependent_init_p (tree init)
5269 if (TREE_CODE (init) == TREE_LIST)
5270 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
5271 return any_value_dependent_elements_p (init);
5272 else if (TREE_CODE (init) == CONSTRUCTOR)
5273 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
5275 VEC(constructor_elt, gc) *elts;
5279 elts = CONSTRUCTOR_ELTS (init);
5280 nelts = VEC_length (constructor_elt, elts);
5281 for (i = 0; i < nelts; ++i)
5282 if (value_dependent_init_p (VEC_index (constructor_elt,
5287 /* It must be a simple expression, e.g., int i = 3; */
5288 return value_dependent_expression_p (init);
5293 /* Finish processing of a declaration;
5294 install its line number and initial value.
5295 If the length of an array type is not known before,
5296 it must be determined now, from the initial value, or it is an error.
5298 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
5299 true, then INIT is an integral constant expression.
5301 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
5302 if the (init) syntax was used. */
5305 cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
5306 tree asmspec_tree, int flags)
5310 const char *asmspec = NULL;
5311 int was_readonly = 0;
5312 bool var_definition_p = false;
5313 int saved_processing_template_decl;
5315 if (decl == error_mark_node)
5320 error ("assignment (not initialization) in declaration");
5324 gcc_assert (TREE_CODE (decl) != RESULT_DECL);
5325 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
5326 gcc_assert (TREE_CODE (decl) != PARM_DECL);
5328 type = TREE_TYPE (decl);
5329 if (type == error_mark_node)
5332 /* Assume no cleanup is required. */
5333 cleanup = NULL_TREE;
5334 saved_processing_template_decl = processing_template_decl;
5336 /* If a name was specified, get the string. */
5337 if (global_scope_p (current_binding_level))
5338 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
5339 if (asmspec_tree && asmspec_tree != error_mark_node)
5340 asmspec = TREE_STRING_POINTER (asmspec_tree);
5342 if (current_class_type
5343 && CP_DECL_CONTEXT (decl) == current_class_type
5344 && TYPE_BEING_DEFINED (current_class_type)
5345 && (DECL_INITIAL (decl) || init))
5346 DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
5348 if (processing_template_decl)
5350 bool type_dependent_p;
5352 /* Add this declaration to the statement-tree. */
5353 if (at_function_scope_p ())
5354 add_decl_expr (decl);
5356 type_dependent_p = dependent_type_p (type);
5358 if (init && init_const_expr_p)
5360 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
5361 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl))
5362 TREE_CONSTANT (decl) = 1;
5365 /* Generally, initializers in templates are expanded when the
5366 template is instantiated. But, if DECL is an integral
5367 constant static data member, then it can be used in future
5368 integral constant expressions, and its value must be
5371 && DECL_CLASS_SCOPE_P (decl)
5372 && DECL_INTEGRAL_CONSTANT_VAR_P (decl)
5373 && !type_dependent_p
5374 && !value_dependent_init_p (init)))
5377 DECL_INITIAL (decl) = init;
5378 if (TREE_CODE (decl) == VAR_DECL
5379 && !DECL_PRETTY_FUNCTION_P (decl)
5380 && !type_dependent_p)
5381 maybe_deduce_size_from_array_init (decl, init);
5385 if (TREE_CODE (init) == TREE_LIST)
5387 /* If the parenthesized-initializer form was used (e.g.,
5388 "int A<N>::i(X)"), then INIT will be a TREE_LIST of initializer
5389 arguments. (There is generally only one.) We convert them
5392 for (; list; list = TREE_CHAIN (list))
5394 tree elt = TREE_VALUE (list);
5395 TREE_VALUE (list) = fold_non_dependent_expr (elt);
5399 init = fold_non_dependent_expr (init);
5400 processing_template_decl = 0;
5403 /* Take care of TYPE_DECLs up front. */
5404 if (TREE_CODE (decl) == TYPE_DECL)
5406 if (type != error_mark_node
5407 && IS_AGGR_TYPE (type) && DECL_NAME (decl))
5409 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
5410 warning (0, "shadowing previous type declaration of %q#D", decl);
5411 set_identifier_type_value (DECL_NAME (decl), decl);
5414 /* If we have installed this as the canonical typedef for this
5415 type, and that type has not been defined yet, delay emitting
5416 the debug information for it, as we will emit it later. */
5417 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
5418 && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
5419 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
5421 rest_of_decl_compilation (decl, DECL_CONTEXT (decl) == NULL_TREE,
5426 /* A reference will be modified here, as it is initialized. */
5427 if (! DECL_EXTERNAL (decl)
5428 && TREE_READONLY (decl)
5429 && TREE_CODE (type) == REFERENCE_TYPE)
5432 TREE_READONLY (decl) = 0;
5435 if (TREE_CODE (decl) == VAR_DECL)
5437 /* Only PODs can have thread-local storage. Other types may require
5438 various kinds of non-trivial initialization. */
5439 if (DECL_THREAD_LOCAL_P (decl) && !pod_type_p (TREE_TYPE (decl)))
5440 error ("%qD cannot be thread-local because it has non-POD type %qT",
5441 decl, TREE_TYPE (decl));
5442 /* If this is a local variable that will need a mangled name,
5443 register it now. We must do this before processing the
5444 initializer for the variable, since the initialization might
5445 require a guard variable, and since the mangled name of the
5446 guard variable will depend on the mangled name of this
5448 if (!processing_template_decl
5449 && DECL_FUNCTION_SCOPE_P (decl)
5450 && TREE_STATIC (decl)
5451 && !DECL_ARTIFICIAL (decl))
5452 push_local_name (decl);
5453 /* Convert the initializer to the type of DECL, if we have not
5454 already initialized DECL. */
5455 if (!DECL_INITIALIZED_P (decl)
5456 /* If !DECL_EXTERNAL then DECL is being defined. In the
5457 case of a static data member initialized inside the
5458 class-specifier, there can be an initializer even if DECL
5459 is *not* defined. */
5460 && (!DECL_EXTERNAL (decl) || init))
5464 DECL_NONTRIVIALLY_INITIALIZED_P (decl) = 1;
5465 if (init_const_expr_p)
5467 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
5468 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl))
5469 TREE_CONSTANT (decl) = 1;
5472 init = check_initializer (decl, init, flags, &cleanup);
5473 /* Thread-local storage cannot be dynamically initialized. */
5474 if (DECL_THREAD_LOCAL_P (decl) && init)
5476 error ("%qD is thread-local and so cannot be dynamically "
5477 "initialized", decl);
5481 /* Check that the initializer for a static data member was a
5482 constant. Although we check in the parser that the
5483 initializer is an integral constant expression, we do not
5484 simplify division-by-zero at the point at which it
5485 occurs. Therefore, in:
5487 struct S { static const int i = 7 / 0; };
5489 we issue an error at this point. It would
5490 probably be better to forbid division by zero in
5491 integral constant expressions. */
5492 if (DECL_EXTERNAL (decl) && init)
5494 error ("%qD cannot be initialized by a non-constant expression"
5495 " when being declared", decl);
5496 DECL_INITIALIZED_IN_CLASS_P (decl) = 0;
5504 The memory occupied by any object of static storage
5505 duration is zero-initialized at program startup before
5506 any other initialization takes place.
5508 We cannot create an appropriate initializer until after
5509 the type of DECL is finalized. If DECL_INITIAL is set,
5510 then the DECL is statically initialized, and any
5511 necessary zero-initialization has already been performed. */
5512 if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
5513 DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
5514 /*nelts=*/NULL_TREE,
5515 /*static_storage_p=*/true);
5516 /* Remember that the initialization for this variable has
5518 DECL_INITIALIZED_P (decl) = 1;
5519 /* This declaration is the definition of this variable,
5520 unless we are initializing a static data member within
5521 the class specifier. */
5522 if (!DECL_EXTERNAL (decl))
5523 var_definition_p = true;
5525 /* If the variable has an array type, lay out the type, even if
5526 there is no initializer. It is valid to index through the
5527 array, and we must get TYPE_ALIGN set correctly on the array
5529 else if (TREE_CODE (type) == ARRAY_TYPE)
5533 /* Add this declaration to the statement-tree. This needs to happen
5534 after the call to check_initializer so that the DECL_EXPR for a
5535 reference temp is added before the DECL_EXPR for the reference itself. */
5536 if (at_function_scope_p ())
5537 add_decl_expr (decl);
5539 /* Let the middle end know about variables and functions -- but not
5540 static data members in uninstantiated class templates. */
5541 if (!saved_processing_template_decl
5542 && (TREE_CODE (decl) == VAR_DECL
5543 || TREE_CODE (decl) == FUNCTION_DECL))
5545 if (TREE_CODE (decl) == VAR_DECL)
5547 layout_var_decl (decl);
5548 maybe_commonize_var (decl);
5551 /* This needs to happen after the linkage is set. */
5552 determine_visibility (decl);
5554 make_rtl_for_nonlocal_decl (decl, init, asmspec);
5556 /* Check for abstractness of the type. Notice that there is no
5557 need to strip array types here since the check for those types
5558 is already done within create_array_type_for_decl. */
5559 if (TREE_CODE (type) == FUNCTION_TYPE
5560 || TREE_CODE (type) == METHOD_TYPE)
5561 abstract_virtuals_error (decl, TREE_TYPE (type));
5563 abstract_virtuals_error (decl, type);
5565 if (TREE_CODE (decl) == FUNCTION_DECL
5566 || TREE_TYPE (decl) == error_mark_node)
5567 /* No initialization required. */
5569 else if (DECL_EXTERNAL (decl)
5570 && ! (DECL_LANG_SPECIFIC (decl)
5571 && DECL_NOT_REALLY_EXTERN (decl)))
5574 DECL_INITIAL (decl) = init;
5578 /* A variable definition. */
5579 if (DECL_FUNCTION_SCOPE_P (decl))
5581 /* Initialize the local variable. */
5582 if (processing_template_decl)
5583 DECL_INITIAL (decl) = init;
5584 else if (!TREE_STATIC (decl))
5585 initialize_local_var (decl, init);
5588 /* If a variable is defined, and then a subsequent
5589 definition with external linkage is encountered, we will
5590 get here twice for the same variable. We want to avoid
5591 calling expand_static_init more than once. For variables
5592 that are not static data members, we can call
5593 expand_static_init only when we actually process the
5594 initializer. It is not legal to redeclare a static data
5595 member, so this issue does not arise in that case. */
5596 if (var_definition_p && TREE_STATIC (decl))
5598 /* If a TREE_READONLY variable needs initialization
5599 at runtime, it is no longer readonly and we need to
5600 avoid MEM_READONLY_P being set on RTL created for it. */
5603 if (TREE_READONLY (decl))
5604 TREE_READONLY (decl) = 0;
5607 expand_static_init (decl, init);
5612 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
5613 reference, insert it in the statement-tree now. */
5615 push_cleanup (decl, cleanup, false);
5618 processing_template_decl = saved_processing_template_decl;
5621 TREE_READONLY (decl) = 1;
5623 /* If this was marked 'used', be sure it will be output. */
5624 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
5625 mark_decl_referenced (decl);
5628 /* This is here for a midend callback from c-common.c. */
5631 finish_decl (tree decl, tree init, tree asmspec_tree)
5633 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, asmspec_tree, 0);
5636 /* Returns a declaration for a VAR_DECL as if:
5638 extern "C" TYPE NAME;
5640 had been seen. Used to create compiler-generated global
5644 declare_global_var (tree name, tree type)
5648 push_to_top_level ();
5649 decl = build_decl (VAR_DECL, name, type);
5650 TREE_PUBLIC (decl) = 1;
5651 DECL_EXTERNAL (decl) = 1;
5652 DECL_ARTIFICIAL (decl) = 1;
5653 /* If the user has explicitly declared this variable (perhaps
5654 because the code we are compiling is part of a low-level runtime
5655 library), then it is possible that our declaration will be merged
5656 with theirs by pushdecl. */
5657 decl = pushdecl (decl);
5658 finish_decl (decl, NULL_TREE, NULL_TREE);
5659 pop_from_top_level ();
5664 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
5665 if "__cxa_atexit" is not being used) corresponding to the function
5666 to be called when the program exits. */
5669 get_atexit_fn_ptr_type (void)
5674 if (!atexit_fn_ptr_type_node)
5676 if (flag_use_cxa_atexit
5677 && !targetm.cxx.use_atexit_for_cxa_atexit ())
5678 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
5679 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5681 /* The parameter to "atexit" is "void (*)(void)". */
5682 arg_types = void_list_node;
5684 fn_type = build_function_type (void_type_node, arg_types);
5685 atexit_fn_ptr_type_node = build_pointer_type (fn_type);
5688 return atexit_fn_ptr_type_node;
5691 /* Returns a pointer to the `atexit' function. Note that if
5692 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
5693 `__cxa_atexit' function specified in the IA64 C++ ABI. */
5696 get_atexit_node (void)
5703 bool use_aeabi_atexit;
5708 if (flag_use_cxa_atexit && !targetm.cxx.use_atexit_for_cxa_atexit ())
5710 /* The declaration for `__cxa_atexit' is:
5712 int __cxa_atexit (void (*)(void *), void *, void *)
5714 We build up the argument types and then then function type
5717 use_aeabi_atexit = targetm.cxx.use_aeabi_atexit ();
5718 /* First, build the pointer-to-function type for the first
5720 fn_ptr_type = get_atexit_fn_ptr_type ();
5721 /* Then, build the rest of the argument types. */
5722 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5723 if (use_aeabi_atexit)
5725 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
5726 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
5730 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
5731 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
5733 /* And the final __cxa_atexit type. */
5734 fn_type = build_function_type (integer_type_node, arg_types);
5735 fn_ptr_type = build_pointer_type (fn_type);
5736 if (use_aeabi_atexit)
5737 name = "__aeabi_atexit";
5739 name = "__cxa_atexit";
5743 /* The declaration for `atexit' is:
5745 int atexit (void (*)());
5747 We build up the argument types and then then function type
5749 fn_ptr_type = get_atexit_fn_ptr_type ();
5750 arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
5751 /* Build the final atexit type. */
5752 fn_type = build_function_type (integer_type_node, arg_types);
5756 /* Now, build the function declaration. */
5757 push_lang_context (lang_name_c);
5758 atexit_fndecl = build_library_fn_ptr (name, fn_type);
5759 mark_used (atexit_fndecl);
5760 pop_lang_context ();
5761 atexit_node = decay_conversion (atexit_fndecl);
5766 /* Returns the __dso_handle VAR_DECL. */
5769 get_dso_handle_node (void)
5771 if (dso_handle_node)
5772 return dso_handle_node;
5774 /* Declare the variable. */
5775 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
5778 return dso_handle_node;
5781 /* Begin a new function with internal linkage whose job will be simply
5782 to destroy some particular variable. */
5784 static GTY(()) int start_cleanup_cnt;
5787 start_cleanup_fn (void)
5792 bool use_cxa_atexit = flag_use_cxa_atexit
5793 && !targetm.cxx.use_atexit_for_cxa_atexit ();
5795 push_to_top_level ();
5797 /* No need to mangle this. */
5798 push_lang_context (lang_name_c);
5800 /* Build the name of the function. */
5801 sprintf (name, "__tcf_%d", start_cleanup_cnt++);
5802 /* Build the function declaration. */
5803 fntype = TREE_TYPE (get_atexit_fn_ptr_type ());
5804 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
5805 /* It's a function with internal linkage, generated by the
5807 TREE_PUBLIC (fndecl) = 0;
5808 DECL_ARTIFICIAL (fndecl) = 1;
5809 /* Make the function `inline' so that it is only emitted if it is
5810 actually needed. It is unlikely that it will be inlined, since
5811 it is only called via a function pointer, but we avoid unnecessary
5812 emissions this way. */
5813 DECL_INLINE (fndecl) = 1;
5814 DECL_DECLARED_INLINE_P (fndecl) = 1;
5815 DECL_INTERFACE_KNOWN (fndecl) = 1;
5816 /* Build the parameter. */
5821 parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
5822 DECL_CONTEXT (parmdecl) = fndecl;
5823 TREE_USED (parmdecl) = 1;
5824 DECL_ARGUMENTS (fndecl) = parmdecl;
5828 start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED);
5830 pop_lang_context ();
5832 return current_function_decl;
5835 /* Finish the cleanup function begun by start_cleanup_fn. */
5838 end_cleanup_fn (void)
5840 expand_or_defer_fn (finish_function (0));
5842 pop_from_top_level ();
5845 /* Generate code to handle the destruction of DECL, an object with
5846 static storage duration. */
5849 register_dtor_fn (tree decl)
5858 type = TREE_TYPE (decl);
5859 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
5860 return void_zero_node;
5862 /* If we're using "__cxa_atexit" (or "__aeabi_atexit"), and DECL is
5863 a class object, we can just pass the destructor to
5864 "__cxa_atexit"; we don't have to build a temporary function to do
5866 use_dtor = (flag_use_cxa_atexit
5867 && !targetm.cxx.use_atexit_for_cxa_atexit ()
5868 && CLASS_TYPE_P (type));
5873 /* Find the destructor. */
5874 idx = lookup_fnfields_1 (type, complete_dtor_identifier);
5875 gcc_assert (idx >= 0);
5876 cleanup = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), idx);
5877 /* Make sure it is accessible. */
5878 perform_or_defer_access_check (TYPE_BINFO (type), cleanup, cleanup);
5882 /* Call build_cleanup before we enter the anonymous function so
5883 that any access checks will be done relative to the current
5884 scope, rather than the scope of the anonymous function. */
5885 build_cleanup (decl);
5887 /* Now start the function. */
5888 cleanup = start_cleanup_fn ();
5890 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
5891 to the original function, rather than the anonymous one. That
5892 will make the back end think that nested functions are in use,
5893 which causes confusion. */
5894 push_deferring_access_checks (dk_no_check);
5895 fcall = build_cleanup (decl);
5896 pop_deferring_access_checks ();
5898 /* Create the body of the anonymous function. */
5899 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
5900 finish_expr_stmt (fcall);
5901 finish_compound_stmt (compound_stmt);
5905 /* Call atexit with the cleanup function. */
5906 mark_used (cleanup);
5907 cleanup = build_address (cleanup);
5908 if (flag_use_cxa_atexit && !targetm.cxx.use_atexit_for_cxa_atexit ())
5914 /* We must convert CLEANUP to the type that "__cxa_atexit"
5916 cleanup = build_nop (get_atexit_fn_ptr_type (), cleanup);
5917 /* "__cxa_atexit" will pass the address of DECL to the
5918 cleanup function. */
5920 addr = build_address (decl);
5921 /* The declared type of the parameter to "__cxa_atexit" is
5922 "void *". For plain "T*", we could just let the
5923 machinery in build_function_call convert it -- but if the
5924 type is "cv-qualified T *", then we need to convert it
5925 before passing it in, to avoid spurious errors. */
5926 addr = build_nop (ptr_type_node, addr);
5929 /* Since the cleanup functions we build ignore the address
5930 they're given, there's no reason to pass the actual address
5931 in, and, in general, it's cheaper to pass NULL than any
5933 addr = null_pointer_node;
5934 args = tree_cons (NULL_TREE,
5935 build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0),
5937 if (targetm.cxx.use_aeabi_atexit ())
5939 args = tree_cons (NULL_TREE, cleanup, args);
5940 args = tree_cons (NULL_TREE, addr, args);
5944 args = tree_cons (NULL_TREE, addr, args);
5945 args = tree_cons (NULL_TREE, cleanup, args);
5949 args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
5950 return build_function_call (get_atexit_node (), args);
5953 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
5954 is its initializer. Generate code to handle the construction
5955 and destruction of DECL. */
5958 expand_static_init (tree decl, tree init)
5960 gcc_assert (TREE_CODE (decl) == VAR_DECL);
5961 gcc_assert (TREE_STATIC (decl));
5963 /* Some variables require no initialization. */
5965 && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
5966 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
5969 if (DECL_FUNCTION_SCOPE_P (decl))
5971 /* Emit code to perform this initialization but once. */
5972 tree if_stmt = NULL_TREE, inner_if_stmt = NULL_TREE;
5973 tree then_clause = NULL_TREE, inner_then_clause = NULL_TREE;
5974 tree guard, guard_addr;
5975 tree acquire_fn, release_fn, abort_fn;
5978 /* Emit code to perform this initialization but once. This code
5981 static <type> guard;
5982 if (!guard.first_byte) {
5983 if (__cxa_guard_acquire (&guard)) {
5986 // Do initialization.
5987 flag = true; __cxa_guard_release (&guard);
5988 // Register variable for destruction at end of program.
5990 if (!flag) __cxa_guard_abort (&guard);
5994 Note that the `flag' variable is only set to 1 *after* the
5995 initialization is complete. This ensures that an exception,
5996 thrown during the construction, will cause the variable to
5997 reinitialized when we pass through this code again, as per:
6001 If the initialization exits by throwing an exception, the
6002 initialization is not complete, so it will be tried again
6003 the next time control enters the declaration.
6005 This process should be thread-safe, too; multiple threads
6006 should not be able to initialize the variable more than
6009 /* Create the guard variable. */
6010 guard = get_guard (decl);
6012 /* This optimization isn't safe on targets with relaxed memory
6013 consistency. On such targets we force synchronization in
6014 __cxa_guard_acquire. */
6015 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
6017 /* Begin the conditional initialization. */
6018 if_stmt = begin_if_stmt ();
6019 finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
6020 then_clause = begin_compound_stmt (BCS_NO_SCOPE);
6023 if (flag_threadsafe_statics)
6025 guard_addr = build_address (guard);
6027 acquire_fn = get_identifier ("__cxa_guard_acquire");
6028 release_fn = get_identifier ("__cxa_guard_release");
6029 abort_fn = get_identifier ("__cxa_guard_abort");
6030 if (!get_global_value_if_present (acquire_fn, &acquire_fn))
6032 tree argtypes = tree_cons (NULL_TREE, TREE_TYPE (guard_addr),
6034 tree vfntype = build_function_type (void_type_node, argtypes);
6035 acquire_fn = push_library_fn
6036 (acquire_fn, build_function_type (integer_type_node, argtypes));
6037 release_fn = push_library_fn (release_fn, vfntype);
6038 abort_fn = push_library_fn (abort_fn, vfntype);
6042 release_fn = identifier_global_value (release_fn);
6043 abort_fn = identifier_global_value (abort_fn);
6046 inner_if_stmt = begin_if_stmt ();
6047 finish_if_stmt_cond (build_call_n (acquire_fn, 1, guard_addr),
6050 inner_then_clause = begin_compound_stmt (BCS_NO_SCOPE);
6051 begin = get_target_expr (boolean_false_node);
6052 flag = TARGET_EXPR_SLOT (begin);
6054 TARGET_EXPR_CLEANUP (begin)
6055 = build3 (COND_EXPR, void_type_node, flag,
6057 build_call_n (abort_fn, 1, guard_addr));
6058 CLEANUP_EH_ONLY (begin) = 1;
6060 /* Do the initialization itself. */
6061 init = add_stmt_to_compound (begin, init);
6062 init = add_stmt_to_compound
6063 (init, build2 (MODIFY_EXPR, void_type_node, flag, boolean_true_node));
6064 init = add_stmt_to_compound
6065 (init, build_call_n (release_fn, 1, guard_addr));
6068 init = add_stmt_to_compound (init, set_guard (guard));
6070 /* Use atexit to register a function for destroying this static
6072 init = add_stmt_to_compound (init, register_dtor_fn (decl));
6074 finish_expr_stmt (init);
6076 if (flag_threadsafe_statics)
6078 finish_compound_stmt (inner_then_clause);
6079 finish_then_clause (inner_if_stmt);
6080 finish_if_stmt (inner_if_stmt);
6083 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
6085 finish_compound_stmt (then_clause);
6086 finish_then_clause (if_stmt);
6087 finish_if_stmt (if_stmt);
6091 static_aggregates = tree_cons (init, decl, static_aggregates);
6095 /* Make TYPE a complete type based on INITIAL_VALUE.
6096 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6097 2 if there was no information (in which case assume 0 if DO_DEFAULT),
6098 3 if the initializer list is empty (in pedantic mode). */
6101 cp_complete_array_type (tree *ptype, tree initial_value, bool do_default)
6104 tree type, elt_type;
6108 /* An array of character type can be initialized from a
6109 brace-enclosed string constant.
6111 FIXME: this code is duplicated from reshape_init. Probably
6112 we should just call reshape_init here? */
6113 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype)))
6114 && TREE_CODE (initial_value) == CONSTRUCTOR
6115 && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (initial_value)))
6117 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
6118 tree value = VEC_index (constructor_elt, v, 0)->value;
6120 if (TREE_CODE (value) == STRING_CST
6121 && VEC_length (constructor_elt, v) == 1)
6122 initial_value = value;
6126 failure = complete_array_type (ptype, initial_value, do_default);
6128 /* We can create the array before the element type is complete, which
6129 means that we didn't have these two bits set in the original type
6130 either. In completing the type, we are expected to propagate these
6131 bits. See also complete_type which does the same thing for arrays
6134 if (TYPE_DOMAIN (type))
6136 elt_type = TREE_TYPE (type);
6137 TYPE_NEEDS_CONSTRUCTING (type) = TYPE_NEEDS_CONSTRUCTING (elt_type);
6138 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
6139 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type);
6145 /* Return zero if something is declared to be a member of type
6146 CTYPE when in the context of CUR_TYPE. STRING is the error
6147 message to print in that case. Otherwise, quietly return 1. */
6150 member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
6152 if (ctype && ctype != cur_type)
6154 if (flags == DTOR_FLAG)
6155 error ("destructor for alien class %qT cannot be a member", ctype);
6157 error ("constructor for alien class %qT cannot be a member", ctype);
6163 /* Subroutine of `grokdeclarator'. */
6165 /* Generate errors possibly applicable for a given set of specifiers.
6166 This is for ARM $7.1.2. */
6169 bad_specifiers (tree object,
6178 error ("%qD declared as a %<virtual%> %s", object, type);
6180 error ("%qD declared as an %<inline%> %s", object, type);
6182 error ("%<const%> and %<volatile%> function specifiers on "
6183 "%qD invalid in %s declaration",
6186 error ("%q+D declared as a friend", object);
6188 && (TREE_CODE (object) == TYPE_DECL
6189 || (!TYPE_PTRFN_P (TREE_TYPE (object))
6190 && !TYPE_REFFN_P (TREE_TYPE (object))
6191 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
6192 error ("%q+D declared with an exception specification", object);
6195 /* DECL is a member function or static data member and is presently
6196 being defined. Check that the definition is taking place in a
6200 check_class_member_definition_namespace (tree decl)
6202 /* These checks only apply to member functions and static data
6204 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
6205 || TREE_CODE (decl) == VAR_DECL);
6206 /* We check for problems with specializations in pt.c in
6207 check_specialization_namespace, where we can issue better
6209 if (processing_specialization)
6211 /* There are no restrictions on the placement of
6212 explicit instantiations. */
6213 if (processing_explicit_instantiation)
6217 A member function definition that appears outside of the
6218 class definition shall appear in a namespace scope enclosing
6219 the class definition.
6223 The definition for a static data member shall appear in a
6224 namespace scope enclosing the member's class definition. */
6225 if (!is_ancestor (current_namespace, DECL_CONTEXT (decl)))
6226 pedwarn ("definition of %qD is not in namespace enclosing %qT",
6227 decl, DECL_CONTEXT (decl));
6230 /* Build a PARM_DECL for the "this" parameter. TYPE is the
6231 METHOD_TYPE for a non-static member function; QUALS are the
6232 cv-qualifiers that apply to the function. */
6235 build_this_parm (tree type, cp_cv_quals quals)
6240 cp_cv_quals this_quals;
6242 this_type = TREE_VALUE (TYPE_ARG_TYPES (type));
6243 /* The `this' parameter is implicitly `const'; it cannot be
6245 this_quals = (quals & TYPE_QUAL_RESTRICT) | TYPE_QUAL_CONST;
6246 qual_type = cp_build_qualified_type (this_type, this_quals);
6247 parm = build_artificial_parm (this_identifier, qual_type);
6248 cp_apply_type_quals_to_decl (this_quals, parm);
6252 /* CTYPE is class type, or null if non-class.
6253 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
6255 DECLARATOR is the function's name.
6256 PARMS is a chain of PARM_DECLs for the function.
6257 VIRTUALP is truthvalue of whether the function is virtual or not.
6258 FLAGS are to be passed through to `grokclassfn'.
6259 QUALS are qualifiers indicating whether the function is `const'
6261 RAISES is a list of exceptions that this function can raise.
6262 CHECK is 1 if we must find this method in CTYPE, 0 if we should
6263 not look, and -1 if we should not call `grokclassfn' at all.
6265 SFK is the kind of special function (if any) for the new function.
6267 Returns `NULL_TREE' if something goes wrong, after issuing
6268 applicable error messages. */
6271 grokfndecl (tree ctype,
6275 tree orig_declarator,
6277 enum overload_flags flags,
6284 special_function_kind sfk,
6291 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
6295 type = build_exception_variant (type, raises);
6297 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
6298 if (TREE_CODE (type) == METHOD_TYPE)
6301 parm = build_this_parm (type, quals);
6302 TREE_CHAIN (parm) = parms;
6305 DECL_ARGUMENTS (decl) = parms;
6306 /* Propagate volatile out from type to decl. */
6307 if (TYPE_VOLATILE (type))
6308 TREE_THIS_VOLATILE (decl) = 1;
6310 /* Setup decl according to sfk. */
6313 case sfk_constructor:
6314 case sfk_copy_constructor:
6315 DECL_CONSTRUCTOR_P (decl) = 1;
6317 case sfk_destructor:
6318 DECL_DESTRUCTOR_P (decl) = 1;
6324 /* If pointers to member functions use the least significant bit to
6325 indicate whether a function is virtual, ensure a pointer
6326 to this function will have that bit clear. */
6327 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
6328 && TREE_CODE (type) == METHOD_TYPE
6329 && DECL_ALIGN (decl) < 2 * BITS_PER_UNIT)
6330 DECL_ALIGN (decl) = 2 * BITS_PER_UNIT;
6333 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
6337 ("defining explicit specialization %qD in friend declaration",
6341 tree fns = TREE_OPERAND (orig_declarator, 0);
6342 tree args = TREE_OPERAND (orig_declarator, 1);
6344 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
6346 /* Something like `template <class T> friend void f<T>()'. */
6347 error ("invalid use of template-id %qD in declaration "
6348 "of primary template",
6354 /* A friend declaration of the form friend void f<>(). Record
6355 the information in the TEMPLATE_ID_EXPR. */
6356 SET_DECL_IMPLICIT_INSTANTIATION (decl);
6358 if (TREE_CODE (fns) == COMPONENT_REF)
6360 /* Due to bison parser ickiness, we will have already looked
6361 up an operator_name or PFUNCNAME within the current class
6362 (see template_id in parse.y). If the current class contains
6363 such a name, we'll get a COMPONENT_REF here. Undo that. */
6365 gcc_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
6366 == current_class_type);
6367 fns = TREE_OPERAND (fns, 1);
6369 gcc_assert (TREE_CODE (fns) == IDENTIFIER_NODE
6370 || TREE_CODE (fns) == OVERLOAD);
6371 DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
6373 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
6374 if (TREE_PURPOSE (t)
6375 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
6377 error ("default arguments are not allowed in declaration "
6378 "of friend template specialization %qD",
6385 error ("%<inline%> is not allowed in declaration of friend "
6386 "template specialization %qD",
6393 /* If this decl has namespace scope, set that up. */
6395 set_decl_namespace (decl, in_namespace, friendp);
6397 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
6399 /* `main' and builtins have implicit 'C' linkage. */
6400 if ((MAIN_NAME_P (declarator)
6401 || (IDENTIFIER_LENGTH (declarator) > 10
6402 && IDENTIFIER_POINTER (declarator)[0] == '_'
6403 && IDENTIFIER_POINTER (declarator)[1] == '_'
6404 && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
6405 && current_lang_name == lang_name_cplusplus
6406 && ctype == NULL_TREE
6407 /* NULL_TREE means global namespace. */
6408 && DECL_CONTEXT (decl) == NULL_TREE)
6409 SET_DECL_LANGUAGE (decl, lang_c);
6411 /* Should probably propagate const out from type to decl I bet (mrs). */
6414 DECL_STATIC_FUNCTION_P (decl) = 1;
6415 DECL_CONTEXT (decl) = ctype;
6420 DECL_CONTEXT (decl) = ctype;
6422 check_class_member_definition_namespace (decl);
6425 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
6427 if (processing_template_decl)
6428 error ("cannot declare %<::main%> to be a template");
6430 error ("cannot declare %<::main%> to be inline");
6432 error ("cannot declare %<::main%> to be static");
6437 /* Members of anonymous types and local classes have no linkage; make
6438 them internal. If a typedef is made later, this will be changed. */
6439 if (ctype && (TYPE_ANONYMOUS_P (ctype)
6440 || decl_function_context (TYPE_MAIN_DECL (ctype))))
6445 /* [basic.link]: A name with no linkage (notably, the name of a class
6446 or enumeration declared in a local scope) shall not be used to
6447 declare an entity with linkage.
6449 Only check this for public decls for now. See core 319, 389. */
6450 t = no_linkage_check (TREE_TYPE (decl),
6451 /*relaxed_p=*/false);
6454 if (TYPE_ANONYMOUS_P (t))
6456 if (DECL_EXTERN_C_P (decl))
6457 /* Allow this; it's pretty common in C. */;
6460 pedwarn ("non-local function %q#D uses anonymous type",
6462 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
6463 pedwarn ("%q+#D does not refer to the unqualified "
6464 "type, so it is not used for linkage",
6469 pedwarn ("non-local function %q#D uses local type %qT", decl, t);
6473 TREE_PUBLIC (decl) = publicp;
6476 DECL_INTERFACE_KNOWN (decl) = 1;
6477 DECL_NOT_REALLY_EXTERN (decl) = 1;
6480 /* If the declaration was declared inline, mark it as such. */
6482 DECL_DECLARED_INLINE_P (decl) = 1;
6483 /* We inline functions that are explicitly declared inline, or, when
6484 the user explicitly asks us to, all functions. */
6485 if (DECL_DECLARED_INLINE_P (decl)
6486 || (flag_inline_trees == 2 && !DECL_INLINE (decl) && funcdef_flag))
6487 DECL_INLINE (decl) = 1;
6489 DECL_EXTERNAL (decl) = 1;
6490 if (quals && TREE_CODE (type) == FUNCTION_TYPE)
6493 ? G_("static member function %qD cannot have cv-qualifier")
6494 : G_("non-member function %qD cannot have cv-qualifier"),
6496 quals = TYPE_UNQUALIFIED;
6499 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl))
6500 && !grok_op_properties (decl, /*complain=*/true))
6503 if (ctype && decl_function_context (decl))
6504 DECL_NO_STATIC_CHAIN (decl) = 1;
6507 /* Make the init_value nonzero so pushdecl knows this is not
6508 tentative. error_mark_node is replaced later with the BLOCK. */
6509 DECL_INITIAL (decl) = error_mark_node;
6511 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
6512 TREE_NOTHROW (decl) = 1;
6514 /* Caller will do the rest of this. */
6518 if (ctype != NULL_TREE)
6519 grokclassfn (ctype, decl, flags);
6521 decl = check_explicit_specialization (orig_declarator, decl,
6524 4 * (friendp != 0));
6525 if (decl == error_mark_node)
6530 cplus_decl_attributes (&decl, *attrlist, 0);
6531 *attrlist = NULL_TREE;
6534 /* Check main's type after attributes have been applied. */
6535 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
6537 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
6540 tree oldtypeargs = TYPE_ARG_TYPES (TREE_TYPE (decl));
6542 error ("%<::main%> must return %<int%>");
6543 newtype = build_function_type (integer_type_node, oldtypeargs);
6544 TREE_TYPE (decl) = newtype;
6546 check_main_parameter_types (decl);
6549 if (ctype != NULL_TREE
6550 && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
6553 tree old_decl = check_classfn (ctype, decl,
6554 (processing_template_decl
6555 > template_class_depth (ctype))
6556 ? current_template_parms
6559 if (old_decl == error_mark_node)
6567 if (TREE_CODE (old_decl) == TEMPLATE_DECL)
6568 /* Because grokfndecl is always supposed to return a
6569 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
6570 here. We depend on our callers to figure out that its
6571 really a template that's being returned. */
6572 old_decl = DECL_TEMPLATE_RESULT (old_decl);
6574 if (DECL_STATIC_FUNCTION_P (old_decl)
6575 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
6576 /* Remove the `this' parm added by grokclassfn.
6577 XXX Isn't this done in start_function, too? */
6578 revert_static_member_fn (decl);
6579 if (DECL_ARTIFICIAL (old_decl))
6581 error ("definition of implicitly-declared %qD", old_decl);
6585 /* Since we've smashed OLD_DECL to its
6586 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
6587 if (TREE_CODE (decl) == TEMPLATE_DECL)
6588 decl = DECL_TEMPLATE_RESULT (decl);
6590 /* Attempt to merge the declarations. This can fail, in
6591 the case of some invalid specialization declarations. */
6592 pushed_scope = push_scope (ctype);
6593 ok = duplicate_decls (decl, old_decl, friendp);
6595 pop_scope (pushed_scope);
6598 error ("no %q#D member function declared in class %qT",
6606 if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
6609 if (ctype == NULL_TREE || check)
6613 DECL_VIRTUAL_P (decl) = 1;
6618 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
6619 the linkage that DECL will receive in the object file. */
6622 set_linkage_for_static_data_member (tree decl)
6624 /* A static data member always has static storage duration and
6625 external linkage. Note that static data members are forbidden in
6626 local classes -- the only situation in which a class has
6627 non-external linkage. */
6628 TREE_PUBLIC (decl) = 1;
6629 TREE_STATIC (decl) = 1;
6630 /* For non-template classes, static data members are always put
6631 out in exactly those files where they are defined, just as
6632 with ordinary namespace-scope variables. */
6633 if (!processing_template_decl)
6634 DECL_INTERFACE_KNOWN (decl) = 1;
6637 /* Create a VAR_DECL named NAME with the indicated TYPE.
6639 If SCOPE is non-NULL, it is the class type or namespace containing
6640 the variable. If SCOPE is NULL, the variable should is created in
6641 the innermost enclosings scope. */
6644 grokvardecl (tree type,
6646 const cp_decl_specifier_seq *declspecs,
6652 tree explicit_scope;
6654 gcc_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE);
6656 /* Compute the scope in which to place the variable, but remember
6657 whether or not that scope was explicitly specified by the user. */
6658 explicit_scope = scope;
6661 /* An explicit "extern" specifier indicates a namespace-scope
6663 if (declspecs->storage_class == sc_extern)
6664 scope = current_namespace;
6665 else if (!at_function_scope_p ())
6666 scope = current_scope ();
6670 && (/* If the variable is a namespace-scope variable declared in a
6671 template, we need DECL_LANG_SPECIFIC. */
6672 (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
6673 /* Similarly for namespace-scope variables with language linkage
6675 || (TREE_CODE (scope) == NAMESPACE_DECL
6676 && current_lang_name != lang_name_cplusplus)
6677 /* Similarly for static data members. */
6679 decl = build_lang_decl (VAR_DECL, name, type);
6681 decl = build_decl (VAR_DECL, name, type);
6683 if (explicit_scope && TREE_CODE (explicit_scope) == NAMESPACE_DECL)
6684 set_decl_namespace (decl, explicit_scope, 0);
6686 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
6688 if (declspecs->storage_class == sc_extern)
6690 DECL_THIS_EXTERN (decl) = 1;
6691 DECL_EXTERNAL (decl) = !initialized;
6694 if (DECL_CLASS_SCOPE_P (decl))
6696 set_linkage_for_static_data_member (decl);
6697 /* This function is only called with out-of-class definitions. */
6698 DECL_EXTERNAL (decl) = 0;
6699 check_class_member_definition_namespace (decl);
6701 /* At top level, either `static' or no s.c. makes a definition
6702 (perhaps tentative), and absence of `static' makes it public. */
6703 else if (toplevel_bindings_p ())
6705 TREE_PUBLIC (decl) = (declspecs->storage_class != sc_static
6706 && (DECL_THIS_EXTERN (decl) || ! constp));
6707 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
6709 /* Not at top level, only `static' makes a static definition. */
6712 TREE_STATIC (decl) = declspecs->storage_class == sc_static;
6713 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
6716 if (declspecs->specs[(int)ds_thread])
6717 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
6719 if (TREE_PUBLIC (decl))
6721 /* [basic.link]: A name with no linkage (notably, the name of a class
6722 or enumeration declared in a local scope) shall not be used to
6723 declare an entity with linkage.
6725 Only check this for public decls for now. */
6726 tree t = no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false);
6729 if (TYPE_ANONYMOUS_P (t))
6731 if (DECL_EXTERN_C_P (decl))
6732 /* Allow this; it's pretty common in C. */
6736 /* DRs 132, 319 and 389 seem to indicate types with
6737 no linkage can only be used to declare extern "C"
6738 entities. Since it's not always an error in the
6739 ISO C++ 90 Standard, we only issue a warning. */
6740 warning (0, "non-local variable %q#D uses anonymous type",
6742 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
6743 warning (0, "%q+#D does not refer to the unqualified "
6744 "type, so it is not used for linkage",
6749 warning (0, "non-local variable %q#D uses local type %qT", decl, t);
6753 DECL_INTERFACE_KNOWN (decl) = 1;
6758 /* Create and return a canonical pointer to member function type, for
6759 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
6762 build_ptrmemfunc_type (tree type)
6766 tree unqualified_variant = NULL_TREE;
6768 if (type == error_mark_node)
6771 /* If a canonical type already exists for this type, use it. We use
6772 this method instead of type_hash_canon, because it only does a
6773 simple equality check on the list of field members. */
6775 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
6778 /* Make sure that we always have the unqualified pointer-to-member
6780 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
6782 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
6784 t = make_aggr_type (RECORD_TYPE);
6785 xref_basetypes (t, NULL_TREE);
6787 /* Let the front end know this is a pointer to member function... */
6788 TYPE_PTRMEMFUNC_FLAG (t) = 1;
6789 /* ... and not really an aggregate. */
6790 SET_IS_AGGR_TYPE (t, 0);
6792 field = build_decl (FIELD_DECL, pfn_identifier, type);
6795 field = build_decl (FIELD_DECL, delta_identifier, delta_type_node);
6796 TREE_CHAIN (field) = fields;
6799 finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
6801 /* Zap out the name so that the back end will give us the debugging
6802 information for this anonymous RECORD_TYPE. */
6803 TYPE_NAME (t) = NULL_TREE;
6805 /* If this is not the unqualified form of this pointer-to-member
6806 type, set the TYPE_MAIN_VARIANT for this type to be the
6807 unqualified type. Since they are actually RECORD_TYPEs that are
6808 not variants of each other, we must do this manually. */
6809 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
6811 t = build_qualified_type (t, cp_type_quals (type));
6812 TYPE_MAIN_VARIANT (t) = unqualified_variant;
6813 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
6814 TYPE_NEXT_VARIANT (unqualified_variant) = t;
6817 /* Cache this pointer-to-member type so that we can find it again
6819 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
6821 /* Managing canonical types for the RECORD_TYPE behind a
6822 pointer-to-member function is a nightmare, so use structural
6823 equality for now. */
6824 SET_TYPE_STRUCTURAL_EQUALITY (t);
6829 /* Create and return a pointer to data member type. */
6832 build_ptrmem_type (tree class_type, tree member_type)
6834 if (TREE_CODE (member_type) == METHOD_TYPE)
6838 arg_types = TYPE_ARG_TYPES (member_type);
6839 class_type = (cp_build_qualified_type
6841 cp_type_quals (TREE_TYPE (TREE_VALUE (arg_types)))));
6843 = build_method_type_directly (class_type,
6844 TREE_TYPE (member_type),
6845 TREE_CHAIN (arg_types));
6846 return build_ptrmemfunc_type (build_pointer_type (member_type));
6850 gcc_assert (TREE_CODE (member_type) != FUNCTION_TYPE);
6851 return build_offset_type (class_type, member_type);
6855 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
6856 Check to see that the definition is valid. Issue appropriate error
6857 messages. Return 1 if the definition is particularly bad, or 0
6861 check_static_variable_definition (tree decl, tree type)
6863 /* Motion 10 at San Diego: If a static const integral data member is
6864 initialized with an integral constant expression, the initializer
6865 may appear either in the declaration (within the class), or in
6866 the definition, but not both. If it appears in the class, the
6867 member is a member constant. The file-scope definition is always
6869 if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
6871 error ("invalid in-class initialization of static data member "
6872 "of non-integral type %qT",
6874 /* If we just return the declaration, crashes will sometimes
6875 occur. We therefore return void_type_node, as if this were a
6876 friend declaration, to cause callers to completely ignore
6877 this declaration. */
6880 else if (!CP_TYPE_CONST_P (type))
6881 error ("ISO C++ forbids in-class initialization of non-const "
6882 "static member %qD",
6884 else if (pedantic && !INTEGRAL_TYPE_P (type))
6885 pedwarn ("ISO C++ forbids initialization of member constant "
6886 "%qD of non-integral type %qT", decl, type);
6891 /* Given the SIZE (i.e., number of elements) in an array, compute an
6892 appropriate index type for the array. If non-NULL, NAME is the
6893 name of the thing being declared. */
6896 compute_array_index_type (tree name, tree size)
6900 tree abi_1_itype = NULL_TREE;
6902 if (error_operand_p (size))
6903 return error_mark_node;
6905 type = TREE_TYPE (size);
6906 /* The array bound must be an integer type. */
6907 if (!dependent_type_p (type) && !INTEGRAL_TYPE_P (type))
6910 error ("size of array %qD has non-integral type %qT", name, type);
6912 error ("size of array has non-integral type %qT", type);
6913 size = integer_one_node;
6914 type = TREE_TYPE (size);
6917 if (value_dependent_expression_p (size))
6919 /* We cannot do any checking for a value-dependent SIZE. Just
6920 build the index type and mark that it requires structural
6922 itype = build_index_type (build_min (MINUS_EXPR, sizetype,
6923 size, integer_one_node));
6924 SET_TYPE_STRUCTURAL_EQUALITY (itype);
6928 if (!abi_version_at_least (2) && processing_template_decl)
6929 /* For abi-1, we handled all instances in templates the same way,
6930 even when they were non-dependent. This effects the manglings
6931 produced. So, we do the normal checking for non-dependent
6932 sizes, but at the end we'll return the same type that abi-1
6933 would have, but with TYPE_CANONICAL set to the "right"
6934 value that the current ABI would provide. */
6935 abi_1_itype = build_index_type (build_min (MINUS_EXPR, sizetype,
6936 size, integer_one_node));
6938 /* The size might be the result of a cast. */
6939 STRIP_TYPE_NOPS (size);
6941 /* It might be a const variable or enumeration constant. */
6942 size = integral_constant_value (size);
6944 /* Normally, the array-bound will be a constant. */
6945 if (TREE_CODE (size) == INTEGER_CST)
6947 /* Check to see if the array bound overflowed. Make that an
6948 error, no matter how generous we're being. */
6949 int old_flag_pedantic_errors = flag_pedantic_errors;
6950 int old_pedantic = pedantic;
6951 pedantic = flag_pedantic_errors = 1;
6952 constant_expression_warning (size);
6953 pedantic = old_pedantic;
6954 flag_pedantic_errors = old_flag_pedantic_errors;
6956 /* An array must have a positive number of elements. */
6957 if (INT_CST_LT (size, integer_zero_node))
6960 error ("size of array %qD is negative", name);
6962 error ("size of array is negative");
6963 size = integer_one_node;
6965 /* As an extension we allow zero-sized arrays. We always allow
6966 them in system headers because glibc uses them. */
6967 else if (integer_zerop (size) && pedantic && !in_system_header)
6970 pedwarn ("ISO C++ forbids zero-size array %qD", name);
6972 pedwarn ("ISO C++ forbids zero-size array");
6975 else if (TREE_CONSTANT (size))
6977 /* `(int) &fn' is not a valid array bound. */
6979 error ("size of array %qD is not an integral constant-expression",
6982 error ("size of array is not an integral constant-expression");
6983 size = integer_one_node;
6985 else if (pedantic && warn_vla != 0)
6988 pedwarn ("ISO C++ forbids variable length array %qD", name);
6990 pedwarn ("ISO C++ forbids variable length array");
6992 else if (warn_vla > 0)
6996 "variable length array %qD is used", name);
6999 "variable length array is used");
7002 if (processing_template_decl && !TREE_CONSTANT (size))
7003 /* A variable sized array. */
7004 itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node);
7007 HOST_WIDE_INT saved_processing_template_decl;
7009 /* Compute the index of the largest element in the array. It is
7010 one less than the number of elements in the array. We save
7011 and restore PROCESSING_TEMPLATE_DECL so that computations in
7012 cp_build_binary_op will be appropriately folded. */
7013 saved_processing_template_decl = processing_template_decl;
7014 processing_template_decl = 0;
7015 itype = cp_build_binary_op (MINUS_EXPR,
7016 cp_convert (ssizetype, size),
7017 cp_convert (ssizetype, integer_one_node));
7018 itype = fold (itype);
7019 processing_template_decl = saved_processing_template_decl;
7021 if (!TREE_CONSTANT (itype))
7022 /* A variable sized array. */
7023 itype = variable_size (itype);
7024 /* Make sure that there was no overflow when creating to a signed
7025 index type. (For example, on a 32-bit machine, an array with
7026 size 2^32 - 1 is too big.) */
7027 else if (TREE_CODE (itype) == INTEGER_CST
7028 && TREE_OVERFLOW (itype))
7030 error ("overflow in array dimension");
7031 TREE_OVERFLOW (itype) = 0;
7035 /* Create and return the appropriate index type. */
7038 tree t = build_index_type (itype);
7039 TYPE_CANONICAL (abi_1_itype) = TYPE_CANONICAL (t);
7043 return build_index_type (itype);
7046 /* Returns the scope (if any) in which the entity declared by
7047 DECLARATOR will be located. If the entity was declared with an
7048 unqualified name, NULL_TREE is returned. */
7051 get_scope_of_declarator (const cp_declarator *declarator)
7053 while (declarator && declarator->kind != cdk_id)
7054 declarator = declarator->declarator;
7056 /* If the declarator-id is a SCOPE_REF, the scope in which the
7057 declaration occurs is the first operand. */
7059 && declarator->u.id.qualifying_scope)
7060 return declarator->u.id.qualifying_scope;
7062 /* Otherwise, the declarator is not a qualified name; the entity will
7063 be declared in the current scope. */
7067 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
7068 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
7072 create_array_type_for_decl (tree name, tree type, tree size)
7074 tree itype = NULL_TREE;
7075 const char* error_msg;
7077 /* If things have already gone awry, bail now. */
7078 if (type == error_mark_node || size == error_mark_node)
7079 return error_mark_node;
7081 /* Assume that everything will go OK. */
7084 /* There are some types which cannot be array elements. */
7085 switch (TREE_CODE (type))
7088 error_msg = "array of void";
7092 error_msg = "array of functions";
7095 case REFERENCE_TYPE:
7096 error_msg = "array of references";
7100 error_msg = "array of function members";
7107 /* If something went wrong, issue an error-message and return. */
7111 error ("declaration of %qD as %s", name, error_msg);
7113 error ("creating %s", error_msg);
7115 return error_mark_node;
7120 The constant expressions that specify the bounds of the arrays
7121 can be omitted only for the first member of the sequence. */
7122 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
7125 error ("declaration of %qD as multidimensional array must "
7126 "have bounds for all dimensions except the first",
7129 error ("multidimensional array must have bounds for all "
7130 "dimensions except the first");
7132 return error_mark_node;
7135 /* Figure out the index type for the array. */
7137 itype = compute_array_index_type (name, size);
7140 T is called the array element type; this type shall not be [...] an
7141 abstract class type. */
7142 abstract_virtuals_error (name, type);
7144 return build_cplus_array_type (type, itype);
7147 /* Check that it's OK to declare a function with the indicated TYPE.
7148 SFK indicates the kind of special function (if any) that this
7149 function is. OPTYPE is the type given in a conversion operator
7150 declaration, or the class type for a constructor/destructor.
7151 Returns the actual return type of the function; that
7152 may be different than TYPE if an error occurs, or for certain
7153 special functions. */
7156 check_special_function_return_type (special_function_kind sfk,
7162 case sfk_constructor:
7164 error ("return type specification for constructor invalid");
7166 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
7167 type = build_pointer_type (optype);
7169 type = void_type_node;
7172 case sfk_destructor:
7174 error ("return type specification for destructor invalid");
7175 /* We can't use the proper return type here because we run into
7176 problems with ambiguous bases and covariant returns.
7177 Java classes are left unchanged because (void *) isn't a valid
7178 Java type, and we don't want to change the Java ABI. */
7179 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
7180 type = build_pointer_type (void_type_node);
7182 type = void_type_node;
7185 case sfk_conversion:
7187 error ("return type specified for %<operator %T%>", optype);
7198 /* A variable or data member (whose unqualified name is IDENTIFIER)
7199 has been declared with the indicated TYPE. If the TYPE is not
7200 acceptable, issue an error message and return a type to use for
7201 error-recovery purposes. */
7204 check_var_type (tree identifier, tree type)
7206 if (VOID_TYPE_P (type))
7209 error ("unnamed variable or field declared void");
7210 else if (TREE_CODE (identifier) == IDENTIFIER_NODE)
7212 gcc_assert (!IDENTIFIER_OPNAME_P (identifier));
7213 error ("variable or field %qE declared void", identifier);
7216 error ("variable or field declared void");
7217 type = error_mark_node;
7223 /* Given declspecs and a declarator (abstract or otherwise), determine
7224 the name and type of the object declared and construct a DECL node
7227 DECLSPECS points to the representation of declaration-specifier
7228 sequence that precedes declarator.
7230 DECL_CONTEXT says which syntactic context this declaration is in:
7231 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
7232 FUNCDEF for a function definition. Like NORMAL but a few different
7233 error messages in each case. Return value may be zero meaning
7234 this definition is too screwy to try to parse.
7235 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
7236 handle member functions (which have FIELD context).
7237 Return value may be zero meaning this definition is too screwy to
7239 PARM for a parameter declaration (either within a function prototype
7240 or before a function body). Make a PARM_DECL, or return void_type_node.
7241 CATCHPARM for a parameter declaration before a catch clause.
7242 TYPENAME if for a typename (in a cast or sizeof).
7243 Don't make a DECL node; just return the ..._TYPE node.
7244 FIELD for a struct or union field; make a FIELD_DECL.
7245 BITFIELD for a field with specified width.
7246 INITIALIZED is 1 if the decl has an initializer.
7248 ATTRLIST is a pointer to the list of attributes, which may be NULL
7249 if there are none; *ATTRLIST may be modified if attributes from inside
7250 the declarator should be applied to the declaration.
7252 When this function is called, scoping variables (such as
7253 CURRENT_CLASS_TYPE) should reflect the scope in which the
7254 declaration occurs, not the scope in which the new declaration will
7255 be placed. For example, on:
7259 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
7262 Returns a DECL (if a declarator is present), a TYPE (if there is no
7263 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
7267 grokdeclarator (const cp_declarator *declarator,
7268 const cp_decl_specifier_seq *declspecs,
7269 enum decl_context decl_context,
7273 tree type = NULL_TREE;
7275 int virtualp, explicitp, friendp, inlinep, staticp;
7276 int explicit_int = 0;
7277 int explicit_char = 0;
7278 int defaulted_int = 0;
7279 tree dependent_name = NULL_TREE;
7281 tree typedef_decl = NULL_TREE;
7282 const char *name = NULL;
7283 tree typedef_type = NULL_TREE;
7284 /* True if this declarator is a function definition. */
7285 bool funcdef_flag = false;
7286 cp_declarator_kind innermost_code = cdk_error;
7289 /* See the code below that used this. */
7290 tree decl_attr = NULL_TREE;
7293 /* Keep track of what sort of function is being processed
7294 so that we can warn about default return values, or explicit
7295 return values which do not match prescribed defaults. */
7296 special_function_kind sfk = sfk_none;
7298 tree dname = NULL_TREE;
7299 tree ctor_return_type = NULL_TREE;
7300 enum overload_flags flags = NO_SPECIAL;
7301 /* cv-qualifiers that apply to the declarator, for a declaration of
7302 a member function. */
7303 cp_cv_quals memfn_quals = TYPE_UNQUALIFIED;
7304 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
7306 tree raises = NULL_TREE;
7307 int template_count = 0;
7308 tree returned_attrs = NULL_TREE;
7309 tree parms = NULL_TREE;
7310 const cp_declarator *id_declarator;
7311 /* The unqualified name of the declarator; either an
7312 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
7313 tree unqualified_id;
7314 /* The class type, if any, in which this entity is located,
7315 or NULL_TREE if none. Note that this value may be different from
7316 the current class type; for example if an attempt is made to declare
7317 "A::f" inside "B", this value will be "A". */
7318 tree ctype = current_class_type;
7319 /* The NAMESPACE_DECL for the namespace in which this entity is
7320 located. If an unqualified name is used to declare the entity,
7321 this value will be NULL_TREE, even if the entity is located at
7323 tree in_namespace = NULL_TREE;
7324 cp_storage_class storage_class;
7325 bool unsigned_p, signed_p, short_p, long_p, thread_p;
7326 bool type_was_error_mark_node = false;
7327 bool parameter_pack_p = declarator? declarator->parameter_pack_p : false;
7328 bool set_no_warning = false;
7330 signed_p = declspecs->specs[(int)ds_signed];
7331 unsigned_p = declspecs->specs[(int)ds_unsigned];
7332 short_p = declspecs->specs[(int)ds_short];
7333 long_p = declspecs->specs[(int)ds_long];
7334 longlong = declspecs->specs[(int)ds_long] >= 2;
7335 thread_p = declspecs->specs[(int)ds_thread];
7337 if (decl_context == FUNCDEF)
7338 funcdef_flag = true, decl_context = NORMAL;
7339 else if (decl_context == MEMFUNCDEF)
7340 funcdef_flag = true, decl_context = FIELD;
7341 else if (decl_context == BITFIELD)
7342 bitfield = 1, decl_context = FIELD;
7344 /* Look inside a declarator for the name being declared
7345 and get it as a string, for an error message. */
7346 for (id_declarator = declarator;
7348 id_declarator = id_declarator->declarator)
7350 if (id_declarator->kind != cdk_id)
7351 innermost_code = id_declarator->kind;
7353 switch (id_declarator->kind)
7356 if (id_declarator->declarator
7357 && id_declarator->declarator->kind == cdk_id)
7359 sfk = id_declarator->declarator->u.id.sfk;
7360 if (sfk == sfk_destructor)
7367 tree qualifying_scope = id_declarator->u.id.qualifying_scope;
7368 tree decl = id_declarator->u.id.unqualified_name;
7371 if (qualifying_scope)
7373 if (at_function_scope_p ())
7377 A declarator-id shall not be qualified except
7380 None of the cases are permitted in block
7382 if (qualifying_scope == global_namespace)
7383 error ("invalid use of qualified-name %<::%D%>",
7385 else if (TYPE_P (qualifying_scope))
7386 error ("invalid use of qualified-name %<%T::%D%>",
7387 qualifying_scope, decl);
7389 error ("invalid use of qualified-name %<%D::%D%>",
7390 qualifying_scope, decl);
7391 return error_mark_node;
7393 else if (TYPE_P (qualifying_scope))
7395 ctype = qualifying_scope;
7396 if (innermost_code != cdk_function
7397 && current_class_type
7398 && !UNIQUELY_DERIVED_FROM_P (ctype,
7399 current_class_type))
7401 error ("type %qT is not derived from type %qT",
7402 ctype, current_class_type);
7403 return error_mark_node;
7406 else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL)
7407 in_namespace = qualifying_scope;
7409 switch (TREE_CODE (decl))
7415 if (innermost_code != cdk_function)
7417 error ("declaration of %qD as non-function", decl);
7418 return error_mark_node;
7420 else if (!qualifying_scope
7421 && !(current_class_type && at_class_scope_p ()))
7423 error ("declaration of %qD as non-member", decl);
7424 return error_mark_node;
7427 type = TREE_OPERAND (decl, 0);
7428 name = IDENTIFIER_POINTER (constructor_name (type));
7433 case TEMPLATE_ID_EXPR:
7435 tree fns = TREE_OPERAND (decl, 0);
7438 if (TREE_CODE (dname) != IDENTIFIER_NODE)
7440 gcc_assert (is_overloaded_fn (dname));
7441 dname = DECL_NAME (get_first_fn (dname));
7446 case IDENTIFIER_NODE:
7447 if (TREE_CODE (decl) == IDENTIFIER_NODE)
7450 if (C_IS_RESERVED_WORD (dname))
7452 error ("declarator-id missing; using reserved word %qD",
7454 name = IDENTIFIER_POINTER (dname);
7456 else if (!IDENTIFIER_TYPENAME_P (dname))
7457 name = IDENTIFIER_POINTER (dname);
7460 gcc_assert (flags == NO_SPECIAL);
7461 flags = TYPENAME_FLAG;
7462 ctor_return_type = TREE_TYPE (dname);
7463 sfk = sfk_conversion;
7464 if (is_typename_at_global_scope (dname))
7465 name = IDENTIFIER_POINTER (dname);
7467 name = "<invalid operator>";
7484 return error_mark_node;
7489 if (id_declarator->kind == cdk_id)
7495 The declarator in a function-definition shall have the form
7496 D1 ( parameter-declaration-clause) ... */
7497 if (funcdef_flag && innermost_code != cdk_function)
7499 error ("function definition does not declare parameters");
7500 return error_mark_node;
7503 if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
7504 && innermost_code != cdk_function
7505 && ! (ctype && !declspecs->any_specifiers_p))
7507 error ("declaration of %qD as non-function", dname);
7508 return error_mark_node;
7511 /* Anything declared one level down from the top level
7512 must be one of the parameters of a function
7513 (because the body is at least two levels down). */
7515 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
7516 by not allowing C++ class definitions to specify their parameters
7517 with xdecls (must be spec.d in the parmlist).
7519 Since we now wait to push a class scope until we are sure that
7520 we are in a legitimate method context, we must set oldcname
7521 explicitly (since current_class_name is not yet alive).
7523 We also want to avoid calling this a PARM if it is in a namespace. */
7525 if (decl_context == NORMAL && !toplevel_bindings_p ())
7527 struct cp_binding_level *b = current_binding_level;
7528 current_binding_level = b->level_chain;
7529 if (current_binding_level != 0 && toplevel_bindings_p ())
7530 decl_context = PARM;
7531 current_binding_level = b;
7535 name = decl_context == PARM ? "parameter" : "type name";
7537 /* If there were multiple types specified in the decl-specifier-seq,
7538 issue an error message. */
7539 if (declspecs->multiple_types_p)
7541 error ("two or more data types in declaration of %qs", name);
7542 return error_mark_node;
7545 /* Extract the basic type from the decl-specifier-seq. */
7546 type = declspecs->type;
7547 if (type == error_mark_node)
7550 type_was_error_mark_node = true;
7552 /* If the entire declaration is itself tagged as deprecated then
7553 suppress reports of deprecated items. */
7554 if (type && TREE_DEPRECATED (type)
7555 && deprecated_state != DEPRECATED_SUPPRESS)
7556 warn_deprecated_use (type);
7557 if (type && TREE_CODE (type) == TYPE_DECL)
7559 typedef_decl = type;
7560 type = TREE_TYPE (typedef_decl);
7561 if (TREE_DEPRECATED (type)
7562 && DECL_ARTIFICIAL (typedef_decl)
7563 && deprecated_state != DEPRECATED_SUPPRESS)
7564 warn_deprecated_use (type);
7566 /* No type at all: default to `int', and set DEFAULTED_INT
7567 because it was not a user-defined typedef. */
7568 if (type == NULL_TREE && (signed_p || unsigned_p || long_p || short_p))
7570 /* These imply 'int'. */
7571 type = integer_type_node;
7575 explicit_int = declspecs->explicit_int_p;
7576 explicit_char = declspecs->explicit_char_p;
7579 /* See the code below that used this. */
7581 decl_attr = DECL_ATTRIBUTES (typedef_decl);
7583 typedef_type = type;
7586 if (sfk != sfk_conversion)
7587 ctor_return_type = ctype;
7589 if (sfk != sfk_none)
7590 type = check_special_function_return_type (sfk, type,
7592 else if (type == NULL_TREE)
7598 /* We handle `main' specially here, because 'main () { }' is so
7599 common. With no options, it is allowed. With -Wreturn-type,
7600 it is a warning. It is only an error with -pedantic-errors. */
7601 is_main = (funcdef_flag
7602 && dname && MAIN_NAME_P (dname)
7603 && ctype == NULL_TREE
7604 && in_namespace == NULL_TREE
7605 && current_namespace == global_namespace);
7607 if (type_was_error_mark_node)
7608 /* We've already issued an error, don't complain more. */;
7609 else if (in_system_header || flag_ms_extensions)
7610 /* Allow it, sigh. */;
7611 else if (pedantic || ! is_main)
7612 pedwarn ("ISO C++ forbids declaration of %qs with no type", name);
7614 warning (OPT_Wreturn_type,
7615 "ISO C++ forbids declaration of %qs with no type", name);
7617 type = integer_type_node;
7622 /* Now process the modifiers that were specified
7623 and check for invalid combinations. */
7625 /* Long double is a special combination. */
7626 if (long_p && !longlong && TYPE_MAIN_VARIANT (type) == double_type_node)
7629 type = build_qualified_type (long_double_type_node,
7630 cp_type_quals (type));
7633 /* Check all other uses of type modifiers. */
7635 if (unsigned_p || signed_p || long_p || short_p)
7639 if ((signed_p || unsigned_p) && TREE_CODE (type) != INTEGER_TYPE)
7640 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
7641 else if (signed_p && unsigned_p)
7642 error ("%<signed%> and %<unsigned%> specified together for %qs", name);
7643 else if (longlong && TREE_CODE (type) != INTEGER_TYPE)
7644 error ("%<long long%> invalid for %qs", name);
7645 else if (long_p && TREE_CODE (type) == REAL_TYPE)
7646 error ("%<long%> invalid for %qs", name);
7647 else if (short_p && TREE_CODE (type) == REAL_TYPE)
7648 error ("%<short%> invalid for %qs", name);
7649 else if ((long_p || short_p) && TREE_CODE (type) != INTEGER_TYPE)
7650 error ("%<long%> or %<short%> invalid for %qs", name);
7651 else if ((long_p || short_p) && explicit_char)
7652 error ("%<long%> or %<short%> specified with char for %qs", name);
7653 else if (long_p && short_p)
7654 error ("%<long%> and %<short%> specified together for %qs", name);
7658 if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
7660 pedwarn ("long, short, signed or unsigned used invalidly for %qs",
7662 if (flag_pedantic_errors)
7667 /* Discard the type modifiers if they are invalid. */
7678 /* Decide whether an integer type is signed or not.
7679 Optionally treat bitfields as signed by default. */
7683 It is implementation-defined whether a plain (neither
7684 explicitly signed or unsigned) char, short, int, or long
7685 bit-field is signed or unsigned.
7687 Naturally, we extend this to long long as well. Note that
7688 this does not include wchar_t. */
7689 || (bitfield && !flag_signed_bitfields
7691 /* A typedef for plain `int' without `signed' can be
7692 controlled just like plain `int', but a typedef for
7693 `signed int' cannot be so controlled. */
7695 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
7696 && TREE_CODE (type) == INTEGER_TYPE
7697 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
7700 type = long_long_unsigned_type_node;
7702 type = long_unsigned_type_node;
7704 type = short_unsigned_type_node;
7705 else if (type == char_type_node)
7706 type = unsigned_char_type_node;
7707 else if (typedef_decl)
7708 type = unsigned_type_for (type);
7710 type = unsigned_type_node;
7712 else if (signed_p && type == char_type_node)
7713 type = signed_char_type_node;
7715 type = long_long_integer_type_node;
7717 type = long_integer_type_node;
7719 type = short_integer_type_node;
7721 if (declspecs->specs[(int)ds_complex])
7723 if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
7724 error ("complex invalid for %qs", name);
7725 /* If we just have "complex", it is equivalent to
7726 "complex double", but if any modifiers at all are specified it is
7727 the complex form of TYPE. E.g, "complex short" is
7728 "complex short int". */
7730 else if (defaulted_int && ! longlong
7731 && ! (long_p || short_p || signed_p || unsigned_p))
7732 type = complex_double_type_node;
7733 else if (type == integer_type_node)
7734 type = complex_integer_type_node;
7735 else if (type == float_type_node)
7736 type = complex_float_type_node;
7737 else if (type == double_type_node)
7738 type = complex_double_type_node;
7739 else if (type == long_double_type_node)
7740 type = complex_long_double_type_node;
7742 type = build_complex_type (type);
7745 type_quals = TYPE_UNQUALIFIED;
7746 if (declspecs->specs[(int)ds_const])
7747 type_quals |= TYPE_QUAL_CONST;
7748 if (declspecs->specs[(int)ds_volatile])
7749 type_quals |= TYPE_QUAL_VOLATILE;
7750 if (declspecs->specs[(int)ds_restrict])
7751 type_quals |= TYPE_QUAL_RESTRICT;
7752 if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
7753 error ("qualifiers are not allowed on declaration of %<operator %T%>",
7756 if (TREE_CODE (type) == FUNCTION_TYPE
7757 && type_quals != TYPE_UNQUALIFIED)
7759 /* This was an error in C++98 (cv-qualifiers cannot be added to
7760 a function type), but DR 295 makes the code well-formed by
7761 dropping the extra qualifiers. */
7764 tree bad_type = build_qualified_type (type, type_quals);
7765 pedwarn ("ignoring %qV qualifiers added to function type %qT",
7768 type_quals = TYPE_UNQUALIFIED;
7770 type_quals |= cp_type_quals (type);
7771 type = cp_build_qualified_type_real
7772 (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
7773 ? tf_ignore_bad_quals : 0) | tf_warning_or_error));
7774 /* We might have ignored or rejected some of the qualifiers. */
7775 type_quals = cp_type_quals (type);
7778 inlinep = !! declspecs->specs[(int)ds_inline];
7779 virtualp = !! declspecs->specs[(int)ds_virtual];
7780 explicitp = !! declspecs->specs[(int)ds_explicit];
7782 storage_class = declspecs->storage_class;
7783 if (storage_class == sc_static)
7784 staticp = 1 + (decl_context == FIELD);
7786 if (virtualp && staticp == 2)
7788 error ("member %qD cannot be declared both virtual and static", dname);
7789 storage_class = sc_none;
7792 friendp = !! declspecs->specs[(int)ds_friend];
7794 if (dependent_name && !friendp)
7796 error ("%<%T::%D%> is not a valid declarator", ctype, dependent_name);
7797 return error_mark_node;
7800 /* Issue errors about use of storage classes for parameters. */
7801 if (decl_context == PARM)
7803 if (declspecs->specs[(int)ds_typedef])
7805 error ("typedef declaration invalid in parameter declaration");
7806 return error_mark_node;
7808 else if (storage_class == sc_static
7809 || storage_class == sc_extern
7811 error ("storage class specifiers invalid in parameter declarations");
7814 /* Give error if `virtual' is used outside of class declaration. */
7816 && (current_class_name == NULL_TREE || decl_context != FIELD))
7818 error ("virtual outside class declaration");
7822 /* Static anonymous unions are dealt with here. */
7823 if (staticp && decl_context == TYPENAME
7825 && ANON_AGGR_TYPE_P (declspecs->type))
7826 decl_context = FIELD;
7828 /* Warn about storage classes that are invalid for certain
7829 kinds of declarations (parameters, typenames, etc.). */
7832 && storage_class != sc_extern
7833 && storage_class != sc_static)
7834 || declspecs->specs[(int)ds_typedef]))
7836 error ("multiple storage classes in declaration of %qs", name);
7839 if (declspecs->conflicting_specifiers_p)
7841 error ("conflicting specifiers in declaration of %qs", name);
7842 storage_class = sc_none;
7844 else if (decl_context != NORMAL
7845 && ((storage_class != sc_none
7846 && storage_class != sc_mutable)
7849 if ((decl_context == PARM || decl_context == CATCHPARM)
7850 && (storage_class == sc_register
7851 || storage_class == sc_auto))
7853 else if (declspecs->specs[(int)ds_typedef])
7855 else if (decl_context == FIELD
7856 /* C++ allows static class elements. */
7857 && storage_class == sc_static)
7858 /* C++ also allows inlines and signed and unsigned elements,
7859 but in those cases we don't come in here. */
7863 if (decl_context == FIELD)
7864 error ("storage class specified for %qs", name);
7867 if (decl_context == PARM || decl_context == CATCHPARM)
7868 error ("storage class specified for parameter %qs", name);
7870 error ("storage class specified for typename");
7872 if (storage_class == sc_register
7873 || storage_class == sc_auto
7874 || storage_class == sc_extern
7876 storage_class = sc_none;
7879 else if (storage_class == sc_extern && initialized
7882 if (toplevel_bindings_p ())
7884 /* It's common practice (and completely valid) to have a const
7885 be initialized and declared extern. */
7886 if (!(type_quals & TYPE_QUAL_CONST))
7887 warning (0, "%qs initialized and declared %<extern%>", name);
7890 error ("%qs has both %<extern%> and initializer", name);
7892 else if (storage_class == sc_extern && funcdef_flag
7893 && ! toplevel_bindings_p ())
7894 error ("nested function %qs declared %<extern%>", name);
7895 else if (toplevel_bindings_p ())
7897 if (storage_class == sc_auto)
7898 error ("top-level declaration of %qs specifies %<auto%>", name);
7901 && storage_class != sc_extern
7902 && storage_class != sc_static)
7904 error ("function-scope %qs implicitly auto and declared %<__thread%>",
7909 if (storage_class && friendp)
7910 error ("storage class specifiers invalid in friend function declarations");
7913 unqualified_id = NULL_TREE;
7916 unqualified_id = id_declarator->u.id.unqualified_name;
7917 switch (TREE_CODE (unqualified_id))
7921 = constructor_name (TREE_OPERAND (unqualified_id, 0));
7924 case IDENTIFIER_NODE:
7925 case TEMPLATE_ID_EXPR:
7933 /* Determine the type of the entity declared by recurring on the
7935 for (; declarator; declarator = declarator->declarator)
7937 const cp_declarator *inner_declarator;
7940 if (type == error_mark_node)
7941 return error_mark_node;
7943 attrs = declarator->attributes;
7949 if (declarator == NULL || declarator->kind == cdk_id)
7950 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
7951 if (declarator->kind == cdk_function)
7952 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
7953 if (declarator->kind == cdk_array)
7954 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
7955 returned_attrs = decl_attributes (&type,
7956 chainon (returned_attrs, attrs),
7960 if (declarator->kind == cdk_id)
7963 inner_declarator = declarator->declarator;
7965 switch (declarator->kind)
7968 type = create_array_type_for_decl (dname, type,
7969 declarator->u.array.bounds);
7977 /* Declaring a function type.
7978 Make sure we have a valid type for the function to return. */
7980 if (type_quals != TYPE_UNQUALIFIED)
7982 if (SCALAR_TYPE_P (type) || VOID_TYPE_P (type))
7983 warning (OPT_Wreturn_type,
7984 "type qualifiers ignored on function return type");
7985 /* We now know that the TYPE_QUALS don't apply to the
7986 decl, but to its return type. */
7987 type_quals = TYPE_UNQUALIFIED;
7988 set_no_warning = true;
7991 /* Warn about some types functions can't return. */
7993 if (TREE_CODE (type) == FUNCTION_TYPE)
7995 error ("%qs declared as function returning a function", name);
7996 type = integer_type_node;
7998 if (TREE_CODE (type) == ARRAY_TYPE)
8000 error ("%qs declared as function returning an array", name);
8001 type = integer_type_node;
8004 /* Pick up type qualifiers which should be applied to `this'. */
8005 memfn_quals = declarator->u.function.qualifiers;
8007 /* Pick up the exception specifications. */
8008 raises = declarator->u.function.exception_specification;
8010 /* Say it's a definition only for the CALL_EXPR
8011 closest to the identifier. */
8012 funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id;
8014 if (ctype == NULL_TREE
8015 && decl_context == FIELD
8017 && (friendp == 0 || dname == current_class_name))
8018 ctype = current_class_type;
8020 if (ctype && (sfk == sfk_constructor
8021 || sfk == sfk_destructor))
8023 /* We are within a class's scope. If our declarator name
8024 is the same as the class name, and we are defining
8025 a function, then it is a constructor/destructor, and
8026 therefore returns a void type. */
8028 /* ISO C++ 12.4/2. A destructor may not be declared
8029 const or volatile. A destructor may not be
8032 ISO C++ 12.1. A constructor may not be declared
8033 const or volatile. A constructor may not be
8034 virtual. A constructor may not be static. */
8036 error ((flags == DTOR_FLAG)
8037 ? "destructor cannot be static member function"
8038 : "constructor cannot be static member function");
8041 error ((flags == DTOR_FLAG)
8042 ? "destructors may not be cv-qualified"
8043 : "constructors may not be cv-qualified");
8044 memfn_quals = TYPE_UNQUALIFIED;
8047 if (decl_context == FIELD
8048 && !member_function_or_else (ctype,
8051 return error_mark_node;
8053 if (flags != DTOR_FLAG)
8055 /* It's a constructor. */
8060 pedwarn ("constructors cannot be declared virtual");
8063 if (decl_context == FIELD
8064 && sfk != sfk_constructor)
8065 return error_mark_node;
8067 if (decl_context == FIELD)
8073 error ("can't initialize friend function %qs", name);
8076 /* Cannot be both friend and virtual. */
8077 error ("virtual functions cannot be friends");
8080 if (decl_context == NORMAL)
8081 error ("friend declaration not in class definition");
8082 if (current_function_decl && funcdef_flag)
8083 error ("can't define friend function %qs in a local "
8088 arg_types = grokparms (declarator->u.function.parameters,
8091 if (inner_declarator
8092 && inner_declarator->kind == cdk_id
8093 && inner_declarator->u.id.sfk == sfk_destructor
8094 && arg_types != void_list_node)
8096 error ("destructors may not have parameters");
8097 arg_types = void_list_node;
8101 type = build_function_type (type, arg_types);
8108 /* Filter out pointers-to-references and references-to-references.
8109 We can get these if a TYPE_DECL is used. */
8111 if (TREE_CODE (type) == REFERENCE_TYPE)
8113 if (declarator->kind != cdk_reference)
8115 error ("cannot declare pointer to %q#T", type);
8116 type = TREE_TYPE (type);
8119 /* In C++0x, we allow reference to reference declarations
8120 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
8121 and template type arguments [14.3.1/4 temp.arg.type]. The
8122 check for direct reference to reference declarations, which
8123 are still forbidden, occurs below. Reasoning behind the change
8124 can be found in DR106, DR540, and the rvalue reference
8126 else if (cxx_dialect == cxx98)
8128 error ("cannot declare reference to %q#T", type);
8129 type = TREE_TYPE (type);
8132 else if (VOID_TYPE_P (type))
8134 if (declarator->kind == cdk_reference)
8135 error ("cannot declare reference to %q#T", type);
8136 else if (declarator->kind == cdk_ptrmem)
8137 error ("cannot declare pointer to %q#T member", type);
8140 /* We now know that the TYPE_QUALS don't apply to the decl,
8141 but to the target of the pointer. */
8142 type_quals = TYPE_UNQUALIFIED;
8144 if (declarator->kind == cdk_ptrmem
8145 && (TREE_CODE (type) == FUNCTION_TYPE || memfn_quals))
8147 memfn_quals |= cp_type_quals (type);
8148 type = build_memfn_type (type,
8149 declarator->u.pointer.class_type,
8151 memfn_quals = TYPE_UNQUALIFIED;
8154 if (declarator->kind == cdk_reference)
8156 /* In C++0x, the type we are creating a reference to might be
8157 a typedef which is itself a reference type. In that case,
8158 we follow the reference collapsing rules in
8159 [7.1.3/8 dcl.typedef] to create the final reference type:
8161 "If a typedef TD names a type that is a reference to a type
8162 T, an attempt to create the type 'lvalue reference to cv TD'
8163 creates the type 'lvalue reference to T,' while an attempt
8164 to create the type "rvalue reference to cv TD' creates the
8167 if (!VOID_TYPE_P (type))
8168 type = cp_build_reference_type
8169 ((TREE_CODE (type) == REFERENCE_TYPE
8170 ? TREE_TYPE (type) : type),
8171 (declarator->u.reference.rvalue_ref
8172 && (TREE_CODE(type) != REFERENCE_TYPE
8173 || TYPE_REF_IS_RVALUE (type))));
8175 /* In C++0x, we need this check for direct reference to
8176 reference declarations, which are forbidden by
8177 [8.3.2/5 dcl.ref]. Reference to reference declarations
8178 are only allowed indirectly through typedefs and template
8179 type arguments. Example:
8181 void foo(int & &); // invalid ref-to-ref decl
8183 typedef int & int_ref;
8184 void foo(int_ref &); // valid ref-to-ref decl
8186 if (inner_declarator && inner_declarator->kind == cdk_reference)
8187 error ("cannot declare reference to %q#T, which is not "
8188 "a typedef or a template type argument", type);
8190 else if (TREE_CODE (type) == METHOD_TYPE)
8191 type = build_ptrmemfunc_type (build_pointer_type (type));
8192 else if (declarator->kind == cdk_ptrmem)
8194 gcc_assert (TREE_CODE (declarator->u.pointer.class_type)
8196 if (declarator->u.pointer.class_type == error_mark_node)
8197 /* We will already have complained. */
8198 type = error_mark_node;
8200 type = build_ptrmem_type (declarator->u.pointer.class_type,
8204 type = build_pointer_type (type);
8206 /* Process a list of type modifier keywords (such as
8207 const or volatile) that were given inside the `*' or `&'. */
8209 if (declarator->u.pointer.qualifiers)
8212 = cp_build_qualified_type (type,
8213 declarator->u.pointer.qualifiers);
8214 type_quals = cp_type_quals (type);
8227 if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR
8228 && TREE_CODE (type) != FUNCTION_TYPE
8229 && TREE_CODE (type) != METHOD_TYPE)
8231 error ("template-id %qD used as a declarator",
8233 unqualified_id = dname;
8236 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
8237 qualified with a class-name, turn it into a METHOD_TYPE, unless
8238 we know that the function is static. We take advantage of this
8239 opportunity to do other processing that pertains to entities
8240 explicitly declared to be class members. Note that if DECLARATOR
8241 is non-NULL, we know it is a cdk_id declarator; otherwise, we
8242 would not have exited the loop above. */
8244 && declarator->u.id.qualifying_scope
8245 && TYPE_P (declarator->u.id.qualifying_scope))
8249 ctype = declarator->u.id.qualifying_scope;
8250 ctype = TYPE_MAIN_VARIANT (ctype);
8252 while (t != NULL_TREE && CLASS_TYPE_P (t))
8254 /* You're supposed to have one `template <...>' for every
8255 template class, but you don't need one for a full
8256 specialization. For example:
8258 template <class T> struct S{};
8259 template <> struct S<int> { void f(); };
8260 void S<int>::f () {}
8262 is correct; there shouldn't be a `template <>' for the
8263 definition of `S<int>::f'. */
8264 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t)
8265 && !any_dependent_template_arguments_p (CLASSTYPE_TI_ARGS (t)))
8266 /* T is an explicit (not partial) specialization. All
8267 containing classes must therefore also be explicitly
8270 if ((CLASSTYPE_USE_TEMPLATE (t) || CLASSTYPE_IS_TEMPLATE (t))
8271 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
8272 template_count += 1;
8274 t = TYPE_MAIN_DECL (t);
8275 t = DECL_CONTEXT (t);
8278 if (ctype == current_class_type)
8282 pedwarn ("member functions are implicitly friends of their class");
8286 pedwarn ("extra qualification %<%T::%> on member %qs",
8289 else if (/* If the qualifying type is already complete, then we
8290 can skip the following checks. */
8291 !COMPLETE_TYPE_P (ctype)
8292 && (/* If the function is being defined, then
8293 qualifying type must certainly be complete. */
8295 /* A friend declaration of "T::f" is OK, even if
8296 "T" is a template parameter. But, if this
8297 function is not a friend, the qualifying type
8299 || (!friendp && !CLASS_TYPE_P (ctype))
8300 /* For a declaration, the type need not be
8301 complete, if either it is dependent (since there
8302 is no meaningful definition of complete in that
8303 case) or the qualifying class is currently being
8305 || !(dependent_type_p (ctype)
8306 || currently_open_class (ctype)))
8307 /* Check that the qualifying type is complete. */
8308 && !complete_type_or_else (ctype, NULL_TREE))
8309 return error_mark_node;
8310 else if (TREE_CODE (type) == FUNCTION_TYPE)
8312 tree sname = declarator->u.id.unqualified_name;
8314 if (current_class_type
8315 && (!friendp || funcdef_flag))
8318 ? "cannot define member function %<%T::%s%> within %<%T%>"
8319 : "cannot declare member function %<%T::%s%> within %<%T%>",
8320 ctype, name, current_class_type);
8321 return error_mark_node;
8324 if (TREE_CODE (sname) == IDENTIFIER_NODE
8325 && NEW_DELETE_OPNAME_P (sname))
8326 /* Overloaded operator new and operator delete
8327 are always static functions. */
8330 type = build_memfn_type (type, ctype, memfn_quals);
8332 else if (declspecs->specs[(int)ds_typedef]
8333 && current_class_type)
8335 error ("cannot declare member %<%T::%s%> within %qT",
8336 ctype, name, current_class_type);
8337 return error_mark_node;
8341 /* Now TYPE has the actual type. */
8346 *attrlist = chainon (returned_attrs, *attrlist);
8348 attrlist = &returned_attrs;
8351 /* Handle parameter packs. */
8352 if (parameter_pack_p)
8354 if (decl_context == PARM)
8355 /* Turn the type into a pack expansion.*/
8356 type = make_pack_expansion (type);
8358 error ("non-parameter %qs cannot be a parameter pack", name);
8361 /* Did array size calculations overflow? */
8363 if (TREE_CODE (type) == ARRAY_TYPE
8364 && COMPLETE_TYPE_P (type)
8365 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
8366 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
8368 error ("size of array %qs is too large", name);
8369 /* If we proceed with the array type as it is, we'll eventually
8370 crash in tree_low_cst(). */
8371 type = error_mark_node;
8374 if ((decl_context == FIELD || decl_context == PARM)
8375 && !processing_template_decl
8376 && variably_modified_type_p (type, NULL_TREE))
8378 if (decl_context == FIELD)
8379 error ("data member may not have variably modified type %qT", type);
8381 error ("parameter may not have variably modified type %qT", type);
8382 type = error_mark_node;
8385 if (explicitp == 1 || (explicitp && friendp))
8387 /* [dcl.fct.spec] The explicit specifier shall only be used in
8388 declarations of constructors within a class definition. */
8389 error ("only declarations of constructors can be %<explicit%>");
8393 if (storage_class == sc_mutable)
8395 if (decl_context != FIELD || friendp)
8397 error ("non-member %qs cannot be declared %<mutable%>", name);
8398 storage_class = sc_none;
8400 else if (decl_context == TYPENAME || declspecs->specs[(int)ds_typedef])
8402 error ("non-object member %qs cannot be declared %<mutable%>", name);
8403 storage_class = sc_none;
8405 else if (TREE_CODE (type) == FUNCTION_TYPE
8406 || TREE_CODE (type) == METHOD_TYPE)
8408 error ("function %qs cannot be declared %<mutable%>", name);
8409 storage_class = sc_none;
8413 error ("static %qs cannot be declared %<mutable%>", name);
8414 storage_class = sc_none;
8416 else if (type_quals & TYPE_QUAL_CONST)
8418 error ("const %qs cannot be declared %<mutable%>", name);
8419 storage_class = sc_none;
8423 /* If this is declaring a typedef name, return a TYPE_DECL. */
8424 if (declspecs->specs[(int)ds_typedef] && decl_context != TYPENAME)
8428 /* Note that the grammar rejects storage classes
8429 in typenames, fields or parameters. */
8430 if (current_lang_name == lang_name_java)
8431 TYPE_FOR_JAVA (type) = 1;
8433 /* This declaration:
8435 typedef void f(int) const;
8437 declares a function type which is not a member of any
8438 particular class, but which is cv-qualified; for
8439 example "f S::*" declares a pointer to a const-qualified
8440 member function of S. We record the cv-qualification in the
8442 if (memfn_quals && TREE_CODE (type) == FUNCTION_TYPE)
8444 type = cp_build_qualified_type (type, memfn_quals);
8446 /* We have now dealt with these qualifiers. */
8447 memfn_quals = TYPE_UNQUALIFIED;
8450 if (decl_context == FIELD)
8451 decl = build_lang_decl (TYPE_DECL, unqualified_id, type);
8453 decl = build_decl (TYPE_DECL, unqualified_id, type);
8454 if (id_declarator && declarator->u.id.qualifying_scope)
8455 error ("%Jtypedef name may not be a nested-name-specifier", decl);
8457 if (decl_context != FIELD)
8459 if (!current_function_decl)
8460 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8461 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl)
8462 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
8463 (current_function_decl)))
8464 /* The TYPE_DECL is "abstract" because there will be
8465 clones of this constructor/destructor, and there will
8466 be copies of this TYPE_DECL generated in those
8468 DECL_ABSTRACT (decl) = 1;
8470 else if (constructor_name_p (unqualified_id, current_class_type))
8471 pedwarn ("ISO C++ forbids nested type %qD with same name "
8472 "as enclosing class",
8475 /* If the user declares "typedef struct {...} foo" then the
8476 struct will have an anonymous name. Fill that name in now.
8477 Nothing can refer to it, so nothing needs know about the name
8479 if (type != error_mark_node
8482 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
8483 && TYPE_ANONYMOUS_P (type)
8484 /* Don't do this if there are attributes. */
8485 && (!attrlist || !*attrlist)
8486 && cp_type_quals (type) == TYPE_UNQUALIFIED)
8488 tree oldname = TYPE_NAME (type);
8491 /* Replace the anonymous name with the real name everywhere. */
8492 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
8493 if (TYPE_NAME (t) == oldname)
8494 TYPE_NAME (t) = decl;
8496 if (TYPE_LANG_SPECIFIC (type))
8497 TYPE_WAS_ANONYMOUS (type) = 1;
8499 /* If this is a typedef within a template class, the nested
8500 type is a (non-primary) template. The name for the
8501 template needs updating as well. */
8502 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
8503 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
8504 = TYPE_IDENTIFIER (type);
8506 /* FIXME remangle member functions; member functions of a
8507 type with external linkage have external linkage. */
8511 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
8512 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
8514 bad_specifiers (decl, "type", virtualp,
8515 memfn_quals != TYPE_UNQUALIFIED,
8516 inlinep, friendp, raises != NULL_TREE);
8521 /* Detect the case of an array type of unspecified size
8522 which came, as such, direct from a typedef name.
8523 We must copy the type, so that the array's domain can be
8524 individually set by the object's initializer. */
8526 if (type && typedef_type
8527 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
8528 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
8529 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
8531 /* Detect where we're using a typedef of function type to declare a
8532 function. PARMS will not be set, so we must create it now. */
8534 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
8536 tree decls = NULL_TREE;
8539 for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
8541 tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
8543 TREE_CHAIN (decl) = decls;
8547 parms = nreverse (decls);
8549 if (decl_context != TYPENAME)
8551 /* A cv-qualifier-seq shall only be part of the function type
8552 for a non-static member function. [8.3.5/4 dcl.fct] */
8553 if (cp_type_quals (type) != TYPE_UNQUALIFIED
8554 && (current_class_type == NULL_TREE || staticp) )
8557 ? G_("qualified function types cannot be used to "
8558 "declare static member functions")
8559 : G_("qualified function types cannot be used to "
8560 "declare free functions"));
8561 type = TYPE_MAIN_VARIANT (type);
8564 /* The qualifiers on the function type become the qualifiers on
8565 the non-static member function. */
8566 memfn_quals |= cp_type_quals (type);
8570 /* If this is a type name (such as, in a cast or sizeof),
8571 compute the type and return it now. */
8573 if (decl_context == TYPENAME)
8575 /* Note that the grammar rejects storage classes
8576 in typenames, fields or parameters. */
8577 if (type_quals != TYPE_UNQUALIFIED)
8578 type_quals = TYPE_UNQUALIFIED;
8580 /* Special case: "friend class foo" looks like a TYPENAME context. */
8583 if (type_quals != TYPE_UNQUALIFIED)
8585 error ("type qualifiers specified for friend class declaration");
8586 type_quals = TYPE_UNQUALIFIED;
8590 error ("%<inline%> specified for friend class declaration");
8596 /* Don't allow friend declaration without a class-key. */
8597 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
8598 pedwarn ("template parameters cannot be friends");
8599 else if (TREE_CODE (type) == TYPENAME_TYPE)
8600 pedwarn ("friend declaration requires class-key, "
8601 "i.e. %<friend class %T::%D%>",
8602 TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
8604 pedwarn ("friend declaration requires class-key, "
8605 "i.e. %<friend %#T%>",
8609 /* Only try to do this stuff if we didn't already give up. */
8610 if (type != integer_type_node)
8612 /* A friendly class? */
8613 if (current_class_type)
8614 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
8617 error ("trying to make class %qT a friend of global scope",
8620 type = void_type_node;
8623 else if (memfn_quals)
8625 if (ctype == NULL_TREE)
8627 if (TREE_CODE (type) != METHOD_TYPE)
8628 error ("invalid qualifiers on non-member function type");
8630 ctype = TYPE_METHOD_BASETYPE (type);
8633 type = build_memfn_type (type, ctype, memfn_quals);
8638 else if (unqualified_id == NULL_TREE && decl_context != PARM
8639 && decl_context != CATCHPARM
8640 && TREE_CODE (type) != UNION_TYPE
8643 error ("abstract declarator %qT used as declaration", type);
8644 return error_mark_node;
8647 /* Only functions may be declared using an operator-function-id. */
8649 && IDENTIFIER_OPNAME_P (unqualified_id)
8650 && TREE_CODE (type) != FUNCTION_TYPE
8651 && TREE_CODE (type) != METHOD_TYPE)
8653 error ("declaration of %qD as non-function", unqualified_id);
8654 return error_mark_node;
8657 /* We don't check parameter types here because we can emit a better
8658 error message later. */
8659 if (decl_context != PARM)
8661 type = check_var_type (unqualified_id, type);
8662 if (type == error_mark_node)
8663 return error_mark_node;
8666 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
8667 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
8669 if (decl_context == PARM || decl_context == CATCHPARM)
8671 if (ctype || in_namespace)
8672 error ("cannot use %<::%> in parameter declaration");
8674 /* A parameter declared as an array of T is really a pointer to T.
8675 One declared as a function is really a pointer to a function.
8676 One declared as a member is really a pointer to member. */
8678 if (TREE_CODE (type) == ARRAY_TYPE)
8680 /* Transfer const-ness of array into that of type pointed to. */
8681 type = build_pointer_type (TREE_TYPE (type));
8682 type_quals = TYPE_UNQUALIFIED;
8684 else if (TREE_CODE (type) == FUNCTION_TYPE)
8685 type = build_pointer_type (type);
8691 if (decl_context == PARM)
8693 decl = cp_build_parm_decl (unqualified_id, type);
8695 bad_specifiers (decl, "parameter", virtualp,
8696 memfn_quals != TYPE_UNQUALIFIED,
8697 inlinep, friendp, raises != NULL_TREE);
8699 else if (decl_context == FIELD)
8701 /* The C99 flexible array extension. */
8702 if (!staticp && TREE_CODE (type) == ARRAY_TYPE
8703 && TYPE_DOMAIN (type) == NULL_TREE)
8705 tree itype = compute_array_index_type (dname, integer_zero_node);
8706 type = build_cplus_array_type (TREE_TYPE (type), itype);
8709 if (type == error_mark_node)
8711 /* Happens when declaring arrays of sizes which
8712 are error_mark_node, for example. */
8715 else if (in_namespace && !friendp)
8717 /* Something like struct S { int N::j; }; */
8718 error ("invalid use of %<::%>");
8719 return error_mark_node;
8721 else if (TREE_CODE (type) == FUNCTION_TYPE)
8724 tree function_context;
8728 if (ctype == NULL_TREE)
8729 ctype = current_class_type;
8731 if (ctype == NULL_TREE)
8733 error ("can't make %qD into a method -- not in a class",
8735 return error_mark_node;
8738 /* ``A union may [ ... ] not [ have ] virtual functions.''
8740 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
8742 error ("function %qD declared virtual inside a union",
8744 return error_mark_node;
8747 if (NEW_DELETE_OPNAME_P (unqualified_id))
8751 error ("%qD cannot be declared virtual, since it "
8757 else if (staticp < 2)
8758 type = build_memfn_type (type, ctype, memfn_quals);
8761 /* Check that the name used for a destructor makes sense. */
8762 if (sfk == sfk_destructor)
8766 gcc_assert (friendp);
8767 error ("expected qualified name in friend declaration "
8768 "for destructor %qD",
8769 id_declarator->u.id.unqualified_name);
8770 return error_mark_node;
8773 if (!same_type_p (TREE_OPERAND
8774 (id_declarator->u.id.unqualified_name, 0),
8777 error ("declaration of %qD as member of %qT",
8778 id_declarator->u.id.unqualified_name, ctype);
8779 return error_mark_node;
8783 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
8784 function_context = (ctype != NULL_TREE) ?
8785 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
8786 publicp = (! friendp || ! staticp)
8787 && function_context == NULL_TREE;
8788 decl = grokfndecl (ctype, type,
8789 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
8790 ? unqualified_id : dname,
8793 virtualp, flags, memfn_quals, raises,
8794 friendp ? -1 : 0, friendp, publicp, inlinep,
8796 funcdef_flag, template_count, in_namespace, attrlist);
8797 if (decl == NULL_TREE)
8798 return error_mark_node;
8800 /* This clobbers the attrs stored in `decl' from `attrlist'. */
8801 /* The decl and setting of decl_attr is also turned off. */
8802 decl = build_decl_attribute_variant (decl, decl_attr);
8805 /* [class.conv.ctor]
8807 A constructor declared without the function-specifier
8808 explicit that can be called with a single parameter
8809 specifies a conversion from the type of its first
8810 parameter to the type of its class. Such a constructor
8811 is called a converting constructor. */
8813 DECL_NONCONVERTING_P (decl) = 1;
8814 else if (DECL_CONSTRUCTOR_P (decl))
8816 /* The constructor can be called with exactly one
8817 parameter if there is at least one parameter, and
8818 any subsequent parameters have default arguments.
8819 Ignore any compiler-added parms. */
8820 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
8822 if (arg_types == void_list_node
8824 && TREE_CHAIN (arg_types)
8825 && TREE_CHAIN (arg_types) != void_list_node
8826 && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
8827 DECL_NONCONVERTING_P (decl) = 1;
8830 else if (TREE_CODE (type) == METHOD_TYPE)
8832 /* We only get here for friend declarations of
8833 members of other classes. */
8834 /* All method decls are public, so tell grokfndecl to set
8835 TREE_PUBLIC, also. */
8836 decl = grokfndecl (ctype, type,
8837 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
8838 ? unqualified_id : dname,
8841 virtualp, flags, memfn_quals, raises,
8842 friendp ? -1 : 0, friendp, 1, 0, sfk,
8843 funcdef_flag, template_count, in_namespace,
8845 if (decl == NULL_TREE)
8846 return error_mark_node;
8848 else if (!staticp && !dependent_type_p (type)
8849 && !COMPLETE_TYPE_P (complete_type (type))
8850 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
8853 error ("field %qD has incomplete type", unqualified_id);
8855 error ("name %qT has incomplete type", type);
8857 /* If we're instantiating a template, tell them which
8858 instantiation made the field's type be incomplete. */
8859 if (current_class_type
8860 && TYPE_NAME (current_class_type)
8861 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
8863 && declspecs->type == type)
8864 error (" in instantiation of template %qT",
8865 current_class_type);
8867 return error_mark_node;
8873 error ("%qE is neither function nor member function; "
8874 "cannot be declared friend", unqualified_id);
8882 /* Friends are treated specially. */
8883 if (ctype == current_class_type)
8884 ; /* We already issued a pedwarn. */
8885 else if (decl && DECL_NAME (decl))
8887 if (template_class_depth (current_class_type) == 0)
8889 decl = check_explicit_specialization
8890 (unqualified_id, decl, template_count,
8891 2 * funcdef_flag + 4);
8892 if (decl == error_mark_node)
8893 return error_mark_node;
8896 decl = do_friend (ctype, unqualified_id, decl,
8902 return error_mark_node;
8905 /* Structure field. It may not be a function, except for C++. */
8907 if (decl == NULL_TREE)
8913 /* An attempt is being made to initialize a non-static
8914 member. But, from [class.mem]:
8916 4 A member-declarator can contain a
8917 constant-initializer only if it declares a static
8918 member (_class.static_) of integral or enumeration
8919 type, see _class.static.data_.
8921 This used to be relatively common practice, but
8922 the rest of the compiler does not correctly
8923 handle the initialization unless the member is
8924 static so we make it static below. */
8925 pedwarn ("ISO C++ forbids initialization of member %qD",
8927 pedwarn ("making %qD static", unqualified_id);
8931 if (uses_template_parms (type))
8932 /* We'll check at instantiation time. */
8934 else if (check_static_variable_definition (unqualified_id,
8936 /* If we just return the declaration, crashes
8937 will sometimes occur. We therefore return
8938 void_type_node, as if this was a friend
8939 declaration, to cause callers to completely
8940 ignore this declaration. */
8941 return error_mark_node;
8946 /* C++ allows static class members. All other work
8947 for this is done by grokfield. */
8948 decl = build_lang_decl (VAR_DECL, unqualified_id, type);
8949 set_linkage_for_static_data_member (decl);
8950 /* Even if there is an in-class initialization, DECL
8951 is considered undefined until an out-of-class
8952 definition is provided. */
8953 DECL_EXTERNAL (decl) = 1;
8956 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
8960 decl = build_decl (FIELD_DECL, unqualified_id, type);
8961 DECL_NONADDRESSABLE_P (decl) = bitfield;
8962 if (bitfield && !unqualified_id)
8963 TREE_NO_WARNING (decl) = 1;
8965 if (storage_class == sc_mutable)
8967 DECL_MUTABLE_P (decl) = 1;
8968 storage_class = sc_none;
8972 bad_specifiers (decl, "field", virtualp,
8973 memfn_quals != TYPE_UNQUALIFIED,
8974 inlinep, friendp, raises != NULL_TREE);
8977 else if (TREE_CODE (type) == FUNCTION_TYPE
8978 || TREE_CODE (type) == METHOD_TYPE)
8983 if (!unqualified_id)
8984 return error_mark_node;
8986 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
8987 original_name = dname;
8989 original_name = unqualified_id;
8991 if (storage_class == sc_auto)
8992 error ("storage class %<auto%> invalid for function %qs", name);
8993 else if (storage_class == sc_register)
8994 error ("storage class %<register%> invalid for function %qs", name);
8996 error ("storage class %<__thread%> invalid for function %qs", name);
8998 /* Function declaration not at top level.
8999 Storage classes other than `extern' are not allowed
9000 and `extern' makes no difference. */
9001 if (! toplevel_bindings_p ()
9002 && (storage_class == sc_static
9003 || declspecs->specs[(int)ds_inline])
9006 if (storage_class == sc_static)
9007 pedwarn ("%<static%> specified invalid for function %qs "
9008 "declared out of global scope", name);
9010 pedwarn ("%<inline%> specifier invalid for function %qs "
9011 "declared out of global scope", name);
9014 if (ctype == NULL_TREE)
9018 error ("virtual non-class function %qs", name);
9022 else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2
9023 && !NEW_DELETE_OPNAME_P (original_name))
9024 type = build_method_type_directly (ctype,
9026 TYPE_ARG_TYPES (type));
9028 /* Record presence of `static'. */
9029 publicp = (ctype != NULL_TREE
9030 || storage_class == sc_extern
9031 || storage_class != sc_static);
9033 decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
9034 virtualp, flags, memfn_quals, raises,
9036 publicp, inlinep, sfk, funcdef_flag,
9037 template_count, in_namespace, attrlist);
9038 if (decl == NULL_TREE)
9039 return error_mark_node;
9043 int invalid_static = 0;
9045 /* Don't allow a static member function in a class, and forbid
9046 declaring main to be static. */
9047 if (TREE_CODE (type) == METHOD_TYPE)
9049 pedwarn ("cannot declare member function %qD to have "
9050 "static linkage", decl);
9053 else if (current_function_decl)
9055 /* FIXME need arm citation */
9056 error ("cannot declare static function inside another function");
9063 storage_class = sc_none;
9069 /* It's a variable. */
9071 /* An uninitialized decl with `extern' is a reference. */
9072 decl = grokvardecl (type, unqualified_id,
9075 (type_quals & TYPE_QUAL_CONST) != 0,
9076 ctype ? ctype : in_namespace);
9077 bad_specifiers (decl, "variable", virtualp,
9078 memfn_quals != TYPE_UNQUALIFIED,
9079 inlinep, friendp, raises != NULL_TREE);
9083 DECL_CONTEXT (decl) = ctype;
9086 pedwarn ("%<static%> may not be used when defining "
9087 "(as opposed to declaring) a static data member");
9089 storage_class = sc_none;
9091 if (storage_class == sc_register && TREE_STATIC (decl))
9093 error ("static member %qD declared %<register%>", decl);
9094 storage_class = sc_none;
9096 if (storage_class == sc_extern && pedantic)
9098 pedwarn ("cannot explicitly declare member %q#D to have "
9101 storage_class = sc_none;
9106 /* Record `register' declaration for warnings on &
9107 and in case doing stupid register allocation. */
9109 if (storage_class == sc_register)
9110 DECL_REGISTER (decl) = 1;
9111 else if (storage_class == sc_extern)
9112 DECL_THIS_EXTERN (decl) = 1;
9113 else if (storage_class == sc_static)
9114 DECL_THIS_STATIC (decl) = 1;
9116 /* Record constancy and volatility. There's no need to do this
9117 when processing a template; we'll do this for the instantiated
9118 declaration based on the type of DECL. */
9119 if (!processing_template_decl)
9120 cp_apply_type_quals_to_decl (type_quals, decl);
9123 TREE_NO_WARNING (decl) = 1;
9129 /* Subroutine of start_function. Ensure that each of the parameter
9130 types (as listed in PARMS) is complete, as is required for a
9131 function definition. */
9134 require_complete_types_for_parms (tree parms)
9136 for (; parms; parms = TREE_CHAIN (parms))
9138 if (dependent_type_p (TREE_TYPE (parms)))
9140 if (!VOID_TYPE_P (TREE_TYPE (parms))
9141 && complete_type_or_else (TREE_TYPE (parms), parms))
9143 relayout_decl (parms);
9144 DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
9147 /* grokparms or complete_type_or_else will have already issued
9149 TREE_TYPE (parms) = error_mark_node;
9153 /* Returns nonzero if T is a local variable. */
9156 local_variable_p (const_tree t)
9158 if ((TREE_CODE (t) == VAR_DECL
9159 /* A VAR_DECL with a context that is a _TYPE is a static data
9161 && !TYPE_P (CP_DECL_CONTEXT (t))
9162 /* Any other non-local variable must be at namespace scope. */
9163 && !DECL_NAMESPACE_SCOPE_P (t))
9164 || (TREE_CODE (t) == PARM_DECL))
9170 /* Like local_variable_p, but suitable for use as a tree-walking
9174 local_variable_p_walkfn (tree *tp, int *walk_subtrees,
9175 void *data ATTRIBUTE_UNUSED)
9177 if (local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
9179 else if (TYPE_P (*tp))
9186 /* Check that ARG, which is a default-argument expression for a
9187 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
9188 something goes wrong. DECL may also be a _TYPE node, rather than a
9189 DECL, if there is no DECL available. */
9192 check_default_argument (tree decl, tree arg)
9197 if (TREE_CODE (arg) == DEFAULT_ARG)
9198 /* We get a DEFAULT_ARG when looking at an in-class declaration
9199 with a default argument. Ignore the argument for now; we'll
9200 deal with it after the class is complete. */
9209 decl_type = TREE_TYPE (decl);
9211 if (arg == error_mark_node
9212 || decl == error_mark_node
9213 || TREE_TYPE (arg) == error_mark_node
9214 || decl_type == error_mark_node)
9215 /* Something already went wrong. There's no need to check
9217 return error_mark_node;
9219 /* [dcl.fct.default]
9221 A default argument expression is implicitly converted to the
9223 if (!TREE_TYPE (arg)
9224 || !can_convert_arg (decl_type, TREE_TYPE (arg), arg, LOOKUP_NORMAL))
9227 error ("default argument for %q#D has type %qT",
9228 decl, TREE_TYPE (arg));
9230 error ("default argument for parameter of type %qT has type %qT",
9231 decl_type, TREE_TYPE (arg));
9233 return error_mark_node;
9236 /* [dcl.fct.default]
9238 Local variables shall not be used in default argument
9241 The keyword `this' shall not be used in a default argument of a
9243 var = cp_walk_tree_without_duplicates (&arg, local_variable_p_walkfn, NULL);
9246 error ("default argument %qE uses local variable %qD", arg, var);
9247 return error_mark_node;
9254 /* Decode the list of parameter types for a function type.
9255 Given the list of things declared inside the parens,
9256 return a list of types.
9258 If this parameter does not end with an ellipsis, we append
9261 *PARMS is set to the chain of PARM_DECLs created. */
9264 grokparms (cp_parameter_declarator *first_parm, tree *parms)
9266 tree result = NULL_TREE;
9267 tree decls = NULL_TREE;
9268 int ellipsis = !first_parm || first_parm->ellipsis_p;
9269 cp_parameter_declarator *parm;
9271 struct pointer_set_t *unique_decls = pointer_set_create ();
9273 for (parm = first_parm; parm != NULL; parm = parm->next)
9275 tree type = NULL_TREE;
9276 tree init = parm->default_argument;
9280 if (parm == no_parameters)
9283 attrs = parm->decl_specifiers.attributes;
9284 parm->decl_specifiers.attributes = NULL_TREE;
9285 decl = grokdeclarator (parm->declarator, &parm->decl_specifiers,
9286 PARM, init != NULL_TREE, &attrs);
9287 if (! decl || TREE_TYPE (decl) == error_mark_node)
9291 cplus_decl_attributes (&decl, attrs, 0);
9293 type = TREE_TYPE (decl);
9294 if (VOID_TYPE_P (type))
9296 if (same_type_p (type, void_type_node)
9297 && DECL_SELF_REFERENCE_P (type)
9298 && !DECL_NAME (decl) && !result && !parm->next && !ellipsis)
9299 /* this is a parmlist of `(void)', which is ok. */
9301 cxx_incomplete_type_error (decl, type);
9302 /* It's not a good idea to actually create parameters of
9303 type `void'; other parts of the compiler assume that a
9304 void type terminates the parameter list. */
9305 type = error_mark_node;
9306 TREE_TYPE (decl) = error_mark_node;
9309 if (type != error_mark_node)
9311 /* Top-level qualifiers on the parameters are
9312 ignored for function types. */
9313 type = cp_build_qualified_type (type, 0);
9314 if (TREE_CODE (type) == METHOD_TYPE)
9316 error ("parameter %qD invalidly declared method type", decl);
9317 type = build_pointer_type (type);
9318 TREE_TYPE (decl) = type;
9320 else if (abstract_virtuals_error (decl, type))
9321 any_error = 1; /* Seems like a good idea. */
9322 else if (POINTER_TYPE_P (type))
9324 /* [dcl.fct]/6, parameter types cannot contain pointers
9325 (references) to arrays of unknown bound. */
9326 tree t = TREE_TYPE (type);
9327 int ptr = TYPE_PTR_P (type);
9333 else if (TREE_CODE (t) != ARRAY_TYPE)
9335 else if (!TYPE_DOMAIN (t))
9339 if (TREE_CODE (t) == ARRAY_TYPE)
9340 error ("parameter %qD includes %s to array of unknown "
9342 decl, ptr ? "pointer" : "reference", t);
9347 else if (init && !processing_template_decl)
9348 init = check_default_argument (decl, init);
9351 if (TREE_CODE (decl) == PARM_DECL
9352 && FUNCTION_PARAMETER_PACK_P (decl)
9354 error ("parameter packs must be at the end of the parameter list");
9356 if (DECL_NAME (decl))
9358 if (pointer_set_contains (unique_decls, DECL_NAME (decl)))
9359 error ("multiple parameters named %qE", DECL_NAME (decl));
9361 pointer_set_insert (unique_decls, DECL_NAME (decl));
9364 TREE_CHAIN (decl) = decls;
9366 result = tree_cons (init, type, result);
9368 decls = nreverse (decls);
9369 result = nreverse (result);
9371 result = chainon (result, void_list_node);
9374 pointer_set_destroy (unique_decls);
9379 /* D is a constructor or overloaded `operator='.
9381 Let T be the class in which D is declared. Then, this function
9384 -1 if D's is an ill-formed constructor or copy assignment operator
9385 whose first parameter is of type `T'.
9386 0 if D is not a copy constructor or copy assignment
9388 1 if D is a copy constructor or copy assignment operator whose
9389 first parameter is a reference to const qualified T.
9390 2 if D is a copy constructor or copy assignment operator whose
9391 first parameter is a reference to non-const qualified T.
9393 This function can be used as a predicate. Positive values indicate
9394 a copy constructor and nonzero values indicate a copy assignment
9398 copy_fn_p (const_tree d)
9404 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
9406 if (TREE_CODE (d) == TEMPLATE_DECL
9407 || (DECL_TEMPLATE_INFO (d)
9408 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
9409 /* Instantiations of template member functions are never copy
9410 functions. Note that member functions of templated classes are
9411 represented as template functions internally, and we must
9412 accept those as copy functions. */
9415 args = FUNCTION_FIRST_USER_PARMTYPE (d);
9419 arg_type = TREE_VALUE (args);
9420 if (arg_type == error_mark_node)
9423 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
9425 /* Pass by value copy assignment operator. */
9428 else if (TREE_CODE (arg_type) == REFERENCE_TYPE
9429 && !TYPE_REF_IS_RVALUE (arg_type)
9430 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
9432 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
9438 args = TREE_CHAIN (args);
9440 if (args && args != void_list_node && !TREE_PURPOSE (args))
9441 /* There are more non-optional args. */
9447 /* D is a constructor or overloaded `operator='.
9449 Let T be the class in which D is declared. Then, this function
9450 returns true when D is a move constructor or move assignment
9451 operator, false otherwise. */
9454 move_fn_p (const_tree d)
9458 bool result = false;
9460 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
9462 if (cxx_dialect == cxx98)
9463 /* There are no move constructors if we are in C++98 mode. */
9466 if (TREE_CODE (d) == TEMPLATE_DECL
9467 || (DECL_TEMPLATE_INFO (d)
9468 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
9469 /* Instantiations of template member functions are never copy
9470 functions. Note that member functions of templated classes are
9471 represented as template functions internally, and we must
9472 accept those as copy functions. */
9475 args = FUNCTION_FIRST_USER_PARMTYPE (d);
9479 arg_type = TREE_VALUE (args);
9480 if (arg_type == error_mark_node)
9483 if (TREE_CODE (arg_type) == REFERENCE_TYPE
9484 && TYPE_REF_IS_RVALUE (arg_type)
9485 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)),
9489 args = TREE_CHAIN (args);
9491 if (args && args != void_list_node && !TREE_PURPOSE (args))
9492 /* There are more non-optional args. */
9498 /* Remember any special properties of member function DECL. */
9500 void grok_special_member_properties (tree decl)
9504 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
9507 class_type = DECL_CONTEXT (decl);
9508 if (DECL_CONSTRUCTOR_P (decl))
9510 int ctor = copy_fn_p (decl);
9512 TYPE_HAS_CONSTRUCTOR (class_type) = 1;
9518 A non-template constructor for class X is a copy
9519 constructor if its first parameter is of type X&, const
9520 X&, volatile X& or const volatile X&, and either there
9521 are no other parameters or else all other parameters have
9522 default arguments. */
9523 TYPE_HAS_INIT_REF (class_type) = 1;
9525 TYPE_HAS_CONST_INIT_REF (class_type) = 1;
9527 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
9528 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type) = 1;
9530 else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
9534 A non-template assignment operator for class X is a copy
9535 assignment operator if its parameter is of type X, X&, const
9536 X&, volatile X& or const volatile X&. */
9538 int assop = copy_fn_p (decl);
9542 TYPE_HAS_ASSIGN_REF (class_type) = 1;
9544 TYPE_HAS_CONST_ASSIGN_REF (class_type) = 1;
9549 /* Check a constructor DECL has the correct form. Complains
9550 if the class has a constructor of the form X(X). */
9553 grok_ctor_properties (const_tree ctype, const_tree decl)
9555 int ctor_parm = copy_fn_p (decl);
9561 A declaration of a constructor for a class X is ill-formed if
9562 its first parameter is of type (optionally cv-qualified) X
9563 and either there are no other parameters or else all other
9564 parameters have default arguments.
9566 We *don't* complain about member template instantiations that
9567 have this form, though; they can occur as we try to decide
9568 what constructor to use during overload resolution. Since
9569 overload resolution will never prefer such a constructor to
9570 the non-template copy constructor (which is either explicitly
9571 or implicitly defined), there's no need to worry about their
9572 existence. Theoretically, they should never even be
9573 instantiated, but that's hard to forestall. */
9574 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
9582 /* An operator with this code is unary, but can also be binary. */
9585 ambi_op_p (enum tree_code code)
9587 return (code == INDIRECT_REF
9588 || code == ADDR_EXPR
9589 || code == UNARY_PLUS_EXPR
9590 || code == NEGATE_EXPR
9591 || code == PREINCREMENT_EXPR
9592 || code == PREDECREMENT_EXPR);
9595 /* An operator with this name can only be unary. */
9598 unary_op_p (enum tree_code code)
9600 return (code == TRUTH_NOT_EXPR
9601 || code == BIT_NOT_EXPR
9602 || code == COMPONENT_REF
9603 || code == TYPE_EXPR);
9606 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
9607 errors are issued for invalid declarations. */
9610 grok_op_properties (tree decl, bool complain)
9612 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
9614 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
9615 tree name = DECL_NAME (decl);
9616 enum tree_code operator_code;
9621 /* Count the number of arguments and check for ellipsis. */
9622 for (argtype = argtypes, arity = 0;
9623 argtype && argtype != void_list_node;
9624 argtype = TREE_CHAIN (argtype))
9626 ellipsis_p = !argtype;
9628 class_type = DECL_CONTEXT (decl);
9629 if (class_type && !CLASS_TYPE_P (class_type))
9630 class_type = NULL_TREE;
9632 if (DECL_CONV_FN_P (decl))
9633 operator_code = TYPE_EXPR;
9637 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
9638 if (ansi_opname (CODE) == name) \
9640 operator_code = (CODE); \
9643 else if (ansi_assopname (CODE) == name) \
9645 operator_code = (CODE); \
9646 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
9650 #include "operators.def"
9656 gcc_assert (operator_code != LAST_CPLUS_TREE_CODE);
9657 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
9660 switch (operator_code)
9663 TYPE_HAS_NEW_OPERATOR (class_type) = 1;
9667 TYPE_GETS_DELETE (class_type) |= 1;
9671 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type) = 1;
9674 case VEC_DELETE_EXPR:
9675 TYPE_GETS_DELETE (class_type) |= 2;
9682 /* [basic.std.dynamic.allocation]/1:
9684 A program is ill-formed if an allocation function is declared
9685 in a namespace scope other than global scope or declared static
9688 The same also holds true for deallocation functions. */
9689 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR
9690 || operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
9692 if (DECL_NAMESPACE_SCOPE_P (decl))
9694 if (CP_DECL_CONTEXT (decl) != global_namespace)
9696 error ("%qD may not be declared within a namespace", decl);
9699 else if (!TREE_PUBLIC (decl))
9701 error ("%qD may not be declared as static", decl);
9707 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
9708 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
9709 else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
9710 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
9713 /* An operator function must either be a non-static member function
9714 or have at least one parameter of a class, a reference to a class,
9715 an enumeration, or a reference to an enumeration. 13.4.0.6 */
9716 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
9718 if (operator_code == TYPE_EXPR
9719 || operator_code == CALL_EXPR
9720 || operator_code == COMPONENT_REF
9721 || operator_code == ARRAY_REF
9722 || operator_code == NOP_EXPR)
9724 error ("%qD must be a nonstatic member function", decl);
9731 if (DECL_STATIC_FUNCTION_P (decl))
9733 error ("%qD must be either a non-static member "
9734 "function or a non-member function", decl);
9738 for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
9740 tree arg = non_reference (TREE_VALUE (p));
9741 if (arg == error_mark_node)
9744 /* IS_AGGR_TYPE, rather than CLASS_TYPE_P, is used
9745 because these checks are performed even on
9746 template functions. */
9747 if (IS_AGGR_TYPE (arg) || TREE_CODE (arg) == ENUMERAL_TYPE)
9751 if (!p || p == void_list_node)
9754 error ("%qD must have an argument of class or "
9755 "enumerated type", decl);
9761 /* There are no restrictions on the arguments to an overloaded
9763 if (operator_code == CALL_EXPR)
9766 /* Warn about conversion operators that will never be used. */
9767 if (IDENTIFIER_TYPENAME_P (name)
9768 && ! DECL_TEMPLATE_INFO (decl)
9770 /* Warn only declaring the function; there is no need to
9771 warn again about out-of-class definitions. */
9772 && class_type == current_class_type)
9774 tree t = TREE_TYPE (name);
9775 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
9776 const char *what = 0;
9779 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
9781 if (TREE_CODE (t) == VOID_TYPE)
9783 else if (class_type)
9785 if (t == class_type)
9786 what = "the same type";
9787 /* Don't force t to be complete here. */
9788 else if (IS_AGGR_TYPE (t)
9789 && COMPLETE_TYPE_P (t)
9790 && DERIVED_FROM_P (t, class_type))
9791 what = "a base class";
9795 warning (OPT_Wconversion, "conversion to %s%s will never use a type "
9796 "conversion operator",
9797 ref ? "a reference to " : "", what);
9800 if (operator_code == COND_EXPR)
9803 error ("ISO C++ prohibits overloading operator ?:");
9806 else if (ellipsis_p)
9808 error ("%qD must not have variable number of arguments", decl);
9811 else if (ambi_op_p (operator_code))
9814 /* We pick the one-argument operator codes by default, so
9815 we don't have to change anything. */
9817 else if (arity == 2)
9819 /* If we thought this was a unary operator, we now know
9820 it to be a binary operator. */
9821 switch (operator_code)
9824 operator_code = MULT_EXPR;
9828 operator_code = BIT_AND_EXPR;
9831 case UNARY_PLUS_EXPR:
9832 operator_code = PLUS_EXPR;
9836 operator_code = MINUS_EXPR;
9839 case PREINCREMENT_EXPR:
9840 operator_code = POSTINCREMENT_EXPR;
9843 case PREDECREMENT_EXPR:
9844 operator_code = POSTDECREMENT_EXPR;
9851 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
9853 if ((operator_code == POSTINCREMENT_EXPR
9854 || operator_code == POSTDECREMENT_EXPR)
9855 && ! processing_template_decl
9856 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
9859 error ("postfix %qD must take %<int%> as its argument",
9862 error ("postfix %qD must take %<int%> as its second "
9870 error ("%qD must take either zero or one argument", decl);
9872 error ("%qD must take either one or two arguments", decl);
9876 /* More Effective C++ rule 6. */
9878 && (operator_code == POSTINCREMENT_EXPR
9879 || operator_code == POSTDECREMENT_EXPR
9880 || operator_code == PREINCREMENT_EXPR
9881 || operator_code == PREDECREMENT_EXPR))
9883 tree arg = TREE_VALUE (argtypes);
9884 tree ret = TREE_TYPE (TREE_TYPE (decl));
9885 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
9886 arg = TREE_TYPE (arg);
9887 arg = TYPE_MAIN_VARIANT (arg);
9888 if (operator_code == PREINCREMENT_EXPR
9889 || operator_code == PREDECREMENT_EXPR)
9891 if (TREE_CODE (ret) != REFERENCE_TYPE
9892 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
9894 warning (OPT_Weffc__, "prefix %qD should return %qT", decl,
9895 build_reference_type (arg));
9899 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
9900 warning (OPT_Weffc__, "postfix %qD should return %qT", decl, arg);
9904 else if (unary_op_p (operator_code))
9909 error ("%qD must take %<void%>", decl);
9911 error ("%qD must take exactly one argument", decl);
9915 else /* if (binary_op_p (operator_code)) */
9920 error ("%qD must take exactly one argument", decl);
9922 error ("%qD must take exactly two arguments", decl);
9926 /* More Effective C++ rule 7. */
9928 && (operator_code == TRUTH_ANDIF_EXPR
9929 || operator_code == TRUTH_ORIF_EXPR
9930 || operator_code == COMPOUND_EXPR))
9931 warning (OPT_Weffc__, "user-defined %qD always evaluates both arguments",
9935 /* Effective C++ rule 23. */
9938 && !DECL_ASSIGNMENT_OPERATOR_P (decl)
9939 && (operator_code == PLUS_EXPR
9940 || operator_code == MINUS_EXPR
9941 || operator_code == TRUNC_DIV_EXPR
9942 || operator_code == MULT_EXPR
9943 || operator_code == TRUNC_MOD_EXPR)
9944 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
9945 warning (OPT_Weffc__, "%qD should return by value", decl);
9948 for (; argtypes && argtypes != void_list_node;
9949 argtypes = TREE_CHAIN (argtypes))
9950 if (TREE_PURPOSE (argtypes))
9952 TREE_PURPOSE (argtypes) = NULL_TREE;
9953 if (operator_code == POSTINCREMENT_EXPR
9954 || operator_code == POSTDECREMENT_EXPR)
9957 pedwarn ("%qD cannot have default arguments", decl);
9961 error ("%qD cannot have default arguments", decl);
9969 /* Return a string giving the keyword associate with CODE. */
9972 tag_name (enum tag_types code)
9991 /* Name lookup in an elaborated-type-specifier (after the keyword
9992 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
9993 elaborated-type-specifier is invalid, issue a diagnostic and return
9994 error_mark_node; otherwise, return the *_TYPE to which it referred.
9995 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
9998 check_elaborated_type_specifier (enum tag_types tag_code,
10000 bool allow_template_p)
10006 struct S { struct S *p; };
10008 name lookup will find the TYPE_DECL for the implicit "S::S"
10009 typedef. Adjust for that here. */
10010 if (DECL_SELF_REFERENCE_P (decl))
10011 decl = TYPE_NAME (TREE_TYPE (decl));
10013 type = TREE_TYPE (decl);
10015 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
10016 is false for this case as well. */
10017 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
10019 error ("using template type parameter %qT after %qs",
10020 type, tag_name (tag_code));
10021 return error_mark_node;
10025 If the identifier resolves to a typedef-name or a template
10026 type-parameter, the elaborated-type-specifier is ill-formed.
10028 In other words, the only legitimate declaration to use in the
10029 elaborated type specifier is the implicit typedef created when
10030 the type is declared. */
10031 else if (!DECL_IMPLICIT_TYPEDEF_P (decl)
10032 && tag_code != typename_type)
10034 error ("using typedef-name %qD after %qs", decl, tag_name (tag_code));
10035 error ("%q+D has a previous declaration here", decl);
10036 return error_mark_node;
10038 else if (TREE_CODE (type) != RECORD_TYPE
10039 && TREE_CODE (type) != UNION_TYPE
10040 && tag_code != enum_type
10041 && tag_code != typename_type)
10043 error ("%qT referred to as %qs", type, tag_name (tag_code));
10044 error ("%q+T has a previous declaration here", type);
10045 return error_mark_node;
10047 else if (TREE_CODE (type) != ENUMERAL_TYPE
10048 && tag_code == enum_type)
10050 error ("%qT referred to as enum", type);
10051 error ("%q+T has a previous declaration here", type);
10052 return error_mark_node;
10054 else if (!allow_template_p
10055 && TREE_CODE (type) == RECORD_TYPE
10056 && CLASSTYPE_IS_TEMPLATE (type))
10058 /* If a class template appears as elaborated type specifier
10059 without a template header such as:
10061 template <class T> class C {};
10062 void f(class C); // No template header here
10064 then the required template argument is missing. */
10065 error ("template argument required for %<%s %T%>",
10066 tag_name (tag_code),
10067 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
10068 return error_mark_node;
10074 /* Lookup NAME in elaborate type specifier in scope according to
10075 SCOPE and issue diagnostics if necessary.
10076 Return *_TYPE node upon success, NULL_TREE when the NAME is not
10077 found, and ERROR_MARK_NODE for type error. */
10080 lookup_and_check_tag (enum tag_types tag_code, tree name,
10081 tag_scope scope, bool template_header_p)
10085 if (scope == ts_global)
10087 /* First try ordinary name lookup, ignoring hidden class name
10088 injected via friend declaration. */
10089 decl = lookup_name_prefer_type (name, 2);
10090 /* If that fails, the name will be placed in the smallest
10091 non-class, non-function-prototype scope according to 3.3.1/5.
10092 We may already have a hidden name declared as friend in this
10093 scope. So lookup again but not ignoring hidden names.
10094 If we find one, that name will be made visible rather than
10095 creating a new tag. */
10097 decl = lookup_type_scope (name, ts_within_enclosing_non_class);
10100 decl = lookup_type_scope (name, scope);
10102 if (decl && DECL_CLASS_TEMPLATE_P (decl))
10103 decl = DECL_TEMPLATE_RESULT (decl);
10105 if (decl && TREE_CODE (decl) == TYPE_DECL)
10107 /* Look for invalid nested type:
10111 if (scope == ts_current && DECL_SELF_REFERENCE_P (decl))
10113 error ("%qD has the same name as the class in which it is "
10116 return error_mark_node;
10119 /* Two cases we need to consider when deciding if a class
10120 template is allowed as an elaborated type specifier:
10121 1. It is a self reference to its own class.
10122 2. It comes with a template header.
10126 template <class T> class C {
10127 class C *c1; // DECL_SELF_REFERENCE_P is true
10130 template <class U> class C; // template_header_p is true
10131 template <class T> class C<T>::D {
10132 class C *c2; // DECL_SELF_REFERENCE_P is true
10135 t = check_elaborated_type_specifier (tag_code,
10138 | DECL_SELF_REFERENCE_P (decl));
10141 else if (decl && TREE_CODE (decl) == TREE_LIST)
10143 error ("reference to %qD is ambiguous", name);
10144 print_candidates (decl);
10145 return error_mark_node;
10151 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
10152 Define the tag as a forward-reference if it is not defined.
10154 If a declaration is given, process it here, and report an error if
10155 multiple declarations are not identical.
10157 SCOPE is TS_CURRENT when this is also a definition. Only look in
10158 the current frame for the name (since C++ allows new names in any
10159 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
10160 declaration. Only look beginning from the current scope outward up
10161 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
10163 TEMPLATE_HEADER_P is true when this declaration is preceded by
10164 a set of template parameters. */
10167 xref_tag (enum tag_types tag_code, tree name,
10168 tag_scope scope, bool template_header_p)
10170 enum tree_code code;
10172 tree context = NULL_TREE;
10174 timevar_push (TV_NAME_LOOKUP);
10176 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
10182 code = RECORD_TYPE;
10188 code = ENUMERAL_TYPE;
10191 gcc_unreachable ();
10194 /* In case of anonymous name, xref_tag is only called to
10195 make type node and push name. Name lookup is not required. */
10196 if (ANON_AGGRNAME_P (name))
10199 t = lookup_and_check_tag (tag_code, name,
10200 scope, template_header_p);
10202 if (t == error_mark_node)
10203 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10205 if (scope != ts_current && t && current_class_type
10206 && template_class_depth (current_class_type)
10207 && template_header_p)
10209 /* Since SCOPE is not TS_CURRENT, we are not looking at a
10210 definition of this tag. Since, in addition, we are currently
10211 processing a (member) template declaration of a template
10212 class, we must be very careful; consider:
10219 { template <class V>
10220 friend struct S1; };
10222 Here, the S2::S1 declaration should not be confused with the
10223 outer declaration. In particular, the inner version should
10224 have a template parameter of level 2, not level 1. This
10225 would be particularly important if the member declaration
10228 template <class V = U> friend struct S1;
10230 say, when we should tsubst into `U' when instantiating
10231 S2. On the other hand, when presented with:
10241 we must find the inner binding eventually. We
10242 accomplish this by making sure that the new type we
10243 create to represent this declaration has the right
10245 context = TYPE_CONTEXT (t);
10251 /* If no such tag is yet defined, create a forward-reference node
10252 and record it as the "definition".
10253 When a real declaration of this type is found,
10254 the forward-reference will be altered into a real type. */
10255 if (code == ENUMERAL_TYPE)
10257 error ("use of enum %q#D without previous declaration", name);
10258 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10262 t = make_aggr_type (code);
10263 TYPE_CONTEXT (t) = context;
10264 t = pushtag (name, t, scope);
10269 if (template_header_p && IS_AGGR_TYPE (t))
10271 if (!redeclare_class_template (t, current_template_parms))
10272 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10274 else if (!processing_template_decl
10275 && CLASS_TYPE_P (t)
10276 && CLASSTYPE_IS_TEMPLATE (t))
10278 error ("redeclaration of %qT as a non-template", t);
10279 error ("previous declaration %q+D", t);
10280 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10283 /* Make injected friend class visible. */
10284 if (scope != ts_within_enclosing_non_class
10285 && hidden_name_p (TYPE_NAME (t)))
10287 DECL_ANTICIPATED (TYPE_NAME (t)) = 0;
10288 DECL_FRIEND_P (TYPE_NAME (t)) = 0;
10290 if (TYPE_TEMPLATE_INFO (t))
10292 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t)) = 0;
10293 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t)) = 0;
10298 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
10302 xref_tag_from_type (tree old, tree id, tag_scope scope)
10304 enum tag_types tag_kind;
10306 if (TREE_CODE (old) == RECORD_TYPE)
10307 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
10309 tag_kind = union_type;
10311 if (id == NULL_TREE)
10312 id = TYPE_IDENTIFIER (old);
10314 return xref_tag (tag_kind, id, scope, false);
10317 /* Create the binfo hierarchy for REF with (possibly NULL) base list
10318 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
10319 access_* node, and the TREE_VALUE is the type of the base-class.
10320 Non-NULL TREE_TYPE indicates virtual inheritance.
10322 Returns true if the binfo hierarchy was successfully created,
10323 false if an error was detected. */
10326 xref_basetypes (tree ref, tree base_list)
10329 tree binfo, base_binfo;
10330 unsigned max_vbases = 0; /* Maximum direct & indirect virtual bases. */
10331 unsigned max_bases = 0; /* Maximum direct bases. */
10333 tree default_access;
10334 tree igo_prev; /* Track Inheritance Graph Order. */
10336 if (ref == error_mark_node)
10339 /* The base of a derived class is private by default, all others are
10341 default_access = (TREE_CODE (ref) == RECORD_TYPE
10342 && CLASSTYPE_DECLARED_CLASS (ref)
10343 ? access_private_node : access_public_node);
10345 /* First, make sure that any templates in base-classes are
10346 instantiated. This ensures that if we call ourselves recursively
10347 we do not get confused about which classes are marked and which
10349 basep = &base_list;
10352 tree basetype = TREE_VALUE (*basep);
10354 if (!(processing_template_decl && uses_template_parms (basetype))
10355 && !complete_type_or_else (basetype, NULL))
10356 /* An incomplete type. Remove it from the list. */
10357 *basep = TREE_CHAIN (*basep);
10361 if (TREE_TYPE (*basep))
10363 if (CLASS_TYPE_P (basetype))
10364 max_vbases += VEC_length (tree, CLASSTYPE_VBASECLASSES (basetype));
10365 basep = &TREE_CHAIN (*basep);
10369 TYPE_MARKED_P (ref) = 1;
10371 /* The binfo slot should be empty, unless this is an (ill-formed)
10373 gcc_assert (!TYPE_BINFO (ref) || TYPE_SIZE (ref));
10374 gcc_assert (TYPE_MAIN_VARIANT (ref) == ref);
10376 binfo = make_tree_binfo (max_bases);
10378 TYPE_BINFO (ref) = binfo;
10379 BINFO_OFFSET (binfo) = size_zero_node;
10380 BINFO_TYPE (binfo) = ref;
10384 BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, gc, max_bases);
10385 /* An aggregate cannot have baseclasses. */
10386 CLASSTYPE_NON_AGGREGATE (ref) = 1;
10388 if (TREE_CODE (ref) == UNION_TYPE)
10390 error ("derived union %qT invalid", ref);
10397 if (TYPE_FOR_JAVA (ref))
10399 error ("Java class %qT cannot have multiple bases", ref);
10406 CLASSTYPE_VBASECLASSES (ref) = VEC_alloc (tree, gc, max_vbases);
10408 if (TYPE_FOR_JAVA (ref))
10410 error ("Java class %qT cannot have virtual bases", ref);
10415 for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list))
10417 tree access = TREE_PURPOSE (base_list);
10418 int via_virtual = TREE_TYPE (base_list) != NULL_TREE;
10419 tree basetype = TREE_VALUE (base_list);
10421 if (access == access_default_node)
10422 access = default_access;
10424 if (PACK_EXPANSION_P (basetype))
10425 basetype = PACK_EXPANSION_PATTERN (basetype);
10426 if (TREE_CODE (basetype) == TYPE_DECL)
10427 basetype = TREE_TYPE (basetype);
10428 if (TREE_CODE (basetype) != RECORD_TYPE
10429 && TREE_CODE (basetype) != TYPENAME_TYPE
10430 && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
10431 && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM)
10433 error ("base type %qT fails to be a struct or class type",
10438 if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0))
10439 TYPE_FOR_JAVA (ref) = 1;
10441 base_binfo = NULL_TREE;
10442 if (CLASS_TYPE_P (basetype) && !dependent_type_p (basetype))
10444 base_binfo = TYPE_BINFO (basetype);
10445 /* The original basetype could have been a typedef'd type. */
10446 basetype = BINFO_TYPE (base_binfo);
10448 /* Inherit flags from the base. */
10449 TYPE_HAS_NEW_OPERATOR (ref)
10450 |= TYPE_HAS_NEW_OPERATOR (basetype);
10451 TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
10452 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
10453 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
10454 TYPE_HAS_CONVERSION (ref) |= TYPE_HAS_CONVERSION (basetype);
10455 CLASSTYPE_DIAMOND_SHAPED_P (ref)
10456 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype);
10457 CLASSTYPE_REPEATED_BASE_P (ref)
10458 |= CLASSTYPE_REPEATED_BASE_P (basetype);
10461 /* We must do this test after we've seen through a typedef
10463 if (TYPE_MARKED_P (basetype))
10465 if (basetype == ref)
10466 error ("recursive type %qT undefined", basetype);
10468 error ("duplicate base type %qT invalid", basetype);
10472 if (PACK_EXPANSION_P (TREE_VALUE (base_list)))
10473 /* Regenerate the pack expansion for the bases. */
10474 basetype = make_pack_expansion (basetype);
10476 TYPE_MARKED_P (basetype) = 1;
10478 base_binfo = copy_binfo (base_binfo, basetype, ref,
10479 &igo_prev, via_virtual);
10480 if (!BINFO_INHERITANCE_CHAIN (base_binfo))
10481 BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
10483 BINFO_BASE_APPEND (binfo, base_binfo);
10484 BINFO_BASE_ACCESS_APPEND (binfo, access);
10487 if (VEC_space (tree, CLASSTYPE_VBASECLASSES (ref), 1))
10488 /* If we have space in the vbase vector, we must have shared at
10489 least one of them, and are therefore diamond shaped. */
10490 CLASSTYPE_DIAMOND_SHAPED_P (ref) = 1;
10492 /* Unmark all the types. */
10493 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
10494 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
10495 TYPE_MARKED_P (ref) = 0;
10497 /* Now see if we have a repeated base type. */
10498 if (!CLASSTYPE_REPEATED_BASE_P (ref))
10500 for (base_binfo = binfo; base_binfo;
10501 base_binfo = TREE_CHAIN (base_binfo))
10503 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
10505 CLASSTYPE_REPEATED_BASE_P (ref) = 1;
10508 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 1;
10510 for (base_binfo = binfo; base_binfo;
10511 base_binfo = TREE_CHAIN (base_binfo))
10512 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
10513 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
10522 /* Begin compiling the definition of an enumeration type.
10524 Returns the type object, as yet incomplete.
10525 Also records info about it so that build_enumerator
10526 may be used to declare the individual values as they are read. */
10529 start_enum (tree name)
10533 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
10535 /* If this is the real definition for a previous forward reference,
10536 fill in the contents in the same object that used to be the
10537 forward reference. */
10539 enumtype = lookup_and_check_tag (enum_type, name,
10540 /*tag_scope=*/ts_current,
10541 /*template_header_p=*/false);
10543 if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
10545 error ("multiple definition of %q#T", enumtype);
10546 error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype));
10547 /* Clear out TYPE_VALUES, and start again. */
10548 TYPE_VALUES (enumtype) = NULL_TREE;
10552 /* In case of error, make a dummy enum to allow parsing to
10554 if (enumtype == error_mark_node)
10555 name = make_anon_name ();
10557 enumtype = make_node (ENUMERAL_TYPE);
10558 enumtype = pushtag (name, enumtype, /*tag_scope=*/ts_current);
10564 /* After processing and defining all the values of an enumeration type,
10565 install their decls in the enumeration type and finish it off.
10566 ENUMTYPE is the type object and VALUES a list of name-value pairs. */
10569 finish_enum (tree enumtype)
10578 bool use_short_enum;
10582 integer_type_kind itk;
10583 tree underlying_type = NULL_TREE;
10585 /* We built up the VALUES in reverse order. */
10586 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
10588 /* For an enum defined in a template, just set the type of the values;
10589 all further processing is postponed until the template is
10590 instantiated. We need to set the type so that tsubst of a CONST_DECL
10592 if (processing_template_decl)
10594 for (values = TYPE_VALUES (enumtype);
10596 values = TREE_CHAIN (values))
10597 TREE_TYPE (TREE_VALUE (values)) = enumtype;
10598 if (at_function_scope_p ())
10599 add_stmt (build_min (TAG_DEFN, enumtype));
10603 /* Determine the minimum and maximum values of the enumerators. */
10604 if (TYPE_VALUES (enumtype))
10606 minnode = maxnode = NULL_TREE;
10608 for (values = TYPE_VALUES (enumtype);
10610 values = TREE_CHAIN (values))
10612 decl = TREE_VALUE (values);
10614 /* [dcl.enum]: Following the closing brace of an enum-specifier,
10615 each enumerator has the type of its enumeration. Prior to the
10616 closing brace, the type of each enumerator is the type of its
10617 initializing value. */
10618 TREE_TYPE (decl) = enumtype;
10620 /* Update the minimum and maximum values, if appropriate. */
10621 value = DECL_INITIAL (decl);
10622 if (value == error_mark_node)
10623 value = integer_zero_node;
10624 /* Figure out what the minimum and maximum values of the
10625 enumerators are. */
10627 minnode = maxnode = value;
10628 else if (tree_int_cst_lt (maxnode, value))
10630 else if (tree_int_cst_lt (value, minnode))
10637 If the enumerator-list is empty, the underlying type is as if
10638 the enumeration had a single enumerator with value 0. */
10639 minnode = maxnode = integer_zero_node;
10641 /* Compute the number of bits require to represent all values of the
10642 enumeration. We must do this before the type of MINNODE and
10643 MAXNODE are transformed, since min_precision relies on the
10644 TREE_TYPE of the value it is passed. */
10645 unsignedp = tree_int_cst_sgn (minnode) >= 0;
10646 lowprec = min_precision (minnode, unsignedp);
10647 highprec = min_precision (maxnode, unsignedp);
10648 precision = MAX (lowprec, highprec);
10650 /* Determine the underlying type of the enumeration.
10654 The underlying type of an enumeration is an integral type that
10655 can represent all the enumerator values defined in the
10656 enumeration. It is implementation-defined which integral type is
10657 used as the underlying type for an enumeration except that the
10658 underlying type shall not be larger than int unless the value of
10659 an enumerator cannot fit in an int or unsigned int.
10661 We use "int" or an "unsigned int" as the underlying type, even if
10662 a smaller integral type would work, unless the user has
10663 explicitly requested that we use the smallest possible type. The
10664 user can request that for all enumerations with a command line
10665 flag, or for just one enumeration with an attribute. */
10667 use_short_enum = flag_short_enums
10668 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype));
10670 for (itk = (use_short_enum ? itk_char : itk_int);
10674 underlying_type = integer_types[itk];
10675 if (TYPE_PRECISION (underlying_type) >= precision
10676 && TYPE_UNSIGNED (underlying_type) == unsignedp)
10679 if (itk == itk_none)
10683 IF no integral type can represent all the enumerator values, the
10684 enumeration is ill-formed. */
10685 error ("no integral type can represent all of the enumerator values "
10686 "for %qT", enumtype);
10687 precision = TYPE_PRECISION (long_long_integer_type_node);
10688 underlying_type = integer_types[itk_unsigned_long_long];
10691 /* Compute the minium and maximum values for the type.
10695 For an enumeration where emin is the smallest enumerator and emax
10696 is the largest, the values of the enumeration are the values of the
10697 underlying type in the range bmin to bmax, where bmin and bmax are,
10698 respectively, the smallest and largest values of the smallest bit-
10699 field that can store emin and emax. */
10701 /* The middle-end currently assumes that types with TYPE_PRECISION
10702 narrower than their underlying type are suitably zero or sign
10703 extended to fill their mode. g++ doesn't make these guarantees.
10704 Until the middle-end can represent such paradoxical types, we
10705 set the TYPE_PRECISION to the width of the underlying type. */
10706 TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type);
10708 set_min_and_max_values_for_integral_type (enumtype, precision, unsignedp);
10712 The value of sizeof() applied to an enumeration type, an object
10713 of an enumeration type, or an enumerator, is the value of sizeof()
10714 applied to the underlying type. */
10715 TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
10716 TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
10717 TYPE_MODE (enumtype) = TYPE_MODE (underlying_type);
10718 TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
10719 TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
10720 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);
10722 /* Convert each of the enumerators to the type of the underlying
10723 type of the enumeration. */
10724 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
10726 location_t saved_location;
10728 decl = TREE_VALUE (values);
10729 saved_location = input_location;
10730 input_location = DECL_SOURCE_LOCATION (decl);
10731 value = perform_implicit_conversion (underlying_type,
10732 DECL_INITIAL (decl));
10733 input_location = saved_location;
10735 /* Do not clobber shared ints. */
10736 value = copy_node (value);
10738 TREE_TYPE (value) = enumtype;
10739 DECL_INITIAL (decl) = value;
10740 TREE_VALUE (values) = value;
10743 /* Fix up all variant types of this enum type. */
10744 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
10746 TYPE_VALUES (t) = TYPE_VALUES (enumtype);
10747 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
10748 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
10749 TYPE_SIZE (t) = TYPE_SIZE (enumtype);
10750 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
10751 TYPE_MODE (t) = TYPE_MODE (enumtype);
10752 TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
10753 TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
10754 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
10755 TYPE_UNSIGNED (t) = TYPE_UNSIGNED (enumtype);
10758 /* Finish debugging output for this type. */
10759 rest_of_type_compilation (enumtype, namespace_bindings_p ());
10762 /* Build and install a CONST_DECL for an enumeration constant of the
10763 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
10764 Assignment of sequential values by default is handled here. */
10767 build_enumerator (tree name, tree value, tree enumtype)
10773 /* If the VALUE was erroneous, pretend it wasn't there; that will
10774 result in the enum being assigned the next value in sequence. */
10775 if (value == error_mark_node)
10778 /* Remove no-op casts from the value. */
10780 STRIP_TYPE_NOPS (value);
10782 if (! processing_template_decl)
10784 /* Validate and default VALUE. */
10785 if (value != NULL_TREE)
10787 value = integral_constant_value (value);
10789 if (TREE_CODE (value) == INTEGER_CST)
10791 value = perform_integral_promotions (value);
10792 constant_expression_warning (value);
10796 error ("enumerator value for %qD is not an integer constant", name);
10801 /* Default based on previous value. */
10802 if (value == NULL_TREE)
10804 if (TYPE_VALUES (enumtype))
10807 unsigned HOST_WIDE_INT lo;
10811 /* The next value is the previous value plus one. We can
10812 safely assume that the previous value is an INTEGER_CST.
10813 add_double doesn't know the type of the target expression,
10814 so we must check with int_fits_type_p as well. */
10815 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
10816 overflowed = add_double (TREE_INT_CST_LOW (prev_value),
10817 TREE_INT_CST_HIGH (prev_value),
10819 value = build_int_cst_wide (TREE_TYPE (prev_value), lo, hi);
10820 overflowed |= !int_fits_type_p (value, TREE_TYPE (prev_value));
10824 error ("overflow in enumeration values at %qD", name);
10825 value = error_mark_node;
10829 value = integer_zero_node;
10832 /* Remove no-op casts from the value. */
10833 STRIP_TYPE_NOPS (value);
10836 /* C++ associates enums with global, function, or class declarations. */
10837 context = current_scope ();
10839 /* Build the actual enumeration constant. Note that the enumeration
10840 constants have the type of their initializers until the
10841 enumeration is complete:
10845 Following the closing brace of an enum-specifier, each enumer-
10846 ator has the type of its enumeration. Prior to the closing
10847 brace, the type of each enumerator is the type of its
10848 initializing value.
10850 In finish_enum we will reset the type. Of course, if we're
10851 processing a template, there may be no value. */
10852 type = value ? TREE_TYPE (value) : NULL_TREE;
10854 if (context && context == current_class_type)
10855 /* This enum declaration is local to the class. We need the full
10856 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
10857 decl = build_lang_decl (CONST_DECL, name, type);
10859 /* It's a global enum, or it's local to a function. (Note local to
10860 a function could mean local to a class method. */
10861 decl = build_decl (CONST_DECL, name, type);
10863 DECL_CONTEXT (decl) = FROB_CONTEXT (context);
10864 TREE_CONSTANT (decl) = 1;
10865 TREE_INVARIANT (decl) = 1;
10866 TREE_READONLY (decl) = 1;
10867 DECL_INITIAL (decl) = value;
10869 if (context && context == current_class_type)
10870 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
10871 on the TYPE_FIELDS list for `S'. (That's so that you can say
10872 things like `S::i' later.) */
10873 finish_member_declaration (decl);
10877 /* Add this enumeration constant to the list for this type. */
10878 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
10882 /* We're defining DECL. Make sure that it's type is OK. */
10885 check_function_type (tree decl, tree current_function_parms)
10887 tree fntype = TREE_TYPE (decl);
10888 tree return_type = complete_type (TREE_TYPE (fntype));
10890 /* In a function definition, arg types must be complete. */
10891 require_complete_types_for_parms (current_function_parms);
10893 if (dependent_type_p (return_type))
10895 if (!COMPLETE_OR_VOID_TYPE_P (return_type))
10897 tree args = TYPE_ARG_TYPES (fntype);
10899 error ("return type %q#T is incomplete", return_type);
10901 /* Make it return void instead. */
10902 if (TREE_CODE (fntype) == METHOD_TYPE)
10903 fntype = build_method_type_directly (TREE_TYPE (TREE_VALUE (args)),
10905 TREE_CHAIN (args));
10907 fntype = build_function_type (void_type_node, args);
10909 = build_exception_variant (fntype,
10910 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)));
10913 abstract_virtuals_error (decl, TREE_TYPE (fntype));
10916 /* Create the FUNCTION_DECL for a function definition.
10917 DECLSPECS and DECLARATOR are the parts of the declaration;
10918 they describe the function's name and the type it returns,
10919 but twisted together in a fashion that parallels the syntax of C.
10921 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
10922 DECLARATOR is really the DECL for the function we are about to
10923 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
10924 indicating that the function is an inline defined in-class.
10926 This function creates a binding context for the function body
10927 as well as setting up the FUNCTION_DECL in current_function_decl.
10929 For C++, we must first check whether that datum makes any sense.
10930 For example, "class A local_a(1,2);" means that variable local_a
10931 is an aggregate of type A, which should have a constructor
10932 applied to it with the argument list [1, 2].
10934 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
10935 or may be a BLOCK if the function has been defined previously
10936 in this translation unit. On exit, DECL_INITIAL (decl1) will be
10937 error_mark_node if the function has never been defined, or
10938 a BLOCK if the function has been defined somewhere. */
10941 start_preparsed_function (tree decl1, tree attrs, int flags)
10943 tree ctype = NULL_TREE;
10946 int doing_friend = 0;
10947 struct cp_binding_level *bl;
10948 tree current_function_parms;
10949 struct c_fileinfo *finfo
10950 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1)));
10951 bool honor_interface;
10953 /* Sanity check. */
10954 gcc_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE);
10955 gcc_assert (TREE_CHAIN (void_list_node) == NULL_TREE);
10957 fntype = TREE_TYPE (decl1);
10958 if (TREE_CODE (fntype) == METHOD_TYPE)
10959 ctype = TYPE_METHOD_BASETYPE (fntype);
10961 /* ISO C++ 11.4/5. A friend function defined in a class is in
10962 the (lexical) scope of the class in which it is defined. */
10963 if (!ctype && DECL_FRIEND_P (decl1))
10965 ctype = DECL_FRIEND_CONTEXT (decl1);
10967 /* CTYPE could be null here if we're dealing with a template;
10968 for example, `inline friend float foo()' inside a template
10969 will have no CTYPE set. */
10970 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
10976 if (DECL_DECLARED_INLINE_P (decl1)
10977 && lookup_attribute ("noinline", attrs))
10978 warning (0, "inline function %q+D given attribute noinline", decl1);
10980 /* Handle gnu_inline attribute. */
10981 if (GNU_INLINE_P (decl1))
10983 DECL_EXTERNAL (decl1) = 1;
10984 DECL_NOT_REALLY_EXTERN (decl1) = 0;
10985 DECL_INTERFACE_KNOWN (decl1) = 1;
10986 DECL_DISREGARD_INLINE_LIMITS (decl1) = 1;
10989 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
10990 /* This is a constructor, we must ensure that any default args
10991 introduced by this definition are propagated to the clones
10992 now. The clones are used directly in overload resolution. */
10993 adjust_clone_args (decl1);
10995 /* Sometimes we don't notice that a function is a static member, and
10996 build a METHOD_TYPE for it. Fix that up now. */
10997 if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
10998 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
11000 revert_static_member_fn (decl1);
11004 /* Set up current_class_type, and enter the scope of the class, if
11007 push_nested_class (ctype);
11008 else if (DECL_STATIC_FUNCTION_P (decl1))
11009 push_nested_class (DECL_CONTEXT (decl1));
11011 /* Now that we have entered the scope of the class, we must restore
11012 the bindings for any template parameters surrounding DECL1, if it
11013 is an inline member template. (Order is important; consider the
11014 case where a template parameter has the same name as a field of
11015 the class.) It is not until after this point that
11016 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
11017 if (flags & SF_INCLASS_INLINE)
11018 maybe_begin_member_template_processing (decl1);
11020 /* Effective C++ rule 15. */
11022 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
11023 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
11024 warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");
11026 /* Make the init_value nonzero so pushdecl knows this is not tentative.
11027 error_mark_node is replaced below (in poplevel) with the BLOCK. */
11028 if (!DECL_INITIAL (decl1))
11029 DECL_INITIAL (decl1) = error_mark_node;
11031 /* This function exists in static storage.
11032 (This does not mean `static' in the C sense!) */
11033 TREE_STATIC (decl1) = 1;
11035 /* We must call push_template_decl after current_class_type is set
11036 up. (If we are processing inline definitions after exiting a
11037 class scope, current_class_type will be NULL_TREE until set above
11038 by push_nested_class.) */
11039 if (processing_template_decl)
11041 /* FIXME: Handle error_mark_node more gracefully. */
11042 tree newdecl1 = push_template_decl (decl1);
11043 if (newdecl1 != error_mark_node)
11047 /* We are now in the scope of the function being defined. */
11048 current_function_decl = decl1;
11050 /* Save the parm names or decls from this function's declarator
11051 where store_parm_decls will find them. */
11052 current_function_parms = DECL_ARGUMENTS (decl1);
11054 /* Make sure the parameter and return types are reasonable. When
11055 you declare a function, these types can be incomplete, but they
11056 must be complete when you define the function. */
11057 check_function_type (decl1, current_function_parms);
11059 /* Build the return declaration for the function. */
11060 restype = TREE_TYPE (fntype);
11061 if (DECL_RESULT (decl1) == NULL_TREE)
11065 resdecl = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
11066 DECL_ARTIFICIAL (resdecl) = 1;
11067 DECL_IGNORED_P (resdecl) = 1;
11068 DECL_RESULT (decl1) = resdecl;
11070 cp_apply_type_quals_to_decl (cp_type_quals (restype), resdecl);
11073 /* Let the user know we're compiling this function. */
11074 announce_function (decl1);
11076 /* Record the decl so that the function name is defined.
11077 If we already have a decl for this name, and it is a FUNCTION_DECL,
11078 use the old decl. */
11079 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
11081 /* A specialization is not used to guide overload resolution. */
11082 if (!DECL_FUNCTION_MEMBER_P (decl1)
11083 && !(DECL_USE_TEMPLATE (decl1) &&
11084 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1))))
11086 tree olddecl = pushdecl (decl1);
11088 if (olddecl == error_mark_node)
11089 /* If something went wrong when registering the declaration,
11090 use DECL1; we have to have a FUNCTION_DECL to use when
11091 parsing the body of the function. */
11095 /* Otherwise, OLDDECL is either a previous declaration
11096 of the same function or DECL1 itself. */
11098 if (warn_missing_declarations
11099 && olddecl == decl1
11100 && !DECL_MAIN_P (decl1)
11101 && TREE_PUBLIC (decl1)
11102 && !DECL_DECLARED_INLINE_P (decl1))
11106 /* Check whether DECL1 is in an anonymous
11108 for (context = DECL_CONTEXT (decl1);
11110 context = DECL_CONTEXT (context))
11112 if (TREE_CODE (context) == NAMESPACE_DECL
11113 && DECL_NAME (context) == NULL_TREE)
11117 if (context == NULL)
11118 warning (OPT_Wmissing_declarations,
11119 "no previous declaration for %q+D", decl1);
11127 /* We need to set the DECL_CONTEXT. */
11128 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
11129 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
11131 fntype = TREE_TYPE (decl1);
11133 /* If #pragma weak applies, mark the decl appropriately now.
11134 The pragma only applies to global functions. Because
11135 determining whether or not the #pragma applies involves
11136 computing the mangled name for the declaration, we cannot
11137 apply the pragma until after we have merged this declaration
11138 with any previous declarations; if the original declaration
11139 has a linkage specification, that specification applies to
11140 the definition as well, and may affect the mangled name. */
11141 if (!DECL_CONTEXT (decl1))
11142 maybe_apply_pragma_weak (decl1);
11145 /* Reset this in case the call to pushdecl changed it. */
11146 current_function_decl = decl1;
11148 gcc_assert (DECL_INITIAL (decl1));
11150 /* This function may already have been parsed, in which case just
11151 return; our caller will skip over the body without parsing. */
11152 if (DECL_INITIAL (decl1) != error_mark_node)
11155 /* Initialize RTL machinery. We cannot do this until
11156 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
11157 even when processing a template; this is how we get
11158 CFUN set up, and our per-function variables initialized.
11159 FIXME factor out the non-RTL stuff. */
11160 bl = current_binding_level;
11161 allocate_struct_function (decl1);
11162 current_binding_level = bl;
11164 /* Even though we're inside a function body, we still don't want to
11165 call expand_expr to calculate the size of a variable-sized array.
11166 We haven't necessarily assigned RTL to all variables yet, so it's
11167 not safe to try to expand expressions involving them. */
11168 cfun->x_dont_save_pending_sizes_p = 1;
11170 /* Start the statement-tree, start the tree now. */
11171 DECL_SAVED_TREE (decl1) = push_stmt_list ();
11173 /* If we are (erroneously) defining a function that we have already
11174 defined before, wipe out what we knew before. */
11175 if (!DECL_PENDING_INLINE_P (decl1))
11176 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
11178 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
11180 /* We know that this was set up by `grokclassfn'. We do not
11181 wait until `store_parm_decls', since evil parse errors may
11182 never get us to that point. Here we keep the consistency
11183 between `current_class_type' and `current_class_ptr'. */
11184 tree t = DECL_ARGUMENTS (decl1);
11186 gcc_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL);
11187 gcc_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE);
11189 cp_function_chain->x_current_class_ref
11190 = build_indirect_ref (t, NULL);
11191 cp_function_chain->x_current_class_ptr = t;
11193 /* Constructors and destructors need to know whether they're "in
11194 charge" of initializing virtual base classes. */
11195 t = TREE_CHAIN (t);
11196 if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
11198 current_in_charge_parm = t;
11199 t = TREE_CHAIN (t);
11201 if (DECL_HAS_VTT_PARM_P (decl1))
11203 gcc_assert (DECL_NAME (t) == vtt_parm_identifier);
11204 current_vtt_parm = t;
11208 honor_interface = (!DECL_TEMPLATE_INSTANTIATION (decl1)
11209 /* Implicitly-defined methods (like the
11210 destructor for a class in which no destructor
11211 is explicitly declared) must not be defined
11212 until their definition is needed. So, we
11213 ignore interface specifications for
11214 compiler-generated functions. */
11215 && !DECL_ARTIFICIAL (decl1));
11217 if (DECL_INTERFACE_KNOWN (decl1))
11219 tree ctx = decl_function_context (decl1);
11221 if (DECL_NOT_REALLY_EXTERN (decl1))
11222 DECL_EXTERNAL (decl1) = 0;
11224 if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
11225 && TREE_PUBLIC (ctx))
11226 /* This is a function in a local class in an extern inline
11228 comdat_linkage (decl1);
11230 /* If this function belongs to an interface, it is public.
11231 If it belongs to someone else's interface, it is also external.
11232 This only affects inlines and template instantiations. */
11233 else if (!finfo->interface_unknown && honor_interface)
11235 if (DECL_DECLARED_INLINE_P (decl1)
11236 || DECL_TEMPLATE_INSTANTIATION (decl1)
11237 || processing_template_decl)
11239 DECL_EXTERNAL (decl1)
11240 = (finfo->interface_only
11241 || (DECL_DECLARED_INLINE_P (decl1)
11242 && ! flag_implement_inlines
11243 && !DECL_VINDEX (decl1)));
11245 /* For WIN32 we also want to put these in linkonce sections. */
11246 maybe_make_one_only (decl1);
11249 DECL_EXTERNAL (decl1) = 0;
11250 DECL_INTERFACE_KNOWN (decl1) = 1;
11251 /* If this function is in an interface implemented in this file,
11252 make sure that the back end knows to emit this function
11254 if (!DECL_EXTERNAL (decl1))
11255 mark_needed (decl1);
11257 else if (finfo->interface_unknown && finfo->interface_only
11258 && honor_interface)
11260 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
11261 interface, we will have both finfo->interface_unknown and
11262 finfo->interface_only set. In that case, we don't want to
11263 use the normal heuristics because someone will supply a
11264 #pragma implementation elsewhere, and deducing it here would
11265 produce a conflict. */
11266 comdat_linkage (decl1);
11267 DECL_EXTERNAL (decl1) = 0;
11268 DECL_INTERFACE_KNOWN (decl1) = 1;
11269 DECL_DEFER_OUTPUT (decl1) = 1;
11273 /* This is a definition, not a reference.
11274 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
11275 if (!GNU_INLINE_P (decl1))
11276 DECL_EXTERNAL (decl1) = 0;
11278 if ((DECL_DECLARED_INLINE_P (decl1)
11279 || DECL_TEMPLATE_INSTANTIATION (decl1))
11280 && ! DECL_INTERFACE_KNOWN (decl1)
11281 /* Don't try to defer nested functions for now. */
11282 && ! decl_function_context (decl1))
11283 DECL_DEFER_OUTPUT (decl1) = 1;
11285 DECL_INTERFACE_KNOWN (decl1) = 1;
11288 /* Determine the ELF visibility attribute for the function. We must not
11289 do this before calling "pushdecl", as we must allow "duplicate_decls"
11290 to merge any attributes appropriately. We also need to wait until
11292 if (!DECL_CLONED_FUNCTION_P (decl1))
11293 determine_visibility (decl1);
11295 begin_scope (sk_function_parms, decl1);
11299 if (DECL_DESTRUCTOR_P (decl1)
11300 || (DECL_CONSTRUCTOR_P (decl1)
11301 && targetm.cxx.cdtor_returns_this ()))
11303 cdtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
11304 DECL_CONTEXT (cdtor_label) = current_function_decl;
11307 start_fname_decls ();
11309 store_parm_decls (current_function_parms);
11313 /* Like start_preparsed_function, except that instead of a
11314 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
11316 Returns 1 on success. If the DECLARATOR is not suitable for a function
11317 (it defines a datum instead), we return 0, which tells
11318 yyparse to report a parse error. */
11321 start_function (cp_decl_specifier_seq *declspecs,
11322 const cp_declarator *declarator,
11327 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
11328 /* If the declarator is not suitable for a function definition,
11329 cause a syntax error. */
11330 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
11333 if (DECL_MAIN_P (decl1))
11334 /* main must return int. grokfndecl should have corrected it
11335 (and issued a diagnostic) if the user got it wrong. */
11336 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1)),
11337 integer_type_node));
11339 start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT);
11344 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
11348 use_eh_spec_block (tree fn)
11350 return (flag_exceptions && flag_enforce_eh_specs
11351 && !processing_template_decl
11352 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn))
11353 /* We insert the EH_SPEC_BLOCK only in the original
11354 function; then, it is copied automatically to the
11356 && !DECL_CLONED_FUNCTION_P (fn)
11357 /* Implicitly-generated constructors and destructors have
11358 exception specifications. However, those specifications
11359 are the union of the possible exceptions specified by the
11360 constructors/destructors for bases and members, so no
11361 unallowed exception will ever reach this function. By
11362 not creating the EH_SPEC_BLOCK we save a little memory,
11363 and we avoid spurious warnings about unreachable
11365 && !DECL_ARTIFICIAL (fn));
11368 /* Store the parameter declarations into the current function declaration.
11369 This is called after parsing the parameter declarations, before
11370 digesting the body of the function.
11372 Also install to binding contour return value identifier, if any. */
11375 store_parm_decls (tree current_function_parms)
11377 tree fndecl = current_function_decl;
11380 /* This is a chain of any other decls that came in among the parm
11381 declarations. If a parm is declared with enum {foo, bar} x;
11382 then CONST_DECLs for foo and bar are put here. */
11383 tree nonparms = NULL_TREE;
11385 if (current_function_parms)
11387 /* This case is when the function was defined with an ANSI prototype.
11388 The parms already have decls, so we need not do anything here
11389 except record them as in effect
11390 and complain if any redundant old-style parm decls were written. */
11392 tree specparms = current_function_parms;
11395 /* Must clear this because it might contain TYPE_DECLs declared
11397 current_binding_level->names = NULL;
11399 /* If we're doing semantic analysis, then we'll call pushdecl
11400 for each of these. We must do them in reverse order so that
11401 they end in the correct forward order. */
11402 specparms = nreverse (specparms);
11404 for (parm = specparms; parm; parm = next)
11406 next = TREE_CHAIN (parm);
11407 if (TREE_CODE (parm) == PARM_DECL)
11409 if (DECL_NAME (parm) == NULL_TREE
11410 || TREE_CODE (parm) != VOID_TYPE)
11413 error ("parameter %qD declared void", parm);
11417 /* If we find an enum constant or a type tag,
11418 put it aside for the moment. */
11419 TREE_CHAIN (parm) = NULL_TREE;
11420 nonparms = chainon (nonparms, parm);
11424 /* Get the decls in their original chain order and record in the
11425 function. This is all and only the PARM_DECLs that were
11426 pushed into scope by the loop above. */
11427 DECL_ARGUMENTS (fndecl) = getdecls ();
11430 DECL_ARGUMENTS (fndecl) = NULL_TREE;
11432 /* Now store the final chain of decls for the arguments
11433 as the decl-chain of the current lexical scope.
11434 Put the enumerators in as well, at the front so that
11435 DECL_ARGUMENTS is not modified. */
11436 current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));
11438 if (use_eh_spec_block (current_function_decl))
11439 current_eh_spec_block = begin_eh_spec_block ();
11443 /* We have finished doing semantic analysis on DECL, but have not yet
11444 generated RTL for its body. Save away our current state, so that
11445 when we want to generate RTL later we know what to do. */
11448 save_function_data (tree decl)
11450 struct language_function *f;
11452 /* Save the language-specific per-function data so that we can
11453 get it back when we really expand this function. */
11454 gcc_assert (!DECL_PENDING_INLINE_P (decl));
11457 f = GGC_NEW (struct language_function);
11458 memcpy (f, cp_function_chain, sizeof (struct language_function));
11459 DECL_SAVED_FUNCTION_DATA (decl) = f;
11461 /* Clear out the bits we don't need. */
11462 f->base.x_stmt_tree.x_cur_stmt_list = NULL_TREE;
11463 f->bindings = NULL;
11464 f->x_local_names = NULL;
11468 /* Set the return value of the constructor (if present). */
11471 finish_constructor_body (void)
11476 if (targetm.cxx.cdtor_returns_this ())
11478 /* Any return from a constructor will end up here. */
11479 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
11481 val = DECL_ARGUMENTS (current_function_decl);
11482 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
11483 DECL_RESULT (current_function_decl), val);
11484 /* Return the address of the object. */
11485 exprstmt = build_stmt (RETURN_EXPR, val);
11486 add_stmt (exprstmt);
11490 /* Do all the processing for the beginning of a destructor; set up the
11491 vtable pointers and cleanups for bases and members. */
11494 begin_destructor_body (void)
11496 tree compound_stmt;
11498 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
11499 issued an error message. We still want to try to process the
11500 body of the function, but initialize_vtbl_ptrs will crash if
11501 TYPE_BINFO is NULL. */
11502 if (COMPLETE_TYPE_P (current_class_type))
11504 compound_stmt = begin_compound_stmt (0);
11505 /* Make all virtual function table pointers in non-virtual base
11506 classes point to CURRENT_CLASS_TYPE's virtual function
11508 initialize_vtbl_ptrs (current_class_ptr);
11509 finish_compound_stmt (compound_stmt);
11511 /* And insert cleanups for our bases and members so that they
11512 will be properly destroyed if we throw. */
11513 push_base_cleanups ();
11517 /* At the end of every destructor we generate code to delete the object if
11518 necessary. Do that now. */
11521 finish_destructor_body (void)
11525 /* Any return from a destructor will end up here; that way all base
11526 and member cleanups will be run when the function returns. */
11527 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
11529 /* In a virtual destructor, we must call delete. */
11530 if (DECL_VIRTUAL_P (current_function_decl))
11533 tree virtual_size = cxx_sizeof (current_class_type);
11537 At the point of definition of a virtual destructor (including
11538 an implicit definition), non-placement operator delete shall
11539 be looked up in the scope of the destructor's class and if
11540 found shall be accessible and unambiguous. */
11541 exprstmt = build_op_delete_call(DELETE_EXPR, current_class_ptr,
11543 /*global_p=*/false,
11544 /*placement=*/NULL_TREE,
11545 /*alloc_fn=*/NULL_TREE);
11547 if_stmt = begin_if_stmt ();
11548 finish_if_stmt_cond (build2 (BIT_AND_EXPR, integer_type_node,
11549 current_in_charge_parm,
11552 finish_expr_stmt (exprstmt);
11553 finish_then_clause (if_stmt);
11554 finish_if_stmt (if_stmt);
11557 if (targetm.cxx.cdtor_returns_this ())
11561 val = DECL_ARGUMENTS (current_function_decl);
11562 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
11563 DECL_RESULT (current_function_decl), val);
11564 /* Return the address of the object. */
11565 exprstmt = build_stmt (RETURN_EXPR, val);
11566 add_stmt (exprstmt);
11570 /* Do the necessary processing for the beginning of a function body, which
11571 in this case includes member-initializers, but not the catch clauses of
11572 a function-try-block. Currently, this means opening a binding level
11573 for the member-initializers (in a ctor) and member cleanups (in a dtor). */
11576 begin_function_body (void)
11580 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
11583 if (processing_template_decl)
11584 /* Do nothing now. */;
11586 /* Always keep the BLOCK node associated with the outermost pair of
11587 curly braces of a function. These are needed for correct
11588 operation of dwarfout.c. */
11589 keep_next_level (true);
11591 stmt = begin_compound_stmt (BCS_FN_BODY);
11593 if (processing_template_decl)
11594 /* Do nothing now. */;
11595 else if (DECL_DESTRUCTOR_P (current_function_decl))
11596 begin_destructor_body ();
11601 /* Do the processing for the end of a function body. Currently, this means
11602 closing out the cleanups for fully-constructed bases and members, and in
11603 the case of the destructor, deleting the object if desired. Again, this
11604 is only meaningful for [cd]tors, since they are the only functions where
11605 there is a significant distinction between the main body and any
11606 function catch clauses. Handling, say, main() return semantics here
11607 would be wrong, as flowing off the end of a function catch clause for
11608 main() would also need to return 0. */
11611 finish_function_body (tree compstmt)
11613 if (compstmt == NULL_TREE)
11616 /* Close the block. */
11617 finish_compound_stmt (compstmt);
11619 if (processing_template_decl)
11620 /* Do nothing now. */;
11621 else if (DECL_CONSTRUCTOR_P (current_function_decl))
11622 finish_constructor_body ();
11623 else if (DECL_DESTRUCTOR_P (current_function_decl))
11624 finish_destructor_body ();
11627 /* Given a function, returns the BLOCK corresponding to the outermost level
11628 of curly braces, skipping the artificial block created for constructor
11632 outer_curly_brace_block (tree fndecl)
11634 tree block = BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl));
11635 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
11636 /* Skip the artificial function body block. */
11637 block = BLOCK_SUBBLOCKS (block);
11641 /* Finish up a function declaration and compile that function
11642 all the way to assembler language output. The free the storage
11643 for the function definition.
11645 FLAGS is a bitwise or of the following values:
11647 We just finished processing the body of an in-class inline
11648 function definition. (This processing will have taken place
11649 after the class definition is complete.) */
11652 finish_function (int flags)
11654 tree fndecl = current_function_decl;
11655 tree fntype, ctype = NULL_TREE;
11656 int inclass_inline = (flags & 2) != 0;
11659 /* When we get some parse errors, we can end up without a
11660 current_function_decl, so cope. */
11661 if (fndecl == NULL_TREE)
11662 return error_mark_node;
11664 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
11665 && DECL_VIRTUAL_P (fndecl)
11666 && !processing_template_decl)
11668 tree fnclass = DECL_CONTEXT (fndecl);
11669 if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
11670 keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
11673 nested = function_depth > 1;
11674 fntype = TREE_TYPE (fndecl);
11676 /* TREE_READONLY (fndecl) = 1;
11677 This caused &foo to be of type ptr-to-const-function
11678 which then got a warning when stored in a ptr-to-function variable. */
11680 gcc_assert (building_stmt_tree ());
11681 /* The current function is being defined, so its DECL_INITIAL should
11682 be set, and unless there's a multiple definition, it should be
11683 error_mark_node. */
11684 gcc_assert (DECL_INITIAL (fndecl) == error_mark_node);
11686 /* For a cloned function, we've already got all the code we need;
11687 there's no need to add any extra bits. */
11688 if (!DECL_CLONED_FUNCTION_P (fndecl))
11690 if (DECL_MAIN_P (current_function_decl))
11694 /* Make it so that `main' always returns 0 by default (or
11697 stmt = finish_return_stmt (integer_one_node);
11699 stmt = finish_return_stmt (integer_zero_node);
11701 /* Hack. We don't want the middle-end to warn that this
11702 return is unreachable, so put the statement on the
11704 #ifdef USE_MAPPED_LOCATION
11706 location_t linezero = linemap_line_start (line_table, 0, 1);
11707 SET_EXPR_LOCATION (stmt, linezero);
11710 annotate_with_file_line (stmt, input_filename, 0);
11714 if (use_eh_spec_block (current_function_decl))
11715 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
11716 (TREE_TYPE (current_function_decl)),
11717 current_eh_spec_block);
11720 /* If we're saving up tree structure, tie off the function now. */
11721 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
11723 finish_fname_decls ();
11725 /* If this function can't throw any exceptions, remember that. */
11726 if (!processing_template_decl
11727 && !cp_function_chain->can_throw
11728 && !flag_non_call_exceptions
11729 && !DECL_REPLACEABLE_P (fndecl))
11730 TREE_NOTHROW (fndecl) = 1;
11732 /* This must come after expand_function_end because cleanups might
11733 have declarations (from inline functions) that need to go into
11734 this function's blocks. */
11736 /* If the current binding level isn't the outermost binding level
11737 for this function, either there is a bug, or we have experienced
11738 syntax errors and the statement tree is malformed. */
11739 if (current_binding_level->kind != sk_function_parms)
11741 /* Make sure we have already experienced errors. */
11742 gcc_assert (errorcount);
11744 /* Throw away the broken statement tree and extra binding
11746 DECL_SAVED_TREE (fndecl) = alloc_stmt_list ();
11748 while (current_binding_level->kind != sk_function_parms)
11750 if (current_binding_level->kind == sk_class)
11751 pop_nested_class ();
11753 poplevel (0, 0, 0);
11756 poplevel (1, 0, 1);
11758 /* Statements should always be full-expressions at the outermost set
11759 of curly braces for a function. */
11760 gcc_assert (stmts_are_full_exprs_p ());
11762 /* Set up the named return value optimization, if we can. Candidate
11763 variables are selected in check_return_expr. */
11764 if (current_function_return_value)
11766 tree r = current_function_return_value;
11769 if (r != error_mark_node
11770 /* This is only worth doing for fns that return in memory--and
11771 simpler, since we don't have to worry about promoted modes. */
11772 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
11773 /* Only allow this for variables declared in the outer scope of
11774 the function so we know that their lifetime always ends with a
11775 return; see g++.dg/opt/nrv6.C. We could be more flexible if
11776 we were to do this optimization in tree-ssa. */
11777 && (outer = outer_curly_brace_block (fndecl))
11778 && chain_member (r, BLOCK_VARS (outer)))
11779 finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));
11781 current_function_return_value = NULL_TREE;
11784 /* Remember that we were in class scope. */
11785 if (current_class_name)
11786 ctype = current_class_type;
11788 /* Must mark the RESULT_DECL as being in this function. */
11789 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
11791 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
11792 to the FUNCTION_DECL node itself. */
11793 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
11795 /* Save away current state, if appropriate. */
11796 if (!processing_template_decl)
11797 save_function_data (fndecl);
11799 /* Complain if there's just no return statement. */
11800 if (warn_return_type
11801 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
11802 && !dependent_type_p (TREE_TYPE (fntype))
11803 && !current_function_returns_value && !current_function_returns_null
11804 /* Don't complain if we abort or throw. */
11805 && !current_function_returns_abnormally
11806 && !DECL_NAME (DECL_RESULT (fndecl))
11807 /* Normally, with -Wreturn-type, flow will complain. Unless we're an
11808 inline function, as we might never be compiled separately. */
11809 && (DECL_INLINE (fndecl) || processing_template_decl)
11810 /* Structor return values (if any) are set by the compiler. */
11811 && !DECL_CONSTRUCTOR_P (fndecl)
11812 && !DECL_DESTRUCTOR_P (fndecl))
11813 warning (OPT_Wreturn_type, "no return statement in function returning non-void");
11815 /* Store the end of the function, so that we get good line number
11816 info for the epilogue. */
11817 cfun->function_end_locus = input_location;
11819 /* Genericize before inlining. */
11820 if (!processing_template_decl)
11822 struct language_function *f = DECL_SAVED_FUNCTION_DATA (fndecl);
11823 cp_genericize (fndecl);
11824 /* Clear out the bits we don't need. */
11825 f->x_current_class_ptr = NULL;
11826 f->x_current_class_ref = NULL;
11827 f->x_eh_spec_block = NULL;
11828 f->x_in_charge_parm = NULL;
11829 f->x_vtt_parm = NULL;
11830 f->x_return_value = NULL;
11831 f->bindings = NULL;
11832 f->extern_decl_map = NULL;
11834 /* Handle attribute((warn_unused_result)). Relies on gimple input. */
11835 c_warn_unused_result (&DECL_SAVED_TREE (fndecl));
11837 /* Clear out the bits we don't need. */
11838 local_names = NULL;
11840 /* We're leaving the context of this function, so zap cfun. It's still in
11841 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
11843 current_function_decl = NULL;
11845 /* If this is an in-class inline definition, we may have to pop the
11846 bindings for the template parameters that we added in
11847 maybe_begin_member_template_processing when start_function was
11849 if (inclass_inline)
11850 maybe_end_member_template_processing ();
11852 /* Leave the scope of the class. */
11854 pop_nested_class ();
11860 /* Let the error reporting routines know that we're outside a
11861 function. For a nested function, this value is used in
11862 cxx_pop_function_context and then reset via pop_function_context. */
11863 current_function_decl = NULL_TREE;
11868 /* Create the FUNCTION_DECL for a function definition.
11869 DECLSPECS and DECLARATOR are the parts of the declaration;
11870 they describe the return type and the name of the function,
11871 but twisted together in a fashion that parallels the syntax of C.
11873 This function creates a binding context for the function body
11874 as well as setting up the FUNCTION_DECL in current_function_decl.
11876 Returns a FUNCTION_DECL on success.
11878 If the DECLARATOR is not suitable for a function (it defines a datum
11879 instead), we return 0, which tells yyparse to report a parse error.
11881 May return void_type_node indicating that this method is actually
11882 a friend. See grokfield for more details.
11884 Came here with a `.pushlevel' .
11886 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
11887 CHANGES TO CODE IN `grokfield'. */
11890 start_method (cp_decl_specifier_seq *declspecs,
11891 const cp_declarator *declarator, tree attrlist)
11893 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
11896 if (fndecl == error_mark_node)
11897 return error_mark_node;
11899 if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
11901 error ("invalid member function declaration");
11902 return error_mark_node;
11906 cplus_decl_attributes (&fndecl, attrlist, 0);
11908 /* Pass friends other than inline friend functions back. */
11909 if (fndecl == void_type_node)
11912 if (DECL_IN_AGGR_P (fndecl))
11914 if (DECL_CONTEXT (fndecl)
11915 && TREE_CODE (DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
11916 error ("%qD is already defined in class %qT", fndecl,
11917 DECL_CONTEXT (fndecl));
11918 return error_mark_node;
11921 check_template_shadow (fndecl);
11923 DECL_DECLARED_INLINE_P (fndecl) = 1;
11924 if (flag_default_inline)
11925 DECL_INLINE (fndecl) = 1;
11927 /* We process method specializations in finish_struct_1. */
11928 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
11930 fndecl = push_template_decl (fndecl);
11931 if (fndecl == error_mark_node)
11935 if (! DECL_FRIEND_P (fndecl))
11937 if (TREE_CHAIN (fndecl))
11939 fndecl = copy_node (fndecl);
11940 TREE_CHAIN (fndecl) = NULL_TREE;
11944 finish_decl (fndecl, NULL_TREE, NULL_TREE);
11946 /* Make a place for the parms. */
11947 begin_scope (sk_function_parms, fndecl);
11949 DECL_IN_AGGR_P (fndecl) = 1;
11953 /* Go through the motions of finishing a function definition.
11954 We don't compile this method until after the whole class has
11957 FINISH_METHOD must return something that looks as though it
11958 came from GROKFIELD (since we are defining a method, after all).
11960 This is called after parsing the body of the function definition.
11961 STMTS is the chain of statements that makes up the function body.
11963 DECL is the ..._DECL that `start_method' provided. */
11966 finish_method (tree decl)
11968 tree fndecl = decl;
11973 if (decl == void_type_node)
11976 old_initial = DECL_INITIAL (fndecl);
11978 /* Undo the level for the parms (from start_method).
11979 This is like poplevel, but it causes nothing to be
11980 saved. Saving information here confuses symbol-table
11981 output routines. Besides, this information will
11982 be correctly output when this method is actually
11985 /* Clear out the meanings of the local variables of this level;
11986 also record in each decl which block it belongs to. */
11988 for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
11990 if (DECL_NAME (link) != NULL_TREE)
11991 pop_binding (DECL_NAME (link), link);
11992 gcc_assert (TREE_CODE (link) != FUNCTION_DECL);
11993 DECL_CONTEXT (link) = NULL_TREE;
11996 poplevel (0, 0, 0);
11998 DECL_INITIAL (fndecl) = old_initial;
12000 /* We used to check if the context of FNDECL was different from
12001 current_class_type as another way to get inside here. This didn't work
12002 for String.cc in libg++. */
12003 if (DECL_FRIEND_P (fndecl))
12005 VEC_safe_push (tree, gc, CLASSTYPE_INLINE_FRIENDS (current_class_type),
12007 decl = void_type_node;
12014 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
12015 we can lay it out later, when and if its type becomes complete. */
12018 maybe_register_incomplete_var (tree var)
12020 gcc_assert (TREE_CODE (var) == VAR_DECL);
12022 /* Keep track of variables with incomplete types. */
12023 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
12024 && DECL_EXTERNAL (var))
12026 tree inner_type = TREE_TYPE (var);
12028 while (TREE_CODE (inner_type) == ARRAY_TYPE)
12029 inner_type = TREE_TYPE (inner_type);
12030 inner_type = TYPE_MAIN_VARIANT (inner_type);
12032 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
12033 /* RTTI TD entries are created while defining the type_info. */
12034 || (TYPE_LANG_SPECIFIC (inner_type)
12035 && TYPE_BEING_DEFINED (inner_type)))
12036 incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
12040 /* Called when a class type (given by TYPE) is defined. If there are
12041 any existing VAR_DECLs whose type hsa been completed by this
12042 declaration, update them now. */
12045 complete_vars (tree type)
12047 tree *list = &incomplete_vars;
12049 gcc_assert (CLASS_TYPE_P (type));
12052 if (same_type_p (type, TREE_PURPOSE (*list)))
12054 tree var = TREE_VALUE (*list);
12055 tree type = TREE_TYPE (var);
12056 /* Complete the type of the variable. The VAR_DECL itself
12057 will be laid out in expand_expr. */
12058 complete_type (type);
12059 cp_apply_type_quals_to_decl (cp_type_quals (type), var);
12060 /* Remove this entry from the list. */
12061 *list = TREE_CHAIN (*list);
12064 list = &TREE_CHAIN (*list);
12067 /* Check for pending declarations which may have abstract type. */
12068 complete_type_check_abstract (type);
12071 /* If DECL is of a type which needs a cleanup, build and return an
12072 expression to perform that cleanup here. Return NULL_TREE if no
12073 cleanup need be done. */
12076 cxx_maybe_build_cleanup (tree decl)
12082 /* Assume no cleanup is required. */
12083 cleanup = NULL_TREE;
12085 if (error_operand_p (decl))
12088 /* Handle "__attribute__((cleanup))". We run the cleanup function
12089 before the destructor since the destructor is what actually
12090 terminates the lifetime of the object. */
12091 attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
12098 /* Get the name specified by the user for the cleanup function. */
12099 id = TREE_VALUE (TREE_VALUE (attr));
12100 /* Look up the name to find the cleanup function to call. It is
12101 important to use lookup_name here because that is what is
12102 used in c-common.c:handle_cleanup_attribute when performing
12103 initial checks on the attribute. Note that those checks
12104 include ensuring that the function found is not an overloaded
12105 function, or an object with an overloaded call operator,
12106 etc.; we can rely on the fact that the functionfound is an
12107 ordinary FUNCTION_DECL. */
12108 fn = lookup_name (id);
12109 arg = build_address (decl);
12111 cleanup = build_function_call (fn, build_tree_list (NULL_TREE,
12114 /* Handle ordinary C++ destructors. */
12115 type = TREE_TYPE (decl);
12116 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
12118 int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
12119 bool has_vbases = (TREE_CODE (type) == RECORD_TYPE
12120 && CLASSTYPE_VBASECLASSES (type));
12124 if (TREE_CODE (type) == ARRAY_TYPE)
12128 cxx_mark_addressable (decl);
12129 addr = build_unary_op (ADDR_EXPR, decl, 0);
12132 /* Optimize for space over speed here. */
12133 if (!has_vbases || flag_expensive_optimizations)
12134 flags |= LOOKUP_NONVIRTUAL;
12136 call = build_delete (TREE_TYPE (addr), addr,
12137 sfk_complete_destructor, flags, 0);
12139 cleanup = build_compound_expr (cleanup, call);
12147 /* When a stmt has been parsed, this function is called. */
12154 /* DECL was originally constructed as a non-static member function,
12155 but turned out to be static. Update it accordingly. */
12158 revert_static_member_fn (tree decl)
12161 tree function = TREE_TYPE (decl);
12162 tree args = TYPE_ARG_TYPES (function);
12164 if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
12165 != TYPE_UNQUALIFIED)
12166 error ("static member function %q#D declared with type qualifiers", decl);
12168 args = TREE_CHAIN (args);
12169 tmp = build_function_type (TREE_TYPE (function), args);
12170 tmp = build_qualified_type (tmp, cp_type_quals (function));
12171 tmp = build_exception_variant (tmp,
12172 TYPE_RAISES_EXCEPTIONS (function));
12173 TREE_TYPE (decl) = tmp;
12174 if (DECL_ARGUMENTS (decl))
12175 DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
12176 DECL_STATIC_FUNCTION_P (decl) = 1;
12179 /* Initialize the variables used during compilation of a C++
12183 cxx_push_function_context (struct function * f)
12185 struct language_function *p = GGC_CNEW (struct language_function);
12188 /* Whenever we start a new function, we destroy temporaries in the
12190 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
12196 if (DECL_SAVED_FUNCTION_DATA (fn))
12198 /* If we already parsed this function, and we're just expanding it
12199 now, restore saved state. */
12200 *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (fn);
12202 /* We don't need the saved data anymore. Unless this is an inline
12203 function; we need the named return value info for
12204 declare_return_variable. */
12205 if (! DECL_INLINE (fn))
12206 DECL_SAVED_FUNCTION_DATA (fn) = NULL;
12211 /* Free the language-specific parts of F, now that we've finished
12212 compiling the function. */
12215 cxx_pop_function_context (struct function * f)
12220 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
12221 one of the language-independent trees. */
12223 enum cp_tree_node_structure_enum
12224 cp_tree_node_structure (union lang_tree_node * t)
12226 switch (TREE_CODE (&t->generic))
12228 case DEFAULT_ARG: return TS_CP_DEFAULT_ARG;
12229 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER;
12230 case OVERLOAD: return TS_CP_OVERLOAD;
12231 case TEMPLATE_PARM_INDEX: return TS_CP_TPI;
12232 case PTRMEM_CST: return TS_CP_PTRMEM;
12233 case BASELINK: return TS_CP_BASELINK;
12234 case STATIC_ASSERT: return TS_CP_STATIC_ASSERT;
12235 case ARGUMENT_PACK_SELECT: return TS_CP_ARGUMENT_PACK_SELECT;
12236 case TRAIT_EXPR: return TS_CP_TRAIT_EXPR;
12237 default: return TS_CP_GENERIC;
12241 /* Build the void_list_node (void_type_node having been created). */
12243 build_void_list_node (void)
12245 tree t = build_tree_list (NULL_TREE, void_type_node);
12250 cp_missing_noreturn_ok_p (tree decl)
12252 /* A missing noreturn is ok for the `main' function. */
12253 return DECL_MAIN_P (decl);
12256 /* Return the COMDAT group into which DECL should be placed. */
12259 cxx_comdat_group (tree decl)
12263 /* Virtual tables, construction virtual tables, and virtual table
12264 tables all go in a single COMDAT group, named after the primary
12266 if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
12267 name = DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl)));
12268 /* For all other DECLs, the COMDAT group is the mangled name of the
12269 declaration itself. */
12272 while (DECL_THUNK_P (decl))
12274 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
12275 into the same section as the target function. In that case
12276 we must return target's name. */
12277 tree target = THUNK_TARGET (decl);
12278 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target)
12279 && DECL_SECTION_NAME (target) != NULL
12280 && DECL_ONE_ONLY (target))
12285 name = DECL_ASSEMBLER_NAME (decl);
12288 return IDENTIFIER_POINTER (name);
12291 #include "gt-cp-decl.h"