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, 2008, 2009
4 Free Software Foundation, Inc.
5 Contributed by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
24 /* Process declarations and symbol lookup for C++ front end.
25 Also constructs types; the standard scalar types at initialization,
26 and structure, union, array and enum types when they are declared. */
28 /* ??? not all decl nodes are given the most useful possible
29 line numbers. For example, the CONST_DECLs for enum values. */
33 #include "coretypes.h"
40 #include "tree-inline.h"
50 #include "diagnostic.h"
54 #include "tree-flow.h"
55 #include "pointer-set.h"
58 static tree grokparms (tree parmlist, tree *);
59 static const char *redeclaration_error_message (tree, tree);
61 static int decl_jump_unsafe (tree);
62 static void require_complete_types_for_parms (tree);
63 static int ambi_op_p (enum tree_code);
64 static int unary_op_p (enum tree_code);
65 static void push_local_name (tree);
66 static tree grok_reference_init (tree, tree, tree, tree *);
67 static tree grokvardecl (tree, tree, const cp_decl_specifier_seq *,
69 static void record_unknown_type (tree, const char *);
70 static tree builtin_function_1 (tree, tree, bool);
71 static tree build_library_fn_1 (tree, enum tree_code, tree);
72 static int member_function_or_else (tree, tree, enum overload_flags);
73 static void bad_specifiers (tree, const char *, int, int, int, int,
75 static void check_for_uninitialized_const_var (tree);
76 static hashval_t typename_hash (const void *);
77 static int typename_compare (const void *, const void *);
78 static tree local_variable_p_walkfn (tree *, int *, void *);
79 static tree record_builtin_java_type (const char *, int);
80 static const char *tag_name (enum tag_types);
81 static tree lookup_and_check_tag (enum tag_types, tree, tag_scope, bool);
82 static int walk_namespaces_r (tree, walk_namespaces_fn, void *);
83 static void maybe_deduce_size_from_array_init (tree, tree);
84 static void layout_var_decl (tree);
85 static tree check_initializer (tree, tree, int, tree *);
86 static void make_rtl_for_nonlocal_decl (tree, tree, const char *);
87 static void save_function_data (tree);
88 static void check_function_type (tree, tree);
89 static void finish_constructor_body (void);
90 static void begin_destructor_body (void);
91 static void finish_destructor_body (void);
92 static tree create_array_type_for_decl (tree, tree, tree);
93 static tree get_atexit_node (void);
94 static tree get_dso_handle_node (void);
95 static tree start_cleanup_fn (void);
96 static void end_cleanup_fn (void);
97 static tree cp_make_fname_decl (tree, int);
98 static void initialize_predefined_identifiers (void);
99 static tree check_special_function_return_type
100 (special_function_kind, tree, tree);
101 static tree push_cp_library_fn (enum tree_code, tree);
102 static tree build_cp_library_fn (tree, enum tree_code, tree);
103 static void store_parm_decls (tree);
104 static void initialize_local_var (tree, tree);
105 static void expand_static_init (tree, tree);
106 static tree next_initializable_field (tree);
108 /* The following symbols are subsumed in the cp_global_trees array, and
109 listed here individually for documentation purposes.
112 tree wchar_decl_node;
114 tree vtable_entry_type;
115 tree delta_type_node;
116 tree __t_desc_type_node;
118 tree class_type_node;
119 tree unknown_type_node;
121 Array type `vtable_entry_type[]'
124 tree vtbl_ptr_type_node;
131 A FUNCTION_DECL which can call `abort'. Not necessarily the
132 one that the user will declare, but sufficient to be called
133 by routines that want to abort the program.
137 The FUNCTION_DECL for the default `::operator delete'.
139 tree global_delete_fndecl;
142 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
143 tree tinfo_var_id; */
145 tree cp_global_trees[CPTI_MAX];
147 /* Indicates that there is a type value in some namespace, although
148 that is not necessarily in scope at the moment. */
150 tree global_type_node;
152 /* The node that holds the "name" of the global scope. */
153 tree global_scope_name;
155 #define local_names cp_function_chain->x_local_names
157 /* A list of objects which have constructors or destructors
158 which reside in the global scope. The decl is stored in
159 the TREE_VALUE slot and the initializer is stored
160 in the TREE_PURPOSE slot. */
161 tree static_aggregates;
165 /* A node for the integer constants 2, and 3. */
167 tree integer_two_node, integer_three_node;
169 /* Used only for jumps to as-yet undefined labels, since jumps to
170 defined labels can have their validity checked immediately. */
172 struct named_label_use_entry GTY(())
174 struct named_label_use_entry *next;
175 /* The binding level to which this entry is *currently* attached.
176 This is initially the binding level in which the goto appeared,
177 but is modified as scopes are closed. */
178 struct cp_binding_level *binding_level;
179 /* The head of the names list that was current when the goto appeared,
180 or the inner scope popped. These are the decls that will *not* be
181 skipped when jumping to the label. */
183 /* The location of the goto, for error reporting. */
184 location_t o_goto_locus;
185 /* True if an OpenMP structured block scope has been closed since
186 the goto appeared. This means that the branch from the label will
187 illegally exit an OpenMP scope. */
191 /* A list of all LABEL_DECLs in the function that have names. Here so
192 we can clear out their names' definitions at the end of the
193 function, and so we can check the validity of jumps to these labels. */
195 struct named_label_entry GTY(())
197 /* The decl itself. */
200 /* The binding level to which the label is *currently* attached.
201 This is initially set to the binding level in which the label
202 is defined, but is modified as scopes are closed. */
203 struct cp_binding_level *binding_level;
204 /* The head of the names list that was current when the label was
205 defined, or the inner scope popped. These are the decls that will
206 be skipped when jumping to the label. */
208 /* A tree list of all decls from all binding levels that would be
209 crossed by a backward branch to the label. */
212 /* A list of uses of the label, before the label is defined. */
213 struct named_label_use_entry *uses;
215 /* The following bits are set after the label is defined, and are
216 updated as scopes are popped. They indicate that a backward jump
217 to the label will illegally enter a scope of the given flavor. */
223 #define named_labels cp_function_chain->x_named_labels
225 /* The number of function bodies which we are currently processing.
226 (Zero if we are at namespace scope, one inside the body of a
227 function, two inside the body of a function in a local class, etc.) */
230 /* To avoid unwanted recursion, finish_function defers all mark_used calls
231 encountered during its execution until it finishes. */
232 bool defer_mark_used_calls;
233 VEC(tree, gc) *deferred_mark_used_calls;
235 /* States indicating how grokdeclarator() should handle declspecs marked
236 with __attribute__((deprecated)). An object declared as
237 __attribute__((deprecated)) suppresses warnings of uses of other
239 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' matches 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 location = input_location; /* FIXME want (input_filename, (line)0) */
360 /* Avoid crashing later. */
361 define_label (location, DECL_NAME (label));
364 warn_for_unused_label (label);
367 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
370 /* At the end of a function, all labels declared within the function
371 go out of scope. BLOCK is the top-level block for the
375 pop_labels_1 (void **slot, void *data)
377 struct named_label_entry *ent = (struct named_label_entry *) *slot;
378 tree block = (tree) data;
380 pop_label (ent->label_decl, NULL_TREE);
382 /* Put the labels into the "variables" of the top-level block,
383 so debugger can see them. */
384 TREE_CHAIN (ent->label_decl) = BLOCK_VARS (block);
385 BLOCK_VARS (block) = ent->label_decl;
387 htab_clear_slot (named_labels, slot);
393 pop_labels (tree block)
397 htab_traverse (named_labels, pop_labels_1, block);
402 /* At the end of a block with local labels, restore the outer definition. */
405 pop_local_label (tree label, tree old_value)
407 struct named_label_entry dummy;
410 pop_label (label, old_value);
412 dummy.label_decl = label;
413 slot = htab_find_slot (named_labels, &dummy, NO_INSERT);
414 htab_clear_slot (named_labels, slot);
417 /* The following two routines are used to interface to Objective-C++.
418 The binding level is purposely treated as an opaque type. */
421 objc_get_current_scope (void)
423 return current_binding_level;
426 /* The following routine is used by the NeXT-style SJLJ exceptions;
427 variables get marked 'volatile' so as to not be clobbered by
428 _setjmp()/_longjmp() calls. All variables in the current scope,
429 as well as parent scopes up to (but not including) ENCLOSING_BLK
430 shall be thusly marked. */
433 objc_mark_locals_volatile (void *enclosing_blk)
435 struct cp_binding_level *scope;
437 for (scope = current_binding_level;
438 scope && scope != enclosing_blk;
439 scope = scope->level_chain)
443 for (decl = scope->names; decl; decl = TREE_CHAIN (decl))
444 objc_volatilize_decl (decl);
446 /* Do not climb up past the current function. */
447 if (scope->kind == sk_function_parms)
452 /* Update data for defined and undefined labels when leaving a scope. */
455 poplevel_named_label_1 (void **slot, void *data)
457 struct named_label_entry *ent = (struct named_label_entry *) *slot;
458 struct cp_binding_level *bl = (struct cp_binding_level *) data;
459 struct cp_binding_level *obl = bl->level_chain;
461 if (ent->binding_level == bl)
465 for (decl = ent->names_in_scope; decl; decl = TREE_CHAIN (decl))
466 if (decl_jump_unsafe (decl))
467 ent->bad_decls = tree_cons (NULL, decl, ent->bad_decls);
469 ent->binding_level = obl;
470 ent->names_in_scope = obl->names;
474 ent->in_try_scope = true;
477 ent->in_catch_scope = true;
480 ent->in_omp_scope = true;
488 struct named_label_use_entry *use;
490 for (use = ent->uses; use ; use = use->next)
491 if (use->binding_level == bl)
493 use->binding_level = obl;
494 use->names_in_scope = obl->names;
495 if (bl->kind == sk_omp)
496 use->in_omp_scope = true;
503 /* Exit a binding level.
504 Pop the level off, and restore the state of the identifier-decl mappings
505 that were in effect when this level was entered.
507 If KEEP == 1, this level had explicit declarations, so
508 and create a "block" (a BLOCK node) for the level
509 to record its declarations and subblocks for symbol table output.
511 If FUNCTIONBODY is nonzero, this level is the body of a function,
512 so create a block as if KEEP were set and also clear out all
515 If REVERSE is nonzero, reverse the order of decls before putting
516 them into the BLOCK. */
519 poplevel (int keep, int reverse, int functionbody)
522 /* The chain of decls was accumulated in reverse order.
523 Put it into forward order, just for cleanliness. */
525 int tmp = functionbody;
526 int real_functionbody;
530 int leaving_for_scope;
533 timevar_push (TV_NAME_LOOKUP);
538 gcc_assert (current_binding_level->kind != sk_class);
540 real_functionbody = (current_binding_level->kind == sk_cleanup
541 ? ((functionbody = 0), tmp) : functionbody);
542 subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
544 gcc_assert (!VEC_length(cp_class_binding,
545 current_binding_level->class_shadowed));
547 /* We used to use KEEP == 2 to indicate that the new block should go
548 at the beginning of the list of blocks at this binding level,
549 rather than the end. This hack is no longer used. */
550 gcc_assert (keep == 0 || keep == 1);
552 if (current_binding_level->keep)
555 /* Any uses of undefined labels, and any defined labels, now operate
556 under constraints of next binding contour. */
557 if (cfun && !functionbody && named_labels)
558 htab_traverse (named_labels, poplevel_named_label_1,
559 current_binding_level);
561 /* Get the decls in the order they were written.
562 Usually current_binding_level->names is in reverse order.
563 But parameter decls were previously put in forward order. */
566 current_binding_level->names
567 = decls = nreverse (current_binding_level->names);
569 decls = current_binding_level->names;
571 /* If there were any declarations or structure tags in that level,
572 or if this level is a function body,
573 create a BLOCK to record them for the life of this function. */
575 if (keep == 1 || functionbody)
576 block = make_node (BLOCK);
577 if (block != NULL_TREE)
579 BLOCK_VARS (block) = decls;
580 BLOCK_SUBBLOCKS (block) = subblocks;
583 /* In each subblock, record that this is its superior. */
585 for (link = subblocks; link; link = BLOCK_CHAIN (link))
586 BLOCK_SUPERCONTEXT (link) = block;
588 /* We still support the old for-scope rules, whereby the variables
589 in a for-init statement were in scope after the for-statement
590 ended. We only use the new rules if flag_new_for_scope is
593 = current_binding_level->kind == sk_for && flag_new_for_scope == 1;
595 /* Before we remove the declarations first check for unused variables. */
596 if (warn_unused_variable
597 && !processing_template_decl)
598 for (decl = getdecls (); decl; decl = TREE_CHAIN (decl))
599 if (TREE_CODE (decl) == VAR_DECL
600 && ! TREE_USED (decl)
601 && ! DECL_IN_SYSTEM_HEADER (decl)
602 && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl))
603 warning (OPT_Wunused_variable, "unused variable %q+D", decl);
605 /* Remove declarations for all the DECLs in this level. */
606 for (link = decls; link; link = TREE_CHAIN (link))
608 if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
611 tree name = DECL_NAME (link);
615 ob = outer_binding (name,
616 IDENTIFIER_BINDING (name),
619 ns_binding = IDENTIFIER_NAMESPACE_VALUE (name);
621 ns_binding = NULL_TREE;
623 if (ob && ob->scope == current_binding_level->level_chain)
624 /* We have something like:
629 and we are leaving the `for' scope. There's no reason to
630 keep the binding of the inner `i' in this case. */
631 pop_binding (name, link);
632 else if ((ob && (TREE_CODE (ob->value) == TYPE_DECL))
633 || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL))
634 /* Here, we have something like:
642 We must pop the for-scope binding so we know what's a
643 type and what isn't. */
644 pop_binding (name, link);
647 /* Mark this VAR_DECL as dead so that we can tell we left it
648 there only for backward compatibility. */
649 DECL_DEAD_FOR_LOCAL (link) = 1;
651 /* Keep track of what should have happened when we
652 popped the binding. */
655 SET_DECL_SHADOWED_FOR_VAR (link, ob->value);
656 DECL_HAS_SHADOWED_FOR_VAR_P (link) = 1;
659 /* Add it to the list of dead variables in the next
660 outermost binding to that we can remove these when we
661 leave that binding. */
662 current_binding_level->level_chain->dead_vars_from_for
663 = tree_cons (NULL_TREE, link,
664 current_binding_level->level_chain->
667 /* Although we don't pop the cxx_binding, we do clear
668 its SCOPE since the scope is going away now. */
669 IDENTIFIER_BINDING (name)->scope
670 = current_binding_level->level_chain;
677 /* Remove the binding. */
680 if (TREE_CODE (decl) == TREE_LIST)
681 decl = TREE_VALUE (decl);
684 if (TREE_CODE (name) == OVERLOAD)
685 name = OVL_FUNCTION (name);
687 gcc_assert (DECL_P (name));
688 pop_binding (DECL_NAME (name), decl);
692 /* Remove declarations for any `for' variables from inner scopes
693 that we kept around. */
694 for (link = current_binding_level->dead_vars_from_for;
695 link; link = TREE_CHAIN (link))
696 pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
698 /* Restore the IDENTIFIER_TYPE_VALUEs. */
699 for (link = current_binding_level->type_shadowed;
700 link; link = TREE_CHAIN (link))
701 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
703 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
704 for (link = current_binding_level->shadowed_labels;
706 link = TREE_CHAIN (link))
707 pop_local_label (TREE_VALUE (link), TREE_PURPOSE (link));
709 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
710 list if a `using' declaration put them there. The debugging
711 back ends won't understand OVERLOAD, so we remove them here.
712 Because the BLOCK_VARS are (temporarily) shared with
713 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
714 popped all the bindings. */
719 for (d = &BLOCK_VARS (block); *d; )
721 if (TREE_CODE (*d) == TREE_LIST)
722 *d = TREE_CHAIN (*d);
724 d = &TREE_CHAIN (*d);
728 /* If the level being exited is the top level of a function,
729 check over all the labels. */
732 /* Since this is the top level block of a function, the vars are
733 the function's parameters. Don't leave them in the BLOCK
734 because they are found in the FUNCTION_DECL instead. */
735 BLOCK_VARS (block) = 0;
739 kind = current_binding_level->kind;
740 if (kind == sk_cleanup)
744 /* If this is a temporary binding created for a cleanup, then we'll
745 have pushed a statement list level. Pop that, create a new
746 BIND_EXPR for the block, and insert it into the stream. */
747 stmt = pop_stmt_list (current_binding_level->statement_list);
748 stmt = c_build_bind_expr (block, stmt);
755 /* The current function is being defined, so its DECL_INITIAL
756 should be error_mark_node. */
757 gcc_assert (DECL_INITIAL (current_function_decl) == error_mark_node);
758 DECL_INITIAL (current_function_decl) = block;
761 current_binding_level->blocks
762 = chainon (current_binding_level->blocks, block);
764 /* If we did not make a block for the level just exited,
765 any blocks made for inner levels
766 (since they cannot be recorded as subblocks in that level)
767 must be carried forward so they will later become subblocks
768 of something else. */
770 current_binding_level->blocks
771 = chainon (current_binding_level->blocks, subblocks);
773 /* Each and every BLOCK node created here in `poplevel' is important
774 (e.g. for proper debugging information) so if we created one
775 earlier, mark it as "used". */
777 TREE_USED (block) = 1;
779 /* All temporary bindings created for cleanups are popped silently. */
780 if (kind == sk_cleanup)
783 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, block);
786 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
787 itself, calling F for each. The DATA is passed to F as well. */
790 walk_namespaces_r (tree name_space, walk_namespaces_fn f, void* data)
793 tree current = NAMESPACE_LEVEL (name_space)->namespaces;
795 result |= (*f) (name_space, data);
797 for (; current; current = TREE_CHAIN (current))
798 result |= walk_namespaces_r (current, f, data);
803 /* Walk all the namespaces, calling F for each. The DATA is passed to
807 walk_namespaces (walk_namespaces_fn f, void* data)
809 return walk_namespaces_r (global_namespace, f, data);
812 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
813 DATA is non-NULL, this is the last time we will call
814 wrapup_global_declarations for this NAMESPACE. */
817 wrapup_globals_for_namespace (tree name_space, void* data)
819 struct cp_binding_level *level = NAMESPACE_LEVEL (name_space);
820 VEC(tree,gc) *statics = level->static_decls;
821 tree *vec = VEC_address (tree, statics);
822 int len = VEC_length (tree, statics);
823 int last_time = (data != 0);
827 check_global_declarations (vec, len);
828 emit_debug_global_declarations (vec, len);
832 /* Write out any globals that need to be output. */
833 return wrapup_global_declarations (vec, len);
837 /* In C++, you don't have to write `struct S' to refer to `S'; you
838 can just use `S'. We accomplish this by creating a TYPE_DECL as
839 if the user had written `typedef struct S S'. Create and return
840 the TYPE_DECL for TYPE. */
843 create_implicit_typedef (tree name, tree type)
847 decl = build_decl (TYPE_DECL, name, type);
848 DECL_ARTIFICIAL (decl) = 1;
849 /* There are other implicit type declarations, like the one *within*
850 a class that allows you to write `S::S'. We must distinguish
852 SET_DECL_IMPLICIT_TYPEDEF_P (decl);
853 TYPE_NAME (type) = decl;
858 /* Remember a local name for name-mangling purposes. */
861 push_local_name (tree decl)
866 timevar_push (TV_NAME_LOOKUP);
868 name = DECL_NAME (decl);
870 nelts = VEC_length (tree, local_names);
871 for (i = 0; i < nelts; i++)
873 t = VEC_index (tree, local_names, i);
874 if (DECL_NAME (t) == name)
876 if (!DECL_LANG_SPECIFIC (decl))
877 retrofit_lang_decl (decl);
878 DECL_LANG_SPECIFIC (decl)->decl_flags.u2sel = 1;
879 if (DECL_LANG_SPECIFIC (t))
880 DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
882 DECL_DISCRIMINATOR (decl) = 1;
884 VEC_replace (tree, local_names, i, decl);
885 timevar_pop (TV_NAME_LOOKUP);
890 VEC_safe_push (tree, gc, local_names, decl);
891 timevar_pop (TV_NAME_LOOKUP);
894 /* Subroutine of duplicate_decls: return truthvalue of whether
895 or not types of these decls match.
897 For C++, we must compare the parameter list so that `int' can match
898 `int&' in a parameter position, but `int&' is not confused with
902 decls_match (tree newdecl, tree olddecl)
906 if (newdecl == olddecl)
909 if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
910 /* If the two DECLs are not even the same kind of thing, we're not
911 interested in their types. */
914 if (TREE_CODE (newdecl) == FUNCTION_DECL)
916 tree f1 = TREE_TYPE (newdecl);
917 tree f2 = TREE_TYPE (olddecl);
918 tree p1 = TYPE_ARG_TYPES (f1);
919 tree p2 = TYPE_ARG_TYPES (f2);
921 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
922 && ! (DECL_EXTERN_C_P (newdecl)
923 && DECL_EXTERN_C_P (olddecl)))
926 if (TREE_CODE (f1) != TREE_CODE (f2))
929 if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
931 if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
932 && (DECL_BUILT_IN (olddecl)
933 #ifndef NO_IMPLICIT_EXTERN_C
934 || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
935 || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
939 types_match = self_promoting_args_p (p1);
940 if (p1 == void_list_node)
941 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
943 #ifndef NO_IMPLICIT_EXTERN_C
944 else if (p1 == NULL_TREE
945 && (DECL_EXTERN_C_P (olddecl)
946 && DECL_IN_SYSTEM_HEADER (olddecl)
947 && !DECL_CLASS_SCOPE_P (olddecl))
948 && (DECL_EXTERN_C_P (newdecl)
949 && DECL_IN_SYSTEM_HEADER (newdecl)
950 && !DECL_CLASS_SCOPE_P (newdecl)))
952 types_match = self_promoting_args_p (p2);
953 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
957 types_match = compparms (p1, p2);
962 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
964 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
965 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
968 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
969 DECL_TEMPLATE_PARMS (olddecl)))
972 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
973 types_match = same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)),
974 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl)));
976 types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
977 DECL_TEMPLATE_RESULT (newdecl));
981 /* Need to check scope for variable declaration (VAR_DECL).
982 For typedef (TYPE_DECL), scope is ignored. */
983 if (TREE_CODE (newdecl) == VAR_DECL
984 && CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
986 Two declarations for an object with C language linkage
987 with the same name (ignoring the namespace that qualify
988 it) that appear in different namespace scopes refer to
990 && !(DECL_EXTERN_C_P (olddecl) && DECL_EXTERN_C_P (newdecl)))
993 if (TREE_TYPE (newdecl) == error_mark_node)
994 types_match = TREE_TYPE (olddecl) == error_mark_node;
995 else if (TREE_TYPE (olddecl) == NULL_TREE)
996 types_match = TREE_TYPE (newdecl) == NULL_TREE;
997 else if (TREE_TYPE (newdecl) == NULL_TREE)
1000 types_match = comptypes (TREE_TYPE (newdecl),
1001 TREE_TYPE (olddecl),
1002 COMPARE_REDECLARATION);
1008 /* If NEWDECL is `static' and an `extern' was seen previously,
1009 warn about it. OLDDECL is the previous declaration.
1011 Note that this does not apply to the C++ case of declaring
1012 a variable `extern const' and then later `const'.
1014 Don't complain about built-in functions, since they are beyond
1015 the user's control. */
1018 warn_extern_redeclared_static (tree newdecl, tree olddecl)
1022 if (TREE_CODE (newdecl) == TYPE_DECL
1023 || TREE_CODE (newdecl) == TEMPLATE_DECL
1024 || TREE_CODE (newdecl) == CONST_DECL
1025 || TREE_CODE (newdecl) == NAMESPACE_DECL)
1028 /* Don't get confused by static member functions; that's a different
1030 if (TREE_CODE (newdecl) == FUNCTION_DECL
1031 && DECL_STATIC_FUNCTION_P (newdecl))
1034 /* If the old declaration was `static', or the new one isn't, then
1035 then everything is OK. */
1036 if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
1039 /* It's OK to declare a builtin function as `static'. */
1040 if (TREE_CODE (olddecl) == FUNCTION_DECL
1041 && DECL_ARTIFICIAL (olddecl))
1044 name = DECL_ASSEMBLER_NAME (newdecl);
1045 permerror (input_location, "%qD was declared %<extern%> and later %<static%>", newdecl);
1046 permerror (input_location, "previous declaration of %q+D", olddecl);
1049 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1050 function templates. If their exception specifications do not
1051 match, issue a diagnostic. */
1054 check_redeclaration_exception_specification (tree new_decl,
1059 tree new_exceptions;
1060 tree old_exceptions;
1062 new_type = TREE_TYPE (new_decl);
1063 new_exceptions = TYPE_RAISES_EXCEPTIONS (new_type);
1064 old_type = TREE_TYPE (old_decl);
1065 old_exceptions = TYPE_RAISES_EXCEPTIONS (old_type);
1069 If any declaration of a function has an exception-specification,
1070 all declarations, including the definition and an explicit
1071 specialization, of that function shall have an
1072 exception-specification with the same set of type-ids. */
1073 if ((pedantic || ! DECL_IN_SYSTEM_HEADER (old_decl))
1074 && ! DECL_IS_BUILTIN (old_decl)
1076 && !comp_except_specs (new_exceptions, old_exceptions,
1079 error ("declaration of %qF throws different exceptions", new_decl);
1080 error ("from previous declaration %q+F", old_decl);
1084 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1085 && lookup_attribute ("gnu_inline", \
1086 DECL_ATTRIBUTES (fn)))
1088 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1089 If the redeclaration is invalid, a diagnostic is issued, and the
1090 error_mark_node is returned. Otherwise, OLDDECL is returned.
1092 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1095 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1098 duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend)
1100 unsigned olddecl_uid = DECL_UID (olddecl);
1101 int olddecl_friend = 0, types_match = 0, hidden_friend = 0;
1102 int new_defines_function = 0;
1105 if (newdecl == olddecl)
1108 types_match = decls_match (newdecl, olddecl);
1110 /* If either the type of the new decl or the type of the old decl is an
1111 error_mark_node, then that implies that we have already issued an
1112 error (earlier) for some bogus type specification, and in that case,
1113 it is rather pointless to harass the user with yet more error message
1114 about the same declaration, so just pretend the types match here. */
1115 if (TREE_TYPE (newdecl) == error_mark_node
1116 || TREE_TYPE (olddecl) == error_mark_node)
1117 return error_mark_node;
1119 if (DECL_P (olddecl)
1120 && TREE_CODE (newdecl) == FUNCTION_DECL
1121 && TREE_CODE (olddecl) == FUNCTION_DECL
1122 && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
1124 if (DECL_DECLARED_INLINE_P (newdecl)
1125 && DECL_UNINLINABLE (newdecl)
1126 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1127 /* Already warned elsewhere. */;
1128 else if (DECL_DECLARED_INLINE_P (olddecl)
1129 && DECL_UNINLINABLE (olddecl)
1130 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1131 /* Already warned. */;
1132 else if (DECL_DECLARED_INLINE_P (newdecl)
1133 && DECL_UNINLINABLE (olddecl)
1134 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1136 warning (OPT_Wattributes, "function %q+D redeclared as inline",
1138 warning (OPT_Wattributes, "previous declaration of %q+D "
1139 "with attribute noinline", olddecl);
1141 else if (DECL_DECLARED_INLINE_P (olddecl)
1142 && DECL_UNINLINABLE (newdecl)
1143 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1145 warning (OPT_Wattributes, "function %q+D redeclared with "
1146 "attribute noinline", newdecl);
1147 warning (OPT_Wattributes, "previous declaration of %q+D was inline",
1152 /* Check for redeclaration and other discrepancies. */
1153 if (TREE_CODE (olddecl) == FUNCTION_DECL
1154 && DECL_ARTIFICIAL (olddecl))
1156 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl));
1157 if (TREE_CODE (newdecl) != FUNCTION_DECL)
1159 /* Avoid warnings redeclaring built-ins which have not been
1160 explicitly declared. */
1161 if (DECL_ANTICIPATED (olddecl))
1164 /* If you declare a built-in or predefined function name as static,
1165 the old definition is overridden, but optionally warn this was a
1166 bad choice of name. */
1167 if (! TREE_PUBLIC (newdecl))
1169 warning (OPT_Wshadow, "shadowing %s function %q#D",
1170 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
1172 /* Discard the old built-in function. */
1175 /* If the built-in is not ansi, then programs can override
1176 it even globally without an error. */
1177 else if (! DECL_BUILT_IN (olddecl))
1178 warning (0, "library function %q#D redeclared as non-function %q#D",
1182 error ("declaration of %q#D", newdecl);
1183 error ("conflicts with built-in declaration %q#D",
1188 else if (!types_match)
1190 /* Avoid warnings redeclaring built-ins which have not been
1191 explicitly declared. */
1192 if (DECL_ANTICIPATED (olddecl))
1194 /* Deal with fileptr_type_node. FILE type is not known
1195 at the time we create the builtins. */
1198 for (t1 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1199 t2 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1201 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1204 else if (TREE_VALUE (t2) == fileptr_type_node)
1206 tree t = TREE_VALUE (t1);
1208 if (TREE_CODE (t) == POINTER_TYPE
1209 && TYPE_NAME (TREE_TYPE (t))
1210 && DECL_NAME (TYPE_NAME (TREE_TYPE (t)))
1211 == get_identifier ("FILE")
1212 && compparms (TREE_CHAIN (t1), TREE_CHAIN (t2)))
1214 tree oldargs = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1216 TYPE_ARG_TYPES (TREE_TYPE (olddecl))
1217 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1218 types_match = decls_match (newdecl, olddecl);
1220 return duplicate_decls (newdecl, olddecl,
1222 TYPE_ARG_TYPES (TREE_TYPE (olddecl)) = oldargs;
1225 else if (! same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1228 else if ((DECL_EXTERN_C_P (newdecl)
1229 && DECL_EXTERN_C_P (olddecl))
1230 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1231 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1233 /* A near match; override the builtin. */
1235 if (TREE_PUBLIC (newdecl))
1237 warning (0, "new declaration %q#D", newdecl);
1238 warning (0, "ambiguates built-in declaration %q#D",
1242 warning (OPT_Wshadow, "shadowing %s function %q#D",
1243 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
1247 /* Discard the old built-in function. */
1250 /* Replace the old RTL to avoid problems with inlining. */
1251 COPY_DECL_RTL (newdecl, olddecl);
1253 /* Even if the types match, prefer the new declarations type for
1254 built-ins which have not been explicitly declared, for
1255 exception lists, etc... */
1256 else if (DECL_ANTICIPATED (olddecl))
1258 tree type = TREE_TYPE (newdecl);
1259 tree attribs = (*targetm.merge_type_attributes)
1260 (TREE_TYPE (olddecl), type);
1262 type = cp_build_type_attribute_variant (type, attribs);
1263 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = type;
1266 /* If a function is explicitly declared "throw ()", propagate that to
1267 the corresponding builtin. */
1268 if (DECL_BUILT_IN_CLASS (olddecl) == BUILT_IN_NORMAL
1269 && DECL_ANTICIPATED (olddecl)
1270 && TREE_NOTHROW (newdecl)
1271 && !TREE_NOTHROW (olddecl)
1272 && built_in_decls [DECL_FUNCTION_CODE (olddecl)] != NULL_TREE
1273 && built_in_decls [DECL_FUNCTION_CODE (olddecl)] != olddecl
1275 TREE_NOTHROW (built_in_decls [DECL_FUNCTION_CODE (olddecl)]) = 1;
1277 /* Whether or not the builtin can throw exceptions has no
1278 bearing on this declarator. */
1279 TREE_NOTHROW (olddecl) = 0;
1281 if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
1283 /* If a builtin function is redeclared as `static', merge
1284 the declarations, but make the original one static. */
1285 DECL_THIS_STATIC (olddecl) = 1;
1286 TREE_PUBLIC (olddecl) = 0;
1288 /* Make the old declaration consistent with the new one so
1289 that all remnants of the builtin-ness of this function
1290 will be banished. */
1291 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1292 COPY_DECL_RTL (newdecl, olddecl);
1295 else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1297 /* C++ Standard, 3.3, clause 4:
1298 "[Note: a namespace name or a class template name must be unique
1299 in its declarative region (7.3.2, clause 14). ]" */
1300 if (TREE_CODE (olddecl) != NAMESPACE_DECL
1301 && TREE_CODE (newdecl) != NAMESPACE_DECL
1302 && (TREE_CODE (olddecl) != TEMPLATE_DECL
1303 || TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) != TYPE_DECL)
1304 && (TREE_CODE (newdecl) != TEMPLATE_DECL
1305 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != TYPE_DECL))
1307 if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
1308 && TREE_CODE (newdecl) != TYPE_DECL)
1309 || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
1310 && TREE_CODE (olddecl) != TYPE_DECL))
1312 /* We do nothing special here, because C++ does such nasty
1313 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1314 get shadowed, and know that if we need to find a TYPE_DECL
1315 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1316 slot of the identifier. */
1320 if ((TREE_CODE (newdecl) == FUNCTION_DECL
1321 && DECL_FUNCTION_TEMPLATE_P (olddecl))
1322 || (TREE_CODE (olddecl) == FUNCTION_DECL
1323 && DECL_FUNCTION_TEMPLATE_P (newdecl)))
1327 error ("%q#D redeclared as different kind of symbol", newdecl);
1328 if (TREE_CODE (olddecl) == TREE_LIST)
1329 olddecl = TREE_VALUE (olddecl);
1330 error ("previous declaration of %q+#D", olddecl);
1332 return error_mark_node;
1334 else if (!types_match)
1336 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
1337 /* These are certainly not duplicate declarations; they're
1338 from different scopes. */
1341 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1343 /* The name of a class template may not be declared to refer to
1344 any other template, class, function, object, namespace, value,
1345 or type in the same scope. */
1346 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
1347 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1349 error ("declaration of template %q#D", newdecl);
1350 error ("conflicts with previous declaration %q+#D", olddecl);
1352 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
1353 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
1354 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
1355 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
1356 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1357 DECL_TEMPLATE_PARMS (olddecl))
1358 /* Template functions can be disambiguated by
1360 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
1361 TREE_TYPE (TREE_TYPE (olddecl))))
1363 error ("new declaration %q#D", newdecl);
1364 error ("ambiguates old declaration %q+#D", olddecl);
1368 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1370 if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
1372 error ("declaration of C function %q#D conflicts with",
1374 error ("previous declaration %q+#D here", olddecl);
1376 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1377 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1379 error ("new declaration %q#D", newdecl);
1380 error ("ambiguates old declaration %q+#D", olddecl);
1381 return error_mark_node;
1388 error ("conflicting declaration %q#D", newdecl);
1389 error ("%q+D has a previous declaration as %q#D", olddecl, olddecl);
1390 return error_mark_node;
1393 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1394 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
1395 && (!DECL_TEMPLATE_INFO (newdecl)
1396 || (DECL_TI_TEMPLATE (newdecl)
1397 != DECL_TI_TEMPLATE (olddecl))))
1398 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
1399 && (!DECL_TEMPLATE_INFO (olddecl)
1400 || (DECL_TI_TEMPLATE (olddecl)
1401 != DECL_TI_TEMPLATE (newdecl))))))
1402 /* It's OK to have a template specialization and a non-template
1403 with the same type, or to have specializations of two
1404 different templates with the same type. Note that if one is a
1405 specialization, and the other is an instantiation of the same
1406 template, that we do not exit at this point. That situation
1407 can occur if we instantiate a template class, and then
1408 specialize one of its methods. This situation is valid, but
1409 the declarations must be merged in the usual way. */
1411 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1412 && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
1413 && !DECL_USE_TEMPLATE (newdecl))
1414 || (DECL_TEMPLATE_INSTANTIATION (newdecl)
1415 && !DECL_USE_TEMPLATE (olddecl))))
1416 /* One of the declarations is a template instantiation, and the
1417 other is not a template at all. That's OK. */
1419 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1421 /* In [namespace.alias] we have:
1423 In a declarative region, a namespace-alias-definition can be
1424 used to redefine a namespace-alias declared in that declarative
1425 region to refer only to the namespace to which it already
1428 Therefore, if we encounter a second alias directive for the same
1429 alias, we can just ignore the second directive. */
1430 if (DECL_NAMESPACE_ALIAS (newdecl)
1431 && (DECL_NAMESPACE_ALIAS (newdecl)
1432 == DECL_NAMESPACE_ALIAS (olddecl)))
1434 /* [namespace.alias]
1436 A namespace-name or namespace-alias shall not be declared as
1437 the name of any other entity in the same declarative region.
1438 A namespace-name defined at global scope shall not be
1439 declared as the name of any other entity in any global scope
1441 error ("declaration of namespace %qD conflicts with", newdecl);
1442 error ("previous declaration of namespace %q+D here", olddecl);
1443 return error_mark_node;
1447 const char *errmsg = redeclaration_error_message (newdecl, olddecl);
1450 error_at (DECL_SOURCE_LOCATION (newdecl), errmsg, newdecl);
1451 if (DECL_NAME (olddecl) != NULL_TREE)
1452 error ((DECL_INITIAL (olddecl) && namespace_bindings_p ())
1453 ? "%q+#D previously defined here"
1454 : "%q+#D previously declared here", olddecl);
1455 return error_mark_node;
1457 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1458 && DECL_INITIAL (olddecl) != NULL_TREE
1459 && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
1460 && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
1462 /* Prototype decl follows defn w/o prototype. */
1463 warning (0, "prototype for %q+#D", newdecl);
1464 warning (0, "%Jfollows non-prototype definition here", olddecl);
1466 else if ((TREE_CODE (olddecl) == FUNCTION_DECL
1467 || TREE_CODE (olddecl) == VAR_DECL)
1468 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
1471 If two declarations of the same function or object
1472 specify different linkage-specifications ..., the program
1473 is ill-formed.... Except for functions with C++ linkage,
1474 a function declaration without a linkage specification
1475 shall not precede the first linkage specification for
1476 that function. A function can be declared without a
1477 linkage specification after an explicit linkage
1478 specification has been seen; the linkage explicitly
1479 specified in the earlier declaration is not affected by
1480 such a function declaration.
1482 DR 563 raises the question why the restrictions on
1483 functions should not also apply to objects. Older
1484 versions of G++ silently ignore the linkage-specification
1492 which is clearly wrong. Therefore, we now treat objects
1494 if (current_lang_depth () == 0)
1496 /* There is no explicit linkage-specification, so we use
1497 the linkage from the previous declaration. */
1498 if (!DECL_LANG_SPECIFIC (newdecl))
1499 retrofit_lang_decl (newdecl);
1500 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1504 error ("previous declaration of %q+#D with %qL linkage",
1505 olddecl, DECL_LANGUAGE (olddecl));
1506 error ("conflicts with new declaration with %qL linkage",
1507 DECL_LANGUAGE (newdecl));
1511 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
1513 else if (TREE_CODE (olddecl) == FUNCTION_DECL)
1515 tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1516 tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1519 if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
1520 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
1522 for (; t1 && t1 != void_list_node;
1523 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
1524 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
1526 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
1529 permerror (input_location, "default argument given for parameter %d of %q#D",
1531 permerror (input_location, "after previous specification in %q+#D", olddecl);
1535 error ("default argument given for parameter %d of %q#D",
1537 error ("after previous specification in %q+#D",
1544 /* Do not merge an implicit typedef with an explicit one. In:
1548 typedef class A A __attribute__ ((foo));
1550 the attribute should apply only to the typedef. */
1551 if (TREE_CODE (olddecl) == TYPE_DECL
1552 && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
1553 || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
1556 /* If new decl is `static' and an `extern' was seen previously,
1558 warn_extern_redeclared_static (newdecl, olddecl);
1560 /* We have committed to returning 1 at this point. */
1561 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1563 /* Now that functions must hold information normally held
1564 by field decls, there is extra work to do so that
1565 declaration information does not get destroyed during
1567 if (DECL_VINDEX (olddecl))
1568 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
1569 if (DECL_CONTEXT (olddecl))
1570 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1571 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
1572 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1573 DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
1574 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
1575 DECL_INVALID_OVERRIDER_P (newdecl) |= DECL_INVALID_OVERRIDER_P (olddecl);
1576 DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
1577 if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
1578 SET_OVERLOADED_OPERATOR_CODE
1579 (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
1580 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
1582 /* Optionally warn about more than one declaration for the same
1583 name, but don't warn about a function declaration followed by a
1585 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
1586 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
1587 /* Don't warn about extern decl followed by definition. */
1588 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
1589 /* Don't warn about friends, let add_friend take care of it. */
1590 && ! (newdecl_is_friend || DECL_FRIEND_P (olddecl)))
1592 warning (OPT_Wredundant_decls, "redundant redeclaration of %qD in same scope", newdecl);
1593 warning (OPT_Wredundant_decls, "previous declaration of %q+D", olddecl);
1596 if (DECL_DELETED_FN (newdecl))
1598 error ("deleted definition of %qD", newdecl);
1599 error ("after previous declaration %q+D", olddecl);
1603 /* Deal with C++: must preserve virtual function table size. */
1604 if (TREE_CODE (olddecl) == TYPE_DECL)
1606 tree newtype = TREE_TYPE (newdecl);
1607 tree oldtype = TREE_TYPE (olddecl);
1609 if (newtype != error_mark_node && oldtype != error_mark_node
1610 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
1611 CLASSTYPE_FRIEND_CLASSES (newtype)
1612 = CLASSTYPE_FRIEND_CLASSES (oldtype);
1614 DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
1617 /* Copy all the DECL_... slots specified in the new decl
1618 except for any that we copy here from the old type. */
1619 DECL_ATTRIBUTES (newdecl)
1620 = (*targetm.merge_decl_attributes) (olddecl, newdecl);
1622 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1626 old_result = DECL_TEMPLATE_RESULT (olddecl);
1627 new_result = DECL_TEMPLATE_RESULT (newdecl);
1628 TREE_TYPE (olddecl) = TREE_TYPE (old_result);
1629 DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
1630 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
1631 DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
1633 DECL_ATTRIBUTES (old_result)
1634 = (*targetm.merge_decl_attributes) (old_result, new_result);
1636 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1638 if (GNU_INLINE_P (old_result) != GNU_INLINE_P (new_result)
1639 && DECL_INITIAL (new_result))
1641 if (DECL_INITIAL (old_result))
1642 DECL_UNINLINABLE (old_result) = 1;
1644 DECL_UNINLINABLE (old_result) = DECL_UNINLINABLE (new_result);
1645 DECL_EXTERNAL (old_result) = DECL_EXTERNAL (new_result);
1646 DECL_NOT_REALLY_EXTERN (old_result)
1647 = DECL_NOT_REALLY_EXTERN (new_result);
1648 DECL_INTERFACE_KNOWN (old_result)
1649 = DECL_INTERFACE_KNOWN (new_result);
1650 DECL_DECLARED_INLINE_P (old_result)
1651 = DECL_DECLARED_INLINE_P (new_result);
1652 DECL_DISREGARD_INLINE_LIMITS (old_result)
1653 |= DECL_DISREGARD_INLINE_LIMITS (new_result);
1658 DECL_DECLARED_INLINE_P (old_result)
1659 |= DECL_DECLARED_INLINE_P (new_result);
1660 DECL_DISREGARD_INLINE_LIMITS (old_result)
1661 |= DECL_DISREGARD_INLINE_LIMITS (new_result);
1662 check_redeclaration_exception_specification (newdecl, olddecl);
1666 /* If the new declaration is a definition, update the file and
1667 line information on the declaration, and also make
1668 the old declaration the same definition. */
1669 if (DECL_INITIAL (new_result) != NULL_TREE)
1671 DECL_SOURCE_LOCATION (olddecl)
1672 = DECL_SOURCE_LOCATION (old_result)
1673 = DECL_SOURCE_LOCATION (newdecl);
1674 DECL_INITIAL (old_result) = DECL_INITIAL (new_result);
1675 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1678 DECL_ARGUMENTS (old_result)
1679 = DECL_ARGUMENTS (new_result);
1680 for (parm = DECL_ARGUMENTS (old_result); parm;
1681 parm = TREE_CHAIN (parm))
1682 DECL_CONTEXT (parm) = old_result;
1691 /* Automatically handles default parameters. */
1692 tree oldtype = TREE_TYPE (olddecl);
1695 /* Merge the data types specified in the two decls. */
1696 newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1698 /* If merge_types produces a non-typedef type, just use the old type. */
1699 if (TREE_CODE (newdecl) == TYPE_DECL
1700 && newtype == DECL_ORIGINAL_TYPE (newdecl))
1703 if (TREE_CODE (newdecl) == VAR_DECL)
1705 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
1706 DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
1707 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl)
1708 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl);
1709 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl)
1710 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl);
1712 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
1713 if (DECL_LANG_SPECIFIC (olddecl)
1714 && CP_DECL_THREADPRIVATE_P (olddecl))
1716 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
1717 if (!DECL_LANG_SPECIFIC (newdecl))
1718 retrofit_lang_decl (newdecl);
1720 DECL_TLS_MODEL (newdecl) = DECL_TLS_MODEL (olddecl);
1721 CP_DECL_THREADPRIVATE_P (newdecl) = 1;
1725 /* Do this after calling `merge_types' so that default
1726 parameters don't confuse us. */
1727 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1728 check_redeclaration_exception_specification (newdecl, olddecl);
1729 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
1731 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1732 check_default_args (newdecl);
1734 /* Lay the type out, unless already done. */
1735 if (! same_type_p (newtype, oldtype)
1736 && TREE_TYPE (newdecl) != error_mark_node
1737 && !(processing_template_decl && uses_template_parms (newdecl)))
1738 layout_type (TREE_TYPE (newdecl));
1740 if ((TREE_CODE (newdecl) == VAR_DECL
1741 || TREE_CODE (newdecl) == PARM_DECL
1742 || TREE_CODE (newdecl) == RESULT_DECL
1743 || TREE_CODE (newdecl) == FIELD_DECL
1744 || TREE_CODE (newdecl) == TYPE_DECL)
1745 && !(processing_template_decl && uses_template_parms (newdecl)))
1746 layout_decl (newdecl, 0);
1748 /* Merge the type qualifiers. */
1749 if (TREE_READONLY (newdecl))
1750 TREE_READONLY (olddecl) = 1;
1751 if (TREE_THIS_VOLATILE (newdecl))
1752 TREE_THIS_VOLATILE (olddecl) = 1;
1753 if (TREE_NOTHROW (newdecl))
1754 TREE_NOTHROW (olddecl) = 1;
1756 /* Merge deprecatedness. */
1757 if (TREE_DEPRECATED (newdecl))
1758 TREE_DEPRECATED (olddecl) = 1;
1760 /* Preserve function specific target and optimization options */
1761 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1763 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl)
1764 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl))
1765 DECL_FUNCTION_SPECIFIC_TARGET (newdecl)
1766 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl);
1768 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl)
1769 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl))
1770 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl)
1771 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl);
1774 /* Merge the initialization information. */
1775 if (DECL_INITIAL (newdecl) == NULL_TREE
1776 && DECL_INITIAL (olddecl) != NULL_TREE)
1778 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1779 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
1780 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
1781 && DECL_LANG_SPECIFIC (newdecl)
1782 && DECL_LANG_SPECIFIC (olddecl))
1784 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1785 DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
1789 /* Merge the section attribute.
1790 We want to issue an error if the sections conflict but that must be
1791 done later in decl_attributes since we are called before attributes
1793 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1794 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1796 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1798 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1799 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1800 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1801 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1802 TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl);
1803 DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
1804 DECL_IS_OPERATOR_NEW (newdecl) |= DECL_IS_OPERATOR_NEW (olddecl);
1805 DECL_PURE_P (newdecl) |= DECL_PURE_P (olddecl);
1806 TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
1807 DECL_LOOPING_CONST_OR_PURE_P (newdecl)
1808 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl);
1809 /* Keep the old RTL. */
1810 COPY_DECL_RTL (olddecl, newdecl);
1812 else if (TREE_CODE (newdecl) == VAR_DECL
1813 && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
1815 /* Keep the old RTL. We cannot keep the old RTL if the old
1816 declaration was for an incomplete object and the new
1817 declaration is not since many attributes of the RTL will
1819 COPY_DECL_RTL (olddecl, newdecl);
1822 /* If cannot merge, then use the new type and qualifiers,
1823 and don't preserve the old rtl. */
1826 /* Clean out any memory we had of the old declaration. */
1827 tree oldstatic = value_member (olddecl, static_aggregates);
1829 TREE_VALUE (oldstatic) = error_mark_node;
1831 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1832 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1833 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1834 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1837 /* Merge the storage class information. */
1838 merge_weak (newdecl, olddecl);
1840 DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
1841 DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
1842 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1843 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
1844 if (! DECL_EXTERNAL (olddecl))
1845 DECL_EXTERNAL (newdecl) = 0;
1847 new_template = NULL_TREE;
1848 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
1850 bool new_redefines_gnu_inline = false;
1852 if (new_defines_function
1853 && ((DECL_INTERFACE_KNOWN (olddecl)
1854 && TREE_CODE (olddecl) == FUNCTION_DECL)
1855 || (TREE_CODE (olddecl) == TEMPLATE_DECL
1856 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
1857 == FUNCTION_DECL))))
1861 if (TREE_CODE (fn) == TEMPLATE_DECL)
1862 fn = DECL_TEMPLATE_RESULT (olddecl);
1864 new_redefines_gnu_inline = GNU_INLINE_P (fn) && DECL_INITIAL (fn);
1867 if (!new_redefines_gnu_inline)
1869 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
1870 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
1871 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
1873 DECL_TEMPLATE_INSTANTIATED (newdecl)
1874 |= DECL_TEMPLATE_INSTANTIATED (olddecl);
1876 /* If the OLDDECL is an instantiation and/or specialization,
1877 then the NEWDECL must be too. But, it may not yet be marked
1878 as such if the caller has created NEWDECL, but has not yet
1879 figured out that it is a redeclaration. */
1880 if (!DECL_USE_TEMPLATE (newdecl))
1881 DECL_USE_TEMPLATE (newdecl) = DECL_USE_TEMPLATE (olddecl);
1883 /* Don't really know how much of the language-specific
1884 values we should copy from old to new. */
1885 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
1886 DECL_LANG_SPECIFIC (newdecl)->decl_flags.u2 =
1887 DECL_LANG_SPECIFIC (olddecl)->decl_flags.u2;
1888 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
1889 DECL_REPO_AVAILABLE_P (newdecl) = DECL_REPO_AVAILABLE_P (olddecl);
1890 if (DECL_TEMPLATE_INFO (newdecl))
1891 new_template = DECL_TI_TEMPLATE (newdecl);
1892 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
1893 DECL_INITIALIZED_IN_CLASS_P (newdecl)
1894 |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
1895 olddecl_friend = DECL_FRIEND_P (olddecl);
1896 hidden_friend = (DECL_ANTICIPATED (olddecl)
1897 && DECL_HIDDEN_FRIEND_P (olddecl)
1898 && newdecl_is_friend);
1900 /* Only functions have DECL_BEFRIENDING_CLASSES. */
1901 if (TREE_CODE (newdecl) == FUNCTION_DECL
1902 || DECL_FUNCTION_TEMPLATE_P (newdecl))
1904 DECL_BEFRIENDING_CLASSES (newdecl)
1905 = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
1906 DECL_BEFRIENDING_CLASSES (olddecl));
1907 /* DECL_THUNKS is only valid for virtual functions,
1908 otherwise it is a DECL_FRIEND_CONTEXT. */
1909 if (DECL_VIRTUAL_P (newdecl))
1910 DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl);
1914 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1918 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
1919 && !DECL_TEMPLATE_INSTANTIATION (newdecl))
1921 /* If newdecl is not a specialization, then it is not a
1922 template-related function at all. And that means that we
1923 should have exited above, returning 0. */
1924 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl));
1926 if (TREE_USED (olddecl))
1927 /* From [temp.expl.spec]:
1929 If a template, a member template or the member of a class
1930 template is explicitly specialized then that
1931 specialization shall be declared before the first use of
1932 that specialization that would cause an implicit
1933 instantiation to take place, in every translation unit in
1934 which such a use occurs. */
1935 error ("explicit specialization of %qD after first use",
1938 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
1940 /* Don't propagate visibility from the template to the
1941 specialization here. We'll do that in determine_visibility if
1943 DECL_VISIBILITY_SPECIFIED (olddecl) = 0;
1945 /* [temp.expl.spec/14] We don't inline explicit specialization
1946 just because the primary template says so. */
1948 else if (new_defines_function && DECL_INITIAL (olddecl))
1950 /* Never inline re-defined extern inline functions.
1951 FIXME: this could be better handled by keeping both
1952 function as separate declarations. */
1953 DECL_UNINLINABLE (newdecl) = 1;
1957 if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
1958 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
1960 DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
1962 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
1963 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
1965 DECL_DISREGARD_INLINE_LIMITS (newdecl)
1966 = DECL_DISREGARD_INLINE_LIMITS (olddecl)
1967 = (DECL_DISREGARD_INLINE_LIMITS (newdecl)
1968 || DECL_DISREGARD_INLINE_LIMITS (olddecl));
1971 /* Preserve abstractness on cloned [cd]tors. */
1972 DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
1974 /* Update newdecl's parms to point at olddecl. */
1975 for (parm = DECL_ARGUMENTS (newdecl); parm;
1976 parm = TREE_CHAIN (parm))
1977 DECL_CONTEXT (parm) = olddecl;
1981 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1982 COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
1983 COPY_DECL_RTL (newdecl, olddecl);
1985 if (! types_match || new_defines_function)
1987 /* These need to be copied so that the names are available.
1988 Note that if the types do match, we'll preserve inline
1989 info and other bits, but if not, we won't. */
1990 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
1991 DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
1993 if (new_defines_function)
1994 /* If defining a function declared with other language
1995 linkage, use the previously declared language linkage. */
1996 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1997 else if (types_match)
1999 /* If redeclaring a builtin function, and not a definition,
2000 it stays built in. */
2001 if (DECL_BUILT_IN (olddecl))
2003 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
2004 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
2005 /* If we're keeping the built-in definition, keep the rtl,
2006 regardless of declaration matches. */
2007 COPY_DECL_RTL (olddecl, newdecl);
2010 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
2011 /* Don't clear out the arguments if we're just redeclaring a
2013 if (DECL_ARGUMENTS (olddecl))
2014 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
2017 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
2018 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
2020 /* Now preserve various other info from the definition. */
2021 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
2022 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
2023 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
2024 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
2026 /* Warn about conflicting visibility specifications. */
2027 if (DECL_VISIBILITY_SPECIFIED (olddecl)
2028 && DECL_VISIBILITY_SPECIFIED (newdecl)
2029 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
2031 warning (OPT_Wattributes, "%q+D: visibility attribute ignored "
2032 "because it", newdecl);
2033 warning (OPT_Wattributes, "%Jconflicts with previous "
2034 "declaration here", olddecl);
2036 /* Choose the declaration which specified visibility. */
2037 if (DECL_VISIBILITY_SPECIFIED (olddecl))
2039 DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
2040 DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
2042 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2043 so keep this behavior. */
2044 if (TREE_CODE (newdecl) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (newdecl))
2046 SET_DECL_INIT_PRIORITY (olddecl, DECL_INIT_PRIORITY (newdecl));
2047 DECL_HAS_INIT_PRIORITY_P (olddecl) = 1;
2050 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2051 with that from NEWDECL below. */
2052 if (DECL_LANG_SPECIFIC (olddecl))
2054 gcc_assert (DECL_LANG_SPECIFIC (olddecl)
2055 != DECL_LANG_SPECIFIC (newdecl));
2056 ggc_free (DECL_LANG_SPECIFIC (olddecl));
2059 /* Merge the USED information. */
2060 if (TREE_USED (olddecl))
2061 TREE_USED (newdecl) = 1;
2062 else if (TREE_USED (newdecl))
2063 TREE_USED (olddecl) = 1;
2065 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2069 function_size = sizeof (struct tree_decl_common);
2071 memcpy ((char *) olddecl + sizeof (struct tree_common),
2072 (char *) newdecl + sizeof (struct tree_common),
2073 function_size - sizeof (struct tree_common));
2075 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2076 (char *) newdecl + sizeof (struct tree_decl_common),
2077 sizeof (struct tree_function_decl) - sizeof (struct tree_decl_common));
2079 /* If newdecl is a template instantiation, it is possible that
2080 the following sequence of events has occurred:
2082 o A friend function was declared in a class template. The
2083 class template was instantiated.
2085 o The instantiation of the friend declaration was
2086 recorded on the instantiation list, and is newdecl.
2088 o Later, however, instantiate_class_template called pushdecl
2089 on the newdecl to perform name injection. But, pushdecl in
2090 turn called duplicate_decls when it discovered that another
2091 declaration of a global function with the same name already
2094 o Here, in duplicate_decls, we decided to clobber newdecl.
2096 If we're going to do that, we'd better make sure that
2097 olddecl, and not newdecl, is on the list of
2098 instantiations so that if we try to do the instantiation
2099 again we won't get the clobbered declaration. */
2100 reregister_specialization (newdecl,
2106 size_t size = tree_code_size (TREE_CODE (olddecl));
2107 memcpy ((char *) olddecl + sizeof (struct tree_common),
2108 (char *) newdecl + sizeof (struct tree_common),
2109 sizeof (struct tree_decl_common) - sizeof (struct tree_common));
2110 switch (TREE_CODE (olddecl))
2120 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2121 (char *) newdecl + sizeof (struct tree_decl_common),
2122 size - sizeof (struct tree_decl_common)
2123 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2127 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2128 (char *) newdecl + sizeof (struct tree_decl_common),
2129 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common)
2130 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2134 DECL_UID (olddecl) = olddecl_uid;
2136 DECL_FRIEND_P (olddecl) = 1;
2139 DECL_ANTICIPATED (olddecl) = 1;
2140 DECL_HIDDEN_FRIEND_P (olddecl) = 1;
2143 /* NEWDECL contains the merged attribute lists.
2144 Update OLDDECL to be the same. */
2145 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
2147 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2148 so that encode_section_info has a chance to look at the new decl
2149 flags and attributes. */
2150 if (DECL_RTL_SET_P (olddecl)
2151 && (TREE_CODE (olddecl) == FUNCTION_DECL
2152 || (TREE_CODE (olddecl) == VAR_DECL
2153 && TREE_STATIC (olddecl))))
2154 make_decl_rtl (olddecl);
2156 /* The NEWDECL will no longer be needed. Because every out-of-class
2157 declaration of a member results in a call to duplicate_decls,
2158 freeing these nodes represents in a significant savings. */
2164 /* Return zero if the declaration NEWDECL is valid
2165 when the declaration OLDDECL (assumed to be for the same name)
2166 has already been seen.
2167 Otherwise return an error message format string with a %s
2168 where the identifier should go. */
2171 redeclaration_error_message (tree newdecl, tree olddecl)
2173 if (TREE_CODE (newdecl) == TYPE_DECL)
2175 /* Because C++ can put things into name space for free,
2176 constructs like "typedef struct foo { ... } foo"
2177 would look like an erroneous redeclaration. */
2178 if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
2181 return "redefinition of %q#D";
2183 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
2185 /* If this is a pure function, its olddecl will actually be
2186 the original initialization to `0' (which we force to call
2187 abort()). Don't complain about redefinition in this case. */
2188 if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl)
2189 && DECL_INITIAL (olddecl) == NULL_TREE)
2192 /* If both functions come from different namespaces, this is not
2193 a redeclaration - this is a conflict with a used function. */
2194 if (DECL_NAMESPACE_SCOPE_P (olddecl)
2195 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl)
2196 && ! decls_match (olddecl, newdecl))
2197 return "%qD conflicts with used function";
2199 /* We'll complain about linkage mismatches in
2200 warn_extern_redeclared_static. */
2202 /* Defining the same name twice is no good. */
2203 if (DECL_INITIAL (olddecl) != NULL_TREE
2204 && DECL_INITIAL (newdecl) != NULL_TREE)
2206 if (DECL_NAME (olddecl) == NULL_TREE)
2207 return "%q#D not declared in class";
2208 else if (!GNU_INLINE_P (olddecl)
2209 || GNU_INLINE_P (newdecl))
2210 return "redefinition of %q#D";
2213 if (DECL_DECLARED_INLINE_P (olddecl) && DECL_DECLARED_INLINE_P (newdecl))
2215 bool olda = GNU_INLINE_P (olddecl);
2216 bool newa = GNU_INLINE_P (newdecl);
2221 return "%q+D redeclared inline with %<gnu_inline%> attribute";
2223 return "%q+D redeclared inline without %<gnu_inline%> attribute";
2229 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2233 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2235 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl))
2236 && COMPLETE_TYPE_P (TREE_TYPE (olddecl)))
2237 return "redefinition of %q#D";
2241 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL
2242 || (DECL_TEMPLATE_RESULT (newdecl)
2243 == DECL_TEMPLATE_RESULT (olddecl)))
2246 nt = DECL_TEMPLATE_RESULT (newdecl);
2247 if (DECL_TEMPLATE_INFO (nt))
2248 nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt));
2249 ot = DECL_TEMPLATE_RESULT (olddecl);
2250 if (DECL_TEMPLATE_INFO (ot))
2251 ot = DECL_TEMPLATE_RESULT (template_for_substitution (ot));
2252 if (DECL_INITIAL (nt) && DECL_INITIAL (ot)
2253 && (!GNU_INLINE_P (ot) || GNU_INLINE_P (nt)))
2254 return "redefinition of %q#D";
2256 if (DECL_DECLARED_INLINE_P (ot) && DECL_DECLARED_INLINE_P (nt))
2258 bool olda = GNU_INLINE_P (ot);
2259 bool newa = GNU_INLINE_P (nt);
2264 return "%q+D redeclared inline with %<gnu_inline%> attribute";
2266 return "%q+D redeclared inline without %<gnu_inline%> attribute";
2270 /* Core issue #226 (C++0x):
2272 If a friend function template declaration specifies a
2273 default template-argument, that declaration shall be a
2274 definition and shall be the only declaration of the
2275 function template in the translation unit. */
2276 if ((cxx_dialect != cxx98)
2277 && TREE_CODE (ot) == FUNCTION_DECL && DECL_FRIEND_P (ot)
2278 && !check_default_tmpl_args (nt, DECL_TEMPLATE_PARMS (newdecl),
2279 /*is_primary=*/1, /*is_partial=*/0,
2280 /*is_friend_decl=*/2))
2281 return "redeclaration of friend %q#D may not have default template arguments";
2285 else if (TREE_CODE (newdecl) == VAR_DECL
2286 && DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl)
2287 && (! DECL_LANG_SPECIFIC (olddecl)
2288 || ! CP_DECL_THREADPRIVATE_P (olddecl)
2289 || DECL_THREAD_LOCAL_P (newdecl)))
2291 /* Only variables can be thread-local, and all declarations must
2292 agree on this property. */
2293 if (DECL_THREAD_LOCAL_P (newdecl))
2294 return "thread-local declaration of %q#D follows "
2295 "non-thread-local declaration";
2297 return "non-thread-local declaration of %q#D follows "
2298 "thread-local declaration";
2300 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
2302 /* The objects have been declared at namespace scope. If either
2303 is a member of an anonymous union, then this is an invalid
2304 redeclaration. For example:
2310 if ((TREE_CODE (newdecl) == VAR_DECL && DECL_ANON_UNION_VAR_P (newdecl))
2311 || (TREE_CODE (olddecl) == VAR_DECL && DECL_ANON_UNION_VAR_P (olddecl)))
2312 return "redeclaration of %q#D";
2313 /* If at least one declaration is a reference, there is no
2314 conflict. For example:
2320 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2322 /* Reject two definitions. */
2323 return "redefinition of %q#D";
2327 /* Objects declared with block scope: */
2328 /* Reject two definitions, and reject a definition
2329 together with an external reference. */
2330 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
2331 return "redeclaration of %q#D";
2336 /* Hash and equality functions for the named_label table. */
2339 named_label_entry_hash (const void *data)
2341 const struct named_label_entry *ent = (const struct named_label_entry *) data;
2342 return DECL_UID (ent->label_decl);
2346 named_label_entry_eq (const void *a, const void *b)
2348 const struct named_label_entry *ent_a = (const struct named_label_entry *) a;
2349 const struct named_label_entry *ent_b = (const struct named_label_entry *) b;
2350 return ent_a->label_decl == ent_b->label_decl;
2353 /* Create a new label, named ID. */
2356 make_label_decl (tree id, int local_p)
2358 struct named_label_entry *ent;
2362 decl = build_decl (LABEL_DECL, id, void_type_node);
2364 DECL_CONTEXT (decl) = current_function_decl;
2365 DECL_MODE (decl) = VOIDmode;
2366 C_DECLARED_LABEL_FLAG (decl) = local_p;
2368 /* Say where one reference is to the label, for the sake of the
2369 error if it is not defined. */
2370 DECL_SOURCE_LOCATION (decl) = input_location;
2372 /* Record the fact that this identifier is bound to this label. */
2373 SET_IDENTIFIER_LABEL_VALUE (id, decl);
2375 /* Create the label htab for the function on demand. */
2377 named_labels = htab_create_ggc (13, named_label_entry_hash,
2378 named_label_entry_eq, NULL);
2380 /* Record this label on the list of labels used in this function.
2381 We do this before calling make_label_decl so that we get the
2382 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2383 ent = GGC_CNEW (struct named_label_entry);
2384 ent->label_decl = decl;
2386 slot = htab_find_slot (named_labels, ent, INSERT);
2387 gcc_assert (*slot == NULL);
2393 /* Look for a label named ID in the current function. If one cannot
2394 be found, create one. (We keep track of used, but undefined,
2395 labels, and complain about them at the end of a function.) */
2398 lookup_label (tree id)
2402 timevar_push (TV_NAME_LOOKUP);
2403 /* You can't use labels at global scope. */
2404 if (current_function_decl == NULL_TREE)
2406 error ("label %qE referenced outside of any function", id);
2407 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2410 /* See if we've already got this label. */
2411 decl = IDENTIFIER_LABEL_VALUE (id);
2412 if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
2413 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2415 decl = make_label_decl (id, /*local_p=*/0);
2416 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2419 /* Declare a local label named ID. */
2422 declare_local_label (tree id)
2426 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2427 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2428 shadow = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
2429 current_binding_level->shadowed_labels);
2430 current_binding_level->shadowed_labels = shadow;
2432 decl = make_label_decl (id, /*local_p=*/1);
2433 TREE_VALUE (shadow) = decl;
2438 /* Returns nonzero if it is ill-formed to jump past the declaration of
2439 DECL. Returns 2 if it's also a real problem. */
2442 decl_jump_unsafe (tree decl)
2444 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl)
2445 || TREE_TYPE (decl) == error_mark_node)
2448 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
2449 || DECL_NONTRIVIALLY_INITIALIZED_P (decl))
2452 if (pod_type_p (TREE_TYPE (decl)))
2455 /* The POD stuff is just pedantry; why should it matter if the class
2456 contains a field of pointer to member type? */
2460 /* A subroutine of check_previous_goto_1 to identify a branch to the user. */
2463 identify_goto (tree decl, const location_t *locus)
2466 permerror (input_location, "jump to label %qD", decl);
2468 permerror (input_location, "jump to case label");
2470 permerror (input_location, "%H from here", locus);
2473 /* Check that a single previously seen jump to a newly defined label
2474 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2475 the jump context; NAMES are the names in scope in LEVEL at the jump
2476 context; LOCUS is the source position of the jump or 0. Returns
2477 true if all is well. */
2480 check_previous_goto_1 (tree decl, struct cp_binding_level* level, tree names,
2481 bool exited_omp, const location_t *locus)
2483 struct cp_binding_level *b;
2484 bool identified = false, saw_eh = false, saw_omp = false;
2488 identify_goto (decl, locus);
2489 error (" exits OpenMP structured block");
2490 identified = saw_omp = true;
2493 for (b = current_binding_level; b ; b = b->level_chain)
2495 tree new_decls, old_decls = (b == level ? names : NULL_TREE);
2497 for (new_decls = b->names; new_decls != old_decls;
2498 new_decls = TREE_CHAIN (new_decls))
2500 int problem = decl_jump_unsafe (new_decls);
2506 identify_goto (decl, locus);
2510 error (" crosses initialization of %q+#D", new_decls);
2512 permerror (input_location, " enters scope of non-POD %q+#D", new_decls);
2517 if ((b->kind == sk_try || b->kind == sk_catch) && !saw_eh)
2521 identify_goto (decl, locus);
2524 if (b->kind == sk_try)
2525 error (" enters try block");
2527 error (" enters catch block");
2530 if (b->kind == sk_omp && !saw_omp)
2534 identify_goto (decl, locus);
2537 error (" enters OpenMP structured block");
2546 check_previous_goto (tree decl, struct named_label_use_entry *use)
2548 check_previous_goto_1 (decl, use->binding_level,
2549 use->names_in_scope, use->in_omp_scope,
2550 &use->o_goto_locus);
2554 check_switch_goto (struct cp_binding_level* level)
2556 return check_previous_goto_1 (NULL_TREE, level, level->names, false, NULL);
2559 /* Check that a new jump to a label DECL is OK. Called by
2560 finish_goto_stmt. */
2563 check_goto (tree decl)
2565 struct named_label_entry *ent, dummy;
2566 bool saw_catch = false, identified = false;
2569 /* We can't know where a computed goto is jumping.
2570 So we assume that it's OK. */
2571 if (TREE_CODE (decl) != LABEL_DECL)
2574 /* We didn't record any information about this label when we created it,
2575 and there's not much point since it's trivial to analyze as a return. */
2576 if (decl == cdtor_label)
2579 dummy.label_decl = decl;
2580 ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2581 gcc_assert (ent != NULL);
2583 /* If the label hasn't been defined yet, defer checking. */
2584 if (! DECL_INITIAL (decl))
2586 struct named_label_use_entry *new_use;
2588 /* Don't bother creating another use if the last goto had the
2589 same data, and will therefore create the same set of errors. */
2591 && ent->uses->names_in_scope == current_binding_level->names)
2594 new_use = GGC_NEW (struct named_label_use_entry);
2595 new_use->binding_level = current_binding_level;
2596 new_use->names_in_scope = current_binding_level->names;
2597 new_use->o_goto_locus = input_location;
2598 new_use->in_omp_scope = false;
2600 new_use->next = ent->uses;
2601 ent->uses = new_use;
2605 if (ent->in_try_scope || ent->in_catch_scope
2606 || ent->in_omp_scope || ent->bad_decls)
2608 permerror (input_location, "jump to label %q+D", decl);
2609 permerror (input_location, " from here");
2613 for (bad = ent->bad_decls; bad; bad = TREE_CHAIN (bad))
2615 tree b = TREE_VALUE (bad);
2616 int u = decl_jump_unsafe (b);
2618 if (u > 1 && DECL_ARTIFICIAL (b))
2620 /* Can't skip init of __exception_info. */
2621 error ("%J enters catch block", b);
2625 error (" skips initialization of %q+#D", b);
2627 permerror (input_location, " enters scope of non-POD %q+#D", b);
2630 if (ent->in_try_scope)
2631 error (" enters try block");
2632 else if (ent->in_catch_scope && !saw_catch)
2633 error (" enters catch block");
2635 if (ent->in_omp_scope)
2636 error (" enters OpenMP structured block");
2637 else if (flag_openmp)
2639 struct cp_binding_level *b;
2640 for (b = current_binding_level; b ; b = b->level_chain)
2642 if (b == ent->binding_level)
2644 if (b->kind == sk_omp)
2648 permerror (input_location, "jump to label %q+D", decl);
2649 permerror (input_location, " from here");
2652 error (" exits OpenMP structured block");
2659 /* Check that a return is ok wrt OpenMP structured blocks.
2660 Called by finish_return_stmt. Returns true if all is well. */
2663 check_omp_return (void)
2665 struct cp_binding_level *b;
2666 for (b = current_binding_level; b ; b = b->level_chain)
2667 if (b->kind == sk_omp)
2669 error ("invalid exit from OpenMP structured block");
2675 /* Define a label, specifying the location in the source file.
2676 Return the LABEL_DECL node for the label. */
2679 define_label (location_t location, tree name)
2681 struct named_label_entry *ent, dummy;
2682 struct cp_binding_level *p;
2685 timevar_push (TV_NAME_LOOKUP);
2687 decl = lookup_label (name);
2689 dummy.label_decl = decl;
2690 ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2691 gcc_assert (ent != NULL);
2693 /* After labels, make any new cleanups in the function go into their
2694 own new (temporary) binding contour. */
2695 for (p = current_binding_level;
2696 p->kind != sk_function_parms;
2698 p->more_cleanups_ok = 0;
2700 if (name == get_identifier ("wchar_t"))
2701 permerror (input_location, "label named wchar_t");
2703 if (DECL_INITIAL (decl) != NULL_TREE)
2705 error ("duplicate label %qD", decl);
2706 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
2710 struct named_label_use_entry *use;
2712 /* Mark label as having been defined. */
2713 DECL_INITIAL (decl) = error_mark_node;
2714 /* Say where in the source. */
2715 DECL_SOURCE_LOCATION (decl) = location;
2717 ent->binding_level = current_binding_level;
2718 ent->names_in_scope = current_binding_level->names;
2720 for (use = ent->uses; use ; use = use->next)
2721 check_previous_goto (decl, use);
2725 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2730 struct cp_binding_level *level;
2731 struct cp_switch *next;
2732 /* The SWITCH_STMT being built. */
2734 /* A splay-tree mapping the low element of a case range to the high
2735 element, or NULL_TREE if there is no high element. Used to
2736 determine whether or not a new case label duplicates an old case
2737 label. We need a tree, rather than simply a hash table, because
2738 of the GNU case range extension. */
2742 /* A stack of the currently active switch statements. The innermost
2743 switch statement is on the top of the stack. There is no need to
2744 mark the stack for garbage collection because it is only active
2745 during the processing of the body of a function, and we never
2746 collect at that point. */
2748 static struct cp_switch *switch_stack;
2750 /* Called right after a switch-statement condition is parsed.
2751 SWITCH_STMT is the switch statement being parsed. */
2754 push_switch (tree switch_stmt)
2756 struct cp_switch *p = XNEW (struct cp_switch);
2757 p->level = current_binding_level;
2758 p->next = switch_stack;
2759 p->switch_stmt = switch_stmt;
2760 p->cases = splay_tree_new (case_compare, NULL, NULL);
2767 struct cp_switch *cs = switch_stack;
2768 location_t switch_location;
2770 /* Emit warnings as needed. */
2771 if (EXPR_HAS_LOCATION (cs->switch_stmt))
2772 switch_location = EXPR_LOCATION (cs->switch_stmt);
2774 switch_location = input_location;
2775 if (!processing_template_decl)
2776 c_do_switch_warnings (cs->cases, switch_location,
2777 SWITCH_STMT_TYPE (cs->switch_stmt),
2778 SWITCH_STMT_COND (cs->switch_stmt));
2780 splay_tree_delete (cs->cases);
2781 switch_stack = switch_stack->next;
2785 /* Note that we've seen a definition of a case label, and complain if this
2786 is a bad place for one. */
2789 finish_case_label (tree low_value, tree high_value)
2792 struct cp_binding_level *p;
2794 if (processing_template_decl)
2798 /* For templates, just add the case label; we'll do semantic
2799 analysis at instantiation-time. */
2800 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
2801 return add_stmt (build_case_label (low_value, high_value, label));
2804 /* Find the condition on which this switch statement depends. */
2805 cond = SWITCH_STMT_COND (switch_stack->switch_stmt);
2806 if (cond && TREE_CODE (cond) == TREE_LIST)
2807 cond = TREE_VALUE (cond);
2809 if (!check_switch_goto (switch_stack->level))
2810 return error_mark_node;
2812 r = c_add_case_label (switch_stack->cases, cond,
2813 SWITCH_STMT_TYPE (switch_stack->switch_stmt),
2814 low_value, high_value);
2816 /* After labels, make any new cleanups in the function go into their
2817 own new (temporary) binding contour. */
2818 for (p = current_binding_level;
2819 p->kind != sk_function_parms;
2821 p->more_cleanups_ok = 0;
2826 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
2829 typename_hash (const void* k)
2832 const_tree const t = (const_tree) k;
2834 hash = (htab_hash_pointer (TYPE_CONTEXT (t))
2835 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));
2840 typedef struct typename_info {
2848 /* Compare two TYPENAME_TYPEs. K1 is really of type `tree', K2 is
2849 really of type `typename_info*' */
2852 typename_compare (const void * k1, const void * k2)
2854 const_tree const t1 = (const_tree) k1;
2855 const typename_info *const t2 = (const typename_info *) k2;
2857 return (DECL_NAME (TYPE_NAME (t1)) == t2->name
2858 && TYPE_CONTEXT (t1) == t2->scope
2859 && TYPENAME_TYPE_FULLNAME (t1) == t2->template_id
2860 && TYPENAME_IS_ENUM_P (t1) == t2->enum_p
2861 && TYPENAME_IS_CLASS_P (t1) == t2->class_p);
2864 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
2865 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
2867 Returns the new TYPENAME_TYPE. */
2869 static GTY ((param_is (union tree_node))) htab_t typename_htab;
2872 build_typename_type (tree context, tree name, tree fullname,
2873 enum tag_types tag_type)
2881 if (typename_htab == NULL)
2882 typename_htab = htab_create_ggc (61, &typename_hash,
2883 &typename_compare, NULL);
2885 ti.scope = FROB_CONTEXT (context);
2887 ti.template_id = fullname;
2888 ti.enum_p = tag_type == enum_type;
2889 ti.class_p = (tag_type == class_type
2890 || tag_type == record_type
2891 || tag_type == union_type);
2892 hash = (htab_hash_pointer (ti.scope)
2893 ^ htab_hash_pointer (ti.name));
2895 /* See if we already have this type. */
2896 e = htab_find_slot_with_hash (typename_htab, &ti, hash, INSERT);
2901 /* Build the TYPENAME_TYPE. */
2902 t = cxx_make_type (TYPENAME_TYPE);
2903 TYPE_CONTEXT (t) = ti.scope;
2904 TYPENAME_TYPE_FULLNAME (t) = ti.template_id;
2905 TYPENAME_IS_ENUM_P (t) = ti.enum_p;
2906 TYPENAME_IS_CLASS_P (t) = ti.class_p;
2908 /* Build the corresponding TYPE_DECL. */
2909 d = build_decl (TYPE_DECL, name, t);
2910 TYPE_NAME (TREE_TYPE (d)) = d;
2911 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2912 DECL_CONTEXT (d) = FROB_CONTEXT (context);
2913 DECL_ARTIFICIAL (d) = 1;
2915 /* Store it in the hash table. */
2918 /* TYPENAME_TYPEs must always be compared structurally, because
2919 they may or may not resolve down to another type depending on
2920 the currently open classes. */
2921 SET_TYPE_STRUCTURAL_EQUALITY (t);
2927 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
2928 provided to name the type. Returns an appropriate type, unless an
2929 error occurs, in which case error_mark_node is returned. If we
2930 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
2931 return that, rather than the _TYPE it corresponds to, in other
2932 cases we look through the type decl. If TF_ERROR is set, complain
2933 about errors, otherwise be quiet. */
2936 make_typename_type (tree context, tree name, enum tag_types tag_type,
2937 tsubst_flags_t complain)
2943 if (name == error_mark_node
2944 || context == NULL_TREE
2945 || context == error_mark_node)
2946 return error_mark_node;
2950 if (!(TYPE_LANG_SPECIFIC (name)
2951 && (CLASSTYPE_IS_TEMPLATE (name)
2952 || CLASSTYPE_USE_TEMPLATE (name))))
2953 name = TYPE_IDENTIFIER (name);
2955 /* Create a TEMPLATE_ID_EXPR for the type. */
2956 name = build_nt (TEMPLATE_ID_EXPR,
2957 CLASSTYPE_TI_TEMPLATE (name),
2958 CLASSTYPE_TI_ARGS (name));
2960 else if (TREE_CODE (name) == TYPE_DECL)
2961 name = DECL_NAME (name);
2965 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
2967 name = TREE_OPERAND (name, 0);
2968 if (TREE_CODE (name) == TEMPLATE_DECL)
2969 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
2970 else if (TREE_CODE (name) == OVERLOAD)
2972 error ("%qD is not a type", name);
2973 return error_mark_node;
2976 if (TREE_CODE (name) == TEMPLATE_DECL)
2978 error ("%qD used without template parameters", name);
2979 return error_mark_node;
2981 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
2982 gcc_assert (TYPE_P (context));
2984 if (!MAYBE_CLASS_TYPE_P (context))
2986 if (complain & tf_error)
2987 error ("%q#T is not a class", context);
2988 return error_mark_node;
2991 /* When the CONTEXT is a dependent type, NAME could refer to a
2992 dependent base class of CONTEXT. But look inside it anyway
2993 if CONTEXT is a currently open scope, in case it refers to a
2994 member of the current instantiation or a non-dependent base;
2995 lookup will stop when we hit a dependent base. */
2996 if (!dependent_scope_p (context))
2997 /* We should only set WANT_TYPE when we're a nested typename type.
2998 Then we can give better diagnostics if we find a non-type. */
2999 t = lookup_field (context, name, 0, /*want_type=*/true);
3003 if (!t && dependent_type_p (context))
3004 return build_typename_type (context, name, fullname, tag_type);
3006 want_template = TREE_CODE (fullname) == TEMPLATE_ID_EXPR;
3010 if (complain & tf_error)
3011 error (want_template ? "no class template named %q#T in %q#T"
3012 : "no type named %q#T in %q#T", name, context);
3013 return error_mark_node;
3016 if (want_template && !DECL_CLASS_TEMPLATE_P (t))
3018 if (complain & tf_error)
3019 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3021 return error_mark_node;
3023 if (!want_template && TREE_CODE (t) != TYPE_DECL)
3025 if (complain & tf_error)
3026 error ("%<typename %T::%D%> names %q#T, which is not a type",
3028 return error_mark_node;
3031 if (complain & tf_error)
3032 perform_or_defer_access_check (TYPE_BINFO (context), t, t);
3035 return lookup_template_class (t, TREE_OPERAND (fullname, 1),
3037 /*entering_scope=*/0,
3038 tf_warning_or_error | tf_user);
3040 if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
3046 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3047 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3048 in which case error_mark_node is returned.
3050 If PARM_LIST is non-NULL, also make sure that the template parameter
3051 list of TEMPLATE_DECL matches.
3053 If COMPLAIN zero, don't complain about any errors that occur. */
3056 make_unbound_class_template (tree context, tree name, tree parm_list,
3057 tsubst_flags_t complain)
3063 name = TYPE_IDENTIFIER (name);
3064 else if (DECL_P (name))
3065 name = DECL_NAME (name);
3066 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
3068 if (!dependent_type_p (context)
3069 || currently_open_class (context))
3071 tree tmpl = NULL_TREE;
3073 if (MAYBE_CLASS_TYPE_P (context))
3074 tmpl = lookup_field (context, name, 0, false);
3076 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
3078 if (complain & tf_error)
3079 error ("no class template named %q#T in %q#T", name, context);
3080 return error_mark_node;
3084 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl), parm_list))
3086 if (complain & tf_error)
3088 error ("template parameters do not match template");
3089 error ("%q+D declared here", tmpl);
3091 return error_mark_node;
3094 if (complain & tf_error)
3095 perform_or_defer_access_check (TYPE_BINFO (context), tmpl, tmpl);
3100 /* Build the UNBOUND_CLASS_TEMPLATE. */
3101 t = cxx_make_type (UNBOUND_CLASS_TEMPLATE);
3102 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
3103 TREE_TYPE (t) = NULL_TREE;
3104 SET_TYPE_STRUCTURAL_EQUALITY (t);
3106 /* Build the corresponding TEMPLATE_DECL. */
3107 d = build_decl (TEMPLATE_DECL, name, t);
3108 TYPE_NAME (TREE_TYPE (d)) = d;
3109 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
3110 DECL_CONTEXT (d) = FROB_CONTEXT (context);
3111 DECL_ARTIFICIAL (d) = 1;
3112 DECL_TEMPLATE_PARMS (d) = parm_list;
3119 /* Push the declarations of builtin types into the namespace.
3120 RID_INDEX is the index of the builtin type in the array
3121 RID_POINTERS. NAME is the name used when looking up the builtin
3122 type. TYPE is the _TYPE node for the builtin type. */
3125 record_builtin_type (enum rid rid_index,
3129 tree rname = NULL_TREE, tname = NULL_TREE;
3130 tree tdecl = NULL_TREE;
3132 if ((int) rid_index < (int) RID_MAX)
3133 rname = ridpointers[(int) rid_index];
3135 tname = get_identifier (name);
3137 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
3138 eliminated. Built-in types should not be looked up name; their
3139 names are keywords that the parser can recognize. However, there
3140 is code in c-common.c that uses identifier_global_value to look
3141 up built-in types by name. */
3144 tdecl = build_decl (TYPE_DECL, tname, type);
3145 DECL_ARTIFICIAL (tdecl) = 1;
3146 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
3152 tdecl = build_decl (TYPE_DECL, rname, type);
3153 DECL_ARTIFICIAL (tdecl) = 1;
3155 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
3158 if (!TYPE_NAME (type))
3159 TYPE_NAME (type) = tdecl;
3162 debug_hooks->type_decl (tdecl, 0);
3165 /* Record one of the standard Java types.
3166 * Declare it as having the given NAME.
3167 * If SIZE > 0, it is the size of one of the integral types;
3168 * otherwise it is the negative of the size of one of the other types. */
3171 record_builtin_java_type (const char* name, int size)
3175 type = build_nonstandard_integer_type (size, 0);
3176 else if (size > -32)
3179 /* "__java_char" or ""__java_boolean". */
3180 type = build_nonstandard_integer_type (-size, 1);
3181 /* Get the signed type cached and attached to the unsigned type,
3182 so it doesn't get garbage-collected at "random" times,
3183 causing potential codegen differences out of different UIDs
3184 and different alias set numbers. */
3185 stype = build_nonstandard_integer_type (-size, 0);
3186 TREE_CHAIN (type) = stype;
3187 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
3190 { /* "__java_float" or ""__java_double". */
3191 type = make_node (REAL_TYPE);
3192 TYPE_PRECISION (type) = - size;
3195 record_builtin_type (RID_MAX, name, type);
3196 decl = TYPE_NAME (type);
3198 /* Suppress generate debug symbol entries for these types,
3199 since for normal C++ they are just clutter.
3200 However, push_lang_context undoes this if extern "Java" is seen. */
3201 DECL_IGNORED_P (decl) = 1;
3203 TYPE_FOR_JAVA (type) = 1;
3207 /* Push a type into the namespace so that the back ends ignore it. */
3210 record_unknown_type (tree type, const char* name)
3212 tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
3213 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3214 DECL_IGNORED_P (decl) = 1;
3215 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
3216 TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
3217 TYPE_ALIGN (type) = 1;
3218 TYPE_USER_ALIGN (type) = 0;
3219 SET_TYPE_MODE (type, TYPE_MODE (void_type_node));
3222 /* A string for which we should create an IDENTIFIER_NODE at
3225 typedef struct predefined_identifier
3227 /* The name of the identifier. */
3228 const char *const name;
3229 /* The place where the IDENTIFIER_NODE should be stored. */
3231 /* Nonzero if this is the name of a constructor or destructor. */
3232 const int ctor_or_dtor_p;
3233 } predefined_identifier;
3235 /* Create all the predefined identifiers. */
3238 initialize_predefined_identifiers (void)
3240 const predefined_identifier *pid;
3242 /* A table of identifiers to create at startup. */
3243 static const predefined_identifier predefined_identifiers[] = {
3244 { "C++", &lang_name_cplusplus, 0 },
3245 { "C", &lang_name_c, 0 },
3246 { "Java", &lang_name_java, 0 },
3247 /* Some of these names have a trailing space so that it is
3248 impossible for them to conflict with names written by users. */
3249 { "__ct ", &ctor_identifier, 1 },
3250 { "__base_ctor ", &base_ctor_identifier, 1 },
3251 { "__comp_ctor ", &complete_ctor_identifier, 1 },
3252 { "__dt ", &dtor_identifier, 1 },
3253 { "__comp_dtor ", &complete_dtor_identifier, 1 },
3254 { "__base_dtor ", &base_dtor_identifier, 1 },
3255 { "__deleting_dtor ", &deleting_dtor_identifier, 1 },
3256 { IN_CHARGE_NAME, &in_charge_identifier, 0 },
3257 { "nelts", &nelts_identifier, 0 },
3258 { THIS_NAME, &this_identifier, 0 },
3259 { VTABLE_DELTA_NAME, &delta_identifier, 0 },
3260 { VTABLE_PFN_NAME, &pfn_identifier, 0 },
3261 { "_vptr", &vptr_identifier, 0 },
3262 { "__vtt_parm", &vtt_parm_identifier, 0 },
3263 { "::", &global_scope_name, 0 },
3264 { "std", &std_identifier, 0 },
3268 for (pid = predefined_identifiers; pid->name; ++pid)
3270 *pid->node = get_identifier (pid->name);
3271 if (pid->ctor_or_dtor_p)
3272 IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
3276 /* Create the predefined scalar types of C,
3277 and some nodes representing standard constants (0, 1, (void *)0).
3278 Initialize the global binding level.
3279 Make definitions for built-in primitive functions. */
3282 cxx_init_decl_processing (void)
3285 tree void_ftype_ptr;
3287 build_common_tree_nodes (flag_signed_char, false);
3289 /* Create all the identifiers we need. */
3290 initialize_predefined_identifiers ();
3292 /* Create the global variables. */
3293 push_to_top_level ();
3295 current_function_decl = NULL_TREE;
3296 current_binding_level = NULL;
3297 /* Enter the global namespace. */
3298 gcc_assert (global_namespace == NULL_TREE);
3299 global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name,
3301 TREE_PUBLIC (global_namespace) = 1;
3302 begin_scope (sk_namespace, global_namespace);
3304 current_lang_name = NULL_TREE;
3306 if (flag_visibility_ms_compat)
3307 default_visibility = VISIBILITY_HIDDEN;
3310 current_lang_name = lang_name_c;
3312 /* Create the `std' namespace. */
3313 push_namespace (std_identifier);
3314 std_node = current_namespace;
3317 c_common_nodes_and_builtins ();
3319 java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
3320 java_short_type_node = record_builtin_java_type ("__java_short", 16);
3321 java_int_type_node = record_builtin_java_type ("__java_int", 32);
3322 java_long_type_node = record_builtin_java_type ("__java_long", 64);
3323 java_float_type_node = record_builtin_java_type ("__java_float", -32);
3324 java_double_type_node = record_builtin_java_type ("__java_double", -64);
3325 java_char_type_node = record_builtin_java_type ("__java_char", -16);
3326 java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
3328 integer_two_node = build_int_cst (NULL_TREE, 2);
3329 integer_three_node = build_int_cst (NULL_TREE, 3);
3331 record_builtin_type (RID_BOOL, "bool", boolean_type_node);
3332 truthvalue_type_node = boolean_type_node;
3333 truthvalue_false_node = boolean_false_node;
3334 truthvalue_true_node = boolean_true_node;
3336 empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
3339 record_builtin_type (RID_MAX, NULL, string_type_node);
3342 delta_type_node = ptrdiff_type_node;
3343 vtable_index_type = ptrdiff_type_node;
3345 vtt_parm_type = build_pointer_type (const_ptr_type_node);
3346 void_ftype = build_function_type (void_type_node, void_list_node);
3347 void_ftype_ptr = build_function_type (void_type_node,
3348 tree_cons (NULL_TREE,
3352 = build_exception_variant (void_ftype_ptr, empty_except_spec);
3354 /* C++ extensions */
3356 unknown_type_node = make_node (UNKNOWN_TYPE);
3357 record_unknown_type (unknown_type_node, "unknown type");
3359 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3360 TREE_TYPE (unknown_type_node) = unknown_type_node;
3362 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3364 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
3365 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
3367 init_list_type_node = make_node (UNKNOWN_TYPE);
3368 record_unknown_type (init_list_type_node, "init list");
3371 /* Make sure we get a unique function type, so we can give
3372 its pointer type a name. (This wins for gdb.) */
3373 tree vfunc_type = make_node (FUNCTION_TYPE);
3374 TREE_TYPE (vfunc_type) = integer_type_node;
3375 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
3376 layout_type (vfunc_type);
3378 vtable_entry_type = build_pointer_type (vfunc_type);
3380 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
3383 = build_cplus_array_type (vtable_entry_type, NULL_TREE);
3384 layout_type (vtbl_type_node);
3385 vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
3386 record_builtin_type (RID_MAX, NULL, vtbl_type_node);
3387 vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
3388 layout_type (vtbl_ptr_type_node);
3389 record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
3391 push_namespace (get_identifier ("__cxxabiv1"));
3392 abi_node = current_namespace;
3395 global_type_node = make_node (LANG_TYPE);
3396 record_unknown_type (global_type_node, "global type");
3399 current_lang_name = lang_name_cplusplus;
3403 tree bad_alloc_type_node;
3404 tree bad_alloc_decl;
3405 tree newtype, deltype;
3406 tree ptr_ftype_sizetype;
3408 push_namespace (std_identifier);
3409 bad_alloc_id = get_identifier ("bad_alloc");
3410 bad_alloc_type_node = make_class_type (RECORD_TYPE);
3411 TYPE_CONTEXT (bad_alloc_type_node) = current_namespace;
3413 = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node);
3414 DECL_CONTEXT (bad_alloc_decl) = current_namespace;
3415 TYPE_STUB_DECL (bad_alloc_type_node) = bad_alloc_decl;
3419 = build_function_type (ptr_type_node,
3420 tree_cons (NULL_TREE,
3423 newtype = build_exception_variant
3424 (ptr_ftype_sizetype, add_exception_specifier
3425 (NULL_TREE, bad_alloc_type_node, -1));
3426 deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
3427 push_cp_library_fn (NEW_EXPR, newtype);
3428 push_cp_library_fn (VEC_NEW_EXPR, newtype);
3429 global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
3430 push_cp_library_fn (VEC_DELETE_EXPR, deltype);
3434 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
3436 /* Perform other language dependent initializations. */
3437 init_class_processing ();
3438 init_rtti_processing ();
3440 if (flag_exceptions)
3441 init_exception_processing ();
3443 if (! supports_one_only ())
3446 make_fname_decl = cp_make_fname_decl;
3447 start_fname_decls ();
3449 /* Show we use EH for cleanups. */
3450 if (flag_exceptions)
3451 using_eh_for_cleanups ();
3454 /* Generate an initializer for a function naming variable from
3455 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3456 filled in with the type of the init. */
3459 cp_fname_init (const char* name, tree *type_p)
3461 tree domain = NULL_TREE;
3463 tree init = NULL_TREE;
3468 length = strlen (name);
3469 domain = build_index_type (size_int (length));
3470 init = build_string (length + 1, name);
3473 type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
3474 type = build_cplus_array_type (type, domain);
3479 TREE_TYPE (init) = type;
3481 init = error_mark_node;
3486 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
3487 decl, NAME is the initialization string and TYPE_DEP indicates whether
3488 NAME depended on the type of the function. We make use of that to detect
3489 __PRETTY_FUNCTION__ inside a template fn. This is being done
3490 lazily at the point of first use, so we mustn't push the decl now. */
3493 cp_make_fname_decl (tree id, int type_dep)
3495 const char *const name = (type_dep && processing_template_decl
3496 ? NULL : fname_as_string (type_dep));
3498 tree init = cp_fname_init (name, &type);
3499 tree decl = build_decl (VAR_DECL, id, type);
3502 free (CONST_CAST (char *, name));
3504 /* As we're using pushdecl_with_scope, we must set the context. */
3505 DECL_CONTEXT (decl) = current_function_decl;
3506 DECL_PRETTY_FUNCTION_P (decl) = type_dep;
3508 TREE_STATIC (decl) = 1;
3509 TREE_READONLY (decl) = 1;
3510 DECL_ARTIFICIAL (decl) = 1;
3512 TREE_USED (decl) = 1;
3514 if (current_function_decl)
3516 struct cp_binding_level *b = current_binding_level;
3517 while (b->level_chain->kind != sk_function_parms)
3519 pushdecl_with_scope (decl, b, /*is_friend=*/false);
3520 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE,
3521 LOOKUP_ONLYCONVERTING);
3524 pushdecl_top_level_and_finish (decl, init);
3530 builtin_function_1 (tree decl, tree context, bool is_global)
3532 tree id = DECL_NAME (decl);
3533 const char *name = IDENTIFIER_POINTER (id);
3535 retrofit_lang_decl (decl);
3537 /* All nesting of C++ functions is lexical; there is never a "static
3538 chain" in the sense of GNU C nested functions. */
3539 DECL_NO_STATIC_CHAIN (decl) = 1;
3541 DECL_ARTIFICIAL (decl) = 1;
3542 SET_OVERLOADED_OPERATOR_CODE (decl, ERROR_MARK);
3543 SET_DECL_LANGUAGE (decl, lang_c);
3544 /* Runtime library routines are, by definition, available in an
3545 external shared object. */
3546 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
3547 DECL_VISIBILITY_SPECIFIED (decl) = 1;
3549 DECL_CONTEXT (decl) = context;
3552 pushdecl_top_level (decl);
3556 /* A function in the user's namespace should have an explicit
3557 declaration before it is used. Mark the built-in function as
3558 anticipated but not actually declared. */
3559 if (name[0] != '_' || name[1] != '_')
3560 DECL_ANTICIPATED (decl) = 1;
3561 else if (strncmp (name + 2, "builtin_", strlen ("builtin_")) != 0)
3563 size_t len = strlen (name);
3565 /* Treat __*_chk fortification functions as anticipated as well,
3566 unless they are __builtin_*. */
3567 if (len > strlen ("___chk")
3568 && memcmp (name + len - strlen ("_chk"),
3569 "_chk", strlen ("_chk") + 1) == 0)
3570 DECL_ANTICIPATED (decl) = 1;
3577 cxx_builtin_function (tree decl)
3579 tree id = DECL_NAME (decl);
3580 const char *name = IDENTIFIER_POINTER (id);
3581 /* All builtins that don't begin with an '_' should additionally
3582 go in the 'std' namespace. */
3585 tree decl2 = copy_node(decl);
3586 push_namespace (std_identifier);
3587 builtin_function_1 (decl2, std_node, false);
3591 return builtin_function_1 (decl, NULL_TREE, false);
3594 /* Like cxx_builtin_function, but guarantee the function is added to the global
3595 scope. This is to allow function specific options to add new machine
3596 dependent builtins when the target ISA changes via attribute((target(...)))
3597 which saves space on program startup if the program does not use non-generic
3601 cxx_builtin_function_ext_scope (tree decl)
3604 tree id = DECL_NAME (decl);
3605 const char *name = IDENTIFIER_POINTER (id);
3606 /* All builtins that don't begin with an '_' should additionally
3607 go in the 'std' namespace. */
3610 tree decl2 = copy_node(decl);
3611 push_namespace (std_identifier);
3612 builtin_function_1 (decl2, std_node, true);
3616 return builtin_function_1 (decl, NULL_TREE, true);
3619 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
3620 function. Not called directly. */
3623 build_library_fn_1 (tree name, enum tree_code operator_code, tree type)
3625 tree fn = build_lang_decl (FUNCTION_DECL, name, type);
3626 DECL_EXTERNAL (fn) = 1;
3627 TREE_PUBLIC (fn) = 1;
3628 DECL_ARTIFICIAL (fn) = 1;
3629 SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
3630 SET_DECL_LANGUAGE (fn, lang_c);
3631 /* Runtime library routines are, by definition, available in an
3632 external shared object. */
3633 DECL_VISIBILITY (fn) = VISIBILITY_DEFAULT;
3634 DECL_VISIBILITY_SPECIFIED (fn) = 1;
3638 /* Returns the _DECL for a library function with C linkage.
3639 We assume that such functions never throw; if this is incorrect,
3640 callers should unset TREE_NOTHROW. */
3643 build_library_fn (tree name, tree type)
3645 tree fn = build_library_fn_1 (name, ERROR_MARK, type);
3646 TREE_NOTHROW (fn) = 1;
3650 /* Returns the _DECL for a library function with C++ linkage. */
3653 build_cp_library_fn (tree name, enum tree_code operator_code, tree type)
3655 tree fn = build_library_fn_1 (name, operator_code, type);
3656 TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
3657 DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
3658 SET_DECL_LANGUAGE (fn, lang_cplusplus);
3662 /* Like build_library_fn, but takes a C string instead of an
3666 build_library_fn_ptr (const char* name, tree type)
3668 return build_library_fn (get_identifier (name), type);
3671 /* Like build_cp_library_fn, but takes a C string instead of an
3675 build_cp_library_fn_ptr (const char* name, tree type)
3677 return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
3680 /* Like build_library_fn, but also pushes the function so that we will
3681 be able to find it via IDENTIFIER_GLOBAL_VALUE. Also, the function
3682 may throw exceptions listed in RAISES. */
3685 push_library_fn (tree name, tree type, tree raises)
3690 type = build_exception_variant (type, raises);
3692 fn = build_library_fn (name, type);
3693 pushdecl_top_level (fn);
3697 /* Like build_cp_library_fn, but also pushes the function so that it
3698 will be found by normal lookup. */
3701 push_cp_library_fn (enum tree_code operator_code, tree type)
3703 tree fn = build_cp_library_fn (ansi_opname (operator_code),
3710 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
3714 push_void_library_fn (tree name, tree parmtypes)
3716 tree type = build_function_type (void_type_node, parmtypes);
3717 return push_library_fn (name, type, NULL_TREE);
3720 /* Like push_library_fn, but also note that this function throws
3721 and does not return. Used for __throw_foo and the like. */
3724 push_throw_library_fn (tree name, tree type)
3726 tree fn = push_library_fn (name, type, NULL_TREE);
3727 TREE_THIS_VOLATILE (fn) = 1;
3728 TREE_NOTHROW (fn) = 0;
3732 /* When we call finish_struct for an anonymous union, we create
3733 default copy constructors and such. But, an anonymous union
3734 shouldn't have such things; this function undoes the damage to the
3735 anonymous union type T.
3737 (The reason that we create the synthesized methods is that we don't
3738 distinguish `union { int i; }' from `typedef union { int i; } U'.
3739 The first is an anonymous union; the second is just an ordinary
3743 fixup_anonymous_aggr (tree t)
3747 /* Wipe out memory of synthesized methods. */
3748 TYPE_HAS_USER_CONSTRUCTOR (t) = 0;
3749 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
3750 TYPE_HAS_INIT_REF (t) = 0;
3751 TYPE_HAS_CONST_INIT_REF (t) = 0;
3752 TYPE_HAS_ASSIGN_REF (t) = 0;
3753 TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
3755 /* Splice the implicitly generated functions out of the TYPE_METHODS
3757 q = &TYPE_METHODS (t);
3760 if (DECL_ARTIFICIAL (*q))
3761 *q = TREE_CHAIN (*q);
3763 q = &TREE_CHAIN (*q);
3766 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
3767 if (TYPE_METHODS (t))
3769 tree decl = TYPE_MAIN_DECL (t);
3771 if (TREE_CODE (t) != UNION_TYPE)
3772 error ("%Jan anonymous struct cannot have function members", decl);
3774 error ("%Jan anonymous union cannot have function members", decl);
3777 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
3778 assignment operators (because they cannot have these methods themselves).
3779 For anonymous unions this is already checked because they are not allowed
3780 in any union, otherwise we have to check it. */
3781 if (TREE_CODE (t) != UNION_TYPE)
3785 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
3786 if (TREE_CODE (field) == FIELD_DECL)
3788 type = TREE_TYPE (field);
3789 if (CLASS_TYPE_P (type))
3791 if (TYPE_NEEDS_CONSTRUCTING (type))
3792 error ("member %q+#D with constructor not allowed "
3793 "in anonymous aggregate", field);
3794 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
3795 error ("member %q+#D with destructor not allowed "
3796 "in anonymous aggregate", field);
3797 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
3798 error ("member %q+#D with copy assignment operator "
3799 "not allowed in anonymous aggregate", field);
3805 /* Make sure that a declaration with no declarator is well-formed, i.e.
3806 just declares a tagged type or anonymous union.
3808 Returns the type declared; or NULL_TREE if none. */
3811 check_tag_decl (cp_decl_specifier_seq *declspecs)
3813 int saw_friend = declspecs->specs[(int)ds_friend] != 0;
3814 int saw_typedef = declspecs->specs[(int)ds_typedef] != 0;
3815 /* If a class, struct, or enum type is declared by the DECLSPECS
3816 (i.e, if a class-specifier, enum-specifier, or non-typename
3817 elaborated-type-specifier appears in the DECLSPECS),
3818 DECLARED_TYPE is set to the corresponding type. */
3819 tree declared_type = NULL_TREE;
3820 bool error_p = false;
3822 if (declspecs->multiple_types_p)
3823 error ("multiple types in one declaration");
3824 else if (declspecs->redefined_builtin_type)
3826 if (!in_system_header)
3827 permerror (input_location, "redeclaration of C++ built-in type %qT",
3828 declspecs->redefined_builtin_type);
3833 && TYPE_P (declspecs->type)
3834 && ((TREE_CODE (declspecs->type) != TYPENAME_TYPE
3835 && MAYBE_CLASS_TYPE_P (declspecs->type))
3836 || TREE_CODE (declspecs->type) == ENUMERAL_TYPE))
3837 declared_type = declspecs->type;
3838 else if (declspecs->type == error_mark_node)
3840 if (declared_type == NULL_TREE && ! saw_friend && !error_p)
3841 permerror (input_location, "declaration does not declare anything");
3842 /* Check for an anonymous union. */
3843 else if (declared_type && RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type))
3844 && TYPE_ANONYMOUS_P (declared_type))
3846 /* 7/3 In a simple-declaration, the optional init-declarator-list
3847 can be omitted only when declaring a class (clause 9) or
3848 enumeration (7.2), that is, when the decl-specifier-seq contains
3849 either a class-specifier, an elaborated-type-specifier with
3850 a class-key (9.1), or an enum-specifier. In these cases and
3851 whenever a class-specifier or enum-specifier is present in the
3852 decl-specifier-seq, the identifiers in these specifiers are among
3853 the names being declared by the declaration (as class-name,
3854 enum-names, or enumerators, depending on the syntax). In such
3855 cases, and except for the declaration of an unnamed bit-field (9.6),
3856 the decl-specifier-seq shall introduce one or more names into the
3857 program, or shall redeclare a name introduced by a previous
3858 declaration. [Example:
3859 enum { }; // ill-formed
3860 typedef class { }; // ill-formed
3864 error ("missing type-name in typedef-declaration");
3867 /* Anonymous unions are objects, so they can have specifiers. */;
3868 SET_ANON_AGGR_TYPE_P (declared_type);
3870 if (TREE_CODE (declared_type) != UNION_TYPE && !in_system_header)
3871 pedwarn (input_location, OPT_pedantic, "ISO C++ prohibits anonymous structs");
3876 if (declspecs->specs[(int)ds_inline]
3877 || declspecs->specs[(int)ds_virtual])
3878 error ("%qs can only be specified for functions",
3879 declspecs->specs[(int)ds_inline]
3880 ? "inline" : "virtual");
3882 && (!current_class_type
3883 || current_scope () != current_class_type))
3884 error ("%<friend%> can only be specified inside a class");
3885 else if (declspecs->specs[(int)ds_explicit])
3886 error ("%<explicit%> can only be specified for constructors");
3887 else if (declspecs->storage_class)
3888 error ("a storage class can only be specified for objects "
3890 else if (declspecs->specs[(int)ds_const]
3891 || declspecs->specs[(int)ds_volatile]
3892 || declspecs->specs[(int)ds_restrict]
3893 || declspecs->specs[(int)ds_thread])
3894 error ("qualifiers can only be specified for objects "
3896 else if (saw_typedef)
3897 warning (0, "%<typedef%> was ignored in this declaration");
3900 return declared_type;
3903 /* Called when a declaration is seen that contains no names to declare.
3904 If its type is a reference to a structure, union or enum inherited
3905 from a containing scope, shadow that tag name for the current scope
3906 with a forward reference.
3907 If its type defines a new named structure or union
3908 or defines an enum, it is valid but we need not do anything here.
3909 Otherwise, it is an error.
3911 C++: may have to grok the declspecs to learn about static,
3912 complain for anonymous unions.
3914 Returns the TYPE declared -- or NULL_TREE if none. */
3917 shadow_tag (cp_decl_specifier_seq *declspecs)
3919 tree t = check_tag_decl (declspecs);
3924 if (declspecs->attributes)
3926 warning (0, "attribute ignored in declaration of %q+#T", t);
3927 warning (0, "attribute for %q+#T must follow the %qs keyword",
3928 t, class_key_or_enum_as_string (t));
3932 if (maybe_process_partial_specialization (t) == error_mark_node)
3935 /* This is where the variables in an anonymous union are
3936 declared. An anonymous union declaration looks like:
3938 because there is no declarator after the union, the parser
3939 sends that declaration here. */
3940 if (ANON_AGGR_TYPE_P (t))
3942 fixup_anonymous_aggr (t);
3944 if (TYPE_FIELDS (t))
3946 tree decl = grokdeclarator (/*declarator=*/NULL,
3947 declspecs, NORMAL, 0, NULL);
3948 finish_anon_union (decl);
3955 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
3958 groktypename (cp_decl_specifier_seq *type_specifiers,
3959 const cp_declarator *declarator,
3960 bool is_template_arg)
3964 enum decl_context context
3965 = is_template_arg ? TEMPLATE_TYPE_ARG : TYPENAME;
3966 attrs = type_specifiers->attributes;
3967 type_specifiers->attributes = NULL_TREE;
3968 type = grokdeclarator (declarator, type_specifiers, context, 0, &attrs);
3969 if (attrs && type != error_mark_node)
3971 if (CLASS_TYPE_P (type))
3972 warning (OPT_Wattributes, "ignoring attributes applied to class type %qT "
3973 "outside of definition", type);
3974 else if (MAYBE_CLASS_TYPE_P (type))
3975 /* A template type parameter or other dependent type. */
3976 warning (OPT_Wattributes, "ignoring attributes applied to dependent "
3977 "type %qT without an associated declaration", type);
3979 cplus_decl_attributes (&type, attrs, 0);
3984 /* Process a DECLARATOR for a function-scope variable declaration,
3985 namespace-scope variable declaration, or function declaration.
3986 (Function definitions go through start_function; class member
3987 declarations appearing in the body of the class go through
3988 grokfield.) The DECL corresponding to the DECLARATOR is returned.
3989 If an error occurs, the error_mark_node is returned instead.
3991 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
3992 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
3993 for an explicitly defaulted function, or SD_DELETED for an explicitly
3994 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
3995 implicitly initialized via a default constructor. ATTRIBUTES and
3996 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
3997 *PUSHED_SCOPE_P is set to the scope entered in this function, if any; if
3998 set, the caller is responsible for calling pop_scope. */
4001 start_decl (const cp_declarator *declarator,
4002 cp_decl_specifier_seq *declspecs,
4005 tree prefix_attributes,
4006 tree *pushed_scope_p)
4014 *pushed_scope_p = NULL_TREE;
4016 /* An object declared as __attribute__((deprecated)) suppresses
4017 warnings of uses of other deprecated items. */
4018 if (lookup_attribute ("deprecated", attributes))
4019 deprecated_state = DEPRECATED_SUPPRESS;
4021 attributes = chainon (attributes, prefix_attributes);
4023 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
4026 deprecated_state = DEPRECATED_NORMAL;
4028 if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE
4029 || decl == error_mark_node)
4030 return error_mark_node;
4032 type = TREE_TYPE (decl);
4034 context = DECL_CONTEXT (decl);
4038 *pushed_scope_p = push_scope (context);
4040 /* We are only interested in class contexts, later. */
4041 if (TREE_CODE (context) == NAMESPACE_DECL)
4042 context = NULL_TREE;
4046 /* Is it valid for this decl to have an initializer at all?
4047 If not, set INITIALIZED to zero, which will indirectly
4048 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
4049 switch (TREE_CODE (decl))
4052 error ("typedef %qD is initialized (use decltype instead)", decl);
4053 return error_mark_node;
4056 if (initialized == SD_DELETED)
4057 /* We'll handle the rest of the semantics later, but we need to
4058 set this now so it's visible to duplicate_decls. */
4059 DECL_DELETED_FN (decl) = 1;
4068 if (! toplevel_bindings_p ()
4069 && DECL_EXTERNAL (decl))
4070 warning (0, "declaration of %q#D has %<extern%> and is initialized",
4072 DECL_EXTERNAL (decl) = 0;
4073 if (toplevel_bindings_p ())
4074 TREE_STATIC (decl) = 1;
4077 /* If this is a typedef that names the class for linkage purposes
4078 (7.1.3p8), apply any attributes directly to the type. */
4079 if (TREE_CODE (decl) == TYPE_DECL
4080 && TAGGED_TYPE_P (TREE_TYPE (decl))
4081 && decl == TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl))))
4082 flags = ATTR_FLAG_TYPE_IN_PLACE;
4086 /* Set attributes here so if duplicate decl, will have proper attributes. */
4087 cplus_decl_attributes (&decl, attributes, flags);
4089 /* Dllimported symbols cannot be defined. Static data members (which
4090 can be initialized in-class and dllimported) go through grokfield,
4091 not here, so we don't need to exclude those decls when checking for
4093 if (initialized && DECL_DLLIMPORT_P (decl))
4095 error ("definition of %q#D is marked %<dllimport%>", decl);
4096 DECL_DLLIMPORT_P (decl) = 0;
4099 /* If #pragma weak was used, mark the decl weak now. */
4100 maybe_apply_pragma_weak (decl);
4102 if (TREE_CODE (decl) == FUNCTION_DECL
4103 && DECL_DECLARED_INLINE_P (decl)
4104 && DECL_UNINLINABLE (decl)
4105 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
4106 warning (0, "inline function %q+D given attribute noinline", decl);
4108 if (context && COMPLETE_TYPE_P (complete_type (context)))
4110 if (TREE_CODE (decl) == VAR_DECL)
4112 tree field = lookup_field (context, DECL_NAME (decl), 0, false);
4113 if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
4114 error ("%q#D is not a static member of %q#T", decl, context);
4117 if (DECL_CONTEXT (field) != context)
4119 if (!same_type_p (DECL_CONTEXT (field), context))
4120 permerror (input_location, "ISO C++ does not permit %<%T::%D%> "
4121 "to be defined as %<%T::%D%>",
4122 DECL_CONTEXT (field), DECL_NAME (decl),
4123 context, DECL_NAME (decl));
4124 DECL_CONTEXT (decl) = DECL_CONTEXT (field);
4126 if (processing_specialization
4127 && template_class_depth (context) == 0
4128 && CLASSTYPE_TEMPLATE_SPECIALIZATION (context))
4129 error ("template header not allowed in member definition "
4130 "of explicitly specialized class");
4131 /* Static data member are tricky; an in-class initialization
4132 still doesn't provide a definition, so the in-class
4133 declaration will have DECL_EXTERNAL set, but will have an
4134 initialization. Thus, duplicate_decls won't warn
4135 about this situation, and so we check here. */
4136 if (initialized && DECL_INITIALIZED_IN_CLASS_P (field))
4137 error ("duplicate initialization of %qD", decl);
4138 if (duplicate_decls (decl, field, /*newdecl_is_friend=*/false))
4144 tree field = check_classfn (context, decl,
4145 (processing_template_decl
4146 > template_class_depth (context))
4147 ? current_template_parms
4149 if (field && field != error_mark_node
4150 && duplicate_decls (decl, field,
4151 /*newdecl_is_friend=*/false))
4155 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
4156 DECL_IN_AGGR_P (decl) = 0;
4157 /* Do not mark DECL as an explicit specialization if it was not
4158 already marked as an instantiation; a declaration should
4159 never be marked as a specialization unless we know what
4160 template is being specialized. */
4161 if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
4163 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
4165 /* [temp.expl.spec] An explicit specialization of a static data
4166 member of a template is a definition if the declaration
4167 includes an initializer; otherwise, it is a declaration.
4169 We check for processing_specialization so this only applies
4170 to the new specialization syntax. */
4171 if (!initialized && processing_specialization)
4172 DECL_EXTERNAL (decl) = 1;
4175 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
4176 permerror (input_location, "declaration of %q#D outside of class is not definition",
4180 was_public = TREE_PUBLIC (decl);
4182 /* Enter this declaration into the symbol table. */
4183 decl = maybe_push_decl (decl);
4185 if (processing_template_decl)
4186 decl = push_template_decl (decl);
4187 if (decl == error_mark_node)
4188 return error_mark_node;
4190 /* Tell the back end to use or not use .common as appropriate. If we say
4191 -fconserve-space, we want this to save .data space, at the expense of
4192 wrong semantics. If we say -fno-conserve-space, we want this to
4193 produce errors about redefs; to do this we force variables into the
4195 if (flag_conserve_space
4196 && TREE_CODE (decl) == VAR_DECL
4197 && TREE_PUBLIC (decl)
4198 && !DECL_THREAD_LOCAL_P (decl)
4199 && !have_global_bss_p ())
4200 DECL_COMMON (decl) = 1;
4202 if (TREE_CODE (decl) == VAR_DECL
4203 && DECL_NAMESPACE_SCOPE_P (decl) && !TREE_PUBLIC (decl) && !was_public
4204 && !DECL_THIS_STATIC (decl) && !DECL_ARTIFICIAL (decl))
4206 /* This is a const variable with implicit 'static'. Set
4207 DECL_THIS_STATIC so we can tell it from variables that are
4208 !TREE_PUBLIC because of the anonymous namespace. */
4209 gcc_assert (cp_type_readonly (TREE_TYPE (decl)));
4210 DECL_THIS_STATIC (decl) = 1;
4213 if (!processing_template_decl && TREE_CODE (decl) == VAR_DECL)
4214 start_decl_1 (decl, initialized);
4219 /* Process the declaration of a variable DECL. INITIALIZED is true
4220 iff DECL is explicitly initialized. (INITIALIZED is false if the
4221 variable is initialized via an implicitly-called constructor.)
4222 This function must be called for ordinary variables (including, for
4223 example, implicit instantiations of templates), but must not be
4224 called for template declarations. */
4227 start_decl_1 (tree decl, bool initialized)
4231 bool aggregate_definition_p;
4233 gcc_assert (!processing_template_decl);
4235 if (error_operand_p (decl))
4238 gcc_assert (TREE_CODE (decl) == VAR_DECL);
4240 type = TREE_TYPE (decl);
4241 complete_p = COMPLETE_TYPE_P (type);
4242 aggregate_definition_p = MAYBE_CLASS_TYPE_P (type) && !DECL_EXTERNAL (decl);
4244 /* If an explicit initializer is present, or if this is a definition
4245 of an aggregate, then we need a complete type at this point.
4246 (Scalars are always complete types, so there is nothing to
4247 check.) This code just sets COMPLETE_P; errors (if necessary)
4248 are issued below. */
4249 if ((initialized || aggregate_definition_p)
4251 && COMPLETE_TYPE_P (complete_type (type)))
4254 /* We will not yet have set TREE_READONLY on DECL if the type
4255 was "const", but incomplete, before this point. But, now, we
4256 have a complete type, so we can try again. */
4257 cp_apply_type_quals_to_decl (cp_type_quals (type), decl);
4261 /* Is it valid for this decl to have an initializer at all? */
4263 /* Don't allow initializations for incomplete types except for
4264 arrays which might be completed by the initialization. */
4266 ; /* A complete type is ok. */
4267 else if (type_uses_auto (type))
4268 ; /* An auto type is ok. */
4269 else if (TREE_CODE (type) != ARRAY_TYPE)
4271 error ("variable %q#D has initializer but incomplete type", decl);
4272 type = TREE_TYPE (decl) = error_mark_node;
4274 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
4276 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
4277 error ("elements of array %q#D have incomplete type", decl);
4278 /* else we already gave an error in start_decl. */
4281 else if (aggregate_definition_p && !complete_p)
4283 if (type_uses_auto (type))
4284 error ("declaration of %q#D has no initializer", decl);
4286 error ("aggregate %q#D has incomplete type and cannot be defined",
4288 /* Change the type so that assemble_variable will give
4289 DECL an rtl we can live with: (mem (const_int 0)). */
4290 type = TREE_TYPE (decl) = error_mark_node;
4293 /* Create a new scope to hold this declaration if necessary.
4294 Whether or not a new scope is necessary cannot be determined
4295 until after the type has been completed; if the type is a
4296 specialization of a class template it is not until after
4297 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4298 will be set correctly. */
4299 maybe_push_cleanup_level (type);
4302 /* Handle initialization of references. DECL, TYPE, and INIT have the
4303 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
4304 but will be set to a new CLEANUP_STMT if a temporary is created
4305 that must be destroyed subsequently.
4307 Returns an initializer expression to use to initialize DECL, or
4308 NULL if the initialization can be performed statically.
4310 Quotes on semantics can be found in ARM 8.4.3. */
4313 grok_reference_init (tree decl, tree type, tree init, tree *cleanup)
4317 if (init == NULL_TREE)
4319 if ((DECL_LANG_SPECIFIC (decl) == 0
4320 || DECL_IN_AGGR_P (decl) == 0)
4321 && ! DECL_THIS_EXTERN (decl))
4322 error ("%qD declared as reference but not initialized", decl);
4326 if (TREE_CODE (init) == CONSTRUCTOR)
4328 error ("ISO C++ forbids use of initializer list to "
4329 "initialize reference %qD", decl);
4333 if (TREE_CODE (init) == TREE_LIST)
4334 init = build_x_compound_expr_from_list (init, "initializer");
4336 if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
4337 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
4338 /* Note: default conversion is only called in very special cases. */
4339 init = decay_conversion (init);
4341 /* Convert INIT to the reference type TYPE. This may involve the
4342 creation of a temporary, whose lifetime must be the same as that
4343 of the reference. If so, a DECL_EXPR for the temporary will be
4344 added just after the DECL_EXPR for DECL. That's why we don't set
4345 DECL_INITIAL for local references (instead assigning to them
4346 explicitly); we need to allow the temporary to be initialized
4348 tmp = initialize_reference (type, init, decl, cleanup);
4350 if (tmp == error_mark_node)
4352 else if (tmp == NULL_TREE)
4354 error ("cannot initialize %qT from %qT", type, TREE_TYPE (init));
4358 if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
4361 DECL_INITIAL (decl) = tmp;
4366 /* Subroutine of check_initializer. We're initializing a DECL of
4367 std::initializer_list<T> TYPE from a braced-init-list INIT, and need to
4368 extend the lifetime of the underlying array to match that of the decl,
4369 just like for reference initialization. CLEANUP is as for
4370 grok_reference_init. */
4373 build_init_list_var_init (tree decl, tree type, tree init, tree *cleanup)
4375 tree aggr_init, array, arrtype;
4376 init = perform_implicit_conversion (type, init, tf_warning_or_error);
4377 aggr_init = TARGET_EXPR_INITIAL (init);
4378 init = build2 (INIT_EXPR, type, decl, init);
4380 array = AGGR_INIT_EXPR_ARG (aggr_init, 1);
4381 arrtype = TREE_TYPE (array);
4383 gcc_assert (TREE_CODE (array) == ADDR_EXPR);
4384 array = TREE_OPERAND (array, 0);
4385 /* If the array is constant, finish_compound_literal already made it a
4386 static variable and we don't need to do anything here. */
4387 if (decl && TREE_CODE (array) == TARGET_EXPR)
4390 tree var = set_up_extended_ref_temp (decl, array, cleanup, &subinit);
4391 var = build_address (var);
4392 var = convert (arrtype, var);
4393 AGGR_INIT_EXPR_ARG (aggr_init, 1) = var;
4394 init = build2 (COMPOUND_EXPR, TREE_TYPE (init), subinit, init);
4399 /* Designated initializers in arrays are not supported in GNU C++.
4400 The parser cannot detect this error since it does not know whether
4401 a given brace-enclosed initializer is for a class type or for an
4402 array. This function checks that CE does not use a designated
4403 initializer. If it does, an error is issued. Returns true if CE
4404 is valid, i.e., does not have a designated initializer. */
4407 check_array_designated_initializer (const constructor_elt *ce)
4409 /* Designated initializers for array elements are not supported. */
4412 /* The parser only allows identifiers as designated
4414 if (ce->index == error_mark_node)
4415 error ("name used in a GNU-style designated "
4416 "initializer for an array");
4419 gcc_assert (TREE_CODE (ce->index) == IDENTIFIER_NODE);
4420 error ("name %qD used in a GNU-style designated "
4421 "initializer for an array", ce->index);
4429 /* When parsing `int a[] = {1, 2};' we don't know the size of the
4430 array until we finish parsing the initializer. If that's the
4431 situation we're in, update DECL accordingly. */
4434 maybe_deduce_size_from_array_init (tree decl, tree init)
4436 tree type = TREE_TYPE (decl);
4438 if (TREE_CODE (type) == ARRAY_TYPE
4439 && TYPE_DOMAIN (type) == NULL_TREE
4440 && TREE_CODE (decl) != TYPE_DECL)
4442 /* do_default is really a C-ism to deal with tentative definitions.
4443 But let's leave it here to ease the eventual merge. */
4444 int do_default = !DECL_EXTERNAL (decl);
4445 tree initializer = init ? init : DECL_INITIAL (decl);
4448 /* Check that there are no designated initializers in INIT, as
4449 those are not supported in GNU C++, and as the middle-end
4450 will crash if presented with a non-numeric designated
4452 if (initializer && TREE_CODE (initializer) == CONSTRUCTOR)
4454 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initializer);
4455 constructor_elt *ce;
4458 VEC_iterate (constructor_elt, v, i, ce);
4460 if (!check_array_designated_initializer (ce))
4466 failure = cp_complete_array_type (&TREE_TYPE (decl), initializer,
4470 error ("initializer fails to determine size of %qD", decl);
4471 TREE_TYPE (decl) = error_mark_node;
4473 else if (failure == 2)
4477 error ("array size missing in %qD", decl);
4478 TREE_TYPE (decl) = error_mark_node;
4480 /* If a `static' var's size isn't known, make it extern as
4481 well as static, so it does not get allocated. If it's not
4482 `static', then don't mark it extern; finish_incomplete_decl
4483 will give it a default size and it will get allocated. */
4484 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
4485 DECL_EXTERNAL (decl) = 1;
4487 else if (failure == 3)
4489 error ("zero-size array %qD", decl);
4490 TREE_TYPE (decl) = error_mark_node;
4494 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl)), decl);
4496 layout_decl (decl, 0);
4500 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
4501 any appropriate error messages regarding the layout. */
4504 layout_var_decl (tree decl)
4508 type = TREE_TYPE (decl);
4509 if (type == error_mark_node)
4512 /* If we haven't already layed out this declaration, do so now.
4513 Note that we must not call complete type for an external object
4514 because it's type might involve templates that we are not
4515 supposed to instantiate yet. (And it's perfectly valid to say
4516 `extern X x' for some incomplete type `X'.) */
4517 if (!DECL_EXTERNAL (decl))
4518 complete_type (type);
4519 if (!DECL_SIZE (decl)
4520 && TREE_TYPE (decl) != error_mark_node
4521 && (COMPLETE_TYPE_P (type)
4522 || (TREE_CODE (type) == ARRAY_TYPE
4523 && !TYPE_DOMAIN (type)
4524 && COMPLETE_TYPE_P (TREE_TYPE (type)))))
4525 layout_decl (decl, 0);
4527 if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
4529 /* An automatic variable with an incomplete type: that is an error.
4530 Don't talk about array types here, since we took care of that
4531 message in grokdeclarator. */
4532 error ("storage size of %qD isn't known", decl);
4533 TREE_TYPE (decl) = error_mark_node;
4536 /* Keep this code around in case we later want to control debug info
4537 based on whether a type is "used". (jason 1999-11-11) */
4539 else if (!DECL_EXTERNAL (decl) && MAYBE_CLASS_TYPE_P (ttype))
4540 /* Let debugger know it should output info for this type. */
4541 note_debug_info_needed (ttype);
4543 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
4544 note_debug_info_needed (DECL_CONTEXT (decl));
4547 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
4548 && DECL_SIZE (decl) != NULL_TREE
4549 && ! TREE_CONSTANT (DECL_SIZE (decl)))
4551 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
4552 constant_expression_warning (DECL_SIZE (decl));
4555 error ("storage size of %qD isn't constant", decl);
4556 TREE_TYPE (decl) = error_mark_node;
4561 /* If a local static variable is declared in an inline function, or if
4562 we have a weak definition, we must endeavor to create only one
4563 instance of the variable at link-time. */
4566 maybe_commonize_var (tree decl)
4568 /* Static data in a function with comdat linkage also has comdat
4570 if (TREE_STATIC (decl)
4571 /* Don't mess with __FUNCTION__. */
4572 && ! DECL_ARTIFICIAL (decl)
4573 && DECL_FUNCTION_SCOPE_P (decl)
4574 /* Unfortunately, import_export_decl has not always been called
4575 before the function is processed, so we cannot simply check
4577 && (DECL_COMDAT (DECL_CONTEXT (decl))
4578 || ((DECL_DECLARED_INLINE_P (DECL_CONTEXT (decl))
4579 || DECL_TEMPLATE_INSTANTIATION (DECL_CONTEXT (decl)))
4580 && TREE_PUBLIC (DECL_CONTEXT (decl)))))
4584 /* With weak symbols, we simply make the variable COMDAT;
4585 that will cause copies in multiple translations units to
4587 comdat_linkage (decl);
4591 if (DECL_INITIAL (decl) == NULL_TREE
4592 || DECL_INITIAL (decl) == error_mark_node)
4594 /* Without weak symbols, we can use COMMON to merge
4595 uninitialized variables. */
4596 TREE_PUBLIC (decl) = 1;
4597 DECL_COMMON (decl) = 1;
4601 /* While for initialized variables, we must use internal
4602 linkage -- which means that multiple copies will not
4604 TREE_PUBLIC (decl) = 0;
4605 DECL_COMMON (decl) = 0;
4606 warning (0, "sorry: semantics of inline function static "
4607 "data %q+#D are wrong (you'll wind up "
4608 "with multiple copies)", decl);
4609 warning (0, "%J you can work around this by removing "
4615 else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
4616 /* Set it up again; we might have set DECL_INITIAL since the last
4618 comdat_linkage (decl);
4621 /* Issue an error message if DECL is an uninitialized const variable. */
4624 check_for_uninitialized_const_var (tree decl)
4626 tree type = TREE_TYPE (decl);
4628 /* ``Unless explicitly declared extern, a const object does not have
4629 external linkage and must be initialized. ($8.4; $12.1)'' ARM
4631 if (TREE_CODE (decl) == VAR_DECL
4632 && TREE_CODE (type) != REFERENCE_TYPE
4633 && CP_TYPE_CONST_P (type)
4634 && !TYPE_NEEDS_CONSTRUCTING (type)
4635 && !DECL_INITIAL (decl))
4636 error ("uninitialized const %qD", decl);
4640 /* Structure holding the current initializer being processed by reshape_init.
4641 CUR is a pointer to the current element being processed, END is a pointer
4642 after the last element present in the initializer. */
4643 typedef struct reshape_iterator_t
4645 constructor_elt *cur;
4646 constructor_elt *end;
4649 static tree reshape_init_r (tree, reshape_iter *, bool);
4651 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
4652 returned is the next FIELD_DECL (possibly FIELD itself) that can be
4653 initialized. If there are no more such fields, the return value
4657 next_initializable_field (tree field)
4660 && (TREE_CODE (field) != FIELD_DECL
4661 || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
4662 || DECL_ARTIFICIAL (field)))
4663 field = TREE_CHAIN (field);
4668 /* Subroutine of reshape_init_array and reshape_init_vector, which does
4669 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
4670 INTEGER_CST representing the size of the array minus one (the maximum index),
4671 or NULL_TREE if the array was declared without specifying the size. D is
4672 the iterator within the constructor. */
4675 reshape_init_array_1 (tree elt_type, tree max_index, reshape_iter *d)
4678 bool sized_array_p = (max_index != NULL_TREE);
4679 unsigned HOST_WIDE_INT max_index_cst = 0;
4680 unsigned HOST_WIDE_INT index;
4682 /* The initializer for an array is always a CONSTRUCTOR. */
4683 new_init = build_constructor (init_list_type_node, NULL);
4687 /* Minus 1 is used for zero sized arrays. */
4688 if (integer_all_onesp (max_index))
4691 if (host_integerp (max_index, 1))
4692 max_index_cst = tree_low_cst (max_index, 1);
4693 /* sizetype is sign extended, not zero extended. */
4695 max_index_cst = tree_low_cst (fold_convert (size_type_node, max_index),
4699 /* Loop until there are no more initializers. */
4701 d->cur != d->end && (!sized_array_p || index <= max_index_cst);
4706 check_array_designated_initializer (d->cur);
4707 elt_init = reshape_init_r (elt_type, d, /*first_initializer_p=*/false);
4708 if (elt_init == error_mark_node)
4709 return error_mark_node;
4710 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), NULL_TREE, elt_init);
4716 /* Subroutine of reshape_init_r, processes the initializers for arrays.
4717 Parameters are the same of reshape_init_r. */
4720 reshape_init_array (tree type, reshape_iter *d)
4722 tree max_index = NULL_TREE;
4724 gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
4726 if (TYPE_DOMAIN (type))
4727 max_index = array_type_nelts (type);
4729 return reshape_init_array_1 (TREE_TYPE (type), max_index, d);
4732 /* Subroutine of reshape_init_r, processes the initializers for vectors.
4733 Parameters are the same of reshape_init_r. */
4736 reshape_init_vector (tree type, reshape_iter *d)
4738 tree max_index = NULL_TREE;
4741 gcc_assert (TREE_CODE (type) == VECTOR_TYPE);
4743 if (COMPOUND_LITERAL_P (d->cur->value))
4745 tree value = d->cur->value;
4746 if (!same_type_p (TREE_TYPE (value), type))
4748 error ("invalid type %qT as initializer for a vector of type %qT",
4749 TREE_TYPE (d->cur->value), type);
4750 value = error_mark_node;
4756 /* For a vector, the representation type is a struct
4757 containing a single member which is an array of the
4758 appropriate size. */
4759 rtype = TYPE_DEBUG_REPRESENTATION_TYPE (type);
4760 if (rtype && TYPE_DOMAIN (TREE_TYPE (TYPE_FIELDS (rtype))))
4761 max_index = array_type_nelts (TREE_TYPE (TYPE_FIELDS (rtype)));
4763 return reshape_init_array_1 (TREE_TYPE (type), max_index, d);
4766 /* Subroutine of reshape_init_r, processes the initializers for classes
4767 or union. Parameters are the same of reshape_init_r. */
4770 reshape_init_class (tree type, reshape_iter *d, bool first_initializer_p)
4775 gcc_assert (CLASS_TYPE_P (type));
4777 /* The initializer for a class is always a CONSTRUCTOR. */
4778 new_init = build_constructor (init_list_type_node, NULL);
4779 field = next_initializable_field (TYPE_FIELDS (type));
4785 An initializer for an aggregate member that is an
4786 empty class shall have the form of an empty
4787 initializer-list {}. */
4788 if (!first_initializer_p)
4790 error ("initializer for %qT must be brace-enclosed", type);
4791 return error_mark_node;
4796 /* Loop through the initializable fields, gathering initializers. */
4797 while (d->cur != d->end)
4801 /* Handle designated initializers, as an extension. */
4804 field = lookup_field_1 (type, d->cur->index, /*want_type=*/false);
4806 if (!field || TREE_CODE (field) != FIELD_DECL)
4808 error ("%qT has no non-static data member named %qD", type,
4810 return error_mark_node;
4814 /* If we processed all the member of the class, we are done. */
4818 field_init = reshape_init_r (TREE_TYPE (field), d,
4819 /*first_initializer_p=*/false);
4820 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), field, field_init);
4824 When a union is initialized with a brace-enclosed
4825 initializer, the braces shall only contain an
4826 initializer for the first member of the union. */
4827 if (TREE_CODE (type) == UNION_TYPE)
4830 field = next_initializable_field (TREE_CHAIN (field));
4836 /* Subroutine of reshape_init, which processes a single initializer (part of
4837 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
4838 iterator within the CONSTRUCTOR which points to the initializer to process.
4839 FIRST_INITIALIZER_P is true if this is the first initializer of the
4840 CONSTRUCTOR node. */
4843 reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p)
4845 tree init = d->cur->value;
4847 if (error_operand_p (init))
4848 return error_mark_node;
4850 /* A non-aggregate type is always initialized with a single
4852 if (!CP_AGGREGATE_TYPE_P (type))
4854 /* It is invalid to initialize a non-aggregate type with a
4855 brace-enclosed initializer before C++0x.
4856 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
4857 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
4858 a CONSTRUCTOR (with a record type). */
4859 if (TREE_CODE (init) == CONSTRUCTOR
4860 && BRACE_ENCLOSED_INITIALIZER_P (init)) /* p7626.C */
4862 if (SCALAR_TYPE_P (type))
4864 error ("braces around scalar initializer for type %qT", type);
4865 init = error_mark_node;
4868 maybe_warn_cpp0x ("extended initializer lists");
4877 All implicit type conversions (clause _conv_) are considered when
4878 initializing the aggregate member with an initializer from an
4879 initializer-list. If the initializer can initialize a member,
4880 the member is initialized. Otherwise, if the member is itself a
4881 non-empty subaggregate, brace elision is assumed and the
4882 initializer is considered for the initialization of the first
4883 member of the subaggregate. */
4884 if (TREE_CODE (init) != CONSTRUCTOR
4885 && can_convert_arg (type, TREE_TYPE (init), init, LOOKUP_NORMAL))
4891 /* [dcl.init.string]
4893 A char array (whether plain char, signed char, or unsigned char)
4894 can be initialized by a string-literal (optionally enclosed in
4895 braces); a wchar_t array can be initialized by a wide
4896 string-literal (optionally enclosed in braces). */
4897 if (TREE_CODE (type) == ARRAY_TYPE
4898 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
4900 tree str_init = init;
4902 /* Strip one level of braces if and only if they enclose a single
4903 element (as allowed by [dcl.init.string]). */
4904 if (!first_initializer_p
4905 && TREE_CODE (str_init) == CONSTRUCTOR
4906 && VEC_length (constructor_elt, CONSTRUCTOR_ELTS (str_init)) == 1)
4908 str_init = VEC_index (constructor_elt,
4909 CONSTRUCTOR_ELTS (str_init), 0)->value;
4912 /* If it's a string literal, then it's the initializer for the array
4913 as a whole. Otherwise, continue with normal initialization for
4914 array types (one value per array element). */
4915 if (TREE_CODE (str_init) == STRING_CST)
4922 /* The following cases are about aggregates. If we are not within a full
4923 initializer already, and there is not a CONSTRUCTOR, it means that there
4924 is a missing set of braces (that is, we are processing the case for
4925 which reshape_init exists). */
4926 if (!first_initializer_p)
4928 if (TREE_CODE (init) == CONSTRUCTOR)
4930 if (TREE_TYPE (init) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init)))
4931 /* There is no need to reshape pointer-to-member function
4932 initializers, as they are always constructed correctly
4933 by the front end. */
4935 else if (COMPOUND_LITERAL_P (init))
4936 /* For a nested compound literal, there is no need to reshape since
4937 brace elision is not allowed. Even if we decided to allow it,
4938 we should add a call to reshape_init in finish_compound_literal,
4939 before calling digest_init, so changing this code would still
4940 not be necessary. */
4941 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init));
4945 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
4946 return reshape_init (type, init);
4950 warning (OPT_Wmissing_braces, "missing braces around initializer for %qT",
4954 /* Dispatch to specialized routines. */
4955 if (CLASS_TYPE_P (type))
4956 return reshape_init_class (type, d, first_initializer_p);
4957 else if (TREE_CODE (type) == ARRAY_TYPE)
4958 return reshape_init_array (type, d);
4959 else if (TREE_CODE (type) == VECTOR_TYPE)
4960 return reshape_init_vector (type, d);
4965 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
4966 brace-enclosed aggregate initializer.
4968 INIT is the CONSTRUCTOR containing the list of initializers describing
4969 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
4970 It may not presently match the shape of the TYPE; for example:
4972 struct S { int a; int b; };
4973 struct S a[] = { 1, 2, 3, 4 };
4975 Here INIT will hold a VEC of four elements, rather than a
4976 VEC of two elements, each itself a VEC of two elements. This
4977 routine transforms INIT from the former form into the latter. The
4978 revised CONSTRUCTOR node is returned. */
4981 reshape_init (tree type, tree init)
4983 VEC(constructor_elt, gc) *v;
4987 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
4989 v = CONSTRUCTOR_ELTS (init);
4991 /* An empty constructor does not need reshaping, and it is always a valid
4993 if (VEC_empty (constructor_elt, v))
4996 /* Recurse on this CONSTRUCTOR. */
4997 d.cur = VEC_index (constructor_elt, v, 0);
4998 d.end = d.cur + VEC_length (constructor_elt, v);
5000 new_init = reshape_init_r (type, &d, true);
5001 if (new_init == error_mark_node)
5002 return error_mark_node;
5004 /* Make sure all the element of the constructor were used. Otherwise,
5005 issue an error about exceeding initializers. */
5007 error ("too many initializers for %qT", type);
5012 /* Verify array initializer. Returns true if errors have been reported. */
5015 check_array_initializer (tree decl, tree type, tree init)
5017 tree element_type = TREE_TYPE (type);
5019 /* The array type itself need not be complete, because the
5020 initializer may tell us how many elements are in the array.
5021 But, the elements of the array must be complete. */
5022 if (!COMPLETE_TYPE_P (complete_type (element_type)))
5025 error ("elements of array %q#D have incomplete type", decl);
5027 error ("elements of array %q#T have incomplete type", type);
5030 /* It is not valid to initialize a VLA. */
5032 && ((COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
5033 || !TREE_CONSTANT (TYPE_SIZE (element_type))))
5036 error ("variable-sized object %qD may not be initialized", decl);
5038 error ("variable-sized compound literal");
5044 /* Subroutine of check_initializer; args are passed down from that function.
5045 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
5048 build_aggr_init_full_exprs (tree decl, tree init, int flags)
5051 int saved_stmts_are_full_exprs_p = 0;
5052 if (building_stmt_tree ())
5054 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
5055 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
5057 init = build_aggr_init (decl, init, flags, tf_warning_or_error);
5058 if (building_stmt_tree ())
5059 current_stmt_tree ()->stmts_are_full_exprs_p =
5060 saved_stmts_are_full_exprs_p;
5064 /* Verify INIT (the initializer for DECL), and record the
5065 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
5066 grok_reference_init.
5068 If the return value is non-NULL, it is an expression that must be
5069 evaluated dynamically to initialize DECL. */
5072 check_initializer (tree decl, tree init, int flags, tree *cleanup)
5074 tree type = TREE_TYPE (decl);
5075 tree init_code = NULL;
5077 /* Things that are going to be initialized need to have complete
5079 TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
5081 if (type == error_mark_node)
5082 /* We will have already complained. */
5085 if (TREE_CODE (type) == ARRAY_TYPE)
5087 if (check_array_initializer (decl, type, init))
5090 else if (!COMPLETE_TYPE_P (type))
5092 error ("%qD has incomplete type", decl);
5093 TREE_TYPE (decl) = error_mark_node;
5097 /* There is no way to make a variable-sized class type in GNU C++. */
5098 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type)));
5100 if (init && BRACE_ENCLOSED_INITIALIZER_P (init))
5102 int init_len = VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init));
5103 if (SCALAR_TYPE_P (type))
5107 maybe_warn_cpp0x ("extended initializer lists");
5108 init = build_zero_init (type, NULL_TREE, false);
5110 else if (init_len != 1)
5112 error ("scalar object %qD requires one element in initializer",
5114 TREE_TYPE (decl) = error_mark_node;
5120 if (TREE_CODE (decl) == CONST_DECL)
5122 gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);
5124 DECL_INITIAL (decl) = init;
5126 gcc_assert (init != NULL_TREE);
5129 else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
5130 init = grok_reference_init (decl, type, init, cleanup);
5133 /* Do not reshape constructors of vectors (they don't need to be
5135 if (BRACE_ENCLOSED_INITIALIZER_P (init))
5137 if (is_std_init_list (type))
5138 return build_init_list_var_init (decl, type, init, cleanup);
5139 else if (TYPE_NON_AGGREGATE_CLASS (type))
5141 /* Don't reshape if the class has constructors. */
5142 if (cxx_dialect == cxx98)
5143 error ("in C++98 %qD must be initialized by constructor, "
5146 init = build_tree_list (NULL_TREE, init);
5148 else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_VECTOR_OPAQUE (type))
5150 error ("opaque vector types cannot be initialized");
5151 init = error_mark_node;
5154 init = reshape_init (type, init);
5157 /* If DECL has an array type without a specific bound, deduce the
5158 array size from the initializer. */
5159 maybe_deduce_size_from_array_init (decl, init);
5160 type = TREE_TYPE (decl);
5161 if (type == error_mark_node)
5164 if (TYPE_NEEDS_CONSTRUCTING (type)
5165 || (CLASS_TYPE_P (type)
5166 && !BRACE_ENCLOSED_INITIALIZER_P (init)))
5167 return build_aggr_init_full_exprs (decl, init, flags);
5168 else if (TREE_CODE (init) != TREE_VEC)
5170 init_code = store_init_value (decl, init);
5171 if (pedantic && TREE_CODE (type) == ARRAY_TYPE
5172 && DECL_INITIAL (decl)
5173 && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST
5174 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl)))
5175 warning (0, "array %qD initialized by parenthesized string literal %qE",
5176 decl, DECL_INITIAL (decl));
5180 else if (DECL_EXTERNAL (decl))
5182 else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
5183 return build_aggr_init_full_exprs (decl, init, flags);
5184 else if (MAYBE_CLASS_TYPE_P (type))
5186 tree core_type = strip_array_types (type);
5188 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
5189 error ("structure %qD with uninitialized const members", decl);
5190 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
5191 error ("structure %qD with uninitialized reference members", decl);
5193 check_for_uninitialized_const_var (decl);
5196 check_for_uninitialized_const_var (decl);
5198 if (init && init != error_mark_node)
5199 init_code = build2 (INIT_EXPR, type, decl, init);
5204 /* If DECL is not a local variable, give it RTL. */
5207 make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
5209 int toplev = toplevel_bindings_p ();
5211 const char *filename;
5213 /* Set the DECL_ASSEMBLER_NAME for the object. */
5216 /* The `register' keyword, when used together with an
5217 asm-specification, indicates that the variable should be
5218 placed in a particular register. */
5219 if (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
5221 set_user_assembler_name (decl, asmspec);
5222 DECL_HARD_REGISTER (decl) = 1;
5226 if (TREE_CODE (decl) == FUNCTION_DECL
5227 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
5228 set_builtin_user_assembler_name (decl, asmspec);
5229 set_user_assembler_name (decl, asmspec);
5233 /* Handle non-variables up front. */
5234 if (TREE_CODE (decl) != VAR_DECL)
5236 rest_of_decl_compilation (decl, toplev, at_eof);
5240 /* If we see a class member here, it should be a static data
5242 if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
5244 gcc_assert (TREE_STATIC (decl));
5245 /* An in-class declaration of a static data member should be
5246 external; it is only a declaration, and not a definition. */
5247 if (init == NULL_TREE)
5248 gcc_assert (DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl));
5251 /* We don't create any RTL for local variables. */
5252 if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
5255 /* We defer emission of local statics until the corresponding
5256 DECL_EXPR is expanded. */
5257 defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
5259 /* We try to defer namespace-scope static constants so that they are
5260 not emitted into the object file unnecessarily. */
5261 filename = input_filename;
5262 if (!DECL_VIRTUAL_P (decl)
5263 && TREE_READONLY (decl)
5264 && DECL_INITIAL (decl) != NULL_TREE
5265 && DECL_INITIAL (decl) != error_mark_node
5267 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
5269 && !TREE_PUBLIC (decl))
5271 /* Fool with the linkage of static consts according to #pragma
5273 struct c_fileinfo *finfo = get_fileinfo (filename);
5274 if (!finfo->interface_unknown && !TREE_PUBLIC (decl))
5276 TREE_PUBLIC (decl) = 1;
5277 DECL_EXTERNAL (decl) = finfo->interface_only;
5282 /* Likewise for template instantiations. */
5283 else if (DECL_LANG_SPECIFIC (decl)
5284 && DECL_IMPLICIT_INSTANTIATION (decl))
5287 /* If we're not deferring, go ahead and assemble the variable. */
5289 rest_of_decl_compilation (decl, toplev, at_eof);
5292 /* walk_tree helper for wrap_temporary_cleanups, below. */
5295 wrap_cleanups_r (tree *stmt_p, int *walk_subtrees, void *data)
5297 if (TYPE_P (*stmt_p))
5303 if (TREE_CODE (*stmt_p) == TARGET_EXPR)
5305 tree guard = (tree)data;
5306 tree tcleanup = TARGET_EXPR_CLEANUP (*stmt_p);
5308 tcleanup = build2 (TRY_CATCH_EXPR, void_type_node, tcleanup, guard);
5309 /* Tell honor_protect_cleanup_actions to handle this as a separate
5311 TRY_CATCH_IS_CLEANUP (tcleanup) = 1;
5313 TARGET_EXPR_CLEANUP (*stmt_p) = tcleanup;
5319 /* We're initializing a local variable which has a cleanup GUARD. If there
5320 are any temporaries used in the initializer INIT of this variable, we
5321 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
5322 variable will be cleaned up properly if one of them throws.
5324 Unfortunately, there's no way to express this properly in terms of
5325 nesting, as the regions for the temporaries overlap the region for the
5326 variable itself; if there are two temporaries, the variable needs to be
5327 the first thing destroyed if either of them throws. However, we only
5328 want to run the variable's cleanup if it actually got constructed. So
5329 we need to guard the temporary cleanups with the variable's cleanup if
5330 they are run on the normal path, but not if they are run on the
5331 exceptional path. We implement this by telling
5332 honor_protect_cleanup_actions to strip the variable cleanup from the
5333 exceptional path. */
5336 wrap_temporary_cleanups (tree init, tree guard)
5338 cp_walk_tree_without_duplicates (&init, wrap_cleanups_r, (void *)guard);
5341 /* Generate code to initialize DECL (a local variable). */
5344 initialize_local_var (tree decl, tree init)
5346 tree type = TREE_TYPE (decl);
5350 gcc_assert (TREE_CODE (decl) == VAR_DECL
5351 || TREE_CODE (decl) == RESULT_DECL);
5352 gcc_assert (!TREE_STATIC (decl));
5354 if (DECL_SIZE (decl) == NULL_TREE)
5356 /* If we used it already as memory, it must stay in memory. */
5357 DECL_INITIAL (decl) = NULL_TREE;
5358 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
5362 if (type == error_mark_node)
5365 /* Compute and store the initial value. */
5366 already_used = TREE_USED (decl) || TREE_USED (type);
5368 /* Generate a cleanup, if necessary. */
5369 cleanup = cxx_maybe_build_cleanup (decl);
5371 /* Perform the initialization. */
5374 int saved_stmts_are_full_exprs_p;
5376 /* If we're only initializing a single object, guard the destructors
5377 of any temporaries used in its initializer with its destructor.
5378 This isn't right for arrays because each element initialization is
5379 a full-expression. */
5380 if (cleanup && TREE_CODE (type) != ARRAY_TYPE)
5381 wrap_temporary_cleanups (init, cleanup);
5383 gcc_assert (building_stmt_tree ());
5384 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
5385 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
5386 finish_expr_stmt (init);
5387 current_stmt_tree ()->stmts_are_full_exprs_p =
5388 saved_stmts_are_full_exprs_p;
5391 /* Set this to 0 so we can tell whether an aggregate which was
5392 initialized was ever used. Don't do this if it has a
5393 destructor, so we don't complain about the 'resource
5394 allocation is initialization' idiom. Now set
5395 attribute((unused)) on types so decls of that type will be
5396 marked used. (see TREE_USED, above.) */
5397 if (TYPE_NEEDS_CONSTRUCTING (type)
5399 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
5400 && DECL_NAME (decl))
5401 TREE_USED (decl) = 0;
5402 else if (already_used)
5403 TREE_USED (decl) = 1;
5406 finish_decl_cleanup (decl, cleanup);
5409 /* DECL is a VAR_DECL for a compiler-generated variable with static
5410 storage duration (like a virtual table) whose initializer is a
5411 compile-time constant. INIT must be either a TREE_LIST of values,
5412 or a CONSTRUCTOR. Initialize the variable and provide it to the
5416 initialize_artificial_var (tree decl, tree init)
5418 gcc_assert (DECL_ARTIFICIAL (decl));
5419 if (TREE_CODE (init) == TREE_LIST)
5420 init = build_constructor_from_list (TREE_TYPE (decl), init);
5421 gcc_assert (TREE_CODE (init) == CONSTRUCTOR);
5422 DECL_INITIAL (decl) = init;
5423 DECL_INITIALIZED_P (decl) = 1;
5424 determine_visibility (decl);
5425 layout_var_decl (decl);
5426 maybe_commonize_var (decl);
5427 make_rtl_for_nonlocal_decl (decl, init, /*asmspec=*/NULL);
5430 /* INIT is the initializer for a variable, as represented by the
5431 parser. Returns true iff INIT is value-dependent. */
5434 value_dependent_init_p (tree init)
5436 if (TREE_CODE (init) == TREE_LIST)
5437 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
5438 return any_value_dependent_elements_p (init);
5439 else if (TREE_CODE (init) == CONSTRUCTOR)
5440 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
5442 VEC(constructor_elt, gc) *elts;
5446 elts = CONSTRUCTOR_ELTS (init);
5447 nelts = VEC_length (constructor_elt, elts);
5448 for (i = 0; i < nelts; ++i)
5449 if (value_dependent_init_p (VEC_index (constructor_elt,
5454 /* It must be a simple expression, e.g., int i = 3; */
5455 return value_dependent_expression_p (init);
5460 /* Finish processing of a declaration;
5461 install its line number and initial value.
5462 If the length of an array type is not known before,
5463 it must be determined now, from the initial value, or it is an error.
5465 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
5466 true, then INIT is an integral constant expression.
5468 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
5469 if the (init) syntax was used. */
5472 cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
5473 tree asmspec_tree, int flags)
5477 const char *asmspec = NULL;
5478 int was_readonly = 0;
5479 bool var_definition_p = false;
5480 int saved_processing_template_decl;
5483 if (decl == error_mark_node)
5488 error ("assignment (not initialization) in declaration");
5492 gcc_assert (TREE_CODE (decl) != RESULT_DECL);
5493 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
5494 gcc_assert (TREE_CODE (decl) != PARM_DECL);
5496 type = TREE_TYPE (decl);
5497 if (type == error_mark_node)
5500 /* Assume no cleanup is required. */
5501 cleanup = NULL_TREE;
5502 saved_processing_template_decl = processing_template_decl;
5504 /* If a name was specified, get the string. */
5505 if (global_scope_p (current_binding_level))
5506 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
5507 if (asmspec_tree && asmspec_tree != error_mark_node)
5508 asmspec = TREE_STRING_POINTER (asmspec_tree);
5510 if (current_class_type
5511 && CP_DECL_CONTEXT (decl) == current_class_type
5512 && TYPE_BEING_DEFINED (current_class_type)
5513 && (DECL_INITIAL (decl) || init))
5514 DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
5516 auto_node = type_uses_auto (type);
5519 if (init == NULL_TREE)
5521 error ("declaration of %q#D has no initializer", decl);
5522 TREE_TYPE (decl) = error_mark_node;
5525 else if (describable_type (init))
5527 type = TREE_TYPE (decl) = do_auto_deduction (type, init, auto_node);
5528 if (type == error_mark_node)
5533 if (init && TREE_CODE (decl) == FUNCTION_DECL)
5535 if (init == ridpointers[(int)RID_DELETE])
5537 /* FIXME check this is 1st decl. */
5538 DECL_DELETED_FN (decl) = 1;
5539 DECL_DECLARED_INLINE_P (decl) = 1;
5540 DECL_INITIAL (decl) = error_mark_node;
5543 else if (init == ridpointers[(int)RID_DEFAULT])
5545 if (!defaultable_fn_p (decl))
5547 error ("%qD cannot be defaulted", decl);
5548 DECL_INITIAL (decl) = NULL_TREE;
5551 DECL_DEFAULTED_FN (decl) = 1;
5555 if (processing_template_decl)
5557 bool type_dependent_p;
5559 /* Add this declaration to the statement-tree. */
5560 if (at_function_scope_p ())
5561 add_decl_expr (decl);
5563 type_dependent_p = dependent_type_p (type);
5565 if (check_for_bare_parameter_packs (init))
5568 DECL_INITIAL (decl) = NULL_TREE;
5571 if (init && init_const_expr_p && TREE_CODE (decl) == VAR_DECL)
5573 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
5574 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl))
5575 TREE_CONSTANT (decl) = 1;
5578 /* Generally, initializers in templates are expanded when the
5579 template is instantiated. But, if DECL is an integral
5580 constant static data member, then it can be used in future
5581 integral constant expressions, and its value must be
5584 && DECL_CLASS_SCOPE_P (decl)
5585 && DECL_INTEGRAL_CONSTANT_VAR_P (decl)
5586 && !type_dependent_p
5587 && !value_dependent_init_p (init)))
5590 DECL_INITIAL (decl) = init;
5591 if (TREE_CODE (decl) == VAR_DECL
5592 && !DECL_PRETTY_FUNCTION_P (decl)
5593 && !type_dependent_p)
5594 maybe_deduce_size_from_array_init (decl, init);
5598 if (TREE_CODE (init) == TREE_LIST)
5600 /* If the parenthesized-initializer form was used (e.g.,
5601 "int A<N>::i(X)"), then INIT will be a TREE_LIST of initializer
5602 arguments. (There is generally only one.) We convert them
5605 for (; list; list = TREE_CHAIN (list))
5607 tree elt = TREE_VALUE (list);
5608 TREE_VALUE (list) = fold_non_dependent_expr (elt);
5612 init = fold_non_dependent_expr (init);
5613 processing_template_decl = 0;
5616 /* Take care of TYPE_DECLs up front. */
5617 if (TREE_CODE (decl) == TYPE_DECL)
5619 if (type != error_mark_node
5620 && MAYBE_CLASS_TYPE_P (type) && DECL_NAME (decl))
5622 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
5623 warning (0, "shadowing previous type declaration of %q#D", decl);
5624 set_identifier_type_value (DECL_NAME (decl), decl);
5627 /* If we have installed this as the canonical typedef for this
5628 type, and that type has not been defined yet, delay emitting
5629 the debug information for it, as we will emit it later. */
5630 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
5631 && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
5632 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
5634 rest_of_decl_compilation (decl, DECL_CONTEXT (decl) == NULL_TREE,
5639 /* A reference will be modified here, as it is initialized. */
5640 if (! DECL_EXTERNAL (decl)
5641 && TREE_READONLY (decl)
5642 && TREE_CODE (type) == REFERENCE_TYPE)
5645 TREE_READONLY (decl) = 0;
5648 if (TREE_CODE (decl) == VAR_DECL)
5650 /* Only PODs can have thread-local storage. Other types may require
5651 various kinds of non-trivial initialization. */
5652 if (DECL_THREAD_LOCAL_P (decl) && !pod_type_p (TREE_TYPE (decl)))
5653 error ("%qD cannot be thread-local because it has non-POD type %qT",
5654 decl, TREE_TYPE (decl));
5655 /* If this is a local variable that will need a mangled name,
5656 register it now. We must do this before processing the
5657 initializer for the variable, since the initialization might
5658 require a guard variable, and since the mangled name of the
5659 guard variable will depend on the mangled name of this
5661 if (DECL_FUNCTION_SCOPE_P (decl)
5662 && TREE_STATIC (decl)
5663 && !DECL_ARTIFICIAL (decl))
5664 push_local_name (decl);
5665 /* Convert the initializer to the type of DECL, if we have not
5666 already initialized DECL. */
5667 if (!DECL_INITIALIZED_P (decl)
5668 /* If !DECL_EXTERNAL then DECL is being defined. In the
5669 case of a static data member initialized inside the
5670 class-specifier, there can be an initializer even if DECL
5671 is *not* defined. */
5672 && (!DECL_EXTERNAL (decl) || init))
5674 if (TYPE_FOR_JAVA (type) && MAYBE_CLASS_TYPE_P (type))
5677 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
5678 /* Allow libjava/prims.cc define primitive classes. */
5679 if (init != NULL_TREE
5680 || jclass == NULL_TREE
5681 || TREE_CODE (jclass) != TYPE_DECL
5682 || !POINTER_TYPE_P (TREE_TYPE (jclass))
5683 || !same_type_ignoring_top_level_qualifiers_p
5684 (type, TREE_TYPE (TREE_TYPE (jclass))))
5685 error ("Java object %qD not allocated with %<new%>", decl);
5690 DECL_NONTRIVIALLY_INITIALIZED_P (decl) = 1;
5691 if (init_const_expr_p)
5693 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
5694 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl))
5695 TREE_CONSTANT (decl) = 1;
5698 init = check_initializer (decl, init, flags, &cleanup);
5699 /* Thread-local storage cannot be dynamically initialized. */
5700 if (DECL_THREAD_LOCAL_P (decl) && init)
5702 error ("%qD is thread-local and so cannot be dynamically "
5703 "initialized", decl);
5707 /* Check that the initializer for a static data member was a
5708 constant. Although we check in the parser that the
5709 initializer is an integral constant expression, we do not
5710 simplify division-by-zero at the point at which it
5711 occurs. Therefore, in:
5713 struct S { static const int i = 7 / 0; };
5715 we issue an error at this point. It would
5716 probably be better to forbid division by zero in
5717 integral constant expressions. */
5718 if (DECL_EXTERNAL (decl) && init)
5720 error ("%qD cannot be initialized by a non-constant expression"
5721 " when being declared", decl);
5722 DECL_INITIALIZED_IN_CLASS_P (decl) = 0;
5730 The memory occupied by any object of static storage
5731 duration is zero-initialized at program startup before
5732 any other initialization takes place.
5734 We cannot create an appropriate initializer until after
5735 the type of DECL is finalized. If DECL_INITIAL is set,
5736 then the DECL is statically initialized, and any
5737 necessary zero-initialization has already been performed. */
5738 if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
5739 DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
5740 /*nelts=*/NULL_TREE,
5741 /*static_storage_p=*/true);
5742 /* Remember that the initialization for this variable has
5744 DECL_INITIALIZED_P (decl) = 1;
5745 /* This declaration is the definition of this variable,
5746 unless we are initializing a static data member within
5747 the class specifier. */
5748 if (!DECL_EXTERNAL (decl))
5749 var_definition_p = true;
5751 /* If the variable has an array type, lay out the type, even if
5752 there is no initializer. It is valid to index through the
5753 array, and we must get TYPE_ALIGN set correctly on the array
5755 else if (TREE_CODE (type) == ARRAY_TYPE)
5758 else if (TREE_CODE (decl) == FIELD_DECL
5759 && TYPE_FOR_JAVA (type) && MAYBE_CLASS_TYPE_P (type))
5760 error ("non-static data member %qD has Java class type", decl);
5762 /* Add this declaration to the statement-tree. This needs to happen
5763 after the call to check_initializer so that the DECL_EXPR for a
5764 reference temp is added before the DECL_EXPR for the reference itself. */
5765 if (at_function_scope_p ())
5766 add_decl_expr (decl);
5768 /* Let the middle end know about variables and functions -- but not
5769 static data members in uninstantiated class templates. */
5770 if (!saved_processing_template_decl
5771 && (TREE_CODE (decl) == VAR_DECL
5772 || TREE_CODE (decl) == FUNCTION_DECL))
5774 if (TREE_CODE (decl) == VAR_DECL)
5776 layout_var_decl (decl);
5777 maybe_commonize_var (decl);
5780 /* This needs to happen after the linkage is set. */
5781 determine_visibility (decl);
5783 if (var_definition_p && TREE_STATIC (decl))
5785 /* If a TREE_READONLY variable needs initialization
5786 at runtime, it is no longer readonly and we need to
5787 avoid MEM_READONLY_P being set on RTL created for it. */
5790 if (TREE_READONLY (decl))
5791 TREE_READONLY (decl) = 0;
5794 else if (was_readonly)
5795 TREE_READONLY (decl) = 1;
5798 make_rtl_for_nonlocal_decl (decl, init, asmspec);
5800 /* Check for abstractness of the type. Notice that there is no
5801 need to strip array types here since the check for those types
5802 is already done within create_array_type_for_decl. */
5803 if (TREE_CODE (type) == FUNCTION_TYPE
5804 || TREE_CODE (type) == METHOD_TYPE)
5805 abstract_virtuals_error (decl, TREE_TYPE (type));
5807 abstract_virtuals_error (decl, type);
5809 if (TREE_TYPE (decl) == error_mark_node)
5810 /* No initialization required. */
5812 else if (TREE_CODE (decl) == FUNCTION_DECL)
5816 if (init == ridpointers[(int)RID_DEFAULT])
5818 /* An out-of-class default definition is defined at
5819 the point where it is explicitly defaulted. */
5820 if (DECL_INITIAL (decl) == error_mark_node)
5821 synthesize_method (decl);
5824 error ("function %q#D is initialized like a variable", decl);
5826 /* else no initialization required. */
5828 else if (DECL_EXTERNAL (decl)
5829 && ! (DECL_LANG_SPECIFIC (decl)
5830 && DECL_NOT_REALLY_EXTERN (decl)))
5833 DECL_INITIAL (decl) = init;
5835 /* A variable definition. */
5836 else if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
5837 /* Initialize the local variable. */
5838 initialize_local_var (decl, init);
5840 /* If a variable is defined, and then a subsequent
5841 definition with external linkage is encountered, we will
5842 get here twice for the same variable. We want to avoid
5843 calling expand_static_init more than once. For variables
5844 that are not static data members, we can call
5845 expand_static_init only when we actually process the
5846 initializer. It is not legal to redeclare a static data
5847 member, so this issue does not arise in that case. */
5848 else if (var_definition_p && TREE_STATIC (decl))
5849 expand_static_init (decl, init);
5852 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
5853 reference, insert it in the statement-tree now. */
5855 push_cleanup (decl, cleanup, false);
5858 processing_template_decl = saved_processing_template_decl;
5861 TREE_READONLY (decl) = 1;
5863 /* If this was marked 'used', be sure it will be output. */
5864 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
5865 mark_decl_referenced (decl);
5868 /* This is here for a midend callback from c-common.c. */
5871 finish_decl (tree decl, tree init, tree asmspec_tree)
5873 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, asmspec_tree, 0);
5876 /* Returns a declaration for a VAR_DECL as if:
5878 extern "C" TYPE NAME;
5880 had been seen. Used to create compiler-generated global
5884 declare_global_var (tree name, tree type)
5888 push_to_top_level ();
5889 decl = build_decl (VAR_DECL, name, type);
5890 TREE_PUBLIC (decl) = 1;
5891 DECL_EXTERNAL (decl) = 1;
5892 DECL_ARTIFICIAL (decl) = 1;
5893 /* If the user has explicitly declared this variable (perhaps
5894 because the code we are compiling is part of a low-level runtime
5895 library), then it is possible that our declaration will be merged
5896 with theirs by pushdecl. */
5897 decl = pushdecl (decl);
5898 finish_decl (decl, NULL_TREE, NULL_TREE);
5899 pop_from_top_level ();
5904 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
5905 if "__cxa_atexit" is not being used) corresponding to the function
5906 to be called when the program exits. */
5909 get_atexit_fn_ptr_type (void)
5914 if (!atexit_fn_ptr_type_node)
5916 if (flag_use_cxa_atexit
5917 && !targetm.cxx.use_atexit_for_cxa_atexit ())
5918 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
5919 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5921 /* The parameter to "atexit" is "void (*)(void)". */
5922 arg_types = void_list_node;
5924 fn_type = build_function_type (void_type_node, arg_types);
5925 atexit_fn_ptr_type_node = build_pointer_type (fn_type);
5928 return atexit_fn_ptr_type_node;
5931 /* Returns a pointer to the `atexit' function. Note that if
5932 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
5933 `__cxa_atexit' function specified in the IA64 C++ ABI. */
5936 get_atexit_node (void)
5943 bool use_aeabi_atexit;
5948 if (flag_use_cxa_atexit && !targetm.cxx.use_atexit_for_cxa_atexit ())
5950 /* The declaration for `__cxa_atexit' is:
5952 int __cxa_atexit (void (*)(void *), void *, void *)
5954 We build up the argument types and then then function type
5957 use_aeabi_atexit = targetm.cxx.use_aeabi_atexit ();
5958 /* First, build the pointer-to-function type for the first
5960 fn_ptr_type = get_atexit_fn_ptr_type ();
5961 /* Then, build the rest of the argument types. */
5962 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5963 if (use_aeabi_atexit)
5965 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
5966 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
5970 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
5971 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
5973 /* And the final __cxa_atexit type. */
5974 fn_type = build_function_type (integer_type_node, arg_types);
5975 fn_ptr_type = build_pointer_type (fn_type);
5976 if (use_aeabi_atexit)
5977 name = "__aeabi_atexit";
5979 name = "__cxa_atexit";
5983 /* The declaration for `atexit' is:
5985 int atexit (void (*)());
5987 We build up the argument types and then then function type
5989 fn_ptr_type = get_atexit_fn_ptr_type ();
5990 arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
5991 /* Build the final atexit type. */
5992 fn_type = build_function_type (integer_type_node, arg_types);
5996 /* Now, build the function declaration. */
5997 push_lang_context (lang_name_c);
5998 atexit_fndecl = build_library_fn_ptr (name, fn_type);
5999 mark_used (atexit_fndecl);
6000 pop_lang_context ();
6001 atexit_node = decay_conversion (atexit_fndecl);
6006 /* Returns the __dso_handle VAR_DECL. */
6009 get_dso_handle_node (void)
6011 if (dso_handle_node)
6012 return dso_handle_node;
6014 /* Declare the variable. */
6015 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
6018 return dso_handle_node;
6021 /* Begin a new function with internal linkage whose job will be simply
6022 to destroy some particular variable. */
6024 static GTY(()) int start_cleanup_cnt;
6027 start_cleanup_fn (void)
6032 bool use_cxa_atexit = flag_use_cxa_atexit
6033 && !targetm.cxx.use_atexit_for_cxa_atexit ();
6035 push_to_top_level ();
6037 /* No need to mangle this. */
6038 push_lang_context (lang_name_c);
6040 /* Build the name of the function. */
6041 sprintf (name, "__tcf_%d", start_cleanup_cnt++);
6042 /* Build the function declaration. */
6043 fntype = TREE_TYPE (get_atexit_fn_ptr_type ());
6044 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
6045 /* It's a function with internal linkage, generated by the
6047 TREE_PUBLIC (fndecl) = 0;
6048 DECL_ARTIFICIAL (fndecl) = 1;
6049 /* Make the function `inline' so that it is only emitted if it is
6050 actually needed. It is unlikely that it will be inlined, since
6051 it is only called via a function pointer, but we avoid unnecessary
6052 emissions this way. */
6053 DECL_DECLARED_INLINE_P (fndecl) = 1;
6054 DECL_INTERFACE_KNOWN (fndecl) = 1;
6055 /* Build the parameter. */
6060 parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
6061 DECL_CONTEXT (parmdecl) = fndecl;
6062 TREE_USED (parmdecl) = 1;
6063 DECL_ARGUMENTS (fndecl) = parmdecl;
6067 start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED);
6069 pop_lang_context ();
6071 return current_function_decl;
6074 /* Finish the cleanup function begun by start_cleanup_fn. */
6077 end_cleanup_fn (void)
6079 expand_or_defer_fn (finish_function (0));
6081 pop_from_top_level ();
6084 /* Generate code to handle the destruction of DECL, an object with
6085 static storage duration. */
6088 register_dtor_fn (tree decl)
6097 type = TREE_TYPE (decl);
6098 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
6099 return void_zero_node;
6101 /* If we're using "__cxa_atexit" (or "__aeabi_atexit"), and DECL is
6102 a class object, we can just pass the destructor to
6103 "__cxa_atexit"; we don't have to build a temporary function to do
6105 use_dtor = (flag_use_cxa_atexit
6106 && !targetm.cxx.use_atexit_for_cxa_atexit ()
6107 && CLASS_TYPE_P (type));
6112 /* Find the destructor. */
6113 idx = lookup_fnfields_1 (type, complete_dtor_identifier);
6114 gcc_assert (idx >= 0);
6115 cleanup = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), idx);
6116 /* Make sure it is accessible. */
6117 perform_or_defer_access_check (TYPE_BINFO (type), cleanup, cleanup);
6121 /* Call build_cleanup before we enter the anonymous function so
6122 that any access checks will be done relative to the current
6123 scope, rather than the scope of the anonymous function. */
6124 build_cleanup (decl);
6126 /* Now start the function. */
6127 cleanup = start_cleanup_fn ();
6129 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
6130 to the original function, rather than the anonymous one. That
6131 will make the back end think that nested functions are in use,
6132 which causes confusion. */
6133 push_deferring_access_checks (dk_no_check);
6134 fcall = build_cleanup (decl);
6135 pop_deferring_access_checks ();
6137 /* Create the body of the anonymous function. */
6138 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
6139 finish_expr_stmt (fcall);
6140 finish_compound_stmt (compound_stmt);
6144 /* Call atexit with the cleanup function. */
6145 mark_used (cleanup);
6146 cleanup = build_address (cleanup);
6147 if (flag_use_cxa_atexit && !targetm.cxx.use_atexit_for_cxa_atexit ())
6153 /* We must convert CLEANUP to the type that "__cxa_atexit"
6155 cleanup = build_nop (get_atexit_fn_ptr_type (), cleanup);
6156 /* "__cxa_atexit" will pass the address of DECL to the
6157 cleanup function. */
6159 addr = build_address (decl);
6160 /* The declared type of the parameter to "__cxa_atexit" is
6161 "void *". For plain "T*", we could just let the
6162 machinery in cp_build_function_call convert it -- but if the
6163 type is "cv-qualified T *", then we need to convert it
6164 before passing it in, to avoid spurious errors. */
6165 addr = build_nop (ptr_type_node, addr);
6168 /* Since the cleanup functions we build ignore the address
6169 they're given, there's no reason to pass the actual address
6170 in, and, in general, it's cheaper to pass NULL than any
6172 addr = null_pointer_node;
6173 args = tree_cons (NULL_TREE,
6174 cp_build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0,
6175 tf_warning_or_error),
6177 if (targetm.cxx.use_aeabi_atexit ())
6179 args = tree_cons (NULL_TREE, cleanup, args);
6180 args = tree_cons (NULL_TREE, addr, args);
6184 args = tree_cons (NULL_TREE, addr, args);
6185 args = tree_cons (NULL_TREE, cleanup, args);
6189 args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
6190 return cp_build_function_call (get_atexit_node (), args,
6191 tf_warning_or_error);
6194 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
6195 is its initializer. Generate code to handle the construction
6196 and destruction of DECL. */
6199 expand_static_init (tree decl, tree init)
6201 gcc_assert (TREE_CODE (decl) == VAR_DECL);
6202 gcc_assert (TREE_STATIC (decl));
6204 /* Some variables require no initialization. */
6206 && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
6207 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
6210 if (DECL_FUNCTION_SCOPE_P (decl))
6212 /* Emit code to perform this initialization but once. */
6213 tree if_stmt = NULL_TREE, inner_if_stmt = NULL_TREE;
6214 tree then_clause = NULL_TREE, inner_then_clause = NULL_TREE;
6215 tree guard, guard_addr;
6216 tree acquire_fn, release_fn, abort_fn;
6219 /* Emit code to perform this initialization but once. This code
6222 static <type> guard;
6223 if (!guard.first_byte) {
6224 if (__cxa_guard_acquire (&guard)) {
6227 // Do initialization.
6228 flag = true; __cxa_guard_release (&guard);
6229 // Register variable for destruction at end of program.
6231 if (!flag) __cxa_guard_abort (&guard);
6235 Note that the `flag' variable is only set to 1 *after* the
6236 initialization is complete. This ensures that an exception,
6237 thrown during the construction, will cause the variable to
6238 reinitialized when we pass through this code again, as per:
6242 If the initialization exits by throwing an exception, the
6243 initialization is not complete, so it will be tried again
6244 the next time control enters the declaration.
6246 This process should be thread-safe, too; multiple threads
6247 should not be able to initialize the variable more than
6250 /* Create the guard variable. */
6251 guard = get_guard (decl);
6253 /* This optimization isn't safe on targets with relaxed memory
6254 consistency. On such targets we force synchronization in
6255 __cxa_guard_acquire. */
6256 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
6258 /* Begin the conditional initialization. */
6259 if_stmt = begin_if_stmt ();
6260 finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
6261 then_clause = begin_compound_stmt (BCS_NO_SCOPE);
6264 if (flag_threadsafe_statics)
6266 guard_addr = build_address (guard);
6268 acquire_fn = get_identifier ("__cxa_guard_acquire");
6269 release_fn = get_identifier ("__cxa_guard_release");
6270 abort_fn = get_identifier ("__cxa_guard_abort");
6271 if (!get_global_value_if_present (acquire_fn, &acquire_fn))
6273 tree argtypes = tree_cons (NULL_TREE, TREE_TYPE (guard_addr),
6275 tree vfntype = build_function_type (void_type_node, argtypes);
6276 acquire_fn = push_library_fn
6277 (acquire_fn, build_function_type (integer_type_node, argtypes),
6279 release_fn = push_library_fn (release_fn, vfntype, NULL_TREE);
6280 abort_fn = push_library_fn (abort_fn, vfntype, NULL_TREE);
6284 release_fn = identifier_global_value (release_fn);
6285 abort_fn = identifier_global_value (abort_fn);
6288 inner_if_stmt = begin_if_stmt ();
6289 finish_if_stmt_cond (build_call_n (acquire_fn, 1, guard_addr),
6292 inner_then_clause = begin_compound_stmt (BCS_NO_SCOPE);
6293 begin = get_target_expr (boolean_false_node);
6294 flag = TARGET_EXPR_SLOT (begin);
6296 TARGET_EXPR_CLEANUP (begin)
6297 = build3 (COND_EXPR, void_type_node, flag,
6299 build_call_n (abort_fn, 1, guard_addr));
6300 CLEANUP_EH_ONLY (begin) = 1;
6302 /* Do the initialization itself. */
6303 init = add_stmt_to_compound (begin, init);
6304 init = add_stmt_to_compound
6305 (init, build2 (MODIFY_EXPR, void_type_node, flag, boolean_true_node));
6306 init = add_stmt_to_compound
6307 (init, build_call_n (release_fn, 1, guard_addr));
6310 init = add_stmt_to_compound (init, set_guard (guard));
6312 /* Use atexit to register a function for destroying this static
6314 init = add_stmt_to_compound (init, register_dtor_fn (decl));
6316 finish_expr_stmt (init);
6318 if (flag_threadsafe_statics)
6320 finish_compound_stmt (inner_then_clause);
6321 finish_then_clause (inner_if_stmt);
6322 finish_if_stmt (inner_if_stmt);
6325 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
6327 finish_compound_stmt (then_clause);
6328 finish_then_clause (if_stmt);
6329 finish_if_stmt (if_stmt);
6333 static_aggregates = tree_cons (init, decl, static_aggregates);
6337 /* Make TYPE a complete type based on INITIAL_VALUE.
6338 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6339 2 if there was no information (in which case assume 0 if DO_DEFAULT),
6340 3 if the initializer list is empty (in pedantic mode). */
6343 cp_complete_array_type (tree *ptype, tree initial_value, bool do_default)
6346 tree type, elt_type;
6350 unsigned HOST_WIDE_INT i;
6353 /* An array of character type can be initialized from a
6354 brace-enclosed string constant.
6356 FIXME: this code is duplicated from reshape_init. Probably
6357 we should just call reshape_init here? */
6358 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype)))
6359 && TREE_CODE (initial_value) == CONSTRUCTOR
6360 && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (initial_value)))
6362 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
6363 tree value = VEC_index (constructor_elt, v, 0)->value;
6365 if (TREE_CODE (value) == STRING_CST
6366 && VEC_length (constructor_elt, v) == 1)
6367 initial_value = value;
6370 /* If any of the elements are parameter packs, we can't actually
6371 complete this type now because the array size is dependent. */
6372 if (TREE_CODE (initial_value) == CONSTRUCTOR)
6374 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value),
6377 if (PACK_EXPANSION_P (value))
6383 failure = complete_array_type (ptype, initial_value, do_default);
6385 /* We can create the array before the element type is complete, which
6386 means that we didn't have these two bits set in the original type
6387 either. In completing the type, we are expected to propagate these
6388 bits. See also complete_type which does the same thing for arrays
6391 if (TYPE_DOMAIN (type))
6393 elt_type = TREE_TYPE (type);
6394 TYPE_NEEDS_CONSTRUCTING (type) = TYPE_NEEDS_CONSTRUCTING (elt_type);
6395 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
6396 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type);
6402 /* Return zero if something is declared to be a member of type
6403 CTYPE when in the context of CUR_TYPE. STRING is the error
6404 message to print in that case. Otherwise, quietly return 1. */
6407 member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
6409 if (ctype && ctype != cur_type)
6411 if (flags == DTOR_FLAG)
6412 error ("destructor for alien class %qT cannot be a member", ctype);
6414 error ("constructor for alien class %qT cannot be a member", ctype);
6420 /* Subroutine of `grokdeclarator'. */
6422 /* Generate errors possibly applicable for a given set of specifiers.
6423 This is for ARM $7.1.2. */
6426 bad_specifiers (tree object,
6435 error ("%qD declared as a %<virtual%> %s", object, type);
6437 error ("%qD declared as an %<inline%> %s", object, type);
6439 error ("%<const%> and %<volatile%> function specifiers on "
6440 "%qD invalid in %s declaration",
6443 error ("%q+D declared as a friend", object);
6445 && (TREE_CODE (object) == TYPE_DECL
6446 || (!TYPE_PTRFN_P (TREE_TYPE (object))
6447 && !TYPE_REFFN_P (TREE_TYPE (object))
6448 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
6449 error ("%q+D declared with an exception specification", object);
6452 /* DECL is a member function or static data member and is presently
6453 being defined. Check that the definition is taking place in a
6457 check_class_member_definition_namespace (tree decl)
6459 /* These checks only apply to member functions and static data
6461 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
6462 || TREE_CODE (decl) == VAR_DECL);
6463 /* We check for problems with specializations in pt.c in
6464 check_specialization_namespace, where we can issue better
6466 if (processing_specialization)
6468 /* There are no restrictions on the placement of
6469 explicit instantiations. */
6470 if (processing_explicit_instantiation)
6474 A member function definition that appears outside of the
6475 class definition shall appear in a namespace scope enclosing
6476 the class definition.
6480 The definition for a static data member shall appear in a
6481 namespace scope enclosing the member's class definition. */
6482 if (!is_ancestor (current_namespace, DECL_CONTEXT (decl)))
6483 permerror (input_location, "definition of %qD is not in namespace enclosing %qT",
6484 decl, DECL_CONTEXT (decl));
6487 /* Build a PARM_DECL for the "this" parameter. TYPE is the
6488 METHOD_TYPE for a non-static member function; QUALS are the
6489 cv-qualifiers that apply to the function. */
6492 build_this_parm (tree type, cp_cv_quals quals)
6497 cp_cv_quals this_quals;
6499 this_type = TREE_VALUE (TYPE_ARG_TYPES (type));
6500 /* The `this' parameter is implicitly `const'; it cannot be
6502 this_quals = (quals & TYPE_QUAL_RESTRICT) | TYPE_QUAL_CONST;
6503 qual_type = cp_build_qualified_type (this_type, this_quals);
6504 parm = build_artificial_parm (this_identifier, qual_type);
6505 cp_apply_type_quals_to_decl (this_quals, parm);
6509 /* CTYPE is class type, or null if non-class.
6510 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
6512 DECLARATOR is the function's name.
6513 PARMS is a chain of PARM_DECLs for the function.
6514 VIRTUALP is truthvalue of whether the function is virtual or not.
6515 FLAGS are to be passed through to `grokclassfn'.
6516 QUALS are qualifiers indicating whether the function is `const'
6518 RAISES is a list of exceptions that this function can raise.
6519 CHECK is 1 if we must find this method in CTYPE, 0 if we should
6520 not look, and -1 if we should not call `grokclassfn' at all.
6522 SFK is the kind of special function (if any) for the new function.
6524 Returns `NULL_TREE' if something goes wrong, after issuing
6525 applicable error messages. */
6528 grokfndecl (tree ctype,
6532 tree orig_declarator,
6534 enum overload_flags flags,
6541 special_function_kind sfk,
6546 location_t location)
6549 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
6553 type = build_exception_variant (type, raises);
6555 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
6557 /* If we have an explicit location, use it, otherwise use whatever
6558 build_lang_decl used (probably input_location). */
6559 if (location != UNKNOWN_LOCATION)
6560 DECL_SOURCE_LOCATION (decl) = location;
6562 if (TREE_CODE (type) == METHOD_TYPE)
6565 parm = build_this_parm (type, quals);
6566 TREE_CHAIN (parm) = parms;
6569 DECL_ARGUMENTS (decl) = parms;
6570 for (t = parms; t; t = TREE_CHAIN (t))
6571 DECL_CONTEXT (t) = decl;
6572 /* Propagate volatile out from type to decl. */
6573 if (TYPE_VOLATILE (type))
6574 TREE_THIS_VOLATILE (decl) = 1;
6576 /* Setup decl according to sfk. */
6579 case sfk_constructor:
6580 case sfk_copy_constructor:
6581 DECL_CONSTRUCTOR_P (decl) = 1;
6583 case sfk_destructor:
6584 DECL_DESTRUCTOR_P (decl) = 1;
6590 /* If pointers to member functions use the least significant bit to
6591 indicate whether a function is virtual, ensure a pointer
6592 to this function will have that bit clear. */
6593 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
6594 && TREE_CODE (type) == METHOD_TYPE
6595 && DECL_ALIGN (decl) < 2 * BITS_PER_UNIT)
6596 DECL_ALIGN (decl) = 2 * BITS_PER_UNIT;
6599 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
6603 ("defining explicit specialization %qD in friend declaration",
6607 tree fns = TREE_OPERAND (orig_declarator, 0);
6608 tree args = TREE_OPERAND (orig_declarator, 1);
6610 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
6612 /* Something like `template <class T> friend void f<T>()'. */
6613 error ("invalid use of template-id %qD in declaration "
6614 "of primary template",
6620 /* A friend declaration of the form friend void f<>(). Record
6621 the information in the TEMPLATE_ID_EXPR. */
6622 SET_DECL_IMPLICIT_INSTANTIATION (decl);
6624 if (TREE_CODE (fns) == COMPONENT_REF)
6626 /* Due to bison parser ickiness, we will have already looked
6627 up an operator_name or PFUNCNAME within the current class
6628 (see template_id in parse.y). If the current class contains
6629 such a name, we'll get a COMPONENT_REF here. Undo that. */
6631 gcc_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
6632 == current_class_type);
6633 fns = TREE_OPERAND (fns, 1);
6635 gcc_assert (TREE_CODE (fns) == IDENTIFIER_NODE
6636 || TREE_CODE (fns) == OVERLOAD);
6637 DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
6639 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
6640 if (TREE_PURPOSE (t)
6641 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
6643 error ("default arguments are not allowed in declaration "
6644 "of friend template specialization %qD",
6651 error ("%<inline%> is not allowed in declaration of friend "
6652 "template specialization %qD",
6659 /* If this decl has namespace scope, set that up. */
6661 set_decl_namespace (decl, in_namespace, friendp);
6663 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
6665 /* `main' and builtins have implicit 'C' linkage. */
6666 if ((MAIN_NAME_P (declarator)
6667 || (IDENTIFIER_LENGTH (declarator) > 10
6668 && IDENTIFIER_POINTER (declarator)[0] == '_'
6669 && IDENTIFIER_POINTER (declarator)[1] == '_'
6670 && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
6671 && current_lang_name == lang_name_cplusplus
6672 && ctype == NULL_TREE
6673 /* NULL_TREE means global namespace. */
6674 && DECL_CONTEXT (decl) == NULL_TREE)
6675 SET_DECL_LANGUAGE (decl, lang_c);
6677 /* Should probably propagate const out from type to decl I bet (mrs). */
6680 DECL_STATIC_FUNCTION_P (decl) = 1;
6681 DECL_CONTEXT (decl) = ctype;
6686 DECL_CONTEXT (decl) = ctype;
6688 check_class_member_definition_namespace (decl);
6691 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
6693 if (processing_template_decl)
6694 error ("cannot declare %<::main%> to be a template");
6696 error ("cannot declare %<::main%> to be inline");
6698 error ("cannot declare %<::main%> to be static");
6703 /* Members of anonymous types and local classes have no linkage; make
6704 them internal. If a typedef is made later, this will be changed. */
6705 if (ctype && (TYPE_ANONYMOUS_P (ctype)
6706 || decl_function_context (TYPE_MAIN_DECL (ctype))))
6711 /* [basic.link]: A name with no linkage (notably, the name of a class
6712 or enumeration declared in a local scope) shall not be used to
6713 declare an entity with linkage.
6715 Only check this for public decls for now. See core 319, 389. */
6716 t = no_linkage_check (TREE_TYPE (decl),
6717 /*relaxed_p=*/false);
6720 if (TYPE_ANONYMOUS_P (t))
6722 if (DECL_EXTERN_C_P (decl))
6723 /* Allow this; it's pretty common in C. */;
6726 permerror (input_location, "non-local function %q#D uses anonymous type",
6728 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
6729 permerror (input_location, "%q+#D does not refer to the unqualified "
6730 "type, so it is not used for linkage",
6735 permerror (input_location, "non-local function %q#D uses local type %qT", decl, t);
6739 TREE_PUBLIC (decl) = publicp;
6742 DECL_INTERFACE_KNOWN (decl) = 1;
6743 DECL_NOT_REALLY_EXTERN (decl) = 1;
6746 /* If the declaration was declared inline, mark it as such. */
6748 DECL_DECLARED_INLINE_P (decl) = 1;
6750 DECL_EXTERNAL (decl) = 1;
6751 if (quals && TREE_CODE (type) == FUNCTION_TYPE)
6754 ? G_("static member function %qD cannot have cv-qualifier")
6755 : G_("non-member function %qD cannot have cv-qualifier"),
6757 quals = TYPE_UNQUALIFIED;
6760 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl))
6761 && !grok_op_properties (decl, /*complain=*/true))
6764 if (ctype && decl_function_context (decl))
6765 DECL_NO_STATIC_CHAIN (decl) = 1;
6768 /* Make the init_value nonzero so pushdecl knows this is not
6769 tentative. error_mark_node is replaced later with the BLOCK. */
6770 DECL_INITIAL (decl) = error_mark_node;
6772 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
6773 TREE_NOTHROW (decl) = 1;
6775 /* Caller will do the rest of this. */
6779 if (ctype != NULL_TREE)
6780 grokclassfn (ctype, decl, flags);
6782 decl = check_explicit_specialization (orig_declarator, decl,
6785 4 * (friendp != 0));
6786 if (decl == error_mark_node)
6791 cplus_decl_attributes (&decl, *attrlist, 0);
6792 *attrlist = NULL_TREE;
6795 /* Check main's type after attributes have been applied. */
6796 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
6798 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
6801 tree oldtypeargs = TYPE_ARG_TYPES (TREE_TYPE (decl));
6803 error ("%<::main%> must return %<int%>");
6804 newtype = build_function_type (integer_type_node, oldtypeargs);
6805 TREE_TYPE (decl) = newtype;
6808 check_main_parameter_types (decl);
6811 if (ctype != NULL_TREE
6812 && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
6815 tree old_decl = check_classfn (ctype, decl,
6816 (processing_template_decl
6817 > template_class_depth (ctype))
6818 ? current_template_parms
6821 if (old_decl == error_mark_node)
6829 if (TREE_CODE (old_decl) == TEMPLATE_DECL)
6830 /* Because grokfndecl is always supposed to return a
6831 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
6832 here. We depend on our callers to figure out that its
6833 really a template that's being returned. */
6834 old_decl = DECL_TEMPLATE_RESULT (old_decl);
6836 if (DECL_STATIC_FUNCTION_P (old_decl)
6837 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
6838 /* Remove the `this' parm added by grokclassfn.
6839 XXX Isn't this done in start_function, too? */
6840 revert_static_member_fn (decl);
6841 if (DECL_ARTIFICIAL (old_decl))
6843 error ("definition of implicitly-declared %qD", old_decl);
6847 /* Since we've smashed OLD_DECL to its
6848 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
6849 if (TREE_CODE (decl) == TEMPLATE_DECL)
6850 decl = DECL_TEMPLATE_RESULT (decl);
6852 /* Attempt to merge the declarations. This can fail, in
6853 the case of some invalid specialization declarations. */
6854 pushed_scope = push_scope (ctype);
6855 ok = duplicate_decls (decl, old_decl, friendp);
6857 pop_scope (pushed_scope);
6860 error ("no %q#D member function declared in class %qT",
6868 if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
6871 if (ctype == NULL_TREE || check)
6875 DECL_VIRTUAL_P (decl) = 1;
6880 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
6881 the linkage that DECL will receive in the object file. */
6884 set_linkage_for_static_data_member (tree decl)
6886 /* A static data member always has static storage duration and
6887 external linkage. Note that static data members are forbidden in
6888 local classes -- the only situation in which a class has
6889 non-external linkage. */
6890 TREE_PUBLIC (decl) = 1;
6891 TREE_STATIC (decl) = 1;
6892 /* For non-template classes, static data members are always put
6893 out in exactly those files where they are defined, just as
6894 with ordinary namespace-scope variables. */
6895 if (!processing_template_decl)
6896 DECL_INTERFACE_KNOWN (decl) = 1;
6899 /* Create a VAR_DECL named NAME with the indicated TYPE.
6901 If SCOPE is non-NULL, it is the class type or namespace containing
6902 the variable. If SCOPE is NULL, the variable should is created in
6903 the innermost enclosings scope. */
6906 grokvardecl (tree type,
6908 const cp_decl_specifier_seq *declspecs,
6914 tree explicit_scope;
6916 gcc_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE);
6918 /* Compute the scope in which to place the variable, but remember
6919 whether or not that scope was explicitly specified by the user. */
6920 explicit_scope = scope;
6923 /* An explicit "extern" specifier indicates a namespace-scope
6925 if (declspecs->storage_class == sc_extern)
6926 scope = current_namespace;
6927 else if (!at_function_scope_p ())
6928 scope = current_scope ();
6932 && (/* If the variable is a namespace-scope variable declared in a
6933 template, we need DECL_LANG_SPECIFIC. */
6934 (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
6935 /* Similarly for namespace-scope variables with language linkage
6937 || (TREE_CODE (scope) == NAMESPACE_DECL
6938 && current_lang_name != lang_name_cplusplus)
6939 /* Similarly for static data members. */
6941 decl = build_lang_decl (VAR_DECL, name, type);
6943 decl = build_decl (VAR_DECL, name, type);
6945 if (explicit_scope && TREE_CODE (explicit_scope) == NAMESPACE_DECL)
6946 set_decl_namespace (decl, explicit_scope, 0);
6948 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
6950 if (declspecs->storage_class == sc_extern)
6952 DECL_THIS_EXTERN (decl) = 1;
6953 DECL_EXTERNAL (decl) = !initialized;
6956 if (DECL_CLASS_SCOPE_P (decl))
6958 set_linkage_for_static_data_member (decl);
6959 /* This function is only called with out-of-class definitions. */
6960 DECL_EXTERNAL (decl) = 0;
6961 check_class_member_definition_namespace (decl);
6963 /* At top level, either `static' or no s.c. makes a definition
6964 (perhaps tentative), and absence of `static' makes it public. */
6965 else if (toplevel_bindings_p ())
6967 TREE_PUBLIC (decl) = (declspecs->storage_class != sc_static
6968 && (DECL_THIS_EXTERN (decl) || ! constp));
6969 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
6971 /* Not at top level, only `static' makes a static definition. */
6974 TREE_STATIC (decl) = declspecs->storage_class == sc_static;
6975 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
6978 if (declspecs->specs[(int)ds_thread])
6979 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
6981 if (TREE_PUBLIC (decl))
6983 /* [basic.link]: A name with no linkage (notably, the name of a class
6984 or enumeration declared in a local scope) shall not be used to
6985 declare an entity with linkage.
6987 Only check this for public decls for now. */
6988 tree t = no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false);
6991 if (TYPE_ANONYMOUS_P (t))
6993 if (DECL_EXTERN_C_P (decl))
6994 /* Allow this; it's pretty common in C. */
6998 /* DRs 132, 319 and 389 seem to indicate types with
6999 no linkage can only be used to declare extern "C"
7000 entities. Since it's not always an error in the
7001 ISO C++ 90 Standard, we only issue a warning. */
7002 warning (0, "non-local variable %q#D uses anonymous type",
7004 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
7005 warning (0, "%q+#D does not refer to the unqualified "
7006 "type, so it is not used for linkage",
7011 warning (0, "non-local variable %q#D uses local type %qT", decl, t);
7015 DECL_INTERFACE_KNOWN (decl) = 1;
7020 /* Create and return a canonical pointer to member function type, for
7021 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
7024 build_ptrmemfunc_type (tree type)
7028 tree unqualified_variant = NULL_TREE;
7030 if (type == error_mark_node)
7033 /* If a canonical type already exists for this type, use it. We use
7034 this method instead of type_hash_canon, because it only does a
7035 simple equality check on the list of field members. */
7037 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
7040 /* Make sure that we always have the unqualified pointer-to-member
7042 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
7044 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
7046 t = make_class_type (RECORD_TYPE);
7047 xref_basetypes (t, NULL_TREE);
7049 /* Let the front end know this is a pointer to member function... */
7050 TYPE_PTRMEMFUNC_FLAG (t) = 1;
7051 /* ... and not really a class type. */
7052 SET_CLASS_TYPE_P (t, 0);
7054 field = build_decl (FIELD_DECL, pfn_identifier, type);
7057 field = build_decl (FIELD_DECL, delta_identifier, delta_type_node);
7058 TREE_CHAIN (field) = fields;
7061 finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
7063 /* Zap out the name so that the back end will give us the debugging
7064 information for this anonymous RECORD_TYPE. */
7065 TYPE_NAME (t) = NULL_TREE;
7067 /* If this is not the unqualified form of this pointer-to-member
7068 type, set the TYPE_MAIN_VARIANT for this type to be the
7069 unqualified type. Since they are actually RECORD_TYPEs that are
7070 not variants of each other, we must do this manually. */
7071 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
7073 t = build_qualified_type (t, cp_type_quals (type));
7074 TYPE_MAIN_VARIANT (t) = unqualified_variant;
7075 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
7076 TYPE_NEXT_VARIANT (unqualified_variant) = t;
7077 TREE_TYPE (TYPE_BINFO (t)) = t;
7080 /* Cache this pointer-to-member type so that we can find it again
7082 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
7084 if (TYPE_STRUCTURAL_EQUALITY_P (type))
7085 SET_TYPE_STRUCTURAL_EQUALITY (t);
7086 else if (TYPE_CANONICAL (type) != type)
7087 TYPE_CANONICAL (t) = build_ptrmemfunc_type (TYPE_CANONICAL (type));
7092 /* Create and return a pointer to data member type. */
7095 build_ptrmem_type (tree class_type, tree member_type)
7097 if (TREE_CODE (member_type) == METHOD_TYPE)
7101 arg_types = TYPE_ARG_TYPES (member_type);
7102 class_type = (cp_build_qualified_type
7104 cp_type_quals (TREE_TYPE (TREE_VALUE (arg_types)))));
7106 = build_method_type_directly (class_type,
7107 TREE_TYPE (member_type),
7108 TREE_CHAIN (arg_types));
7109 return build_ptrmemfunc_type (build_pointer_type (member_type));
7113 gcc_assert (TREE_CODE (member_type) != FUNCTION_TYPE);
7114 return build_offset_type (class_type, member_type);
7118 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
7119 Check to see that the definition is valid. Issue appropriate error
7120 messages. Return 1 if the definition is particularly bad, or 0
7124 check_static_variable_definition (tree decl, tree type)
7126 /* Motion 10 at San Diego: If a static const integral data member is
7127 initialized with an integral constant expression, the initializer
7128 may appear either in the declaration (within the class), or in
7129 the definition, but not both. If it appears in the class, the
7130 member is a member constant. The file-scope definition is always
7132 if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
7134 error ("invalid in-class initialization of static data member "
7135 "of non-integral type %qT",
7137 /* If we just return the declaration, crashes will sometimes
7138 occur. We therefore return void_type_node, as if this were a
7139 friend declaration, to cause callers to completely ignore
7140 this declaration. */
7143 else if (!CP_TYPE_CONST_P (type))
7144 error ("ISO C++ forbids in-class initialization of non-const "
7145 "static member %qD",
7147 else if (!INTEGRAL_TYPE_P (type))
7148 pedwarn (input_location, OPT_pedantic, "ISO C++ forbids initialization of member constant "
7149 "%qD of non-integral type %qT", decl, type);
7154 /* Given the SIZE (i.e., number of elements) in an array, compute an
7155 appropriate index type for the array. If non-NULL, NAME is the
7156 name of the thing being declared. */
7159 compute_array_index_type (tree name, tree size)
7163 tree abi_1_itype = NULL_TREE;
7165 if (error_operand_p (size))
7166 return error_mark_node;
7168 type = TREE_TYPE (size);
7169 /* The array bound must be an integer type. */
7170 if (!dependent_type_p (type) && !INTEGRAL_TYPE_P (type))
7173 error ("size of array %qD has non-integral type %qT", name, type);
7175 error ("size of array has non-integral type %qT", type);
7176 size = integer_one_node;
7177 type = TREE_TYPE (size);
7180 /* We can only call value_dependent_expression_p on integral constant
7181 expressions; the parser adds a dummy NOP_EXPR with TREE_SIDE_EFFECTS
7182 set if this isn't one. */
7183 if (processing_template_decl
7184 && (TREE_SIDE_EFFECTS (size) || value_dependent_expression_p (size)))
7186 /* We cannot do any checking for a SIZE that isn't known to be
7187 constant. Just build the index type and mark that it requires
7188 structural equality checks. */
7189 itype = build_index_type (build_min (MINUS_EXPR, sizetype,
7190 size, integer_one_node));
7191 if (!TREE_SIDE_EFFECTS (size))
7193 TYPE_DEPENDENT_P (itype) = 1;
7194 TYPE_DEPENDENT_P_VALID (itype) = 1;
7196 SET_TYPE_STRUCTURAL_EQUALITY (itype);
7200 if (!abi_version_at_least (2) && processing_template_decl)
7201 /* For abi-1, we handled all instances in templates the same way,
7202 even when they were non-dependent. This affects the manglings
7203 produced. So, we do the normal checking for non-dependent
7204 sizes, but at the end we'll return the same type that abi-1
7205 would have, but with TYPE_CANONICAL set to the "right"
7206 value that the current ABI would provide. */
7207 abi_1_itype = build_index_type (build_min (MINUS_EXPR, sizetype,
7208 size, integer_one_node));
7210 /* The size might be the result of a cast. */
7211 STRIP_TYPE_NOPS (size);
7213 /* It might be a const variable or enumeration constant. */
7214 size = integral_constant_value (size);
7216 /* Normally, the array-bound will be a constant. */
7217 if (TREE_CODE (size) == INTEGER_CST)
7219 /* Check to see if the array bound overflowed. Make that an
7220 error, no matter how generous we're being. */
7221 constant_expression_error (size);
7223 /* An array must have a positive number of elements. */
7224 if (INT_CST_LT (size, integer_zero_node))
7227 error ("size of array %qD is negative", name);
7229 error ("size of array is negative");
7230 size = integer_one_node;
7232 /* As an extension we allow zero-sized arrays. We always allow
7233 them in system headers because glibc uses them. */
7234 else if (integer_zerop (size) && !in_system_header)
7237 pedwarn (input_location, OPT_pedantic, "ISO C++ forbids zero-size array %qD", name);
7239 pedwarn (input_location, OPT_pedantic, "ISO C++ forbids zero-size array");
7242 else if (TREE_CONSTANT (size))
7244 /* `(int) &fn' is not a valid array bound. */
7246 error ("size of array %qD is not an integral constant-expression",
7249 error ("size of array is not an integral constant-expression");
7250 size = integer_one_node;
7252 else if (pedantic && warn_vla != 0)
7255 pedwarn (input_location, OPT_Wvla, "ISO C++ forbids variable length array %qD", name);
7257 pedwarn (input_location, OPT_Wvla, "ISO C++ forbids variable length array");
7259 else if (warn_vla > 0)
7263 "variable length array %qD is used", name);
7266 "variable length array is used");
7269 if (processing_template_decl && !TREE_CONSTANT (size))
7270 /* A variable sized array. */
7271 itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node);
7274 HOST_WIDE_INT saved_processing_template_decl;
7276 /* Compute the index of the largest element in the array. It is
7277 one less than the number of elements in the array. We save
7278 and restore PROCESSING_TEMPLATE_DECL so that computations in
7279 cp_build_binary_op will be appropriately folded. */
7280 saved_processing_template_decl = processing_template_decl;
7281 processing_template_decl = 0;
7282 itype = cp_build_binary_op (input_location,
7284 cp_convert (ssizetype, size),
7285 cp_convert (ssizetype, integer_one_node),
7286 tf_warning_or_error);
7287 itype = fold (itype);
7288 processing_template_decl = saved_processing_template_decl;
7290 if (!TREE_CONSTANT (itype))
7291 /* A variable sized array. */
7292 itype = variable_size (itype);
7293 /* Make sure that there was no overflow when creating to a signed
7294 index type. (For example, on a 32-bit machine, an array with
7295 size 2^32 - 1 is too big.) */
7296 else if (TREE_CODE (itype) == INTEGER_CST
7297 && TREE_OVERFLOW (itype))
7299 error ("overflow in array dimension");
7300 TREE_OVERFLOW (itype) = 0;
7304 /* Create and return the appropriate index type. */
7307 tree t = build_index_type (itype);
7308 TYPE_CANONICAL (abi_1_itype) = TYPE_CANONICAL (t);
7312 return build_index_type (itype);
7315 /* Returns the scope (if any) in which the entity declared by
7316 DECLARATOR will be located. If the entity was declared with an
7317 unqualified name, NULL_TREE is returned. */
7320 get_scope_of_declarator (const cp_declarator *declarator)
7322 while (declarator && declarator->kind != cdk_id)
7323 declarator = declarator->declarator;
7325 /* If the declarator-id is a SCOPE_REF, the scope in which the
7326 declaration occurs is the first operand. */
7328 && declarator->u.id.qualifying_scope)
7329 return declarator->u.id.qualifying_scope;
7331 /* Otherwise, the declarator is not a qualified name; the entity will
7332 be declared in the current scope. */
7336 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
7337 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
7341 create_array_type_for_decl (tree name, tree type, tree size)
7343 tree itype = NULL_TREE;
7344 const char* error_msg;
7346 /* If things have already gone awry, bail now. */
7347 if (type == error_mark_node || size == error_mark_node)
7348 return error_mark_node;
7350 /* Assume that everything will go OK. */
7353 /* There are some types which cannot be array elements. */
7354 switch (TREE_CODE (type))
7357 error_msg = "array of void";
7361 error_msg = "array of functions";
7364 case REFERENCE_TYPE:
7365 error_msg = "array of references";
7369 error_msg = "array of function members";
7376 /* If something went wrong, issue an error-message and return. */
7380 error ("declaration of %qD as %s", name, error_msg);
7382 error ("creating %s", error_msg);
7384 return error_mark_node;
7389 The constant expressions that specify the bounds of the arrays
7390 can be omitted only for the first member of the sequence. */
7391 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
7394 error ("declaration of %qD as multidimensional array must "
7395 "have bounds for all dimensions except the first",
7398 error ("multidimensional array must have bounds for all "
7399 "dimensions except the first");
7401 return error_mark_node;
7404 /* Figure out the index type for the array. */
7406 itype = compute_array_index_type (name, size);
7409 T is called the array element type; this type shall not be [...] an
7410 abstract class type. */
7411 abstract_virtuals_error (name, type);
7413 return build_cplus_array_type (type, itype);
7416 /* Check that it's OK to declare a function with the indicated TYPE.
7417 SFK indicates the kind of special function (if any) that this
7418 function is. OPTYPE is the type given in a conversion operator
7419 declaration, or the class type for a constructor/destructor.
7420 Returns the actual return type of the function; that
7421 may be different than TYPE if an error occurs, or for certain
7422 special functions. */
7425 check_special_function_return_type (special_function_kind sfk,
7431 case sfk_constructor:
7433 error ("return type specification for constructor invalid");
7435 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
7436 type = build_pointer_type (optype);
7438 type = void_type_node;
7441 case sfk_destructor:
7443 error ("return type specification for destructor invalid");
7444 /* We can't use the proper return type here because we run into
7445 problems with ambiguous bases and covariant returns.
7446 Java classes are left unchanged because (void *) isn't a valid
7447 Java type, and we don't want to change the Java ABI. */
7448 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
7449 type = build_pointer_type (void_type_node);
7451 type = void_type_node;
7454 case sfk_conversion:
7456 error ("return type specified for %<operator %T%>", optype);
7467 /* A variable or data member (whose unqualified name is IDENTIFIER)
7468 has been declared with the indicated TYPE. If the TYPE is not
7469 acceptable, issue an error message and return a type to use for
7470 error-recovery purposes. */
7473 check_var_type (tree identifier, tree type)
7475 if (VOID_TYPE_P (type))
7478 error ("unnamed variable or field declared void");
7479 else if (TREE_CODE (identifier) == IDENTIFIER_NODE)
7481 gcc_assert (!IDENTIFIER_OPNAME_P (identifier));
7482 error ("variable or field %qE declared void", identifier);
7485 error ("variable or field declared void");
7486 type = error_mark_node;
7492 /* Given declspecs and a declarator (abstract or otherwise), determine
7493 the name and type of the object declared and construct a DECL node
7496 DECLSPECS points to the representation of declaration-specifier
7497 sequence that precedes declarator.
7499 DECL_CONTEXT says which syntactic context this declaration is in:
7500 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
7501 FUNCDEF for a function definition. Like NORMAL but a few different
7502 error messages in each case. Return value may be zero meaning
7503 this definition is too screwy to try to parse.
7504 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
7505 handle member functions (which have FIELD context).
7506 Return value may be zero meaning this definition is too screwy to
7508 PARM for a parameter declaration (either within a function prototype
7509 or before a function body). Make a PARM_DECL, or return void_type_node.
7510 CATCHPARM for a parameter declaration before a catch clause.
7511 TYPENAME if for a typename (in a cast or sizeof).
7512 Don't make a DECL node; just return the ..._TYPE node.
7513 FIELD for a struct or union field; make a FIELD_DECL.
7514 BITFIELD for a field with specified width.
7515 INITIALIZED is as for start_decl.
7517 ATTRLIST is a pointer to the list of attributes, which may be NULL
7518 if there are none; *ATTRLIST may be modified if attributes from inside
7519 the declarator should be applied to the declaration.
7521 When this function is called, scoping variables (such as
7522 CURRENT_CLASS_TYPE) should reflect the scope in which the
7523 declaration occurs, not the scope in which the new declaration will
7524 be placed. For example, on:
7528 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
7531 Returns a DECL (if a declarator is present), a TYPE (if there is no
7532 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
7536 grokdeclarator (const cp_declarator *declarator,
7537 const cp_decl_specifier_seq *declspecs,
7538 enum decl_context decl_context,
7542 tree type = NULL_TREE;
7544 int virtualp, explicitp, friendp, inlinep, staticp;
7545 int explicit_int = 0;
7546 int explicit_char = 0;
7547 int defaulted_int = 0;
7548 tree dependent_name = NULL_TREE;
7550 tree typedef_decl = NULL_TREE;
7551 const char *name = NULL;
7552 tree typedef_type = NULL_TREE;
7553 /* True if this declarator is a function definition. */
7554 bool funcdef_flag = false;
7555 cp_declarator_kind innermost_code = cdk_error;
7558 /* See the code below that used this. */
7559 tree decl_attr = NULL_TREE;
7562 /* Keep track of what sort of function is being processed
7563 so that we can warn about default return values, or explicit
7564 return values which do not match prescribed defaults. */
7565 special_function_kind sfk = sfk_none;
7567 tree dname = NULL_TREE;
7568 tree ctor_return_type = NULL_TREE;
7569 enum overload_flags flags = NO_SPECIAL;
7570 /* cv-qualifiers that apply to the declarator, for a declaration of
7571 a member function. */
7572 cp_cv_quals memfn_quals = TYPE_UNQUALIFIED;
7573 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
7575 tree raises = NULL_TREE;
7576 int template_count = 0;
7577 tree returned_attrs = NULL_TREE;
7578 tree parms = NULL_TREE;
7579 const cp_declarator *id_declarator;
7580 /* The unqualified name of the declarator; either an
7581 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
7582 tree unqualified_id;
7583 /* The class type, if any, in which this entity is located,
7584 or NULL_TREE if none. Note that this value may be different from
7585 the current class type; for example if an attempt is made to declare
7586 "A::f" inside "B", this value will be "A". */
7587 tree ctype = current_class_type;
7588 /* The NAMESPACE_DECL for the namespace in which this entity is
7589 located. If an unqualified name is used to declare the entity,
7590 this value will be NULL_TREE, even if the entity is located at
7592 tree in_namespace = NULL_TREE;
7593 cp_storage_class storage_class;
7594 bool unsigned_p, signed_p, short_p, long_p, thread_p;
7595 bool type_was_error_mark_node = false;
7596 bool parameter_pack_p = declarator? declarator->parameter_pack_p : false;
7597 bool set_no_warning = false;
7598 bool template_type_arg = false;
7600 signed_p = declspecs->specs[(int)ds_signed];
7601 unsigned_p = declspecs->specs[(int)ds_unsigned];
7602 short_p = declspecs->specs[(int)ds_short];
7603 long_p = declspecs->specs[(int)ds_long];
7604 longlong = declspecs->specs[(int)ds_long] >= 2;
7605 thread_p = declspecs->specs[(int)ds_thread];
7607 if (decl_context == FUNCDEF)
7608 funcdef_flag = true, decl_context = NORMAL;
7609 else if (decl_context == MEMFUNCDEF)
7610 funcdef_flag = true, decl_context = FIELD;
7611 else if (decl_context == BITFIELD)
7612 bitfield = 1, decl_context = FIELD;
7613 else if (decl_context == TEMPLATE_TYPE_ARG)
7614 template_type_arg = true, decl_context = TYPENAME;
7616 if (initialized > 1)
7617 funcdef_flag = true;
7619 /* Look inside a declarator for the name being declared
7620 and get it as a string, for an error message. */
7621 for (id_declarator = declarator;
7623 id_declarator = id_declarator->declarator)
7625 if (id_declarator->kind != cdk_id)
7626 innermost_code = id_declarator->kind;
7628 switch (id_declarator->kind)
7631 if (id_declarator->declarator
7632 && id_declarator->declarator->kind == cdk_id)
7634 sfk = id_declarator->declarator->u.id.sfk;
7635 if (sfk == sfk_destructor)
7642 tree qualifying_scope = id_declarator->u.id.qualifying_scope;
7643 tree decl = id_declarator->u.id.unqualified_name;
7646 if (qualifying_scope)
7648 if (at_function_scope_p ())
7652 A declarator-id shall not be qualified except
7655 None of the cases are permitted in block
7657 if (qualifying_scope == global_namespace)
7658 error ("invalid use of qualified-name %<::%D%>",
7660 else if (TYPE_P (qualifying_scope))
7661 error ("invalid use of qualified-name %<%T::%D%>",
7662 qualifying_scope, decl);
7664 error ("invalid use of qualified-name %<%D::%D%>",
7665 qualifying_scope, decl);
7666 return error_mark_node;
7668 else if (TYPE_P (qualifying_scope))
7670 ctype = qualifying_scope;
7671 if (innermost_code != cdk_function
7672 && current_class_type
7673 && !UNIQUELY_DERIVED_FROM_P (ctype,
7674 current_class_type))
7676 error ("type %qT is not derived from type %qT",
7677 ctype, current_class_type);
7678 return error_mark_node;
7681 else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL)
7682 in_namespace = qualifying_scope;
7684 switch (TREE_CODE (decl))
7690 if (innermost_code != cdk_function)
7692 error ("declaration of %qD as non-function", decl);
7693 return error_mark_node;
7695 else if (!qualifying_scope
7696 && !(current_class_type && at_class_scope_p ()))
7698 error ("declaration of %qD as non-member", decl);
7699 return error_mark_node;
7702 type = TREE_OPERAND (decl, 0);
7704 type = constructor_name (type);
7705 name = IDENTIFIER_POINTER (type);
7710 case TEMPLATE_ID_EXPR:
7712 tree fns = TREE_OPERAND (decl, 0);
7715 if (TREE_CODE (dname) != IDENTIFIER_NODE)
7717 gcc_assert (is_overloaded_fn (dname));
7718 dname = DECL_NAME (get_first_fn (dname));
7723 case IDENTIFIER_NODE:
7724 if (TREE_CODE (decl) == IDENTIFIER_NODE)
7727 if (C_IS_RESERVED_WORD (dname))
7729 error ("declarator-id missing; using reserved word %qD",
7731 name = IDENTIFIER_POINTER (dname);
7733 else if (!IDENTIFIER_TYPENAME_P (dname))
7734 name = IDENTIFIER_POINTER (dname);
7737 gcc_assert (flags == NO_SPECIAL);
7738 flags = TYPENAME_FLAG;
7739 ctor_return_type = TREE_TYPE (dname);
7740 sfk = sfk_conversion;
7741 if (is_typename_at_global_scope (dname))
7742 name = IDENTIFIER_POINTER (dname);
7744 name = "<invalid operator>";
7761 return error_mark_node;
7766 if (id_declarator->kind == cdk_id)
7772 The declarator in a function-definition shall have the form
7773 D1 ( parameter-declaration-clause) ... */
7774 if (funcdef_flag && innermost_code != cdk_function)
7776 error ("function definition does not declare parameters");
7777 return error_mark_node;
7780 if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
7781 && innermost_code != cdk_function
7782 && ! (ctype && !declspecs->any_specifiers_p))
7784 error ("declaration of %qD as non-function", dname);
7785 return error_mark_node;
7788 /* Anything declared one level down from the top level
7789 must be one of the parameters of a function
7790 (because the body is at least two levels down). */
7792 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
7793 by not allowing C++ class definitions to specify their parameters
7794 with xdecls (must be spec.d in the parmlist).
7796 Since we now wait to push a class scope until we are sure that
7797 we are in a legitimate method context, we must set oldcname
7798 explicitly (since current_class_name is not yet alive).
7800 We also want to avoid calling this a PARM if it is in a namespace. */
7802 if (decl_context == NORMAL && !toplevel_bindings_p ())
7804 struct cp_binding_level *b = current_binding_level;
7805 current_binding_level = b->level_chain;
7806 if (current_binding_level != 0 && toplevel_bindings_p ())
7807 decl_context = PARM;
7808 current_binding_level = b;
7812 name = decl_context == PARM ? "parameter" : "type name";
7814 /* If there were multiple types specified in the decl-specifier-seq,
7815 issue an error message. */
7816 if (declspecs->multiple_types_p)
7818 error ("two or more data types in declaration of %qs", name);
7819 return error_mark_node;
7822 if (declspecs->conflicting_specifiers_p)
7824 error ("conflicting specifiers in declaration of %qs", name);
7825 return error_mark_node;
7828 /* Extract the basic type from the decl-specifier-seq. */
7829 type = declspecs->type;
7830 if (type == error_mark_node)
7833 type_was_error_mark_node = true;
7835 /* If the entire declaration is itself tagged as deprecated then
7836 suppress reports of deprecated items. */
7837 if (type && TREE_DEPRECATED (type)
7838 && deprecated_state != DEPRECATED_SUPPRESS)
7839 warn_deprecated_use (type);
7840 if (type && TREE_CODE (type) == TYPE_DECL)
7842 typedef_decl = type;
7843 type = TREE_TYPE (typedef_decl);
7844 if (TREE_DEPRECATED (type)
7845 && DECL_ARTIFICIAL (typedef_decl)
7846 && deprecated_state != DEPRECATED_SUPPRESS)
7847 warn_deprecated_use (type);
7849 /* No type at all: default to `int', and set DEFAULTED_INT
7850 because it was not a user-defined typedef. */
7851 if (type == NULL_TREE && (signed_p || unsigned_p || long_p || short_p))
7853 /* These imply 'int'. */
7854 type = integer_type_node;
7858 explicit_int = declspecs->explicit_int_p;
7859 explicit_char = declspecs->explicit_char_p;
7862 /* See the code below that used this. */
7864 decl_attr = DECL_ATTRIBUTES (typedef_decl);
7866 typedef_type = type;
7869 if (sfk != sfk_conversion)
7870 ctor_return_type = ctype;
7872 if (sfk != sfk_none)
7873 type = check_special_function_return_type (sfk, type,
7875 else if (type == NULL_TREE)
7881 /* We handle `main' specially here, because 'main () { }' is so
7882 common. With no options, it is allowed. With -Wreturn-type,
7883 it is a warning. It is only an error with -pedantic-errors. */
7884 is_main = (funcdef_flag
7885 && dname && MAIN_NAME_P (dname)
7886 && ctype == NULL_TREE
7887 && in_namespace == NULL_TREE
7888 && current_namespace == global_namespace);
7890 if (type_was_error_mark_node)
7891 /* We've already issued an error, don't complain more. */;
7892 else if (in_system_header || flag_ms_extensions)
7893 /* Allow it, sigh. */;
7895 permerror (input_location, "ISO C++ forbids declaration of %qs with no type", name);
7897 pedwarn (input_location, OPT_pedantic,
7898 "ISO C++ forbids declaration of %qs with no type", name);
7900 warning (OPT_Wreturn_type,
7901 "ISO C++ forbids declaration of %qs with no type", name);
7903 type = integer_type_node;
7908 /* Now process the modifiers that were specified
7909 and check for invalid combinations. */
7911 /* Long double is a special combination. */
7912 if (long_p && !longlong && TYPE_MAIN_VARIANT (type) == double_type_node)
7915 type = build_qualified_type (long_double_type_node,
7916 cp_type_quals (type));
7919 /* Check all other uses of type modifiers. */
7921 if (unsigned_p || signed_p || long_p || short_p)
7925 if ((signed_p || unsigned_p) && TREE_CODE (type) != INTEGER_TYPE)
7926 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
7927 else if (signed_p && unsigned_p)
7928 error ("%<signed%> and %<unsigned%> specified together for %qs", name);
7929 else if (longlong && TREE_CODE (type) != INTEGER_TYPE)
7930 error ("%<long long%> invalid for %qs", name);
7931 else if (long_p && TREE_CODE (type) == REAL_TYPE)
7932 error ("%<long%> invalid for %qs", name);
7933 else if (short_p && TREE_CODE (type) == REAL_TYPE)
7934 error ("%<short%> invalid for %qs", name);
7935 else if ((long_p || short_p) && TREE_CODE (type) != INTEGER_TYPE)
7936 error ("%<long%> or %<short%> invalid for %qs", name);
7937 else if ((long_p || short_p) && explicit_char)
7938 error ("%<long%> or %<short%> specified with char for %qs", name);
7939 else if (long_p && short_p)
7940 error ("%<long%> and %<short%> specified together for %qs", name);
7941 else if (type == char16_type_node || type == char32_type_node)
7943 if (signed_p || unsigned_p)
7944 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
7945 else if (short_p || long_p)
7946 error ("%<short%> or %<long%> invalid for %qs", name);
7951 if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
7953 pedwarn (input_location, OPT_pedantic,
7954 "long, short, signed or unsigned used invalidly for %qs",
7956 if (flag_pedantic_errors)
7961 /* Discard the type modifiers if they are invalid. */
7972 /* Decide whether an integer type is signed or not.
7973 Optionally treat bitfields as signed by default. */
7977 It is implementation-defined whether a plain (neither
7978 explicitly signed or unsigned) char, short, int, or long
7979 bit-field is signed or unsigned.
7981 Naturally, we extend this to long long as well. Note that
7982 this does not include wchar_t. */
7983 || (bitfield && !flag_signed_bitfields
7985 /* A typedef for plain `int' without `signed' can be
7986 controlled just like plain `int', but a typedef for
7987 `signed int' cannot be so controlled. */
7989 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
7990 && TREE_CODE (type) == INTEGER_TYPE
7991 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
7994 type = long_long_unsigned_type_node;
7996 type = long_unsigned_type_node;
7998 type = short_unsigned_type_node;
7999 else if (type == char_type_node)
8000 type = unsigned_char_type_node;
8001 else if (typedef_decl)
8002 type = unsigned_type_for (type);
8004 type = unsigned_type_node;
8006 else if (signed_p && type == char_type_node)
8007 type = signed_char_type_node;
8009 type = long_long_integer_type_node;
8011 type = long_integer_type_node;
8013 type = short_integer_type_node;
8015 if (declspecs->specs[(int)ds_complex])
8017 if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
8018 error ("complex invalid for %qs", name);
8019 /* If we just have "complex", it is equivalent to
8020 "complex double", but if any modifiers at all are specified it is
8021 the complex form of TYPE. E.g, "complex short" is
8022 "complex short int". */
8024 else if (defaulted_int && ! longlong
8025 && ! (long_p || short_p || signed_p || unsigned_p))
8026 type = complex_double_type_node;
8027 else if (type == integer_type_node)
8028 type = complex_integer_type_node;
8029 else if (type == float_type_node)
8030 type = complex_float_type_node;
8031 else if (type == double_type_node)
8032 type = complex_double_type_node;
8033 else if (type == long_double_type_node)
8034 type = complex_long_double_type_node;
8036 type = build_complex_type (type);
8039 type_quals = TYPE_UNQUALIFIED;
8040 if (declspecs->specs[(int)ds_const])
8041 type_quals |= TYPE_QUAL_CONST;
8042 if (declspecs->specs[(int)ds_volatile])
8043 type_quals |= TYPE_QUAL_VOLATILE;
8044 if (declspecs->specs[(int)ds_restrict])
8045 type_quals |= TYPE_QUAL_RESTRICT;
8046 if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
8047 error ("qualifiers are not allowed on declaration of %<operator %T%>",
8050 if (TREE_CODE (type) == FUNCTION_TYPE
8051 && type_quals != TYPE_UNQUALIFIED)
8053 /* This was an error in C++98 (cv-qualifiers cannot be added to
8054 a function type), but DR 295 makes the code well-formed by
8055 dropping the extra qualifiers. */
8058 tree bad_type = build_qualified_type (type, type_quals);
8059 pedwarn (input_location, OPT_pedantic,
8060 "ignoring %qV qualifiers added to function type %qT",
8063 type_quals = TYPE_UNQUALIFIED;
8065 type_quals |= cp_type_quals (type);
8066 type = cp_build_qualified_type_real
8067 (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
8068 ? tf_ignore_bad_quals : 0) | tf_warning_or_error));
8069 /* We might have ignored or rejected some of the qualifiers. */
8070 type_quals = cp_type_quals (type);
8073 inlinep = !! declspecs->specs[(int)ds_inline];
8074 virtualp = !! declspecs->specs[(int)ds_virtual];
8075 explicitp = !! declspecs->specs[(int)ds_explicit];
8077 storage_class = declspecs->storage_class;
8078 if (storage_class == sc_static)
8079 staticp = 1 + (decl_context == FIELD);
8081 if (virtualp && staticp == 2)
8083 error ("member %qD cannot be declared both virtual and static", dname);
8084 storage_class = sc_none;
8087 friendp = !! declspecs->specs[(int)ds_friend];
8089 if (dependent_name && !friendp)
8091 error ("%<%T::%D%> is not a valid declarator", ctype, dependent_name);
8092 return error_mark_node;
8095 /* Issue errors about use of storage classes for parameters. */
8096 if (decl_context == PARM)
8098 if (declspecs->specs[(int)ds_typedef])
8100 error ("typedef declaration invalid in parameter declaration");
8101 return error_mark_node;
8103 else if (storage_class == sc_static
8104 || storage_class == sc_extern
8106 error ("storage class specifiers invalid in parameter declarations");
8108 if (type_uses_auto (type))
8110 error ("parameter declared %<auto%>");
8111 type = error_mark_node;
8115 /* Give error if `virtual' is used outside of class declaration. */
8117 && (current_class_name == NULL_TREE || decl_context != FIELD))
8119 error ("%<virtual%> outside class declaration");
8123 /* Static anonymous unions are dealt with here. */
8124 if (staticp && decl_context == TYPENAME
8126 && ANON_AGGR_TYPE_P (declspecs->type))
8127 decl_context = FIELD;
8129 /* Warn about storage classes that are invalid for certain
8130 kinds of declarations (parameters, typenames, etc.). */
8133 && storage_class != sc_extern
8134 && storage_class != sc_static)
8135 || declspecs->specs[(int)ds_typedef]))
8137 error ("multiple storage classes in declaration of %qs", name);
8140 if (decl_context != NORMAL
8141 && ((storage_class != sc_none
8142 && storage_class != sc_mutable)
8145 if ((decl_context == PARM || decl_context == CATCHPARM)
8146 && (storage_class == sc_register
8147 || storage_class == sc_auto))
8149 else if (declspecs->specs[(int)ds_typedef])
8151 else if (decl_context == FIELD
8152 /* C++ allows static class elements. */
8153 && storage_class == sc_static)
8154 /* C++ also allows inlines and signed and unsigned elements,
8155 but in those cases we don't come in here. */
8159 if (decl_context == FIELD)
8160 error ("storage class specified for %qs", name);
8163 if (decl_context == PARM || decl_context == CATCHPARM)
8164 error ("storage class specified for parameter %qs", name);
8166 error ("storage class specified for typename");
8168 if (storage_class == sc_register
8169 || storage_class == sc_auto
8170 || storage_class == sc_extern
8172 storage_class = sc_none;
8175 else if (storage_class == sc_extern && funcdef_flag
8176 && ! toplevel_bindings_p ())
8177 error ("nested function %qs declared %<extern%>", name);
8178 else if (toplevel_bindings_p ())
8180 if (storage_class == sc_auto)
8181 error ("top-level declaration of %qs specifies %<auto%>", name);
8184 && storage_class != sc_extern
8185 && storage_class != sc_static)
8187 error ("function-scope %qs implicitly auto and declared %<__thread%>",
8192 if (storage_class && friendp)
8194 error ("storage class specifiers invalid in friend function declarations");
8195 storage_class = sc_none;
8200 unqualified_id = NULL_TREE;
8203 unqualified_id = id_declarator->u.id.unqualified_name;
8204 switch (TREE_CODE (unqualified_id))
8207 unqualified_id = TREE_OPERAND (unqualified_id, 0);
8208 if (TYPE_P (unqualified_id))
8209 unqualified_id = constructor_name (unqualified_id);
8212 case IDENTIFIER_NODE:
8213 case TEMPLATE_ID_EXPR:
8221 /* Determine the type of the entity declared by recurring on the
8223 for (; declarator; declarator = declarator->declarator)
8225 const cp_declarator *inner_declarator;
8228 if (type == error_mark_node)
8229 return error_mark_node;
8231 attrs = declarator->attributes;
8237 if (declarator == NULL || declarator->kind == cdk_id)
8238 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
8239 if (declarator->kind == cdk_function)
8240 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
8241 if (declarator->kind == cdk_array)
8242 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
8243 returned_attrs = decl_attributes (&type,
8244 chainon (returned_attrs, attrs),
8248 if (declarator->kind == cdk_id)
8251 inner_declarator = declarator->declarator;
8253 switch (declarator->kind)
8256 type = create_array_type_for_decl (dname, type,
8257 declarator->u.array.bounds);
8265 /* Declaring a function type.
8266 Make sure we have a valid type for the function to return. */
8268 if (type_quals != TYPE_UNQUALIFIED)
8270 if (SCALAR_TYPE_P (type) || VOID_TYPE_P (type))
8271 warning (OPT_Wignored_qualifiers,
8272 "type qualifiers ignored on function return type");
8273 /* We now know that the TYPE_QUALS don't apply to the
8274 decl, but to its return type. */
8275 type_quals = TYPE_UNQUALIFIED;
8276 set_no_warning = true;
8279 /* Error about some types functions can't return. */
8281 if (TREE_CODE (type) == FUNCTION_TYPE)
8283 error ("%qs declared as function returning a function", name);
8284 return error_mark_node;
8286 if (TREE_CODE (type) == ARRAY_TYPE)
8288 error ("%qs declared as function returning an array", name);
8289 return error_mark_node;
8292 /* Pick up type qualifiers which should be applied to `this'. */
8293 memfn_quals = declarator->u.function.qualifiers;
8295 /* Pick up the exception specifications. */
8296 raises = declarator->u.function.exception_specification;
8298 /* Say it's a definition only for the CALL_EXPR
8299 closest to the identifier. */
8300 funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id;
8302 /* Handle a late-specified return type. */
8305 if (type_uses_auto (type))
8307 if (!declarator->u.function.late_return_type)
8309 error ("%qs function uses %<auto%> type specifier without"
8310 " late return type", name);
8311 return error_mark_node;
8313 else if (!is_auto (type))
8315 error ("%qs function with late return type has"
8316 " %qT as its type rather than plain %<auto%>",
8318 return error_mark_node;
8321 else if (declarator->u.function.late_return_type)
8323 error ("%qs function with late return type not declared"
8324 " with %<auto%> type specifier", name);
8325 return error_mark_node;
8328 type = splice_late_return_type
8329 (type, declarator->u.function.late_return_type);
8330 if (type == error_mark_node)
8331 return error_mark_node;
8333 if (ctype == NULL_TREE
8334 && decl_context == FIELD
8336 && (friendp == 0 || dname == current_class_name))
8337 ctype = current_class_type;
8339 if (ctype && (sfk == sfk_constructor
8340 || sfk == sfk_destructor))
8342 /* We are within a class's scope. If our declarator name
8343 is the same as the class name, and we are defining
8344 a function, then it is a constructor/destructor, and
8345 therefore returns a void type. */
8347 /* ISO C++ 12.4/2. A destructor may not be declared
8348 const or volatile. A destructor may not be
8351 ISO C++ 12.1. A constructor may not be declared
8352 const or volatile. A constructor may not be
8353 virtual. A constructor may not be static. */
8355 error ((flags == DTOR_FLAG)
8356 ? "destructor cannot be static member function"
8357 : "constructor cannot be static member function");
8360 error ((flags == DTOR_FLAG)
8361 ? "destructors may not be cv-qualified"
8362 : "constructors may not be cv-qualified");
8363 memfn_quals = TYPE_UNQUALIFIED;
8366 if (decl_context == FIELD
8367 && !member_function_or_else (ctype,
8370 return error_mark_node;
8372 if (flags != DTOR_FLAG)
8374 /* It's a constructor. */
8379 permerror (input_location, "constructors cannot be declared virtual");
8382 if (decl_context == FIELD
8383 && sfk != sfk_constructor)
8384 return error_mark_node;
8386 if (decl_context == FIELD)
8392 error ("can't initialize friend function %qs", name);
8395 /* Cannot be both friend and virtual. */
8396 error ("virtual functions cannot be friends");
8399 if (decl_context == NORMAL)
8400 error ("friend declaration not in class definition");
8401 if (current_function_decl && funcdef_flag)
8402 error ("can't define friend function %qs in a local "
8407 arg_types = grokparms (declarator->u.function.parameters,
8410 if (inner_declarator
8411 && inner_declarator->kind == cdk_id
8412 && inner_declarator->u.id.sfk == sfk_destructor
8413 && arg_types != void_list_node)
8415 error ("destructors may not have parameters");
8416 arg_types = void_list_node;
8420 type = build_function_type (type, arg_types);
8427 /* Filter out pointers-to-references and references-to-references.
8428 We can get these if a TYPE_DECL is used. */
8430 if (TREE_CODE (type) == REFERENCE_TYPE)
8432 if (declarator->kind != cdk_reference)
8434 error ("cannot declare pointer to %q#T", type);
8435 type = TREE_TYPE (type);
8438 /* In C++0x, we allow reference to reference declarations
8439 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
8440 and template type arguments [14.3.1/4 temp.arg.type]. The
8441 check for direct reference to reference declarations, which
8442 are still forbidden, occurs below. Reasoning behind the change
8443 can be found in DR106, DR540, and the rvalue reference
8445 else if (cxx_dialect == cxx98)
8447 error ("cannot declare reference to %q#T", type);
8448 type = TREE_TYPE (type);
8451 else if (VOID_TYPE_P (type))
8453 if (declarator->kind == cdk_reference)
8454 error ("cannot declare reference to %q#T", type);
8455 else if (declarator->kind == cdk_ptrmem)
8456 error ("cannot declare pointer to %q#T member", type);
8459 /* We now know that the TYPE_QUALS don't apply to the decl,
8460 but to the target of the pointer. */
8461 type_quals = TYPE_UNQUALIFIED;
8463 if (declarator->kind == cdk_ptrmem
8464 && (TREE_CODE (type) == FUNCTION_TYPE
8465 || (memfn_quals && TREE_CODE (type) == METHOD_TYPE)))
8467 memfn_quals |= cp_type_quals (type);
8468 type = build_memfn_type (type,
8469 declarator->u.pointer.class_type,
8471 memfn_quals = TYPE_UNQUALIFIED;
8474 if (TREE_CODE (type) == FUNCTION_TYPE
8475 && cp_type_quals (type) != TYPE_UNQUALIFIED)
8476 error ("cannot declare %s to qualified function type %qT",
8477 declarator->kind == cdk_reference ? "reference" : "pointer",
8480 if (declarator->kind == cdk_reference)
8482 /* In C++0x, the type we are creating a reference to might be
8483 a typedef which is itself a reference type. In that case,
8484 we follow the reference collapsing rules in
8485 [7.1.3/8 dcl.typedef] to create the final reference type:
8487 "If a typedef TD names a type that is a reference to a type
8488 T, an attempt to create the type 'lvalue reference to cv TD'
8489 creates the type 'lvalue reference to T,' while an attempt
8490 to create the type "rvalue reference to cv TD' creates the
8493 if (!VOID_TYPE_P (type))
8494 type = cp_build_reference_type
8495 ((TREE_CODE (type) == REFERENCE_TYPE
8496 ? TREE_TYPE (type) : type),
8497 (declarator->u.reference.rvalue_ref
8498 && (TREE_CODE(type) != REFERENCE_TYPE
8499 || TYPE_REF_IS_RVALUE (type))));
8501 /* In C++0x, we need this check for direct reference to
8502 reference declarations, which are forbidden by
8503 [8.3.2/5 dcl.ref]. Reference to reference declarations
8504 are only allowed indirectly through typedefs and template
8505 type arguments. Example:
8507 void foo(int & &); // invalid ref-to-ref decl
8509 typedef int & int_ref;
8510 void foo(int_ref &); // valid ref-to-ref decl
8512 if (inner_declarator && inner_declarator->kind == cdk_reference)
8513 error ("cannot declare reference to %q#T, which is not "
8514 "a typedef or a template type argument", type);
8516 else if (TREE_CODE (type) == METHOD_TYPE)
8517 type = build_ptrmemfunc_type (build_pointer_type (type));
8518 else if (declarator->kind == cdk_ptrmem)
8520 gcc_assert (TREE_CODE (declarator->u.pointer.class_type)
8522 if (declarator->u.pointer.class_type == error_mark_node)
8523 /* We will already have complained. */
8524 type = error_mark_node;
8526 type = build_ptrmem_type (declarator->u.pointer.class_type,
8530 type = build_pointer_type (type);
8532 /* Process a list of type modifier keywords (such as
8533 const or volatile) that were given inside the `*' or `&'. */
8535 if (declarator->u.pointer.qualifiers)
8538 = cp_build_qualified_type (type,
8539 declarator->u.pointer.qualifiers);
8540 type_quals = cp_type_quals (type);
8553 if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR
8554 && TREE_CODE (type) != FUNCTION_TYPE
8555 && TREE_CODE (type) != METHOD_TYPE)
8557 error ("template-id %qD used as a declarator",
8559 unqualified_id = dname;
8562 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
8563 qualified with a class-name, turn it into a METHOD_TYPE, unless
8564 we know that the function is static. We take advantage of this
8565 opportunity to do other processing that pertains to entities
8566 explicitly declared to be class members. Note that if DECLARATOR
8567 is non-NULL, we know it is a cdk_id declarator; otherwise, we
8568 would not have exited the loop above. */
8570 && declarator->u.id.qualifying_scope
8571 && TYPE_P (declarator->u.id.qualifying_scope))
8575 ctype = declarator->u.id.qualifying_scope;
8576 ctype = TYPE_MAIN_VARIANT (ctype);
8578 while (t != NULL_TREE && CLASS_TYPE_P (t))
8580 /* You're supposed to have one `template <...>' for every
8581 template class, but you don't need one for a full
8582 specialization. For example:
8584 template <class T> struct S{};
8585 template <> struct S<int> { void f(); };
8586 void S<int>::f () {}
8588 is correct; there shouldn't be a `template <>' for the
8589 definition of `S<int>::f'. */
8590 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t)
8591 && !any_dependent_template_arguments_p (CLASSTYPE_TI_ARGS (t)))
8592 /* T is an explicit (not partial) specialization. All
8593 containing classes must therefore also be explicitly
8596 if ((CLASSTYPE_USE_TEMPLATE (t) || CLASSTYPE_IS_TEMPLATE (t))
8597 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
8598 template_count += 1;
8600 t = TYPE_MAIN_DECL (t);
8601 t = DECL_CONTEXT (t);
8604 if (ctype == current_class_type)
8608 permerror (input_location, "member functions are implicitly friends of their class");
8612 permerror (declarator->id_loc,
8613 "extra qualification %<%T::%> on member %qs",
8616 else if (/* If the qualifying type is already complete, then we
8617 can skip the following checks. */
8618 !COMPLETE_TYPE_P (ctype)
8619 && (/* If the function is being defined, then
8620 qualifying type must certainly be complete. */
8622 /* A friend declaration of "T::f" is OK, even if
8623 "T" is a template parameter. But, if this
8624 function is not a friend, the qualifying type
8626 || (!friendp && !CLASS_TYPE_P (ctype))
8627 /* For a declaration, the type need not be
8628 complete, if either it is dependent (since there
8629 is no meaningful definition of complete in that
8630 case) or the qualifying class is currently being
8632 || !(dependent_type_p (ctype)
8633 || currently_open_class (ctype)))
8634 /* Check that the qualifying type is complete. */
8635 && !complete_type_or_else (ctype, NULL_TREE))
8636 return error_mark_node;
8637 else if (TREE_CODE (type) == FUNCTION_TYPE)
8639 tree sname = declarator->u.id.unqualified_name;
8641 if (current_class_type
8642 && (!friendp || funcdef_flag))
8645 ? "cannot define member function %<%T::%s%> within %<%T%>"
8646 : "cannot declare member function %<%T::%s%> within %<%T%>",
8647 ctype, name, current_class_type);
8648 return error_mark_node;
8651 if (TREE_CODE (sname) == IDENTIFIER_NODE
8652 && NEW_DELETE_OPNAME_P (sname))
8653 /* Overloaded operator new and operator delete
8654 are always static functions. */
8657 type = build_memfn_type (type, ctype, memfn_quals);
8659 else if (declspecs->specs[(int)ds_typedef]
8660 && current_class_type)
8662 error ("cannot declare member %<%T::%s%> within %qT",
8663 ctype, name, current_class_type);
8664 return error_mark_node;
8668 /* Now TYPE has the actual type. */
8673 *attrlist = chainon (returned_attrs, *attrlist);
8675 attrlist = &returned_attrs;
8678 /* Handle parameter packs. */
8679 if (parameter_pack_p)
8681 if (decl_context == PARM)
8682 /* Turn the type into a pack expansion.*/
8683 type = make_pack_expansion (type);
8685 error ("non-parameter %qs cannot be a parameter pack", name);
8688 /* Did array size calculations overflow? */
8690 if (TREE_CODE (type) == ARRAY_TYPE
8691 && COMPLETE_TYPE_P (type)
8692 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
8693 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
8695 error ("size of array %qs is too large", name);
8696 /* If we proceed with the array type as it is, we'll eventually
8697 crash in tree_low_cst(). */
8698 type = error_mark_node;
8701 if ((decl_context == FIELD || decl_context == PARM)
8702 && !processing_template_decl
8703 && variably_modified_type_p (type, NULL_TREE))
8705 if (decl_context == FIELD)
8706 error ("data member may not have variably modified type %qT", type);
8708 error ("parameter may not have variably modified type %qT", type);
8709 type = error_mark_node;
8712 if (explicitp == 1 || (explicitp && friendp))
8714 /* [dcl.fct.spec] The explicit specifier shall only be used in
8715 declarations of constructors within a class definition. */
8716 error ("only declarations of constructors can be %<explicit%>");
8720 if (storage_class == sc_mutable)
8722 if (decl_context != FIELD || friendp)
8724 error ("non-member %qs cannot be declared %<mutable%>", name);
8725 storage_class = sc_none;
8727 else if (decl_context == TYPENAME || declspecs->specs[(int)ds_typedef])
8729 error ("non-object member %qs cannot be declared %<mutable%>", name);
8730 storage_class = sc_none;
8732 else if (TREE_CODE (type) == FUNCTION_TYPE
8733 || TREE_CODE (type) == METHOD_TYPE)
8735 error ("function %qs cannot be declared %<mutable%>", name);
8736 storage_class = sc_none;
8740 error ("static %qs cannot be declared %<mutable%>", name);
8741 storage_class = sc_none;
8743 else if (type_quals & TYPE_QUAL_CONST)
8745 error ("const %qs cannot be declared %<mutable%>", name);
8746 storage_class = sc_none;
8750 /* If this is declaring a typedef name, return a TYPE_DECL. */
8751 if (declspecs->specs[(int)ds_typedef] && decl_context != TYPENAME)
8755 /* Note that the grammar rejects storage classes
8756 in typenames, fields or parameters. */
8757 if (current_lang_name == lang_name_java)
8758 TYPE_FOR_JAVA (type) = 1;
8760 /* This declaration:
8762 typedef void f(int) const;
8764 declares a function type which is not a member of any
8765 particular class, but which is cv-qualified; for
8766 example "f S::*" declares a pointer to a const-qualified
8767 member function of S. We record the cv-qualification in the
8769 if (memfn_quals && TREE_CODE (type) == FUNCTION_TYPE)
8771 type = cp_build_qualified_type (type, memfn_quals);
8773 /* We have now dealt with these qualifiers. */
8774 memfn_quals = TYPE_UNQUALIFIED;
8777 if (decl_context == FIELD)
8778 decl = build_lang_decl (TYPE_DECL, unqualified_id, type);
8780 decl = build_decl (TYPE_DECL, unqualified_id, type);
8781 if (id_declarator && declarator->u.id.qualifying_scope) {
8782 error ("%Jtypedef name may not be a nested-name-specifier", decl);
8783 TREE_TYPE (decl) = error_mark_node;
8786 if (decl_context != FIELD)
8788 if (!current_function_decl)
8789 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8790 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl)
8791 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
8792 (current_function_decl)))
8793 /* The TYPE_DECL is "abstract" because there will be
8794 clones of this constructor/destructor, and there will
8795 be copies of this TYPE_DECL generated in those
8797 DECL_ABSTRACT (decl) = 1;
8799 else if (constructor_name_p (unqualified_id, current_class_type))
8800 permerror (input_location, "ISO C++ forbids nested type %qD with same name "
8801 "as enclosing class",
8804 /* If the user declares "typedef struct {...} foo" then the
8805 struct will have an anonymous name. Fill that name in now.
8806 Nothing can refer to it, so nothing needs know about the name
8808 if (type != error_mark_node
8811 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
8812 && TYPE_ANONYMOUS_P (type)
8813 && cp_type_quals (type) == TYPE_UNQUALIFIED)
8817 /* Replace the anonymous name with the real name everywhere. */
8818 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
8820 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8822 debug_hooks->set_name (t, decl);
8823 TYPE_NAME (t) = decl;
8827 if (TYPE_LANG_SPECIFIC (type))
8828 TYPE_WAS_ANONYMOUS (type) = 1;
8830 /* If this is a typedef within a template class, the nested
8831 type is a (non-primary) template. The name for the
8832 template needs updating as well. */
8833 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
8834 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
8835 = TYPE_IDENTIFIER (type);
8837 /* FIXME remangle member functions; member functions of a
8838 type with external linkage have external linkage. */
8842 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
8843 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
8845 bad_specifiers (decl, "type", virtualp,
8846 memfn_quals != TYPE_UNQUALIFIED,
8847 inlinep, friendp, raises != NULL_TREE);
8852 /* Detect the case of an array type of unspecified size
8853 which came, as such, direct from a typedef name.
8854 We must copy the type, so that the array's domain can be
8855 individually set by the object's initializer. */
8857 if (type && typedef_type
8858 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
8859 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
8860 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
8862 /* Detect where we're using a typedef of function type to declare a
8863 function. PARMS will not be set, so we must create it now. */
8865 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
8867 tree decls = NULL_TREE;
8870 for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
8872 tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
8874 TREE_CHAIN (decl) = decls;
8878 parms = nreverse (decls);
8880 if (decl_context != TYPENAME)
8882 /* A cv-qualifier-seq shall only be part of the function type
8883 for a non-static member function. [8.3.5/4 dcl.fct] */
8884 if (cp_type_quals (type) != TYPE_UNQUALIFIED
8885 && (current_class_type == NULL_TREE || staticp) )
8888 ? G_("qualified function types cannot be used to "
8889 "declare static member functions")
8890 : G_("qualified function types cannot be used to "
8891 "declare free functions"));
8892 type = TYPE_MAIN_VARIANT (type);
8895 /* The qualifiers on the function type become the qualifiers on
8896 the non-static member function. */
8897 memfn_quals |= cp_type_quals (type);
8901 /* If this is a type name (such as, in a cast or sizeof),
8902 compute the type and return it now. */
8904 if (decl_context == TYPENAME)
8906 /* Note that the grammar rejects storage classes
8907 in typenames, fields or parameters. */
8908 if (type_quals != TYPE_UNQUALIFIED)
8909 type_quals = TYPE_UNQUALIFIED;
8911 /* Special case: "friend class foo" looks like a TYPENAME context. */
8914 if (type_quals != TYPE_UNQUALIFIED)
8916 error ("type qualifiers specified for friend class declaration");
8917 type_quals = TYPE_UNQUALIFIED;
8921 error ("%<inline%> specified for friend class declaration");
8927 /* Don't allow friend declaration without a class-key. */
8928 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
8929 permerror (input_location, "template parameters cannot be friends");
8930 else if (TREE_CODE (type) == TYPENAME_TYPE)
8931 permerror (input_location, "friend declaration requires class-key, "
8932 "i.e. %<friend class %T::%D%>",
8933 TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
8935 permerror (input_location, "friend declaration requires class-key, "
8936 "i.e. %<friend %#T%>",
8940 /* Only try to do this stuff if we didn't already give up. */
8941 if (type != integer_type_node)
8943 /* A friendly class? */
8944 if (current_class_type)
8945 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
8948 error ("trying to make class %qT a friend of global scope",
8951 type = void_type_node;
8954 else if (memfn_quals)
8956 if (ctype == NULL_TREE
8957 && TREE_CODE (type) == METHOD_TYPE)
8958 ctype = TYPE_METHOD_BASETYPE (type);
8961 type = build_memfn_type (type, ctype, memfn_quals);
8962 /* Core issue #547: need to allow this in template type args. */
8963 else if (template_type_arg && TREE_CODE (type) == FUNCTION_TYPE)
8964 type = cp_build_qualified_type (type, memfn_quals);
8966 error ("invalid qualifiers on non-member function type");
8971 else if (unqualified_id == NULL_TREE && decl_context != PARM
8972 && decl_context != CATCHPARM
8973 && TREE_CODE (type) != UNION_TYPE
8976 error ("abstract declarator %qT used as declaration", type);
8977 return error_mark_node;
8980 /* Only functions may be declared using an operator-function-id. */
8982 && IDENTIFIER_OPNAME_P (unqualified_id)
8983 && TREE_CODE (type) != FUNCTION_TYPE
8984 && TREE_CODE (type) != METHOD_TYPE)
8986 error ("declaration of %qD as non-function", unqualified_id);
8987 return error_mark_node;
8990 /* We don't check parameter types here because we can emit a better
8991 error message later. */
8992 if (decl_context != PARM)
8994 type = check_var_type (unqualified_id, type);
8995 if (type == error_mark_node)
8996 return error_mark_node;
8999 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
9000 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
9002 if (decl_context == PARM || decl_context == CATCHPARM)
9004 if (ctype || in_namespace)
9005 error ("cannot use %<::%> in parameter declaration");
9007 /* A parameter declared as an array of T is really a pointer to T.
9008 One declared as a function is really a pointer to a function.
9009 One declared as a member is really a pointer to member. */
9011 if (TREE_CODE (type) == ARRAY_TYPE)
9013 /* Transfer const-ness of array into that of type pointed to. */
9014 type = build_pointer_type (TREE_TYPE (type));
9015 type_quals = TYPE_UNQUALIFIED;
9017 else if (TREE_CODE (type) == FUNCTION_TYPE)
9018 type = build_pointer_type (type);
9024 if (decl_context == PARM)
9026 decl = cp_build_parm_decl (unqualified_id, type);
9028 bad_specifiers (decl, "parameter", virtualp,
9029 memfn_quals != TYPE_UNQUALIFIED,
9030 inlinep, friendp, raises != NULL_TREE);
9032 else if (decl_context == FIELD)
9034 /* The C99 flexible array extension. */
9035 if (!staticp && TREE_CODE (type) == ARRAY_TYPE
9036 && TYPE_DOMAIN (type) == NULL_TREE)
9038 tree itype = compute_array_index_type (dname, integer_zero_node);
9039 type = build_cplus_array_type (TREE_TYPE (type), itype);
9042 if (type == error_mark_node)
9044 /* Happens when declaring arrays of sizes which
9045 are error_mark_node, for example. */
9048 else if (in_namespace && !friendp)
9050 /* Something like struct S { int N::j; }; */
9051 error ("invalid use of %<::%>");
9052 return error_mark_node;
9054 else if (TREE_CODE (type) == FUNCTION_TYPE)
9057 tree function_context;
9061 if (ctype == NULL_TREE)
9062 ctype = current_class_type;
9064 if (ctype == NULL_TREE)
9066 error ("can't make %qD into a method -- not in a class",
9068 return error_mark_node;
9071 /* ``A union may [ ... ] not [ have ] virtual functions.''
9073 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
9075 error ("function %qD declared virtual inside a union",
9077 return error_mark_node;
9080 if (NEW_DELETE_OPNAME_P (unqualified_id))
9084 error ("%qD cannot be declared virtual, since it "
9090 else if (staticp < 2)
9091 type = build_memfn_type (type, ctype, memfn_quals);
9094 /* Check that the name used for a destructor makes sense. */
9095 if (sfk == sfk_destructor)
9097 tree uqname = id_declarator->u.id.unqualified_name;
9101 gcc_assert (friendp);
9102 error ("expected qualified name in friend declaration "
9103 "for destructor %qD", uqname);
9104 return error_mark_node;
9107 if (!check_dtor_name (ctype, TREE_OPERAND (uqname, 0)))
9109 error ("declaration of %qD as member of %qT",
9111 return error_mark_node;
9114 else if (sfk == sfk_constructor && friendp)
9116 error ("expected qualified name in friend declaration "
9117 "for constructor %qD",
9118 id_declarator->u.id.unqualified_name);
9119 return error_mark_node;
9122 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
9123 function_context = (ctype != NULL_TREE) ?
9124 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
9125 publicp = (! friendp || ! staticp)
9126 && function_context == NULL_TREE;
9127 decl = grokfndecl (ctype, type,
9128 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
9129 ? unqualified_id : dname,
9132 virtualp, flags, memfn_quals, raises,
9133 friendp ? -1 : 0, friendp, publicp, inlinep,
9135 funcdef_flag, template_count, in_namespace,
9136 attrlist, declarator->id_loc);
9137 if (decl == NULL_TREE)
9138 return error_mark_node;
9140 /* This clobbers the attrs stored in `decl' from `attrlist'. */
9141 /* The decl and setting of decl_attr is also turned off. */
9142 decl = build_decl_attribute_variant (decl, decl_attr);
9145 /* [class.conv.ctor]
9147 A constructor declared without the function-specifier
9148 explicit that can be called with a single parameter
9149 specifies a conversion from the type of its first
9150 parameter to the type of its class. Such a constructor
9151 is called a converting constructor. */
9153 DECL_NONCONVERTING_P (decl) = 1;
9155 else if (TREE_CODE (type) == METHOD_TYPE)
9157 /* We only get here for friend declarations of
9158 members of other classes. */
9159 /* All method decls are public, so tell grokfndecl to set
9160 TREE_PUBLIC, also. */
9161 decl = grokfndecl (ctype, type,
9162 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
9163 ? unqualified_id : dname,
9166 virtualp, flags, memfn_quals, raises,
9167 friendp ? -1 : 0, friendp, 1, 0, sfk,
9168 funcdef_flag, template_count, in_namespace,
9170 declarator->id_loc);
9171 if (decl == NULL_TREE)
9172 return error_mark_node;
9174 else if (!staticp && !dependent_type_p (type)
9175 && !COMPLETE_TYPE_P (complete_type (type))
9176 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
9179 error ("field %qD has incomplete type", unqualified_id);
9181 error ("name %qT has incomplete type", type);
9183 /* If we're instantiating a template, tell them which
9184 instantiation made the field's type be incomplete. */
9185 if (current_class_type
9186 && TYPE_NAME (current_class_type)
9187 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
9189 && declspecs->type == type)
9190 error (" in instantiation of template %qT",
9191 current_class_type);
9193 return error_mark_node;
9199 error ("%qE is neither function nor member function; "
9200 "cannot be declared friend", unqualified_id);
9208 /* Friends are treated specially. */
9209 if (ctype == current_class_type)
9210 ; /* We already issued a permerror. */
9211 else if (decl && DECL_NAME (decl))
9213 if (template_class_depth (current_class_type) == 0)
9215 decl = check_explicit_specialization
9216 (unqualified_id, decl, template_count,
9217 2 * funcdef_flag + 4);
9218 if (decl == error_mark_node)
9219 return error_mark_node;
9222 decl = do_friend (ctype, unqualified_id, decl,
9228 return error_mark_node;
9231 /* Structure field. It may not be a function, except for C++. */
9233 if (decl == NULL_TREE)
9239 /* An attempt is being made to initialize a non-static
9240 member. But, from [class.mem]:
9242 4 A member-declarator can contain a
9243 constant-initializer only if it declares a static
9244 member (_class.static_) of integral or enumeration
9245 type, see _class.static.data_.
9247 This used to be relatively common practice, but
9248 the rest of the compiler does not correctly
9249 handle the initialization unless the member is
9250 static so we make it static below. */
9251 permerror (input_location, "ISO C++ forbids initialization of member %qD",
9253 permerror (input_location, "making %qD static", unqualified_id);
9257 if (uses_template_parms (type))
9258 /* We'll check at instantiation time. */
9260 else if (check_static_variable_definition (unqualified_id,
9262 /* If we just return the declaration, crashes
9263 will sometimes occur. We therefore return
9264 void_type_node, as if this was a friend
9265 declaration, to cause callers to completely
9266 ignore this declaration. */
9267 return error_mark_node;
9272 /* C++ allows static class members. All other work
9273 for this is done by grokfield. */
9274 decl = build_lang_decl (VAR_DECL, unqualified_id, type);
9275 set_linkage_for_static_data_member (decl);
9276 /* Even if there is an in-class initialization, DECL
9277 is considered undefined until an out-of-class
9278 definition is provided. */
9279 DECL_EXTERNAL (decl) = 1;
9282 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
9286 decl = build_decl (FIELD_DECL, unqualified_id, type);
9287 DECL_NONADDRESSABLE_P (decl) = bitfield;
9288 if (bitfield && !unqualified_id)
9289 TREE_NO_WARNING (decl) = 1;
9291 if (storage_class == sc_mutable)
9293 DECL_MUTABLE_P (decl) = 1;
9294 storage_class = sc_none;
9298 bad_specifiers (decl, "field", virtualp,
9299 memfn_quals != TYPE_UNQUALIFIED,
9300 inlinep, friendp, raises != NULL_TREE);
9303 else if (TREE_CODE (type) == FUNCTION_TYPE
9304 || TREE_CODE (type) == METHOD_TYPE)
9309 if (!unqualified_id)
9310 return error_mark_node;
9312 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
9313 original_name = dname;
9315 original_name = unqualified_id;
9317 if (storage_class == sc_auto)
9318 error ("storage class %<auto%> invalid for function %qs", name);
9319 else if (storage_class == sc_register)
9320 error ("storage class %<register%> invalid for function %qs", name);
9322 error ("storage class %<__thread%> invalid for function %qs", name);
9324 /* Function declaration not at top level.
9325 Storage classes other than `extern' are not allowed
9326 and `extern' makes no difference. */
9327 if (! toplevel_bindings_p ()
9328 && (storage_class == sc_static
9329 || declspecs->specs[(int)ds_inline])
9332 if (storage_class == sc_static)
9333 pedwarn (input_location, OPT_pedantic,
9334 "%<static%> specified invalid for function %qs "
9335 "declared out of global scope", name);
9337 pedwarn (input_location, OPT_pedantic,
9338 "%<inline%> specifier invalid for function %qs "
9339 "declared out of global scope", name);
9342 if (ctype != NULL_TREE
9343 && TREE_CODE (ctype) != NAMESPACE_DECL && !MAYBE_CLASS_TYPE_P (ctype))
9345 error ("%q#T is not a class or a namespace", ctype);
9349 if (ctype == NULL_TREE)
9353 error ("virtual non-class function %qs", name);
9356 else if (sfk == sfk_constructor
9357 || sfk == sfk_destructor)
9360 ? "%qs defined in a non-class scope"
9361 : "%qs declared in a non-class scope", name);
9365 else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2
9366 && !NEW_DELETE_OPNAME_P (original_name))
9367 type = build_method_type_directly (ctype,
9369 TYPE_ARG_TYPES (type));
9371 /* Record presence of `static'. */
9372 publicp = (ctype != NULL_TREE
9373 || storage_class == sc_extern
9374 || storage_class != sc_static);
9376 decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
9377 virtualp, flags, memfn_quals, raises,
9379 publicp, inlinep, sfk, funcdef_flag,
9380 template_count, in_namespace, attrlist,
9381 declarator->id_loc);
9382 if (decl == NULL_TREE)
9383 return error_mark_node;
9387 int invalid_static = 0;
9389 /* Don't allow a static member function in a class, and forbid
9390 declaring main to be static. */
9391 if (TREE_CODE (type) == METHOD_TYPE)
9393 permerror (input_location, "cannot declare member function %qD to have "
9394 "static linkage", decl);
9397 else if (current_function_decl)
9399 /* FIXME need arm citation */
9400 error ("cannot declare static function inside another function");
9407 storage_class = sc_none;
9413 /* It's a variable. */
9415 /* An uninitialized decl with `extern' is a reference. */
9416 decl = grokvardecl (type, unqualified_id,
9419 (type_quals & TYPE_QUAL_CONST) != 0,
9420 ctype ? ctype : in_namespace);
9421 bad_specifiers (decl, "variable", virtualp,
9422 memfn_quals != TYPE_UNQUALIFIED,
9423 inlinep, friendp, raises != NULL_TREE);
9427 DECL_CONTEXT (decl) = ctype;
9430 permerror (input_location, "%<static%> may not be used when defining "
9431 "(as opposed to declaring) a static data member");
9433 storage_class = sc_none;
9435 if (storage_class == sc_register && TREE_STATIC (decl))
9437 error ("static member %qD declared %<register%>", decl);
9438 storage_class = sc_none;
9440 if (storage_class == sc_extern && pedantic)
9442 pedwarn (input_location, OPT_pedantic,
9443 "cannot explicitly declare member %q#D to have "
9444 "extern linkage", decl);
9445 storage_class = sc_none;
9450 if (storage_class == sc_extern && initialized && !funcdef_flag)
9452 if (toplevel_bindings_p ())
9454 /* It's common practice (and completely valid) to have a const
9455 be initialized and declared extern. */
9456 if (!(type_quals & TYPE_QUAL_CONST))
9457 warning (0, "%qs initialized and declared %<extern%>", name);
9461 error ("%qs has both %<extern%> and initializer", name);
9462 return error_mark_node;
9466 /* Record `register' declaration for warnings on &
9467 and in case doing stupid register allocation. */
9469 if (storage_class == sc_register)
9470 DECL_REGISTER (decl) = 1;
9471 else if (storage_class == sc_extern)
9472 DECL_THIS_EXTERN (decl) = 1;
9473 else if (storage_class == sc_static)
9474 DECL_THIS_STATIC (decl) = 1;
9476 /* Record constancy and volatility on the DECL itself . There's
9477 no need to do this when processing a template; we'll do this
9478 for the instantiated declaration based on the type of DECL. */
9479 if (!processing_template_decl)
9480 cp_apply_type_quals_to_decl (type_quals, decl);
9483 TREE_NO_WARNING (decl) = 1;
9489 /* Subroutine of start_function. Ensure that each of the parameter
9490 types (as listed in PARMS) is complete, as is required for a
9491 function definition. */
9494 require_complete_types_for_parms (tree parms)
9496 for (; parms; parms = TREE_CHAIN (parms))
9498 if (dependent_type_p (TREE_TYPE (parms)))
9500 if (!VOID_TYPE_P (TREE_TYPE (parms))
9501 && complete_type_or_else (TREE_TYPE (parms), parms))
9503 relayout_decl (parms);
9504 DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
9507 /* grokparms or complete_type_or_else will have already issued
9509 TREE_TYPE (parms) = error_mark_node;
9513 /* Returns nonzero if T is a local variable. */
9516 local_variable_p (const_tree t)
9518 if ((TREE_CODE (t) == VAR_DECL
9519 /* A VAR_DECL with a context that is a _TYPE is a static data
9521 && !TYPE_P (CP_DECL_CONTEXT (t))
9522 /* Any other non-local variable must be at namespace scope. */
9523 && !DECL_NAMESPACE_SCOPE_P (t))
9524 || (TREE_CODE (t) == PARM_DECL))
9530 /* Like local_variable_p, but suitable for use as a tree-walking
9534 local_variable_p_walkfn (tree *tp, int *walk_subtrees,
9535 void *data ATTRIBUTE_UNUSED)
9537 if (local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
9539 else if (TYPE_P (*tp))
9546 /* Check that ARG, which is a default-argument expression for a
9547 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
9548 something goes wrong. DECL may also be a _TYPE node, rather than a
9549 DECL, if there is no DECL available. */
9552 check_default_argument (tree decl, tree arg)
9557 if (TREE_CODE (arg) == DEFAULT_ARG)
9558 /* We get a DEFAULT_ARG when looking at an in-class declaration
9559 with a default argument. Ignore the argument for now; we'll
9560 deal with it after the class is complete. */
9569 decl_type = TREE_TYPE (decl);
9571 if (arg == error_mark_node
9572 || decl == error_mark_node
9573 || TREE_TYPE (arg) == error_mark_node
9574 || decl_type == error_mark_node)
9575 /* Something already went wrong. There's no need to check
9577 return error_mark_node;
9579 /* [dcl.fct.default]
9581 A default argument expression is implicitly converted to the
9583 if (!TREE_TYPE (arg)
9584 || !can_convert_arg (decl_type, TREE_TYPE (arg), arg, LOOKUP_NORMAL))
9587 error ("default argument for %q#D has type %qT",
9588 decl, TREE_TYPE (arg));
9590 error ("default argument for parameter of type %qT has type %qT",
9591 decl_type, TREE_TYPE (arg));
9593 return error_mark_node;
9596 /* [dcl.fct.default]
9598 Local variables shall not be used in default argument
9601 The keyword `this' shall not be used in a default argument of a
9603 var = cp_walk_tree_without_duplicates (&arg, local_variable_p_walkfn, NULL);
9606 error ("default argument %qE uses local variable %qD", arg, var);
9607 return error_mark_node;
9614 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
9617 type_is_deprecated (tree type)
9619 enum tree_code code;
9620 if (TREE_DEPRECATED (type))
9622 if (TYPE_NAME (type)
9623 && TREE_DEPRECATED (TYPE_NAME (type)))
9626 code = TREE_CODE (type);
9628 if (code == POINTER_TYPE || code == REFERENCE_TYPE
9629 || code == OFFSET_TYPE || code == FUNCTION_TYPE
9630 || code == METHOD_TYPE || code == ARRAY_TYPE)
9631 return type_is_deprecated (TREE_TYPE (type));
9633 if (TYPE_PTRMEMFUNC_P (type))
9634 return type_is_deprecated
9635 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type))));
9640 /* Decode the list of parameter types for a function type.
9641 Given the list of things declared inside the parens,
9642 return a list of types.
9644 If this parameter does not end with an ellipsis, we append
9647 *PARMS is set to the chain of PARM_DECLs created. */
9650 grokparms (tree parmlist, tree *parms)
9652 tree result = NULL_TREE;
9653 tree decls = NULL_TREE;
9657 for (parm = parmlist; parm != NULL_TREE; parm = TREE_CHAIN (parm))
9659 tree type = NULL_TREE;
9660 tree init = TREE_PURPOSE (parm);
9661 tree decl = TREE_VALUE (parm);
9663 if (parm == void_list_node)
9666 if (! decl || TREE_TYPE (decl) == error_mark_node)
9669 type = TREE_TYPE (decl);
9670 if (VOID_TYPE_P (type))
9672 if (same_type_p (type, void_type_node)
9673 && DECL_SELF_REFERENCE_P (type)
9674 && !DECL_NAME (decl) && !result && TREE_CHAIN (parm) == void_list_node)
9675 /* this is a parmlist of `(void)', which is ok. */
9677 cxx_incomplete_type_error (decl, type);
9678 /* It's not a good idea to actually create parameters of
9679 type `void'; other parts of the compiler assume that a
9680 void type terminates the parameter list. */
9681 type = error_mark_node;
9682 TREE_TYPE (decl) = error_mark_node;
9685 if (type != error_mark_node
9686 && TYPE_FOR_JAVA (type)
9687 && MAYBE_CLASS_TYPE_P (type))
9689 error ("parameter %qD has Java class type", decl);
9690 type = error_mark_node;
9691 TREE_TYPE (decl) = error_mark_node;
9695 if (type != error_mark_node)
9697 if (deprecated_state != DEPRECATED_SUPPRESS)
9699 tree deptype = type_is_deprecated (type);
9701 warn_deprecated_use (deptype);
9704 /* Top-level qualifiers on the parameters are
9705 ignored for function types. */
9706 type = cp_build_qualified_type (type, 0);
9707 if (TREE_CODE (type) == METHOD_TYPE)
9709 error ("parameter %qD invalidly declared method type", decl);
9710 type = build_pointer_type (type);
9711 TREE_TYPE (decl) = type;
9713 else if (abstract_virtuals_error (decl, type))
9714 any_error = 1; /* Seems like a good idea. */
9715 else if (POINTER_TYPE_P (type))
9717 /* [dcl.fct]/6, parameter types cannot contain pointers
9718 (references) to arrays of unknown bound. */
9719 tree t = TREE_TYPE (type);
9720 int ptr = TYPE_PTR_P (type);
9726 else if (TREE_CODE (t) != ARRAY_TYPE)
9728 else if (!TYPE_DOMAIN (t))
9732 if (TREE_CODE (t) == ARRAY_TYPE)
9733 error ("parameter %qD includes %s to array of unknown "
9735 decl, ptr ? "pointer" : "reference", t);
9740 else if (init && !processing_template_decl)
9741 init = check_default_argument (decl, init);
9744 if (TREE_CODE (decl) == PARM_DECL
9745 && FUNCTION_PARAMETER_PACK_P (decl)
9746 && TREE_CHAIN (parm)
9747 && TREE_CHAIN (parm) != void_list_node)
9748 error ("parameter packs must be at the end of the parameter list");
9750 TREE_CHAIN (decl) = decls;
9752 result = tree_cons (init, type, result);
9754 decls = nreverse (decls);
9755 result = nreverse (result);
9757 result = chainon (result, void_list_node);
9764 /* D is a constructor or overloaded `operator='.
9766 Let T be the class in which D is declared. Then, this function
9769 -1 if D's is an ill-formed constructor or copy assignment operator
9770 whose first parameter is of type `T'.
9771 0 if D is not a copy constructor or copy assignment
9773 1 if D is a copy constructor or copy assignment operator whose
9774 first parameter is a reference to const qualified T.
9775 2 if D is a copy constructor or copy assignment operator whose
9776 first parameter is a reference to non-const qualified T.
9778 This function can be used as a predicate. Positive values indicate
9779 a copy constructor and nonzero values indicate a copy assignment
9783 copy_fn_p (const_tree d)
9789 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
9791 if (TREE_CODE (d) == TEMPLATE_DECL
9792 || (DECL_TEMPLATE_INFO (d)
9793 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
9794 /* Instantiations of template member functions are never copy
9795 functions. Note that member functions of templated classes are
9796 represented as template functions internally, and we must
9797 accept those as copy functions. */
9800 args = FUNCTION_FIRST_USER_PARMTYPE (d);
9804 arg_type = TREE_VALUE (args);
9805 if (arg_type == error_mark_node)
9808 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
9810 /* Pass by value copy assignment operator. */
9813 else if (TREE_CODE (arg_type) == REFERENCE_TYPE
9814 && !TYPE_REF_IS_RVALUE (arg_type)
9815 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
9817 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
9823 args = TREE_CHAIN (args);
9825 if (args && args != void_list_node && !TREE_PURPOSE (args))
9826 /* There are more non-optional args. */
9832 /* D is a constructor or overloaded `operator='.
9834 Let T be the class in which D is declared. Then, this function
9835 returns true when D is a move constructor or move assignment
9836 operator, false otherwise. */
9839 move_fn_p (const_tree d)
9843 bool result = false;
9845 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
9847 if (cxx_dialect == cxx98)
9848 /* There are no move constructors if we are in C++98 mode. */
9851 if (TREE_CODE (d) == TEMPLATE_DECL
9852 || (DECL_TEMPLATE_INFO (d)
9853 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
9854 /* Instantiations of template member functions are never copy
9855 functions. Note that member functions of templated classes are
9856 represented as template functions internally, and we must
9857 accept those as copy functions. */
9860 args = FUNCTION_FIRST_USER_PARMTYPE (d);
9864 arg_type = TREE_VALUE (args);
9865 if (arg_type == error_mark_node)
9868 if (TREE_CODE (arg_type) == REFERENCE_TYPE
9869 && TYPE_REF_IS_RVALUE (arg_type)
9870 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)),
9874 args = TREE_CHAIN (args);
9876 if (args && args != void_list_node && !TREE_PURPOSE (args))
9877 /* There are more non-optional args. */
9883 /* Remember any special properties of member function DECL. */
9886 grok_special_member_properties (tree decl)
9890 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
9893 class_type = DECL_CONTEXT (decl);
9894 if (DECL_CONSTRUCTOR_P (decl))
9896 int ctor = copy_fn_p (decl);
9898 if (!DECL_ARTIFICIAL (decl))
9899 TYPE_HAS_USER_CONSTRUCTOR (class_type) = 1;
9905 A non-template constructor for class X is a copy
9906 constructor if its first parameter is of type X&, const
9907 X&, volatile X& or const volatile X&, and either there
9908 are no other parameters or else all other parameters have
9909 default arguments. */
9910 TYPE_HAS_INIT_REF (class_type) = 1;
9911 if (!DECL_DEFAULTED_FN (decl))
9912 TYPE_HAS_COMPLEX_INIT_REF (class_type) = 1;
9914 TYPE_HAS_CONST_INIT_REF (class_type) = 1;
9916 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
9918 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type) = 1;
9919 if (TREE_CODE (decl) == TEMPLATE_DECL || !DECL_DEFAULTED_FN (decl))
9920 TYPE_HAS_COMPLEX_DFLT (class_type) = 1;
9922 else if (is_list_ctor (decl))
9923 TYPE_HAS_LIST_CTOR (class_type) = 1;
9925 else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
9929 A non-template assignment operator for class X is a copy
9930 assignment operator if its parameter is of type X, X&, const
9931 X&, volatile X& or const volatile X&. */
9933 int assop = copy_fn_p (decl);
9937 TYPE_HAS_ASSIGN_REF (class_type) = 1;
9938 if (!DECL_DEFAULTED_FN (decl))
9939 TYPE_HAS_COMPLEX_ASSIGN_REF (class_type) = 1;
9941 TYPE_HAS_CONST_ASSIGN_REF (class_type) = 1;
9946 /* Check a constructor DECL has the correct form. Complains
9947 if the class has a constructor of the form X(X). */
9950 grok_ctor_properties (const_tree ctype, const_tree decl)
9952 int ctor_parm = copy_fn_p (decl);
9958 A declaration of a constructor for a class X is ill-formed if
9959 its first parameter is of type (optionally cv-qualified) X
9960 and either there are no other parameters or else all other
9961 parameters have default arguments.
9963 We *don't* complain about member template instantiations that
9964 have this form, though; they can occur as we try to decide
9965 what constructor to use during overload resolution. Since
9966 overload resolution will never prefer such a constructor to
9967 the non-template copy constructor (which is either explicitly
9968 or implicitly defined), there's no need to worry about their
9969 existence. Theoretically, they should never even be
9970 instantiated, but that's hard to forestall. */
9971 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
9979 /* An operator with this code is unary, but can also be binary. */
9982 ambi_op_p (enum tree_code code)
9984 return (code == INDIRECT_REF
9985 || code == ADDR_EXPR
9986 || code == UNARY_PLUS_EXPR
9987 || code == NEGATE_EXPR
9988 || code == PREINCREMENT_EXPR
9989 || code == PREDECREMENT_EXPR);
9992 /* An operator with this name can only be unary. */
9995 unary_op_p (enum tree_code code)
9997 return (code == TRUTH_NOT_EXPR
9998 || code == BIT_NOT_EXPR
9999 || code == COMPONENT_REF
10000 || code == TYPE_EXPR);
10003 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
10004 errors are issued for invalid declarations. */
10007 grok_op_properties (tree decl, bool complain)
10009 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
10011 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
10012 tree name = DECL_NAME (decl);
10013 enum tree_code operator_code;
10018 /* Count the number of arguments and check for ellipsis. */
10019 for (argtype = argtypes, arity = 0;
10020 argtype && argtype != void_list_node;
10021 argtype = TREE_CHAIN (argtype))
10023 ellipsis_p = !argtype;
10025 class_type = DECL_CONTEXT (decl);
10026 if (class_type && !CLASS_TYPE_P (class_type))
10027 class_type = NULL_TREE;
10029 if (DECL_CONV_FN_P (decl))
10030 operator_code = TYPE_EXPR;
10034 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
10035 if (ansi_opname (CODE) == name) \
10037 operator_code = (CODE); \
10040 else if (ansi_assopname (CODE) == name) \
10042 operator_code = (CODE); \
10043 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
10047 #include "operators.def"
10048 #undef DEF_OPERATOR
10050 gcc_unreachable ();
10053 gcc_assert (operator_code != MAX_TREE_CODES);
10054 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
10057 switch (operator_code)
10060 TYPE_HAS_NEW_OPERATOR (class_type) = 1;
10064 TYPE_GETS_DELETE (class_type) |= 1;
10068 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type) = 1;
10071 case VEC_DELETE_EXPR:
10072 TYPE_GETS_DELETE (class_type) |= 2;
10079 /* [basic.std.dynamic.allocation]/1:
10081 A program is ill-formed if an allocation function is declared
10082 in a namespace scope other than global scope or declared static
10085 The same also holds true for deallocation functions. */
10086 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR
10087 || operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
10089 if (DECL_NAMESPACE_SCOPE_P (decl))
10091 if (CP_DECL_CONTEXT (decl) != global_namespace)
10093 error ("%qD may not be declared within a namespace", decl);
10096 else if (!TREE_PUBLIC (decl))
10098 error ("%qD may not be declared as static", decl);
10104 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
10106 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
10107 DECL_IS_OPERATOR_NEW (decl) = 1;
10109 else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
10110 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
10113 /* An operator function must either be a non-static member function
10114 or have at least one parameter of a class, a reference to a class,
10115 an enumeration, or a reference to an enumeration. 13.4.0.6 */
10116 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
10118 if (operator_code == TYPE_EXPR
10119 || operator_code == CALL_EXPR
10120 || operator_code == COMPONENT_REF
10121 || operator_code == ARRAY_REF
10122 || operator_code == NOP_EXPR)
10124 error ("%qD must be a nonstatic member function", decl);
10131 if (DECL_STATIC_FUNCTION_P (decl))
10133 error ("%qD must be either a non-static member "
10134 "function or a non-member function", decl);
10138 for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
10140 tree arg = non_reference (TREE_VALUE (p));
10141 if (arg == error_mark_node)
10144 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
10145 because these checks are performed even on
10146 template functions. */
10147 if (MAYBE_CLASS_TYPE_P (arg)
10148 || TREE_CODE (arg) == ENUMERAL_TYPE)
10152 if (!p || p == void_list_node)
10155 error ("%qD must have an argument of class or "
10156 "enumerated type", decl);
10162 /* There are no restrictions on the arguments to an overloaded
10164 if (operator_code == CALL_EXPR)
10167 /* Warn about conversion operators that will never be used. */
10168 if (IDENTIFIER_TYPENAME_P (name)
10169 && ! DECL_TEMPLATE_INFO (decl)
10171 /* Warn only declaring the function; there is no need to
10172 warn again about out-of-class definitions. */
10173 && class_type == current_class_type)
10175 tree t = TREE_TYPE (name);
10176 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
10177 const char *what = 0;
10180 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
10182 if (TREE_CODE (t) == VOID_TYPE)
10184 else if (class_type)
10186 if (t == class_type)
10187 what = "the same type";
10188 /* Don't force t to be complete here. */
10189 else if (MAYBE_CLASS_TYPE_P (t)
10190 && COMPLETE_TYPE_P (t)
10191 && DERIVED_FROM_P (t, class_type))
10192 what = "a base class";
10196 warning (OPT_Wconversion, "conversion to %s%s will never use a type "
10197 "conversion operator",
10198 ref ? "a reference to " : "", what);
10201 if (operator_code == COND_EXPR)
10204 error ("ISO C++ prohibits overloading operator ?:");
10207 else if (ellipsis_p)
10209 error ("%qD must not have variable number of arguments", decl);
10212 else if (ambi_op_p (operator_code))
10215 /* We pick the one-argument operator codes by default, so
10216 we don't have to change anything. */
10218 else if (arity == 2)
10220 /* If we thought this was a unary operator, we now know
10221 it to be a binary operator. */
10222 switch (operator_code)
10225 operator_code = MULT_EXPR;
10229 operator_code = BIT_AND_EXPR;
10232 case UNARY_PLUS_EXPR:
10233 operator_code = PLUS_EXPR;
10237 operator_code = MINUS_EXPR;
10240 case PREINCREMENT_EXPR:
10241 operator_code = POSTINCREMENT_EXPR;
10244 case PREDECREMENT_EXPR:
10245 operator_code = POSTDECREMENT_EXPR;
10249 gcc_unreachable ();
10252 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
10254 if ((operator_code == POSTINCREMENT_EXPR
10255 || operator_code == POSTDECREMENT_EXPR)
10256 && ! processing_template_decl
10257 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
10260 error ("postfix %qD must take %<int%> as its argument",
10263 error ("postfix %qD must take %<int%> as its second "
10271 error ("%qD must take either zero or one argument", decl);
10273 error ("%qD must take either one or two arguments", decl);
10277 /* More Effective C++ rule 6. */
10279 && (operator_code == POSTINCREMENT_EXPR
10280 || operator_code == POSTDECREMENT_EXPR
10281 || operator_code == PREINCREMENT_EXPR
10282 || operator_code == PREDECREMENT_EXPR))
10284 tree arg = TREE_VALUE (argtypes);
10285 tree ret = TREE_TYPE (TREE_TYPE (decl));
10286 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
10287 arg = TREE_TYPE (arg);
10288 arg = TYPE_MAIN_VARIANT (arg);
10289 if (operator_code == PREINCREMENT_EXPR
10290 || operator_code == PREDECREMENT_EXPR)
10292 if (TREE_CODE (ret) != REFERENCE_TYPE
10293 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
10295 warning (OPT_Weffc__, "prefix %qD should return %qT", decl,
10296 build_reference_type (arg));
10300 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
10301 warning (OPT_Weffc__, "postfix %qD should return %qT", decl, arg);
10305 else if (unary_op_p (operator_code))
10310 error ("%qD must take %<void%>", decl);
10312 error ("%qD must take exactly one argument", decl);
10316 else /* if (binary_op_p (operator_code)) */
10321 error ("%qD must take exactly one argument", decl);
10323 error ("%qD must take exactly two arguments", decl);
10327 /* More Effective C++ rule 7. */
10329 && (operator_code == TRUTH_ANDIF_EXPR
10330 || operator_code == TRUTH_ORIF_EXPR
10331 || operator_code == COMPOUND_EXPR))
10332 warning (OPT_Weffc__, "user-defined %qD always evaluates both arguments",
10336 /* Effective C++ rule 23. */
10339 && !DECL_ASSIGNMENT_OPERATOR_P (decl)
10340 && (operator_code == PLUS_EXPR
10341 || operator_code == MINUS_EXPR
10342 || operator_code == TRUNC_DIV_EXPR
10343 || operator_code == MULT_EXPR
10344 || operator_code == TRUNC_MOD_EXPR)
10345 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
10346 warning (OPT_Weffc__, "%qD should return by value", decl);
10348 /* [over.oper]/8 */
10349 for (; argtypes && argtypes != void_list_node;
10350 argtypes = TREE_CHAIN (argtypes))
10351 if (TREE_PURPOSE (argtypes))
10353 TREE_PURPOSE (argtypes) = NULL_TREE;
10354 if (operator_code == POSTINCREMENT_EXPR
10355 || operator_code == POSTDECREMENT_EXPR)
10357 pedwarn (input_location, OPT_pedantic, "%qD cannot have default arguments",
10362 error ("%qD cannot have default arguments", decl);
10370 /* Return a string giving the keyword associate with CODE. */
10372 static const char *
10373 tag_name (enum tag_types code)
10385 case typename_type:
10388 gcc_unreachable ();
10392 /* Name lookup in an elaborated-type-specifier (after the keyword
10393 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
10394 elaborated-type-specifier is invalid, issue a diagnostic and return
10395 error_mark_node; otherwise, return the *_TYPE to which it referred.
10396 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
10399 check_elaborated_type_specifier (enum tag_types tag_code,
10401 bool allow_template_p)
10407 struct S { struct S *p; };
10409 name lookup will find the TYPE_DECL for the implicit "S::S"
10410 typedef. Adjust for that here. */
10411 if (DECL_SELF_REFERENCE_P (decl))
10412 decl = TYPE_NAME (TREE_TYPE (decl));
10414 type = TREE_TYPE (decl);
10416 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
10417 is false for this case as well. */
10418 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
10420 error ("using template type parameter %qT after %qs",
10421 type, tag_name (tag_code));
10422 return error_mark_node;
10426 If the identifier resolves to a typedef-name or a template
10427 type-parameter, the elaborated-type-specifier is ill-formed.
10429 In other words, the only legitimate declaration to use in the
10430 elaborated type specifier is the implicit typedef created when
10431 the type is declared. */
10432 else if (!DECL_IMPLICIT_TYPEDEF_P (decl)
10433 && tag_code != typename_type)
10435 error ("using typedef-name %qD after %qs", decl, tag_name (tag_code));
10436 error ("%q+D has a previous declaration here", decl);
10437 return error_mark_node;
10439 else if (TREE_CODE (type) != RECORD_TYPE
10440 && TREE_CODE (type) != UNION_TYPE
10441 && tag_code != enum_type
10442 && tag_code != typename_type)
10444 error ("%qT referred to as %qs", type, tag_name (tag_code));
10445 error ("%q+T has a previous declaration here", type);
10446 return error_mark_node;
10448 else if (TREE_CODE (type) != ENUMERAL_TYPE
10449 && tag_code == enum_type)
10451 error ("%qT referred to as enum", type);
10452 error ("%q+T has a previous declaration here", type);
10453 return error_mark_node;
10455 else if (!allow_template_p
10456 && TREE_CODE (type) == RECORD_TYPE
10457 && CLASSTYPE_IS_TEMPLATE (type))
10459 /* If a class template appears as elaborated type specifier
10460 without a template header such as:
10462 template <class T> class C {};
10463 void f(class C); // No template header here
10465 then the required template argument is missing. */
10466 error ("template argument required for %<%s %T%>",
10467 tag_name (tag_code),
10468 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
10469 return error_mark_node;
10475 /* Lookup NAME in elaborate type specifier in scope according to
10476 SCOPE and issue diagnostics if necessary.
10477 Return *_TYPE node upon success, NULL_TREE when the NAME is not
10478 found, and ERROR_MARK_NODE for type error. */
10481 lookup_and_check_tag (enum tag_types tag_code, tree name,
10482 tag_scope scope, bool template_header_p)
10486 if (scope == ts_global)
10488 /* First try ordinary name lookup, ignoring hidden class name
10489 injected via friend declaration. */
10490 decl = lookup_name_prefer_type (name, 2);
10491 /* If that fails, the name will be placed in the smallest
10492 non-class, non-function-prototype scope according to 3.3.1/5.
10493 We may already have a hidden name declared as friend in this
10494 scope. So lookup again but not ignoring hidden names.
10495 If we find one, that name will be made visible rather than
10496 creating a new tag. */
10498 decl = lookup_type_scope (name, ts_within_enclosing_non_class);
10501 decl = lookup_type_scope (name, scope);
10503 if (decl && DECL_CLASS_TEMPLATE_P (decl))
10504 decl = DECL_TEMPLATE_RESULT (decl);
10506 if (decl && TREE_CODE (decl) == TYPE_DECL)
10508 /* Look for invalid nested type:
10512 if (scope == ts_current && DECL_SELF_REFERENCE_P (decl))
10514 error ("%qD has the same name as the class in which it is "
10517 return error_mark_node;
10520 /* Two cases we need to consider when deciding if a class
10521 template is allowed as an elaborated type specifier:
10522 1. It is a self reference to its own class.
10523 2. It comes with a template header.
10527 template <class T> class C {
10528 class C *c1; // DECL_SELF_REFERENCE_P is true
10531 template <class U> class C; // template_header_p is true
10532 template <class T> class C<T>::D {
10533 class C *c2; // DECL_SELF_REFERENCE_P is true
10536 t = check_elaborated_type_specifier (tag_code,
10539 | DECL_SELF_REFERENCE_P (decl));
10542 else if (decl && TREE_CODE (decl) == TREE_LIST)
10544 error ("reference to %qD is ambiguous", name);
10545 print_candidates (decl);
10546 return error_mark_node;
10552 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
10553 Define the tag as a forward-reference if it is not defined.
10555 If a declaration is given, process it here, and report an error if
10556 multiple declarations are not identical.
10558 SCOPE is TS_CURRENT when this is also a definition. Only look in
10559 the current frame for the name (since C++ allows new names in any
10560 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
10561 declaration. Only look beginning from the current scope outward up
10562 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
10564 TEMPLATE_HEADER_P is true when this declaration is preceded by
10565 a set of template parameters. */
10568 xref_tag (enum tag_types tag_code, tree name,
10569 tag_scope scope, bool template_header_p)
10571 enum tree_code code;
10573 tree context = NULL_TREE;
10575 timevar_push (TV_NAME_LOOKUP);
10577 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
10583 code = RECORD_TYPE;
10589 code = ENUMERAL_TYPE;
10592 gcc_unreachable ();
10595 /* In case of anonymous name, xref_tag is only called to
10596 make type node and push name. Name lookup is not required. */
10597 if (ANON_AGGRNAME_P (name))
10600 t = lookup_and_check_tag (tag_code, name,
10601 scope, template_header_p);
10603 if (t == error_mark_node)
10604 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10606 if (scope != ts_current && t && current_class_type
10607 && template_class_depth (current_class_type)
10608 && template_header_p)
10610 /* Since SCOPE is not TS_CURRENT, we are not looking at a
10611 definition of this tag. Since, in addition, we are currently
10612 processing a (member) template declaration of a template
10613 class, we must be very careful; consider:
10620 { template <class V>
10621 friend struct S1; };
10623 Here, the S2::S1 declaration should not be confused with the
10624 outer declaration. In particular, the inner version should
10625 have a template parameter of level 2, not level 1. This
10626 would be particularly important if the member declaration
10629 template <class V = U> friend struct S1;
10631 say, when we should tsubst into `U' when instantiating
10632 S2. On the other hand, when presented with:
10642 we must find the inner binding eventually. We
10643 accomplish this by making sure that the new type we
10644 create to represent this declaration has the right
10646 context = TYPE_CONTEXT (t);
10652 /* If no such tag is yet defined, create a forward-reference node
10653 and record it as the "definition".
10654 When a real declaration of this type is found,
10655 the forward-reference will be altered into a real type. */
10656 if (code == ENUMERAL_TYPE)
10658 error ("use of enum %q#D without previous declaration", name);
10659 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10663 t = make_class_type (code);
10664 TYPE_CONTEXT (t) = context;
10665 t = pushtag (name, t, scope);
10670 if (template_header_p && MAYBE_CLASS_TYPE_P (t))
10672 if (!redeclare_class_template (t, current_template_parms))
10673 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10675 else if (!processing_template_decl
10676 && CLASS_TYPE_P (t)
10677 && CLASSTYPE_IS_TEMPLATE (t))
10679 error ("redeclaration of %qT as a non-template", t);
10680 error ("previous declaration %q+D", t);
10681 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10684 /* Make injected friend class visible. */
10685 if (scope != ts_within_enclosing_non_class
10686 && hidden_name_p (TYPE_NAME (t)))
10688 DECL_ANTICIPATED (TYPE_NAME (t)) = 0;
10689 DECL_FRIEND_P (TYPE_NAME (t)) = 0;
10691 if (TYPE_TEMPLATE_INFO (t))
10693 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t)) = 0;
10694 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t)) = 0;
10699 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
10703 xref_tag_from_type (tree old, tree id, tag_scope scope)
10705 enum tag_types tag_kind;
10707 if (TREE_CODE (old) == RECORD_TYPE)
10708 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
10710 tag_kind = union_type;
10712 if (id == NULL_TREE)
10713 id = TYPE_IDENTIFIER (old);
10715 return xref_tag (tag_kind, id, scope, false);
10718 /* Create the binfo hierarchy for REF with (possibly NULL) base list
10719 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
10720 access_* node, and the TREE_VALUE is the type of the base-class.
10721 Non-NULL TREE_TYPE indicates virtual inheritance.
10723 Returns true if the binfo hierarchy was successfully created,
10724 false if an error was detected. */
10727 xref_basetypes (tree ref, tree base_list)
10730 tree binfo, base_binfo;
10731 unsigned max_vbases = 0; /* Maximum direct & indirect virtual bases. */
10732 unsigned max_bases = 0; /* Maximum direct bases. */
10734 tree default_access;
10735 tree igo_prev; /* Track Inheritance Graph Order. */
10737 if (ref == error_mark_node)
10740 /* The base of a derived class is private by default, all others are
10742 default_access = (TREE_CODE (ref) == RECORD_TYPE
10743 && CLASSTYPE_DECLARED_CLASS (ref)
10744 ? access_private_node : access_public_node);
10746 /* First, make sure that any templates in base-classes are
10747 instantiated. This ensures that if we call ourselves recursively
10748 we do not get confused about which classes are marked and which
10750 basep = &base_list;
10753 tree basetype = TREE_VALUE (*basep);
10755 if (!(processing_template_decl && uses_template_parms (basetype))
10756 && !complete_type_or_else (basetype, NULL))
10757 /* An incomplete type. Remove it from the list. */
10758 *basep = TREE_CHAIN (*basep);
10762 if (TREE_TYPE (*basep))
10764 if (CLASS_TYPE_P (basetype))
10765 max_vbases += VEC_length (tree, CLASSTYPE_VBASECLASSES (basetype));
10766 basep = &TREE_CHAIN (*basep);
10770 TYPE_MARKED_P (ref) = 1;
10772 /* The binfo slot should be empty, unless this is an (ill-formed)
10774 gcc_assert (!TYPE_BINFO (ref) || TYPE_SIZE (ref));
10775 gcc_assert (TYPE_MAIN_VARIANT (ref) == ref);
10777 binfo = make_tree_binfo (max_bases);
10779 TYPE_BINFO (ref) = binfo;
10780 BINFO_OFFSET (binfo) = size_zero_node;
10781 BINFO_TYPE (binfo) = ref;
10783 /* Apply base-class info set up to the variants of this type. */
10784 fixup_type_variants (ref);
10788 BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, gc, max_bases);
10789 /* An aggregate cannot have baseclasses. */
10790 CLASSTYPE_NON_AGGREGATE (ref) = 1;
10792 if (TREE_CODE (ref) == UNION_TYPE)
10794 error ("derived union %qT invalid", ref);
10801 if (TYPE_FOR_JAVA (ref))
10803 error ("Java class %qT cannot have multiple bases", ref);
10810 CLASSTYPE_VBASECLASSES (ref) = VEC_alloc (tree, gc, max_vbases);
10812 if (TYPE_FOR_JAVA (ref))
10814 error ("Java class %qT cannot have virtual bases", ref);
10819 for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list))
10821 tree access = TREE_PURPOSE (base_list);
10822 int via_virtual = TREE_TYPE (base_list) != NULL_TREE;
10823 tree basetype = TREE_VALUE (base_list);
10825 if (access == access_default_node)
10826 access = default_access;
10828 if (PACK_EXPANSION_P (basetype))
10829 basetype = PACK_EXPANSION_PATTERN (basetype);
10830 if (TREE_CODE (basetype) == TYPE_DECL)
10831 basetype = TREE_TYPE (basetype);
10832 if (!MAYBE_CLASS_TYPE_P (basetype) || TREE_CODE (basetype) == UNION_TYPE)
10834 error ("base type %qT fails to be a struct or class type",
10839 if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0))
10840 TYPE_FOR_JAVA (ref) = 1;
10842 base_binfo = NULL_TREE;
10843 if (CLASS_TYPE_P (basetype) && !dependent_type_p (basetype))
10845 base_binfo = TYPE_BINFO (basetype);
10846 /* The original basetype could have been a typedef'd type. */
10847 basetype = BINFO_TYPE (base_binfo);
10849 /* Inherit flags from the base. */
10850 TYPE_HAS_NEW_OPERATOR (ref)
10851 |= TYPE_HAS_NEW_OPERATOR (basetype);
10852 TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
10853 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
10854 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
10855 TYPE_HAS_CONVERSION (ref) |= TYPE_HAS_CONVERSION (basetype);
10856 CLASSTYPE_DIAMOND_SHAPED_P (ref)
10857 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype);
10858 CLASSTYPE_REPEATED_BASE_P (ref)
10859 |= CLASSTYPE_REPEATED_BASE_P (basetype);
10862 /* We must do this test after we've seen through a typedef
10864 if (TYPE_MARKED_P (basetype))
10866 if (basetype == ref)
10867 error ("recursive type %qT undefined", basetype);
10869 error ("duplicate base type %qT invalid", basetype);
10873 if (PACK_EXPANSION_P (TREE_VALUE (base_list)))
10874 /* Regenerate the pack expansion for the bases. */
10875 basetype = make_pack_expansion (basetype);
10877 TYPE_MARKED_P (basetype) = 1;
10879 base_binfo = copy_binfo (base_binfo, basetype, ref,
10880 &igo_prev, via_virtual);
10881 if (!BINFO_INHERITANCE_CHAIN (base_binfo))
10882 BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
10884 BINFO_BASE_APPEND (binfo, base_binfo);
10885 BINFO_BASE_ACCESS_APPEND (binfo, access);
10888 if (VEC_space (tree, CLASSTYPE_VBASECLASSES (ref), 1))
10889 /* If we have space in the vbase vector, we must have shared at
10890 least one of them, and are therefore diamond shaped. */
10891 CLASSTYPE_DIAMOND_SHAPED_P (ref) = 1;
10893 /* Unmark all the types. */
10894 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
10895 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
10896 TYPE_MARKED_P (ref) = 0;
10898 /* Now see if we have a repeated base type. */
10899 if (!CLASSTYPE_REPEATED_BASE_P (ref))
10901 for (base_binfo = binfo; base_binfo;
10902 base_binfo = TREE_CHAIN (base_binfo))
10904 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
10906 CLASSTYPE_REPEATED_BASE_P (ref) = 1;
10909 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 1;
10911 for (base_binfo = binfo; base_binfo;
10912 base_binfo = TREE_CHAIN (base_binfo))
10913 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
10914 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
10923 /* Begin compiling the definition of an enumeration type.
10926 UNDERLYING_TYPE is the type that will be used as the storage for
10927 the enumeration type. This should be NULL_TREE if no storage type
10930 SCOPED_ENUM_P is true if this is a scoped enumeration type.
10932 Returns the type object, as yet incomplete.
10933 Also records info about it so that build_enumerator
10934 may be used to declare the individual values as they are read. */
10937 start_enum (tree name, tree underlying_type, bool scoped_enum_p)
10941 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
10943 /* If this is the real definition for a previous forward reference,
10944 fill in the contents in the same object that used to be the
10945 forward reference. */
10947 enumtype = lookup_and_check_tag (enum_type, name,
10948 /*tag_scope=*/ts_current,
10949 /*template_header_p=*/false);
10951 if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
10953 error ("multiple definition of %q#T", enumtype);
10954 error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype));
10955 /* Clear out TYPE_VALUES, and start again. */
10956 TYPE_VALUES (enumtype) = NULL_TREE;
10960 /* In case of error, make a dummy enum to allow parsing to
10962 if (enumtype == error_mark_node)
10963 name = make_anon_name ();
10965 enumtype = make_node (ENUMERAL_TYPE);
10966 enumtype = pushtag (name, enumtype, /*tag_scope=*/ts_current);
10969 if (enumtype == error_mark_node)
10974 SET_SCOPED_ENUM_P (enumtype, 1);
10975 begin_scope (sk_scoped_enum, enumtype);
10977 /* [C++0x dcl.enum]p5:
10979 If not explicitly specified, the underlying type of a scoped
10980 enumeration type is int. */
10981 if (!underlying_type)
10982 underlying_type = integer_type_node;
10985 if (underlying_type)
10987 if (CP_INTEGRAL_TYPE_P (underlying_type))
10989 TYPE_MIN_VALUE (enumtype) = TYPE_MIN_VALUE (underlying_type);
10990 TYPE_MAX_VALUE (enumtype) = TYPE_MAX_VALUE (underlying_type);
10991 TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
10992 TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
10993 SET_TYPE_MODE (enumtype, TYPE_MODE (underlying_type));
10994 TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type);
10995 TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
10996 TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
10997 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);
10998 ENUM_UNDERLYING_TYPE (enumtype) = underlying_type;
11001 error ("underlying type %<%T%> of %<%T%> must be an integral type",
11002 underlying_type, enumtype);
11008 /* After processing and defining all the values of an enumeration type,
11009 install their decls in the enumeration type and finish it off.
11010 ENUMTYPE is the type object and VALUES a list of name-value pairs. */
11013 finish_enum (tree enumtype)
11022 bool use_short_enum;
11026 integer_type_kind itk;
11027 tree underlying_type = NULL_TREE;
11028 bool fixed_underlying_type_p
11029 = ENUM_UNDERLYING_TYPE (enumtype) != NULL_TREE;
11031 /* We built up the VALUES in reverse order. */
11032 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
11034 /* For an enum defined in a template, just set the type of the values;
11035 all further processing is postponed until the template is
11036 instantiated. We need to set the type so that tsubst of a CONST_DECL
11038 if (processing_template_decl)
11040 for (values = TYPE_VALUES (enumtype);
11042 values = TREE_CHAIN (values))
11043 TREE_TYPE (TREE_VALUE (values)) = enumtype;
11044 if (at_function_scope_p ())
11045 add_stmt (build_min (TAG_DEFN, enumtype));
11049 /* Determine the minimum and maximum values of the enumerators. */
11050 if (TYPE_VALUES (enumtype))
11052 minnode = maxnode = NULL_TREE;
11054 for (values = TYPE_VALUES (enumtype);
11056 values = TREE_CHAIN (values))
11058 decl = TREE_VALUE (values);
11060 /* [dcl.enum]: Following the closing brace of an enum-specifier,
11061 each enumerator has the type of its enumeration. Prior to the
11062 closing brace, the type of each enumerator is the type of its
11063 initializing value. */
11064 TREE_TYPE (decl) = enumtype;
11066 /* Update the minimum and maximum values, if appropriate. */
11067 value = DECL_INITIAL (decl);
11068 if (value == error_mark_node)
11069 value = integer_zero_node;
11070 /* Figure out what the minimum and maximum values of the
11071 enumerators are. */
11073 minnode = maxnode = value;
11074 else if (tree_int_cst_lt (maxnode, value))
11076 else if (tree_int_cst_lt (value, minnode))
11083 If the enumerator-list is empty, the underlying type is as if
11084 the enumeration had a single enumerator with value 0. */
11085 minnode = maxnode = integer_zero_node;
11087 /* Compute the number of bits require to represent all values of the
11088 enumeration. We must do this before the type of MINNODE and
11089 MAXNODE are transformed, since tree_int_cst_min_precision relies
11090 on the TREE_TYPE of the value it is passed. */
11091 unsignedp = tree_int_cst_sgn (minnode) >= 0;
11092 lowprec = tree_int_cst_min_precision (minnode, unsignedp);
11093 highprec = tree_int_cst_min_precision (maxnode, unsignedp);
11094 precision = MAX (lowprec, highprec);
11096 if (!fixed_underlying_type_p)
11098 /* Determine the underlying type of the enumeration.
11102 The underlying type of an enumeration is an integral type that
11103 can represent all the enumerator values defined in the
11104 enumeration. It is implementation-defined which integral type is
11105 used as the underlying type for an enumeration except that the
11106 underlying type shall not be larger than int unless the value of
11107 an enumerator cannot fit in an int or unsigned int.
11109 We use "int" or an "unsigned int" as the underlying type, even if
11110 a smaller integral type would work, unless the user has
11111 explicitly requested that we use the smallest possible type. The
11112 user can request that for all enumerations with a command line
11113 flag, or for just one enumeration with an attribute. */
11115 use_short_enum = flag_short_enums
11116 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype));
11118 for (itk = (use_short_enum ? itk_char : itk_int);
11122 underlying_type = integer_types[itk];
11123 if (TYPE_PRECISION (underlying_type) >= precision
11124 && TYPE_UNSIGNED (underlying_type) == unsignedp)
11127 if (itk == itk_none)
11131 IF no integral type can represent all the enumerator values, the
11132 enumeration is ill-formed. */
11133 error ("no integral type can represent all of the enumerator values "
11134 "for %qT", enumtype);
11135 precision = TYPE_PRECISION (long_long_integer_type_node);
11136 underlying_type = integer_types[itk_unsigned_long_long];
11141 The value of sizeof() applied to an enumeration type, an object
11142 of an enumeration type, or an enumerator, is the value of sizeof()
11143 applied to the underlying type. */
11144 TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
11145 TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
11146 SET_TYPE_MODE (enumtype, TYPE_MODE (underlying_type));
11147 TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
11148 TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
11149 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);
11151 /* Set the underlying type of the enumeration type to the
11152 computed enumeration type, restricted to the enumerator
11154 ENUM_UNDERLYING_TYPE (enumtype) = copy_node (underlying_type);
11155 set_min_and_max_values_for_integral_type
11156 (ENUM_UNDERLYING_TYPE (enumtype), precision, unsignedp);
11159 underlying_type = ENUM_UNDERLYING_TYPE (enumtype);
11161 /* Compute the minimum and maximum values for the type.
11165 For an enumeration where emin is the smallest enumerator and emax
11166 is the largest, the values of the enumeration are the values of the
11167 underlying type in the range bmin to bmax, where bmin and bmax are,
11168 respectively, the smallest and largest values of the smallest bit-
11169 field that can store emin and emax. */
11171 /* The middle-end currently assumes that types with TYPE_PRECISION
11172 narrower than their underlying type are suitably zero or sign
11173 extended to fill their mode. g++ doesn't make these guarantees.
11174 Until the middle-end can represent such paradoxical types, we
11175 set the TYPE_PRECISION to the width of the underlying type. */
11176 TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type);
11178 set_min_and_max_values_for_integral_type (enumtype, precision, unsignedp);
11180 /* Convert each of the enumerators to the type of the underlying
11181 type of the enumeration. */
11182 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
11184 location_t saved_location;
11186 decl = TREE_VALUE (values);
11187 saved_location = input_location;
11188 input_location = DECL_SOURCE_LOCATION (decl);
11189 if (fixed_underlying_type_p)
11190 /* If the enumeration type has a fixed underlying type, we
11191 already checked all of the enumerator values. */
11192 value = DECL_INITIAL (decl);
11194 value = perform_implicit_conversion (underlying_type,
11195 DECL_INITIAL (decl),
11196 tf_warning_or_error);
11197 input_location = saved_location;
11199 /* Do not clobber shared ints. */
11200 value = copy_node (value);
11202 TREE_TYPE (value) = enumtype;
11203 DECL_INITIAL (decl) = value;
11206 /* Fix up all variant types of this enum type. */
11207 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
11209 TYPE_VALUES (t) = TYPE_VALUES (enumtype);
11210 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
11211 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
11212 TYPE_SIZE (t) = TYPE_SIZE (enumtype);
11213 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
11214 SET_TYPE_MODE (t, TYPE_MODE (enumtype));
11215 TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
11216 TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
11217 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
11218 TYPE_UNSIGNED (t) = TYPE_UNSIGNED (enumtype);
11219 ENUM_UNDERLYING_TYPE (t) = ENUM_UNDERLYING_TYPE (enumtype);
11222 /* Finish up the scope of a scoped enumeration. */
11223 if (SCOPED_ENUM_P (enumtype))
11226 /* Finish debugging output for this type. */
11227 rest_of_type_compilation (enumtype, namespace_bindings_p ());
11230 /* Build and install a CONST_DECL for an enumeration constant of the
11231 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
11232 Assignment of sequential values by default is handled here. */
11235 build_enumerator (tree name, tree value, tree enumtype)
11241 /* If the VALUE was erroneous, pretend it wasn't there; that will
11242 result in the enum being assigned the next value in sequence. */
11243 if (value == error_mark_node)
11246 /* Remove no-op casts from the value. */
11248 STRIP_TYPE_NOPS (value);
11250 if (! processing_template_decl)
11252 /* Validate and default VALUE. */
11253 if (value != NULL_TREE)
11255 value = integral_constant_value (value);
11257 if (TREE_CODE (value) == INTEGER_CST)
11259 value = perform_integral_promotions (value);
11260 constant_expression_warning (value);
11264 error ("enumerator value for %qD is not an integer constant", name);
11269 /* Default based on previous value. */
11270 if (value == NULL_TREE)
11272 if (TYPE_VALUES (enumtype))
11275 unsigned HOST_WIDE_INT lo;
11279 /* The next value is the previous value plus one.
11280 add_double doesn't know the type of the target expression,
11281 so we must check with int_fits_type_p as well. */
11282 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
11283 if (error_operand_p (prev_value))
11284 value = error_mark_node;
11287 overflowed = add_double (TREE_INT_CST_LOW (prev_value),
11288 TREE_INT_CST_HIGH (prev_value),
11290 value = build_int_cst_wide (TREE_TYPE (prev_value), lo, hi);
11292 |= !int_fits_type_p (value, TREE_TYPE (prev_value));
11296 error ("overflow in enumeration values at %qD", name);
11297 value = error_mark_node;
11302 value = integer_zero_node;
11305 /* Remove no-op casts from the value. */
11306 STRIP_TYPE_NOPS (value);
11308 /* If the underlying type of the enum is fixed, check whether
11309 the enumerator values fits in the underlying type. If it
11310 does not fit, the program is ill-formed [C++0x dcl.enum]. */
11311 if (ENUM_UNDERLYING_TYPE (enumtype)
11313 && TREE_CODE (value) == INTEGER_CST
11314 && !int_fits_type_p (value, ENUM_UNDERLYING_TYPE (enumtype)))
11316 error ("enumerator value %E is too large for underlying type %<%T%>",
11317 value, ENUM_UNDERLYING_TYPE (enumtype));
11319 /* Silently convert the value so that we can continue. */
11320 value = perform_implicit_conversion (ENUM_UNDERLYING_TYPE (enumtype),
11325 /* C++ associates enums with global, function, or class declarations. */
11326 context = current_scope ();
11328 /* Build the actual enumeration constant. Note that the enumeration
11329 constants have the underlying type of the enum (if it is fixed)
11330 or the type of their initializer (if the underlying type of the
11331 enum is not fixed):
11335 If the underlying type is fixed, the type of each enumerator
11336 prior to the closing brace is the underlying type; if the
11337 initializing value of an enumerator cannot be represented by
11338 the underlying type, the program is ill-formed. If the
11339 underlying type is not fixed, the type of each enumerator is
11340 the type of its initializing value.
11342 If the underlying type is not fixed, it will be computed by
11343 finish_enum and we will reset the type of this enumerator. Of
11344 course, if we're processing a template, there may be no value. */
11345 type = value ? TREE_TYPE (value) : NULL_TREE;
11347 if (context && context == current_class_type)
11348 /* This enum declaration is local to the class. We need the full
11349 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
11350 decl = build_lang_decl (CONST_DECL, name, type);
11352 /* It's a global enum, or it's local to a function. (Note local to
11353 a function could mean local to a class method. */
11354 decl = build_decl (CONST_DECL, name, type);
11356 DECL_CONTEXT (decl) = FROB_CONTEXT (context);
11357 TREE_CONSTANT (decl) = 1;
11358 TREE_READONLY (decl) = 1;
11359 DECL_INITIAL (decl) = value;
11361 if (context && context == current_class_type)
11362 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
11363 on the TYPE_FIELDS list for `S'. (That's so that you can say
11364 things like `S::i' later.) */
11365 finish_member_declaration (decl);
11369 /* Add this enumeration constant to the list for this type. */
11370 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
11373 /* Look for an enumerator with the given NAME within the enumeration
11374 type ENUMTYPE. This routine is used primarily for qualified name
11375 lookup into an enumerator in C++0x, e.g.,
11377 enum class Color { Red, Green, Blue };
11379 Color color = Color::Red;
11381 Returns the value corresponding to the enumerator, or
11382 NULL_TREE if no such enumerator was found. */
11384 lookup_enumerator (tree enumtype, tree name)
11387 gcc_assert (enumtype && TREE_CODE (enumtype) == ENUMERAL_TYPE);
11389 e = purpose_member (name, TYPE_VALUES (enumtype));
11390 return e? TREE_VALUE (e) : NULL_TREE;
11394 /* We're defining DECL. Make sure that it's type is OK. */
11397 check_function_type (tree decl, tree current_function_parms)
11399 tree fntype = TREE_TYPE (decl);
11400 tree return_type = complete_type (TREE_TYPE (fntype));
11402 /* In a function definition, arg types must be complete. */
11403 require_complete_types_for_parms (current_function_parms);
11405 if (dependent_type_p (return_type))
11407 if (!COMPLETE_OR_VOID_TYPE_P (return_type)
11408 || (TYPE_FOR_JAVA (return_type) && MAYBE_CLASS_TYPE_P (return_type)))
11410 tree args = TYPE_ARG_TYPES (fntype);
11412 if (!COMPLETE_OR_VOID_TYPE_P (return_type))
11413 error ("return type %q#T is incomplete", return_type);
11415 error ("return type has Java class type %q#T", return_type);
11417 /* Make it return void instead. */
11418 if (TREE_CODE (fntype) == METHOD_TYPE)
11419 fntype = build_method_type_directly (TREE_TYPE (TREE_VALUE (args)),
11421 TREE_CHAIN (args));
11423 fntype = build_function_type (void_type_node, args);
11425 = build_exception_variant (fntype,
11426 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)));
11429 abstract_virtuals_error (decl, TREE_TYPE (fntype));
11432 /* Create the FUNCTION_DECL for a function definition.
11433 DECLSPECS and DECLARATOR are the parts of the declaration;
11434 they describe the function's name and the type it returns,
11435 but twisted together in a fashion that parallels the syntax of C.
11437 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
11438 DECLARATOR is really the DECL for the function we are about to
11439 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
11440 indicating that the function is an inline defined in-class.
11442 This function creates a binding context for the function body
11443 as well as setting up the FUNCTION_DECL in current_function_decl.
11445 For C++, we must first check whether that datum makes any sense.
11446 For example, "class A local_a(1,2);" means that variable local_a
11447 is an aggregate of type A, which should have a constructor
11448 applied to it with the argument list [1, 2].
11450 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
11451 or may be a BLOCK if the function has been defined previously
11452 in this translation unit. On exit, DECL_INITIAL (decl1) will be
11453 error_mark_node if the function has never been defined, or
11454 a BLOCK if the function has been defined somewhere. */
11457 start_preparsed_function (tree decl1, tree attrs, int flags)
11459 tree ctype = NULL_TREE;
11462 int doing_friend = 0;
11463 struct cp_binding_level *bl;
11464 tree current_function_parms;
11465 struct c_fileinfo *finfo
11466 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1)));
11467 bool honor_interface;
11469 /* Sanity check. */
11470 gcc_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE);
11471 gcc_assert (TREE_CHAIN (void_list_node) == NULL_TREE);
11473 fntype = TREE_TYPE (decl1);
11474 if (TREE_CODE (fntype) == METHOD_TYPE)
11475 ctype = TYPE_METHOD_BASETYPE (fntype);
11477 /* ISO C++ 11.4/5. A friend function defined in a class is in
11478 the (lexical) scope of the class in which it is defined. */
11479 if (!ctype && DECL_FRIEND_P (decl1))
11481 ctype = DECL_FRIEND_CONTEXT (decl1);
11483 /* CTYPE could be null here if we're dealing with a template;
11484 for example, `inline friend float foo()' inside a template
11485 will have no CTYPE set. */
11486 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
11492 if (DECL_DECLARED_INLINE_P (decl1)
11493 && lookup_attribute ("noinline", attrs))
11494 warning (0, "inline function %q+D given attribute noinline", decl1);
11496 /* Handle gnu_inline attribute. */
11497 if (GNU_INLINE_P (decl1))
11499 DECL_EXTERNAL (decl1) = 1;
11500 DECL_NOT_REALLY_EXTERN (decl1) = 0;
11501 DECL_INTERFACE_KNOWN (decl1) = 1;
11502 DECL_DISREGARD_INLINE_LIMITS (decl1) = 1;
11505 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
11506 /* This is a constructor, we must ensure that any default args
11507 introduced by this definition are propagated to the clones
11508 now. The clones are used directly in overload resolution. */
11509 adjust_clone_args (decl1);
11511 /* Sometimes we don't notice that a function is a static member, and
11512 build a METHOD_TYPE for it. Fix that up now. */
11513 if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
11514 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
11516 revert_static_member_fn (decl1);
11520 /* Set up current_class_type, and enter the scope of the class, if
11523 push_nested_class (ctype);
11524 else if (DECL_STATIC_FUNCTION_P (decl1))
11525 push_nested_class (DECL_CONTEXT (decl1));
11527 /* Now that we have entered the scope of the class, we must restore
11528 the bindings for any template parameters surrounding DECL1, if it
11529 is an inline member template. (Order is important; consider the
11530 case where a template parameter has the same name as a field of
11531 the class.) It is not until after this point that
11532 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
11533 if (flags & SF_INCLASS_INLINE)
11534 maybe_begin_member_template_processing (decl1);
11536 /* Effective C++ rule 15. */
11538 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
11539 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
11540 warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");
11542 /* Make the init_value nonzero so pushdecl knows this is not tentative.
11543 error_mark_node is replaced below (in poplevel) with the BLOCK. */
11544 if (!DECL_INITIAL (decl1))
11545 DECL_INITIAL (decl1) = error_mark_node;
11547 /* This function exists in static storage.
11548 (This does not mean `static' in the C sense!) */
11549 TREE_STATIC (decl1) = 1;
11551 /* We must call push_template_decl after current_class_type is set
11552 up. (If we are processing inline definitions after exiting a
11553 class scope, current_class_type will be NULL_TREE until set above
11554 by push_nested_class.) */
11555 if (processing_template_decl)
11557 /* FIXME: Handle error_mark_node more gracefully. */
11558 tree newdecl1 = push_template_decl (decl1);
11559 if (newdecl1 != error_mark_node)
11563 /* We are now in the scope of the function being defined. */
11564 current_function_decl = decl1;
11566 /* Save the parm names or decls from this function's declarator
11567 where store_parm_decls will find them. */
11568 current_function_parms = DECL_ARGUMENTS (decl1);
11570 /* Make sure the parameter and return types are reasonable. When
11571 you declare a function, these types can be incomplete, but they
11572 must be complete when you define the function. */
11573 check_function_type (decl1, current_function_parms);
11575 /* Build the return declaration for the function. */
11576 restype = TREE_TYPE (fntype);
11577 if (DECL_RESULT (decl1) == NULL_TREE)
11581 resdecl = build_decl (RESULT_DECL, 0, restype);
11582 DECL_ARTIFICIAL (resdecl) = 1;
11583 DECL_IGNORED_P (resdecl) = 1;
11584 DECL_RESULT (decl1) = resdecl;
11586 cp_apply_type_quals_to_decl (cp_type_quals (restype), resdecl);
11589 /* Let the user know we're compiling this function. */
11590 announce_function (decl1);
11592 /* Record the decl so that the function name is defined.
11593 If we already have a decl for this name, and it is a FUNCTION_DECL,
11594 use the old decl. */
11595 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
11597 /* A specialization is not used to guide overload resolution. */
11598 if (!DECL_FUNCTION_MEMBER_P (decl1)
11599 && !(DECL_USE_TEMPLATE (decl1) &&
11600 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1))))
11602 tree olddecl = pushdecl (decl1);
11604 if (olddecl == error_mark_node)
11605 /* If something went wrong when registering the declaration,
11606 use DECL1; we have to have a FUNCTION_DECL to use when
11607 parsing the body of the function. */
11611 /* Otherwise, OLDDECL is either a previous declaration
11612 of the same function or DECL1 itself. */
11614 if (warn_missing_declarations
11615 && olddecl == decl1
11616 && !DECL_MAIN_P (decl1)
11617 && TREE_PUBLIC (decl1)
11618 && !DECL_DECLARED_INLINE_P (decl1))
11622 /* Check whether DECL1 is in an anonymous
11624 for (context = DECL_CONTEXT (decl1);
11626 context = DECL_CONTEXT (context))
11628 if (TREE_CODE (context) == NAMESPACE_DECL
11629 && DECL_NAME (context) == NULL_TREE)
11633 if (context == NULL)
11634 warning (OPT_Wmissing_declarations,
11635 "no previous declaration for %q+D", decl1);
11643 /* We need to set the DECL_CONTEXT. */
11644 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
11645 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
11647 fntype = TREE_TYPE (decl1);
11649 /* If #pragma weak applies, mark the decl appropriately now.
11650 The pragma only applies to global functions. Because
11651 determining whether or not the #pragma applies involves
11652 computing the mangled name for the declaration, we cannot
11653 apply the pragma until after we have merged this declaration
11654 with any previous declarations; if the original declaration
11655 has a linkage specification, that specification applies to
11656 the definition as well, and may affect the mangled name. */
11657 if (!DECL_CONTEXT (decl1))
11658 maybe_apply_pragma_weak (decl1);
11661 /* Reset this in case the call to pushdecl changed it. */
11662 current_function_decl = decl1;
11664 gcc_assert (DECL_INITIAL (decl1));
11666 /* This function may already have been parsed, in which case just
11667 return; our caller will skip over the body without parsing. */
11668 if (DECL_INITIAL (decl1) != error_mark_node)
11671 /* Initialize RTL machinery. We cannot do this until
11672 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
11673 even when processing a template; this is how we get
11674 CFUN set up, and our per-function variables initialized.
11675 FIXME factor out the non-RTL stuff. */
11676 bl = current_binding_level;
11677 allocate_struct_function (decl1, processing_template_decl);
11679 /* Initialize the language data structures. Whenever we start
11680 a new function, we destroy temporaries in the usual way. */
11681 cfun->language = GGC_CNEW (struct language_function);
11682 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
11683 current_binding_level = bl;
11685 /* Even though we're inside a function body, we still don't want to
11686 call expand_expr to calculate the size of a variable-sized array.
11687 We haven't necessarily assigned RTL to all variables yet, so it's
11688 not safe to try to expand expressions involving them. */
11689 cfun->dont_save_pending_sizes_p = 1;
11691 /* Start the statement-tree, start the tree now. */
11692 DECL_SAVED_TREE (decl1) = push_stmt_list ();
11694 /* If we are (erroneously) defining a function that we have already
11695 defined before, wipe out what we knew before. */
11696 if (!DECL_PENDING_INLINE_P (decl1))
11697 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
11699 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
11701 /* We know that this was set up by `grokclassfn'. We do not
11702 wait until `store_parm_decls', since evil parse errors may
11703 never get us to that point. Here we keep the consistency
11704 between `current_class_type' and `current_class_ptr'. */
11705 tree t = DECL_ARGUMENTS (decl1);
11707 gcc_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL);
11708 gcc_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE);
11710 cp_function_chain->x_current_class_ref
11711 = cp_build_indirect_ref (t, NULL, tf_warning_or_error);
11712 cp_function_chain->x_current_class_ptr = t;
11714 /* Constructors and destructors need to know whether they're "in
11715 charge" of initializing virtual base classes. */
11716 t = TREE_CHAIN (t);
11717 if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
11719 current_in_charge_parm = t;
11720 t = TREE_CHAIN (t);
11722 if (DECL_HAS_VTT_PARM_P (decl1))
11724 gcc_assert (DECL_NAME (t) == vtt_parm_identifier);
11725 current_vtt_parm = t;
11729 honor_interface = (!DECL_TEMPLATE_INSTANTIATION (decl1)
11730 /* Implicitly-defined methods (like the
11731 destructor for a class in which no destructor
11732 is explicitly declared) must not be defined
11733 until their definition is needed. So, we
11734 ignore interface specifications for
11735 compiler-generated functions. */
11736 && !DECL_ARTIFICIAL (decl1));
11738 if (DECL_INTERFACE_KNOWN (decl1))
11740 tree ctx = decl_function_context (decl1);
11742 if (DECL_NOT_REALLY_EXTERN (decl1))
11743 DECL_EXTERNAL (decl1) = 0;
11745 if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
11746 && TREE_PUBLIC (ctx))
11747 /* This is a function in a local class in an extern inline
11749 comdat_linkage (decl1);
11751 /* If this function belongs to an interface, it is public.
11752 If it belongs to someone else's interface, it is also external.
11753 This only affects inlines and template instantiations. */
11754 else if (!finfo->interface_unknown && honor_interface)
11756 if (DECL_DECLARED_INLINE_P (decl1)
11757 || DECL_TEMPLATE_INSTANTIATION (decl1)
11758 || processing_template_decl)
11760 DECL_EXTERNAL (decl1)
11761 = (finfo->interface_only
11762 || (DECL_DECLARED_INLINE_P (decl1)
11763 && ! flag_implement_inlines
11764 && !DECL_VINDEX (decl1)));
11766 /* For WIN32 we also want to put these in linkonce sections. */
11767 maybe_make_one_only (decl1);
11770 DECL_EXTERNAL (decl1) = 0;
11771 DECL_INTERFACE_KNOWN (decl1) = 1;
11772 /* If this function is in an interface implemented in this file,
11773 make sure that the back end knows to emit this function
11775 if (!DECL_EXTERNAL (decl1))
11776 mark_needed (decl1);
11778 else if (finfo->interface_unknown && finfo->interface_only
11779 && honor_interface)
11781 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
11782 interface, we will have both finfo->interface_unknown and
11783 finfo->interface_only set. In that case, we don't want to
11784 use the normal heuristics because someone will supply a
11785 #pragma implementation elsewhere, and deducing it here would
11786 produce a conflict. */
11787 comdat_linkage (decl1);
11788 DECL_EXTERNAL (decl1) = 0;
11789 DECL_INTERFACE_KNOWN (decl1) = 1;
11790 DECL_DEFER_OUTPUT (decl1) = 1;
11794 /* This is a definition, not a reference.
11795 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
11796 if (!GNU_INLINE_P (decl1))
11797 DECL_EXTERNAL (decl1) = 0;
11799 if ((DECL_DECLARED_INLINE_P (decl1)
11800 || DECL_TEMPLATE_INSTANTIATION (decl1))
11801 && ! DECL_INTERFACE_KNOWN (decl1)
11802 /* Don't try to defer nested functions for now. */
11803 && ! decl_function_context (decl1))
11804 DECL_DEFER_OUTPUT (decl1) = 1;
11806 DECL_INTERFACE_KNOWN (decl1) = 1;
11809 /* Determine the ELF visibility attribute for the function. We must not
11810 do this before calling "pushdecl", as we must allow "duplicate_decls"
11811 to merge any attributes appropriately. We also need to wait until
11813 if (!DECL_CLONED_FUNCTION_P (decl1))
11814 determine_visibility (decl1);
11816 begin_scope (sk_function_parms, decl1);
11820 if (DECL_DESTRUCTOR_P (decl1)
11821 || (DECL_CONSTRUCTOR_P (decl1)
11822 && targetm.cxx.cdtor_returns_this ()))
11824 cdtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
11825 DECL_CONTEXT (cdtor_label) = current_function_decl;
11828 start_fname_decls ();
11830 store_parm_decls (current_function_parms);
11834 /* Like start_preparsed_function, except that instead of a
11835 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
11837 Returns 1 on success. If the DECLARATOR is not suitable for a function
11838 (it defines a datum instead), we return 0, which tells
11839 yyparse to report a parse error. */
11842 start_function (cp_decl_specifier_seq *declspecs,
11843 const cp_declarator *declarator,
11848 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
11849 if (decl1 == error_mark_node)
11851 /* If the declarator is not suitable for a function definition,
11852 cause a syntax error. */
11853 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
11855 error ("invalid function declaration");
11859 if (DECL_MAIN_P (decl1))
11860 /* main must return int. grokfndecl should have corrected it
11861 (and issued a diagnostic) if the user got it wrong. */
11862 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1)),
11863 integer_type_node));
11865 start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT);
11870 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
11874 use_eh_spec_block (tree fn)
11876 return (flag_exceptions && flag_enforce_eh_specs
11877 && !processing_template_decl
11878 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn))
11879 /* We insert the EH_SPEC_BLOCK only in the original
11880 function; then, it is copied automatically to the
11882 && !DECL_CLONED_FUNCTION_P (fn)
11883 /* Implicitly-generated constructors and destructors have
11884 exception specifications. However, those specifications
11885 are the union of the possible exceptions specified by the
11886 constructors/destructors for bases and members, so no
11887 unallowed exception will ever reach this function. By
11888 not creating the EH_SPEC_BLOCK we save a little memory,
11889 and we avoid spurious warnings about unreachable
11891 && !DECL_ARTIFICIAL (fn));
11894 /* Store the parameter declarations into the current function declaration.
11895 This is called after parsing the parameter declarations, before
11896 digesting the body of the function.
11898 Also install to binding contour return value identifier, if any. */
11901 store_parm_decls (tree current_function_parms)
11903 tree fndecl = current_function_decl;
11906 /* This is a chain of any other decls that came in among the parm
11907 declarations. If a parm is declared with enum {foo, bar} x;
11908 then CONST_DECLs for foo and bar are put here. */
11909 tree nonparms = NULL_TREE;
11911 if (current_function_parms)
11913 /* This case is when the function was defined with an ANSI prototype.
11914 The parms already have decls, so we need not do anything here
11915 except record them as in effect
11916 and complain if any redundant old-style parm decls were written. */
11918 tree specparms = current_function_parms;
11921 /* Must clear this because it might contain TYPE_DECLs declared
11923 current_binding_level->names = NULL;
11925 /* If we're doing semantic analysis, then we'll call pushdecl
11926 for each of these. We must do them in reverse order so that
11927 they end in the correct forward order. */
11928 specparms = nreverse (specparms);
11930 for (parm = specparms; parm; parm = next)
11932 next = TREE_CHAIN (parm);
11933 if (TREE_CODE (parm) == PARM_DECL)
11935 if (DECL_NAME (parm) == NULL_TREE
11936 || TREE_CODE (parm) != VOID_TYPE)
11939 error ("parameter %qD declared void", parm);
11943 /* If we find an enum constant or a type tag,
11944 put it aside for the moment. */
11945 TREE_CHAIN (parm) = NULL_TREE;
11946 nonparms = chainon (nonparms, parm);
11950 /* Get the decls in their original chain order and record in the
11951 function. This is all and only the PARM_DECLs that were
11952 pushed into scope by the loop above. */
11953 DECL_ARGUMENTS (fndecl) = getdecls ();
11956 DECL_ARGUMENTS (fndecl) = NULL_TREE;
11958 /* Now store the final chain of decls for the arguments
11959 as the decl-chain of the current lexical scope.
11960 Put the enumerators in as well, at the front so that
11961 DECL_ARGUMENTS is not modified. */
11962 current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));
11964 if (use_eh_spec_block (current_function_decl))
11965 current_eh_spec_block = begin_eh_spec_block ();
11969 /* We have finished doing semantic analysis on DECL, but have not yet
11970 generated RTL for its body. Save away our current state, so that
11971 when we want to generate RTL later we know what to do. */
11974 save_function_data (tree decl)
11976 struct language_function *f;
11978 /* Save the language-specific per-function data so that we can
11979 get it back when we really expand this function. */
11980 gcc_assert (!DECL_PENDING_INLINE_P (decl));
11983 f = GGC_NEW (struct language_function);
11984 memcpy (f, cp_function_chain, sizeof (struct language_function));
11985 DECL_SAVED_FUNCTION_DATA (decl) = f;
11987 /* Clear out the bits we don't need. */
11988 f->base.x_stmt_tree.x_cur_stmt_list = NULL_TREE;
11989 f->bindings = NULL;
11990 f->x_local_names = NULL;
11994 /* Set the return value of the constructor (if present). */
11997 finish_constructor_body (void)
12002 if (targetm.cxx.cdtor_returns_this ()
12003 && (! TYPE_FOR_JAVA (current_class_type)))
12005 /* Any return from a constructor will end up here. */
12006 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
12008 val = DECL_ARGUMENTS (current_function_decl);
12009 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
12010 DECL_RESULT (current_function_decl), val);
12011 /* Return the address of the object. */
12012 exprstmt = build_stmt (RETURN_EXPR, val);
12013 add_stmt (exprstmt);
12017 /* Do all the processing for the beginning of a destructor; set up the
12018 vtable pointers and cleanups for bases and members. */
12021 begin_destructor_body (void)
12023 tree compound_stmt;
12025 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
12026 issued an error message. We still want to try to process the
12027 body of the function, but initialize_vtbl_ptrs will crash if
12028 TYPE_BINFO is NULL. */
12029 if (COMPLETE_TYPE_P (current_class_type))
12031 compound_stmt = begin_compound_stmt (0);
12032 /* Make all virtual function table pointers in non-virtual base
12033 classes point to CURRENT_CLASS_TYPE's virtual function
12035 initialize_vtbl_ptrs (current_class_ptr);
12036 finish_compound_stmt (compound_stmt);
12038 /* And insert cleanups for our bases and members so that they
12039 will be properly destroyed if we throw. */
12040 push_base_cleanups ();
12044 /* At the end of every destructor we generate code to delete the object if
12045 necessary. Do that now. */
12048 finish_destructor_body (void)
12052 /* Any return from a destructor will end up here; that way all base
12053 and member cleanups will be run when the function returns. */
12054 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
12056 /* In a virtual destructor, we must call delete. */
12057 if (DECL_VIRTUAL_P (current_function_decl))
12060 tree virtual_size = cxx_sizeof (current_class_type);
12064 At the point of definition of a virtual destructor (including
12065 an implicit definition), non-placement operator delete shall
12066 be looked up in the scope of the destructor's class and if
12067 found shall be accessible and unambiguous. */
12068 exprstmt = build_op_delete_call(DELETE_EXPR, current_class_ptr,
12070 /*global_p=*/false,
12071 /*placement=*/NULL_TREE,
12072 /*alloc_fn=*/NULL_TREE);
12074 if_stmt = begin_if_stmt ();
12075 finish_if_stmt_cond (build2 (BIT_AND_EXPR, integer_type_node,
12076 current_in_charge_parm,
12079 finish_expr_stmt (exprstmt);
12080 finish_then_clause (if_stmt);
12081 finish_if_stmt (if_stmt);
12084 if (targetm.cxx.cdtor_returns_this ())
12088 val = DECL_ARGUMENTS (current_function_decl);
12089 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
12090 DECL_RESULT (current_function_decl), val);
12091 /* Return the address of the object. */
12092 exprstmt = build_stmt (RETURN_EXPR, val);
12093 add_stmt (exprstmt);
12097 /* Do the necessary processing for the beginning of a function body, which
12098 in this case includes member-initializers, but not the catch clauses of
12099 a function-try-block. Currently, this means opening a binding level
12100 for the member-initializers (in a ctor) and member cleanups (in a dtor). */
12103 begin_function_body (void)
12107 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
12110 if (processing_template_decl)
12111 /* Do nothing now. */;
12113 /* Always keep the BLOCK node associated with the outermost pair of
12114 curly braces of a function. These are needed for correct
12115 operation of dwarfout.c. */
12116 keep_next_level (true);
12118 stmt = begin_compound_stmt (BCS_FN_BODY);
12120 if (processing_template_decl)
12121 /* Do nothing now. */;
12122 else if (DECL_DESTRUCTOR_P (current_function_decl))
12123 begin_destructor_body ();
12128 /* Do the processing for the end of a function body. Currently, this means
12129 closing out the cleanups for fully-constructed bases and members, and in
12130 the case of the destructor, deleting the object if desired. Again, this
12131 is only meaningful for [cd]tors, since they are the only functions where
12132 there is a significant distinction between the main body and any
12133 function catch clauses. Handling, say, main() return semantics here
12134 would be wrong, as flowing off the end of a function catch clause for
12135 main() would also need to return 0. */
12138 finish_function_body (tree compstmt)
12140 if (compstmt == NULL_TREE)
12143 /* Close the block. */
12144 finish_compound_stmt (compstmt);
12146 if (processing_template_decl)
12147 /* Do nothing now. */;
12148 else if (DECL_CONSTRUCTOR_P (current_function_decl))
12149 finish_constructor_body ();
12150 else if (DECL_DESTRUCTOR_P (current_function_decl))
12151 finish_destructor_body ();
12154 /* Given a function, returns the BLOCK corresponding to the outermost level
12155 of curly braces, skipping the artificial block created for constructor
12159 outer_curly_brace_block (tree fndecl)
12161 tree block = BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl));
12162 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
12163 /* Skip the artificial function body block. */
12164 block = BLOCK_SUBBLOCKS (block);
12168 /* Finish up a function declaration and compile that function
12169 all the way to assembler language output. The free the storage
12170 for the function definition.
12172 FLAGS is a bitwise or of the following values:
12174 We just finished processing the body of an in-class inline
12175 function definition. (This processing will have taken place
12176 after the class definition is complete.) */
12179 finish_function (int flags)
12181 tree fndecl = current_function_decl;
12182 tree fntype, ctype = NULL_TREE;
12183 int inclass_inline = (flags & 2) != 0;
12186 /* When we get some parse errors, we can end up without a
12187 current_function_decl, so cope. */
12188 if (fndecl == NULL_TREE)
12189 return error_mark_node;
12191 gcc_assert (!defer_mark_used_calls);
12192 defer_mark_used_calls = true;
12194 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
12195 && DECL_VIRTUAL_P (fndecl)
12196 && !processing_template_decl)
12198 tree fnclass = DECL_CONTEXT (fndecl);
12199 if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
12200 keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
12203 nested = function_depth > 1;
12204 fntype = TREE_TYPE (fndecl);
12206 /* TREE_READONLY (fndecl) = 1;
12207 This caused &foo to be of type ptr-to-const-function
12208 which then got a warning when stored in a ptr-to-function variable. */
12210 gcc_assert (building_stmt_tree ());
12211 /* The current function is being defined, so its DECL_INITIAL should
12212 be set, and unless there's a multiple definition, it should be
12213 error_mark_node. */
12214 gcc_assert (DECL_INITIAL (fndecl) == error_mark_node);
12216 /* For a cloned function, we've already got all the code we need;
12217 there's no need to add any extra bits. */
12218 if (!DECL_CLONED_FUNCTION_P (fndecl))
12220 if (DECL_MAIN_P (current_function_decl))
12224 /* Make it so that `main' always returns 0 by default (or
12227 stmt = finish_return_stmt (integer_one_node);
12229 stmt = finish_return_stmt (integer_zero_node);
12231 /* Hack. We don't want the middle-end to warn that this
12232 return is unreachable, so put the statement on the
12235 location_t linezero = linemap_line_start (line_table, 0, 1);
12236 SET_EXPR_LOCATION (stmt, linezero);
12240 if (use_eh_spec_block (current_function_decl))
12241 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
12242 (TREE_TYPE (current_function_decl)),
12243 current_eh_spec_block);
12246 /* If we're saving up tree structure, tie off the function now. */
12247 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
12249 finish_fname_decls ();
12251 /* If this function can't throw any exceptions, remember that. */
12252 if (!processing_template_decl
12253 && !cp_function_chain->can_throw
12254 && !flag_non_call_exceptions
12255 && !DECL_REPLACEABLE_P (fndecl))
12256 TREE_NOTHROW (fndecl) = 1;
12258 /* This must come after expand_function_end because cleanups might
12259 have declarations (from inline functions) that need to go into
12260 this function's blocks. */
12262 /* If the current binding level isn't the outermost binding level
12263 for this function, either there is a bug, or we have experienced
12264 syntax errors and the statement tree is malformed. */
12265 if (current_binding_level->kind != sk_function_parms)
12267 /* Make sure we have already experienced errors. */
12268 gcc_assert (errorcount);
12270 /* Throw away the broken statement tree and extra binding
12272 DECL_SAVED_TREE (fndecl) = alloc_stmt_list ();
12274 while (current_binding_level->kind != sk_function_parms)
12276 if (current_binding_level->kind == sk_class)
12277 pop_nested_class ();
12279 poplevel (0, 0, 0);
12282 poplevel (1, 0, 1);
12284 /* Statements should always be full-expressions at the outermost set
12285 of curly braces for a function. */
12286 gcc_assert (stmts_are_full_exprs_p ());
12288 /* Set up the named return value optimization, if we can. Candidate
12289 variables are selected in check_return_expr. */
12290 if (current_function_return_value)
12292 tree r = current_function_return_value;
12295 if (r != error_mark_node
12296 /* This is only worth doing for fns that return in memory--and
12297 simpler, since we don't have to worry about promoted modes. */
12298 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
12299 /* Only allow this for variables declared in the outer scope of
12300 the function so we know that their lifetime always ends with a
12301 return; see g++.dg/opt/nrv6.C. We could be more flexible if
12302 we were to do this optimization in tree-ssa. */
12303 && (outer = outer_curly_brace_block (fndecl))
12304 && chain_member (r, BLOCK_VARS (outer)))
12305 finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));
12307 current_function_return_value = NULL_TREE;
12310 /* Remember that we were in class scope. */
12311 if (current_class_name)
12312 ctype = current_class_type;
12314 /* Must mark the RESULT_DECL as being in this function. */
12315 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
12317 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
12318 to the FUNCTION_DECL node itself. */
12319 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
12321 /* Save away current state, if appropriate. */
12322 if (!processing_template_decl)
12323 save_function_data (fndecl);
12325 /* Complain if there's just no return statement. */
12326 if (warn_return_type
12327 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
12328 && !dependent_type_p (TREE_TYPE (fntype))
12329 && !current_function_returns_value && !current_function_returns_null
12330 /* Don't complain if we abort or throw. */
12331 && !current_function_returns_abnormally
12332 && !DECL_NAME (DECL_RESULT (fndecl))
12333 && !TREE_NO_WARNING (fndecl)
12334 /* Structor return values (if any) are set by the compiler. */
12335 && !DECL_CONSTRUCTOR_P (fndecl)
12336 && !DECL_DESTRUCTOR_P (fndecl))
12338 warning (OPT_Wreturn_type,
12339 "no return statement in function returning non-void");
12340 TREE_NO_WARNING (fndecl) = 1;
12343 /* Store the end of the function, so that we get good line number
12344 info for the epilogue. */
12345 cfun->function_end_locus = input_location;
12347 /* Genericize before inlining. */
12348 if (!processing_template_decl)
12350 struct language_function *f = DECL_SAVED_FUNCTION_DATA (fndecl);
12351 invoke_plugin_callbacks (PLUGIN_CXX_CP_PRE_GENERICIZE, fndecl);
12352 cp_genericize (fndecl);
12353 /* Clear out the bits we don't need. */
12354 f->x_current_class_ptr = NULL;
12355 f->x_current_class_ref = NULL;
12356 f->x_eh_spec_block = NULL;
12357 f->x_in_charge_parm = NULL;
12358 f->x_vtt_parm = NULL;
12359 f->x_return_value = NULL;
12360 f->bindings = NULL;
12361 f->extern_decl_map = NULL;
12363 /* Handle attribute((warn_unused_result)). Relies on gimple input. */
12364 c_warn_unused_result (gimple_body (fndecl));
12366 /* Clear out the bits we don't need. */
12367 local_names = NULL;
12369 /* We're leaving the context of this function, so zap cfun. It's still in
12370 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
12372 current_function_decl = NULL;
12374 /* If this is an in-class inline definition, we may have to pop the
12375 bindings for the template parameters that we added in
12376 maybe_begin_member_template_processing when start_function was
12378 if (inclass_inline)
12379 maybe_end_member_template_processing ();
12381 /* Leave the scope of the class. */
12383 pop_nested_class ();
12389 /* Let the error reporting routines know that we're outside a
12390 function. For a nested function, this value is used in
12391 cxx_pop_function_context and then reset via pop_function_context. */
12392 current_function_decl = NULL_TREE;
12394 defer_mark_used_calls = false;
12395 if (deferred_mark_used_calls)
12400 for (i = 0; VEC_iterate (tree, deferred_mark_used_calls, i, decl); i++)
12402 VEC_free (tree, gc, deferred_mark_used_calls);
12408 /* Create the FUNCTION_DECL for a function definition.
12409 DECLSPECS and DECLARATOR are the parts of the declaration;
12410 they describe the return type and the name of the function,
12411 but twisted together in a fashion that parallels the syntax of C.
12413 This function creates a binding context for the function body
12414 as well as setting up the FUNCTION_DECL in current_function_decl.
12416 Returns a FUNCTION_DECL on success.
12418 If the DECLARATOR is not suitable for a function (it defines a datum
12419 instead), we return 0, which tells yyparse to report a parse error.
12421 May return void_type_node indicating that this method is actually
12422 a friend. See grokfield for more details.
12424 Came here with a `.pushlevel' .
12426 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
12427 CHANGES TO CODE IN `grokfield'. */
12430 start_method (cp_decl_specifier_seq *declspecs,
12431 const cp_declarator *declarator, tree attrlist)
12433 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
12436 if (fndecl == error_mark_node)
12437 return error_mark_node;
12439 if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
12441 error ("invalid member function declaration");
12442 return error_mark_node;
12446 cplus_decl_attributes (&fndecl, attrlist, 0);
12448 /* Pass friends other than inline friend functions back. */
12449 if (fndecl == void_type_node)
12452 if (DECL_IN_AGGR_P (fndecl))
12454 if (DECL_CONTEXT (fndecl)
12455 && TREE_CODE (DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
12456 error ("%qD is already defined in class %qT", fndecl,
12457 DECL_CONTEXT (fndecl));
12458 return error_mark_node;
12461 check_template_shadow (fndecl);
12463 DECL_DECLARED_INLINE_P (fndecl) = 1;
12464 DECL_NO_INLINE_WARNING_P (fndecl) = 1;
12466 /* We process method specializations in finish_struct_1. */
12467 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
12469 fndecl = push_template_decl (fndecl);
12470 if (fndecl == error_mark_node)
12474 if (! DECL_FRIEND_P (fndecl))
12476 if (TREE_CHAIN (fndecl))
12478 fndecl = copy_node (fndecl);
12479 TREE_CHAIN (fndecl) = NULL_TREE;
12483 finish_decl (fndecl, NULL_TREE, NULL_TREE);
12485 /* Make a place for the parms. */
12486 begin_scope (sk_function_parms, fndecl);
12488 DECL_IN_AGGR_P (fndecl) = 1;
12492 /* Go through the motions of finishing a function definition.
12493 We don't compile this method until after the whole class has
12496 FINISH_METHOD must return something that looks as though it
12497 came from GROKFIELD (since we are defining a method, after all).
12499 This is called after parsing the body of the function definition.
12500 STMTS is the chain of statements that makes up the function body.
12502 DECL is the ..._DECL that `start_method' provided. */
12505 finish_method (tree decl)
12507 tree fndecl = decl;
12512 if (decl == void_type_node)
12515 old_initial = DECL_INITIAL (fndecl);
12517 /* Undo the level for the parms (from start_method).
12518 This is like poplevel, but it causes nothing to be
12519 saved. Saving information here confuses symbol-table
12520 output routines. Besides, this information will
12521 be correctly output when this method is actually
12524 /* Clear out the meanings of the local variables of this level;
12525 also record in each decl which block it belongs to. */
12527 for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
12529 if (DECL_NAME (link) != NULL_TREE)
12530 pop_binding (DECL_NAME (link), link);
12531 gcc_assert (TREE_CODE (link) != FUNCTION_DECL);
12532 DECL_CONTEXT (link) = NULL_TREE;
12535 poplevel (0, 0, 0);
12537 DECL_INITIAL (fndecl) = old_initial;
12539 /* We used to check if the context of FNDECL was different from
12540 current_class_type as another way to get inside here. This didn't work
12541 for String.cc in libg++. */
12542 if (DECL_FRIEND_P (fndecl))
12544 VEC_safe_push (tree, gc, CLASSTYPE_INLINE_FRIENDS (current_class_type),
12546 decl = void_type_node;
12553 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
12554 we can lay it out later, when and if its type becomes complete. */
12557 maybe_register_incomplete_var (tree var)
12559 gcc_assert (TREE_CODE (var) == VAR_DECL);
12561 /* Keep track of variables with incomplete types. */
12562 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
12563 && DECL_EXTERNAL (var))
12565 tree inner_type = TREE_TYPE (var);
12567 while (TREE_CODE (inner_type) == ARRAY_TYPE)
12568 inner_type = TREE_TYPE (inner_type);
12569 inner_type = TYPE_MAIN_VARIANT (inner_type);
12571 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
12572 /* RTTI TD entries are created while defining the type_info. */
12573 || (TYPE_LANG_SPECIFIC (inner_type)
12574 && TYPE_BEING_DEFINED (inner_type)))
12575 incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
12579 /* Called when a class type (given by TYPE) is defined. If there are
12580 any existing VAR_DECLs whose type has been completed by this
12581 declaration, update them now. */
12584 complete_vars (tree type)
12586 tree *list = &incomplete_vars;
12588 gcc_assert (CLASS_TYPE_P (type));
12591 if (same_type_p (type, TREE_PURPOSE (*list)))
12593 tree var = TREE_VALUE (*list);
12594 tree type = TREE_TYPE (var);
12595 /* Complete the type of the variable. The VAR_DECL itself
12596 will be laid out in expand_expr. */
12597 complete_type (type);
12598 cp_apply_type_quals_to_decl (cp_type_quals (type), var);
12599 /* Remove this entry from the list. */
12600 *list = TREE_CHAIN (*list);
12603 list = &TREE_CHAIN (*list);
12606 /* Check for pending declarations which may have abstract type. */
12607 complete_type_check_abstract (type);
12610 /* If DECL is of a type which needs a cleanup, build and return an
12611 expression to perform that cleanup here. Return NULL_TREE if no
12612 cleanup need be done. */
12615 cxx_maybe_build_cleanup (tree decl)
12621 /* Assume no cleanup is required. */
12622 cleanup = NULL_TREE;
12624 if (error_operand_p (decl))
12627 /* Handle "__attribute__((cleanup))". We run the cleanup function
12628 before the destructor since the destructor is what actually
12629 terminates the lifetime of the object. */
12630 attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
12637 /* Get the name specified by the user for the cleanup function. */
12638 id = TREE_VALUE (TREE_VALUE (attr));
12639 /* Look up the name to find the cleanup function to call. It is
12640 important to use lookup_name here because that is what is
12641 used in c-common.c:handle_cleanup_attribute when performing
12642 initial checks on the attribute. Note that those checks
12643 include ensuring that the function found is not an overloaded
12644 function, or an object with an overloaded call operator,
12645 etc.; we can rely on the fact that the function found is an
12646 ordinary FUNCTION_DECL. */
12647 fn = lookup_name (id);
12648 arg = build_address (decl);
12650 cleanup = cp_build_function_call (fn, build_tree_list (NULL_TREE,
12652 tf_warning_or_error);
12654 /* Handle ordinary C++ destructors. */
12655 type = TREE_TYPE (decl);
12656 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
12658 int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
12659 bool has_vbases = (TREE_CODE (type) == RECORD_TYPE
12660 && CLASSTYPE_VBASECLASSES (type));
12664 if (TREE_CODE (type) == ARRAY_TYPE)
12667 addr = build_address (decl);
12669 /* Optimize for space over speed here. */
12670 if (!has_vbases || flag_expensive_optimizations)
12671 flags |= LOOKUP_NONVIRTUAL;
12673 call = build_delete (TREE_TYPE (addr), addr,
12674 sfk_complete_destructor, flags, 0);
12676 cleanup = build_compound_expr (cleanup, call);
12684 /* When a stmt has been parsed, this function is called. */
12691 /* DECL was originally constructed as a non-static member function,
12692 but turned out to be static. Update it accordingly. */
12695 revert_static_member_fn (tree decl)
12698 tree function = TREE_TYPE (decl);
12699 tree args = TYPE_ARG_TYPES (function);
12701 if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
12702 != TYPE_UNQUALIFIED)
12703 error ("static member function %q#D declared with type qualifiers", decl);
12705 args = TREE_CHAIN (args);
12706 tmp = build_function_type (TREE_TYPE (function), args);
12707 tmp = build_qualified_type (tmp, cp_type_quals (function));
12708 tmp = build_exception_variant (tmp,
12709 TYPE_RAISES_EXCEPTIONS (function));
12710 TREE_TYPE (decl) = tmp;
12711 if (DECL_ARGUMENTS (decl))
12712 DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
12713 DECL_STATIC_FUNCTION_P (decl) = 1;
12716 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
12717 one of the language-independent trees. */
12719 enum cp_tree_node_structure_enum
12720 cp_tree_node_structure (union lang_tree_node * t)
12722 switch (TREE_CODE (&t->generic))
12724 case DEFAULT_ARG: return TS_CP_DEFAULT_ARG;
12725 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER;
12726 case OVERLOAD: return TS_CP_OVERLOAD;
12727 case TEMPLATE_PARM_INDEX: return TS_CP_TPI;
12728 case PTRMEM_CST: return TS_CP_PTRMEM;
12729 case BASELINK: return TS_CP_BASELINK;
12730 case STATIC_ASSERT: return TS_CP_STATIC_ASSERT;
12731 case ARGUMENT_PACK_SELECT: return TS_CP_ARGUMENT_PACK_SELECT;
12732 case TRAIT_EXPR: return TS_CP_TRAIT_EXPR;
12733 default: return TS_CP_GENERIC;
12737 /* Build the void_list_node (void_type_node having been created). */
12739 build_void_list_node (void)
12741 tree t = build_tree_list (NULL_TREE, void_type_node);
12746 cp_missing_noreturn_ok_p (tree decl)
12748 /* A missing noreturn is ok for the `main' function. */
12749 return DECL_MAIN_P (decl);
12752 /* Return the COMDAT group into which DECL should be placed. */
12755 cxx_comdat_group (tree decl)
12759 /* Virtual tables, construction virtual tables, and virtual table
12760 tables all go in a single COMDAT group, named after the primary
12762 if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
12763 name = DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl)));
12764 /* For all other DECLs, the COMDAT group is the mangled name of the
12765 declaration itself. */
12768 while (DECL_THUNK_P (decl))
12770 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
12771 into the same section as the target function. In that case
12772 we must return target's name. */
12773 tree target = THUNK_TARGET (decl);
12774 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target)
12775 && DECL_SECTION_NAME (target) != NULL
12776 && DECL_ONE_ONLY (target))
12781 name = DECL_ASSEMBLER_NAME (decl);
12784 return IDENTIFIER_POINTER (name);
12787 #include "gt-cp-decl.h"