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 origtype ATTRIBUTE_UNUSED,
5874 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, asmspec_tree, 0);
5877 /* Returns a declaration for a VAR_DECL as if:
5879 extern "C" TYPE NAME;
5881 had been seen. Used to create compiler-generated global
5885 declare_global_var (tree name, tree type)
5889 push_to_top_level ();
5890 decl = build_decl (VAR_DECL, name, type);
5891 TREE_PUBLIC (decl) = 1;
5892 DECL_EXTERNAL (decl) = 1;
5893 DECL_ARTIFICIAL (decl) = 1;
5894 /* If the user has explicitly declared this variable (perhaps
5895 because the code we are compiling is part of a low-level runtime
5896 library), then it is possible that our declaration will be merged
5897 with theirs by pushdecl. */
5898 decl = pushdecl (decl);
5899 finish_decl (decl, NULL_TREE, NULL_TREE, NULL_TREE);
5900 pop_from_top_level ();
5905 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
5906 if "__cxa_atexit" is not being used) corresponding to the function
5907 to be called when the program exits. */
5910 get_atexit_fn_ptr_type (void)
5915 if (!atexit_fn_ptr_type_node)
5917 if (flag_use_cxa_atexit
5918 && !targetm.cxx.use_atexit_for_cxa_atexit ())
5919 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
5920 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5922 /* The parameter to "atexit" is "void (*)(void)". */
5923 arg_types = void_list_node;
5925 fn_type = build_function_type (void_type_node, arg_types);
5926 atexit_fn_ptr_type_node = build_pointer_type (fn_type);
5929 return atexit_fn_ptr_type_node;
5932 /* Returns a pointer to the `atexit' function. Note that if
5933 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
5934 `__cxa_atexit' function specified in the IA64 C++ ABI. */
5937 get_atexit_node (void)
5944 bool use_aeabi_atexit;
5949 if (flag_use_cxa_atexit && !targetm.cxx.use_atexit_for_cxa_atexit ())
5951 /* The declaration for `__cxa_atexit' is:
5953 int __cxa_atexit (void (*)(void *), void *, void *)
5955 We build up the argument types and then then function type
5958 use_aeabi_atexit = targetm.cxx.use_aeabi_atexit ();
5959 /* First, build the pointer-to-function type for the first
5961 fn_ptr_type = get_atexit_fn_ptr_type ();
5962 /* Then, build the rest of the argument types. */
5963 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5964 if (use_aeabi_atexit)
5966 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
5967 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
5971 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
5972 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
5974 /* And the final __cxa_atexit type. */
5975 fn_type = build_function_type (integer_type_node, arg_types);
5976 fn_ptr_type = build_pointer_type (fn_type);
5977 if (use_aeabi_atexit)
5978 name = "__aeabi_atexit";
5980 name = "__cxa_atexit";
5984 /* The declaration for `atexit' is:
5986 int atexit (void (*)());
5988 We build up the argument types and then then function type
5990 fn_ptr_type = get_atexit_fn_ptr_type ();
5991 arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
5992 /* Build the final atexit type. */
5993 fn_type = build_function_type (integer_type_node, arg_types);
5997 /* Now, build the function declaration. */
5998 push_lang_context (lang_name_c);
5999 atexit_fndecl = build_library_fn_ptr (name, fn_type);
6000 mark_used (atexit_fndecl);
6001 pop_lang_context ();
6002 atexit_node = decay_conversion (atexit_fndecl);
6007 /* Returns the __dso_handle VAR_DECL. */
6010 get_dso_handle_node (void)
6012 if (dso_handle_node)
6013 return dso_handle_node;
6015 /* Declare the variable. */
6016 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
6019 return dso_handle_node;
6022 /* Begin a new function with internal linkage whose job will be simply
6023 to destroy some particular variable. */
6025 static GTY(()) int start_cleanup_cnt;
6028 start_cleanup_fn (void)
6033 bool use_cxa_atexit = flag_use_cxa_atexit
6034 && !targetm.cxx.use_atexit_for_cxa_atexit ();
6036 push_to_top_level ();
6038 /* No need to mangle this. */
6039 push_lang_context (lang_name_c);
6041 /* Build the name of the function. */
6042 sprintf (name, "__tcf_%d", start_cleanup_cnt++);
6043 /* Build the function declaration. */
6044 fntype = TREE_TYPE (get_atexit_fn_ptr_type ());
6045 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
6046 /* It's a function with internal linkage, generated by the
6048 TREE_PUBLIC (fndecl) = 0;
6049 DECL_ARTIFICIAL (fndecl) = 1;
6050 /* Make the function `inline' so that it is only emitted if it is
6051 actually needed. It is unlikely that it will be inlined, since
6052 it is only called via a function pointer, but we avoid unnecessary
6053 emissions this way. */
6054 DECL_DECLARED_INLINE_P (fndecl) = 1;
6055 DECL_INTERFACE_KNOWN (fndecl) = 1;
6056 /* Build the parameter. */
6061 parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
6062 DECL_CONTEXT (parmdecl) = fndecl;
6063 TREE_USED (parmdecl) = 1;
6064 DECL_ARGUMENTS (fndecl) = parmdecl;
6068 start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED);
6070 pop_lang_context ();
6072 return current_function_decl;
6075 /* Finish the cleanup function begun by start_cleanup_fn. */
6078 end_cleanup_fn (void)
6080 expand_or_defer_fn (finish_function (0));
6082 pop_from_top_level ();
6085 /* Generate code to handle the destruction of DECL, an object with
6086 static storage duration. */
6089 register_dtor_fn (tree decl)
6098 type = TREE_TYPE (decl);
6099 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
6100 return void_zero_node;
6102 /* If we're using "__cxa_atexit" (or "__aeabi_atexit"), and DECL is
6103 a class object, we can just pass the destructor to
6104 "__cxa_atexit"; we don't have to build a temporary function to do
6106 use_dtor = (flag_use_cxa_atexit
6107 && !targetm.cxx.use_atexit_for_cxa_atexit ()
6108 && CLASS_TYPE_P (type));
6113 /* Find the destructor. */
6114 idx = lookup_fnfields_1 (type, complete_dtor_identifier);
6115 gcc_assert (idx >= 0);
6116 cleanup = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), idx);
6117 /* Make sure it is accessible. */
6118 perform_or_defer_access_check (TYPE_BINFO (type), cleanup, cleanup);
6122 /* Call build_cleanup before we enter the anonymous function so
6123 that any access checks will be done relative to the current
6124 scope, rather than the scope of the anonymous function. */
6125 build_cleanup (decl);
6127 /* Now start the function. */
6128 cleanup = start_cleanup_fn ();
6130 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
6131 to the original function, rather than the anonymous one. That
6132 will make the back end think that nested functions are in use,
6133 which causes confusion. */
6134 push_deferring_access_checks (dk_no_check);
6135 fcall = build_cleanup (decl);
6136 pop_deferring_access_checks ();
6138 /* Create the body of the anonymous function. */
6139 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
6140 finish_expr_stmt (fcall);
6141 finish_compound_stmt (compound_stmt);
6145 /* Call atexit with the cleanup function. */
6146 mark_used (cleanup);
6147 cleanup = build_address (cleanup);
6148 if (flag_use_cxa_atexit && !targetm.cxx.use_atexit_for_cxa_atexit ())
6154 /* We must convert CLEANUP to the type that "__cxa_atexit"
6156 cleanup = build_nop (get_atexit_fn_ptr_type (), cleanup);
6157 /* "__cxa_atexit" will pass the address of DECL to the
6158 cleanup function. */
6160 addr = build_address (decl);
6161 /* The declared type of the parameter to "__cxa_atexit" is
6162 "void *". For plain "T*", we could just let the
6163 machinery in cp_build_function_call convert it -- but if the
6164 type is "cv-qualified T *", then we need to convert it
6165 before passing it in, to avoid spurious errors. */
6166 addr = build_nop (ptr_type_node, addr);
6169 /* Since the cleanup functions we build ignore the address
6170 they're given, there's no reason to pass the actual address
6171 in, and, in general, it's cheaper to pass NULL than any
6173 addr = null_pointer_node;
6174 args = tree_cons (NULL_TREE,
6175 cp_build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0,
6176 tf_warning_or_error),
6178 if (targetm.cxx.use_aeabi_atexit ())
6180 args = tree_cons (NULL_TREE, cleanup, args);
6181 args = tree_cons (NULL_TREE, addr, args);
6185 args = tree_cons (NULL_TREE, addr, args);
6186 args = tree_cons (NULL_TREE, cleanup, args);
6190 args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
6191 return cp_build_function_call (get_atexit_node (), args,
6192 tf_warning_or_error);
6195 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
6196 is its initializer. Generate code to handle the construction
6197 and destruction of DECL. */
6200 expand_static_init (tree decl, tree init)
6202 gcc_assert (TREE_CODE (decl) == VAR_DECL);
6203 gcc_assert (TREE_STATIC (decl));
6205 /* Some variables require no initialization. */
6207 && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
6208 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
6211 if (DECL_FUNCTION_SCOPE_P (decl))
6213 /* Emit code to perform this initialization but once. */
6214 tree if_stmt = NULL_TREE, inner_if_stmt = NULL_TREE;
6215 tree then_clause = NULL_TREE, inner_then_clause = NULL_TREE;
6216 tree guard, guard_addr;
6217 tree acquire_fn, release_fn, abort_fn;
6220 /* Emit code to perform this initialization but once. This code
6223 static <type> guard;
6224 if (!guard.first_byte) {
6225 if (__cxa_guard_acquire (&guard)) {
6228 // Do initialization.
6229 flag = true; __cxa_guard_release (&guard);
6230 // Register variable for destruction at end of program.
6232 if (!flag) __cxa_guard_abort (&guard);
6236 Note that the `flag' variable is only set to 1 *after* the
6237 initialization is complete. This ensures that an exception,
6238 thrown during the construction, will cause the variable to
6239 reinitialized when we pass through this code again, as per:
6243 If the initialization exits by throwing an exception, the
6244 initialization is not complete, so it will be tried again
6245 the next time control enters the declaration.
6247 This process should be thread-safe, too; multiple threads
6248 should not be able to initialize the variable more than
6251 /* Create the guard variable. */
6252 guard = get_guard (decl);
6254 /* This optimization isn't safe on targets with relaxed memory
6255 consistency. On such targets we force synchronization in
6256 __cxa_guard_acquire. */
6257 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
6259 /* Begin the conditional initialization. */
6260 if_stmt = begin_if_stmt ();
6261 finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
6262 then_clause = begin_compound_stmt (BCS_NO_SCOPE);
6265 if (flag_threadsafe_statics)
6267 guard_addr = build_address (guard);
6269 acquire_fn = get_identifier ("__cxa_guard_acquire");
6270 release_fn = get_identifier ("__cxa_guard_release");
6271 abort_fn = get_identifier ("__cxa_guard_abort");
6272 if (!get_global_value_if_present (acquire_fn, &acquire_fn))
6274 tree argtypes = tree_cons (NULL_TREE, TREE_TYPE (guard_addr),
6276 tree vfntype = build_function_type (void_type_node, argtypes);
6277 acquire_fn = push_library_fn
6278 (acquire_fn, build_function_type (integer_type_node, argtypes),
6280 release_fn = push_library_fn (release_fn, vfntype, NULL_TREE);
6281 abort_fn = push_library_fn (abort_fn, vfntype, NULL_TREE);
6285 release_fn = identifier_global_value (release_fn);
6286 abort_fn = identifier_global_value (abort_fn);
6289 inner_if_stmt = begin_if_stmt ();
6290 finish_if_stmt_cond (build_call_n (acquire_fn, 1, guard_addr),
6293 inner_then_clause = begin_compound_stmt (BCS_NO_SCOPE);
6294 begin = get_target_expr (boolean_false_node);
6295 flag = TARGET_EXPR_SLOT (begin);
6297 TARGET_EXPR_CLEANUP (begin)
6298 = build3 (COND_EXPR, void_type_node, flag,
6300 build_call_n (abort_fn, 1, guard_addr));
6301 CLEANUP_EH_ONLY (begin) = 1;
6303 /* Do the initialization itself. */
6304 init = add_stmt_to_compound (begin, init);
6305 init = add_stmt_to_compound
6306 (init, build2 (MODIFY_EXPR, void_type_node, flag, boolean_true_node));
6307 init = add_stmt_to_compound
6308 (init, build_call_n (release_fn, 1, guard_addr));
6311 init = add_stmt_to_compound (init, set_guard (guard));
6313 /* Use atexit to register a function for destroying this static
6315 init = add_stmt_to_compound (init, register_dtor_fn (decl));
6317 finish_expr_stmt (init);
6319 if (flag_threadsafe_statics)
6321 finish_compound_stmt (inner_then_clause);
6322 finish_then_clause (inner_if_stmt);
6323 finish_if_stmt (inner_if_stmt);
6326 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
6328 finish_compound_stmt (then_clause);
6329 finish_then_clause (if_stmt);
6330 finish_if_stmt (if_stmt);
6334 static_aggregates = tree_cons (init, decl, static_aggregates);
6338 /* Make TYPE a complete type based on INITIAL_VALUE.
6339 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6340 2 if there was no information (in which case assume 0 if DO_DEFAULT),
6341 3 if the initializer list is empty (in pedantic mode). */
6344 cp_complete_array_type (tree *ptype, tree initial_value, bool do_default)
6347 tree type, elt_type;
6351 unsigned HOST_WIDE_INT i;
6354 /* An array of character type can be initialized from a
6355 brace-enclosed string constant.
6357 FIXME: this code is duplicated from reshape_init. Probably
6358 we should just call reshape_init here? */
6359 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype)))
6360 && TREE_CODE (initial_value) == CONSTRUCTOR
6361 && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (initial_value)))
6363 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
6364 tree value = VEC_index (constructor_elt, v, 0)->value;
6366 if (TREE_CODE (value) == STRING_CST
6367 && VEC_length (constructor_elt, v) == 1)
6368 initial_value = value;
6371 /* If any of the elements are parameter packs, we can't actually
6372 complete this type now because the array size is dependent. */
6373 if (TREE_CODE (initial_value) == CONSTRUCTOR)
6375 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value),
6378 if (PACK_EXPANSION_P (value))
6384 failure = complete_array_type (ptype, initial_value, do_default);
6386 /* We can create the array before the element type is complete, which
6387 means that we didn't have these two bits set in the original type
6388 either. In completing the type, we are expected to propagate these
6389 bits. See also complete_type which does the same thing for arrays
6392 if (TYPE_DOMAIN (type))
6394 elt_type = TREE_TYPE (type);
6395 TYPE_NEEDS_CONSTRUCTING (type) = TYPE_NEEDS_CONSTRUCTING (elt_type);
6396 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
6397 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type);
6403 /* Return zero if something is declared to be a member of type
6404 CTYPE when in the context of CUR_TYPE. STRING is the error
6405 message to print in that case. Otherwise, quietly return 1. */
6408 member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
6410 if (ctype && ctype != cur_type)
6412 if (flags == DTOR_FLAG)
6413 error ("destructor for alien class %qT cannot be a member", ctype);
6415 error ("constructor for alien class %qT cannot be a member", ctype);
6421 /* Subroutine of `grokdeclarator'. */
6423 /* Generate errors possibly applicable for a given set of specifiers.
6424 This is for ARM $7.1.2. */
6427 bad_specifiers (tree object,
6436 error ("%qD declared as a %<virtual%> %s", object, type);
6438 error ("%qD declared as an %<inline%> %s", object, type);
6440 error ("%<const%> and %<volatile%> function specifiers on "
6441 "%qD invalid in %s declaration",
6444 error ("%q+D declared as a friend", object);
6446 && (TREE_CODE (object) == TYPE_DECL
6447 || (!TYPE_PTRFN_P (TREE_TYPE (object))
6448 && !TYPE_REFFN_P (TREE_TYPE (object))
6449 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
6450 error ("%q+D declared with an exception specification", object);
6453 /* DECL is a member function or static data member and is presently
6454 being defined. Check that the definition is taking place in a
6458 check_class_member_definition_namespace (tree decl)
6460 /* These checks only apply to member functions and static data
6462 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
6463 || TREE_CODE (decl) == VAR_DECL);
6464 /* We check for problems with specializations in pt.c in
6465 check_specialization_namespace, where we can issue better
6467 if (processing_specialization)
6469 /* There are no restrictions on the placement of
6470 explicit instantiations. */
6471 if (processing_explicit_instantiation)
6475 A member function definition that appears outside of the
6476 class definition shall appear in a namespace scope enclosing
6477 the class definition.
6481 The definition for a static data member shall appear in a
6482 namespace scope enclosing the member's class definition. */
6483 if (!is_ancestor (current_namespace, DECL_CONTEXT (decl)))
6484 permerror (input_location, "definition of %qD is not in namespace enclosing %qT",
6485 decl, DECL_CONTEXT (decl));
6488 /* Build a PARM_DECL for the "this" parameter. TYPE is the
6489 METHOD_TYPE for a non-static member function; QUALS are the
6490 cv-qualifiers that apply to the function. */
6493 build_this_parm (tree type, cp_cv_quals quals)
6498 cp_cv_quals this_quals;
6500 this_type = TREE_VALUE (TYPE_ARG_TYPES (type));
6501 /* The `this' parameter is implicitly `const'; it cannot be
6503 this_quals = (quals & TYPE_QUAL_RESTRICT) | TYPE_QUAL_CONST;
6504 qual_type = cp_build_qualified_type (this_type, this_quals);
6505 parm = build_artificial_parm (this_identifier, qual_type);
6506 cp_apply_type_quals_to_decl (this_quals, parm);
6510 /* CTYPE is class type, or null if non-class.
6511 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
6513 DECLARATOR is the function's name.
6514 PARMS is a chain of PARM_DECLs for the function.
6515 VIRTUALP is truthvalue of whether the function is virtual or not.
6516 FLAGS are to be passed through to `grokclassfn'.
6517 QUALS are qualifiers indicating whether the function is `const'
6519 RAISES is a list of exceptions that this function can raise.
6520 CHECK is 1 if we must find this method in CTYPE, 0 if we should
6521 not look, and -1 if we should not call `grokclassfn' at all.
6523 SFK is the kind of special function (if any) for the new function.
6525 Returns `NULL_TREE' if something goes wrong, after issuing
6526 applicable error messages. */
6529 grokfndecl (tree ctype,
6533 tree orig_declarator,
6535 enum overload_flags flags,
6542 special_function_kind sfk,
6547 location_t location)
6550 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
6554 type = build_exception_variant (type, raises);
6556 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
6558 /* If we have an explicit location, use it, otherwise use whatever
6559 build_lang_decl used (probably input_location). */
6560 if (location != UNKNOWN_LOCATION)
6561 DECL_SOURCE_LOCATION (decl) = location;
6563 if (TREE_CODE (type) == METHOD_TYPE)
6566 parm = build_this_parm (type, quals);
6567 TREE_CHAIN (parm) = parms;
6570 DECL_ARGUMENTS (decl) = parms;
6571 for (t = parms; t; t = TREE_CHAIN (t))
6572 DECL_CONTEXT (t) = decl;
6573 /* Propagate volatile out from type to decl. */
6574 if (TYPE_VOLATILE (type))
6575 TREE_THIS_VOLATILE (decl) = 1;
6577 /* Setup decl according to sfk. */
6580 case sfk_constructor:
6581 case sfk_copy_constructor:
6582 DECL_CONSTRUCTOR_P (decl) = 1;
6584 case sfk_destructor:
6585 DECL_DESTRUCTOR_P (decl) = 1;
6591 /* If pointers to member functions use the least significant bit to
6592 indicate whether a function is virtual, ensure a pointer
6593 to this function will have that bit clear. */
6594 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
6595 && TREE_CODE (type) == METHOD_TYPE
6596 && DECL_ALIGN (decl) < 2 * BITS_PER_UNIT)
6597 DECL_ALIGN (decl) = 2 * BITS_PER_UNIT;
6600 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
6604 ("defining explicit specialization %qD in friend declaration",
6608 tree fns = TREE_OPERAND (orig_declarator, 0);
6609 tree args = TREE_OPERAND (orig_declarator, 1);
6611 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
6613 /* Something like `template <class T> friend void f<T>()'. */
6614 error ("invalid use of template-id %qD in declaration "
6615 "of primary template",
6621 /* A friend declaration of the form friend void f<>(). Record
6622 the information in the TEMPLATE_ID_EXPR. */
6623 SET_DECL_IMPLICIT_INSTANTIATION (decl);
6625 if (TREE_CODE (fns) == COMPONENT_REF)
6627 /* Due to bison parser ickiness, we will have already looked
6628 up an operator_name or PFUNCNAME within the current class
6629 (see template_id in parse.y). If the current class contains
6630 such a name, we'll get a COMPONENT_REF here. Undo that. */
6632 gcc_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
6633 == current_class_type);
6634 fns = TREE_OPERAND (fns, 1);
6636 gcc_assert (TREE_CODE (fns) == IDENTIFIER_NODE
6637 || TREE_CODE (fns) == OVERLOAD);
6638 DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
6640 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
6641 if (TREE_PURPOSE (t)
6642 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
6644 error ("default arguments are not allowed in declaration "
6645 "of friend template specialization %qD",
6652 error ("%<inline%> is not allowed in declaration of friend "
6653 "template specialization %qD",
6660 /* If this decl has namespace scope, set that up. */
6662 set_decl_namespace (decl, in_namespace, friendp);
6664 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
6666 /* `main' and builtins have implicit 'C' linkage. */
6667 if ((MAIN_NAME_P (declarator)
6668 || (IDENTIFIER_LENGTH (declarator) > 10
6669 && IDENTIFIER_POINTER (declarator)[0] == '_'
6670 && IDENTIFIER_POINTER (declarator)[1] == '_'
6671 && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
6672 && current_lang_name == lang_name_cplusplus
6673 && ctype == NULL_TREE
6674 /* NULL_TREE means global namespace. */
6675 && DECL_CONTEXT (decl) == NULL_TREE)
6676 SET_DECL_LANGUAGE (decl, lang_c);
6678 /* Should probably propagate const out from type to decl I bet (mrs). */
6681 DECL_STATIC_FUNCTION_P (decl) = 1;
6682 DECL_CONTEXT (decl) = ctype;
6687 DECL_CONTEXT (decl) = ctype;
6689 check_class_member_definition_namespace (decl);
6692 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
6694 if (processing_template_decl)
6695 error ("cannot declare %<::main%> to be a template");
6697 error ("cannot declare %<::main%> to be inline");
6699 error ("cannot declare %<::main%> to be static");
6704 /* Members of anonymous types and local classes have no linkage; make
6705 them internal. If a typedef is made later, this will be changed. */
6706 if (ctype && (TYPE_ANONYMOUS_P (ctype)
6707 || decl_function_context (TYPE_MAIN_DECL (ctype))))
6712 /* [basic.link]: A name with no linkage (notably, the name of a class
6713 or enumeration declared in a local scope) shall not be used to
6714 declare an entity with linkage.
6716 Only check this for public decls for now. See core 319, 389. */
6717 t = no_linkage_check (TREE_TYPE (decl),
6718 /*relaxed_p=*/false);
6721 if (TYPE_ANONYMOUS_P (t))
6723 if (DECL_EXTERN_C_P (decl))
6724 /* Allow this; it's pretty common in C. */;
6727 permerror (input_location, "non-local function %q#D uses anonymous type",
6729 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
6730 permerror (input_location, "%q+#D does not refer to the unqualified "
6731 "type, so it is not used for linkage",
6736 permerror (input_location, "non-local function %q#D uses local type %qT", decl, t);
6740 TREE_PUBLIC (decl) = publicp;
6743 DECL_INTERFACE_KNOWN (decl) = 1;
6744 DECL_NOT_REALLY_EXTERN (decl) = 1;
6747 /* If the declaration was declared inline, mark it as such. */
6749 DECL_DECLARED_INLINE_P (decl) = 1;
6751 DECL_EXTERNAL (decl) = 1;
6752 if (quals && TREE_CODE (type) == FUNCTION_TYPE)
6755 ? G_("static member function %qD cannot have cv-qualifier")
6756 : G_("non-member function %qD cannot have cv-qualifier"),
6758 quals = TYPE_UNQUALIFIED;
6761 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl))
6762 && !grok_op_properties (decl, /*complain=*/true))
6765 if (ctype && decl_function_context (decl))
6766 DECL_NO_STATIC_CHAIN (decl) = 1;
6769 /* Make the init_value nonzero so pushdecl knows this is not
6770 tentative. error_mark_node is replaced later with the BLOCK. */
6771 DECL_INITIAL (decl) = error_mark_node;
6773 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
6774 TREE_NOTHROW (decl) = 1;
6776 /* Caller will do the rest of this. */
6780 if (ctype != NULL_TREE)
6781 grokclassfn (ctype, decl, flags);
6783 decl = check_explicit_specialization (orig_declarator, decl,
6786 4 * (friendp != 0));
6787 if (decl == error_mark_node)
6792 cplus_decl_attributes (&decl, *attrlist, 0);
6793 *attrlist = NULL_TREE;
6796 /* Check main's type after attributes have been applied. */
6797 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
6799 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
6802 tree oldtypeargs = TYPE_ARG_TYPES (TREE_TYPE (decl));
6804 error ("%<::main%> must return %<int%>");
6805 newtype = build_function_type (integer_type_node, oldtypeargs);
6806 TREE_TYPE (decl) = newtype;
6809 check_main_parameter_types (decl);
6812 if (ctype != NULL_TREE
6813 && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
6816 tree old_decl = check_classfn (ctype, decl,
6817 (processing_template_decl
6818 > template_class_depth (ctype))
6819 ? current_template_parms
6822 if (old_decl == error_mark_node)
6830 if (TREE_CODE (old_decl) == TEMPLATE_DECL)
6831 /* Because grokfndecl is always supposed to return a
6832 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
6833 here. We depend on our callers to figure out that its
6834 really a template that's being returned. */
6835 old_decl = DECL_TEMPLATE_RESULT (old_decl);
6837 if (DECL_STATIC_FUNCTION_P (old_decl)
6838 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
6839 /* Remove the `this' parm added by grokclassfn.
6840 XXX Isn't this done in start_function, too? */
6841 revert_static_member_fn (decl);
6842 if (DECL_ARTIFICIAL (old_decl))
6844 error ("definition of implicitly-declared %qD", old_decl);
6848 /* Since we've smashed OLD_DECL to its
6849 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
6850 if (TREE_CODE (decl) == TEMPLATE_DECL)
6851 decl = DECL_TEMPLATE_RESULT (decl);
6853 /* Attempt to merge the declarations. This can fail, in
6854 the case of some invalid specialization declarations. */
6855 pushed_scope = push_scope (ctype);
6856 ok = duplicate_decls (decl, old_decl, friendp);
6858 pop_scope (pushed_scope);
6861 error ("no %q#D member function declared in class %qT",
6869 if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
6872 if (ctype == NULL_TREE || check)
6876 DECL_VIRTUAL_P (decl) = 1;
6881 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
6882 the linkage that DECL will receive in the object file. */
6885 set_linkage_for_static_data_member (tree decl)
6887 /* A static data member always has static storage duration and
6888 external linkage. Note that static data members are forbidden in
6889 local classes -- the only situation in which a class has
6890 non-external linkage. */
6891 TREE_PUBLIC (decl) = 1;
6892 TREE_STATIC (decl) = 1;
6893 /* For non-template classes, static data members are always put
6894 out in exactly those files where they are defined, just as
6895 with ordinary namespace-scope variables. */
6896 if (!processing_template_decl)
6897 DECL_INTERFACE_KNOWN (decl) = 1;
6900 /* Create a VAR_DECL named NAME with the indicated TYPE.
6902 If SCOPE is non-NULL, it is the class type or namespace containing
6903 the variable. If SCOPE is NULL, the variable should is created in
6904 the innermost enclosings scope. */
6907 grokvardecl (tree type,
6909 const cp_decl_specifier_seq *declspecs,
6915 tree explicit_scope;
6917 gcc_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE);
6919 /* Compute the scope in which to place the variable, but remember
6920 whether or not that scope was explicitly specified by the user. */
6921 explicit_scope = scope;
6924 /* An explicit "extern" specifier indicates a namespace-scope
6926 if (declspecs->storage_class == sc_extern)
6927 scope = current_namespace;
6928 else if (!at_function_scope_p ())
6929 scope = current_scope ();
6933 && (/* If the variable is a namespace-scope variable declared in a
6934 template, we need DECL_LANG_SPECIFIC. */
6935 (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
6936 /* Similarly for namespace-scope variables with language linkage
6938 || (TREE_CODE (scope) == NAMESPACE_DECL
6939 && current_lang_name != lang_name_cplusplus)
6940 /* Similarly for static data members. */
6942 decl = build_lang_decl (VAR_DECL, name, type);
6944 decl = build_decl (VAR_DECL, name, type);
6946 if (explicit_scope && TREE_CODE (explicit_scope) == NAMESPACE_DECL)
6947 set_decl_namespace (decl, explicit_scope, 0);
6949 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
6951 if (declspecs->storage_class == sc_extern)
6953 DECL_THIS_EXTERN (decl) = 1;
6954 DECL_EXTERNAL (decl) = !initialized;
6957 if (DECL_CLASS_SCOPE_P (decl))
6959 set_linkage_for_static_data_member (decl);
6960 /* This function is only called with out-of-class definitions. */
6961 DECL_EXTERNAL (decl) = 0;
6962 check_class_member_definition_namespace (decl);
6964 /* At top level, either `static' or no s.c. makes a definition
6965 (perhaps tentative), and absence of `static' makes it public. */
6966 else if (toplevel_bindings_p ())
6968 TREE_PUBLIC (decl) = (declspecs->storage_class != sc_static
6969 && (DECL_THIS_EXTERN (decl) || ! constp));
6970 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
6972 /* Not at top level, only `static' makes a static definition. */
6975 TREE_STATIC (decl) = declspecs->storage_class == sc_static;
6976 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
6979 if (declspecs->specs[(int)ds_thread])
6980 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
6982 if (TREE_PUBLIC (decl))
6984 /* [basic.link]: A name with no linkage (notably, the name of a class
6985 or enumeration declared in a local scope) shall not be used to
6986 declare an entity with linkage.
6988 Only check this for public decls for now. */
6989 tree t = no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false);
6992 if (TYPE_ANONYMOUS_P (t))
6994 if (DECL_EXTERN_C_P (decl))
6995 /* Allow this; it's pretty common in C. */
6999 /* DRs 132, 319 and 389 seem to indicate types with
7000 no linkage can only be used to declare extern "C"
7001 entities. Since it's not always an error in the
7002 ISO C++ 90 Standard, we only issue a warning. */
7003 warning (0, "non-local variable %q#D uses anonymous type",
7005 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
7006 warning (0, "%q+#D does not refer to the unqualified "
7007 "type, so it is not used for linkage",
7012 warning (0, "non-local variable %q#D uses local type %qT", decl, t);
7016 DECL_INTERFACE_KNOWN (decl) = 1;
7021 /* Create and return a canonical pointer to member function type, for
7022 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
7025 build_ptrmemfunc_type (tree type)
7029 tree unqualified_variant = NULL_TREE;
7031 if (type == error_mark_node)
7034 /* If a canonical type already exists for this type, use it. We use
7035 this method instead of type_hash_canon, because it only does a
7036 simple equality check on the list of field members. */
7038 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
7041 /* Make sure that we always have the unqualified pointer-to-member
7043 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
7045 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
7047 t = make_class_type (RECORD_TYPE);
7048 xref_basetypes (t, NULL_TREE);
7050 /* Let the front end know this is a pointer to member function... */
7051 TYPE_PTRMEMFUNC_FLAG (t) = 1;
7052 /* ... and not really a class type. */
7053 SET_CLASS_TYPE_P (t, 0);
7055 field = build_decl (FIELD_DECL, pfn_identifier, type);
7058 field = build_decl (FIELD_DECL, delta_identifier, delta_type_node);
7059 TREE_CHAIN (field) = fields;
7062 finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
7064 /* Zap out the name so that the back end will give us the debugging
7065 information for this anonymous RECORD_TYPE. */
7066 TYPE_NAME (t) = NULL_TREE;
7068 /* If this is not the unqualified form of this pointer-to-member
7069 type, set the TYPE_MAIN_VARIANT for this type to be the
7070 unqualified type. Since they are actually RECORD_TYPEs that are
7071 not variants of each other, we must do this manually. */
7072 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
7074 t = build_qualified_type (t, cp_type_quals (type));
7075 TYPE_MAIN_VARIANT (t) = unqualified_variant;
7076 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
7077 TYPE_NEXT_VARIANT (unqualified_variant) = t;
7078 TREE_TYPE (TYPE_BINFO (t)) = t;
7081 /* Cache this pointer-to-member type so that we can find it again
7083 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
7085 if (TYPE_STRUCTURAL_EQUALITY_P (type))
7086 SET_TYPE_STRUCTURAL_EQUALITY (t);
7087 else if (TYPE_CANONICAL (type) != type)
7088 TYPE_CANONICAL (t) = build_ptrmemfunc_type (TYPE_CANONICAL (type));
7093 /* Create and return a pointer to data member type. */
7096 build_ptrmem_type (tree class_type, tree member_type)
7098 if (TREE_CODE (member_type) == METHOD_TYPE)
7102 arg_types = TYPE_ARG_TYPES (member_type);
7103 class_type = (cp_build_qualified_type
7105 cp_type_quals (TREE_TYPE (TREE_VALUE (arg_types)))));
7107 = build_method_type_directly (class_type,
7108 TREE_TYPE (member_type),
7109 TREE_CHAIN (arg_types));
7110 return build_ptrmemfunc_type (build_pointer_type (member_type));
7114 gcc_assert (TREE_CODE (member_type) != FUNCTION_TYPE);
7115 return build_offset_type (class_type, member_type);
7119 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
7120 Check to see that the definition is valid. Issue appropriate error
7121 messages. Return 1 if the definition is particularly bad, or 0
7125 check_static_variable_definition (tree decl, tree type)
7127 /* Motion 10 at San Diego: If a static const integral data member is
7128 initialized with an integral constant expression, the initializer
7129 may appear either in the declaration (within the class), or in
7130 the definition, but not both. If it appears in the class, the
7131 member is a member constant. The file-scope definition is always
7133 if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
7135 error ("invalid in-class initialization of static data member "
7136 "of non-integral type %qT",
7138 /* If we just return the declaration, crashes will sometimes
7139 occur. We therefore return void_type_node, as if this were a
7140 friend declaration, to cause callers to completely ignore
7141 this declaration. */
7144 else if (!CP_TYPE_CONST_P (type))
7145 error ("ISO C++ forbids in-class initialization of non-const "
7146 "static member %qD",
7148 else if (!INTEGRAL_TYPE_P (type))
7149 pedwarn (input_location, OPT_pedantic, "ISO C++ forbids initialization of member constant "
7150 "%qD of non-integral type %qT", decl, type);
7155 /* Given the SIZE (i.e., number of elements) in an array, compute an
7156 appropriate index type for the array. If non-NULL, NAME is the
7157 name of the thing being declared. */
7160 compute_array_index_type (tree name, tree size)
7164 tree abi_1_itype = NULL_TREE;
7166 if (error_operand_p (size))
7167 return error_mark_node;
7169 type = TREE_TYPE (size);
7170 /* The array bound must be an integer type. */
7171 if (!dependent_type_p (type) && !INTEGRAL_TYPE_P (type))
7174 error ("size of array %qD has non-integral type %qT", name, type);
7176 error ("size of array has non-integral type %qT", type);
7177 size = integer_one_node;
7178 type = TREE_TYPE (size);
7181 /* We can only call value_dependent_expression_p on integral constant
7182 expressions; the parser adds a dummy NOP_EXPR with TREE_SIDE_EFFECTS
7183 set if this isn't one. */
7184 if (processing_template_decl
7185 && (TREE_SIDE_EFFECTS (size) || value_dependent_expression_p (size)))
7187 /* We cannot do any checking for a SIZE that isn't known to be
7188 constant. Just build the index type and mark that it requires
7189 structural equality checks. */
7190 itype = build_index_type (build_min (MINUS_EXPR, sizetype,
7191 size, integer_one_node));
7192 if (!TREE_SIDE_EFFECTS (size))
7194 TYPE_DEPENDENT_P (itype) = 1;
7195 TYPE_DEPENDENT_P_VALID (itype) = 1;
7197 SET_TYPE_STRUCTURAL_EQUALITY (itype);
7201 if (!abi_version_at_least (2) && processing_template_decl)
7202 /* For abi-1, we handled all instances in templates the same way,
7203 even when they were non-dependent. This affects the manglings
7204 produced. So, we do the normal checking for non-dependent
7205 sizes, but at the end we'll return the same type that abi-1
7206 would have, but with TYPE_CANONICAL set to the "right"
7207 value that the current ABI would provide. */
7208 abi_1_itype = build_index_type (build_min (MINUS_EXPR, sizetype,
7209 size, integer_one_node));
7211 /* The size might be the result of a cast. */
7212 STRIP_TYPE_NOPS (size);
7214 /* It might be a const variable or enumeration constant. */
7215 size = integral_constant_value (size);
7217 /* Normally, the array-bound will be a constant. */
7218 if (TREE_CODE (size) == INTEGER_CST)
7220 /* Check to see if the array bound overflowed. Make that an
7221 error, no matter how generous we're being. */
7222 constant_expression_error (size);
7224 /* An array must have a positive number of elements. */
7225 if (INT_CST_LT (size, integer_zero_node))
7228 error ("size of array %qD is negative", name);
7230 error ("size of array is negative");
7231 size = integer_one_node;
7233 /* As an extension we allow zero-sized arrays. We always allow
7234 them in system headers because glibc uses them. */
7235 else if (integer_zerop (size) && !in_system_header)
7238 pedwarn (input_location, OPT_pedantic, "ISO C++ forbids zero-size array %qD", name);
7240 pedwarn (input_location, OPT_pedantic, "ISO C++ forbids zero-size array");
7243 else if (TREE_CONSTANT (size))
7245 /* `(int) &fn' is not a valid array bound. */
7247 error ("size of array %qD is not an integral constant-expression",
7250 error ("size of array is not an integral constant-expression");
7251 size = integer_one_node;
7253 else if (pedantic && warn_vla != 0)
7256 pedwarn (input_location, OPT_Wvla, "ISO C++ forbids variable length array %qD", name);
7258 pedwarn (input_location, OPT_Wvla, "ISO C++ forbids variable length array");
7260 else if (warn_vla > 0)
7264 "variable length array %qD is used", name);
7267 "variable length array is used");
7270 if (processing_template_decl && !TREE_CONSTANT (size))
7271 /* A variable sized array. */
7272 itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node);
7275 HOST_WIDE_INT saved_processing_template_decl;
7277 /* Compute the index of the largest element in the array. It is
7278 one less than the number of elements in the array. We save
7279 and restore PROCESSING_TEMPLATE_DECL so that computations in
7280 cp_build_binary_op will be appropriately folded. */
7281 saved_processing_template_decl = processing_template_decl;
7282 processing_template_decl = 0;
7283 itype = cp_build_binary_op (input_location,
7285 cp_convert (ssizetype, size),
7286 cp_convert (ssizetype, integer_one_node),
7287 tf_warning_or_error);
7288 itype = fold (itype);
7289 processing_template_decl = saved_processing_template_decl;
7291 if (!TREE_CONSTANT (itype))
7292 /* A variable sized array. */
7293 itype = variable_size (itype);
7294 /* Make sure that there was no overflow when creating to a signed
7295 index type. (For example, on a 32-bit machine, an array with
7296 size 2^32 - 1 is too big.) */
7297 else if (TREE_CODE (itype) == INTEGER_CST
7298 && TREE_OVERFLOW (itype))
7300 error ("overflow in array dimension");
7301 TREE_OVERFLOW (itype) = 0;
7305 /* Create and return the appropriate index type. */
7308 tree t = build_index_type (itype);
7309 TYPE_CANONICAL (abi_1_itype) = TYPE_CANONICAL (t);
7313 return build_index_type (itype);
7316 /* Returns the scope (if any) in which the entity declared by
7317 DECLARATOR will be located. If the entity was declared with an
7318 unqualified name, NULL_TREE is returned. */
7321 get_scope_of_declarator (const cp_declarator *declarator)
7323 while (declarator && declarator->kind != cdk_id)
7324 declarator = declarator->declarator;
7326 /* If the declarator-id is a SCOPE_REF, the scope in which the
7327 declaration occurs is the first operand. */
7329 && declarator->u.id.qualifying_scope)
7330 return declarator->u.id.qualifying_scope;
7332 /* Otherwise, the declarator is not a qualified name; the entity will
7333 be declared in the current scope. */
7337 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
7338 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
7342 create_array_type_for_decl (tree name, tree type, tree size)
7344 tree itype = NULL_TREE;
7345 const char* error_msg;
7347 /* If things have already gone awry, bail now. */
7348 if (type == error_mark_node || size == error_mark_node)
7349 return error_mark_node;
7351 /* Assume that everything will go OK. */
7354 /* There are some types which cannot be array elements. */
7355 switch (TREE_CODE (type))
7358 error_msg = "array of void";
7362 error_msg = "array of functions";
7365 case REFERENCE_TYPE:
7366 error_msg = "array of references";
7370 error_msg = "array of function members";
7377 /* If something went wrong, issue an error-message and return. */
7381 error ("declaration of %qD as %s", name, error_msg);
7383 error ("creating %s", error_msg);
7385 return error_mark_node;
7390 The constant expressions that specify the bounds of the arrays
7391 can be omitted only for the first member of the sequence. */
7392 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
7395 error ("declaration of %qD as multidimensional array must "
7396 "have bounds for all dimensions except the first",
7399 error ("multidimensional array must have bounds for all "
7400 "dimensions except the first");
7402 return error_mark_node;
7405 /* Figure out the index type for the array. */
7407 itype = compute_array_index_type (name, size);
7410 T is called the array element type; this type shall not be [...] an
7411 abstract class type. */
7412 abstract_virtuals_error (name, type);
7414 return build_cplus_array_type (type, itype);
7417 /* Check that it's OK to declare a function with the indicated TYPE.
7418 SFK indicates the kind of special function (if any) that this
7419 function is. OPTYPE is the type given in a conversion operator
7420 declaration, or the class type for a constructor/destructor.
7421 Returns the actual return type of the function; that
7422 may be different than TYPE if an error occurs, or for certain
7423 special functions. */
7426 check_special_function_return_type (special_function_kind sfk,
7432 case sfk_constructor:
7434 error ("return type specification for constructor invalid");
7436 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
7437 type = build_pointer_type (optype);
7439 type = void_type_node;
7442 case sfk_destructor:
7444 error ("return type specification for destructor invalid");
7445 /* We can't use the proper return type here because we run into
7446 problems with ambiguous bases and covariant returns.
7447 Java classes are left unchanged because (void *) isn't a valid
7448 Java type, and we don't want to change the Java ABI. */
7449 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
7450 type = build_pointer_type (void_type_node);
7452 type = void_type_node;
7455 case sfk_conversion:
7457 error ("return type specified for %<operator %T%>", optype);
7468 /* A variable or data member (whose unqualified name is IDENTIFIER)
7469 has been declared with the indicated TYPE. If the TYPE is not
7470 acceptable, issue an error message and return a type to use for
7471 error-recovery purposes. */
7474 check_var_type (tree identifier, tree type)
7476 if (VOID_TYPE_P (type))
7479 error ("unnamed variable or field declared void");
7480 else if (TREE_CODE (identifier) == IDENTIFIER_NODE)
7482 gcc_assert (!IDENTIFIER_OPNAME_P (identifier));
7483 error ("variable or field %qE declared void", identifier);
7486 error ("variable or field declared void");
7487 type = error_mark_node;
7493 /* Given declspecs and a declarator (abstract or otherwise), determine
7494 the name and type of the object declared and construct a DECL node
7497 DECLSPECS points to the representation of declaration-specifier
7498 sequence that precedes declarator.
7500 DECL_CONTEXT says which syntactic context this declaration is in:
7501 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
7502 FUNCDEF for a function definition. Like NORMAL but a few different
7503 error messages in each case. Return value may be zero meaning
7504 this definition is too screwy to try to parse.
7505 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
7506 handle member functions (which have FIELD context).
7507 Return value may be zero meaning this definition is too screwy to
7509 PARM for a parameter declaration (either within a function prototype
7510 or before a function body). Make a PARM_DECL, or return void_type_node.
7511 CATCHPARM for a parameter declaration before a catch clause.
7512 TYPENAME if for a typename (in a cast or sizeof).
7513 Don't make a DECL node; just return the ..._TYPE node.
7514 FIELD for a struct or union field; make a FIELD_DECL.
7515 BITFIELD for a field with specified width.
7516 INITIALIZED is as for start_decl.
7518 ATTRLIST is a pointer to the list of attributes, which may be NULL
7519 if there are none; *ATTRLIST may be modified if attributes from inside
7520 the declarator should be applied to the declaration.
7522 When this function is called, scoping variables (such as
7523 CURRENT_CLASS_TYPE) should reflect the scope in which the
7524 declaration occurs, not the scope in which the new declaration will
7525 be placed. For example, on:
7529 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
7532 Returns a DECL (if a declarator is present), a TYPE (if there is no
7533 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
7537 grokdeclarator (const cp_declarator *declarator,
7538 const cp_decl_specifier_seq *declspecs,
7539 enum decl_context decl_context,
7543 tree type = NULL_TREE;
7545 int virtualp, explicitp, friendp, inlinep, staticp;
7546 int explicit_int = 0;
7547 int explicit_char = 0;
7548 int defaulted_int = 0;
7549 tree dependent_name = NULL_TREE;
7551 tree typedef_decl = NULL_TREE;
7552 const char *name = NULL;
7553 tree typedef_type = NULL_TREE;
7554 /* True if this declarator is a function definition. */
7555 bool funcdef_flag = false;
7556 cp_declarator_kind innermost_code = cdk_error;
7559 /* See the code below that used this. */
7560 tree decl_attr = NULL_TREE;
7563 /* Keep track of what sort of function is being processed
7564 so that we can warn about default return values, or explicit
7565 return values which do not match prescribed defaults. */
7566 special_function_kind sfk = sfk_none;
7568 tree dname = NULL_TREE;
7569 tree ctor_return_type = NULL_TREE;
7570 enum overload_flags flags = NO_SPECIAL;
7571 /* cv-qualifiers that apply to the declarator, for a declaration of
7572 a member function. */
7573 cp_cv_quals memfn_quals = TYPE_UNQUALIFIED;
7574 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
7576 tree raises = NULL_TREE;
7577 int template_count = 0;
7578 tree returned_attrs = NULL_TREE;
7579 tree parms = NULL_TREE;
7580 const cp_declarator *id_declarator;
7581 /* The unqualified name of the declarator; either an
7582 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
7583 tree unqualified_id;
7584 /* The class type, if any, in which this entity is located,
7585 or NULL_TREE if none. Note that this value may be different from
7586 the current class type; for example if an attempt is made to declare
7587 "A::f" inside "B", this value will be "A". */
7588 tree ctype = current_class_type;
7589 /* The NAMESPACE_DECL for the namespace in which this entity is
7590 located. If an unqualified name is used to declare the entity,
7591 this value will be NULL_TREE, even if the entity is located at
7593 tree in_namespace = NULL_TREE;
7594 cp_storage_class storage_class;
7595 bool unsigned_p, signed_p, short_p, long_p, thread_p;
7596 bool type_was_error_mark_node = false;
7597 bool parameter_pack_p = declarator? declarator->parameter_pack_p : false;
7598 bool set_no_warning = false;
7599 bool template_type_arg = false;
7601 signed_p = declspecs->specs[(int)ds_signed];
7602 unsigned_p = declspecs->specs[(int)ds_unsigned];
7603 short_p = declspecs->specs[(int)ds_short];
7604 long_p = declspecs->specs[(int)ds_long];
7605 longlong = declspecs->specs[(int)ds_long] >= 2;
7606 thread_p = declspecs->specs[(int)ds_thread];
7608 if (decl_context == FUNCDEF)
7609 funcdef_flag = true, decl_context = NORMAL;
7610 else if (decl_context == MEMFUNCDEF)
7611 funcdef_flag = true, decl_context = FIELD;
7612 else if (decl_context == BITFIELD)
7613 bitfield = 1, decl_context = FIELD;
7614 else if (decl_context == TEMPLATE_TYPE_ARG)
7615 template_type_arg = true, decl_context = TYPENAME;
7617 if (initialized > 1)
7618 funcdef_flag = true;
7620 /* Look inside a declarator for the name being declared
7621 and get it as a string, for an error message. */
7622 for (id_declarator = declarator;
7624 id_declarator = id_declarator->declarator)
7626 if (id_declarator->kind != cdk_id)
7627 innermost_code = id_declarator->kind;
7629 switch (id_declarator->kind)
7632 if (id_declarator->declarator
7633 && id_declarator->declarator->kind == cdk_id)
7635 sfk = id_declarator->declarator->u.id.sfk;
7636 if (sfk == sfk_destructor)
7643 tree qualifying_scope = id_declarator->u.id.qualifying_scope;
7644 tree decl = id_declarator->u.id.unqualified_name;
7647 if (qualifying_scope)
7649 if (at_function_scope_p ())
7653 A declarator-id shall not be qualified except
7656 None of the cases are permitted in block
7658 if (qualifying_scope == global_namespace)
7659 error ("invalid use of qualified-name %<::%D%>",
7661 else if (TYPE_P (qualifying_scope))
7662 error ("invalid use of qualified-name %<%T::%D%>",
7663 qualifying_scope, decl);
7665 error ("invalid use of qualified-name %<%D::%D%>",
7666 qualifying_scope, decl);
7667 return error_mark_node;
7669 else if (TYPE_P (qualifying_scope))
7671 ctype = qualifying_scope;
7672 if (innermost_code != cdk_function
7673 && current_class_type
7674 && !UNIQUELY_DERIVED_FROM_P (ctype,
7675 current_class_type))
7677 error ("type %qT is not derived from type %qT",
7678 ctype, current_class_type);
7679 return error_mark_node;
7682 else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL)
7683 in_namespace = qualifying_scope;
7685 switch (TREE_CODE (decl))
7691 if (innermost_code != cdk_function)
7693 error ("declaration of %qD as non-function", decl);
7694 return error_mark_node;
7696 else if (!qualifying_scope
7697 && !(current_class_type && at_class_scope_p ()))
7699 error ("declaration of %qD as non-member", decl);
7700 return error_mark_node;
7703 type = TREE_OPERAND (decl, 0);
7705 type = constructor_name (type);
7706 name = IDENTIFIER_POINTER (type);
7711 case TEMPLATE_ID_EXPR:
7713 tree fns = TREE_OPERAND (decl, 0);
7716 if (TREE_CODE (dname) != IDENTIFIER_NODE)
7718 gcc_assert (is_overloaded_fn (dname));
7719 dname = DECL_NAME (get_first_fn (dname));
7724 case IDENTIFIER_NODE:
7725 if (TREE_CODE (decl) == IDENTIFIER_NODE)
7728 if (C_IS_RESERVED_WORD (dname))
7730 error ("declarator-id missing; using reserved word %qD",
7732 name = IDENTIFIER_POINTER (dname);
7734 else if (!IDENTIFIER_TYPENAME_P (dname))
7735 name = IDENTIFIER_POINTER (dname);
7738 gcc_assert (flags == NO_SPECIAL);
7739 flags = TYPENAME_FLAG;
7740 ctor_return_type = TREE_TYPE (dname);
7741 sfk = sfk_conversion;
7742 if (is_typename_at_global_scope (dname))
7743 name = IDENTIFIER_POINTER (dname);
7745 name = "<invalid operator>";
7762 return error_mark_node;
7767 if (id_declarator->kind == cdk_id)
7773 The declarator in a function-definition shall have the form
7774 D1 ( parameter-declaration-clause) ... */
7775 if (funcdef_flag && innermost_code != cdk_function)
7777 error ("function definition does not declare parameters");
7778 return error_mark_node;
7781 if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
7782 && innermost_code != cdk_function
7783 && ! (ctype && !declspecs->any_specifiers_p))
7785 error ("declaration of %qD as non-function", dname);
7786 return error_mark_node;
7789 /* Anything declared one level down from the top level
7790 must be one of the parameters of a function
7791 (because the body is at least two levels down). */
7793 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
7794 by not allowing C++ class definitions to specify their parameters
7795 with xdecls (must be spec.d in the parmlist).
7797 Since we now wait to push a class scope until we are sure that
7798 we are in a legitimate method context, we must set oldcname
7799 explicitly (since current_class_name is not yet alive).
7801 We also want to avoid calling this a PARM if it is in a namespace. */
7803 if (decl_context == NORMAL && !toplevel_bindings_p ())
7805 struct cp_binding_level *b = current_binding_level;
7806 current_binding_level = b->level_chain;
7807 if (current_binding_level != 0 && toplevel_bindings_p ())
7808 decl_context = PARM;
7809 current_binding_level = b;
7813 name = decl_context == PARM ? "parameter" : "type name";
7815 /* If there were multiple types specified in the decl-specifier-seq,
7816 issue an error message. */
7817 if (declspecs->multiple_types_p)
7819 error ("two or more data types in declaration of %qs", name);
7820 return error_mark_node;
7823 if (declspecs->conflicting_specifiers_p)
7825 error ("conflicting specifiers in declaration of %qs", name);
7826 return error_mark_node;
7829 /* Extract the basic type from the decl-specifier-seq. */
7830 type = declspecs->type;
7831 if (type == error_mark_node)
7834 type_was_error_mark_node = true;
7836 /* If the entire declaration is itself tagged as deprecated then
7837 suppress reports of deprecated items. */
7838 if (type && TREE_DEPRECATED (type)
7839 && deprecated_state != DEPRECATED_SUPPRESS)
7840 warn_deprecated_use (type);
7841 if (type && TREE_CODE (type) == TYPE_DECL)
7843 typedef_decl = type;
7844 type = TREE_TYPE (typedef_decl);
7845 if (TREE_DEPRECATED (type)
7846 && DECL_ARTIFICIAL (typedef_decl)
7847 && deprecated_state != DEPRECATED_SUPPRESS)
7848 warn_deprecated_use (type);
7850 /* No type at all: default to `int', and set DEFAULTED_INT
7851 because it was not a user-defined typedef. */
7852 if (type == NULL_TREE && (signed_p || unsigned_p || long_p || short_p))
7854 /* These imply 'int'. */
7855 type = integer_type_node;
7859 explicit_int = declspecs->explicit_int_p;
7860 explicit_char = declspecs->explicit_char_p;
7863 /* See the code below that used this. */
7865 decl_attr = DECL_ATTRIBUTES (typedef_decl);
7867 typedef_type = type;
7870 if (sfk != sfk_conversion)
7871 ctor_return_type = ctype;
7873 if (sfk != sfk_none)
7874 type = check_special_function_return_type (sfk, type,
7876 else if (type == NULL_TREE)
7882 /* We handle `main' specially here, because 'main () { }' is so
7883 common. With no options, it is allowed. With -Wreturn-type,
7884 it is a warning. It is only an error with -pedantic-errors. */
7885 is_main = (funcdef_flag
7886 && dname && MAIN_NAME_P (dname)
7887 && ctype == NULL_TREE
7888 && in_namespace == NULL_TREE
7889 && current_namespace == global_namespace);
7891 if (type_was_error_mark_node)
7892 /* We've already issued an error, don't complain more. */;
7893 else if (in_system_header || flag_ms_extensions)
7894 /* Allow it, sigh. */;
7896 permerror (input_location, "ISO C++ forbids declaration of %qs with no type", name);
7898 pedwarn (input_location, OPT_pedantic,
7899 "ISO C++ forbids declaration of %qs with no type", name);
7901 warning (OPT_Wreturn_type,
7902 "ISO C++ forbids declaration of %qs with no type", name);
7904 type = integer_type_node;
7909 /* Now process the modifiers that were specified
7910 and check for invalid combinations. */
7912 /* Long double is a special combination. */
7913 if (long_p && !longlong && TYPE_MAIN_VARIANT (type) == double_type_node)
7916 type = build_qualified_type (long_double_type_node,
7917 cp_type_quals (type));
7920 /* Check all other uses of type modifiers. */
7922 if (unsigned_p || signed_p || long_p || short_p)
7926 if ((signed_p || unsigned_p) && TREE_CODE (type) != INTEGER_TYPE)
7927 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
7928 else if (signed_p && unsigned_p)
7929 error ("%<signed%> and %<unsigned%> specified together for %qs", name);
7930 else if (longlong && TREE_CODE (type) != INTEGER_TYPE)
7931 error ("%<long long%> invalid for %qs", name);
7932 else if (long_p && TREE_CODE (type) == REAL_TYPE)
7933 error ("%<long%> invalid for %qs", name);
7934 else if (short_p && TREE_CODE (type) == REAL_TYPE)
7935 error ("%<short%> invalid for %qs", name);
7936 else if ((long_p || short_p) && TREE_CODE (type) != INTEGER_TYPE)
7937 error ("%<long%> or %<short%> invalid for %qs", name);
7938 else if ((long_p || short_p) && explicit_char)
7939 error ("%<long%> or %<short%> specified with char for %qs", name);
7940 else if (long_p && short_p)
7941 error ("%<long%> and %<short%> specified together for %qs", name);
7942 else if (type == char16_type_node || type == char32_type_node)
7944 if (signed_p || unsigned_p)
7945 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
7946 else if (short_p || long_p)
7947 error ("%<short%> or %<long%> invalid for %qs", name);
7952 if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
7954 pedwarn (input_location, OPT_pedantic,
7955 "long, short, signed or unsigned used invalidly for %qs",
7957 if (flag_pedantic_errors)
7962 /* Discard the type modifiers if they are invalid. */
7973 /* Decide whether an integer type is signed or not.
7974 Optionally treat bitfields as signed by default. */
7978 It is implementation-defined whether a plain (neither
7979 explicitly signed or unsigned) char, short, int, or long
7980 bit-field is signed or unsigned.
7982 Naturally, we extend this to long long as well. Note that
7983 this does not include wchar_t. */
7984 || (bitfield && !flag_signed_bitfields
7986 /* A typedef for plain `int' without `signed' can be
7987 controlled just like plain `int', but a typedef for
7988 `signed int' cannot be so controlled. */
7990 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
7991 && TREE_CODE (type) == INTEGER_TYPE
7992 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
7995 type = long_long_unsigned_type_node;
7997 type = long_unsigned_type_node;
7999 type = short_unsigned_type_node;
8000 else if (type == char_type_node)
8001 type = unsigned_char_type_node;
8002 else if (typedef_decl)
8003 type = unsigned_type_for (type);
8005 type = unsigned_type_node;
8007 else if (signed_p && type == char_type_node)
8008 type = signed_char_type_node;
8010 type = long_long_integer_type_node;
8012 type = long_integer_type_node;
8014 type = short_integer_type_node;
8016 if (declspecs->specs[(int)ds_complex])
8018 if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
8019 error ("complex invalid for %qs", name);
8020 /* If we just have "complex", it is equivalent to
8021 "complex double", but if any modifiers at all are specified it is
8022 the complex form of TYPE. E.g, "complex short" is
8023 "complex short int". */
8025 else if (defaulted_int && ! longlong
8026 && ! (long_p || short_p || signed_p || unsigned_p))
8027 type = complex_double_type_node;
8028 else if (type == integer_type_node)
8029 type = complex_integer_type_node;
8030 else if (type == float_type_node)
8031 type = complex_float_type_node;
8032 else if (type == double_type_node)
8033 type = complex_double_type_node;
8034 else if (type == long_double_type_node)
8035 type = complex_long_double_type_node;
8037 type = build_complex_type (type);
8040 type_quals = TYPE_UNQUALIFIED;
8041 if (declspecs->specs[(int)ds_const])
8042 type_quals |= TYPE_QUAL_CONST;
8043 if (declspecs->specs[(int)ds_volatile])
8044 type_quals |= TYPE_QUAL_VOLATILE;
8045 if (declspecs->specs[(int)ds_restrict])
8046 type_quals |= TYPE_QUAL_RESTRICT;
8047 if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
8048 error ("qualifiers are not allowed on declaration of %<operator %T%>",
8051 if (TREE_CODE (type) == FUNCTION_TYPE
8052 && type_quals != TYPE_UNQUALIFIED)
8054 /* This was an error in C++98 (cv-qualifiers cannot be added to
8055 a function type), but DR 295 makes the code well-formed by
8056 dropping the extra qualifiers. */
8059 tree bad_type = build_qualified_type (type, type_quals);
8060 pedwarn (input_location, OPT_pedantic,
8061 "ignoring %qV qualifiers added to function type %qT",
8064 type_quals = TYPE_UNQUALIFIED;
8066 type_quals |= cp_type_quals (type);
8067 type = cp_build_qualified_type_real
8068 (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
8069 ? tf_ignore_bad_quals : 0) | tf_warning_or_error));
8070 /* We might have ignored or rejected some of the qualifiers. */
8071 type_quals = cp_type_quals (type);
8074 inlinep = !! declspecs->specs[(int)ds_inline];
8075 virtualp = !! declspecs->specs[(int)ds_virtual];
8076 explicitp = !! declspecs->specs[(int)ds_explicit];
8078 storage_class = declspecs->storage_class;
8079 if (storage_class == sc_static)
8080 staticp = 1 + (decl_context == FIELD);
8082 if (virtualp && staticp == 2)
8084 error ("member %qD cannot be declared both virtual and static", dname);
8085 storage_class = sc_none;
8088 friendp = !! declspecs->specs[(int)ds_friend];
8090 if (dependent_name && !friendp)
8092 error ("%<%T::%D%> is not a valid declarator", ctype, dependent_name);
8093 return error_mark_node;
8096 /* Issue errors about use of storage classes for parameters. */
8097 if (decl_context == PARM)
8099 if (declspecs->specs[(int)ds_typedef])
8101 error ("typedef declaration invalid in parameter declaration");
8102 return error_mark_node;
8104 else if (storage_class == sc_static
8105 || storage_class == sc_extern
8107 error ("storage class specifiers invalid in parameter declarations");
8109 if (type_uses_auto (type))
8111 error ("parameter declared %<auto%>");
8112 type = error_mark_node;
8116 /* Give error if `virtual' is used outside of class declaration. */
8118 && (current_class_name == NULL_TREE || decl_context != FIELD))
8120 error ("%<virtual%> outside class declaration");
8124 /* Static anonymous unions are dealt with here. */
8125 if (staticp && decl_context == TYPENAME
8127 && ANON_AGGR_TYPE_P (declspecs->type))
8128 decl_context = FIELD;
8130 /* Warn about storage classes that are invalid for certain
8131 kinds of declarations (parameters, typenames, etc.). */
8134 && storage_class != sc_extern
8135 && storage_class != sc_static)
8136 || declspecs->specs[(int)ds_typedef]))
8138 error ("multiple storage classes in declaration of %qs", name);
8141 if (decl_context != NORMAL
8142 && ((storage_class != sc_none
8143 && storage_class != sc_mutable)
8146 if ((decl_context == PARM || decl_context == CATCHPARM)
8147 && (storage_class == sc_register
8148 || storage_class == sc_auto))
8150 else if (declspecs->specs[(int)ds_typedef])
8152 else if (decl_context == FIELD
8153 /* C++ allows static class elements. */
8154 && storage_class == sc_static)
8155 /* C++ also allows inlines and signed and unsigned elements,
8156 but in those cases we don't come in here. */
8160 if (decl_context == FIELD)
8161 error ("storage class specified for %qs", name);
8164 if (decl_context == PARM || decl_context == CATCHPARM)
8165 error ("storage class specified for parameter %qs", name);
8167 error ("storage class specified for typename");
8169 if (storage_class == sc_register
8170 || storage_class == sc_auto
8171 || storage_class == sc_extern
8173 storage_class = sc_none;
8176 else if (storage_class == sc_extern && funcdef_flag
8177 && ! toplevel_bindings_p ())
8178 error ("nested function %qs declared %<extern%>", name);
8179 else if (toplevel_bindings_p ())
8181 if (storage_class == sc_auto)
8182 error ("top-level declaration of %qs specifies %<auto%>", name);
8185 && storage_class != sc_extern
8186 && storage_class != sc_static)
8188 error ("function-scope %qs implicitly auto and declared %<__thread%>",
8193 if (storage_class && friendp)
8195 error ("storage class specifiers invalid in friend function declarations");
8196 storage_class = sc_none;
8201 unqualified_id = NULL_TREE;
8204 unqualified_id = id_declarator->u.id.unqualified_name;
8205 switch (TREE_CODE (unqualified_id))
8208 unqualified_id = TREE_OPERAND (unqualified_id, 0);
8209 if (TYPE_P (unqualified_id))
8210 unqualified_id = constructor_name (unqualified_id);
8213 case IDENTIFIER_NODE:
8214 case TEMPLATE_ID_EXPR:
8222 /* Determine the type of the entity declared by recurring on the
8224 for (; declarator; declarator = declarator->declarator)
8226 const cp_declarator *inner_declarator;
8229 if (type == error_mark_node)
8230 return error_mark_node;
8232 attrs = declarator->attributes;
8238 if (declarator == NULL || declarator->kind == cdk_id)
8239 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
8240 if (declarator->kind == cdk_function)
8241 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
8242 if (declarator->kind == cdk_array)
8243 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
8244 returned_attrs = decl_attributes (&type,
8245 chainon (returned_attrs, attrs),
8249 if (declarator->kind == cdk_id)
8252 inner_declarator = declarator->declarator;
8254 switch (declarator->kind)
8257 type = create_array_type_for_decl (dname, type,
8258 declarator->u.array.bounds);
8266 /* Declaring a function type.
8267 Make sure we have a valid type for the function to return. */
8269 if (type_quals != TYPE_UNQUALIFIED)
8271 if (SCALAR_TYPE_P (type) || VOID_TYPE_P (type))
8272 warning (OPT_Wignored_qualifiers,
8273 "type qualifiers ignored on function return type");
8274 /* We now know that the TYPE_QUALS don't apply to the
8275 decl, but to its return type. */
8276 type_quals = TYPE_UNQUALIFIED;
8277 set_no_warning = true;
8280 /* Error about some types functions can't return. */
8282 if (TREE_CODE (type) == FUNCTION_TYPE)
8284 error ("%qs declared as function returning a function", name);
8285 return error_mark_node;
8287 if (TREE_CODE (type) == ARRAY_TYPE)
8289 error ("%qs declared as function returning an array", name);
8290 return error_mark_node;
8293 /* Pick up type qualifiers which should be applied to `this'. */
8294 memfn_quals = declarator->u.function.qualifiers;
8296 /* Pick up the exception specifications. */
8297 raises = declarator->u.function.exception_specification;
8299 /* Say it's a definition only for the CALL_EXPR
8300 closest to the identifier. */
8301 funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id;
8303 /* Handle a late-specified return type. */
8306 if (type_uses_auto (type))
8308 if (!declarator->u.function.late_return_type)
8310 error ("%qs function uses %<auto%> type specifier without"
8311 " late return type", name);
8312 return error_mark_node;
8314 else if (!is_auto (type))
8316 error ("%qs function with late return type has"
8317 " %qT as its type rather than plain %<auto%>",
8319 return error_mark_node;
8322 else if (declarator->u.function.late_return_type)
8324 error ("%qs function with late return type not declared"
8325 " with %<auto%> type specifier", name);
8326 return error_mark_node;
8329 type = splice_late_return_type
8330 (type, declarator->u.function.late_return_type);
8331 if (type == error_mark_node)
8332 return error_mark_node;
8334 if (ctype == NULL_TREE
8335 && decl_context == FIELD
8337 && (friendp == 0 || dname == current_class_name))
8338 ctype = current_class_type;
8340 if (ctype && (sfk == sfk_constructor
8341 || sfk == sfk_destructor))
8343 /* We are within a class's scope. If our declarator name
8344 is the same as the class name, and we are defining
8345 a function, then it is a constructor/destructor, and
8346 therefore returns a void type. */
8348 /* ISO C++ 12.4/2. A destructor may not be declared
8349 const or volatile. A destructor may not be
8352 ISO C++ 12.1. A constructor may not be declared
8353 const or volatile. A constructor may not be
8354 virtual. A constructor may not be static. */
8356 error ((flags == DTOR_FLAG)
8357 ? "destructor cannot be static member function"
8358 : "constructor cannot be static member function");
8361 error ((flags == DTOR_FLAG)
8362 ? "destructors may not be cv-qualified"
8363 : "constructors may not be cv-qualified");
8364 memfn_quals = TYPE_UNQUALIFIED;
8367 if (decl_context == FIELD
8368 && !member_function_or_else (ctype,
8371 return error_mark_node;
8373 if (flags != DTOR_FLAG)
8375 /* It's a constructor. */
8380 permerror (input_location, "constructors cannot be declared virtual");
8383 if (decl_context == FIELD
8384 && sfk != sfk_constructor)
8385 return error_mark_node;
8387 if (decl_context == FIELD)
8393 error ("can't initialize friend function %qs", name);
8396 /* Cannot be both friend and virtual. */
8397 error ("virtual functions cannot be friends");
8400 if (decl_context == NORMAL)
8401 error ("friend declaration not in class definition");
8402 if (current_function_decl && funcdef_flag)
8403 error ("can't define friend function %qs in a local "
8408 arg_types = grokparms (declarator->u.function.parameters,
8411 if (inner_declarator
8412 && inner_declarator->kind == cdk_id
8413 && inner_declarator->u.id.sfk == sfk_destructor
8414 && arg_types != void_list_node)
8416 error ("destructors may not have parameters");
8417 arg_types = void_list_node;
8421 type = build_function_type (type, arg_types);
8428 /* Filter out pointers-to-references and references-to-references.
8429 We can get these if a TYPE_DECL is used. */
8431 if (TREE_CODE (type) == REFERENCE_TYPE)
8433 if (declarator->kind != cdk_reference)
8435 error ("cannot declare pointer to %q#T", type);
8436 type = TREE_TYPE (type);
8439 /* In C++0x, we allow reference to reference declarations
8440 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
8441 and template type arguments [14.3.1/4 temp.arg.type]. The
8442 check for direct reference to reference declarations, which
8443 are still forbidden, occurs below. Reasoning behind the change
8444 can be found in DR106, DR540, and the rvalue reference
8446 else if (cxx_dialect == cxx98)
8448 error ("cannot declare reference to %q#T", type);
8449 type = TREE_TYPE (type);
8452 else if (VOID_TYPE_P (type))
8454 if (declarator->kind == cdk_reference)
8455 error ("cannot declare reference to %q#T", type);
8456 else if (declarator->kind == cdk_ptrmem)
8457 error ("cannot declare pointer to %q#T member", type);
8460 /* We now know that the TYPE_QUALS don't apply to the decl,
8461 but to the target of the pointer. */
8462 type_quals = TYPE_UNQUALIFIED;
8464 if (declarator->kind == cdk_ptrmem
8465 && (TREE_CODE (type) == FUNCTION_TYPE
8466 || (memfn_quals && TREE_CODE (type) == METHOD_TYPE)))
8468 memfn_quals |= cp_type_quals (type);
8469 type = build_memfn_type (type,
8470 declarator->u.pointer.class_type,
8472 memfn_quals = TYPE_UNQUALIFIED;
8475 if (TREE_CODE (type) == FUNCTION_TYPE
8476 && cp_type_quals (type) != TYPE_UNQUALIFIED)
8477 error ("cannot declare %s to qualified function type %qT",
8478 declarator->kind == cdk_reference ? "reference" : "pointer",
8481 if (declarator->kind == cdk_reference)
8483 /* In C++0x, the type we are creating a reference to might be
8484 a typedef which is itself a reference type. In that case,
8485 we follow the reference collapsing rules in
8486 [7.1.3/8 dcl.typedef] to create the final reference type:
8488 "If a typedef TD names a type that is a reference to a type
8489 T, an attempt to create the type 'lvalue reference to cv TD'
8490 creates the type 'lvalue reference to T,' while an attempt
8491 to create the type "rvalue reference to cv TD' creates the
8494 if (!VOID_TYPE_P (type))
8495 type = cp_build_reference_type
8496 ((TREE_CODE (type) == REFERENCE_TYPE
8497 ? TREE_TYPE (type) : type),
8498 (declarator->u.reference.rvalue_ref
8499 && (TREE_CODE(type) != REFERENCE_TYPE
8500 || TYPE_REF_IS_RVALUE (type))));
8502 /* In C++0x, we need this check for direct reference to
8503 reference declarations, which are forbidden by
8504 [8.3.2/5 dcl.ref]. Reference to reference declarations
8505 are only allowed indirectly through typedefs and template
8506 type arguments. Example:
8508 void foo(int & &); // invalid ref-to-ref decl
8510 typedef int & int_ref;
8511 void foo(int_ref &); // valid ref-to-ref decl
8513 if (inner_declarator && inner_declarator->kind == cdk_reference)
8514 error ("cannot declare reference to %q#T, which is not "
8515 "a typedef or a template type argument", type);
8517 else if (TREE_CODE (type) == METHOD_TYPE)
8518 type = build_ptrmemfunc_type (build_pointer_type (type));
8519 else if (declarator->kind == cdk_ptrmem)
8521 gcc_assert (TREE_CODE (declarator->u.pointer.class_type)
8523 if (declarator->u.pointer.class_type == error_mark_node)
8524 /* We will already have complained. */
8525 type = error_mark_node;
8527 type = build_ptrmem_type (declarator->u.pointer.class_type,
8531 type = build_pointer_type (type);
8533 /* Process a list of type modifier keywords (such as
8534 const or volatile) that were given inside the `*' or `&'. */
8536 if (declarator->u.pointer.qualifiers)
8539 = cp_build_qualified_type (type,
8540 declarator->u.pointer.qualifiers);
8541 type_quals = cp_type_quals (type);
8554 if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR
8555 && TREE_CODE (type) != FUNCTION_TYPE
8556 && TREE_CODE (type) != METHOD_TYPE)
8558 error ("template-id %qD used as a declarator",
8560 unqualified_id = dname;
8563 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
8564 qualified with a class-name, turn it into a METHOD_TYPE, unless
8565 we know that the function is static. We take advantage of this
8566 opportunity to do other processing that pertains to entities
8567 explicitly declared to be class members. Note that if DECLARATOR
8568 is non-NULL, we know it is a cdk_id declarator; otherwise, we
8569 would not have exited the loop above. */
8571 && declarator->u.id.qualifying_scope
8572 && TYPE_P (declarator->u.id.qualifying_scope))
8576 ctype = declarator->u.id.qualifying_scope;
8577 ctype = TYPE_MAIN_VARIANT (ctype);
8579 while (t != NULL_TREE && CLASS_TYPE_P (t))
8581 /* You're supposed to have one `template <...>' for every
8582 template class, but you don't need one for a full
8583 specialization. For example:
8585 template <class T> struct S{};
8586 template <> struct S<int> { void f(); };
8587 void S<int>::f () {}
8589 is correct; there shouldn't be a `template <>' for the
8590 definition of `S<int>::f'. */
8591 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t)
8592 && !any_dependent_template_arguments_p (CLASSTYPE_TI_ARGS (t)))
8593 /* T is an explicit (not partial) specialization. All
8594 containing classes must therefore also be explicitly
8597 if ((CLASSTYPE_USE_TEMPLATE (t) || CLASSTYPE_IS_TEMPLATE (t))
8598 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
8599 template_count += 1;
8601 t = TYPE_MAIN_DECL (t);
8602 t = DECL_CONTEXT (t);
8605 if (ctype == current_class_type)
8609 permerror (input_location, "member functions are implicitly friends of their class");
8613 permerror (declarator->id_loc,
8614 "extra qualification %<%T::%> on member %qs",
8617 else if (/* If the qualifying type is already complete, then we
8618 can skip the following checks. */
8619 !COMPLETE_TYPE_P (ctype)
8620 && (/* If the function is being defined, then
8621 qualifying type must certainly be complete. */
8623 /* A friend declaration of "T::f" is OK, even if
8624 "T" is a template parameter. But, if this
8625 function is not a friend, the qualifying type
8627 || (!friendp && !CLASS_TYPE_P (ctype))
8628 /* For a declaration, the type need not be
8629 complete, if either it is dependent (since there
8630 is no meaningful definition of complete in that
8631 case) or the qualifying class is currently being
8633 || !(dependent_type_p (ctype)
8634 || currently_open_class (ctype)))
8635 /* Check that the qualifying type is complete. */
8636 && !complete_type_or_else (ctype, NULL_TREE))
8637 return error_mark_node;
8638 else if (TREE_CODE (type) == FUNCTION_TYPE)
8640 tree sname = declarator->u.id.unqualified_name;
8642 if (current_class_type
8643 && (!friendp || funcdef_flag))
8646 ? "cannot define member function %<%T::%s%> within %<%T%>"
8647 : "cannot declare member function %<%T::%s%> within %<%T%>",
8648 ctype, name, current_class_type);
8649 return error_mark_node;
8652 if (TREE_CODE (sname) == IDENTIFIER_NODE
8653 && NEW_DELETE_OPNAME_P (sname))
8654 /* Overloaded operator new and operator delete
8655 are always static functions. */
8658 type = build_memfn_type (type, ctype, memfn_quals);
8660 else if (declspecs->specs[(int)ds_typedef]
8661 && current_class_type)
8663 error ("cannot declare member %<%T::%s%> within %qT",
8664 ctype, name, current_class_type);
8665 return error_mark_node;
8669 /* Now TYPE has the actual type. */
8674 *attrlist = chainon (returned_attrs, *attrlist);
8676 attrlist = &returned_attrs;
8679 /* Handle parameter packs. */
8680 if (parameter_pack_p)
8682 if (decl_context == PARM)
8683 /* Turn the type into a pack expansion.*/
8684 type = make_pack_expansion (type);
8686 error ("non-parameter %qs cannot be a parameter pack", name);
8689 /* Did array size calculations overflow? */
8691 if (TREE_CODE (type) == ARRAY_TYPE
8692 && COMPLETE_TYPE_P (type)
8693 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
8694 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
8696 error ("size of array %qs is too large", name);
8697 /* If we proceed with the array type as it is, we'll eventually
8698 crash in tree_low_cst(). */
8699 type = error_mark_node;
8702 if ((decl_context == FIELD || decl_context == PARM)
8703 && !processing_template_decl
8704 && variably_modified_type_p (type, NULL_TREE))
8706 if (decl_context == FIELD)
8707 error ("data member may not have variably modified type %qT", type);
8709 error ("parameter may not have variably modified type %qT", type);
8710 type = error_mark_node;
8713 if (explicitp == 1 || (explicitp && friendp))
8715 /* [dcl.fct.spec] The explicit specifier shall only be used in
8716 declarations of constructors within a class definition. */
8717 error ("only declarations of constructors can be %<explicit%>");
8721 if (storage_class == sc_mutable)
8723 if (decl_context != FIELD || friendp)
8725 error ("non-member %qs cannot be declared %<mutable%>", name);
8726 storage_class = sc_none;
8728 else if (decl_context == TYPENAME || declspecs->specs[(int)ds_typedef])
8730 error ("non-object member %qs cannot be declared %<mutable%>", name);
8731 storage_class = sc_none;
8733 else if (TREE_CODE (type) == FUNCTION_TYPE
8734 || TREE_CODE (type) == METHOD_TYPE)
8736 error ("function %qs cannot be declared %<mutable%>", name);
8737 storage_class = sc_none;
8741 error ("static %qs cannot be declared %<mutable%>", name);
8742 storage_class = sc_none;
8744 else if (type_quals & TYPE_QUAL_CONST)
8746 error ("const %qs cannot be declared %<mutable%>", name);
8747 storage_class = sc_none;
8751 /* If this is declaring a typedef name, return a TYPE_DECL. */
8752 if (declspecs->specs[(int)ds_typedef] && decl_context != TYPENAME)
8756 /* Note that the grammar rejects storage classes
8757 in typenames, fields or parameters. */
8758 if (current_lang_name == lang_name_java)
8759 TYPE_FOR_JAVA (type) = 1;
8761 /* This declaration:
8763 typedef void f(int) const;
8765 declares a function type which is not a member of any
8766 particular class, but which is cv-qualified; for
8767 example "f S::*" declares a pointer to a const-qualified
8768 member function of S. We record the cv-qualification in the
8770 if (memfn_quals && TREE_CODE (type) == FUNCTION_TYPE)
8772 type = cp_build_qualified_type (type, memfn_quals);
8774 /* We have now dealt with these qualifiers. */
8775 memfn_quals = TYPE_UNQUALIFIED;
8778 if (decl_context == FIELD)
8779 decl = build_lang_decl (TYPE_DECL, unqualified_id, type);
8781 decl = build_decl (TYPE_DECL, unqualified_id, type);
8782 if (id_declarator && declarator->u.id.qualifying_scope) {
8783 error ("%Jtypedef name may not be a nested-name-specifier", decl);
8784 TREE_TYPE (decl) = error_mark_node;
8787 if (decl_context != FIELD)
8789 if (!current_function_decl)
8790 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8791 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl)
8792 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
8793 (current_function_decl)))
8794 /* The TYPE_DECL is "abstract" because there will be
8795 clones of this constructor/destructor, and there will
8796 be copies of this TYPE_DECL generated in those
8798 DECL_ABSTRACT (decl) = 1;
8800 else if (constructor_name_p (unqualified_id, current_class_type))
8801 permerror (input_location, "ISO C++ forbids nested type %qD with same name "
8802 "as enclosing class",
8805 /* If the user declares "typedef struct {...} foo" then the
8806 struct will have an anonymous name. Fill that name in now.
8807 Nothing can refer to it, so nothing needs know about the name
8809 if (type != error_mark_node
8812 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
8813 && TYPE_ANONYMOUS_P (type)
8814 && cp_type_quals (type) == TYPE_UNQUALIFIED)
8818 /* Replace the anonymous name with the real name everywhere. */
8819 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
8821 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8823 debug_hooks->set_name (t, decl);
8824 TYPE_NAME (t) = decl;
8828 if (TYPE_LANG_SPECIFIC (type))
8829 TYPE_WAS_ANONYMOUS (type) = 1;
8831 /* If this is a typedef within a template class, the nested
8832 type is a (non-primary) template. The name for the
8833 template needs updating as well. */
8834 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
8835 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
8836 = TYPE_IDENTIFIER (type);
8838 /* FIXME remangle member functions; member functions of a
8839 type with external linkage have external linkage. */
8843 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
8844 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
8846 bad_specifiers (decl, "type", virtualp,
8847 memfn_quals != TYPE_UNQUALIFIED,
8848 inlinep, friendp, raises != NULL_TREE);
8853 /* Detect the case of an array type of unspecified size
8854 which came, as such, direct from a typedef name.
8855 We must copy the type, so that the array's domain can be
8856 individually set by the object's initializer. */
8858 if (type && typedef_type
8859 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
8860 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
8861 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
8863 /* Detect where we're using a typedef of function type to declare a
8864 function. PARMS will not be set, so we must create it now. */
8866 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
8868 tree decls = NULL_TREE;
8871 for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
8873 tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
8875 TREE_CHAIN (decl) = decls;
8879 parms = nreverse (decls);
8881 if (decl_context != TYPENAME)
8883 /* A cv-qualifier-seq shall only be part of the function type
8884 for a non-static member function. [8.3.5/4 dcl.fct] */
8885 if (cp_type_quals (type) != TYPE_UNQUALIFIED
8886 && (current_class_type == NULL_TREE || staticp) )
8889 ? G_("qualified function types cannot be used to "
8890 "declare static member functions")
8891 : G_("qualified function types cannot be used to "
8892 "declare free functions"));
8893 type = TYPE_MAIN_VARIANT (type);
8896 /* The qualifiers on the function type become the qualifiers on
8897 the non-static member function. */
8898 memfn_quals |= cp_type_quals (type);
8902 /* If this is a type name (such as, in a cast or sizeof),
8903 compute the type and return it now. */
8905 if (decl_context == TYPENAME)
8907 /* Note that the grammar rejects storage classes
8908 in typenames, fields or parameters. */
8909 if (type_quals != TYPE_UNQUALIFIED)
8910 type_quals = TYPE_UNQUALIFIED;
8912 /* Special case: "friend class foo" looks like a TYPENAME context. */
8915 if (type_quals != TYPE_UNQUALIFIED)
8917 error ("type qualifiers specified for friend class declaration");
8918 type_quals = TYPE_UNQUALIFIED;
8922 error ("%<inline%> specified for friend class declaration");
8928 /* Don't allow friend declaration without a class-key. */
8929 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
8930 permerror (input_location, "template parameters cannot be friends");
8931 else if (TREE_CODE (type) == TYPENAME_TYPE)
8932 permerror (input_location, "friend declaration requires class-key, "
8933 "i.e. %<friend class %T::%D%>",
8934 TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
8936 permerror (input_location, "friend declaration requires class-key, "
8937 "i.e. %<friend %#T%>",
8941 /* Only try to do this stuff if we didn't already give up. */
8942 if (type != integer_type_node)
8944 /* A friendly class? */
8945 if (current_class_type)
8946 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
8949 error ("trying to make class %qT a friend of global scope",
8952 type = void_type_node;
8955 else if (memfn_quals)
8957 if (ctype == NULL_TREE
8958 && TREE_CODE (type) == METHOD_TYPE)
8959 ctype = TYPE_METHOD_BASETYPE (type);
8962 type = build_memfn_type (type, ctype, memfn_quals);
8963 /* Core issue #547: need to allow this in template type args. */
8964 else if (template_type_arg && TREE_CODE (type) == FUNCTION_TYPE)
8965 type = cp_build_qualified_type (type, memfn_quals);
8967 error ("invalid qualifiers on non-member function type");
8972 else if (unqualified_id == NULL_TREE && decl_context != PARM
8973 && decl_context != CATCHPARM
8974 && TREE_CODE (type) != UNION_TYPE
8977 error ("abstract declarator %qT used as declaration", type);
8978 return error_mark_node;
8981 /* Only functions may be declared using an operator-function-id. */
8983 && IDENTIFIER_OPNAME_P (unqualified_id)
8984 && TREE_CODE (type) != FUNCTION_TYPE
8985 && TREE_CODE (type) != METHOD_TYPE)
8987 error ("declaration of %qD as non-function", unqualified_id);
8988 return error_mark_node;
8991 /* We don't check parameter types here because we can emit a better
8992 error message later. */
8993 if (decl_context != PARM)
8995 type = check_var_type (unqualified_id, type);
8996 if (type == error_mark_node)
8997 return error_mark_node;
9000 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
9001 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
9003 if (decl_context == PARM || decl_context == CATCHPARM)
9005 if (ctype || in_namespace)
9006 error ("cannot use %<::%> in parameter declaration");
9008 /* A parameter declared as an array of T is really a pointer to T.
9009 One declared as a function is really a pointer to a function.
9010 One declared as a member is really a pointer to member. */
9012 if (TREE_CODE (type) == ARRAY_TYPE)
9014 /* Transfer const-ness of array into that of type pointed to. */
9015 type = build_pointer_type (TREE_TYPE (type));
9016 type_quals = TYPE_UNQUALIFIED;
9018 else if (TREE_CODE (type) == FUNCTION_TYPE)
9019 type = build_pointer_type (type);
9025 if (decl_context == PARM)
9027 decl = cp_build_parm_decl (unqualified_id, type);
9029 bad_specifiers (decl, "parameter", virtualp,
9030 memfn_quals != TYPE_UNQUALIFIED,
9031 inlinep, friendp, raises != NULL_TREE);
9033 else if (decl_context == FIELD)
9035 /* The C99 flexible array extension. */
9036 if (!staticp && TREE_CODE (type) == ARRAY_TYPE
9037 && TYPE_DOMAIN (type) == NULL_TREE)
9039 tree itype = compute_array_index_type (dname, integer_zero_node);
9040 type = build_cplus_array_type (TREE_TYPE (type), itype);
9043 if (type == error_mark_node)
9045 /* Happens when declaring arrays of sizes which
9046 are error_mark_node, for example. */
9049 else if (in_namespace && !friendp)
9051 /* Something like struct S { int N::j; }; */
9052 error ("invalid use of %<::%>");
9053 return error_mark_node;
9055 else if (TREE_CODE (type) == FUNCTION_TYPE)
9058 tree function_context;
9062 if (ctype == NULL_TREE)
9063 ctype = current_class_type;
9065 if (ctype == NULL_TREE)
9067 error ("can't make %qD into a method -- not in a class",
9069 return error_mark_node;
9072 /* ``A union may [ ... ] not [ have ] virtual functions.''
9074 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
9076 error ("function %qD declared virtual inside a union",
9078 return error_mark_node;
9081 if (NEW_DELETE_OPNAME_P (unqualified_id))
9085 error ("%qD cannot be declared virtual, since it "
9091 else if (staticp < 2)
9092 type = build_memfn_type (type, ctype, memfn_quals);
9095 /* Check that the name used for a destructor makes sense. */
9096 if (sfk == sfk_destructor)
9098 tree uqname = id_declarator->u.id.unqualified_name;
9102 gcc_assert (friendp);
9103 error ("expected qualified name in friend declaration "
9104 "for destructor %qD", uqname);
9105 return error_mark_node;
9108 if (!check_dtor_name (ctype, TREE_OPERAND (uqname, 0)))
9110 error ("declaration of %qD as member of %qT",
9112 return error_mark_node;
9115 else if (sfk == sfk_constructor && friendp)
9117 error ("expected qualified name in friend declaration "
9118 "for constructor %qD",
9119 id_declarator->u.id.unqualified_name);
9120 return error_mark_node;
9123 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
9124 function_context = (ctype != NULL_TREE) ?
9125 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
9126 publicp = (! friendp || ! staticp)
9127 && function_context == NULL_TREE;
9128 decl = grokfndecl (ctype, type,
9129 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
9130 ? unqualified_id : dname,
9133 virtualp, flags, memfn_quals, raises,
9134 friendp ? -1 : 0, friendp, publicp, inlinep,
9136 funcdef_flag, template_count, in_namespace,
9137 attrlist, declarator->id_loc);
9138 if (decl == NULL_TREE)
9139 return error_mark_node;
9141 /* This clobbers the attrs stored in `decl' from `attrlist'. */
9142 /* The decl and setting of decl_attr is also turned off. */
9143 decl = build_decl_attribute_variant (decl, decl_attr);
9146 /* [class.conv.ctor]
9148 A constructor declared without the function-specifier
9149 explicit that can be called with a single parameter
9150 specifies a conversion from the type of its first
9151 parameter to the type of its class. Such a constructor
9152 is called a converting constructor. */
9154 DECL_NONCONVERTING_P (decl) = 1;
9156 else if (TREE_CODE (type) == METHOD_TYPE)
9158 /* We only get here for friend declarations of
9159 members of other classes. */
9160 /* All method decls are public, so tell grokfndecl to set
9161 TREE_PUBLIC, also. */
9162 decl = grokfndecl (ctype, type,
9163 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
9164 ? unqualified_id : dname,
9167 virtualp, flags, memfn_quals, raises,
9168 friendp ? -1 : 0, friendp, 1, 0, sfk,
9169 funcdef_flag, template_count, in_namespace,
9171 declarator->id_loc);
9172 if (decl == NULL_TREE)
9173 return error_mark_node;
9175 else if (!staticp && !dependent_type_p (type)
9176 && !COMPLETE_TYPE_P (complete_type (type))
9177 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
9180 error ("field %qD has incomplete type", unqualified_id);
9182 error ("name %qT has incomplete type", type);
9184 /* If we're instantiating a template, tell them which
9185 instantiation made the field's type be incomplete. */
9186 if (current_class_type
9187 && TYPE_NAME (current_class_type)
9188 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
9190 && declspecs->type == type)
9191 error (" in instantiation of template %qT",
9192 current_class_type);
9194 return error_mark_node;
9200 error ("%qE is neither function nor member function; "
9201 "cannot be declared friend", unqualified_id);
9209 /* Friends are treated specially. */
9210 if (ctype == current_class_type)
9211 ; /* We already issued a permerror. */
9212 else if (decl && DECL_NAME (decl))
9214 if (template_class_depth (current_class_type) == 0)
9216 decl = check_explicit_specialization
9217 (unqualified_id, decl, template_count,
9218 2 * funcdef_flag + 4);
9219 if (decl == error_mark_node)
9220 return error_mark_node;
9223 decl = do_friend (ctype, unqualified_id, decl,
9229 return error_mark_node;
9232 /* Structure field. It may not be a function, except for C++. */
9234 if (decl == NULL_TREE)
9240 /* An attempt is being made to initialize a non-static
9241 member. But, from [class.mem]:
9243 4 A member-declarator can contain a
9244 constant-initializer only if it declares a static
9245 member (_class.static_) of integral or enumeration
9246 type, see _class.static.data_.
9248 This used to be relatively common practice, but
9249 the rest of the compiler does not correctly
9250 handle the initialization unless the member is
9251 static so we make it static below. */
9252 permerror (input_location, "ISO C++ forbids initialization of member %qD",
9254 permerror (input_location, "making %qD static", unqualified_id);
9258 if (uses_template_parms (type))
9259 /* We'll check at instantiation time. */
9261 else if (check_static_variable_definition (unqualified_id,
9263 /* If we just return the declaration, crashes
9264 will sometimes occur. We therefore return
9265 void_type_node, as if this was a friend
9266 declaration, to cause callers to completely
9267 ignore this declaration. */
9268 return error_mark_node;
9273 /* C++ allows static class members. All other work
9274 for this is done by grokfield. */
9275 decl = build_lang_decl (VAR_DECL, unqualified_id, type);
9276 set_linkage_for_static_data_member (decl);
9277 /* Even if there is an in-class initialization, DECL
9278 is considered undefined until an out-of-class
9279 definition is provided. */
9280 DECL_EXTERNAL (decl) = 1;
9283 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
9287 decl = build_decl (FIELD_DECL, unqualified_id, type);
9288 DECL_NONADDRESSABLE_P (decl) = bitfield;
9289 if (bitfield && !unqualified_id)
9290 TREE_NO_WARNING (decl) = 1;
9292 if (storage_class == sc_mutable)
9294 DECL_MUTABLE_P (decl) = 1;
9295 storage_class = sc_none;
9299 bad_specifiers (decl, "field", virtualp,
9300 memfn_quals != TYPE_UNQUALIFIED,
9301 inlinep, friendp, raises != NULL_TREE);
9304 else if (TREE_CODE (type) == FUNCTION_TYPE
9305 || TREE_CODE (type) == METHOD_TYPE)
9310 if (!unqualified_id)
9311 return error_mark_node;
9313 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
9314 original_name = dname;
9316 original_name = unqualified_id;
9318 if (storage_class == sc_auto)
9319 error ("storage class %<auto%> invalid for function %qs", name);
9320 else if (storage_class == sc_register)
9321 error ("storage class %<register%> invalid for function %qs", name);
9323 error ("storage class %<__thread%> invalid for function %qs", name);
9325 /* Function declaration not at top level.
9326 Storage classes other than `extern' are not allowed
9327 and `extern' makes no difference. */
9328 if (! toplevel_bindings_p ()
9329 && (storage_class == sc_static
9330 || declspecs->specs[(int)ds_inline])
9333 if (storage_class == sc_static)
9334 pedwarn (input_location, OPT_pedantic,
9335 "%<static%> specified invalid for function %qs "
9336 "declared out of global scope", name);
9338 pedwarn (input_location, OPT_pedantic,
9339 "%<inline%> specifier invalid for function %qs "
9340 "declared out of global scope", name);
9343 if (ctype != NULL_TREE
9344 && TREE_CODE (ctype) != NAMESPACE_DECL && !MAYBE_CLASS_TYPE_P (ctype))
9346 error ("%q#T is not a class or a namespace", ctype);
9350 if (ctype == NULL_TREE)
9354 error ("virtual non-class function %qs", name);
9357 else if (sfk == sfk_constructor
9358 || sfk == sfk_destructor)
9361 ? "%qs defined in a non-class scope"
9362 : "%qs declared in a non-class scope", name);
9366 else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2
9367 && !NEW_DELETE_OPNAME_P (original_name))
9368 type = build_method_type_directly (ctype,
9370 TYPE_ARG_TYPES (type));
9372 /* Record presence of `static'. */
9373 publicp = (ctype != NULL_TREE
9374 || storage_class == sc_extern
9375 || storage_class != sc_static);
9377 decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
9378 virtualp, flags, memfn_quals, raises,
9380 publicp, inlinep, sfk, funcdef_flag,
9381 template_count, in_namespace, attrlist,
9382 declarator->id_loc);
9383 if (decl == NULL_TREE)
9384 return error_mark_node;
9388 int invalid_static = 0;
9390 /* Don't allow a static member function in a class, and forbid
9391 declaring main to be static. */
9392 if (TREE_CODE (type) == METHOD_TYPE)
9394 permerror (input_location, "cannot declare member function %qD to have "
9395 "static linkage", decl);
9398 else if (current_function_decl)
9400 /* FIXME need arm citation */
9401 error ("cannot declare static function inside another function");
9408 storage_class = sc_none;
9414 /* It's a variable. */
9416 /* An uninitialized decl with `extern' is a reference. */
9417 decl = grokvardecl (type, unqualified_id,
9420 (type_quals & TYPE_QUAL_CONST) != 0,
9421 ctype ? ctype : in_namespace);
9422 bad_specifiers (decl, "variable", virtualp,
9423 memfn_quals != TYPE_UNQUALIFIED,
9424 inlinep, friendp, raises != NULL_TREE);
9428 DECL_CONTEXT (decl) = ctype;
9431 permerror (input_location, "%<static%> may not be used when defining "
9432 "(as opposed to declaring) a static data member");
9434 storage_class = sc_none;
9436 if (storage_class == sc_register && TREE_STATIC (decl))
9438 error ("static member %qD declared %<register%>", decl);
9439 storage_class = sc_none;
9441 if (storage_class == sc_extern && pedantic)
9443 pedwarn (input_location, OPT_pedantic,
9444 "cannot explicitly declare member %q#D to have "
9445 "extern linkage", decl);
9446 storage_class = sc_none;
9451 if (storage_class == sc_extern && initialized && !funcdef_flag)
9453 if (toplevel_bindings_p ())
9455 /* It's common practice (and completely valid) to have a const
9456 be initialized and declared extern. */
9457 if (!(type_quals & TYPE_QUAL_CONST))
9458 warning (0, "%qs initialized and declared %<extern%>", name);
9462 error ("%qs has both %<extern%> and initializer", name);
9463 return error_mark_node;
9467 /* Record `register' declaration for warnings on &
9468 and in case doing stupid register allocation. */
9470 if (storage_class == sc_register)
9471 DECL_REGISTER (decl) = 1;
9472 else if (storage_class == sc_extern)
9473 DECL_THIS_EXTERN (decl) = 1;
9474 else if (storage_class == sc_static)
9475 DECL_THIS_STATIC (decl) = 1;
9477 /* Record constancy and volatility on the DECL itself . There's
9478 no need to do this when processing a template; we'll do this
9479 for the instantiated declaration based on the type of DECL. */
9480 if (!processing_template_decl)
9481 cp_apply_type_quals_to_decl (type_quals, decl);
9484 TREE_NO_WARNING (decl) = 1;
9490 /* Subroutine of start_function. Ensure that each of the parameter
9491 types (as listed in PARMS) is complete, as is required for a
9492 function definition. */
9495 require_complete_types_for_parms (tree parms)
9497 for (; parms; parms = TREE_CHAIN (parms))
9499 if (dependent_type_p (TREE_TYPE (parms)))
9501 if (!VOID_TYPE_P (TREE_TYPE (parms))
9502 && complete_type_or_else (TREE_TYPE (parms), parms))
9504 relayout_decl (parms);
9505 DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
9508 /* grokparms or complete_type_or_else will have already issued
9510 TREE_TYPE (parms) = error_mark_node;
9514 /* Returns nonzero if T is a local variable. */
9517 local_variable_p (const_tree t)
9519 if ((TREE_CODE (t) == VAR_DECL
9520 /* A VAR_DECL with a context that is a _TYPE is a static data
9522 && !TYPE_P (CP_DECL_CONTEXT (t))
9523 /* Any other non-local variable must be at namespace scope. */
9524 && !DECL_NAMESPACE_SCOPE_P (t))
9525 || (TREE_CODE (t) == PARM_DECL))
9531 /* Like local_variable_p, but suitable for use as a tree-walking
9535 local_variable_p_walkfn (tree *tp, int *walk_subtrees,
9536 void *data ATTRIBUTE_UNUSED)
9538 if (local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
9540 else if (TYPE_P (*tp))
9547 /* Check that ARG, which is a default-argument expression for a
9548 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
9549 something goes wrong. DECL may also be a _TYPE node, rather than a
9550 DECL, if there is no DECL available. */
9553 check_default_argument (tree decl, tree arg)
9558 if (TREE_CODE (arg) == DEFAULT_ARG)
9559 /* We get a DEFAULT_ARG when looking at an in-class declaration
9560 with a default argument. Ignore the argument for now; we'll
9561 deal with it after the class is complete. */
9570 decl_type = TREE_TYPE (decl);
9572 if (arg == error_mark_node
9573 || decl == error_mark_node
9574 || TREE_TYPE (arg) == error_mark_node
9575 || decl_type == error_mark_node)
9576 /* Something already went wrong. There's no need to check
9578 return error_mark_node;
9580 /* [dcl.fct.default]
9582 A default argument expression is implicitly converted to the
9584 if (!TREE_TYPE (arg)
9585 || !can_convert_arg (decl_type, TREE_TYPE (arg), arg, LOOKUP_NORMAL))
9588 error ("default argument for %q#D has type %qT",
9589 decl, TREE_TYPE (arg));
9591 error ("default argument for parameter of type %qT has type %qT",
9592 decl_type, TREE_TYPE (arg));
9594 return error_mark_node;
9597 /* [dcl.fct.default]
9599 Local variables shall not be used in default argument
9602 The keyword `this' shall not be used in a default argument of a
9604 var = cp_walk_tree_without_duplicates (&arg, local_variable_p_walkfn, NULL);
9607 error ("default argument %qE uses local variable %qD", arg, var);
9608 return error_mark_node;
9615 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
9618 type_is_deprecated (tree type)
9620 enum tree_code code;
9621 if (TREE_DEPRECATED (type))
9623 if (TYPE_NAME (type)
9624 && TREE_DEPRECATED (TYPE_NAME (type)))
9627 code = TREE_CODE (type);
9629 if (code == POINTER_TYPE || code == REFERENCE_TYPE
9630 || code == OFFSET_TYPE || code == FUNCTION_TYPE
9631 || code == METHOD_TYPE || code == ARRAY_TYPE)
9632 return type_is_deprecated (TREE_TYPE (type));
9634 if (TYPE_PTRMEMFUNC_P (type))
9635 return type_is_deprecated
9636 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type))));
9641 /* Decode the list of parameter types for a function type.
9642 Given the list of things declared inside the parens,
9643 return a list of types.
9645 If this parameter does not end with an ellipsis, we append
9648 *PARMS is set to the chain of PARM_DECLs created. */
9651 grokparms (tree parmlist, tree *parms)
9653 tree result = NULL_TREE;
9654 tree decls = NULL_TREE;
9658 for (parm = parmlist; parm != NULL_TREE; parm = TREE_CHAIN (parm))
9660 tree type = NULL_TREE;
9661 tree init = TREE_PURPOSE (parm);
9662 tree decl = TREE_VALUE (parm);
9664 if (parm == void_list_node)
9667 if (! decl || TREE_TYPE (decl) == error_mark_node)
9670 type = TREE_TYPE (decl);
9671 if (VOID_TYPE_P (type))
9673 if (same_type_p (type, void_type_node)
9674 && DECL_SELF_REFERENCE_P (type)
9675 && !DECL_NAME (decl) && !result && TREE_CHAIN (parm) == void_list_node)
9676 /* this is a parmlist of `(void)', which is ok. */
9678 cxx_incomplete_type_error (decl, type);
9679 /* It's not a good idea to actually create parameters of
9680 type `void'; other parts of the compiler assume that a
9681 void type terminates the parameter list. */
9682 type = error_mark_node;
9683 TREE_TYPE (decl) = error_mark_node;
9686 if (type != error_mark_node
9687 && TYPE_FOR_JAVA (type)
9688 && MAYBE_CLASS_TYPE_P (type))
9690 error ("parameter %qD has Java class type", decl);
9691 type = error_mark_node;
9692 TREE_TYPE (decl) = error_mark_node;
9696 if (type != error_mark_node)
9698 if (deprecated_state != DEPRECATED_SUPPRESS)
9700 tree deptype = type_is_deprecated (type);
9702 warn_deprecated_use (deptype);
9705 /* Top-level qualifiers on the parameters are
9706 ignored for function types. */
9707 type = cp_build_qualified_type (type, 0);
9708 if (TREE_CODE (type) == METHOD_TYPE)
9710 error ("parameter %qD invalidly declared method type", decl);
9711 type = build_pointer_type (type);
9712 TREE_TYPE (decl) = type;
9714 else if (abstract_virtuals_error (decl, type))
9715 any_error = 1; /* Seems like a good idea. */
9716 else if (POINTER_TYPE_P (type))
9718 /* [dcl.fct]/6, parameter types cannot contain pointers
9719 (references) to arrays of unknown bound. */
9720 tree t = TREE_TYPE (type);
9721 int ptr = TYPE_PTR_P (type);
9727 else if (TREE_CODE (t) != ARRAY_TYPE)
9729 else if (!TYPE_DOMAIN (t))
9733 if (TREE_CODE (t) == ARRAY_TYPE)
9734 error ("parameter %qD includes %s to array of unknown "
9736 decl, ptr ? "pointer" : "reference", t);
9741 else if (init && !processing_template_decl)
9742 init = check_default_argument (decl, init);
9745 if (TREE_CODE (decl) == PARM_DECL
9746 && FUNCTION_PARAMETER_PACK_P (decl)
9747 && TREE_CHAIN (parm)
9748 && TREE_CHAIN (parm) != void_list_node)
9749 error ("parameter packs must be at the end of the parameter list");
9751 TREE_CHAIN (decl) = decls;
9753 result = tree_cons (init, type, result);
9755 decls = nreverse (decls);
9756 result = nreverse (result);
9758 result = chainon (result, void_list_node);
9765 /* D is a constructor or overloaded `operator='.
9767 Let T be the class in which D is declared. Then, this function
9770 -1 if D's is an ill-formed constructor or copy assignment operator
9771 whose first parameter is of type `T'.
9772 0 if D is not a copy constructor or copy assignment
9774 1 if D is a copy constructor or copy assignment operator whose
9775 first parameter is a reference to const qualified T.
9776 2 if D is a copy constructor or copy assignment operator whose
9777 first parameter is a reference to non-const qualified T.
9779 This function can be used as a predicate. Positive values indicate
9780 a copy constructor and nonzero values indicate a copy assignment
9784 copy_fn_p (const_tree d)
9790 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
9792 if (TREE_CODE (d) == TEMPLATE_DECL
9793 || (DECL_TEMPLATE_INFO (d)
9794 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
9795 /* Instantiations of template member functions are never copy
9796 functions. Note that member functions of templated classes are
9797 represented as template functions internally, and we must
9798 accept those as copy functions. */
9801 args = FUNCTION_FIRST_USER_PARMTYPE (d);
9805 arg_type = TREE_VALUE (args);
9806 if (arg_type == error_mark_node)
9809 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
9811 /* Pass by value copy assignment operator. */
9814 else if (TREE_CODE (arg_type) == REFERENCE_TYPE
9815 && !TYPE_REF_IS_RVALUE (arg_type)
9816 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
9818 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
9824 args = TREE_CHAIN (args);
9826 if (args && args != void_list_node && !TREE_PURPOSE (args))
9827 /* There are more non-optional args. */
9833 /* D is a constructor or overloaded `operator='.
9835 Let T be the class in which D is declared. Then, this function
9836 returns true when D is a move constructor or move assignment
9837 operator, false otherwise. */
9840 move_fn_p (const_tree d)
9844 bool result = false;
9846 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
9848 if (cxx_dialect == cxx98)
9849 /* There are no move constructors if we are in C++98 mode. */
9852 if (TREE_CODE (d) == TEMPLATE_DECL
9853 || (DECL_TEMPLATE_INFO (d)
9854 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
9855 /* Instantiations of template member functions are never copy
9856 functions. Note that member functions of templated classes are
9857 represented as template functions internally, and we must
9858 accept those as copy functions. */
9861 args = FUNCTION_FIRST_USER_PARMTYPE (d);
9865 arg_type = TREE_VALUE (args);
9866 if (arg_type == error_mark_node)
9869 if (TREE_CODE (arg_type) == REFERENCE_TYPE
9870 && TYPE_REF_IS_RVALUE (arg_type)
9871 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)),
9875 args = TREE_CHAIN (args);
9877 if (args && args != void_list_node && !TREE_PURPOSE (args))
9878 /* There are more non-optional args. */
9884 /* Remember any special properties of member function DECL. */
9887 grok_special_member_properties (tree decl)
9891 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
9894 class_type = DECL_CONTEXT (decl);
9895 if (DECL_CONSTRUCTOR_P (decl))
9897 int ctor = copy_fn_p (decl);
9899 if (!DECL_ARTIFICIAL (decl))
9900 TYPE_HAS_USER_CONSTRUCTOR (class_type) = 1;
9906 A non-template constructor for class X is a copy
9907 constructor if its first parameter is of type X&, const
9908 X&, volatile X& or const volatile X&, and either there
9909 are no other parameters or else all other parameters have
9910 default arguments. */
9911 TYPE_HAS_INIT_REF (class_type) = 1;
9912 if (!DECL_DEFAULTED_FN (decl))
9913 TYPE_HAS_COMPLEX_INIT_REF (class_type) = 1;
9915 TYPE_HAS_CONST_INIT_REF (class_type) = 1;
9917 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
9919 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type) = 1;
9920 if (TREE_CODE (decl) == TEMPLATE_DECL || !DECL_DEFAULTED_FN (decl))
9921 TYPE_HAS_COMPLEX_DFLT (class_type) = 1;
9923 else if (is_list_ctor (decl))
9924 TYPE_HAS_LIST_CTOR (class_type) = 1;
9926 else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
9930 A non-template assignment operator for class X is a copy
9931 assignment operator if its parameter is of type X, X&, const
9932 X&, volatile X& or const volatile X&. */
9934 int assop = copy_fn_p (decl);
9938 TYPE_HAS_ASSIGN_REF (class_type) = 1;
9939 if (!DECL_DEFAULTED_FN (decl))
9940 TYPE_HAS_COMPLEX_ASSIGN_REF (class_type) = 1;
9942 TYPE_HAS_CONST_ASSIGN_REF (class_type) = 1;
9947 /* Check a constructor DECL has the correct form. Complains
9948 if the class has a constructor of the form X(X). */
9951 grok_ctor_properties (const_tree ctype, const_tree decl)
9953 int ctor_parm = copy_fn_p (decl);
9959 A declaration of a constructor for a class X is ill-formed if
9960 its first parameter is of type (optionally cv-qualified) X
9961 and either there are no other parameters or else all other
9962 parameters have default arguments.
9964 We *don't* complain about member template instantiations that
9965 have this form, though; they can occur as we try to decide
9966 what constructor to use during overload resolution. Since
9967 overload resolution will never prefer such a constructor to
9968 the non-template copy constructor (which is either explicitly
9969 or implicitly defined), there's no need to worry about their
9970 existence. Theoretically, they should never even be
9971 instantiated, but that's hard to forestall. */
9972 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
9980 /* An operator with this code is unary, but can also be binary. */
9983 ambi_op_p (enum tree_code code)
9985 return (code == INDIRECT_REF
9986 || code == ADDR_EXPR
9987 || code == UNARY_PLUS_EXPR
9988 || code == NEGATE_EXPR
9989 || code == PREINCREMENT_EXPR
9990 || code == PREDECREMENT_EXPR);
9993 /* An operator with this name can only be unary. */
9996 unary_op_p (enum tree_code code)
9998 return (code == TRUTH_NOT_EXPR
9999 || code == BIT_NOT_EXPR
10000 || code == COMPONENT_REF
10001 || code == TYPE_EXPR);
10004 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
10005 errors are issued for invalid declarations. */
10008 grok_op_properties (tree decl, bool complain)
10010 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
10012 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
10013 tree name = DECL_NAME (decl);
10014 enum tree_code operator_code;
10019 /* Count the number of arguments and check for ellipsis. */
10020 for (argtype = argtypes, arity = 0;
10021 argtype && argtype != void_list_node;
10022 argtype = TREE_CHAIN (argtype))
10024 ellipsis_p = !argtype;
10026 class_type = DECL_CONTEXT (decl);
10027 if (class_type && !CLASS_TYPE_P (class_type))
10028 class_type = NULL_TREE;
10030 if (DECL_CONV_FN_P (decl))
10031 operator_code = TYPE_EXPR;
10035 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
10036 if (ansi_opname (CODE) == name) \
10038 operator_code = (CODE); \
10041 else if (ansi_assopname (CODE) == name) \
10043 operator_code = (CODE); \
10044 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
10048 #include "operators.def"
10049 #undef DEF_OPERATOR
10051 gcc_unreachable ();
10054 gcc_assert (operator_code != MAX_TREE_CODES);
10055 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
10058 switch (operator_code)
10061 TYPE_HAS_NEW_OPERATOR (class_type) = 1;
10065 TYPE_GETS_DELETE (class_type) |= 1;
10069 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type) = 1;
10072 case VEC_DELETE_EXPR:
10073 TYPE_GETS_DELETE (class_type) |= 2;
10080 /* [basic.std.dynamic.allocation]/1:
10082 A program is ill-formed if an allocation function is declared
10083 in a namespace scope other than global scope or declared static
10086 The same also holds true for deallocation functions. */
10087 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR
10088 || operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
10090 if (DECL_NAMESPACE_SCOPE_P (decl))
10092 if (CP_DECL_CONTEXT (decl) != global_namespace)
10094 error ("%qD may not be declared within a namespace", decl);
10097 else if (!TREE_PUBLIC (decl))
10099 error ("%qD may not be declared as static", decl);
10105 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
10107 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
10108 DECL_IS_OPERATOR_NEW (decl) = 1;
10110 else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
10111 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
10114 /* An operator function must either be a non-static member function
10115 or have at least one parameter of a class, a reference to a class,
10116 an enumeration, or a reference to an enumeration. 13.4.0.6 */
10117 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
10119 if (operator_code == TYPE_EXPR
10120 || operator_code == CALL_EXPR
10121 || operator_code == COMPONENT_REF
10122 || operator_code == ARRAY_REF
10123 || operator_code == NOP_EXPR)
10125 error ("%qD must be a nonstatic member function", decl);
10132 if (DECL_STATIC_FUNCTION_P (decl))
10134 error ("%qD must be either a non-static member "
10135 "function or a non-member function", decl);
10139 for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
10141 tree arg = non_reference (TREE_VALUE (p));
10142 if (arg == error_mark_node)
10145 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
10146 because these checks are performed even on
10147 template functions. */
10148 if (MAYBE_CLASS_TYPE_P (arg)
10149 || TREE_CODE (arg) == ENUMERAL_TYPE)
10153 if (!p || p == void_list_node)
10156 error ("%qD must have an argument of class or "
10157 "enumerated type", decl);
10163 /* There are no restrictions on the arguments to an overloaded
10165 if (operator_code == CALL_EXPR)
10168 /* Warn about conversion operators that will never be used. */
10169 if (IDENTIFIER_TYPENAME_P (name)
10170 && ! DECL_TEMPLATE_INFO (decl)
10172 /* Warn only declaring the function; there is no need to
10173 warn again about out-of-class definitions. */
10174 && class_type == current_class_type)
10176 tree t = TREE_TYPE (name);
10177 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
10178 const char *what = 0;
10181 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
10183 if (TREE_CODE (t) == VOID_TYPE)
10185 else if (class_type)
10187 if (t == class_type)
10188 what = "the same type";
10189 /* Don't force t to be complete here. */
10190 else if (MAYBE_CLASS_TYPE_P (t)
10191 && COMPLETE_TYPE_P (t)
10192 && DERIVED_FROM_P (t, class_type))
10193 what = "a base class";
10197 warning (OPT_Wconversion, "conversion to %s%s will never use a type "
10198 "conversion operator",
10199 ref ? "a reference to " : "", what);
10202 if (operator_code == COND_EXPR)
10205 error ("ISO C++ prohibits overloading operator ?:");
10208 else if (ellipsis_p)
10210 error ("%qD must not have variable number of arguments", decl);
10213 else if (ambi_op_p (operator_code))
10216 /* We pick the one-argument operator codes by default, so
10217 we don't have to change anything. */
10219 else if (arity == 2)
10221 /* If we thought this was a unary operator, we now know
10222 it to be a binary operator. */
10223 switch (operator_code)
10226 operator_code = MULT_EXPR;
10230 operator_code = BIT_AND_EXPR;
10233 case UNARY_PLUS_EXPR:
10234 operator_code = PLUS_EXPR;
10238 operator_code = MINUS_EXPR;
10241 case PREINCREMENT_EXPR:
10242 operator_code = POSTINCREMENT_EXPR;
10245 case PREDECREMENT_EXPR:
10246 operator_code = POSTDECREMENT_EXPR;
10250 gcc_unreachable ();
10253 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
10255 if ((operator_code == POSTINCREMENT_EXPR
10256 || operator_code == POSTDECREMENT_EXPR)
10257 && ! processing_template_decl
10258 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
10261 error ("postfix %qD must take %<int%> as its argument",
10264 error ("postfix %qD must take %<int%> as its second "
10272 error ("%qD must take either zero or one argument", decl);
10274 error ("%qD must take either one or two arguments", decl);
10278 /* More Effective C++ rule 6. */
10280 && (operator_code == POSTINCREMENT_EXPR
10281 || operator_code == POSTDECREMENT_EXPR
10282 || operator_code == PREINCREMENT_EXPR
10283 || operator_code == PREDECREMENT_EXPR))
10285 tree arg = TREE_VALUE (argtypes);
10286 tree ret = TREE_TYPE (TREE_TYPE (decl));
10287 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
10288 arg = TREE_TYPE (arg);
10289 arg = TYPE_MAIN_VARIANT (arg);
10290 if (operator_code == PREINCREMENT_EXPR
10291 || operator_code == PREDECREMENT_EXPR)
10293 if (TREE_CODE (ret) != REFERENCE_TYPE
10294 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
10296 warning (OPT_Weffc__, "prefix %qD should return %qT", decl,
10297 build_reference_type (arg));
10301 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
10302 warning (OPT_Weffc__, "postfix %qD should return %qT", decl, arg);
10306 else if (unary_op_p (operator_code))
10311 error ("%qD must take %<void%>", decl);
10313 error ("%qD must take exactly one argument", decl);
10317 else /* if (binary_op_p (operator_code)) */
10322 error ("%qD must take exactly one argument", decl);
10324 error ("%qD must take exactly two arguments", decl);
10328 /* More Effective C++ rule 7. */
10330 && (operator_code == TRUTH_ANDIF_EXPR
10331 || operator_code == TRUTH_ORIF_EXPR
10332 || operator_code == COMPOUND_EXPR))
10333 warning (OPT_Weffc__, "user-defined %qD always evaluates both arguments",
10337 /* Effective C++ rule 23. */
10340 && !DECL_ASSIGNMENT_OPERATOR_P (decl)
10341 && (operator_code == PLUS_EXPR
10342 || operator_code == MINUS_EXPR
10343 || operator_code == TRUNC_DIV_EXPR
10344 || operator_code == MULT_EXPR
10345 || operator_code == TRUNC_MOD_EXPR)
10346 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
10347 warning (OPT_Weffc__, "%qD should return by value", decl);
10349 /* [over.oper]/8 */
10350 for (; argtypes && argtypes != void_list_node;
10351 argtypes = TREE_CHAIN (argtypes))
10352 if (TREE_PURPOSE (argtypes))
10354 TREE_PURPOSE (argtypes) = NULL_TREE;
10355 if (operator_code == POSTINCREMENT_EXPR
10356 || operator_code == POSTDECREMENT_EXPR)
10358 pedwarn (input_location, OPT_pedantic, "%qD cannot have default arguments",
10363 error ("%qD cannot have default arguments", decl);
10371 /* Return a string giving the keyword associate with CODE. */
10373 static const char *
10374 tag_name (enum tag_types code)
10386 case typename_type:
10389 gcc_unreachable ();
10393 /* Name lookup in an elaborated-type-specifier (after the keyword
10394 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
10395 elaborated-type-specifier is invalid, issue a diagnostic and return
10396 error_mark_node; otherwise, return the *_TYPE to which it referred.
10397 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
10400 check_elaborated_type_specifier (enum tag_types tag_code,
10402 bool allow_template_p)
10408 struct S { struct S *p; };
10410 name lookup will find the TYPE_DECL for the implicit "S::S"
10411 typedef. Adjust for that here. */
10412 if (DECL_SELF_REFERENCE_P (decl))
10413 decl = TYPE_NAME (TREE_TYPE (decl));
10415 type = TREE_TYPE (decl);
10417 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
10418 is false for this case as well. */
10419 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
10421 error ("using template type parameter %qT after %qs",
10422 type, tag_name (tag_code));
10423 return error_mark_node;
10427 If the identifier resolves to a typedef-name or a template
10428 type-parameter, the elaborated-type-specifier is ill-formed.
10430 In other words, the only legitimate declaration to use in the
10431 elaborated type specifier is the implicit typedef created when
10432 the type is declared. */
10433 else if (!DECL_IMPLICIT_TYPEDEF_P (decl)
10434 && tag_code != typename_type)
10436 error ("using typedef-name %qD after %qs", decl, tag_name (tag_code));
10437 error ("%q+D has a previous declaration here", decl);
10438 return error_mark_node;
10440 else if (TREE_CODE (type) != RECORD_TYPE
10441 && TREE_CODE (type) != UNION_TYPE
10442 && tag_code != enum_type
10443 && tag_code != typename_type)
10445 error ("%qT referred to as %qs", type, tag_name (tag_code));
10446 error ("%q+T has a previous declaration here", type);
10447 return error_mark_node;
10449 else if (TREE_CODE (type) != ENUMERAL_TYPE
10450 && tag_code == enum_type)
10452 error ("%qT referred to as enum", type);
10453 error ("%q+T has a previous declaration here", type);
10454 return error_mark_node;
10456 else if (!allow_template_p
10457 && TREE_CODE (type) == RECORD_TYPE
10458 && CLASSTYPE_IS_TEMPLATE (type))
10460 /* If a class template appears as elaborated type specifier
10461 without a template header such as:
10463 template <class T> class C {};
10464 void f(class C); // No template header here
10466 then the required template argument is missing. */
10467 error ("template argument required for %<%s %T%>",
10468 tag_name (tag_code),
10469 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
10470 return error_mark_node;
10476 /* Lookup NAME in elaborate type specifier in scope according to
10477 SCOPE and issue diagnostics if necessary.
10478 Return *_TYPE node upon success, NULL_TREE when the NAME is not
10479 found, and ERROR_MARK_NODE for type error. */
10482 lookup_and_check_tag (enum tag_types tag_code, tree name,
10483 tag_scope scope, bool template_header_p)
10487 if (scope == ts_global)
10489 /* First try ordinary name lookup, ignoring hidden class name
10490 injected via friend declaration. */
10491 decl = lookup_name_prefer_type (name, 2);
10492 /* If that fails, the name will be placed in the smallest
10493 non-class, non-function-prototype scope according to 3.3.1/5.
10494 We may already have a hidden name declared as friend in this
10495 scope. So lookup again but not ignoring hidden names.
10496 If we find one, that name will be made visible rather than
10497 creating a new tag. */
10499 decl = lookup_type_scope (name, ts_within_enclosing_non_class);
10502 decl = lookup_type_scope (name, scope);
10504 if (decl && DECL_CLASS_TEMPLATE_P (decl))
10505 decl = DECL_TEMPLATE_RESULT (decl);
10507 if (decl && TREE_CODE (decl) == TYPE_DECL)
10509 /* Look for invalid nested type:
10513 if (scope == ts_current && DECL_SELF_REFERENCE_P (decl))
10515 error ("%qD has the same name as the class in which it is "
10518 return error_mark_node;
10521 /* Two cases we need to consider when deciding if a class
10522 template is allowed as an elaborated type specifier:
10523 1. It is a self reference to its own class.
10524 2. It comes with a template header.
10528 template <class T> class C {
10529 class C *c1; // DECL_SELF_REFERENCE_P is true
10532 template <class U> class C; // template_header_p is true
10533 template <class T> class C<T>::D {
10534 class C *c2; // DECL_SELF_REFERENCE_P is true
10537 t = check_elaborated_type_specifier (tag_code,
10540 | DECL_SELF_REFERENCE_P (decl));
10543 else if (decl && TREE_CODE (decl) == TREE_LIST)
10545 error ("reference to %qD is ambiguous", name);
10546 print_candidates (decl);
10547 return error_mark_node;
10553 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
10554 Define the tag as a forward-reference if it is not defined.
10556 If a declaration is given, process it here, and report an error if
10557 multiple declarations are not identical.
10559 SCOPE is TS_CURRENT when this is also a definition. Only look in
10560 the current frame for the name (since C++ allows new names in any
10561 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
10562 declaration. Only look beginning from the current scope outward up
10563 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
10565 TEMPLATE_HEADER_P is true when this declaration is preceded by
10566 a set of template parameters. */
10569 xref_tag (enum tag_types tag_code, tree name,
10570 tag_scope scope, bool template_header_p)
10572 enum tree_code code;
10574 tree context = NULL_TREE;
10576 timevar_push (TV_NAME_LOOKUP);
10578 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
10584 code = RECORD_TYPE;
10590 code = ENUMERAL_TYPE;
10593 gcc_unreachable ();
10596 /* In case of anonymous name, xref_tag is only called to
10597 make type node and push name. Name lookup is not required. */
10598 if (ANON_AGGRNAME_P (name))
10601 t = lookup_and_check_tag (tag_code, name,
10602 scope, template_header_p);
10604 if (t == error_mark_node)
10605 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10607 if (scope != ts_current && t && current_class_type
10608 && template_class_depth (current_class_type)
10609 && template_header_p)
10611 /* Since SCOPE is not TS_CURRENT, we are not looking at a
10612 definition of this tag. Since, in addition, we are currently
10613 processing a (member) template declaration of a template
10614 class, we must be very careful; consider:
10621 { template <class V>
10622 friend struct S1; };
10624 Here, the S2::S1 declaration should not be confused with the
10625 outer declaration. In particular, the inner version should
10626 have a template parameter of level 2, not level 1. This
10627 would be particularly important if the member declaration
10630 template <class V = U> friend struct S1;
10632 say, when we should tsubst into `U' when instantiating
10633 S2. On the other hand, when presented with:
10643 we must find the inner binding eventually. We
10644 accomplish this by making sure that the new type we
10645 create to represent this declaration has the right
10647 context = TYPE_CONTEXT (t);
10653 /* If no such tag is yet defined, create a forward-reference node
10654 and record it as the "definition".
10655 When a real declaration of this type is found,
10656 the forward-reference will be altered into a real type. */
10657 if (code == ENUMERAL_TYPE)
10659 error ("use of enum %q#D without previous declaration", name);
10660 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10664 t = make_class_type (code);
10665 TYPE_CONTEXT (t) = context;
10666 t = pushtag (name, t, scope);
10671 if (template_header_p && MAYBE_CLASS_TYPE_P (t))
10673 if (!redeclare_class_template (t, current_template_parms))
10674 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10676 else if (!processing_template_decl
10677 && CLASS_TYPE_P (t)
10678 && CLASSTYPE_IS_TEMPLATE (t))
10680 error ("redeclaration of %qT as a non-template", t);
10681 error ("previous declaration %q+D", t);
10682 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10685 /* Make injected friend class visible. */
10686 if (scope != ts_within_enclosing_non_class
10687 && hidden_name_p (TYPE_NAME (t)))
10689 DECL_ANTICIPATED (TYPE_NAME (t)) = 0;
10690 DECL_FRIEND_P (TYPE_NAME (t)) = 0;
10692 if (TYPE_TEMPLATE_INFO (t))
10694 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t)) = 0;
10695 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t)) = 0;
10700 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
10704 xref_tag_from_type (tree old, tree id, tag_scope scope)
10706 enum tag_types tag_kind;
10708 if (TREE_CODE (old) == RECORD_TYPE)
10709 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
10711 tag_kind = union_type;
10713 if (id == NULL_TREE)
10714 id = TYPE_IDENTIFIER (old);
10716 return xref_tag (tag_kind, id, scope, false);
10719 /* Create the binfo hierarchy for REF with (possibly NULL) base list
10720 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
10721 access_* node, and the TREE_VALUE is the type of the base-class.
10722 Non-NULL TREE_TYPE indicates virtual inheritance.
10724 Returns true if the binfo hierarchy was successfully created,
10725 false if an error was detected. */
10728 xref_basetypes (tree ref, tree base_list)
10731 tree binfo, base_binfo;
10732 unsigned max_vbases = 0; /* Maximum direct & indirect virtual bases. */
10733 unsigned max_bases = 0; /* Maximum direct bases. */
10735 tree default_access;
10736 tree igo_prev; /* Track Inheritance Graph Order. */
10738 if (ref == error_mark_node)
10741 /* The base of a derived class is private by default, all others are
10743 default_access = (TREE_CODE (ref) == RECORD_TYPE
10744 && CLASSTYPE_DECLARED_CLASS (ref)
10745 ? access_private_node : access_public_node);
10747 /* First, make sure that any templates in base-classes are
10748 instantiated. This ensures that if we call ourselves recursively
10749 we do not get confused about which classes are marked and which
10751 basep = &base_list;
10754 tree basetype = TREE_VALUE (*basep);
10756 if (!(processing_template_decl && uses_template_parms (basetype))
10757 && !complete_type_or_else (basetype, NULL))
10758 /* An incomplete type. Remove it from the list. */
10759 *basep = TREE_CHAIN (*basep);
10763 if (TREE_TYPE (*basep))
10765 if (CLASS_TYPE_P (basetype))
10766 max_vbases += VEC_length (tree, CLASSTYPE_VBASECLASSES (basetype));
10767 basep = &TREE_CHAIN (*basep);
10771 TYPE_MARKED_P (ref) = 1;
10773 /* The binfo slot should be empty, unless this is an (ill-formed)
10775 gcc_assert (!TYPE_BINFO (ref) || TYPE_SIZE (ref));
10776 gcc_assert (TYPE_MAIN_VARIANT (ref) == ref);
10778 binfo = make_tree_binfo (max_bases);
10780 TYPE_BINFO (ref) = binfo;
10781 BINFO_OFFSET (binfo) = size_zero_node;
10782 BINFO_TYPE (binfo) = ref;
10784 /* Apply base-class info set up to the variants of this type. */
10785 fixup_type_variants (ref);
10789 BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, gc, max_bases);
10790 /* An aggregate cannot have baseclasses. */
10791 CLASSTYPE_NON_AGGREGATE (ref) = 1;
10793 if (TREE_CODE (ref) == UNION_TYPE)
10795 error ("derived union %qT invalid", ref);
10802 if (TYPE_FOR_JAVA (ref))
10804 error ("Java class %qT cannot have multiple bases", ref);
10811 CLASSTYPE_VBASECLASSES (ref) = VEC_alloc (tree, gc, max_vbases);
10813 if (TYPE_FOR_JAVA (ref))
10815 error ("Java class %qT cannot have virtual bases", ref);
10820 for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list))
10822 tree access = TREE_PURPOSE (base_list);
10823 int via_virtual = TREE_TYPE (base_list) != NULL_TREE;
10824 tree basetype = TREE_VALUE (base_list);
10826 if (access == access_default_node)
10827 access = default_access;
10829 if (PACK_EXPANSION_P (basetype))
10830 basetype = PACK_EXPANSION_PATTERN (basetype);
10831 if (TREE_CODE (basetype) == TYPE_DECL)
10832 basetype = TREE_TYPE (basetype);
10833 if (!MAYBE_CLASS_TYPE_P (basetype) || TREE_CODE (basetype) == UNION_TYPE)
10835 error ("base type %qT fails to be a struct or class type",
10840 if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0))
10841 TYPE_FOR_JAVA (ref) = 1;
10843 base_binfo = NULL_TREE;
10844 if (CLASS_TYPE_P (basetype) && !dependent_type_p (basetype))
10846 base_binfo = TYPE_BINFO (basetype);
10847 /* The original basetype could have been a typedef'd type. */
10848 basetype = BINFO_TYPE (base_binfo);
10850 /* Inherit flags from the base. */
10851 TYPE_HAS_NEW_OPERATOR (ref)
10852 |= TYPE_HAS_NEW_OPERATOR (basetype);
10853 TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
10854 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
10855 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
10856 TYPE_HAS_CONVERSION (ref) |= TYPE_HAS_CONVERSION (basetype);
10857 CLASSTYPE_DIAMOND_SHAPED_P (ref)
10858 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype);
10859 CLASSTYPE_REPEATED_BASE_P (ref)
10860 |= CLASSTYPE_REPEATED_BASE_P (basetype);
10863 /* We must do this test after we've seen through a typedef
10865 if (TYPE_MARKED_P (basetype))
10867 if (basetype == ref)
10868 error ("recursive type %qT undefined", basetype);
10870 error ("duplicate base type %qT invalid", basetype);
10874 if (PACK_EXPANSION_P (TREE_VALUE (base_list)))
10875 /* Regenerate the pack expansion for the bases. */
10876 basetype = make_pack_expansion (basetype);
10878 TYPE_MARKED_P (basetype) = 1;
10880 base_binfo = copy_binfo (base_binfo, basetype, ref,
10881 &igo_prev, via_virtual);
10882 if (!BINFO_INHERITANCE_CHAIN (base_binfo))
10883 BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
10885 BINFO_BASE_APPEND (binfo, base_binfo);
10886 BINFO_BASE_ACCESS_APPEND (binfo, access);
10889 if (VEC_space (tree, CLASSTYPE_VBASECLASSES (ref), 1))
10890 /* If we have space in the vbase vector, we must have shared at
10891 least one of them, and are therefore diamond shaped. */
10892 CLASSTYPE_DIAMOND_SHAPED_P (ref) = 1;
10894 /* Unmark all the types. */
10895 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
10896 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
10897 TYPE_MARKED_P (ref) = 0;
10899 /* Now see if we have a repeated base type. */
10900 if (!CLASSTYPE_REPEATED_BASE_P (ref))
10902 for (base_binfo = binfo; base_binfo;
10903 base_binfo = TREE_CHAIN (base_binfo))
10905 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
10907 CLASSTYPE_REPEATED_BASE_P (ref) = 1;
10910 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 1;
10912 for (base_binfo = binfo; base_binfo;
10913 base_binfo = TREE_CHAIN (base_binfo))
10914 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
10915 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
10924 /* Begin compiling the definition of an enumeration type.
10927 UNDERLYING_TYPE is the type that will be used as the storage for
10928 the enumeration type. This should be NULL_TREE if no storage type
10931 SCOPED_ENUM_P is true if this is a scoped enumeration type.
10933 Returns the type object, as yet incomplete.
10934 Also records info about it so that build_enumerator
10935 may be used to declare the individual values as they are read. */
10938 start_enum (tree name, tree underlying_type, bool scoped_enum_p)
10942 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
10944 /* If this is the real definition for a previous forward reference,
10945 fill in the contents in the same object that used to be the
10946 forward reference. */
10948 enumtype = lookup_and_check_tag (enum_type, name,
10949 /*tag_scope=*/ts_current,
10950 /*template_header_p=*/false);
10952 if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
10954 error ("multiple definition of %q#T", enumtype);
10955 error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype));
10956 /* Clear out TYPE_VALUES, and start again. */
10957 TYPE_VALUES (enumtype) = NULL_TREE;
10961 /* In case of error, make a dummy enum to allow parsing to
10963 if (enumtype == error_mark_node)
10964 name = make_anon_name ();
10966 enumtype = make_node (ENUMERAL_TYPE);
10967 enumtype = pushtag (name, enumtype, /*tag_scope=*/ts_current);
10970 if (enumtype == error_mark_node)
10975 SET_SCOPED_ENUM_P (enumtype, 1);
10976 begin_scope (sk_scoped_enum, enumtype);
10978 /* [C++0x dcl.enum]p5:
10980 If not explicitly specified, the underlying type of a scoped
10981 enumeration type is int. */
10982 if (!underlying_type)
10983 underlying_type = integer_type_node;
10986 if (underlying_type)
10988 if (CP_INTEGRAL_TYPE_P (underlying_type))
10990 TYPE_MIN_VALUE (enumtype) = TYPE_MIN_VALUE (underlying_type);
10991 TYPE_MAX_VALUE (enumtype) = TYPE_MAX_VALUE (underlying_type);
10992 TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
10993 TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
10994 SET_TYPE_MODE (enumtype, TYPE_MODE (underlying_type));
10995 TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type);
10996 TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
10997 TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
10998 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);
10999 ENUM_UNDERLYING_TYPE (enumtype) = underlying_type;
11002 error ("underlying type %<%T%> of %<%T%> must be an integral type",
11003 underlying_type, enumtype);
11009 /* After processing and defining all the values of an enumeration type,
11010 install their decls in the enumeration type and finish it off.
11011 ENUMTYPE is the type object and VALUES a list of name-value pairs. */
11014 finish_enum (tree enumtype)
11023 bool use_short_enum;
11027 integer_type_kind itk;
11028 tree underlying_type = NULL_TREE;
11029 bool fixed_underlying_type_p
11030 = ENUM_UNDERLYING_TYPE (enumtype) != NULL_TREE;
11032 /* We built up the VALUES in reverse order. */
11033 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
11035 /* For an enum defined in a template, just set the type of the values;
11036 all further processing is postponed until the template is
11037 instantiated. We need to set the type so that tsubst of a CONST_DECL
11039 if (processing_template_decl)
11041 for (values = TYPE_VALUES (enumtype);
11043 values = TREE_CHAIN (values))
11044 TREE_TYPE (TREE_VALUE (values)) = enumtype;
11045 if (at_function_scope_p ())
11046 add_stmt (build_min (TAG_DEFN, enumtype));
11050 /* Determine the minimum and maximum values of the enumerators. */
11051 if (TYPE_VALUES (enumtype))
11053 minnode = maxnode = NULL_TREE;
11055 for (values = TYPE_VALUES (enumtype);
11057 values = TREE_CHAIN (values))
11059 decl = TREE_VALUE (values);
11061 /* [dcl.enum]: Following the closing brace of an enum-specifier,
11062 each enumerator has the type of its enumeration. Prior to the
11063 closing brace, the type of each enumerator is the type of its
11064 initializing value. */
11065 TREE_TYPE (decl) = enumtype;
11067 /* Update the minimum and maximum values, if appropriate. */
11068 value = DECL_INITIAL (decl);
11069 if (value == error_mark_node)
11070 value = integer_zero_node;
11071 /* Figure out what the minimum and maximum values of the
11072 enumerators are. */
11074 minnode = maxnode = value;
11075 else if (tree_int_cst_lt (maxnode, value))
11077 else if (tree_int_cst_lt (value, minnode))
11084 If the enumerator-list is empty, the underlying type is as if
11085 the enumeration had a single enumerator with value 0. */
11086 minnode = maxnode = integer_zero_node;
11088 /* Compute the number of bits require to represent all values of the
11089 enumeration. We must do this before the type of MINNODE and
11090 MAXNODE are transformed, since tree_int_cst_min_precision relies
11091 on the TREE_TYPE of the value it is passed. */
11092 unsignedp = tree_int_cst_sgn (minnode) >= 0;
11093 lowprec = tree_int_cst_min_precision (minnode, unsignedp);
11094 highprec = tree_int_cst_min_precision (maxnode, unsignedp);
11095 precision = MAX (lowprec, highprec);
11097 if (!fixed_underlying_type_p)
11099 /* Determine the underlying type of the enumeration.
11103 The underlying type of an enumeration is an integral type that
11104 can represent all the enumerator values defined in the
11105 enumeration. It is implementation-defined which integral type is
11106 used as the underlying type for an enumeration except that the
11107 underlying type shall not be larger than int unless the value of
11108 an enumerator cannot fit in an int or unsigned int.
11110 We use "int" or an "unsigned int" as the underlying type, even if
11111 a smaller integral type would work, unless the user has
11112 explicitly requested that we use the smallest possible type. The
11113 user can request that for all enumerations with a command line
11114 flag, or for just one enumeration with an attribute. */
11116 use_short_enum = flag_short_enums
11117 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype));
11119 for (itk = (use_short_enum ? itk_char : itk_int);
11123 underlying_type = integer_types[itk];
11124 if (TYPE_PRECISION (underlying_type) >= precision
11125 && TYPE_UNSIGNED (underlying_type) == unsignedp)
11128 if (itk == itk_none)
11132 IF no integral type can represent all the enumerator values, the
11133 enumeration is ill-formed. */
11134 error ("no integral type can represent all of the enumerator values "
11135 "for %qT", enumtype);
11136 precision = TYPE_PRECISION (long_long_integer_type_node);
11137 underlying_type = integer_types[itk_unsigned_long_long];
11142 The value of sizeof() applied to an enumeration type, an object
11143 of an enumeration type, or an enumerator, is the value of sizeof()
11144 applied to the underlying type. */
11145 TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
11146 TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
11147 SET_TYPE_MODE (enumtype, TYPE_MODE (underlying_type));
11148 TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
11149 TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
11150 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);
11152 /* Set the underlying type of the enumeration type to the
11153 computed enumeration type, restricted to the enumerator
11155 ENUM_UNDERLYING_TYPE (enumtype) = copy_node (underlying_type);
11156 set_min_and_max_values_for_integral_type
11157 (ENUM_UNDERLYING_TYPE (enumtype), precision, unsignedp);
11160 underlying_type = ENUM_UNDERLYING_TYPE (enumtype);
11162 /* Compute the minimum and maximum values for the type.
11166 For an enumeration where emin is the smallest enumerator and emax
11167 is the largest, the values of the enumeration are the values of the
11168 underlying type in the range bmin to bmax, where bmin and bmax are,
11169 respectively, the smallest and largest values of the smallest bit-
11170 field that can store emin and emax. */
11172 /* The middle-end currently assumes that types with TYPE_PRECISION
11173 narrower than their underlying type are suitably zero or sign
11174 extended to fill their mode. g++ doesn't make these guarantees.
11175 Until the middle-end can represent such paradoxical types, we
11176 set the TYPE_PRECISION to the width of the underlying type. */
11177 TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type);
11179 set_min_and_max_values_for_integral_type (enumtype, precision, unsignedp);
11181 /* Convert each of the enumerators to the type of the underlying
11182 type of the enumeration. */
11183 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
11185 location_t saved_location;
11187 decl = TREE_VALUE (values);
11188 saved_location = input_location;
11189 input_location = DECL_SOURCE_LOCATION (decl);
11190 if (fixed_underlying_type_p)
11191 /* If the enumeration type has a fixed underlying type, we
11192 already checked all of the enumerator values. */
11193 value = DECL_INITIAL (decl);
11195 value = perform_implicit_conversion (underlying_type,
11196 DECL_INITIAL (decl),
11197 tf_warning_or_error);
11198 input_location = saved_location;
11200 /* Do not clobber shared ints. */
11201 value = copy_node (value);
11203 TREE_TYPE (value) = enumtype;
11204 DECL_INITIAL (decl) = value;
11207 /* Fix up all variant types of this enum type. */
11208 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
11210 TYPE_VALUES (t) = TYPE_VALUES (enumtype);
11211 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
11212 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
11213 TYPE_SIZE (t) = TYPE_SIZE (enumtype);
11214 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
11215 SET_TYPE_MODE (t, TYPE_MODE (enumtype));
11216 TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
11217 TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
11218 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
11219 TYPE_UNSIGNED (t) = TYPE_UNSIGNED (enumtype);
11220 ENUM_UNDERLYING_TYPE (t) = ENUM_UNDERLYING_TYPE (enumtype);
11223 /* Finish up the scope of a scoped enumeration. */
11224 if (SCOPED_ENUM_P (enumtype))
11227 /* Finish debugging output for this type. */
11228 rest_of_type_compilation (enumtype, namespace_bindings_p ());
11231 /* Build and install a CONST_DECL for an enumeration constant of the
11232 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
11233 Assignment of sequential values by default is handled here. */
11236 build_enumerator (tree name, tree value, tree enumtype)
11242 /* If the VALUE was erroneous, pretend it wasn't there; that will
11243 result in the enum being assigned the next value in sequence. */
11244 if (value == error_mark_node)
11247 /* Remove no-op casts from the value. */
11249 STRIP_TYPE_NOPS (value);
11251 if (! processing_template_decl)
11253 /* Validate and default VALUE. */
11254 if (value != NULL_TREE)
11256 value = integral_constant_value (value);
11258 if (TREE_CODE (value) == INTEGER_CST)
11260 value = perform_integral_promotions (value);
11261 constant_expression_warning (value);
11265 error ("enumerator value for %qD is not an integer constant", name);
11270 /* Default based on previous value. */
11271 if (value == NULL_TREE)
11273 if (TYPE_VALUES (enumtype))
11276 unsigned HOST_WIDE_INT lo;
11280 /* The next value is the previous value plus one.
11281 add_double doesn't know the type of the target expression,
11282 so we must check with int_fits_type_p as well. */
11283 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
11284 if (error_operand_p (prev_value))
11285 value = error_mark_node;
11288 overflowed = add_double (TREE_INT_CST_LOW (prev_value),
11289 TREE_INT_CST_HIGH (prev_value),
11291 value = build_int_cst_wide (TREE_TYPE (prev_value), lo, hi);
11293 |= !int_fits_type_p (value, TREE_TYPE (prev_value));
11297 error ("overflow in enumeration values at %qD", name);
11298 value = error_mark_node;
11303 value = integer_zero_node;
11306 /* Remove no-op casts from the value. */
11307 STRIP_TYPE_NOPS (value);
11309 /* If the underlying type of the enum is fixed, check whether
11310 the enumerator values fits in the underlying type. If it
11311 does not fit, the program is ill-formed [C++0x dcl.enum]. */
11312 if (ENUM_UNDERLYING_TYPE (enumtype)
11314 && TREE_CODE (value) == INTEGER_CST
11315 && !int_fits_type_p (value, ENUM_UNDERLYING_TYPE (enumtype)))
11317 error ("enumerator value %E is too large for underlying type %<%T%>",
11318 value, ENUM_UNDERLYING_TYPE (enumtype));
11320 /* Silently convert the value so that we can continue. */
11321 value = perform_implicit_conversion (ENUM_UNDERLYING_TYPE (enumtype),
11326 /* C++ associates enums with global, function, or class declarations. */
11327 context = current_scope ();
11329 /* Build the actual enumeration constant. Note that the enumeration
11330 constants have the underlying type of the enum (if it is fixed)
11331 or the type of their initializer (if the underlying type of the
11332 enum is not fixed):
11336 If the underlying type is fixed, the type of each enumerator
11337 prior to the closing brace is the underlying type; if the
11338 initializing value of an enumerator cannot be represented by
11339 the underlying type, the program is ill-formed. If the
11340 underlying type is not fixed, the type of each enumerator is
11341 the type of its initializing value.
11343 If the underlying type is not fixed, it will be computed by
11344 finish_enum and we will reset the type of this enumerator. Of
11345 course, if we're processing a template, there may be no value. */
11346 type = value ? TREE_TYPE (value) : NULL_TREE;
11348 if (context && context == current_class_type)
11349 /* This enum declaration is local to the class. We need the full
11350 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
11351 decl = build_lang_decl (CONST_DECL, name, type);
11353 /* It's a global enum, or it's local to a function. (Note local to
11354 a function could mean local to a class method. */
11355 decl = build_decl (CONST_DECL, name, type);
11357 DECL_CONTEXT (decl) = FROB_CONTEXT (context);
11358 TREE_CONSTANT (decl) = 1;
11359 TREE_READONLY (decl) = 1;
11360 DECL_INITIAL (decl) = value;
11362 if (context && context == current_class_type)
11363 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
11364 on the TYPE_FIELDS list for `S'. (That's so that you can say
11365 things like `S::i' later.) */
11366 finish_member_declaration (decl);
11370 /* Add this enumeration constant to the list for this type. */
11371 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
11374 /* Look for an enumerator with the given NAME within the enumeration
11375 type ENUMTYPE. This routine is used primarily for qualified name
11376 lookup into an enumerator in C++0x, e.g.,
11378 enum class Color { Red, Green, Blue };
11380 Color color = Color::Red;
11382 Returns the value corresponding to the enumerator, or
11383 NULL_TREE if no such enumerator was found. */
11385 lookup_enumerator (tree enumtype, tree name)
11388 gcc_assert (enumtype && TREE_CODE (enumtype) == ENUMERAL_TYPE);
11390 e = purpose_member (name, TYPE_VALUES (enumtype));
11391 return e? TREE_VALUE (e) : NULL_TREE;
11395 /* We're defining DECL. Make sure that it's type is OK. */
11398 check_function_type (tree decl, tree current_function_parms)
11400 tree fntype = TREE_TYPE (decl);
11401 tree return_type = complete_type (TREE_TYPE (fntype));
11403 /* In a function definition, arg types must be complete. */
11404 require_complete_types_for_parms (current_function_parms);
11406 if (dependent_type_p (return_type))
11408 if (!COMPLETE_OR_VOID_TYPE_P (return_type)
11409 || (TYPE_FOR_JAVA (return_type) && MAYBE_CLASS_TYPE_P (return_type)))
11411 tree args = TYPE_ARG_TYPES (fntype);
11413 if (!COMPLETE_OR_VOID_TYPE_P (return_type))
11414 error ("return type %q#T is incomplete", return_type);
11416 error ("return type has Java class type %q#T", return_type);
11418 /* Make it return void instead. */
11419 if (TREE_CODE (fntype) == METHOD_TYPE)
11420 fntype = build_method_type_directly (TREE_TYPE (TREE_VALUE (args)),
11422 TREE_CHAIN (args));
11424 fntype = build_function_type (void_type_node, args);
11426 = build_exception_variant (fntype,
11427 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)));
11430 abstract_virtuals_error (decl, TREE_TYPE (fntype));
11433 /* Create the FUNCTION_DECL for a function definition.
11434 DECLSPECS and DECLARATOR are the parts of the declaration;
11435 they describe the function's name and the type it returns,
11436 but twisted together in a fashion that parallels the syntax of C.
11438 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
11439 DECLARATOR is really the DECL for the function we are about to
11440 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
11441 indicating that the function is an inline defined in-class.
11443 This function creates a binding context for the function body
11444 as well as setting up the FUNCTION_DECL in current_function_decl.
11446 For C++, we must first check whether that datum makes any sense.
11447 For example, "class A local_a(1,2);" means that variable local_a
11448 is an aggregate of type A, which should have a constructor
11449 applied to it with the argument list [1, 2].
11451 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
11452 or may be a BLOCK if the function has been defined previously
11453 in this translation unit. On exit, DECL_INITIAL (decl1) will be
11454 error_mark_node if the function has never been defined, or
11455 a BLOCK if the function has been defined somewhere. */
11458 start_preparsed_function (tree decl1, tree attrs, int flags)
11460 tree ctype = NULL_TREE;
11463 int doing_friend = 0;
11464 struct cp_binding_level *bl;
11465 tree current_function_parms;
11466 struct c_fileinfo *finfo
11467 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1)));
11468 bool honor_interface;
11470 /* Sanity check. */
11471 gcc_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE);
11472 gcc_assert (TREE_CHAIN (void_list_node) == NULL_TREE);
11474 fntype = TREE_TYPE (decl1);
11475 if (TREE_CODE (fntype) == METHOD_TYPE)
11476 ctype = TYPE_METHOD_BASETYPE (fntype);
11478 /* ISO C++ 11.4/5. A friend function defined in a class is in
11479 the (lexical) scope of the class in which it is defined. */
11480 if (!ctype && DECL_FRIEND_P (decl1))
11482 ctype = DECL_FRIEND_CONTEXT (decl1);
11484 /* CTYPE could be null here if we're dealing with a template;
11485 for example, `inline friend float foo()' inside a template
11486 will have no CTYPE set. */
11487 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
11493 if (DECL_DECLARED_INLINE_P (decl1)
11494 && lookup_attribute ("noinline", attrs))
11495 warning (0, "inline function %q+D given attribute noinline", decl1);
11497 /* Handle gnu_inline attribute. */
11498 if (GNU_INLINE_P (decl1))
11500 DECL_EXTERNAL (decl1) = 1;
11501 DECL_NOT_REALLY_EXTERN (decl1) = 0;
11502 DECL_INTERFACE_KNOWN (decl1) = 1;
11503 DECL_DISREGARD_INLINE_LIMITS (decl1) = 1;
11506 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
11507 /* This is a constructor, we must ensure that any default args
11508 introduced by this definition are propagated to the clones
11509 now. The clones are used directly in overload resolution. */
11510 adjust_clone_args (decl1);
11512 /* Sometimes we don't notice that a function is a static member, and
11513 build a METHOD_TYPE for it. Fix that up now. */
11514 if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
11515 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
11517 revert_static_member_fn (decl1);
11521 /* Set up current_class_type, and enter the scope of the class, if
11524 push_nested_class (ctype);
11525 else if (DECL_STATIC_FUNCTION_P (decl1))
11526 push_nested_class (DECL_CONTEXT (decl1));
11528 /* Now that we have entered the scope of the class, we must restore
11529 the bindings for any template parameters surrounding DECL1, if it
11530 is an inline member template. (Order is important; consider the
11531 case where a template parameter has the same name as a field of
11532 the class.) It is not until after this point that
11533 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
11534 if (flags & SF_INCLASS_INLINE)
11535 maybe_begin_member_template_processing (decl1);
11537 /* Effective C++ rule 15. */
11539 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
11540 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
11541 warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");
11543 /* Make the init_value nonzero so pushdecl knows this is not tentative.
11544 error_mark_node is replaced below (in poplevel) with the BLOCK. */
11545 if (!DECL_INITIAL (decl1))
11546 DECL_INITIAL (decl1) = error_mark_node;
11548 /* This function exists in static storage.
11549 (This does not mean `static' in the C sense!) */
11550 TREE_STATIC (decl1) = 1;
11552 /* We must call push_template_decl after current_class_type is set
11553 up. (If we are processing inline definitions after exiting a
11554 class scope, current_class_type will be NULL_TREE until set above
11555 by push_nested_class.) */
11556 if (processing_template_decl)
11558 /* FIXME: Handle error_mark_node more gracefully. */
11559 tree newdecl1 = push_template_decl (decl1);
11560 if (newdecl1 != error_mark_node)
11564 /* We are now in the scope of the function being defined. */
11565 current_function_decl = decl1;
11567 /* Save the parm names or decls from this function's declarator
11568 where store_parm_decls will find them. */
11569 current_function_parms = DECL_ARGUMENTS (decl1);
11571 /* Make sure the parameter and return types are reasonable. When
11572 you declare a function, these types can be incomplete, but they
11573 must be complete when you define the function. */
11574 check_function_type (decl1, current_function_parms);
11576 /* Build the return declaration for the function. */
11577 restype = TREE_TYPE (fntype);
11578 if (DECL_RESULT (decl1) == NULL_TREE)
11582 resdecl = build_decl (RESULT_DECL, 0, restype);
11583 DECL_ARTIFICIAL (resdecl) = 1;
11584 DECL_IGNORED_P (resdecl) = 1;
11585 DECL_RESULT (decl1) = resdecl;
11587 cp_apply_type_quals_to_decl (cp_type_quals (restype), resdecl);
11590 /* Let the user know we're compiling this function. */
11591 announce_function (decl1);
11593 /* Record the decl so that the function name is defined.
11594 If we already have a decl for this name, and it is a FUNCTION_DECL,
11595 use the old decl. */
11596 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
11598 /* A specialization is not used to guide overload resolution. */
11599 if (!DECL_FUNCTION_MEMBER_P (decl1)
11600 && !(DECL_USE_TEMPLATE (decl1) &&
11601 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1))))
11603 tree olddecl = pushdecl (decl1);
11605 if (olddecl == error_mark_node)
11606 /* If something went wrong when registering the declaration,
11607 use DECL1; we have to have a FUNCTION_DECL to use when
11608 parsing the body of the function. */
11612 /* Otherwise, OLDDECL is either a previous declaration
11613 of the same function or DECL1 itself. */
11615 if (warn_missing_declarations
11616 && olddecl == decl1
11617 && !DECL_MAIN_P (decl1)
11618 && TREE_PUBLIC (decl1)
11619 && !DECL_DECLARED_INLINE_P (decl1))
11623 /* Check whether DECL1 is in an anonymous
11625 for (context = DECL_CONTEXT (decl1);
11627 context = DECL_CONTEXT (context))
11629 if (TREE_CODE (context) == NAMESPACE_DECL
11630 && DECL_NAME (context) == NULL_TREE)
11634 if (context == NULL)
11635 warning (OPT_Wmissing_declarations,
11636 "no previous declaration for %q+D", decl1);
11644 /* We need to set the DECL_CONTEXT. */
11645 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
11646 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
11648 fntype = TREE_TYPE (decl1);
11650 /* If #pragma weak applies, mark the decl appropriately now.
11651 The pragma only applies to global functions. Because
11652 determining whether or not the #pragma applies involves
11653 computing the mangled name for the declaration, we cannot
11654 apply the pragma until after we have merged this declaration
11655 with any previous declarations; if the original declaration
11656 has a linkage specification, that specification applies to
11657 the definition as well, and may affect the mangled name. */
11658 if (!DECL_CONTEXT (decl1))
11659 maybe_apply_pragma_weak (decl1);
11662 /* Reset this in case the call to pushdecl changed it. */
11663 current_function_decl = decl1;
11665 gcc_assert (DECL_INITIAL (decl1));
11667 /* This function may already have been parsed, in which case just
11668 return; our caller will skip over the body without parsing. */
11669 if (DECL_INITIAL (decl1) != error_mark_node)
11672 /* Initialize RTL machinery. We cannot do this until
11673 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
11674 even when processing a template; this is how we get
11675 CFUN set up, and our per-function variables initialized.
11676 FIXME factor out the non-RTL stuff. */
11677 bl = current_binding_level;
11678 allocate_struct_function (decl1, processing_template_decl);
11680 /* Initialize the language data structures. Whenever we start
11681 a new function, we destroy temporaries in the usual way. */
11682 cfun->language = GGC_CNEW (struct language_function);
11683 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
11684 current_binding_level = bl;
11686 /* Even though we're inside a function body, we still don't want to
11687 call expand_expr to calculate the size of a variable-sized array.
11688 We haven't necessarily assigned RTL to all variables yet, so it's
11689 not safe to try to expand expressions involving them. */
11690 cfun->dont_save_pending_sizes_p = 1;
11692 /* Start the statement-tree, start the tree now. */
11693 DECL_SAVED_TREE (decl1) = push_stmt_list ();
11695 /* If we are (erroneously) defining a function that we have already
11696 defined before, wipe out what we knew before. */
11697 if (!DECL_PENDING_INLINE_P (decl1))
11698 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
11700 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
11702 /* We know that this was set up by `grokclassfn'. We do not
11703 wait until `store_parm_decls', since evil parse errors may
11704 never get us to that point. Here we keep the consistency
11705 between `current_class_type' and `current_class_ptr'. */
11706 tree t = DECL_ARGUMENTS (decl1);
11708 gcc_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL);
11709 gcc_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE);
11711 cp_function_chain->x_current_class_ref
11712 = cp_build_indirect_ref (t, NULL, tf_warning_or_error);
11713 cp_function_chain->x_current_class_ptr = t;
11715 /* Constructors and destructors need to know whether they're "in
11716 charge" of initializing virtual base classes. */
11717 t = TREE_CHAIN (t);
11718 if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
11720 current_in_charge_parm = t;
11721 t = TREE_CHAIN (t);
11723 if (DECL_HAS_VTT_PARM_P (decl1))
11725 gcc_assert (DECL_NAME (t) == vtt_parm_identifier);
11726 current_vtt_parm = t;
11730 honor_interface = (!DECL_TEMPLATE_INSTANTIATION (decl1)
11731 /* Implicitly-defined methods (like the
11732 destructor for a class in which no destructor
11733 is explicitly declared) must not be defined
11734 until their definition is needed. So, we
11735 ignore interface specifications for
11736 compiler-generated functions. */
11737 && !DECL_ARTIFICIAL (decl1));
11739 if (DECL_INTERFACE_KNOWN (decl1))
11741 tree ctx = decl_function_context (decl1);
11743 if (DECL_NOT_REALLY_EXTERN (decl1))
11744 DECL_EXTERNAL (decl1) = 0;
11746 if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
11747 && TREE_PUBLIC (ctx))
11748 /* This is a function in a local class in an extern inline
11750 comdat_linkage (decl1);
11752 /* If this function belongs to an interface, it is public.
11753 If it belongs to someone else's interface, it is also external.
11754 This only affects inlines and template instantiations. */
11755 else if (!finfo->interface_unknown && honor_interface)
11757 if (DECL_DECLARED_INLINE_P (decl1)
11758 || DECL_TEMPLATE_INSTANTIATION (decl1)
11759 || processing_template_decl)
11761 DECL_EXTERNAL (decl1)
11762 = (finfo->interface_only
11763 || (DECL_DECLARED_INLINE_P (decl1)
11764 && ! flag_implement_inlines
11765 && !DECL_VINDEX (decl1)));
11767 /* For WIN32 we also want to put these in linkonce sections. */
11768 maybe_make_one_only (decl1);
11771 DECL_EXTERNAL (decl1) = 0;
11772 DECL_INTERFACE_KNOWN (decl1) = 1;
11773 /* If this function is in an interface implemented in this file,
11774 make sure that the back end knows to emit this function
11776 if (!DECL_EXTERNAL (decl1))
11777 mark_needed (decl1);
11779 else if (finfo->interface_unknown && finfo->interface_only
11780 && honor_interface)
11782 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
11783 interface, we will have both finfo->interface_unknown and
11784 finfo->interface_only set. In that case, we don't want to
11785 use the normal heuristics because someone will supply a
11786 #pragma implementation elsewhere, and deducing it here would
11787 produce a conflict. */
11788 comdat_linkage (decl1);
11789 DECL_EXTERNAL (decl1) = 0;
11790 DECL_INTERFACE_KNOWN (decl1) = 1;
11791 DECL_DEFER_OUTPUT (decl1) = 1;
11795 /* This is a definition, not a reference.
11796 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
11797 if (!GNU_INLINE_P (decl1))
11798 DECL_EXTERNAL (decl1) = 0;
11800 if ((DECL_DECLARED_INLINE_P (decl1)
11801 || DECL_TEMPLATE_INSTANTIATION (decl1))
11802 && ! DECL_INTERFACE_KNOWN (decl1)
11803 /* Don't try to defer nested functions for now. */
11804 && ! decl_function_context (decl1))
11805 DECL_DEFER_OUTPUT (decl1) = 1;
11807 DECL_INTERFACE_KNOWN (decl1) = 1;
11810 /* Determine the ELF visibility attribute for the function. We must not
11811 do this before calling "pushdecl", as we must allow "duplicate_decls"
11812 to merge any attributes appropriately. We also need to wait until
11814 if (!DECL_CLONED_FUNCTION_P (decl1))
11815 determine_visibility (decl1);
11817 begin_scope (sk_function_parms, decl1);
11821 if (DECL_DESTRUCTOR_P (decl1)
11822 || (DECL_CONSTRUCTOR_P (decl1)
11823 && targetm.cxx.cdtor_returns_this ()))
11825 cdtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
11826 DECL_CONTEXT (cdtor_label) = current_function_decl;
11829 start_fname_decls ();
11831 store_parm_decls (current_function_parms);
11835 /* Like start_preparsed_function, except that instead of a
11836 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
11838 Returns 1 on success. If the DECLARATOR is not suitable for a function
11839 (it defines a datum instead), we return 0, which tells
11840 yyparse to report a parse error. */
11843 start_function (cp_decl_specifier_seq *declspecs,
11844 const cp_declarator *declarator,
11849 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
11850 if (decl1 == error_mark_node)
11852 /* If the declarator is not suitable for a function definition,
11853 cause a syntax error. */
11854 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
11856 error ("invalid function declaration");
11860 if (DECL_MAIN_P (decl1))
11861 /* main must return int. grokfndecl should have corrected it
11862 (and issued a diagnostic) if the user got it wrong. */
11863 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1)),
11864 integer_type_node));
11866 start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT);
11871 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
11875 use_eh_spec_block (tree fn)
11877 return (flag_exceptions && flag_enforce_eh_specs
11878 && !processing_template_decl
11879 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn))
11880 /* We insert the EH_SPEC_BLOCK only in the original
11881 function; then, it is copied automatically to the
11883 && !DECL_CLONED_FUNCTION_P (fn)
11884 /* Implicitly-generated constructors and destructors have
11885 exception specifications. However, those specifications
11886 are the union of the possible exceptions specified by the
11887 constructors/destructors for bases and members, so no
11888 unallowed exception will ever reach this function. By
11889 not creating the EH_SPEC_BLOCK we save a little memory,
11890 and we avoid spurious warnings about unreachable
11892 && !DECL_ARTIFICIAL (fn));
11895 /* Store the parameter declarations into the current function declaration.
11896 This is called after parsing the parameter declarations, before
11897 digesting the body of the function.
11899 Also install to binding contour return value identifier, if any. */
11902 store_parm_decls (tree current_function_parms)
11904 tree fndecl = current_function_decl;
11907 /* This is a chain of any other decls that came in among the parm
11908 declarations. If a parm is declared with enum {foo, bar} x;
11909 then CONST_DECLs for foo and bar are put here. */
11910 tree nonparms = NULL_TREE;
11912 if (current_function_parms)
11914 /* This case is when the function was defined with an ANSI prototype.
11915 The parms already have decls, so we need not do anything here
11916 except record them as in effect
11917 and complain if any redundant old-style parm decls were written. */
11919 tree specparms = current_function_parms;
11922 /* Must clear this because it might contain TYPE_DECLs declared
11924 current_binding_level->names = NULL;
11926 /* If we're doing semantic analysis, then we'll call pushdecl
11927 for each of these. We must do them in reverse order so that
11928 they end in the correct forward order. */
11929 specparms = nreverse (specparms);
11931 for (parm = specparms; parm; parm = next)
11933 next = TREE_CHAIN (parm);
11934 if (TREE_CODE (parm) == PARM_DECL)
11936 if (DECL_NAME (parm) == NULL_TREE
11937 || TREE_CODE (parm) != VOID_TYPE)
11940 error ("parameter %qD declared void", parm);
11944 /* If we find an enum constant or a type tag,
11945 put it aside for the moment. */
11946 TREE_CHAIN (parm) = NULL_TREE;
11947 nonparms = chainon (nonparms, parm);
11951 /* Get the decls in their original chain order and record in the
11952 function. This is all and only the PARM_DECLs that were
11953 pushed into scope by the loop above. */
11954 DECL_ARGUMENTS (fndecl) = getdecls ();
11957 DECL_ARGUMENTS (fndecl) = NULL_TREE;
11959 /* Now store the final chain of decls for the arguments
11960 as the decl-chain of the current lexical scope.
11961 Put the enumerators in as well, at the front so that
11962 DECL_ARGUMENTS is not modified. */
11963 current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));
11965 if (use_eh_spec_block (current_function_decl))
11966 current_eh_spec_block = begin_eh_spec_block ();
11970 /* We have finished doing semantic analysis on DECL, but have not yet
11971 generated RTL for its body. Save away our current state, so that
11972 when we want to generate RTL later we know what to do. */
11975 save_function_data (tree decl)
11977 struct language_function *f;
11979 /* Save the language-specific per-function data so that we can
11980 get it back when we really expand this function. */
11981 gcc_assert (!DECL_PENDING_INLINE_P (decl));
11984 f = GGC_NEW (struct language_function);
11985 memcpy (f, cp_function_chain, sizeof (struct language_function));
11986 DECL_SAVED_FUNCTION_DATA (decl) = f;
11988 /* Clear out the bits we don't need. */
11989 f->base.x_stmt_tree.x_cur_stmt_list = NULL_TREE;
11990 f->bindings = NULL;
11991 f->x_local_names = NULL;
11995 /* Set the return value of the constructor (if present). */
11998 finish_constructor_body (void)
12003 if (targetm.cxx.cdtor_returns_this ()
12004 && (! TYPE_FOR_JAVA (current_class_type)))
12006 /* Any return from a constructor will end up here. */
12007 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
12009 val = DECL_ARGUMENTS (current_function_decl);
12010 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
12011 DECL_RESULT (current_function_decl), val);
12012 /* Return the address of the object. */
12013 exprstmt = build_stmt (RETURN_EXPR, val);
12014 add_stmt (exprstmt);
12018 /* Do all the processing for the beginning of a destructor; set up the
12019 vtable pointers and cleanups for bases and members. */
12022 begin_destructor_body (void)
12024 tree compound_stmt;
12026 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
12027 issued an error message. We still want to try to process the
12028 body of the function, but initialize_vtbl_ptrs will crash if
12029 TYPE_BINFO is NULL. */
12030 if (COMPLETE_TYPE_P (current_class_type))
12032 compound_stmt = begin_compound_stmt (0);
12033 /* Make all virtual function table pointers in non-virtual base
12034 classes point to CURRENT_CLASS_TYPE's virtual function
12036 initialize_vtbl_ptrs (current_class_ptr);
12037 finish_compound_stmt (compound_stmt);
12039 /* And insert cleanups for our bases and members so that they
12040 will be properly destroyed if we throw. */
12041 push_base_cleanups ();
12045 /* At the end of every destructor we generate code to delete the object if
12046 necessary. Do that now. */
12049 finish_destructor_body (void)
12053 /* Any return from a destructor will end up here; that way all base
12054 and member cleanups will be run when the function returns. */
12055 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
12057 /* In a virtual destructor, we must call delete. */
12058 if (DECL_VIRTUAL_P (current_function_decl))
12061 tree virtual_size = cxx_sizeof (current_class_type);
12065 At the point of definition of a virtual destructor (including
12066 an implicit definition), non-placement operator delete shall
12067 be looked up in the scope of the destructor's class and if
12068 found shall be accessible and unambiguous. */
12069 exprstmt = build_op_delete_call(DELETE_EXPR, current_class_ptr,
12071 /*global_p=*/false,
12072 /*placement=*/NULL_TREE,
12073 /*alloc_fn=*/NULL_TREE);
12075 if_stmt = begin_if_stmt ();
12076 finish_if_stmt_cond (build2 (BIT_AND_EXPR, integer_type_node,
12077 current_in_charge_parm,
12080 finish_expr_stmt (exprstmt);
12081 finish_then_clause (if_stmt);
12082 finish_if_stmt (if_stmt);
12085 if (targetm.cxx.cdtor_returns_this ())
12089 val = DECL_ARGUMENTS (current_function_decl);
12090 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
12091 DECL_RESULT (current_function_decl), val);
12092 /* Return the address of the object. */
12093 exprstmt = build_stmt (RETURN_EXPR, val);
12094 add_stmt (exprstmt);
12098 /* Do the necessary processing for the beginning of a function body, which
12099 in this case includes member-initializers, but not the catch clauses of
12100 a function-try-block. Currently, this means opening a binding level
12101 for the member-initializers (in a ctor) and member cleanups (in a dtor). */
12104 begin_function_body (void)
12108 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
12111 if (processing_template_decl)
12112 /* Do nothing now. */;
12114 /* Always keep the BLOCK node associated with the outermost pair of
12115 curly braces of a function. These are needed for correct
12116 operation of dwarfout.c. */
12117 keep_next_level (true);
12119 stmt = begin_compound_stmt (BCS_FN_BODY);
12121 if (processing_template_decl)
12122 /* Do nothing now. */;
12123 else if (DECL_DESTRUCTOR_P (current_function_decl))
12124 begin_destructor_body ();
12129 /* Do the processing for the end of a function body. Currently, this means
12130 closing out the cleanups for fully-constructed bases and members, and in
12131 the case of the destructor, deleting the object if desired. Again, this
12132 is only meaningful for [cd]tors, since they are the only functions where
12133 there is a significant distinction between the main body and any
12134 function catch clauses. Handling, say, main() return semantics here
12135 would be wrong, as flowing off the end of a function catch clause for
12136 main() would also need to return 0. */
12139 finish_function_body (tree compstmt)
12141 if (compstmt == NULL_TREE)
12144 /* Close the block. */
12145 finish_compound_stmt (compstmt);
12147 if (processing_template_decl)
12148 /* Do nothing now. */;
12149 else if (DECL_CONSTRUCTOR_P (current_function_decl))
12150 finish_constructor_body ();
12151 else if (DECL_DESTRUCTOR_P (current_function_decl))
12152 finish_destructor_body ();
12155 /* Given a function, returns the BLOCK corresponding to the outermost level
12156 of curly braces, skipping the artificial block created for constructor
12160 outer_curly_brace_block (tree fndecl)
12162 tree block = BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl));
12163 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
12164 /* Skip the artificial function body block. */
12165 block = BLOCK_SUBBLOCKS (block);
12169 /* Finish up a function declaration and compile that function
12170 all the way to assembler language output. The free the storage
12171 for the function definition.
12173 FLAGS is a bitwise or of the following values:
12175 We just finished processing the body of an in-class inline
12176 function definition. (This processing will have taken place
12177 after the class definition is complete.) */
12180 finish_function (int flags)
12182 tree fndecl = current_function_decl;
12183 tree fntype, ctype = NULL_TREE;
12184 int inclass_inline = (flags & 2) != 0;
12187 /* When we get some parse errors, we can end up without a
12188 current_function_decl, so cope. */
12189 if (fndecl == NULL_TREE)
12190 return error_mark_node;
12192 gcc_assert (!defer_mark_used_calls);
12193 defer_mark_used_calls = true;
12195 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
12196 && DECL_VIRTUAL_P (fndecl)
12197 && !processing_template_decl)
12199 tree fnclass = DECL_CONTEXT (fndecl);
12200 if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
12201 keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
12204 nested = function_depth > 1;
12205 fntype = TREE_TYPE (fndecl);
12207 /* TREE_READONLY (fndecl) = 1;
12208 This caused &foo to be of type ptr-to-const-function
12209 which then got a warning when stored in a ptr-to-function variable. */
12211 gcc_assert (building_stmt_tree ());
12212 /* The current function is being defined, so its DECL_INITIAL should
12213 be set, and unless there's a multiple definition, it should be
12214 error_mark_node. */
12215 gcc_assert (DECL_INITIAL (fndecl) == error_mark_node);
12217 /* For a cloned function, we've already got all the code we need;
12218 there's no need to add any extra bits. */
12219 if (!DECL_CLONED_FUNCTION_P (fndecl))
12221 if (DECL_MAIN_P (current_function_decl))
12225 /* Make it so that `main' always returns 0 by default (or
12228 stmt = finish_return_stmt (integer_one_node);
12230 stmt = finish_return_stmt (integer_zero_node);
12232 /* Hack. We don't want the middle-end to warn that this
12233 return is unreachable, so put the statement on the
12236 location_t linezero = linemap_line_start (line_table, 0, 1);
12237 SET_EXPR_LOCATION (stmt, linezero);
12241 if (use_eh_spec_block (current_function_decl))
12242 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
12243 (TREE_TYPE (current_function_decl)),
12244 current_eh_spec_block);
12247 /* If we're saving up tree structure, tie off the function now. */
12248 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
12250 finish_fname_decls ();
12252 /* If this function can't throw any exceptions, remember that. */
12253 if (!processing_template_decl
12254 && !cp_function_chain->can_throw
12255 && !flag_non_call_exceptions
12256 && !DECL_REPLACEABLE_P (fndecl))
12257 TREE_NOTHROW (fndecl) = 1;
12259 /* This must come after expand_function_end because cleanups might
12260 have declarations (from inline functions) that need to go into
12261 this function's blocks. */
12263 /* If the current binding level isn't the outermost binding level
12264 for this function, either there is a bug, or we have experienced
12265 syntax errors and the statement tree is malformed. */
12266 if (current_binding_level->kind != sk_function_parms)
12268 /* Make sure we have already experienced errors. */
12269 gcc_assert (errorcount);
12271 /* Throw away the broken statement tree and extra binding
12273 DECL_SAVED_TREE (fndecl) = alloc_stmt_list ();
12275 while (current_binding_level->kind != sk_function_parms)
12277 if (current_binding_level->kind == sk_class)
12278 pop_nested_class ();
12280 poplevel (0, 0, 0);
12283 poplevel (1, 0, 1);
12285 /* Statements should always be full-expressions at the outermost set
12286 of curly braces for a function. */
12287 gcc_assert (stmts_are_full_exprs_p ());
12289 /* Set up the named return value optimization, if we can. Candidate
12290 variables are selected in check_return_expr. */
12291 if (current_function_return_value)
12293 tree r = current_function_return_value;
12296 if (r != error_mark_node
12297 /* This is only worth doing for fns that return in memory--and
12298 simpler, since we don't have to worry about promoted modes. */
12299 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
12300 /* Only allow this for variables declared in the outer scope of
12301 the function so we know that their lifetime always ends with a
12302 return; see g++.dg/opt/nrv6.C. We could be more flexible if
12303 we were to do this optimization in tree-ssa. */
12304 && (outer = outer_curly_brace_block (fndecl))
12305 && chain_member (r, BLOCK_VARS (outer)))
12306 finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));
12308 current_function_return_value = NULL_TREE;
12311 /* Remember that we were in class scope. */
12312 if (current_class_name)
12313 ctype = current_class_type;
12315 /* Must mark the RESULT_DECL as being in this function. */
12316 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
12318 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
12319 to the FUNCTION_DECL node itself. */
12320 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
12322 /* Save away current state, if appropriate. */
12323 if (!processing_template_decl)
12324 save_function_data (fndecl);
12326 /* Complain if there's just no return statement. */
12327 if (warn_return_type
12328 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
12329 && !dependent_type_p (TREE_TYPE (fntype))
12330 && !current_function_returns_value && !current_function_returns_null
12331 /* Don't complain if we abort or throw. */
12332 && !current_function_returns_abnormally
12333 && !DECL_NAME (DECL_RESULT (fndecl))
12334 && !TREE_NO_WARNING (fndecl)
12335 /* Structor return values (if any) are set by the compiler. */
12336 && !DECL_CONSTRUCTOR_P (fndecl)
12337 && !DECL_DESTRUCTOR_P (fndecl))
12339 warning (OPT_Wreturn_type,
12340 "no return statement in function returning non-void");
12341 TREE_NO_WARNING (fndecl) = 1;
12344 /* Store the end of the function, so that we get good line number
12345 info for the epilogue. */
12346 cfun->function_end_locus = input_location;
12348 /* Genericize before inlining. */
12349 if (!processing_template_decl)
12351 struct language_function *f = DECL_SAVED_FUNCTION_DATA (fndecl);
12352 invoke_plugin_callbacks (PLUGIN_CXX_CP_PRE_GENERICIZE, fndecl);
12353 cp_genericize (fndecl);
12354 /* Clear out the bits we don't need. */
12355 f->x_current_class_ptr = NULL;
12356 f->x_current_class_ref = NULL;
12357 f->x_eh_spec_block = NULL;
12358 f->x_in_charge_parm = NULL;
12359 f->x_vtt_parm = NULL;
12360 f->x_return_value = NULL;
12361 f->bindings = NULL;
12362 f->extern_decl_map = NULL;
12364 /* Handle attribute((warn_unused_result)). Relies on gimple input. */
12365 c_warn_unused_result (gimple_body (fndecl));
12367 /* Clear out the bits we don't need. */
12368 local_names = NULL;
12370 /* We're leaving the context of this function, so zap cfun. It's still in
12371 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
12373 current_function_decl = NULL;
12375 /* If this is an in-class inline definition, we may have to pop the
12376 bindings for the template parameters that we added in
12377 maybe_begin_member_template_processing when start_function was
12379 if (inclass_inline)
12380 maybe_end_member_template_processing ();
12382 /* Leave the scope of the class. */
12384 pop_nested_class ();
12390 /* Let the error reporting routines know that we're outside a
12391 function. For a nested function, this value is used in
12392 cxx_pop_function_context and then reset via pop_function_context. */
12393 current_function_decl = NULL_TREE;
12395 defer_mark_used_calls = false;
12396 if (deferred_mark_used_calls)
12401 for (i = 0; VEC_iterate (tree, deferred_mark_used_calls, i, decl); i++)
12403 VEC_free (tree, gc, deferred_mark_used_calls);
12409 /* Create the FUNCTION_DECL for a function definition.
12410 DECLSPECS and DECLARATOR are the parts of the declaration;
12411 they describe the return type and the name of the function,
12412 but twisted together in a fashion that parallels the syntax of C.
12414 This function creates a binding context for the function body
12415 as well as setting up the FUNCTION_DECL in current_function_decl.
12417 Returns a FUNCTION_DECL on success.
12419 If the DECLARATOR is not suitable for a function (it defines a datum
12420 instead), we return 0, which tells yyparse to report a parse error.
12422 May return void_type_node indicating that this method is actually
12423 a friend. See grokfield for more details.
12425 Came here with a `.pushlevel' .
12427 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
12428 CHANGES TO CODE IN `grokfield'. */
12431 start_method (cp_decl_specifier_seq *declspecs,
12432 const cp_declarator *declarator, tree attrlist)
12434 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
12437 if (fndecl == error_mark_node)
12438 return error_mark_node;
12440 if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
12442 error ("invalid member function declaration");
12443 return error_mark_node;
12447 cplus_decl_attributes (&fndecl, attrlist, 0);
12449 /* Pass friends other than inline friend functions back. */
12450 if (fndecl == void_type_node)
12453 if (DECL_IN_AGGR_P (fndecl))
12455 if (DECL_CONTEXT (fndecl)
12456 && TREE_CODE (DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
12457 error ("%qD is already defined in class %qT", fndecl,
12458 DECL_CONTEXT (fndecl));
12459 return error_mark_node;
12462 check_template_shadow (fndecl);
12464 DECL_DECLARED_INLINE_P (fndecl) = 1;
12465 DECL_NO_INLINE_WARNING_P (fndecl) = 1;
12467 /* We process method specializations in finish_struct_1. */
12468 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
12470 fndecl = push_template_decl (fndecl);
12471 if (fndecl == error_mark_node)
12475 if (! DECL_FRIEND_P (fndecl))
12477 if (TREE_CHAIN (fndecl))
12479 fndecl = copy_node (fndecl);
12480 TREE_CHAIN (fndecl) = NULL_TREE;
12484 finish_decl (fndecl, NULL_TREE, NULL_TREE, NULL_TREE);
12486 /* Make a place for the parms. */
12487 begin_scope (sk_function_parms, fndecl);
12489 DECL_IN_AGGR_P (fndecl) = 1;
12493 /* Go through the motions of finishing a function definition.
12494 We don't compile this method until after the whole class has
12497 FINISH_METHOD must return something that looks as though it
12498 came from GROKFIELD (since we are defining a method, after all).
12500 This is called after parsing the body of the function definition.
12501 STMTS is the chain of statements that makes up the function body.
12503 DECL is the ..._DECL that `start_method' provided. */
12506 finish_method (tree decl)
12508 tree fndecl = decl;
12513 if (decl == void_type_node)
12516 old_initial = DECL_INITIAL (fndecl);
12518 /* Undo the level for the parms (from start_method).
12519 This is like poplevel, but it causes nothing to be
12520 saved. Saving information here confuses symbol-table
12521 output routines. Besides, this information will
12522 be correctly output when this method is actually
12525 /* Clear out the meanings of the local variables of this level;
12526 also record in each decl which block it belongs to. */
12528 for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
12530 if (DECL_NAME (link) != NULL_TREE)
12531 pop_binding (DECL_NAME (link), link);
12532 gcc_assert (TREE_CODE (link) != FUNCTION_DECL);
12533 DECL_CONTEXT (link) = NULL_TREE;
12536 poplevel (0, 0, 0);
12538 DECL_INITIAL (fndecl) = old_initial;
12540 /* We used to check if the context of FNDECL was different from
12541 current_class_type as another way to get inside here. This didn't work
12542 for String.cc in libg++. */
12543 if (DECL_FRIEND_P (fndecl))
12545 VEC_safe_push (tree, gc, CLASSTYPE_INLINE_FRIENDS (current_class_type),
12547 decl = void_type_node;
12554 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
12555 we can lay it out later, when and if its type becomes complete. */
12558 maybe_register_incomplete_var (tree var)
12560 gcc_assert (TREE_CODE (var) == VAR_DECL);
12562 /* Keep track of variables with incomplete types. */
12563 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
12564 && DECL_EXTERNAL (var))
12566 tree inner_type = TREE_TYPE (var);
12568 while (TREE_CODE (inner_type) == ARRAY_TYPE)
12569 inner_type = TREE_TYPE (inner_type);
12570 inner_type = TYPE_MAIN_VARIANT (inner_type);
12572 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
12573 /* RTTI TD entries are created while defining the type_info. */
12574 || (TYPE_LANG_SPECIFIC (inner_type)
12575 && TYPE_BEING_DEFINED (inner_type)))
12576 incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
12580 /* Called when a class type (given by TYPE) is defined. If there are
12581 any existing VAR_DECLs whose type has been completed by this
12582 declaration, update them now. */
12585 complete_vars (tree type)
12587 tree *list = &incomplete_vars;
12589 gcc_assert (CLASS_TYPE_P (type));
12592 if (same_type_p (type, TREE_PURPOSE (*list)))
12594 tree var = TREE_VALUE (*list);
12595 tree type = TREE_TYPE (var);
12596 /* Complete the type of the variable. The VAR_DECL itself
12597 will be laid out in expand_expr. */
12598 complete_type (type);
12599 cp_apply_type_quals_to_decl (cp_type_quals (type), var);
12600 /* Remove this entry from the list. */
12601 *list = TREE_CHAIN (*list);
12604 list = &TREE_CHAIN (*list);
12607 /* Check for pending declarations which may have abstract type. */
12608 complete_type_check_abstract (type);
12611 /* If DECL is of a type which needs a cleanup, build and return an
12612 expression to perform that cleanup here. Return NULL_TREE if no
12613 cleanup need be done. */
12616 cxx_maybe_build_cleanup (tree decl)
12622 /* Assume no cleanup is required. */
12623 cleanup = NULL_TREE;
12625 if (error_operand_p (decl))
12628 /* Handle "__attribute__((cleanup))". We run the cleanup function
12629 before the destructor since the destructor is what actually
12630 terminates the lifetime of the object. */
12631 attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
12638 /* Get the name specified by the user for the cleanup function. */
12639 id = TREE_VALUE (TREE_VALUE (attr));
12640 /* Look up the name to find the cleanup function to call. It is
12641 important to use lookup_name here because that is what is
12642 used in c-common.c:handle_cleanup_attribute when performing
12643 initial checks on the attribute. Note that those checks
12644 include ensuring that the function found is not an overloaded
12645 function, or an object with an overloaded call operator,
12646 etc.; we can rely on the fact that the function found is an
12647 ordinary FUNCTION_DECL. */
12648 fn = lookup_name (id);
12649 arg = build_address (decl);
12651 cleanup = cp_build_function_call (fn, build_tree_list (NULL_TREE,
12653 tf_warning_or_error);
12655 /* Handle ordinary C++ destructors. */
12656 type = TREE_TYPE (decl);
12657 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
12659 int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
12660 bool has_vbases = (TREE_CODE (type) == RECORD_TYPE
12661 && CLASSTYPE_VBASECLASSES (type));
12665 if (TREE_CODE (type) == ARRAY_TYPE)
12668 addr = build_address (decl);
12670 /* Optimize for space over speed here. */
12671 if (!has_vbases || flag_expensive_optimizations)
12672 flags |= LOOKUP_NONVIRTUAL;
12674 call = build_delete (TREE_TYPE (addr), addr,
12675 sfk_complete_destructor, flags, 0);
12677 cleanup = build_compound_expr (cleanup, call);
12685 /* When a stmt has been parsed, this function is called. */
12692 /* DECL was originally constructed as a non-static member function,
12693 but turned out to be static. Update it accordingly. */
12696 revert_static_member_fn (tree decl)
12699 tree function = TREE_TYPE (decl);
12700 tree args = TYPE_ARG_TYPES (function);
12702 if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
12703 != TYPE_UNQUALIFIED)
12704 error ("static member function %q#D declared with type qualifiers", decl);
12706 args = TREE_CHAIN (args);
12707 tmp = build_function_type (TREE_TYPE (function), args);
12708 tmp = build_qualified_type (tmp, cp_type_quals (function));
12709 tmp = build_exception_variant (tmp,
12710 TYPE_RAISES_EXCEPTIONS (function));
12711 TREE_TYPE (decl) = tmp;
12712 if (DECL_ARGUMENTS (decl))
12713 DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
12714 DECL_STATIC_FUNCTION_P (decl) = 1;
12717 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
12718 one of the language-independent trees. */
12720 enum cp_tree_node_structure_enum
12721 cp_tree_node_structure (union lang_tree_node * t)
12723 switch (TREE_CODE (&t->generic))
12725 case DEFAULT_ARG: return TS_CP_DEFAULT_ARG;
12726 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER;
12727 case OVERLOAD: return TS_CP_OVERLOAD;
12728 case TEMPLATE_PARM_INDEX: return TS_CP_TPI;
12729 case PTRMEM_CST: return TS_CP_PTRMEM;
12730 case BASELINK: return TS_CP_BASELINK;
12731 case STATIC_ASSERT: return TS_CP_STATIC_ASSERT;
12732 case ARGUMENT_PACK_SELECT: return TS_CP_ARGUMENT_PACK_SELECT;
12733 case TRAIT_EXPR: return TS_CP_TRAIT_EXPR;
12734 default: return TS_CP_GENERIC;
12738 /* Build the void_list_node (void_type_node having been created). */
12740 build_void_list_node (void)
12742 tree t = build_tree_list (NULL_TREE, void_type_node);
12747 cp_missing_noreturn_ok_p (tree decl)
12749 /* A missing noreturn is ok for the `main' function. */
12750 return DECL_MAIN_P (decl);
12753 /* Return the COMDAT group into which DECL should be placed. */
12756 cxx_comdat_group (tree decl)
12760 /* Virtual tables, construction virtual tables, and virtual table
12761 tables all go in a single COMDAT group, named after the primary
12763 if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
12764 name = DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl)));
12765 /* For all other DECLs, the COMDAT group is the mangled name of the
12766 declaration itself. */
12769 while (DECL_THUNK_P (decl))
12771 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
12772 into the same section as the target function. In that case
12773 we must return target's name. */
12774 tree target = THUNK_TARGET (decl);
12775 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target)
12776 && DECL_SECTION_NAME (target) != NULL
12777 && DECL_ONE_ONLY (target))
12782 name = DECL_ASSEMBLER_NAME (decl);
12785 return IDENTIFIER_POINTER (name);
12788 #include "gt-cp-decl.h"