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 (location_t, 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 GTY(()) named_label_use_entry {
173 struct named_label_use_entry *next;
174 /* The binding level to which this entry is *currently* attached.
175 This is initially the binding level in which the goto appeared,
176 but is modified as scopes are closed. */
177 struct cp_binding_level *binding_level;
178 /* The head of the names list that was current when the goto appeared,
179 or the inner scope popped. These are the decls that will *not* be
180 skipped when jumping to the label. */
182 /* The location of the goto, for error reporting. */
183 location_t o_goto_locus;
184 /* True if an OpenMP structured block scope has been closed since
185 the goto appeared. This means that the branch from the label will
186 illegally exit an OpenMP scope. */
190 /* A list of all LABEL_DECLs in the function that have names. Here so
191 we can clear out their names' definitions at the end of the
192 function, and so we can check the validity of jumps to these labels. */
194 struct GTY(()) named_label_entry {
195 /* The decl itself. */
198 /* The binding level to which the label is *currently* attached.
199 This is initially set to the binding level in which the label
200 is defined, but is modified as scopes are closed. */
201 struct cp_binding_level *binding_level;
202 /* The head of the names list that was current when the label was
203 defined, or the inner scope popped. These are the decls that will
204 be skipped when jumping to the label. */
206 /* A tree list of all decls from all binding levels that would be
207 crossed by a backward branch to the label. */
210 /* A list of uses of the label, before the label is defined. */
211 struct named_label_use_entry *uses;
213 /* The following bits are set after the label is defined, and are
214 updated as scopes are popped. They indicate that a backward jump
215 to the label will illegally enter a scope of the given flavor. */
221 #define named_labels cp_function_chain->x_named_labels
223 /* The number of function bodies which we are currently processing.
224 (Zero if we are at namespace scope, one inside the body of a
225 function, two inside the body of a function in a local class, etc.) */
228 /* To avoid unwanted recursion, finish_function defers all mark_used calls
229 encountered during its execution until it finishes. */
230 bool defer_mark_used_calls;
231 VEC(tree, gc) *deferred_mark_used_calls;
233 /* States indicating how grokdeclarator() should handle declspecs marked
234 with __attribute__((deprecated)). An object declared as
235 __attribute__((deprecated)) suppresses warnings of uses of other
237 enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
240 /* A TREE_LIST of VAR_DECLs. The TREE_PURPOSE is a RECORD_TYPE or
241 UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type. At the
242 time the VAR_DECL was declared, the type was incomplete. */
244 static GTY(()) tree incomplete_vars;
246 /* Returns the kind of template specialization we are currently
247 processing, given that it's declaration contained N_CLASS_SCOPES
248 explicit scope qualifications. */
251 current_tmpl_spec_kind (int n_class_scopes)
253 int n_template_parm_scopes = 0;
254 int seen_specialization_p = 0;
255 int innermost_specialization_p = 0;
256 struct cp_binding_level *b;
258 /* Scan through the template parameter scopes. */
259 for (b = current_binding_level;
260 b->kind == sk_template_parms;
263 /* If we see a specialization scope inside a parameter scope,
264 then something is wrong. That corresponds to a declaration
267 template <class T> template <> ...
269 which is always invalid since [temp.expl.spec] forbids the
270 specialization of a class member template if the enclosing
271 class templates are not explicitly specialized as well. */
272 if (b->explicit_spec_p)
274 if (n_template_parm_scopes == 0)
275 innermost_specialization_p = 1;
277 seen_specialization_p = 1;
279 else if (seen_specialization_p == 1)
280 return tsk_invalid_member_spec;
282 ++n_template_parm_scopes;
285 /* Handle explicit instantiations. */
286 if (processing_explicit_instantiation)
288 if (n_template_parm_scopes != 0)
289 /* We've seen a template parameter list during an explicit
290 instantiation. For example:
292 template <class T> template void f(int);
294 This is erroneous. */
295 return tsk_invalid_expl_inst;
297 return tsk_expl_inst;
300 if (n_template_parm_scopes < n_class_scopes)
301 /* We've not seen enough template headers to match all the
302 specialized classes present. For example:
304 template <class T> void R<T>::S<T>::f(int);
306 This is invalid; there needs to be one set of template
307 parameters for each class. */
308 return tsk_insufficient_parms;
309 else if (n_template_parm_scopes == n_class_scopes)
310 /* We're processing a non-template declaration (even though it may
311 be a member of a template class.) For example:
313 template <class T> void S<T>::f(int);
315 The `class T' matches the `S<T>', leaving no template headers
316 corresponding to the `f'. */
318 else if (n_template_parm_scopes > n_class_scopes + 1)
319 /* We've got too many template headers. For example:
321 template <> template <class T> void f (T);
323 There need to be more enclosing classes. */
324 return tsk_excessive_parms;
326 /* This must be a template. It's of the form:
328 template <class T> template <class U> void S<T>::f(U);
330 This is a specialization if the innermost level was a
331 specialization; otherwise it's just a definition of the
333 return innermost_specialization_p ? tsk_expl_spec : tsk_template;
336 /* Exit the current scope. */
344 /* When a label goes out of scope, check to see if that label was used
345 in a valid manner, and issue any appropriate warnings or errors. */
348 pop_label (tree label, tree old_value)
350 if (!processing_template_decl)
352 if (DECL_INITIAL (label) == NULL_TREE)
356 error ("label %q+D used but not defined", label);
357 location = input_location; /* FIXME want (input_filename, (line)0) */
358 /* Avoid crashing later. */
359 define_label (location, DECL_NAME (label));
362 warn_for_unused_label (label);
365 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
368 /* At the end of a function, all labels declared within the function
369 go out of scope. BLOCK is the top-level block for the
373 pop_labels_1 (void **slot, void *data)
375 struct named_label_entry *ent = (struct named_label_entry *) *slot;
376 tree block = (tree) data;
378 pop_label (ent->label_decl, NULL_TREE);
380 /* Put the labels into the "variables" of the top-level block,
381 so debugger can see them. */
382 TREE_CHAIN (ent->label_decl) = BLOCK_VARS (block);
383 BLOCK_VARS (block) = ent->label_decl;
385 htab_clear_slot (named_labels, slot);
391 pop_labels (tree block)
395 htab_traverse (named_labels, pop_labels_1, block);
400 /* At the end of a block with local labels, restore the outer definition. */
403 pop_local_label (tree label, tree old_value)
405 struct named_label_entry dummy;
408 pop_label (label, old_value);
410 dummy.label_decl = label;
411 slot = htab_find_slot (named_labels, &dummy, NO_INSERT);
412 htab_clear_slot (named_labels, slot);
415 /* The following two routines are used to interface to Objective-C++.
416 The binding level is purposely treated as an opaque type. */
419 objc_get_current_scope (void)
421 return current_binding_level;
424 /* The following routine is used by the NeXT-style SJLJ exceptions;
425 variables get marked 'volatile' so as to not be clobbered by
426 _setjmp()/_longjmp() calls. All variables in the current scope,
427 as well as parent scopes up to (but not including) ENCLOSING_BLK
428 shall be thusly marked. */
431 objc_mark_locals_volatile (void *enclosing_blk)
433 struct cp_binding_level *scope;
435 for (scope = current_binding_level;
436 scope && scope != enclosing_blk;
437 scope = scope->level_chain)
441 for (decl = scope->names; decl; decl = TREE_CHAIN (decl))
442 objc_volatilize_decl (decl);
444 /* Do not climb up past the current function. */
445 if (scope->kind == sk_function_parms)
450 /* Update data for defined and undefined labels when leaving a scope. */
453 poplevel_named_label_1 (void **slot, void *data)
455 struct named_label_entry *ent = (struct named_label_entry *) *slot;
456 struct cp_binding_level *bl = (struct cp_binding_level *) data;
457 struct cp_binding_level *obl = bl->level_chain;
459 if (ent->binding_level == bl)
463 for (decl = ent->names_in_scope; decl; decl = TREE_CHAIN (decl))
464 if (decl_jump_unsafe (decl))
465 ent->bad_decls = tree_cons (NULL, decl, ent->bad_decls);
467 ent->binding_level = obl;
468 ent->names_in_scope = obl->names;
472 ent->in_try_scope = true;
475 ent->in_catch_scope = true;
478 ent->in_omp_scope = true;
486 struct named_label_use_entry *use;
488 for (use = ent->uses; use ; use = use->next)
489 if (use->binding_level == bl)
491 use->binding_level = obl;
492 use->names_in_scope = obl->names;
493 if (bl->kind == sk_omp)
494 use->in_omp_scope = true;
501 /* Exit a binding level.
502 Pop the level off, and restore the state of the identifier-decl mappings
503 that were in effect when this level was entered.
505 If KEEP == 1, this level had explicit declarations, so
506 and create a "block" (a BLOCK node) for the level
507 to record its declarations and subblocks for symbol table output.
509 If FUNCTIONBODY is nonzero, this level is the body of a function,
510 so create a block as if KEEP were set and also clear out all
513 If REVERSE is nonzero, reverse the order of decls before putting
514 them into the BLOCK. */
517 poplevel (int keep, int reverse, int functionbody)
520 /* The chain of decls was accumulated in reverse order.
521 Put it into forward order, just for cleanliness. */
523 int tmp = functionbody;
524 int real_functionbody;
528 int leaving_for_scope;
531 timevar_push (TV_NAME_LOOKUP);
536 gcc_assert (current_binding_level->kind != sk_class);
538 real_functionbody = (current_binding_level->kind == sk_cleanup
539 ? ((functionbody = 0), tmp) : functionbody);
540 subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
542 gcc_assert (!VEC_length(cp_class_binding,
543 current_binding_level->class_shadowed));
545 /* We used to use KEEP == 2 to indicate that the new block should go
546 at the beginning of the list of blocks at this binding level,
547 rather than the end. This hack is no longer used. */
548 gcc_assert (keep == 0 || keep == 1);
550 if (current_binding_level->keep)
553 /* Any uses of undefined labels, and any defined labels, now operate
554 under constraints of next binding contour. */
555 if (cfun && !functionbody && named_labels)
556 htab_traverse (named_labels, poplevel_named_label_1,
557 current_binding_level);
559 /* Get the decls in the order they were written.
560 Usually current_binding_level->names is in reverse order.
561 But parameter decls were previously put in forward order. */
564 current_binding_level->names
565 = decls = nreverse (current_binding_level->names);
567 decls = current_binding_level->names;
569 /* If there were any declarations or structure tags in that level,
570 or if this level is a function body,
571 create a BLOCK to record them for the life of this function. */
573 if (keep == 1 || functionbody)
574 block = make_node (BLOCK);
575 if (block != NULL_TREE)
577 BLOCK_VARS (block) = decls;
578 BLOCK_SUBBLOCKS (block) = subblocks;
581 /* In each subblock, record that this is its superior. */
583 for (link = subblocks; link; link = BLOCK_CHAIN (link))
584 BLOCK_SUPERCONTEXT (link) = block;
586 /* We still support the old for-scope rules, whereby the variables
587 in a for-init statement were in scope after the for-statement
588 ended. We only use the new rules if flag_new_for_scope is
591 = current_binding_level->kind == sk_for && flag_new_for_scope == 1;
593 /* Before we remove the declarations first check for unused variables. */
594 if (warn_unused_variable
595 && !processing_template_decl)
596 for (decl = getdecls (); decl; decl = TREE_CHAIN (decl))
597 if (TREE_CODE (decl) == VAR_DECL
598 && ! TREE_USED (decl)
599 && ! DECL_IN_SYSTEM_HEADER (decl)
600 && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl))
601 warning (OPT_Wunused_variable, "unused variable %q+D", decl);
603 /* Remove declarations for all the DECLs in this level. */
604 for (link = decls; link; link = TREE_CHAIN (link))
606 if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
609 tree name = DECL_NAME (link);
613 ob = outer_binding (name,
614 IDENTIFIER_BINDING (name),
617 ns_binding = IDENTIFIER_NAMESPACE_VALUE (name);
619 ns_binding = NULL_TREE;
621 if (ob && ob->scope == current_binding_level->level_chain)
622 /* We have something like:
627 and we are leaving the `for' scope. There's no reason to
628 keep the binding of the inner `i' in this case. */
629 pop_binding (name, link);
630 else if ((ob && (TREE_CODE (ob->value) == TYPE_DECL))
631 || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL))
632 /* Here, we have something like:
640 We must pop the for-scope binding so we know what's a
641 type and what isn't. */
642 pop_binding (name, link);
645 /* Mark this VAR_DECL as dead so that we can tell we left it
646 there only for backward compatibility. */
647 DECL_DEAD_FOR_LOCAL (link) = 1;
649 /* Keep track of what should have happened when we
650 popped the binding. */
653 SET_DECL_SHADOWED_FOR_VAR (link, ob->value);
654 DECL_HAS_SHADOWED_FOR_VAR_P (link) = 1;
657 /* Add it to the list of dead variables in the next
658 outermost binding to that we can remove these when we
659 leave that binding. */
660 current_binding_level->level_chain->dead_vars_from_for
661 = tree_cons (NULL_TREE, link,
662 current_binding_level->level_chain->
665 /* Although we don't pop the cxx_binding, we do clear
666 its SCOPE since the scope is going away now. */
667 IDENTIFIER_BINDING (name)->scope
668 = current_binding_level->level_chain;
675 /* Remove the binding. */
678 if (TREE_CODE (decl) == TREE_LIST)
679 decl = TREE_VALUE (decl);
682 if (TREE_CODE (name) == OVERLOAD)
683 name = OVL_FUNCTION (name);
685 gcc_assert (DECL_P (name));
686 pop_binding (DECL_NAME (name), decl);
690 /* Remove declarations for any `for' variables from inner scopes
691 that we kept around. */
692 for (link = current_binding_level->dead_vars_from_for;
693 link; link = TREE_CHAIN (link))
694 pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
696 /* Restore the IDENTIFIER_TYPE_VALUEs. */
697 for (link = current_binding_level->type_shadowed;
698 link; link = TREE_CHAIN (link))
699 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
701 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
702 for (link = current_binding_level->shadowed_labels;
704 link = TREE_CHAIN (link))
705 pop_local_label (TREE_VALUE (link), TREE_PURPOSE (link));
707 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
708 list if a `using' declaration put them there. The debugging
709 back ends won't understand OVERLOAD, so we remove them here.
710 Because the BLOCK_VARS are (temporarily) shared with
711 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
712 popped all the bindings. */
717 for (d = &BLOCK_VARS (block); *d; )
719 if (TREE_CODE (*d) == TREE_LIST)
720 *d = TREE_CHAIN (*d);
722 d = &TREE_CHAIN (*d);
726 /* If the level being exited is the top level of a function,
727 check over all the labels. */
730 /* Since this is the top level block of a function, the vars are
731 the function's parameters. Don't leave them in the BLOCK
732 because they are found in the FUNCTION_DECL instead. */
733 BLOCK_VARS (block) = 0;
737 kind = current_binding_level->kind;
738 if (kind == sk_cleanup)
742 /* If this is a temporary binding created for a cleanup, then we'll
743 have pushed a statement list level. Pop that, create a new
744 BIND_EXPR for the block, and insert it into the stream. */
745 stmt = pop_stmt_list (current_binding_level->statement_list);
746 stmt = c_build_bind_expr (input_location, block, stmt);
753 /* The current function is being defined, so its DECL_INITIAL
754 should be error_mark_node. */
755 gcc_assert (DECL_INITIAL (current_function_decl) == error_mark_node);
756 DECL_INITIAL (current_function_decl) = block;
759 current_binding_level->blocks
760 = chainon (current_binding_level->blocks, block);
762 /* If we did not make a block for the level just exited,
763 any blocks made for inner levels
764 (since they cannot be recorded as subblocks in that level)
765 must be carried forward so they will later become subblocks
766 of something else. */
768 current_binding_level->blocks
769 = chainon (current_binding_level->blocks, subblocks);
771 /* Each and every BLOCK node created here in `poplevel' is important
772 (e.g. for proper debugging information) so if we created one
773 earlier, mark it as "used". */
775 TREE_USED (block) = 1;
777 /* All temporary bindings created for cleanups are popped silently. */
778 if (kind == sk_cleanup)
781 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, block);
784 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
785 itself, calling F for each. The DATA is passed to F as well. */
788 walk_namespaces_r (tree name_space, walk_namespaces_fn f, void* data)
791 tree current = NAMESPACE_LEVEL (name_space)->namespaces;
793 result |= (*f) (name_space, data);
795 for (; current; current = TREE_CHAIN (current))
796 result |= walk_namespaces_r (current, f, data);
801 /* Walk all the namespaces, calling F for each. The DATA is passed to
805 walk_namespaces (walk_namespaces_fn f, void* data)
807 return walk_namespaces_r (global_namespace, f, data);
810 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
811 DATA is non-NULL, this is the last time we will call
812 wrapup_global_declarations for this NAMESPACE. */
815 wrapup_globals_for_namespace (tree name_space, void* data)
817 struct cp_binding_level *level = NAMESPACE_LEVEL (name_space);
818 VEC(tree,gc) *statics = level->static_decls;
819 tree *vec = VEC_address (tree, statics);
820 int len = VEC_length (tree, statics);
821 int last_time = (data != 0);
825 check_global_declarations (vec, len);
826 emit_debug_global_declarations (vec, len);
830 /* Write out any globals that need to be output. */
831 return wrapup_global_declarations (vec, len);
835 /* In C++, you don't have to write `struct S' to refer to `S'; you
836 can just use `S'. We accomplish this by creating a TYPE_DECL as
837 if the user had written `typedef struct S S'. Create and return
838 the TYPE_DECL for TYPE. */
841 create_implicit_typedef (tree name, tree type)
845 decl = build_decl (input_location, TYPE_DECL, name, type);
846 DECL_ARTIFICIAL (decl) = 1;
847 /* There are other implicit type declarations, like the one *within*
848 a class that allows you to write `S::S'. We must distinguish
850 SET_DECL_IMPLICIT_TYPEDEF_P (decl);
851 TYPE_NAME (type) = decl;
856 /* Remember a local name for name-mangling purposes. */
859 push_local_name (tree decl)
864 timevar_push (TV_NAME_LOOKUP);
866 name = DECL_NAME (decl);
868 nelts = VEC_length (tree, local_names);
869 for (i = 0; i < nelts; i++)
871 t = VEC_index (tree, local_names, i);
872 if (DECL_NAME (t) == name)
874 if (!DECL_LANG_SPECIFIC (decl))
875 retrofit_lang_decl (decl);
876 DECL_LANG_SPECIFIC (decl)->u.base.u2sel = 1;
877 if (DECL_LANG_SPECIFIC (t))
878 DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
880 DECL_DISCRIMINATOR (decl) = 1;
882 VEC_replace (tree, local_names, i, decl);
883 timevar_pop (TV_NAME_LOOKUP);
888 VEC_safe_push (tree, gc, local_names, decl);
889 timevar_pop (TV_NAME_LOOKUP);
892 /* Subroutine of duplicate_decls: return truthvalue of whether
893 or not types of these decls match.
895 For C++, we must compare the parameter list so that `int' can match
896 `int&' in a parameter position, but `int&' is not confused with
900 decls_match (tree newdecl, tree olddecl)
904 if (newdecl == olddecl)
907 if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
908 /* If the two DECLs are not even the same kind of thing, we're not
909 interested in their types. */
912 if (TREE_CODE (newdecl) == FUNCTION_DECL)
914 tree f1 = TREE_TYPE (newdecl);
915 tree f2 = TREE_TYPE (olddecl);
916 tree p1 = TYPE_ARG_TYPES (f1);
917 tree p2 = TYPE_ARG_TYPES (f2);
919 /* Specializations of different templates are different functions
920 even if they have the same type. */
921 tree t1 = (DECL_USE_TEMPLATE (newdecl)
922 ? DECL_TI_TEMPLATE (newdecl)
924 tree t2 = (DECL_USE_TEMPLATE (olddecl)
925 ? DECL_TI_TEMPLATE (olddecl)
930 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
931 && ! (DECL_EXTERN_C_P (newdecl)
932 && DECL_EXTERN_C_P (olddecl)))
935 if (TREE_CODE (f1) != TREE_CODE (f2))
938 if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
940 if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
941 && (DECL_BUILT_IN (olddecl)
942 #ifndef NO_IMPLICIT_EXTERN_C
943 || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
944 || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
948 types_match = self_promoting_args_p (p1);
949 if (p1 == void_list_node)
950 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
952 #ifndef NO_IMPLICIT_EXTERN_C
953 else if (p1 == NULL_TREE
954 && (DECL_EXTERN_C_P (olddecl)
955 && DECL_IN_SYSTEM_HEADER (olddecl)
956 && !DECL_CLASS_SCOPE_P (olddecl))
957 && (DECL_EXTERN_C_P (newdecl)
958 && DECL_IN_SYSTEM_HEADER (newdecl)
959 && !DECL_CLASS_SCOPE_P (newdecl)))
961 types_match = self_promoting_args_p (p2);
962 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
966 types_match = compparms (p1, p2);
971 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
973 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
974 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
977 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
978 DECL_TEMPLATE_PARMS (olddecl)))
981 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
982 types_match = same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)),
983 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl)));
985 types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
986 DECL_TEMPLATE_RESULT (newdecl));
990 /* Need to check scope for variable declaration (VAR_DECL).
991 For typedef (TYPE_DECL), scope is ignored. */
992 if (TREE_CODE (newdecl) == VAR_DECL
993 && CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
995 Two declarations for an object with C language linkage
996 with the same name (ignoring the namespace that qualify
997 it) that appear in different namespace scopes refer to
999 && !(DECL_EXTERN_C_P (olddecl) && DECL_EXTERN_C_P (newdecl)))
1002 if (TREE_TYPE (newdecl) == error_mark_node)
1003 types_match = TREE_TYPE (olddecl) == error_mark_node;
1004 else if (TREE_TYPE (olddecl) == NULL_TREE)
1005 types_match = TREE_TYPE (newdecl) == NULL_TREE;
1006 else if (TREE_TYPE (newdecl) == NULL_TREE)
1009 types_match = comptypes (TREE_TYPE (newdecl),
1010 TREE_TYPE (olddecl),
1011 COMPARE_REDECLARATION);
1017 /* If NEWDECL is `static' and an `extern' was seen previously,
1018 warn about it. OLDDECL is the previous declaration.
1020 Note that this does not apply to the C++ case of declaring
1021 a variable `extern const' and then later `const'.
1023 Don't complain about built-in functions, since they are beyond
1024 the user's control. */
1027 warn_extern_redeclared_static (tree newdecl, tree olddecl)
1031 if (TREE_CODE (newdecl) == TYPE_DECL
1032 || TREE_CODE (newdecl) == TEMPLATE_DECL
1033 || TREE_CODE (newdecl) == CONST_DECL
1034 || TREE_CODE (newdecl) == NAMESPACE_DECL)
1037 /* Don't get confused by static member functions; that's a different
1039 if (TREE_CODE (newdecl) == FUNCTION_DECL
1040 && DECL_STATIC_FUNCTION_P (newdecl))
1043 /* If the old declaration was `static', or the new one isn't, then
1044 then everything is OK. */
1045 if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
1048 /* It's OK to declare a builtin function as `static'. */
1049 if (TREE_CODE (olddecl) == FUNCTION_DECL
1050 && DECL_ARTIFICIAL (olddecl))
1053 name = DECL_ASSEMBLER_NAME (newdecl);
1054 permerror (input_location, "%qD was declared %<extern%> and later %<static%>", newdecl);
1055 permerror (input_location, "previous declaration of %q+D", olddecl);
1058 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1059 function templates. If their exception specifications do not
1060 match, issue a diagnostic. */
1063 check_redeclaration_exception_specification (tree new_decl,
1068 tree new_exceptions;
1069 tree old_exceptions;
1071 new_type = TREE_TYPE (new_decl);
1072 new_exceptions = TYPE_RAISES_EXCEPTIONS (new_type);
1073 old_type = TREE_TYPE (old_decl);
1074 old_exceptions = TYPE_RAISES_EXCEPTIONS (old_type);
1078 If any declaration of a function has an exception-specification,
1079 all declarations, including the definition and an explicit
1080 specialization, of that function shall have an
1081 exception-specification with the same set of type-ids. */
1082 if ((pedantic || ! DECL_IN_SYSTEM_HEADER (old_decl))
1083 && ! DECL_IS_BUILTIN (old_decl)
1085 && !comp_except_specs (new_exceptions, old_exceptions,
1088 error ("declaration of %qF throws different exceptions", new_decl);
1089 error ("from previous declaration %q+F", old_decl);
1093 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1094 && lookup_attribute ("gnu_inline", \
1095 DECL_ATTRIBUTES (fn)))
1097 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1098 If the redeclaration is invalid, a diagnostic is issued, and the
1099 error_mark_node is returned. Otherwise, OLDDECL is returned.
1101 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1104 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1107 duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend)
1109 unsigned olddecl_uid = DECL_UID (olddecl);
1110 int olddecl_friend = 0, types_match = 0, hidden_friend = 0;
1111 int new_defines_function = 0;
1112 tree new_template_info;
1114 if (newdecl == olddecl)
1117 types_match = decls_match (newdecl, olddecl);
1119 /* If either the type of the new decl or the type of the old decl is an
1120 error_mark_node, then that implies that we have already issued an
1121 error (earlier) for some bogus type specification, and in that case,
1122 it is rather pointless to harass the user with yet more error message
1123 about the same declaration, so just pretend the types match here. */
1124 if (TREE_TYPE (newdecl) == error_mark_node
1125 || TREE_TYPE (olddecl) == error_mark_node)
1126 return error_mark_node;
1128 if (DECL_P (olddecl)
1129 && TREE_CODE (newdecl) == FUNCTION_DECL
1130 && TREE_CODE (olddecl) == FUNCTION_DECL
1131 && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
1133 if (DECL_DECLARED_INLINE_P (newdecl)
1134 && DECL_UNINLINABLE (newdecl)
1135 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1136 /* Already warned elsewhere. */;
1137 else if (DECL_DECLARED_INLINE_P (olddecl)
1138 && DECL_UNINLINABLE (olddecl)
1139 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1140 /* Already warned. */;
1141 else if (DECL_DECLARED_INLINE_P (newdecl)
1142 && DECL_UNINLINABLE (olddecl)
1143 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1145 warning (OPT_Wattributes, "function %q+D redeclared as inline",
1147 warning (OPT_Wattributes, "previous declaration of %q+D "
1148 "with attribute noinline", olddecl);
1150 else if (DECL_DECLARED_INLINE_P (olddecl)
1151 && DECL_UNINLINABLE (newdecl)
1152 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1154 warning (OPT_Wattributes, "function %q+D redeclared with "
1155 "attribute noinline", newdecl);
1156 warning (OPT_Wattributes, "previous declaration of %q+D was inline",
1161 /* Check for redeclaration and other discrepancies. */
1162 if (TREE_CODE (olddecl) == FUNCTION_DECL
1163 && DECL_ARTIFICIAL (olddecl))
1165 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl));
1166 if (TREE_CODE (newdecl) != FUNCTION_DECL)
1168 /* Avoid warnings redeclaring built-ins which have not been
1169 explicitly declared. */
1170 if (DECL_ANTICIPATED (olddecl))
1173 /* If you declare a built-in or predefined function name as static,
1174 the old definition is overridden, but optionally warn this was a
1175 bad choice of name. */
1176 if (! TREE_PUBLIC (newdecl))
1178 warning (OPT_Wshadow, "shadowing %s function %q#D",
1179 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
1181 /* Discard the old built-in function. */
1184 /* If the built-in is not ansi, then programs can override
1185 it even globally without an error. */
1186 else if (! DECL_BUILT_IN (olddecl))
1187 warning (0, "library function %q#D redeclared as non-function %q#D",
1191 error ("declaration of %q#D", newdecl);
1192 error ("conflicts with built-in declaration %q#D",
1197 else if (!types_match)
1199 /* Avoid warnings redeclaring built-ins which have not been
1200 explicitly declared. */
1201 if (DECL_ANTICIPATED (olddecl))
1203 /* Deal with fileptr_type_node. FILE type is not known
1204 at the time we create the builtins. */
1207 for (t1 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1208 t2 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1210 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1213 else if (TREE_VALUE (t2) == fileptr_type_node)
1215 tree t = TREE_VALUE (t1);
1217 if (TREE_CODE (t) == POINTER_TYPE
1218 && TYPE_NAME (TREE_TYPE (t))
1219 && DECL_NAME (TYPE_NAME (TREE_TYPE (t)))
1220 == get_identifier ("FILE")
1221 && compparms (TREE_CHAIN (t1), TREE_CHAIN (t2)))
1223 tree oldargs = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1225 TYPE_ARG_TYPES (TREE_TYPE (olddecl))
1226 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1227 types_match = decls_match (newdecl, olddecl);
1229 return duplicate_decls (newdecl, olddecl,
1231 TYPE_ARG_TYPES (TREE_TYPE (olddecl)) = oldargs;
1234 else if (! same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1237 else if ((DECL_EXTERN_C_P (newdecl)
1238 && DECL_EXTERN_C_P (olddecl))
1239 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1240 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1242 /* A near match; override the builtin. */
1244 if (TREE_PUBLIC (newdecl))
1246 warning (0, "new declaration %q#D", newdecl);
1247 warning (0, "ambiguates built-in declaration %q#D",
1251 warning (OPT_Wshadow, "shadowing %s function %q#D",
1252 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
1256 /* Discard the old built-in function. */
1259 /* Replace the old RTL to avoid problems with inlining. */
1260 COPY_DECL_RTL (newdecl, olddecl);
1262 /* Even if the types match, prefer the new declarations type for
1263 built-ins which have not been explicitly declared, for
1264 exception lists, etc... */
1265 else if (DECL_ANTICIPATED (olddecl))
1267 tree type = TREE_TYPE (newdecl);
1268 tree attribs = (*targetm.merge_type_attributes)
1269 (TREE_TYPE (olddecl), type);
1271 type = cp_build_type_attribute_variant (type, attribs);
1272 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = type;
1275 /* If a function is explicitly declared "throw ()", propagate that to
1276 the corresponding builtin. */
1277 if (DECL_BUILT_IN_CLASS (olddecl) == BUILT_IN_NORMAL
1278 && DECL_ANTICIPATED (olddecl)
1279 && TREE_NOTHROW (newdecl)
1280 && !TREE_NOTHROW (olddecl)
1281 && built_in_decls [DECL_FUNCTION_CODE (olddecl)] != NULL_TREE
1282 && built_in_decls [DECL_FUNCTION_CODE (olddecl)] != olddecl
1284 TREE_NOTHROW (built_in_decls [DECL_FUNCTION_CODE (olddecl)]) = 1;
1286 /* Whether or not the builtin can throw exceptions has no
1287 bearing on this declarator. */
1288 TREE_NOTHROW (olddecl) = 0;
1290 if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
1292 /* If a builtin function is redeclared as `static', merge
1293 the declarations, but make the original one static. */
1294 DECL_THIS_STATIC (olddecl) = 1;
1295 TREE_PUBLIC (olddecl) = 0;
1297 /* Make the old declaration consistent with the new one so
1298 that all remnants of the builtin-ness of this function
1299 will be banished. */
1300 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1301 COPY_DECL_RTL (newdecl, olddecl);
1304 else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1306 /* C++ Standard, 3.3, clause 4:
1307 "[Note: a namespace name or a class template name must be unique
1308 in its declarative region (7.3.2, clause 14). ]" */
1309 if (TREE_CODE (olddecl) != NAMESPACE_DECL
1310 && TREE_CODE (newdecl) != NAMESPACE_DECL
1311 && (TREE_CODE (olddecl) != TEMPLATE_DECL
1312 || TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) != TYPE_DECL)
1313 && (TREE_CODE (newdecl) != TEMPLATE_DECL
1314 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != TYPE_DECL))
1316 if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
1317 && TREE_CODE (newdecl) != TYPE_DECL)
1318 || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
1319 && TREE_CODE (olddecl) != TYPE_DECL))
1321 /* We do nothing special here, because C++ does such nasty
1322 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1323 get shadowed, and know that if we need to find a TYPE_DECL
1324 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1325 slot of the identifier. */
1329 if ((TREE_CODE (newdecl) == FUNCTION_DECL
1330 && DECL_FUNCTION_TEMPLATE_P (olddecl))
1331 || (TREE_CODE (olddecl) == FUNCTION_DECL
1332 && DECL_FUNCTION_TEMPLATE_P (newdecl)))
1336 error ("%q#D redeclared as different kind of symbol", newdecl);
1337 if (TREE_CODE (olddecl) == TREE_LIST)
1338 olddecl = TREE_VALUE (olddecl);
1339 error ("previous declaration of %q+#D", olddecl);
1341 return error_mark_node;
1343 else if (!types_match)
1345 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
1346 /* These are certainly not duplicate declarations; they're
1347 from different scopes. */
1350 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1352 /* The name of a class template may not be declared to refer to
1353 any other template, class, function, object, namespace, value,
1354 or type in the same scope. */
1355 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
1356 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1358 error ("declaration of template %q#D", newdecl);
1359 error ("conflicts with previous declaration %q+#D", olddecl);
1361 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
1362 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
1363 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
1364 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
1365 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1366 DECL_TEMPLATE_PARMS (olddecl))
1367 /* Template functions can be disambiguated by
1369 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
1370 TREE_TYPE (TREE_TYPE (olddecl))))
1372 error ("new declaration %q#D", newdecl);
1373 error ("ambiguates old declaration %q+#D", olddecl);
1377 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1379 if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
1381 error ("declaration of C function %q#D conflicts with",
1383 error ("previous declaration %q+#D here", olddecl);
1385 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1386 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1388 error ("new declaration %q#D", newdecl);
1389 error ("ambiguates old declaration %q+#D", olddecl);
1390 return error_mark_node;
1397 error ("conflicting declaration %q#D", newdecl);
1398 error ("%q+D has a previous declaration as %q#D", olddecl, olddecl);
1399 return error_mark_node;
1402 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1403 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
1404 && (!DECL_TEMPLATE_INFO (newdecl)
1405 || (DECL_TI_TEMPLATE (newdecl)
1406 != DECL_TI_TEMPLATE (olddecl))))
1407 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
1408 && (!DECL_TEMPLATE_INFO (olddecl)
1409 || (DECL_TI_TEMPLATE (olddecl)
1410 != DECL_TI_TEMPLATE (newdecl))))))
1411 /* It's OK to have a template specialization and a non-template
1412 with the same type, or to have specializations of two
1413 different templates with the same type. Note that if one is a
1414 specialization, and the other is an instantiation of the same
1415 template, that we do not exit at this point. That situation
1416 can occur if we instantiate a template class, and then
1417 specialize one of its methods. This situation is valid, but
1418 the declarations must be merged in the usual way. */
1420 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1421 && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
1422 && !DECL_USE_TEMPLATE (newdecl))
1423 || (DECL_TEMPLATE_INSTANTIATION (newdecl)
1424 && !DECL_USE_TEMPLATE (olddecl))))
1425 /* One of the declarations is a template instantiation, and the
1426 other is not a template at all. That's OK. */
1428 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1430 /* In [namespace.alias] we have:
1432 In a declarative region, a namespace-alias-definition can be
1433 used to redefine a namespace-alias declared in that declarative
1434 region to refer only to the namespace to which it already
1437 Therefore, if we encounter a second alias directive for the same
1438 alias, we can just ignore the second directive. */
1439 if (DECL_NAMESPACE_ALIAS (newdecl)
1440 && (DECL_NAMESPACE_ALIAS (newdecl)
1441 == DECL_NAMESPACE_ALIAS (olddecl)))
1443 /* [namespace.alias]
1445 A namespace-name or namespace-alias shall not be declared as
1446 the name of any other entity in the same declarative region.
1447 A namespace-name defined at global scope shall not be
1448 declared as the name of any other entity in any global scope
1450 error ("declaration of namespace %qD conflicts with", newdecl);
1451 error ("previous declaration of namespace %q+D here", olddecl);
1452 return error_mark_node;
1456 const char *errmsg = redeclaration_error_message (newdecl, olddecl);
1459 error_at (DECL_SOURCE_LOCATION (newdecl), errmsg, newdecl);
1460 if (DECL_NAME (olddecl) != NULL_TREE)
1461 error ((DECL_INITIAL (olddecl) && namespace_bindings_p ())
1462 ? "%q+#D previously defined here"
1463 : "%q+#D previously declared here", olddecl);
1464 return error_mark_node;
1466 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1467 && DECL_INITIAL (olddecl) != NULL_TREE
1468 && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
1469 && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
1471 /* Prototype decl follows defn w/o prototype. */
1472 warning (0, "prototype for %q+#D", newdecl);
1473 warning (0, "%Jfollows non-prototype definition here", olddecl);
1475 else if ((TREE_CODE (olddecl) == FUNCTION_DECL
1476 || TREE_CODE (olddecl) == VAR_DECL)
1477 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
1480 If two declarations of the same function or object
1481 specify different linkage-specifications ..., the program
1482 is ill-formed.... Except for functions with C++ linkage,
1483 a function declaration without a linkage specification
1484 shall not precede the first linkage specification for
1485 that function. A function can be declared without a
1486 linkage specification after an explicit linkage
1487 specification has been seen; the linkage explicitly
1488 specified in the earlier declaration is not affected by
1489 such a function declaration.
1491 DR 563 raises the question why the restrictions on
1492 functions should not also apply to objects. Older
1493 versions of G++ silently ignore the linkage-specification
1501 which is clearly wrong. Therefore, we now treat objects
1503 if (current_lang_depth () == 0)
1505 /* There is no explicit linkage-specification, so we use
1506 the linkage from the previous declaration. */
1507 if (!DECL_LANG_SPECIFIC (newdecl))
1508 retrofit_lang_decl (newdecl);
1509 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1513 error ("previous declaration of %q+#D with %qL linkage",
1514 olddecl, DECL_LANGUAGE (olddecl));
1515 error ("conflicts with new declaration with %qL linkage",
1516 DECL_LANGUAGE (newdecl));
1520 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
1522 else if (TREE_CODE (olddecl) == FUNCTION_DECL)
1524 tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1525 tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1528 if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
1529 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
1531 for (; t1 && t1 != void_list_node;
1532 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
1533 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
1535 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
1538 permerror (input_location, "default argument given for parameter %d of %q#D",
1540 permerror (input_location, "after previous specification in %q+#D", olddecl);
1544 error ("default argument given for parameter %d of %q#D",
1546 error ("after previous specification in %q+#D",
1553 /* Do not merge an implicit typedef with an explicit one. In:
1557 typedef class A A __attribute__ ((foo));
1559 the attribute should apply only to the typedef. */
1560 if (TREE_CODE (olddecl) == TYPE_DECL
1561 && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
1562 || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
1565 /* If new decl is `static' and an `extern' was seen previously,
1567 warn_extern_redeclared_static (newdecl, olddecl);
1569 /* We have committed to returning 1 at this point. */
1570 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1572 /* Now that functions must hold information normally held
1573 by field decls, there is extra work to do so that
1574 declaration information does not get destroyed during
1576 if (DECL_VINDEX (olddecl))
1577 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
1578 if (DECL_CONTEXT (olddecl))
1579 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1580 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
1581 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1582 DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
1583 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
1584 DECL_INVALID_OVERRIDER_P (newdecl) |= DECL_INVALID_OVERRIDER_P (olddecl);
1585 DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
1586 if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
1587 SET_OVERLOADED_OPERATOR_CODE
1588 (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
1589 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
1591 /* Optionally warn about more than one declaration for the same
1592 name, but don't warn about a function declaration followed by a
1594 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
1595 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
1596 /* Don't warn about extern decl followed by definition. */
1597 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
1598 /* Don't warn about friends, let add_friend take care of it. */
1599 && ! (newdecl_is_friend || DECL_FRIEND_P (olddecl)))
1601 warning (OPT_Wredundant_decls, "redundant redeclaration of %qD in same scope", newdecl);
1602 warning (OPT_Wredundant_decls, "previous declaration of %q+D", olddecl);
1605 if (DECL_DELETED_FN (newdecl))
1607 error ("deleted definition of %qD", newdecl);
1608 error ("after previous declaration %q+D", olddecl);
1612 /* Deal with C++: must preserve virtual function table size. */
1613 if (TREE_CODE (olddecl) == TYPE_DECL)
1615 tree newtype = TREE_TYPE (newdecl);
1616 tree oldtype = TREE_TYPE (olddecl);
1618 if (newtype != error_mark_node && oldtype != error_mark_node
1619 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
1620 CLASSTYPE_FRIEND_CLASSES (newtype)
1621 = CLASSTYPE_FRIEND_CLASSES (oldtype);
1623 DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
1626 /* Copy all the DECL_... slots specified in the new decl
1627 except for any that we copy here from the old type. */
1628 DECL_ATTRIBUTES (newdecl)
1629 = (*targetm.merge_decl_attributes) (olddecl, newdecl);
1631 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1635 old_result = DECL_TEMPLATE_RESULT (olddecl);
1636 new_result = DECL_TEMPLATE_RESULT (newdecl);
1637 TREE_TYPE (olddecl) = TREE_TYPE (old_result);
1638 DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
1639 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
1640 DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
1642 DECL_ATTRIBUTES (old_result)
1643 = (*targetm.merge_decl_attributes) (old_result, new_result);
1645 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1647 if (GNU_INLINE_P (old_result) != GNU_INLINE_P (new_result)
1648 && DECL_INITIAL (new_result))
1650 if (DECL_INITIAL (old_result))
1651 DECL_UNINLINABLE (old_result) = 1;
1653 DECL_UNINLINABLE (old_result) = DECL_UNINLINABLE (new_result);
1654 DECL_EXTERNAL (old_result) = DECL_EXTERNAL (new_result);
1655 DECL_NOT_REALLY_EXTERN (old_result)
1656 = DECL_NOT_REALLY_EXTERN (new_result);
1657 DECL_INTERFACE_KNOWN (old_result)
1658 = DECL_INTERFACE_KNOWN (new_result);
1659 DECL_DECLARED_INLINE_P (old_result)
1660 = DECL_DECLARED_INLINE_P (new_result);
1661 DECL_DISREGARD_INLINE_LIMITS (old_result)
1662 |= DECL_DISREGARD_INLINE_LIMITS (new_result);
1667 DECL_DECLARED_INLINE_P (old_result)
1668 |= DECL_DECLARED_INLINE_P (new_result);
1669 DECL_DISREGARD_INLINE_LIMITS (old_result)
1670 |= DECL_DISREGARD_INLINE_LIMITS (new_result);
1671 check_redeclaration_exception_specification (newdecl, olddecl);
1675 /* If the new declaration is a definition, update the file and
1676 line information on the declaration, and also make
1677 the old declaration the same definition. */
1678 if (DECL_INITIAL (new_result) != NULL_TREE)
1680 DECL_SOURCE_LOCATION (olddecl)
1681 = DECL_SOURCE_LOCATION (old_result)
1682 = DECL_SOURCE_LOCATION (newdecl);
1683 DECL_INITIAL (old_result) = DECL_INITIAL (new_result);
1684 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1687 DECL_ARGUMENTS (old_result)
1688 = DECL_ARGUMENTS (new_result);
1689 for (parm = DECL_ARGUMENTS (old_result); parm;
1690 parm = TREE_CHAIN (parm))
1691 DECL_CONTEXT (parm) = old_result;
1700 /* Automatically handles default parameters. */
1701 tree oldtype = TREE_TYPE (olddecl);
1704 /* Merge the data types specified in the two decls. */
1705 newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1707 /* If merge_types produces a non-typedef type, just use the old type. */
1708 if (TREE_CODE (newdecl) == TYPE_DECL
1709 && newtype == DECL_ORIGINAL_TYPE (newdecl))
1712 if (TREE_CODE (newdecl) == VAR_DECL)
1714 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
1715 DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
1716 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl)
1717 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl);
1718 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl)
1719 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl);
1721 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
1722 if (DECL_LANG_SPECIFIC (olddecl)
1723 && CP_DECL_THREADPRIVATE_P (olddecl))
1725 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
1726 if (!DECL_LANG_SPECIFIC (newdecl))
1727 retrofit_lang_decl (newdecl);
1729 DECL_TLS_MODEL (newdecl) = DECL_TLS_MODEL (olddecl);
1730 CP_DECL_THREADPRIVATE_P (newdecl) = 1;
1734 /* Do this after calling `merge_types' so that default
1735 parameters don't confuse us. */
1736 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1737 check_redeclaration_exception_specification (newdecl, olddecl);
1738 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
1740 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1741 check_default_args (newdecl);
1743 /* Lay the type out, unless already done. */
1744 if (! same_type_p (newtype, oldtype)
1745 && TREE_TYPE (newdecl) != error_mark_node
1746 && !(processing_template_decl && uses_template_parms (newdecl)))
1747 layout_type (TREE_TYPE (newdecl));
1749 if ((TREE_CODE (newdecl) == VAR_DECL
1750 || TREE_CODE (newdecl) == PARM_DECL
1751 || TREE_CODE (newdecl) == RESULT_DECL
1752 || TREE_CODE (newdecl) == FIELD_DECL
1753 || TREE_CODE (newdecl) == TYPE_DECL)
1754 && !(processing_template_decl && uses_template_parms (newdecl)))
1755 layout_decl (newdecl, 0);
1757 /* Merge the type qualifiers. */
1758 if (TREE_READONLY (newdecl))
1759 TREE_READONLY (olddecl) = 1;
1760 if (TREE_THIS_VOLATILE (newdecl))
1761 TREE_THIS_VOLATILE (olddecl) = 1;
1762 if (TREE_NOTHROW (newdecl))
1763 TREE_NOTHROW (olddecl) = 1;
1765 /* Merge deprecatedness. */
1766 if (TREE_DEPRECATED (newdecl))
1767 TREE_DEPRECATED (olddecl) = 1;
1769 /* Preserve function specific target and optimization options */
1770 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1772 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl)
1773 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl))
1774 DECL_FUNCTION_SPECIFIC_TARGET (newdecl)
1775 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl);
1777 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl)
1778 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl))
1779 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl)
1780 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl);
1783 /* Merge the initialization information. */
1784 if (DECL_INITIAL (newdecl) == NULL_TREE
1785 && DECL_INITIAL (olddecl) != NULL_TREE)
1787 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1788 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
1789 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1791 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1792 DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
1796 /* Merge the section attribute.
1797 We want to issue an error if the sections conflict but that must be
1798 done later in decl_attributes since we are called before attributes
1800 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1801 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1803 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1805 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1806 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1807 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1808 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1809 TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl);
1810 DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
1811 DECL_IS_OPERATOR_NEW (newdecl) |= DECL_IS_OPERATOR_NEW (olddecl);
1812 DECL_PURE_P (newdecl) |= DECL_PURE_P (olddecl);
1813 TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
1814 DECL_LOOPING_CONST_OR_PURE_P (newdecl)
1815 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl);
1816 /* Keep the old RTL. */
1817 COPY_DECL_RTL (olddecl, newdecl);
1819 else if (TREE_CODE (newdecl) == VAR_DECL
1820 && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
1822 /* Keep the old RTL. We cannot keep the old RTL if the old
1823 declaration was for an incomplete object and the new
1824 declaration is not since many attributes of the RTL will
1826 COPY_DECL_RTL (olddecl, newdecl);
1829 /* If cannot merge, then use the new type and qualifiers,
1830 and don't preserve the old rtl. */
1833 /* Clean out any memory we had of the old declaration. */
1834 tree oldstatic = value_member (olddecl, static_aggregates);
1836 TREE_VALUE (oldstatic) = error_mark_node;
1838 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1839 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1840 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1841 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1844 /* Merge the storage class information. */
1845 merge_weak (newdecl, olddecl);
1847 if (DECL_ONE_ONLY (olddecl))
1848 DECL_COMDAT_GROUP (newdecl) = DECL_COMDAT_GROUP (olddecl);
1850 DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
1851 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1852 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
1853 if (! DECL_EXTERNAL (olddecl))
1854 DECL_EXTERNAL (newdecl) = 0;
1856 new_template_info = NULL_TREE;
1857 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
1859 bool new_redefines_gnu_inline = false;
1861 if (new_defines_function
1862 && ((DECL_INTERFACE_KNOWN (olddecl)
1863 && TREE_CODE (olddecl) == FUNCTION_DECL)
1864 || (TREE_CODE (olddecl) == TEMPLATE_DECL
1865 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
1866 == FUNCTION_DECL))))
1870 if (TREE_CODE (fn) == TEMPLATE_DECL)
1871 fn = DECL_TEMPLATE_RESULT (olddecl);
1873 new_redefines_gnu_inline = GNU_INLINE_P (fn) && DECL_INITIAL (fn);
1876 if (!new_redefines_gnu_inline)
1878 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
1879 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
1880 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
1882 DECL_TEMPLATE_INSTANTIATED (newdecl)
1883 |= DECL_TEMPLATE_INSTANTIATED (olddecl);
1885 /* If the OLDDECL is an instantiation and/or specialization,
1886 then the NEWDECL must be too. But, it may not yet be marked
1887 as such if the caller has created NEWDECL, but has not yet
1888 figured out that it is a redeclaration. */
1889 if (!DECL_USE_TEMPLATE (newdecl))
1890 DECL_USE_TEMPLATE (newdecl) = DECL_USE_TEMPLATE (olddecl);
1892 /* Don't really know how much of the language-specific
1893 values we should copy from old to new. */
1894 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
1895 DECL_REPO_AVAILABLE_P (newdecl) = DECL_REPO_AVAILABLE_P (olddecl);
1896 DECL_INITIALIZED_IN_CLASS_P (newdecl)
1897 |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
1899 if (LANG_DECL_HAS_MIN (newdecl))
1901 DECL_LANG_SPECIFIC (newdecl)->u.min.u2 =
1902 DECL_LANG_SPECIFIC (olddecl)->u.min.u2;
1903 if (DECL_TEMPLATE_INFO (newdecl))
1904 new_template_info = DECL_TEMPLATE_INFO (newdecl);
1905 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
1907 /* Only functions have these fields. */
1908 if (TREE_CODE (newdecl) == FUNCTION_DECL
1909 || DECL_FUNCTION_TEMPLATE_P (newdecl))
1911 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
1912 olddecl_friend = DECL_FRIEND_P (olddecl);
1913 hidden_friend = (DECL_ANTICIPATED (olddecl)
1914 && DECL_HIDDEN_FRIEND_P (olddecl)
1915 && newdecl_is_friend);
1916 DECL_BEFRIENDING_CLASSES (newdecl)
1917 = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
1918 DECL_BEFRIENDING_CLASSES (olddecl));
1919 /* DECL_THUNKS is only valid for virtual functions,
1920 otherwise it is a DECL_FRIEND_CONTEXT. */
1921 if (DECL_VIRTUAL_P (newdecl))
1922 DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl);
1926 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1930 /* Merge parameter attributes. */
1931 tree oldarg, newarg;
1932 for (oldarg = DECL_ARGUMENTS(olddecl),
1933 newarg = DECL_ARGUMENTS(newdecl);
1935 oldarg = TREE_CHAIN(oldarg), newarg = TREE_CHAIN(newarg)) {
1936 DECL_ATTRIBUTES (newarg)
1937 = (*targetm.merge_decl_attributes) (oldarg, newarg);
1938 DECL_ATTRIBUTES (oldarg) = DECL_ATTRIBUTES (newarg);
1941 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
1942 && !DECL_TEMPLATE_INSTANTIATION (newdecl))
1944 /* If newdecl is not a specialization, then it is not a
1945 template-related function at all. And that means that we
1946 should have exited above, returning 0. */
1947 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl));
1949 if (TREE_USED (olddecl))
1950 /* From [temp.expl.spec]:
1952 If a template, a member template or the member of a class
1953 template is explicitly specialized then that
1954 specialization shall be declared before the first use of
1955 that specialization that would cause an implicit
1956 instantiation to take place, in every translation unit in
1957 which such a use occurs. */
1958 error ("explicit specialization of %qD after first use",
1961 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
1963 /* Don't propagate visibility from the template to the
1964 specialization here. We'll do that in determine_visibility if
1966 DECL_VISIBILITY_SPECIFIED (olddecl) = 0;
1968 /* [temp.expl.spec/14] We don't inline explicit specialization
1969 just because the primary template says so. */
1971 else if (new_defines_function && DECL_INITIAL (olddecl))
1973 /* Never inline re-defined extern inline functions.
1974 FIXME: this could be better handled by keeping both
1975 function as separate declarations. */
1976 DECL_UNINLINABLE (newdecl) = 1;
1980 if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
1981 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
1983 DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
1985 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
1986 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
1988 DECL_DISREGARD_INLINE_LIMITS (newdecl)
1989 = DECL_DISREGARD_INLINE_LIMITS (olddecl)
1990 = (DECL_DISREGARD_INLINE_LIMITS (newdecl)
1991 || DECL_DISREGARD_INLINE_LIMITS (olddecl));
1994 /* Preserve abstractness on cloned [cd]tors. */
1995 DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
1997 /* Update newdecl's parms to point at olddecl. */
1998 for (parm = DECL_ARGUMENTS (newdecl); parm;
1999 parm = TREE_CHAIN (parm))
2000 DECL_CONTEXT (parm) = olddecl;
2004 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
2005 COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
2006 COPY_DECL_RTL (newdecl, olddecl);
2008 if (! types_match || new_defines_function)
2010 /* These need to be copied so that the names are available.
2011 Note that if the types do match, we'll preserve inline
2012 info and other bits, but if not, we won't. */
2013 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
2014 DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
2016 if (new_defines_function)
2017 /* If defining a function declared with other language
2018 linkage, use the previously declared language linkage. */
2019 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
2020 else if (types_match)
2022 /* If redeclaring a builtin function, and not a definition,
2023 it stays built in. */
2024 if (DECL_BUILT_IN (olddecl))
2026 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
2027 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
2028 /* If we're keeping the built-in definition, keep the rtl,
2029 regardless of declaration matches. */
2030 COPY_DECL_RTL (olddecl, newdecl);
2033 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
2034 /* Don't clear out the arguments if we're just redeclaring a
2036 if (DECL_ARGUMENTS (olddecl))
2037 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
2040 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
2041 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
2043 /* Now preserve various other info from the definition. */
2044 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
2045 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
2046 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
2047 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
2049 /* Warn about conflicting visibility specifications. */
2050 if (DECL_VISIBILITY_SPECIFIED (olddecl)
2051 && DECL_VISIBILITY_SPECIFIED (newdecl)
2052 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
2054 warning (OPT_Wattributes, "%q+D: visibility attribute ignored "
2055 "because it", newdecl);
2056 warning (OPT_Wattributes, "%Jconflicts with previous "
2057 "declaration here", olddecl);
2059 /* Choose the declaration which specified visibility. */
2060 if (DECL_VISIBILITY_SPECIFIED (olddecl))
2062 DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
2063 DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
2065 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2066 so keep this behavior. */
2067 if (TREE_CODE (newdecl) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (newdecl))
2069 SET_DECL_INIT_PRIORITY (olddecl, DECL_INIT_PRIORITY (newdecl));
2070 DECL_HAS_INIT_PRIORITY_P (olddecl) = 1;
2073 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2074 with that from NEWDECL below. */
2075 if (DECL_LANG_SPECIFIC (olddecl))
2077 gcc_assert (DECL_LANG_SPECIFIC (olddecl)
2078 != DECL_LANG_SPECIFIC (newdecl));
2079 ggc_free (DECL_LANG_SPECIFIC (olddecl));
2082 /* Merge the USED information. */
2083 if (TREE_USED (olddecl))
2084 TREE_USED (newdecl) = 1;
2085 else if (TREE_USED (newdecl))
2086 TREE_USED (olddecl) = 1;
2088 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2092 function_size = sizeof (struct tree_decl_common);
2094 memcpy ((char *) olddecl + sizeof (struct tree_common),
2095 (char *) newdecl + sizeof (struct tree_common),
2096 function_size - sizeof (struct tree_common));
2098 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2099 (char *) newdecl + sizeof (struct tree_decl_common),
2100 sizeof (struct tree_function_decl) - sizeof (struct tree_decl_common));
2101 if (new_template_info)
2102 /* If newdecl is a template instantiation, it is possible that
2103 the following sequence of events has occurred:
2105 o A friend function was declared in a class template. The
2106 class template was instantiated.
2108 o The instantiation of the friend declaration was
2109 recorded on the instantiation list, and is newdecl.
2111 o Later, however, instantiate_class_template called pushdecl
2112 on the newdecl to perform name injection. But, pushdecl in
2113 turn called duplicate_decls when it discovered that another
2114 declaration of a global function with the same name already
2117 o Here, in duplicate_decls, we decided to clobber newdecl.
2119 If we're going to do that, we'd better make sure that
2120 olddecl, and not newdecl, is on the list of
2121 instantiations so that if we try to do the instantiation
2122 again we won't get the clobbered declaration. */
2123 reregister_specialization (newdecl,
2129 size_t size = tree_code_size (TREE_CODE (olddecl));
2130 memcpy ((char *) olddecl + sizeof (struct tree_common),
2131 (char *) newdecl + sizeof (struct tree_common),
2132 sizeof (struct tree_decl_common) - sizeof (struct tree_common));
2133 switch (TREE_CODE (olddecl))
2143 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2144 (char *) newdecl + sizeof (struct tree_decl_common),
2145 size - sizeof (struct tree_decl_common)
2146 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2150 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2151 (char *) newdecl + sizeof (struct tree_decl_common),
2152 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common)
2153 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2157 DECL_UID (olddecl) = olddecl_uid;
2159 DECL_FRIEND_P (olddecl) = 1;
2162 DECL_ANTICIPATED (olddecl) = 1;
2163 DECL_HIDDEN_FRIEND_P (olddecl) = 1;
2166 /* NEWDECL contains the merged attribute lists.
2167 Update OLDDECL to be the same. */
2168 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
2170 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2171 so that encode_section_info has a chance to look at the new decl
2172 flags and attributes. */
2173 if (DECL_RTL_SET_P (olddecl)
2174 && (TREE_CODE (olddecl) == FUNCTION_DECL
2175 || (TREE_CODE (olddecl) == VAR_DECL
2176 && TREE_STATIC (olddecl))))
2177 make_decl_rtl (olddecl);
2179 /* The NEWDECL will no longer be needed. Because every out-of-class
2180 declaration of a member results in a call to duplicate_decls,
2181 freeing these nodes represents in a significant savings. */
2187 /* Return zero if the declaration NEWDECL is valid
2188 when the declaration OLDDECL (assumed to be for the same name)
2189 has already been seen.
2190 Otherwise return an error message format string with a %s
2191 where the identifier should go. */
2194 redeclaration_error_message (tree newdecl, tree olddecl)
2196 if (TREE_CODE (newdecl) == TYPE_DECL)
2198 /* Because C++ can put things into name space for free,
2199 constructs like "typedef struct foo { ... } foo"
2200 would look like an erroneous redeclaration. */
2201 if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
2204 return "redefinition of %q#D";
2206 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
2208 /* If this is a pure function, its olddecl will actually be
2209 the original initialization to `0' (which we force to call
2210 abort()). Don't complain about redefinition in this case. */
2211 if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl)
2212 && DECL_INITIAL (olddecl) == NULL_TREE)
2215 /* If both functions come from different namespaces, this is not
2216 a redeclaration - this is a conflict with a used function. */
2217 if (DECL_NAMESPACE_SCOPE_P (olddecl)
2218 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl)
2219 && ! decls_match (olddecl, newdecl))
2220 return "%qD conflicts with used function";
2222 /* We'll complain about linkage mismatches in
2223 warn_extern_redeclared_static. */
2225 /* Defining the same name twice is no good. */
2226 if (DECL_INITIAL (olddecl) != NULL_TREE
2227 && DECL_INITIAL (newdecl) != NULL_TREE)
2229 if (DECL_NAME (olddecl) == NULL_TREE)
2230 return "%q#D not declared in class";
2231 else if (!GNU_INLINE_P (olddecl)
2232 || GNU_INLINE_P (newdecl))
2233 return "redefinition of %q#D";
2236 if (DECL_DECLARED_INLINE_P (olddecl) && DECL_DECLARED_INLINE_P (newdecl))
2238 bool olda = GNU_INLINE_P (olddecl);
2239 bool newa = GNU_INLINE_P (newdecl);
2244 return "%q+D redeclared inline with %<gnu_inline%> attribute";
2246 return "%q+D redeclared inline without %<gnu_inline%> attribute";
2252 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2256 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2258 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl))
2259 && COMPLETE_TYPE_P (TREE_TYPE (olddecl)))
2260 return "redefinition of %q#D";
2264 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL
2265 || (DECL_TEMPLATE_RESULT (newdecl)
2266 == DECL_TEMPLATE_RESULT (olddecl)))
2269 nt = DECL_TEMPLATE_RESULT (newdecl);
2270 if (DECL_TEMPLATE_INFO (nt))
2271 nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt));
2272 ot = DECL_TEMPLATE_RESULT (olddecl);
2273 if (DECL_TEMPLATE_INFO (ot))
2274 ot = DECL_TEMPLATE_RESULT (template_for_substitution (ot));
2275 if (DECL_INITIAL (nt) && DECL_INITIAL (ot)
2276 && (!GNU_INLINE_P (ot) || GNU_INLINE_P (nt)))
2277 return "redefinition of %q#D";
2279 if (DECL_DECLARED_INLINE_P (ot) && DECL_DECLARED_INLINE_P (nt))
2281 bool olda = GNU_INLINE_P (ot);
2282 bool newa = GNU_INLINE_P (nt);
2287 return "%q+D redeclared inline with %<gnu_inline%> attribute";
2289 return "%q+D redeclared inline without %<gnu_inline%> attribute";
2293 /* Core issue #226 (C++0x):
2295 If a friend function template declaration specifies a
2296 default template-argument, that declaration shall be a
2297 definition and shall be the only declaration of the
2298 function template in the translation unit. */
2299 if ((cxx_dialect != cxx98)
2300 && TREE_CODE (ot) == FUNCTION_DECL && DECL_FRIEND_P (ot)
2301 && !check_default_tmpl_args (nt, DECL_TEMPLATE_PARMS (newdecl),
2302 /*is_primary=*/1, /*is_partial=*/0,
2303 /*is_friend_decl=*/2))
2304 return "redeclaration of friend %q#D may not have default template arguments";
2308 else if (TREE_CODE (newdecl) == VAR_DECL
2309 && DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl)
2310 && (! DECL_LANG_SPECIFIC (olddecl)
2311 || ! CP_DECL_THREADPRIVATE_P (olddecl)
2312 || DECL_THREAD_LOCAL_P (newdecl)))
2314 /* Only variables can be thread-local, and all declarations must
2315 agree on this property. */
2316 if (DECL_THREAD_LOCAL_P (newdecl))
2317 return "thread-local declaration of %q#D follows "
2318 "non-thread-local declaration";
2320 return "non-thread-local declaration of %q#D follows "
2321 "thread-local declaration";
2323 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
2325 /* The objects have been declared at namespace scope. If either
2326 is a member of an anonymous union, then this is an invalid
2327 redeclaration. For example:
2333 if ((TREE_CODE (newdecl) == VAR_DECL && DECL_ANON_UNION_VAR_P (newdecl))
2334 || (TREE_CODE (olddecl) == VAR_DECL && DECL_ANON_UNION_VAR_P (olddecl)))
2335 return "redeclaration of %q#D";
2336 /* If at least one declaration is a reference, there is no
2337 conflict. For example:
2343 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2345 /* Reject two definitions. */
2346 return "redefinition of %q#D";
2350 /* Objects declared with block scope: */
2351 /* Reject two definitions, and reject a definition
2352 together with an external reference. */
2353 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
2354 return "redeclaration of %q#D";
2359 /* Hash and equality functions for the named_label table. */
2362 named_label_entry_hash (const void *data)
2364 const struct named_label_entry *ent = (const struct named_label_entry *) data;
2365 return DECL_UID (ent->label_decl);
2369 named_label_entry_eq (const void *a, const void *b)
2371 const struct named_label_entry *ent_a = (const struct named_label_entry *) a;
2372 const struct named_label_entry *ent_b = (const struct named_label_entry *) b;
2373 return ent_a->label_decl == ent_b->label_decl;
2376 /* Create a new label, named ID. */
2379 make_label_decl (tree id, int local_p)
2381 struct named_label_entry *ent;
2385 decl = build_decl (input_location, LABEL_DECL, id, void_type_node);
2387 DECL_CONTEXT (decl) = current_function_decl;
2388 DECL_MODE (decl) = VOIDmode;
2389 C_DECLARED_LABEL_FLAG (decl) = local_p;
2391 /* Say where one reference is to the label, for the sake of the
2392 error if it is not defined. */
2393 DECL_SOURCE_LOCATION (decl) = input_location;
2395 /* Record the fact that this identifier is bound to this label. */
2396 SET_IDENTIFIER_LABEL_VALUE (id, decl);
2398 /* Create the label htab for the function on demand. */
2400 named_labels = htab_create_ggc (13, named_label_entry_hash,
2401 named_label_entry_eq, NULL);
2403 /* Record this label on the list of labels used in this function.
2404 We do this before calling make_label_decl so that we get the
2405 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2406 ent = GGC_CNEW (struct named_label_entry);
2407 ent->label_decl = decl;
2409 slot = htab_find_slot (named_labels, ent, INSERT);
2410 gcc_assert (*slot == NULL);
2416 /* Look for a label named ID in the current function. If one cannot
2417 be found, create one. (We keep track of used, but undefined,
2418 labels, and complain about them at the end of a function.) */
2421 lookup_label (tree id)
2425 timevar_push (TV_NAME_LOOKUP);
2426 /* You can't use labels at global scope. */
2427 if (current_function_decl == NULL_TREE)
2429 error ("label %qE referenced outside of any function", id);
2430 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2433 /* See if we've already got this label. */
2434 decl = IDENTIFIER_LABEL_VALUE (id);
2435 if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
2436 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2438 decl = make_label_decl (id, /*local_p=*/0);
2439 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2442 /* Declare a local label named ID. */
2445 declare_local_label (tree id)
2449 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2450 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2451 shadow = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
2452 current_binding_level->shadowed_labels);
2453 current_binding_level->shadowed_labels = shadow;
2455 decl = make_label_decl (id, /*local_p=*/1);
2456 TREE_VALUE (shadow) = decl;
2461 /* Returns nonzero if it is ill-formed to jump past the declaration of
2462 DECL. Returns 2 if it's also a real problem. */
2465 decl_jump_unsafe (tree decl)
2467 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl)
2468 || TREE_TYPE (decl) == error_mark_node)
2471 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
2472 || DECL_NONTRIVIALLY_INITIALIZED_P (decl))
2475 if (pod_type_p (TREE_TYPE (decl)))
2478 /* The POD stuff is just pedantry; why should it matter if the class
2479 contains a field of pointer to member type? */
2483 /* A subroutine of check_previous_goto_1 to identify a branch to the user. */
2486 identify_goto (tree decl, const location_t *locus)
2489 permerror (input_location, "jump to label %qD", decl);
2491 permerror (input_location, "jump to case label");
2493 permerror (*locus, " from here");
2496 /* Check that a single previously seen jump to a newly defined label
2497 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2498 the jump context; NAMES are the names in scope in LEVEL at the jump
2499 context; LOCUS is the source position of the jump or 0. Returns
2500 true if all is well. */
2503 check_previous_goto_1 (tree decl, struct cp_binding_level* level, tree names,
2504 bool exited_omp, const location_t *locus)
2506 struct cp_binding_level *b;
2507 bool identified = false, saw_eh = false, saw_omp = false;
2511 identify_goto (decl, locus);
2512 error (" exits OpenMP structured block");
2513 identified = saw_omp = true;
2516 for (b = current_binding_level; b ; b = b->level_chain)
2518 tree new_decls, old_decls = (b == level ? names : NULL_TREE);
2520 for (new_decls = b->names; new_decls != old_decls;
2521 new_decls = TREE_CHAIN (new_decls))
2523 int problem = decl_jump_unsafe (new_decls);
2529 identify_goto (decl, locus);
2533 error (" crosses initialization of %q+#D", new_decls);
2535 permerror (input_location, " enters scope of non-POD %q+#D", new_decls);
2540 if ((b->kind == sk_try || b->kind == sk_catch) && !saw_eh)
2544 identify_goto (decl, locus);
2547 if (b->kind == sk_try)
2548 error (" enters try block");
2550 error (" enters catch block");
2553 if (b->kind == sk_omp && !saw_omp)
2557 identify_goto (decl, locus);
2560 error (" enters OpenMP structured block");
2569 check_previous_goto (tree decl, struct named_label_use_entry *use)
2571 check_previous_goto_1 (decl, use->binding_level,
2572 use->names_in_scope, use->in_omp_scope,
2573 &use->o_goto_locus);
2577 check_switch_goto (struct cp_binding_level* level)
2579 return check_previous_goto_1 (NULL_TREE, level, level->names, false, NULL);
2582 /* Check that a new jump to a label DECL is OK. Called by
2583 finish_goto_stmt. */
2586 check_goto (tree decl)
2588 struct named_label_entry *ent, dummy;
2589 bool saw_catch = false, identified = false;
2592 /* We can't know where a computed goto is jumping.
2593 So we assume that it's OK. */
2594 if (TREE_CODE (decl) != LABEL_DECL)
2597 /* We didn't record any information about this label when we created it,
2598 and there's not much point since it's trivial to analyze as a return. */
2599 if (decl == cdtor_label)
2602 dummy.label_decl = decl;
2603 ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2604 gcc_assert (ent != NULL);
2606 /* If the label hasn't been defined yet, defer checking. */
2607 if (! DECL_INITIAL (decl))
2609 struct named_label_use_entry *new_use;
2611 /* Don't bother creating another use if the last goto had the
2612 same data, and will therefore create the same set of errors. */
2614 && ent->uses->names_in_scope == current_binding_level->names)
2617 new_use = GGC_NEW (struct named_label_use_entry);
2618 new_use->binding_level = current_binding_level;
2619 new_use->names_in_scope = current_binding_level->names;
2620 new_use->o_goto_locus = input_location;
2621 new_use->in_omp_scope = false;
2623 new_use->next = ent->uses;
2624 ent->uses = new_use;
2628 if (ent->in_try_scope || ent->in_catch_scope
2629 || ent->in_omp_scope || ent->bad_decls)
2631 permerror (input_location, "jump to label %q+D", decl);
2632 permerror (input_location, " from here");
2636 for (bad = ent->bad_decls; bad; bad = TREE_CHAIN (bad))
2638 tree b = TREE_VALUE (bad);
2639 int u = decl_jump_unsafe (b);
2641 if (u > 1 && DECL_ARTIFICIAL (b))
2643 /* Can't skip init of __exception_info. */
2644 error ("%J enters catch block", b);
2648 error (" skips initialization of %q+#D", b);
2650 permerror (input_location, " enters scope of non-POD %q+#D", b);
2653 if (ent->in_try_scope)
2654 error (" enters try block");
2655 else if (ent->in_catch_scope && !saw_catch)
2656 error (" enters catch block");
2658 if (ent->in_omp_scope)
2659 error (" enters OpenMP structured block");
2660 else if (flag_openmp)
2662 struct cp_binding_level *b;
2663 for (b = current_binding_level; b ; b = b->level_chain)
2665 if (b == ent->binding_level)
2667 if (b->kind == sk_omp)
2671 permerror (input_location, "jump to label %q+D", decl);
2672 permerror (input_location, " from here");
2675 error (" exits OpenMP structured block");
2682 /* Check that a return is ok wrt OpenMP structured blocks.
2683 Called by finish_return_stmt. Returns true if all is well. */
2686 check_omp_return (void)
2688 struct cp_binding_level *b;
2689 for (b = current_binding_level; b ; b = b->level_chain)
2690 if (b->kind == sk_omp)
2692 error ("invalid exit from OpenMP structured block");
2698 /* Define a label, specifying the location in the source file.
2699 Return the LABEL_DECL node for the label. */
2702 define_label (location_t location, tree name)
2704 struct named_label_entry *ent, dummy;
2705 struct cp_binding_level *p;
2708 timevar_push (TV_NAME_LOOKUP);
2710 decl = lookup_label (name);
2712 dummy.label_decl = decl;
2713 ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2714 gcc_assert (ent != NULL);
2716 /* After labels, make any new cleanups in the function go into their
2717 own new (temporary) binding contour. */
2718 for (p = current_binding_level;
2719 p->kind != sk_function_parms;
2721 p->more_cleanups_ok = 0;
2723 if (name == get_identifier ("wchar_t"))
2724 permerror (input_location, "label named wchar_t");
2726 if (DECL_INITIAL (decl) != NULL_TREE)
2728 error ("duplicate label %qD", decl);
2729 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
2733 struct named_label_use_entry *use;
2735 /* Mark label as having been defined. */
2736 DECL_INITIAL (decl) = error_mark_node;
2737 /* Say where in the source. */
2738 DECL_SOURCE_LOCATION (decl) = location;
2740 ent->binding_level = current_binding_level;
2741 ent->names_in_scope = current_binding_level->names;
2743 for (use = ent->uses; use ; use = use->next)
2744 check_previous_goto (decl, use);
2748 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2753 struct cp_binding_level *level;
2754 struct cp_switch *next;
2755 /* The SWITCH_STMT being built. */
2757 /* A splay-tree mapping the low element of a case range to the high
2758 element, or NULL_TREE if there is no high element. Used to
2759 determine whether or not a new case label duplicates an old case
2760 label. We need a tree, rather than simply a hash table, because
2761 of the GNU case range extension. */
2765 /* A stack of the currently active switch statements. The innermost
2766 switch statement is on the top of the stack. There is no need to
2767 mark the stack for garbage collection because it is only active
2768 during the processing of the body of a function, and we never
2769 collect at that point. */
2771 static struct cp_switch *switch_stack;
2773 /* Called right after a switch-statement condition is parsed.
2774 SWITCH_STMT is the switch statement being parsed. */
2777 push_switch (tree switch_stmt)
2779 struct cp_switch *p = XNEW (struct cp_switch);
2780 p->level = current_binding_level;
2781 p->next = switch_stack;
2782 p->switch_stmt = switch_stmt;
2783 p->cases = splay_tree_new (case_compare, NULL, NULL);
2790 struct cp_switch *cs = switch_stack;
2791 location_t switch_location;
2793 /* Emit warnings as needed. */
2794 if (EXPR_HAS_LOCATION (cs->switch_stmt))
2795 switch_location = EXPR_LOCATION (cs->switch_stmt);
2797 switch_location = input_location;
2798 if (!processing_template_decl)
2799 c_do_switch_warnings (cs->cases, switch_location,
2800 SWITCH_STMT_TYPE (cs->switch_stmt),
2801 SWITCH_STMT_COND (cs->switch_stmt));
2803 splay_tree_delete (cs->cases);
2804 switch_stack = switch_stack->next;
2808 /* Note that we've seen a definition of a case label, and complain if this
2809 is a bad place for one. */
2812 finish_case_label (location_t loc, tree low_value, tree high_value)
2815 struct cp_binding_level *p;
2817 if (processing_template_decl)
2821 /* For templates, just add the case label; we'll do semantic
2822 analysis at instantiation-time. */
2823 label = build_decl (loc, LABEL_DECL, NULL_TREE, NULL_TREE);
2824 return add_stmt (build_case_label (loc, low_value, high_value, label));
2827 /* Find the condition on which this switch statement depends. */
2828 cond = SWITCH_STMT_COND (switch_stack->switch_stmt);
2829 if (cond && TREE_CODE (cond) == TREE_LIST)
2830 cond = TREE_VALUE (cond);
2832 if (!check_switch_goto (switch_stack->level))
2833 return error_mark_node;
2835 r = c_add_case_label (loc, switch_stack->cases, cond,
2836 SWITCH_STMT_TYPE (switch_stack->switch_stmt),
2837 low_value, high_value);
2839 /* After labels, make any new cleanups in the function go into their
2840 own new (temporary) binding contour. */
2841 for (p = current_binding_level;
2842 p->kind != sk_function_parms;
2844 p->more_cleanups_ok = 0;
2849 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
2852 typename_hash (const void* k)
2855 const_tree const t = (const_tree) k;
2857 hash = (htab_hash_pointer (TYPE_CONTEXT (t))
2858 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));
2863 typedef struct typename_info {
2871 /* Compare two TYPENAME_TYPEs. K1 is really of type `tree', K2 is
2872 really of type `typename_info*' */
2875 typename_compare (const void * k1, const void * k2)
2877 const_tree const t1 = (const_tree) k1;
2878 const typename_info *const t2 = (const typename_info *) k2;
2880 return (DECL_NAME (TYPE_NAME (t1)) == t2->name
2881 && TYPE_CONTEXT (t1) == t2->scope
2882 && TYPENAME_TYPE_FULLNAME (t1) == t2->template_id
2883 && TYPENAME_IS_ENUM_P (t1) == t2->enum_p
2884 && TYPENAME_IS_CLASS_P (t1) == t2->class_p);
2887 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
2888 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
2890 Returns the new TYPENAME_TYPE. */
2892 static GTY ((param_is (union tree_node))) htab_t typename_htab;
2895 build_typename_type (tree context, tree name, tree fullname,
2896 enum tag_types tag_type)
2904 if (typename_htab == NULL)
2905 typename_htab = htab_create_ggc (61, &typename_hash,
2906 &typename_compare, NULL);
2908 ti.scope = FROB_CONTEXT (context);
2910 ti.template_id = fullname;
2911 ti.enum_p = tag_type == enum_type;
2912 ti.class_p = (tag_type == class_type
2913 || tag_type == record_type
2914 || tag_type == union_type);
2915 hash = (htab_hash_pointer (ti.scope)
2916 ^ htab_hash_pointer (ti.name));
2918 /* See if we already have this type. */
2919 e = htab_find_slot_with_hash (typename_htab, &ti, hash, INSERT);
2924 /* Build the TYPENAME_TYPE. */
2925 t = cxx_make_type (TYPENAME_TYPE);
2926 TYPE_CONTEXT (t) = ti.scope;
2927 TYPENAME_TYPE_FULLNAME (t) = ti.template_id;
2928 TYPENAME_IS_ENUM_P (t) = ti.enum_p;
2929 TYPENAME_IS_CLASS_P (t) = ti.class_p;
2931 /* Build the corresponding TYPE_DECL. */
2932 d = build_decl (input_location, TYPE_DECL, name, t);
2933 TYPE_NAME (TREE_TYPE (d)) = d;
2934 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2935 DECL_CONTEXT (d) = FROB_CONTEXT (context);
2936 DECL_ARTIFICIAL (d) = 1;
2938 /* Store it in the hash table. */
2941 /* TYPENAME_TYPEs must always be compared structurally, because
2942 they may or may not resolve down to another type depending on
2943 the currently open classes. */
2944 SET_TYPE_STRUCTURAL_EQUALITY (t);
2950 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
2951 provided to name the type. Returns an appropriate type, unless an
2952 error occurs, in which case error_mark_node is returned. If we
2953 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
2954 return that, rather than the _TYPE it corresponds to, in other
2955 cases we look through the type decl. If TF_ERROR is set, complain
2956 about errors, otherwise be quiet. */
2959 make_typename_type (tree context, tree name, enum tag_types tag_type,
2960 tsubst_flags_t complain)
2966 if (name == error_mark_node
2967 || context == NULL_TREE
2968 || context == error_mark_node)
2969 return error_mark_node;
2973 if (!(TYPE_LANG_SPECIFIC (name)
2974 && (CLASSTYPE_IS_TEMPLATE (name)
2975 || CLASSTYPE_USE_TEMPLATE (name))))
2976 name = TYPE_IDENTIFIER (name);
2978 /* Create a TEMPLATE_ID_EXPR for the type. */
2979 name = build_nt (TEMPLATE_ID_EXPR,
2980 CLASSTYPE_TI_TEMPLATE (name),
2981 CLASSTYPE_TI_ARGS (name));
2983 else if (TREE_CODE (name) == TYPE_DECL)
2984 name = DECL_NAME (name);
2988 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
2990 name = TREE_OPERAND (name, 0);
2991 if (TREE_CODE (name) == TEMPLATE_DECL)
2992 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
2993 else if (TREE_CODE (name) == OVERLOAD)
2995 error ("%qD is not a type", name);
2996 return error_mark_node;
2999 if (TREE_CODE (name) == TEMPLATE_DECL)
3001 error ("%qD used without template parameters", name);
3002 return error_mark_node;
3004 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
3005 gcc_assert (TYPE_P (context));
3007 if (!MAYBE_CLASS_TYPE_P (context))
3009 if (complain & tf_error)
3010 error ("%q#T is not a class", context);
3011 return error_mark_node;
3014 /* When the CONTEXT is a dependent type, NAME could refer to a
3015 dependent base class of CONTEXT. But look inside it anyway
3016 if CONTEXT is a currently open scope, in case it refers to a
3017 member of the current instantiation or a non-dependent base;
3018 lookup will stop when we hit a dependent base. */
3019 if (!dependent_scope_p (context))
3020 /* We should only set WANT_TYPE when we're a nested typename type.
3021 Then we can give better diagnostics if we find a non-type. */
3022 t = lookup_field (context, name, 0, /*want_type=*/true);
3026 if (!t && dependent_type_p (context))
3027 return build_typename_type (context, name, fullname, tag_type);
3029 want_template = TREE_CODE (fullname) == TEMPLATE_ID_EXPR;
3033 if (complain & tf_error)
3034 error (want_template ? "no class template named %q#T in %q#T"
3035 : "no type named %q#T in %q#T", name, context);
3036 return error_mark_node;
3039 if (want_template && !DECL_CLASS_TEMPLATE_P (t))
3041 if (complain & tf_error)
3042 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3044 return error_mark_node;
3046 if (!want_template && TREE_CODE (t) != TYPE_DECL)
3048 if (complain & tf_error)
3049 error ("%<typename %T::%D%> names %q#T, which is not a type",
3051 return error_mark_node;
3054 if (complain & tf_error)
3055 perform_or_defer_access_check (TYPE_BINFO (context), t, t);
3058 return lookup_template_class (t, TREE_OPERAND (fullname, 1),
3060 /*entering_scope=*/0,
3061 tf_warning_or_error | tf_user);
3063 if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
3069 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3070 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3071 in which case error_mark_node is returned.
3073 If PARM_LIST is non-NULL, also make sure that the template parameter
3074 list of TEMPLATE_DECL matches.
3076 If COMPLAIN zero, don't complain about any errors that occur. */
3079 make_unbound_class_template (tree context, tree name, tree parm_list,
3080 tsubst_flags_t complain)
3086 name = TYPE_IDENTIFIER (name);
3087 else if (DECL_P (name))
3088 name = DECL_NAME (name);
3089 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
3091 if (!dependent_type_p (context)
3092 || currently_open_class (context))
3094 tree tmpl = NULL_TREE;
3096 if (MAYBE_CLASS_TYPE_P (context))
3097 tmpl = lookup_field (context, name, 0, false);
3099 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
3101 if (complain & tf_error)
3102 error ("no class template named %q#T in %q#T", name, context);
3103 return error_mark_node;
3107 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl), parm_list))
3109 if (complain & tf_error)
3111 error ("template parameters do not match template");
3112 error ("%q+D declared here", tmpl);
3114 return error_mark_node;
3117 if (complain & tf_error)
3118 perform_or_defer_access_check (TYPE_BINFO (context), tmpl, tmpl);
3123 /* Build the UNBOUND_CLASS_TEMPLATE. */
3124 t = cxx_make_type (UNBOUND_CLASS_TEMPLATE);
3125 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
3126 TREE_TYPE (t) = NULL_TREE;
3127 SET_TYPE_STRUCTURAL_EQUALITY (t);
3129 /* Build the corresponding TEMPLATE_DECL. */
3130 d = build_decl (input_location, TEMPLATE_DECL, name, t);
3131 TYPE_NAME (TREE_TYPE (d)) = d;
3132 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
3133 DECL_CONTEXT (d) = FROB_CONTEXT (context);
3134 DECL_ARTIFICIAL (d) = 1;
3135 DECL_TEMPLATE_PARMS (d) = parm_list;
3142 /* Push the declarations of builtin types into the namespace.
3143 RID_INDEX is the index of the builtin type in the array
3144 RID_POINTERS. NAME is the name used when looking up the builtin
3145 type. TYPE is the _TYPE node for the builtin type. */
3148 record_builtin_type (enum rid rid_index,
3152 tree rname = NULL_TREE, tname = NULL_TREE;
3153 tree tdecl = NULL_TREE;
3155 if ((int) rid_index < (int) RID_MAX)
3156 rname = ridpointers[(int) rid_index];
3158 tname = get_identifier (name);
3160 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
3161 eliminated. Built-in types should not be looked up name; their
3162 names are keywords that the parser can recognize. However, there
3163 is code in c-common.c that uses identifier_global_value to look
3164 up built-in types by name. */
3167 tdecl = build_decl (BUILTINS_LOCATION, TYPE_DECL, tname, type);
3168 DECL_ARTIFICIAL (tdecl) = 1;
3169 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
3175 tdecl = build_decl (BUILTINS_LOCATION, TYPE_DECL, rname, type);
3176 DECL_ARTIFICIAL (tdecl) = 1;
3178 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
3181 if (!TYPE_NAME (type))
3182 TYPE_NAME (type) = tdecl;
3185 debug_hooks->type_decl (tdecl, 0);
3188 /* Record one of the standard Java types.
3189 * Declare it as having the given NAME.
3190 * If SIZE > 0, it is the size of one of the integral types;
3191 * otherwise it is the negative of the size of one of the other types. */
3194 record_builtin_java_type (const char* name, int size)
3198 type = build_nonstandard_integer_type (size, 0);
3199 else if (size > -32)
3202 /* "__java_char" or ""__java_boolean". */
3203 type = build_nonstandard_integer_type (-size, 1);
3204 /* Get the signed type cached and attached to the unsigned type,
3205 so it doesn't get garbage-collected at "random" times,
3206 causing potential codegen differences out of different UIDs
3207 and different alias set numbers. */
3208 stype = build_nonstandard_integer_type (-size, 0);
3209 TREE_CHAIN (type) = stype;
3210 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
3213 { /* "__java_float" or ""__java_double". */
3214 type = make_node (REAL_TYPE);
3215 TYPE_PRECISION (type) = - size;
3218 record_builtin_type (RID_MAX, name, type);
3219 decl = TYPE_NAME (type);
3221 /* Suppress generate debug symbol entries for these types,
3222 since for normal C++ they are just clutter.
3223 However, push_lang_context undoes this if extern "Java" is seen. */
3224 DECL_IGNORED_P (decl) = 1;
3226 TYPE_FOR_JAVA (type) = 1;
3230 /* Push a type into the namespace so that the back ends ignore it. */
3233 record_unknown_type (tree type, const char* name)
3235 tree decl = pushdecl (build_decl (UNKNOWN_LOCATION,
3236 TYPE_DECL, get_identifier (name), type));
3237 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3238 DECL_IGNORED_P (decl) = 1;
3239 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
3240 TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
3241 TYPE_ALIGN (type) = 1;
3242 TYPE_USER_ALIGN (type) = 0;
3243 SET_TYPE_MODE (type, TYPE_MODE (void_type_node));
3246 /* A string for which we should create an IDENTIFIER_NODE at
3249 typedef struct predefined_identifier
3251 /* The name of the identifier. */
3252 const char *const name;
3253 /* The place where the IDENTIFIER_NODE should be stored. */
3255 /* Nonzero if this is the name of a constructor or destructor. */
3256 const int ctor_or_dtor_p;
3257 } predefined_identifier;
3259 /* Create all the predefined identifiers. */
3262 initialize_predefined_identifiers (void)
3264 const predefined_identifier *pid;
3266 /* A table of identifiers to create at startup. */
3267 static const predefined_identifier predefined_identifiers[] = {
3268 { "C++", &lang_name_cplusplus, 0 },
3269 { "C", &lang_name_c, 0 },
3270 { "Java", &lang_name_java, 0 },
3271 /* Some of these names have a trailing space so that it is
3272 impossible for them to conflict with names written by users. */
3273 { "__ct ", &ctor_identifier, 1 },
3274 { "__base_ctor ", &base_ctor_identifier, 1 },
3275 { "__comp_ctor ", &complete_ctor_identifier, 1 },
3276 { "__dt ", &dtor_identifier, 1 },
3277 { "__comp_dtor ", &complete_dtor_identifier, 1 },
3278 { "__base_dtor ", &base_dtor_identifier, 1 },
3279 { "__deleting_dtor ", &deleting_dtor_identifier, 1 },
3280 { IN_CHARGE_NAME, &in_charge_identifier, 0 },
3281 { "nelts", &nelts_identifier, 0 },
3282 { THIS_NAME, &this_identifier, 0 },
3283 { VTABLE_DELTA_NAME, &delta_identifier, 0 },
3284 { VTABLE_PFN_NAME, &pfn_identifier, 0 },
3285 { "_vptr", &vptr_identifier, 0 },
3286 { "__vtt_parm", &vtt_parm_identifier, 0 },
3287 { "::", &global_scope_name, 0 },
3288 { "std", &std_identifier, 0 },
3292 for (pid = predefined_identifiers; pid->name; ++pid)
3294 *pid->node = get_identifier (pid->name);
3295 if (pid->ctor_or_dtor_p)
3296 IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
3300 /* Create the predefined scalar types of C,
3301 and some nodes representing standard constants (0, 1, (void *)0).
3302 Initialize the global binding level.
3303 Make definitions for built-in primitive functions. */
3306 cxx_init_decl_processing (void)
3309 tree void_ftype_ptr;
3311 build_common_tree_nodes (flag_signed_char, false);
3313 /* Create all the identifiers we need. */
3314 initialize_predefined_identifiers ();
3316 /* Create the global variables. */
3317 push_to_top_level ();
3319 current_function_decl = NULL_TREE;
3320 current_binding_level = NULL;
3321 /* Enter the global namespace. */
3322 gcc_assert (global_namespace == NULL_TREE);
3323 global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name,
3325 TREE_PUBLIC (global_namespace) = 1;
3326 begin_scope (sk_namespace, global_namespace);
3328 current_lang_name = NULL_TREE;
3330 if (flag_visibility_ms_compat)
3331 default_visibility = VISIBILITY_HIDDEN;
3334 current_lang_name = lang_name_c;
3336 /* Create the `std' namespace. */
3337 push_namespace (std_identifier);
3338 std_node = current_namespace;
3341 c_common_nodes_and_builtins ();
3343 java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
3344 java_short_type_node = record_builtin_java_type ("__java_short", 16);
3345 java_int_type_node = record_builtin_java_type ("__java_int", 32);
3346 java_long_type_node = record_builtin_java_type ("__java_long", 64);
3347 java_float_type_node = record_builtin_java_type ("__java_float", -32);
3348 java_double_type_node = record_builtin_java_type ("__java_double", -64);
3349 java_char_type_node = record_builtin_java_type ("__java_char", -16);
3350 java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
3352 integer_two_node = build_int_cst (NULL_TREE, 2);
3353 integer_three_node = build_int_cst (NULL_TREE, 3);
3355 record_builtin_type (RID_BOOL, "bool", boolean_type_node);
3356 truthvalue_type_node = boolean_type_node;
3357 truthvalue_false_node = boolean_false_node;
3358 truthvalue_true_node = boolean_true_node;
3360 empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
3363 record_builtin_type (RID_MAX, NULL, string_type_node);
3366 delta_type_node = ptrdiff_type_node;
3367 vtable_index_type = ptrdiff_type_node;
3369 vtt_parm_type = build_pointer_type (const_ptr_type_node);
3370 void_ftype = build_function_type (void_type_node, void_list_node);
3371 void_ftype_ptr = build_function_type (void_type_node,
3372 tree_cons (NULL_TREE,
3376 = build_exception_variant (void_ftype_ptr, empty_except_spec);
3378 /* C++ extensions */
3380 unknown_type_node = make_node (UNKNOWN_TYPE);
3381 record_unknown_type (unknown_type_node, "unknown type");
3383 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3384 TREE_TYPE (unknown_type_node) = unknown_type_node;
3386 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3388 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
3389 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
3391 init_list_type_node = make_node (UNKNOWN_TYPE);
3392 record_unknown_type (init_list_type_node, "init list");
3395 /* Make sure we get a unique function type, so we can give
3396 its pointer type a name. (This wins for gdb.) */
3397 tree vfunc_type = make_node (FUNCTION_TYPE);
3398 TREE_TYPE (vfunc_type) = integer_type_node;
3399 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
3400 layout_type (vfunc_type);
3402 vtable_entry_type = build_pointer_type (vfunc_type);
3404 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
3407 = build_cplus_array_type (vtable_entry_type, NULL_TREE);
3408 layout_type (vtbl_type_node);
3409 vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
3410 record_builtin_type (RID_MAX, NULL, vtbl_type_node);
3411 vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
3412 layout_type (vtbl_ptr_type_node);
3413 record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
3415 push_namespace (get_identifier ("__cxxabiv1"));
3416 abi_node = current_namespace;
3419 global_type_node = make_node (LANG_TYPE);
3420 record_unknown_type (global_type_node, "global type");
3423 current_lang_name = lang_name_cplusplus;
3427 tree bad_alloc_type_node;
3428 tree bad_alloc_decl;
3429 tree newtype, deltype;
3430 tree ptr_ftype_sizetype;
3432 push_namespace (std_identifier);
3433 bad_alloc_id = get_identifier ("bad_alloc");
3434 bad_alloc_type_node = make_class_type (RECORD_TYPE);
3435 TYPE_CONTEXT (bad_alloc_type_node) = current_namespace;
3437 = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node);
3438 DECL_CONTEXT (bad_alloc_decl) = current_namespace;
3439 TYPE_STUB_DECL (bad_alloc_type_node) = bad_alloc_decl;
3443 = build_function_type (ptr_type_node,
3444 tree_cons (NULL_TREE,
3447 newtype = build_exception_variant
3448 (ptr_ftype_sizetype, add_exception_specifier
3449 (NULL_TREE, bad_alloc_type_node, -1));
3450 deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
3451 push_cp_library_fn (NEW_EXPR, newtype);
3452 push_cp_library_fn (VEC_NEW_EXPR, newtype);
3453 global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
3454 push_cp_library_fn (VEC_DELETE_EXPR, deltype);
3458 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
3460 /* Perform other language dependent initializations. */
3461 init_class_processing ();
3462 init_rtti_processing ();
3463 init_template_processing ();
3465 if (flag_exceptions)
3466 init_exception_processing ();
3468 if (! supports_one_only ())
3471 make_fname_decl = cp_make_fname_decl;
3472 start_fname_decls ();
3474 /* Show we use EH for cleanups. */
3475 if (flag_exceptions)
3476 using_eh_for_cleanups ();
3479 /* Generate an initializer for a function naming variable from
3480 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3481 filled in with the type of the init. */
3484 cp_fname_init (const char* name, tree *type_p)
3486 tree domain = NULL_TREE;
3488 tree init = NULL_TREE;
3493 length = strlen (name);
3494 domain = build_index_type (size_int (length));
3495 init = build_string (length + 1, name);
3498 type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
3499 type = build_cplus_array_type (type, domain);
3504 TREE_TYPE (init) = type;
3506 init = error_mark_node;
3511 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
3512 the decl, LOC is the location to give the decl, NAME is the
3513 initialization string and TYPE_DEP indicates whether NAME depended
3514 on the type of the function. We make use of that to detect
3515 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
3516 at the point of first use, so we mustn't push the decl now. */
3519 cp_make_fname_decl (location_t loc, tree id, int type_dep)
3521 const char *const name = (type_dep && processing_template_decl
3522 ? NULL : fname_as_string (type_dep));
3524 tree init = cp_fname_init (name, &type);
3525 tree decl = build_decl (loc, VAR_DECL, id, type);
3528 free (CONST_CAST (char *, name));
3530 /* As we're using pushdecl_with_scope, we must set the context. */
3531 DECL_CONTEXT (decl) = current_function_decl;
3532 DECL_PRETTY_FUNCTION_P (decl) = type_dep;
3534 TREE_STATIC (decl) = 1;
3535 TREE_READONLY (decl) = 1;
3536 DECL_ARTIFICIAL (decl) = 1;
3538 TREE_USED (decl) = 1;
3540 if (current_function_decl)
3542 struct cp_binding_level *b = current_binding_level;
3543 while (b->level_chain->kind != sk_function_parms)
3545 pushdecl_with_scope (decl, b, /*is_friend=*/false);
3546 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE,
3547 LOOKUP_ONLYCONVERTING);
3550 pushdecl_top_level_and_finish (decl, init);
3556 builtin_function_1 (tree decl, tree context, bool is_global)
3558 tree id = DECL_NAME (decl);
3559 const char *name = IDENTIFIER_POINTER (id);
3561 retrofit_lang_decl (decl);
3563 /* All nesting of C++ functions is lexical; there is never a "static
3564 chain" in the sense of GNU C nested functions. */
3565 DECL_NO_STATIC_CHAIN (decl) = 1;
3567 DECL_ARTIFICIAL (decl) = 1;
3568 SET_OVERLOADED_OPERATOR_CODE (decl, ERROR_MARK);
3569 SET_DECL_LANGUAGE (decl, lang_c);
3570 /* Runtime library routines are, by definition, available in an
3571 external shared object. */
3572 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
3573 DECL_VISIBILITY_SPECIFIED (decl) = 1;
3575 DECL_CONTEXT (decl) = context;
3578 pushdecl_top_level (decl);
3582 /* A function in the user's namespace should have an explicit
3583 declaration before it is used. Mark the built-in function as
3584 anticipated but not actually declared. */
3585 if (name[0] != '_' || name[1] != '_')
3586 DECL_ANTICIPATED (decl) = 1;
3587 else if (strncmp (name + 2, "builtin_", strlen ("builtin_")) != 0)
3589 size_t len = strlen (name);
3591 /* Treat __*_chk fortification functions as anticipated as well,
3592 unless they are __builtin_*. */
3593 if (len > strlen ("___chk")
3594 && memcmp (name + len - strlen ("_chk"),
3595 "_chk", strlen ("_chk") + 1) == 0)
3596 DECL_ANTICIPATED (decl) = 1;
3603 cxx_builtin_function (tree decl)
3605 tree id = DECL_NAME (decl);
3606 const char *name = IDENTIFIER_POINTER (id);
3607 /* All builtins that don't begin with an '_' should additionally
3608 go in the 'std' namespace. */
3611 tree decl2 = copy_node(decl);
3612 push_namespace (std_identifier);
3613 builtin_function_1 (decl2, std_node, false);
3617 return builtin_function_1 (decl, NULL_TREE, false);
3620 /* Like cxx_builtin_function, but guarantee the function is added to the global
3621 scope. This is to allow function specific options to add new machine
3622 dependent builtins when the target ISA changes via attribute((target(...)))
3623 which saves space on program startup if the program does not use non-generic
3627 cxx_builtin_function_ext_scope (tree decl)
3630 tree id = DECL_NAME (decl);
3631 const char *name = IDENTIFIER_POINTER (id);
3632 /* All builtins that don't begin with an '_' should additionally
3633 go in the 'std' namespace. */
3636 tree decl2 = copy_node(decl);
3637 push_namespace (std_identifier);
3638 builtin_function_1 (decl2, std_node, true);
3642 return builtin_function_1 (decl, NULL_TREE, true);
3645 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
3646 function. Not called directly. */
3649 build_library_fn_1 (tree name, enum tree_code operator_code, tree type)
3651 tree fn = build_lang_decl (FUNCTION_DECL, name, type);
3652 DECL_EXTERNAL (fn) = 1;
3653 TREE_PUBLIC (fn) = 1;
3654 DECL_ARTIFICIAL (fn) = 1;
3655 SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
3656 SET_DECL_LANGUAGE (fn, lang_c);
3657 /* Runtime library routines are, by definition, available in an
3658 external shared object. */
3659 DECL_VISIBILITY (fn) = VISIBILITY_DEFAULT;
3660 DECL_VISIBILITY_SPECIFIED (fn) = 1;
3664 /* Returns the _DECL for a library function with C linkage.
3665 We assume that such functions never throw; if this is incorrect,
3666 callers should unset TREE_NOTHROW. */
3669 build_library_fn (tree name, tree type)
3671 tree fn = build_library_fn_1 (name, ERROR_MARK, type);
3672 TREE_NOTHROW (fn) = 1;
3676 /* Returns the _DECL for a library function with C++ linkage. */
3679 build_cp_library_fn (tree name, enum tree_code operator_code, tree type)
3681 tree fn = build_library_fn_1 (name, operator_code, type);
3682 TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
3683 DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
3684 SET_DECL_LANGUAGE (fn, lang_cplusplus);
3688 /* Like build_library_fn, but takes a C string instead of an
3692 build_library_fn_ptr (const char* name, tree type)
3694 return build_library_fn (get_identifier (name), type);
3697 /* Like build_cp_library_fn, but takes a C string instead of an
3701 build_cp_library_fn_ptr (const char* name, tree type)
3703 return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
3706 /* Like build_library_fn, but also pushes the function so that we will
3707 be able to find it via IDENTIFIER_GLOBAL_VALUE. Also, the function
3708 may throw exceptions listed in RAISES. */
3711 push_library_fn (tree name, tree type, tree raises)
3716 type = build_exception_variant (type, raises);
3718 fn = build_library_fn (name, type);
3719 pushdecl_top_level (fn);
3723 /* Like build_cp_library_fn, but also pushes the function so that it
3724 will be found by normal lookup. */
3727 push_cp_library_fn (enum tree_code operator_code, tree type)
3729 tree fn = build_cp_library_fn (ansi_opname (operator_code),
3736 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
3740 push_void_library_fn (tree name, tree parmtypes)
3742 tree type = build_function_type (void_type_node, parmtypes);
3743 return push_library_fn (name, type, NULL_TREE);
3746 /* Like push_library_fn, but also note that this function throws
3747 and does not return. Used for __throw_foo and the like. */
3750 push_throw_library_fn (tree name, tree type)
3752 tree fn = push_library_fn (name, type, NULL_TREE);
3753 TREE_THIS_VOLATILE (fn) = 1;
3754 TREE_NOTHROW (fn) = 0;
3758 /* When we call finish_struct for an anonymous union, we create
3759 default copy constructors and such. But, an anonymous union
3760 shouldn't have such things; this function undoes the damage to the
3761 anonymous union type T.
3763 (The reason that we create the synthesized methods is that we don't
3764 distinguish `union { int i; }' from `typedef union { int i; } U'.
3765 The first is an anonymous union; the second is just an ordinary
3769 fixup_anonymous_aggr (tree t)
3773 /* Wipe out memory of synthesized methods. */
3774 TYPE_HAS_USER_CONSTRUCTOR (t) = 0;
3775 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
3776 TYPE_HAS_INIT_REF (t) = 0;
3777 TYPE_HAS_CONST_INIT_REF (t) = 0;
3778 TYPE_HAS_ASSIGN_REF (t) = 0;
3779 TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
3781 /* Splice the implicitly generated functions out of the TYPE_METHODS
3783 q = &TYPE_METHODS (t);
3786 if (DECL_ARTIFICIAL (*q))
3787 *q = TREE_CHAIN (*q);
3789 q = &TREE_CHAIN (*q);
3792 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
3793 if (TYPE_METHODS (t))
3795 tree decl = TYPE_MAIN_DECL (t);
3797 if (TREE_CODE (t) != UNION_TYPE)
3798 error ("%Jan anonymous struct cannot have function members", decl);
3800 error ("%Jan anonymous union cannot have function members", decl);
3803 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
3804 assignment operators (because they cannot have these methods themselves).
3805 For anonymous unions this is already checked because they are not allowed
3806 in any union, otherwise we have to check it. */
3807 if (TREE_CODE (t) != UNION_TYPE)
3811 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
3812 if (TREE_CODE (field) == FIELD_DECL)
3814 type = TREE_TYPE (field);
3815 if (CLASS_TYPE_P (type))
3817 if (TYPE_NEEDS_CONSTRUCTING (type))
3818 error ("member %q+#D with constructor not allowed "
3819 "in anonymous aggregate", field);
3820 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
3821 error ("member %q+#D with destructor not allowed "
3822 "in anonymous aggregate", field);
3823 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
3824 error ("member %q+#D with copy assignment operator "
3825 "not allowed in anonymous aggregate", field);
3831 /* Make sure that a declaration with no declarator is well-formed, i.e.
3832 just declares a tagged type or anonymous union.
3834 Returns the type declared; or NULL_TREE if none. */
3837 check_tag_decl (cp_decl_specifier_seq *declspecs)
3839 int saw_friend = declspecs->specs[(int)ds_friend] != 0;
3840 int saw_typedef = declspecs->specs[(int)ds_typedef] != 0;
3841 /* If a class, struct, or enum type is declared by the DECLSPECS
3842 (i.e, if a class-specifier, enum-specifier, or non-typename
3843 elaborated-type-specifier appears in the DECLSPECS),
3844 DECLARED_TYPE is set to the corresponding type. */
3845 tree declared_type = NULL_TREE;
3846 bool error_p = false;
3848 if (declspecs->multiple_types_p)
3849 error ("multiple types in one declaration");
3850 else if (declspecs->redefined_builtin_type)
3852 if (!in_system_header)
3853 permerror (input_location, "redeclaration of C++ built-in type %qT",
3854 declspecs->redefined_builtin_type);
3859 && TYPE_P (declspecs->type)
3860 && ((TREE_CODE (declspecs->type) != TYPENAME_TYPE
3861 && MAYBE_CLASS_TYPE_P (declspecs->type))
3862 || TREE_CODE (declspecs->type) == ENUMERAL_TYPE))
3863 declared_type = declspecs->type;
3864 else if (declspecs->type == error_mark_node)
3866 if (declared_type == NULL_TREE && ! saw_friend && !error_p)
3867 permerror (input_location, "declaration does not declare anything");
3868 /* Check for an anonymous union. */
3869 else if (declared_type && RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type))
3870 && TYPE_ANONYMOUS_P (declared_type))
3872 /* 7/3 In a simple-declaration, the optional init-declarator-list
3873 can be omitted only when declaring a class (clause 9) or
3874 enumeration (7.2), that is, when the decl-specifier-seq contains
3875 either a class-specifier, an elaborated-type-specifier with
3876 a class-key (9.1), or an enum-specifier. In these cases and
3877 whenever a class-specifier or enum-specifier is present in the
3878 decl-specifier-seq, the identifiers in these specifiers are among
3879 the names being declared by the declaration (as class-name,
3880 enum-names, or enumerators, depending on the syntax). In such
3881 cases, and except for the declaration of an unnamed bit-field (9.6),
3882 the decl-specifier-seq shall introduce one or more names into the
3883 program, or shall redeclare a name introduced by a previous
3884 declaration. [Example:
3885 enum { }; // ill-formed
3886 typedef class { }; // ill-formed
3890 error ("missing type-name in typedef-declaration");
3893 /* Anonymous unions are objects, so they can have specifiers. */;
3894 SET_ANON_AGGR_TYPE_P (declared_type);
3896 if (TREE_CODE (declared_type) != UNION_TYPE && !in_system_header)
3897 pedwarn (input_location, OPT_pedantic, "ISO C++ prohibits anonymous structs");
3902 if (declspecs->specs[(int)ds_inline]
3903 || declspecs->specs[(int)ds_virtual])
3904 error ("%qs can only be specified for functions",
3905 declspecs->specs[(int)ds_inline]
3906 ? "inline" : "virtual");
3908 && (!current_class_type
3909 || current_scope () != current_class_type))
3910 error ("%<friend%> can only be specified inside a class");
3911 else if (declspecs->specs[(int)ds_explicit])
3912 error ("%<explicit%> can only be specified for constructors");
3913 else if (declspecs->storage_class)
3914 error ("a storage class can only be specified for objects "
3916 else if (declspecs->specs[(int)ds_const]
3917 || declspecs->specs[(int)ds_volatile]
3918 || declspecs->specs[(int)ds_restrict]
3919 || declspecs->specs[(int)ds_thread])
3920 error ("qualifiers can only be specified for objects "
3922 else if (saw_typedef)
3923 warning (0, "%<typedef%> was ignored in this declaration");
3926 return declared_type;
3929 /* Called when a declaration is seen that contains no names to declare.
3930 If its type is a reference to a structure, union or enum inherited
3931 from a containing scope, shadow that tag name for the current scope
3932 with a forward reference.
3933 If its type defines a new named structure or union
3934 or defines an enum, it is valid but we need not do anything here.
3935 Otherwise, it is an error.
3937 C++: may have to grok the declspecs to learn about static,
3938 complain for anonymous unions.
3940 Returns the TYPE declared -- or NULL_TREE if none. */
3943 shadow_tag (cp_decl_specifier_seq *declspecs)
3945 tree t = check_tag_decl (declspecs);
3950 if (declspecs->attributes)
3952 warning (0, "attribute ignored in declaration of %q+#T", t);
3953 warning (0, "attribute for %q+#T must follow the %qs keyword",
3954 t, class_key_or_enum_as_string (t));
3958 if (maybe_process_partial_specialization (t) == error_mark_node)
3961 /* This is where the variables in an anonymous union are
3962 declared. An anonymous union declaration looks like:
3964 because there is no declarator after the union, the parser
3965 sends that declaration here. */
3966 if (ANON_AGGR_TYPE_P (t))
3968 fixup_anonymous_aggr (t);
3970 if (TYPE_FIELDS (t))
3972 tree decl = grokdeclarator (/*declarator=*/NULL,
3973 declspecs, NORMAL, 0, NULL);
3974 finish_anon_union (decl);
3981 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
3984 groktypename (cp_decl_specifier_seq *type_specifiers,
3985 const cp_declarator *declarator,
3986 bool is_template_arg)
3990 enum decl_context context
3991 = is_template_arg ? TEMPLATE_TYPE_ARG : TYPENAME;
3992 attrs = type_specifiers->attributes;
3993 type_specifiers->attributes = NULL_TREE;
3994 type = grokdeclarator (declarator, type_specifiers, context, 0, &attrs);
3995 if (attrs && type != error_mark_node)
3997 if (CLASS_TYPE_P (type))
3998 warning (OPT_Wattributes, "ignoring attributes applied to class type %qT "
3999 "outside of definition", type);
4000 else if (MAYBE_CLASS_TYPE_P (type))
4001 /* A template type parameter or other dependent type. */
4002 warning (OPT_Wattributes, "ignoring attributes applied to dependent "
4003 "type %qT without an associated declaration", type);
4005 cplus_decl_attributes (&type, attrs, 0);
4010 /* Process a DECLARATOR for a function-scope variable declaration,
4011 namespace-scope variable declaration, or function declaration.
4012 (Function definitions go through start_function; class member
4013 declarations appearing in the body of the class go through
4014 grokfield.) The DECL corresponding to the DECLARATOR is returned.
4015 If an error occurs, the error_mark_node is returned instead.
4017 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
4018 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
4019 for an explicitly defaulted function, or SD_DELETED for an explicitly
4020 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
4021 implicitly initialized via a default constructor. ATTRIBUTES and
4022 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
4023 *PUSHED_SCOPE_P is set to the scope entered in this function, if any; if
4024 set, the caller is responsible for calling pop_scope. */
4027 start_decl (const cp_declarator *declarator,
4028 cp_decl_specifier_seq *declspecs,
4031 tree prefix_attributes,
4032 tree *pushed_scope_p)
4040 *pushed_scope_p = NULL_TREE;
4042 /* An object declared as __attribute__((deprecated)) suppresses
4043 warnings of uses of other deprecated items. */
4044 if (lookup_attribute ("deprecated", attributes))
4045 deprecated_state = DEPRECATED_SUPPRESS;
4047 attributes = chainon (attributes, prefix_attributes);
4049 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
4052 deprecated_state = DEPRECATED_NORMAL;
4054 if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE
4055 || decl == error_mark_node)
4056 return error_mark_node;
4058 type = TREE_TYPE (decl);
4060 context = DECL_CONTEXT (decl);
4064 *pushed_scope_p = push_scope (context);
4066 /* We are only interested in class contexts, later. */
4067 if (TREE_CODE (context) == NAMESPACE_DECL)
4068 context = NULL_TREE;
4072 /* Is it valid for this decl to have an initializer at all?
4073 If not, set INITIALIZED to zero, which will indirectly
4074 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
4075 switch (TREE_CODE (decl))
4078 error ("typedef %qD is initialized (use decltype instead)", decl);
4079 return error_mark_node;
4082 if (initialized == SD_DELETED)
4083 /* We'll handle the rest of the semantics later, but we need to
4084 set this now so it's visible to duplicate_decls. */
4085 DECL_DELETED_FN (decl) = 1;
4094 if (! toplevel_bindings_p ()
4095 && DECL_EXTERNAL (decl))
4096 warning (0, "declaration of %q#D has %<extern%> and is initialized",
4098 DECL_EXTERNAL (decl) = 0;
4099 if (toplevel_bindings_p ())
4100 TREE_STATIC (decl) = 1;
4103 /* If this is a typedef that names the class for linkage purposes
4104 (7.1.3p8), apply any attributes directly to the type. */
4105 if (TREE_CODE (decl) == TYPE_DECL
4106 && TAGGED_TYPE_P (TREE_TYPE (decl))
4107 && decl == TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl))))
4108 flags = ATTR_FLAG_TYPE_IN_PLACE;
4112 /* Set attributes here so if duplicate decl, will have proper attributes. */
4113 cplus_decl_attributes (&decl, attributes, flags);
4115 /* Dllimported symbols cannot be defined. Static data members (which
4116 can be initialized in-class and dllimported) go through grokfield,
4117 not here, so we don't need to exclude those decls when checking for
4119 if (initialized && DECL_DLLIMPORT_P (decl))
4121 error ("definition of %q#D is marked %<dllimport%>", decl);
4122 DECL_DLLIMPORT_P (decl) = 0;
4125 /* If #pragma weak was used, mark the decl weak now. */
4126 maybe_apply_pragma_weak (decl);
4128 if (TREE_CODE (decl) == FUNCTION_DECL
4129 && DECL_DECLARED_INLINE_P (decl)
4130 && DECL_UNINLINABLE (decl)
4131 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
4132 warning (0, "inline function %q+D given attribute noinline", decl);
4134 if (context && COMPLETE_TYPE_P (complete_type (context)))
4136 if (TREE_CODE (decl) == VAR_DECL)
4138 tree field = lookup_field (context, DECL_NAME (decl), 0, false);
4139 if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
4140 error ("%q#D is not a static member of %q#T", decl, context);
4143 if (DECL_CONTEXT (field) != context)
4145 if (!same_type_p (DECL_CONTEXT (field), context))
4146 permerror (input_location, "ISO C++ does not permit %<%T::%D%> "
4147 "to be defined as %<%T::%D%>",
4148 DECL_CONTEXT (field), DECL_NAME (decl),
4149 context, DECL_NAME (decl));
4150 DECL_CONTEXT (decl) = DECL_CONTEXT (field);
4152 if (processing_specialization
4153 && template_class_depth (context) == 0
4154 && CLASSTYPE_TEMPLATE_SPECIALIZATION (context))
4155 error ("template header not allowed in member definition "
4156 "of explicitly specialized class");
4157 /* Static data member are tricky; an in-class initialization
4158 still doesn't provide a definition, so the in-class
4159 declaration will have DECL_EXTERNAL set, but will have an
4160 initialization. Thus, duplicate_decls won't warn
4161 about this situation, and so we check here. */
4162 if (initialized && DECL_INITIALIZED_IN_CLASS_P (field))
4163 error ("duplicate initialization of %qD", decl);
4164 if (duplicate_decls (decl, field, /*newdecl_is_friend=*/false))
4170 tree field = check_classfn (context, decl,
4171 (processing_template_decl
4172 > template_class_depth (context))
4173 ? current_template_parms
4175 if (field && field != error_mark_node
4176 && duplicate_decls (decl, field,
4177 /*newdecl_is_friend=*/false))
4181 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
4182 DECL_IN_AGGR_P (decl) = 0;
4183 /* Do not mark DECL as an explicit specialization if it was not
4184 already marked as an instantiation; a declaration should
4185 never be marked as a specialization unless we know what
4186 template is being specialized. */
4187 if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
4189 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
4191 /* [temp.expl.spec] An explicit specialization of a static data
4192 member of a template is a definition if the declaration
4193 includes an initializer; otherwise, it is a declaration.
4195 We check for processing_specialization so this only applies
4196 to the new specialization syntax. */
4197 if (!initialized && processing_specialization)
4198 DECL_EXTERNAL (decl) = 1;
4201 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
4202 permerror (input_location, "declaration of %q#D outside of class is not definition",
4206 was_public = TREE_PUBLIC (decl);
4208 /* Enter this declaration into the symbol table. */
4209 decl = maybe_push_decl (decl);
4211 if (processing_template_decl)
4212 decl = push_template_decl (decl);
4213 if (decl == error_mark_node)
4214 return error_mark_node;
4216 /* Tell the back end to use or not use .common as appropriate. If we say
4217 -fconserve-space, we want this to save .data space, at the expense of
4218 wrong semantics. If we say -fno-conserve-space, we want this to
4219 produce errors about redefs; to do this we force variables into the
4221 if (flag_conserve_space
4222 && TREE_CODE (decl) == VAR_DECL
4223 && TREE_PUBLIC (decl)
4224 && !DECL_THREAD_LOCAL_P (decl)
4225 && !have_global_bss_p ())
4226 DECL_COMMON (decl) = 1;
4228 if (TREE_CODE (decl) == VAR_DECL
4229 && DECL_NAMESPACE_SCOPE_P (decl) && !TREE_PUBLIC (decl) && !was_public
4230 && !DECL_THIS_STATIC (decl) && !DECL_ARTIFICIAL (decl))
4232 /* This is a const variable with implicit 'static'. Set
4233 DECL_THIS_STATIC so we can tell it from variables that are
4234 !TREE_PUBLIC because of the anonymous namespace. */
4235 gcc_assert (cp_type_readonly (TREE_TYPE (decl)));
4236 DECL_THIS_STATIC (decl) = 1;
4239 if (!processing_template_decl && TREE_CODE (decl) == VAR_DECL)
4240 start_decl_1 (decl, initialized);
4245 /* Process the declaration of a variable DECL. INITIALIZED is true
4246 iff DECL is explicitly initialized. (INITIALIZED is false if the
4247 variable is initialized via an implicitly-called constructor.)
4248 This function must be called for ordinary variables (including, for
4249 example, implicit instantiations of templates), but must not be
4250 called for template declarations. */
4253 start_decl_1 (tree decl, bool initialized)
4257 bool aggregate_definition_p;
4259 gcc_assert (!processing_template_decl);
4261 if (error_operand_p (decl))
4264 gcc_assert (TREE_CODE (decl) == VAR_DECL);
4266 type = TREE_TYPE (decl);
4267 complete_p = COMPLETE_TYPE_P (type);
4268 aggregate_definition_p = MAYBE_CLASS_TYPE_P (type) && !DECL_EXTERNAL (decl);
4270 /* If an explicit initializer is present, or if this is a definition
4271 of an aggregate, then we need a complete type at this point.
4272 (Scalars are always complete types, so there is nothing to
4273 check.) This code just sets COMPLETE_P; errors (if necessary)
4274 are issued below. */
4275 if ((initialized || aggregate_definition_p)
4277 && COMPLETE_TYPE_P (complete_type (type)))
4280 /* We will not yet have set TREE_READONLY on DECL if the type
4281 was "const", but incomplete, before this point. But, now, we
4282 have a complete type, so we can try again. */
4283 cp_apply_type_quals_to_decl (cp_type_quals (type), decl);
4287 /* Is it valid for this decl to have an initializer at all? */
4289 /* Don't allow initializations for incomplete types except for
4290 arrays which might be completed by the initialization. */
4292 ; /* A complete type is ok. */
4293 else if (type_uses_auto (type))
4294 ; /* An auto type is ok. */
4295 else if (TREE_CODE (type) != ARRAY_TYPE)
4297 error ("variable %q#D has initializer but incomplete type", decl);
4298 type = TREE_TYPE (decl) = error_mark_node;
4300 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
4302 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
4303 error ("elements of array %q#D have incomplete type", decl);
4304 /* else we already gave an error in start_decl. */
4307 else if (aggregate_definition_p && !complete_p)
4309 if (type_uses_auto (type))
4310 error ("declaration of %q#D has no initializer", decl);
4312 error ("aggregate %q#D has incomplete type and cannot be defined",
4314 /* Change the type so that assemble_variable will give
4315 DECL an rtl we can live with: (mem (const_int 0)). */
4316 type = TREE_TYPE (decl) = error_mark_node;
4319 /* Create a new scope to hold this declaration if necessary.
4320 Whether or not a new scope is necessary cannot be determined
4321 until after the type has been completed; if the type is a
4322 specialization of a class template it is not until after
4323 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4324 will be set correctly. */
4325 maybe_push_cleanup_level (type);
4328 /* Handle initialization of references. DECL, TYPE, and INIT have the
4329 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
4330 but will be set to a new CLEANUP_STMT if a temporary is created
4331 that must be destroyed subsequently.
4333 Returns an initializer expression to use to initialize DECL, or
4334 NULL if the initialization can be performed statically.
4336 Quotes on semantics can be found in ARM 8.4.3. */
4339 grok_reference_init (tree decl, tree type, tree init, tree *cleanup)
4343 if (init == NULL_TREE)
4345 if ((DECL_LANG_SPECIFIC (decl) == 0
4346 || DECL_IN_AGGR_P (decl) == 0)
4347 && ! DECL_THIS_EXTERN (decl))
4348 error ("%qD declared as reference but not initialized", decl);
4352 if (TREE_CODE (init) == CONSTRUCTOR)
4354 error ("ISO C++ forbids use of initializer list to "
4355 "initialize reference %qD", decl);
4359 if (TREE_CODE (init) == TREE_LIST)
4360 init = build_x_compound_expr_from_list (init, "initializer");
4362 if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
4363 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
4364 /* Note: default conversion is only called in very special cases. */
4365 init = decay_conversion (init);
4367 /* Convert INIT to the reference type TYPE. This may involve the
4368 creation of a temporary, whose lifetime must be the same as that
4369 of the reference. If so, a DECL_EXPR for the temporary will be
4370 added just after the DECL_EXPR for DECL. That's why we don't set
4371 DECL_INITIAL for local references (instead assigning to them
4372 explicitly); we need to allow the temporary to be initialized
4374 tmp = initialize_reference (type, init, decl, cleanup);
4376 if (tmp == error_mark_node)
4378 else if (tmp == NULL_TREE)
4380 error ("cannot initialize %qT from %qT", type, TREE_TYPE (init));
4384 if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
4387 DECL_INITIAL (decl) = tmp;
4392 /* Subroutine of check_initializer. We're initializing a DECL of
4393 std::initializer_list<T> TYPE from a braced-init-list INIT, and need to
4394 extend the lifetime of the underlying array to match that of the decl,
4395 just like for reference initialization. CLEANUP is as for
4396 grok_reference_init. */
4399 build_init_list_var_init (tree decl, tree type, tree init, tree *cleanup)
4401 tree aggr_init, array, arrtype;
4402 init = perform_implicit_conversion (type, init, tf_warning_or_error);
4403 aggr_init = TARGET_EXPR_INITIAL (init);
4404 init = build2 (INIT_EXPR, type, decl, init);
4406 array = AGGR_INIT_EXPR_ARG (aggr_init, 1);
4407 arrtype = TREE_TYPE (array);
4409 gcc_assert (TREE_CODE (array) == ADDR_EXPR);
4410 array = TREE_OPERAND (array, 0);
4411 /* If the array is constant, finish_compound_literal already made it a
4412 static variable and we don't need to do anything here. */
4413 if (decl && TREE_CODE (array) == TARGET_EXPR)
4416 tree var = set_up_extended_ref_temp (decl, array, cleanup, &subinit);
4417 var = build_address (var);
4418 var = convert (arrtype, var);
4419 AGGR_INIT_EXPR_ARG (aggr_init, 1) = var;
4420 init = build2 (COMPOUND_EXPR, TREE_TYPE (init), subinit, init);
4425 /* Designated initializers in arrays are not supported in GNU C++.
4426 The parser cannot detect this error since it does not know whether
4427 a given brace-enclosed initializer is for a class type or for an
4428 array. This function checks that CE does not use a designated
4429 initializer. If it does, an error is issued. Returns true if CE
4430 is valid, i.e., does not have a designated initializer. */
4433 check_array_designated_initializer (const constructor_elt *ce)
4435 /* Designated initializers for array elements are not supported. */
4438 /* The parser only allows identifiers as designated
4440 if (ce->index == error_mark_node)
4441 error ("name used in a GNU-style designated "
4442 "initializer for an array");
4445 gcc_assert (TREE_CODE (ce->index) == IDENTIFIER_NODE);
4446 error ("name %qD used in a GNU-style designated "
4447 "initializer for an array", ce->index);
4455 /* When parsing `int a[] = {1, 2};' we don't know the size of the
4456 array until we finish parsing the initializer. If that's the
4457 situation we're in, update DECL accordingly. */
4460 maybe_deduce_size_from_array_init (tree decl, tree init)
4462 tree type = TREE_TYPE (decl);
4464 if (TREE_CODE (type) == ARRAY_TYPE
4465 && TYPE_DOMAIN (type) == NULL_TREE
4466 && TREE_CODE (decl) != TYPE_DECL)
4468 /* do_default is really a C-ism to deal with tentative definitions.
4469 But let's leave it here to ease the eventual merge. */
4470 int do_default = !DECL_EXTERNAL (decl);
4471 tree initializer = init ? init : DECL_INITIAL (decl);
4474 /* Check that there are no designated initializers in INIT, as
4475 those are not supported in GNU C++, and as the middle-end
4476 will crash if presented with a non-numeric designated
4478 if (initializer && TREE_CODE (initializer) == CONSTRUCTOR)
4480 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initializer);
4481 constructor_elt *ce;
4484 VEC_iterate (constructor_elt, v, i, ce);
4486 if (!check_array_designated_initializer (ce))
4492 failure = cp_complete_array_type (&TREE_TYPE (decl), initializer,
4496 error ("initializer fails to determine size of %qD", decl);
4497 TREE_TYPE (decl) = error_mark_node;
4499 else if (failure == 2)
4503 error ("array size missing in %qD", decl);
4504 TREE_TYPE (decl) = error_mark_node;
4506 /* If a `static' var's size isn't known, make it extern as
4507 well as static, so it does not get allocated. If it's not
4508 `static', then don't mark it extern; finish_incomplete_decl
4509 will give it a default size and it will get allocated. */
4510 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
4511 DECL_EXTERNAL (decl) = 1;
4513 else if (failure == 3)
4515 error ("zero-size array %qD", decl);
4516 TREE_TYPE (decl) = error_mark_node;
4520 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl)), decl);
4522 relayout_decl (decl);
4526 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
4527 any appropriate error messages regarding the layout. */
4530 layout_var_decl (tree decl)
4534 type = TREE_TYPE (decl);
4535 if (type == error_mark_node)
4538 /* If we haven't already layed out this declaration, do so now.
4539 Note that we must not call complete type for an external object
4540 because it's type might involve templates that we are not
4541 supposed to instantiate yet. (And it's perfectly valid to say
4542 `extern X x' for some incomplete type `X'.) */
4543 if (!DECL_EXTERNAL (decl))
4544 complete_type (type);
4545 if (!DECL_SIZE (decl)
4546 && TREE_TYPE (decl) != error_mark_node
4547 && (COMPLETE_TYPE_P (type)
4548 || (TREE_CODE (type) == ARRAY_TYPE
4549 && !TYPE_DOMAIN (type)
4550 && COMPLETE_TYPE_P (TREE_TYPE (type)))))
4551 layout_decl (decl, 0);
4553 if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
4555 /* An automatic variable with an incomplete type: that is an error.
4556 Don't talk about array types here, since we took care of that
4557 message in grokdeclarator. */
4558 error ("storage size of %qD isn't known", decl);
4559 TREE_TYPE (decl) = error_mark_node;
4562 /* Keep this code around in case we later want to control debug info
4563 based on whether a type is "used". (jason 1999-11-11) */
4565 else if (!DECL_EXTERNAL (decl) && MAYBE_CLASS_TYPE_P (ttype))
4566 /* Let debugger know it should output info for this type. */
4567 note_debug_info_needed (ttype);
4569 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
4570 note_debug_info_needed (DECL_CONTEXT (decl));
4573 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
4574 && DECL_SIZE (decl) != NULL_TREE
4575 && ! TREE_CONSTANT (DECL_SIZE (decl)))
4577 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
4578 constant_expression_warning (DECL_SIZE (decl));
4581 error ("storage size of %qD isn't constant", decl);
4582 TREE_TYPE (decl) = error_mark_node;
4587 /* If a local static variable is declared in an inline function, or if
4588 we have a weak definition, we must endeavor to create only one
4589 instance of the variable at link-time. */
4592 maybe_commonize_var (tree decl)
4594 /* Static data in a function with comdat linkage also has comdat
4596 if (TREE_STATIC (decl)
4597 /* Don't mess with __FUNCTION__. */
4598 && ! DECL_ARTIFICIAL (decl)
4599 && DECL_FUNCTION_SCOPE_P (decl)
4600 /* Unfortunately, import_export_decl has not always been called
4601 before the function is processed, so we cannot simply check
4603 && (DECL_COMDAT (DECL_CONTEXT (decl))
4604 || ((DECL_DECLARED_INLINE_P (DECL_CONTEXT (decl))
4605 || DECL_TEMPLATE_INSTANTIATION (DECL_CONTEXT (decl)))
4606 && TREE_PUBLIC (DECL_CONTEXT (decl)))))
4610 /* With weak symbols, we simply make the variable COMDAT;
4611 that will cause copies in multiple translations units to
4613 comdat_linkage (decl);
4617 if (DECL_INITIAL (decl) == NULL_TREE
4618 || DECL_INITIAL (decl) == error_mark_node)
4620 /* Without weak symbols, we can use COMMON to merge
4621 uninitialized variables. */
4622 TREE_PUBLIC (decl) = 1;
4623 DECL_COMMON (decl) = 1;
4627 /* While for initialized variables, we must use internal
4628 linkage -- which means that multiple copies will not
4630 TREE_PUBLIC (decl) = 0;
4631 DECL_COMMON (decl) = 0;
4632 warning (0, "sorry: semantics of inline function static "
4633 "data %q+#D are wrong (you'll wind up "
4634 "with multiple copies)", decl);
4635 warning (0, "%J you can work around this by removing "
4641 else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
4642 /* Set it up again; we might have set DECL_INITIAL since the last
4644 comdat_linkage (decl);
4647 /* Issue an error message if DECL is an uninitialized const variable. */
4650 check_for_uninitialized_const_var (tree decl)
4652 tree type = TREE_TYPE (decl);
4654 /* ``Unless explicitly declared extern, a const object does not have
4655 external linkage and must be initialized. ($8.4; $12.1)'' ARM
4657 if (TREE_CODE (decl) == VAR_DECL
4658 && TREE_CODE (type) != REFERENCE_TYPE
4659 && CP_TYPE_CONST_P (type)
4660 && !TYPE_NEEDS_CONSTRUCTING (type)
4661 && !DECL_INITIAL (decl))
4662 error ("uninitialized const %qD", decl);
4666 /* Structure holding the current initializer being processed by reshape_init.
4667 CUR is a pointer to the current element being processed, END is a pointer
4668 after the last element present in the initializer. */
4669 typedef struct reshape_iterator_t
4671 constructor_elt *cur;
4672 constructor_elt *end;
4675 static tree reshape_init_r (tree, reshape_iter *, bool);
4677 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
4678 returned is the next FIELD_DECL (possibly FIELD itself) that can be
4679 initialized. If there are no more such fields, the return value
4683 next_initializable_field (tree field)
4686 && (TREE_CODE (field) != FIELD_DECL
4687 || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
4688 || DECL_ARTIFICIAL (field)))
4689 field = TREE_CHAIN (field);
4694 /* Subroutine of reshape_init_array and reshape_init_vector, which does
4695 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
4696 INTEGER_CST representing the size of the array minus one (the maximum index),
4697 or NULL_TREE if the array was declared without specifying the size. D is
4698 the iterator within the constructor. */
4701 reshape_init_array_1 (tree elt_type, tree max_index, reshape_iter *d)
4704 bool sized_array_p = (max_index != NULL_TREE);
4705 unsigned HOST_WIDE_INT max_index_cst = 0;
4706 unsigned HOST_WIDE_INT index;
4708 /* The initializer for an array is always a CONSTRUCTOR. */
4709 new_init = build_constructor (init_list_type_node, NULL);
4713 /* Minus 1 is used for zero sized arrays. */
4714 if (integer_all_onesp (max_index))
4717 if (host_integerp (max_index, 1))
4718 max_index_cst = tree_low_cst (max_index, 1);
4719 /* sizetype is sign extended, not zero extended. */
4721 max_index_cst = tree_low_cst (fold_convert (size_type_node, max_index),
4725 /* Loop until there are no more initializers. */
4727 d->cur != d->end && (!sized_array_p || index <= max_index_cst);
4732 check_array_designated_initializer (d->cur);
4733 elt_init = reshape_init_r (elt_type, d, /*first_initializer_p=*/false);
4734 if (elt_init == error_mark_node)
4735 return error_mark_node;
4736 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), NULL_TREE, elt_init);
4742 /* Subroutine of reshape_init_r, processes the initializers for arrays.
4743 Parameters are the same of reshape_init_r. */
4746 reshape_init_array (tree type, reshape_iter *d)
4748 tree max_index = NULL_TREE;
4750 gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
4752 if (TYPE_DOMAIN (type))
4753 max_index = array_type_nelts (type);
4755 return reshape_init_array_1 (TREE_TYPE (type), max_index, d);
4758 /* Subroutine of reshape_init_r, processes the initializers for vectors.
4759 Parameters are the same of reshape_init_r. */
4762 reshape_init_vector (tree type, reshape_iter *d)
4764 tree max_index = NULL_TREE;
4767 gcc_assert (TREE_CODE (type) == VECTOR_TYPE);
4769 if (COMPOUND_LITERAL_P (d->cur->value))
4771 tree value = d->cur->value;
4772 if (!same_type_p (TREE_TYPE (value), type))
4774 error ("invalid type %qT as initializer for a vector of type %qT",
4775 TREE_TYPE (d->cur->value), type);
4776 value = error_mark_node;
4782 /* For a vector, the representation type is a struct
4783 containing a single member which is an array of the
4784 appropriate size. */
4785 rtype = TYPE_DEBUG_REPRESENTATION_TYPE (type);
4786 if (rtype && TYPE_DOMAIN (TREE_TYPE (TYPE_FIELDS (rtype))))
4787 max_index = array_type_nelts (TREE_TYPE (TYPE_FIELDS (rtype)));
4789 return reshape_init_array_1 (TREE_TYPE (type), max_index, d);
4792 /* Subroutine of reshape_init_r, processes the initializers for classes
4793 or union. Parameters are the same of reshape_init_r. */
4796 reshape_init_class (tree type, reshape_iter *d, bool first_initializer_p)
4801 gcc_assert (CLASS_TYPE_P (type));
4803 /* The initializer for a class is always a CONSTRUCTOR. */
4804 new_init = build_constructor (init_list_type_node, NULL);
4805 field = next_initializable_field (TYPE_FIELDS (type));
4811 An initializer for an aggregate member that is an
4812 empty class shall have the form of an empty
4813 initializer-list {}. */
4814 if (!first_initializer_p)
4816 error ("initializer for %qT must be brace-enclosed", type);
4817 return error_mark_node;
4822 /* Loop through the initializable fields, gathering initializers. */
4823 while (d->cur != d->end)
4827 /* Handle designated initializers, as an extension. */
4830 field = lookup_field_1 (type, d->cur->index, /*want_type=*/false);
4832 if (!field || TREE_CODE (field) != FIELD_DECL)
4834 error ("%qT has no non-static data member named %qD", type,
4836 return error_mark_node;
4840 /* If we processed all the member of the class, we are done. */
4844 field_init = reshape_init_r (TREE_TYPE (field), d,
4845 /*first_initializer_p=*/false);
4846 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), field, field_init);
4850 When a union is initialized with a brace-enclosed
4851 initializer, the braces shall only contain an
4852 initializer for the first member of the union. */
4853 if (TREE_CODE (type) == UNION_TYPE)
4856 field = next_initializable_field (TREE_CHAIN (field));
4862 /* Subroutine of reshape_init, which processes a single initializer (part of
4863 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
4864 iterator within the CONSTRUCTOR which points to the initializer to process.
4865 FIRST_INITIALIZER_P is true if this is the first initializer of the
4866 CONSTRUCTOR node. */
4869 reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p)
4871 tree init = d->cur->value;
4873 if (error_operand_p (init))
4874 return error_mark_node;
4876 /* A non-aggregate type is always initialized with a single
4878 if (!CP_AGGREGATE_TYPE_P (type))
4880 /* It is invalid to initialize a non-aggregate type with a
4881 brace-enclosed initializer before C++0x.
4882 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
4883 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
4884 a CONSTRUCTOR (with a record type). */
4885 if (TREE_CODE (init) == CONSTRUCTOR
4886 && BRACE_ENCLOSED_INITIALIZER_P (init)) /* p7626.C */
4888 if (SCALAR_TYPE_P (type))
4890 error ("braces around scalar initializer for type %qT", type);
4891 init = error_mark_node;
4894 maybe_warn_cpp0x ("extended initializer lists");
4903 All implicit type conversions (clause _conv_) are considered when
4904 initializing the aggregate member with an initializer from an
4905 initializer-list. If the initializer can initialize a member,
4906 the member is initialized. Otherwise, if the member is itself a
4907 non-empty subaggregate, brace elision is assumed and the
4908 initializer is considered for the initialization of the first
4909 member of the subaggregate. */
4910 if (TREE_CODE (init) != CONSTRUCTOR
4911 && can_convert_arg (type, TREE_TYPE (init), init, LOOKUP_NORMAL))
4917 /* [dcl.init.string]
4919 A char array (whether plain char, signed char, or unsigned char)
4920 can be initialized by a string-literal (optionally enclosed in
4921 braces); a wchar_t array can be initialized by a wide
4922 string-literal (optionally enclosed in braces). */
4923 if (TREE_CODE (type) == ARRAY_TYPE
4924 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
4926 tree str_init = init;
4928 /* Strip one level of braces if and only if they enclose a single
4929 element (as allowed by [dcl.init.string]). */
4930 if (!first_initializer_p
4931 && TREE_CODE (str_init) == CONSTRUCTOR
4932 && VEC_length (constructor_elt, CONSTRUCTOR_ELTS (str_init)) == 1)
4934 str_init = VEC_index (constructor_elt,
4935 CONSTRUCTOR_ELTS (str_init), 0)->value;
4938 /* If it's a string literal, then it's the initializer for the array
4939 as a whole. Otherwise, continue with normal initialization for
4940 array types (one value per array element). */
4941 if (TREE_CODE (str_init) == STRING_CST)
4948 /* The following cases are about aggregates. If we are not within a full
4949 initializer already, and there is not a CONSTRUCTOR, it means that there
4950 is a missing set of braces (that is, we are processing the case for
4951 which reshape_init exists). */
4952 if (!first_initializer_p)
4954 if (TREE_CODE (init) == CONSTRUCTOR)
4956 if (TREE_TYPE (init) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init)))
4957 /* There is no need to reshape pointer-to-member function
4958 initializers, as they are always constructed correctly
4959 by the front end. */
4961 else if (COMPOUND_LITERAL_P (init))
4962 /* For a nested compound literal, there is no need to reshape since
4963 brace elision is not allowed. Even if we decided to allow it,
4964 we should add a call to reshape_init in finish_compound_literal,
4965 before calling digest_init, so changing this code would still
4966 not be necessary. */
4967 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init));
4971 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
4972 return reshape_init (type, init);
4976 warning (OPT_Wmissing_braces, "missing braces around initializer for %qT",
4980 /* Dispatch to specialized routines. */
4981 if (CLASS_TYPE_P (type))
4982 return reshape_init_class (type, d, first_initializer_p);
4983 else if (TREE_CODE (type) == ARRAY_TYPE)
4984 return reshape_init_array (type, d);
4985 else if (TREE_CODE (type) == VECTOR_TYPE)
4986 return reshape_init_vector (type, d);
4991 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
4992 brace-enclosed aggregate initializer.
4994 INIT is the CONSTRUCTOR containing the list of initializers describing
4995 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
4996 It may not presently match the shape of the TYPE; for example:
4998 struct S { int a; int b; };
4999 struct S a[] = { 1, 2, 3, 4 };
5001 Here INIT will hold a VEC of four elements, rather than a
5002 VEC of two elements, each itself a VEC of two elements. This
5003 routine transforms INIT from the former form into the latter. The
5004 revised CONSTRUCTOR node is returned. */
5007 reshape_init (tree type, tree init)
5009 VEC(constructor_elt, gc) *v;
5013 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
5015 v = CONSTRUCTOR_ELTS (init);
5017 /* An empty constructor does not need reshaping, and it is always a valid
5019 if (VEC_empty (constructor_elt, v))
5022 /* Recurse on this CONSTRUCTOR. */
5023 d.cur = VEC_index (constructor_elt, v, 0);
5024 d.end = d.cur + VEC_length (constructor_elt, v);
5026 new_init = reshape_init_r (type, &d, true);
5027 if (new_init == error_mark_node)
5028 return error_mark_node;
5030 /* Make sure all the element of the constructor were used. Otherwise,
5031 issue an error about exceeding initializers. */
5033 error ("too many initializers for %qT", type);
5038 /* Verify array initializer. Returns true if errors have been reported. */
5041 check_array_initializer (tree decl, tree type, tree init)
5043 tree element_type = TREE_TYPE (type);
5045 /* The array type itself need not be complete, because the
5046 initializer may tell us how many elements are in the array.
5047 But, the elements of the array must be complete. */
5048 if (!COMPLETE_TYPE_P (complete_type (element_type)))
5051 error ("elements of array %q#D have incomplete type", decl);
5053 error ("elements of array %q#T have incomplete type", type);
5056 /* It is not valid to initialize a VLA. */
5058 && ((COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
5059 || !TREE_CONSTANT (TYPE_SIZE (element_type))))
5062 error ("variable-sized object %qD may not be initialized", decl);
5064 error ("variable-sized compound literal");
5070 /* Subroutine of check_initializer; args are passed down from that function.
5071 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
5074 build_aggr_init_full_exprs (tree decl, tree init, int flags)
5077 int saved_stmts_are_full_exprs_p = 0;
5078 if (building_stmt_tree ())
5080 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
5081 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
5083 init = build_aggr_init (decl, init, flags, tf_warning_or_error);
5084 if (building_stmt_tree ())
5085 current_stmt_tree ()->stmts_are_full_exprs_p =
5086 saved_stmts_are_full_exprs_p;
5090 /* Verify INIT (the initializer for DECL), and record the
5091 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
5092 grok_reference_init.
5094 If the return value is non-NULL, it is an expression that must be
5095 evaluated dynamically to initialize DECL. */
5098 check_initializer (tree decl, tree init, int flags, tree *cleanup)
5100 tree type = TREE_TYPE (decl);
5101 tree init_code = NULL;
5103 /* Things that are going to be initialized need to have complete
5105 TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
5107 if (type == error_mark_node)
5108 /* We will have already complained. */
5111 if (TREE_CODE (type) == ARRAY_TYPE)
5113 if (check_array_initializer (decl, type, init))
5116 else if (!COMPLETE_TYPE_P (type))
5118 error ("%qD has incomplete type", decl);
5119 TREE_TYPE (decl) = error_mark_node;
5123 /* There is no way to make a variable-sized class type in GNU C++. */
5124 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type)));
5126 if (init && BRACE_ENCLOSED_INITIALIZER_P (init))
5128 int init_len = VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init));
5129 if (SCALAR_TYPE_P (type))
5133 maybe_warn_cpp0x ("extended initializer lists");
5134 init = build_zero_init (type, NULL_TREE, false);
5136 else if (init_len != 1)
5138 error ("scalar object %qD requires one element in initializer",
5140 TREE_TYPE (decl) = error_mark_node;
5146 if (TREE_CODE (decl) == CONST_DECL)
5148 gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);
5150 DECL_INITIAL (decl) = init;
5152 gcc_assert (init != NULL_TREE);
5155 else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
5156 init = grok_reference_init (decl, type, init, cleanup);
5159 /* Do not reshape constructors of vectors (they don't need to be
5161 if (BRACE_ENCLOSED_INITIALIZER_P (init))
5163 if (is_std_init_list (type))
5164 return build_init_list_var_init (decl, type, init, cleanup);
5165 else if (TYPE_NON_AGGREGATE_CLASS (type))
5167 /* Don't reshape if the class has constructors. */
5168 if (cxx_dialect == cxx98)
5169 error ("in C++98 %qD must be initialized by constructor, "
5172 init = build_tree_list (NULL_TREE, init);
5174 else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_VECTOR_OPAQUE (type))
5176 error ("opaque vector types cannot be initialized");
5177 init = error_mark_node;
5180 init = reshape_init (type, init);
5183 /* If DECL has an array type without a specific bound, deduce the
5184 array size from the initializer. */
5185 maybe_deduce_size_from_array_init (decl, init);
5186 type = TREE_TYPE (decl);
5187 if (type == error_mark_node)
5190 if (TYPE_NEEDS_CONSTRUCTING (type)
5191 || (CLASS_TYPE_P (type)
5192 && !BRACE_ENCLOSED_INITIALIZER_P (init)))
5193 return build_aggr_init_full_exprs (decl, init, flags);
5194 else if (TREE_CODE (init) != TREE_VEC)
5196 init_code = store_init_value (decl, init, flags);
5197 if (pedantic && TREE_CODE (type) == ARRAY_TYPE
5198 && DECL_INITIAL (decl)
5199 && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST
5200 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl)))
5201 warning (0, "array %qD initialized by parenthesized string literal %qE",
5202 decl, DECL_INITIAL (decl));
5206 else if (DECL_EXTERNAL (decl))
5208 else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
5209 return build_aggr_init_full_exprs (decl, init, flags);
5210 else if (MAYBE_CLASS_TYPE_P (type))
5212 tree core_type = strip_array_types (type);
5214 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
5215 error ("structure %qD with uninitialized const members", decl);
5216 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
5217 error ("structure %qD with uninitialized reference members", decl);
5219 check_for_uninitialized_const_var (decl);
5222 check_for_uninitialized_const_var (decl);
5224 if (init && init != error_mark_node)
5225 init_code = build2 (INIT_EXPR, type, decl, init);
5230 /* If DECL is not a local variable, give it RTL. */
5233 make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
5235 int toplev = toplevel_bindings_p ();
5237 const char *filename;
5239 /* Set the DECL_ASSEMBLER_NAME for the object. */
5242 /* The `register' keyword, when used together with an
5243 asm-specification, indicates that the variable should be
5244 placed in a particular register. */
5245 if (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
5247 set_user_assembler_name (decl, asmspec);
5248 DECL_HARD_REGISTER (decl) = 1;
5252 if (TREE_CODE (decl) == FUNCTION_DECL
5253 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
5254 set_builtin_user_assembler_name (decl, asmspec);
5255 set_user_assembler_name (decl, asmspec);
5259 /* Handle non-variables up front. */
5260 if (TREE_CODE (decl) != VAR_DECL)
5262 rest_of_decl_compilation (decl, toplev, at_eof);
5266 /* If we see a class member here, it should be a static data
5268 if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
5270 gcc_assert (TREE_STATIC (decl));
5271 /* An in-class declaration of a static data member should be
5272 external; it is only a declaration, and not a definition. */
5273 if (init == NULL_TREE)
5274 gcc_assert (DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl));
5277 /* We don't create any RTL for local variables. */
5278 if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
5281 /* We defer emission of local statics until the corresponding
5282 DECL_EXPR is expanded. */
5283 defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
5285 /* We try to defer namespace-scope static constants so that they are
5286 not emitted into the object file unnecessarily. */
5287 filename = input_filename;
5288 if (!DECL_VIRTUAL_P (decl)
5289 && TREE_READONLY (decl)
5290 && DECL_INITIAL (decl) != NULL_TREE
5291 && DECL_INITIAL (decl) != error_mark_node
5293 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
5295 && !TREE_PUBLIC (decl))
5297 /* Fool with the linkage of static consts according to #pragma
5299 struct c_fileinfo *finfo = get_fileinfo (filename);
5300 if (!finfo->interface_unknown && !TREE_PUBLIC (decl))
5302 TREE_PUBLIC (decl) = 1;
5303 DECL_EXTERNAL (decl) = finfo->interface_only;
5308 /* Likewise for template instantiations. */
5309 else if (DECL_LANG_SPECIFIC (decl)
5310 && DECL_IMPLICIT_INSTANTIATION (decl))
5313 /* If we're not deferring, go ahead and assemble the variable. */
5315 rest_of_decl_compilation (decl, toplev, at_eof);
5318 /* walk_tree helper for wrap_temporary_cleanups, below. */
5321 wrap_cleanups_r (tree *stmt_p, int *walk_subtrees, void *data)
5323 if (TYPE_P (*stmt_p))
5329 if (TREE_CODE (*stmt_p) == TARGET_EXPR)
5331 tree guard = (tree)data;
5332 tree tcleanup = TARGET_EXPR_CLEANUP (*stmt_p);
5334 tcleanup = build2 (TRY_CATCH_EXPR, void_type_node, tcleanup, guard);
5335 /* Tell honor_protect_cleanup_actions to handle this as a separate
5337 TRY_CATCH_IS_CLEANUP (tcleanup) = 1;
5339 TARGET_EXPR_CLEANUP (*stmt_p) = tcleanup;
5345 /* We're initializing a local variable which has a cleanup GUARD. If there
5346 are any temporaries used in the initializer INIT of this variable, we
5347 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
5348 variable will be cleaned up properly if one of them throws.
5350 Unfortunately, there's no way to express this properly in terms of
5351 nesting, as the regions for the temporaries overlap the region for the
5352 variable itself; if there are two temporaries, the variable needs to be
5353 the first thing destroyed if either of them throws. However, we only
5354 want to run the variable's cleanup if it actually got constructed. So
5355 we need to guard the temporary cleanups with the variable's cleanup if
5356 they are run on the normal path, but not if they are run on the
5357 exceptional path. We implement this by telling
5358 honor_protect_cleanup_actions to strip the variable cleanup from the
5359 exceptional path. */
5362 wrap_temporary_cleanups (tree init, tree guard)
5364 cp_walk_tree_without_duplicates (&init, wrap_cleanups_r, (void *)guard);
5367 /* Generate code to initialize DECL (a local variable). */
5370 initialize_local_var (tree decl, tree init)
5372 tree type = TREE_TYPE (decl);
5376 gcc_assert (TREE_CODE (decl) == VAR_DECL
5377 || TREE_CODE (decl) == RESULT_DECL);
5378 gcc_assert (!TREE_STATIC (decl));
5380 if (DECL_SIZE (decl) == NULL_TREE)
5382 /* If we used it already as memory, it must stay in memory. */
5383 DECL_INITIAL (decl) = NULL_TREE;
5384 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
5388 if (type == error_mark_node)
5391 /* Compute and store the initial value. */
5392 already_used = TREE_USED (decl) || TREE_USED (type);
5394 /* Generate a cleanup, if necessary. */
5395 cleanup = cxx_maybe_build_cleanup (decl);
5397 /* Perform the initialization. */
5400 int saved_stmts_are_full_exprs_p;
5402 /* If we're only initializing a single object, guard the destructors
5403 of any temporaries used in its initializer with its destructor.
5404 This isn't right for arrays because each element initialization is
5405 a full-expression. */
5406 if (cleanup && TREE_CODE (type) != ARRAY_TYPE)
5407 wrap_temporary_cleanups (init, cleanup);
5409 gcc_assert (building_stmt_tree ());
5410 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
5411 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
5412 finish_expr_stmt (init);
5413 current_stmt_tree ()->stmts_are_full_exprs_p =
5414 saved_stmts_are_full_exprs_p;
5417 /* Set this to 0 so we can tell whether an aggregate which was
5418 initialized was ever used. Don't do this if it has a
5419 destructor, so we don't complain about the 'resource
5420 allocation is initialization' idiom. Now set
5421 attribute((unused)) on types so decls of that type will be
5422 marked used. (see TREE_USED, above.) */
5423 if (TYPE_NEEDS_CONSTRUCTING (type)
5425 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
5426 && DECL_NAME (decl))
5427 TREE_USED (decl) = 0;
5428 else if (already_used)
5429 TREE_USED (decl) = 1;
5432 finish_decl_cleanup (decl, cleanup);
5435 /* DECL is a VAR_DECL for a compiler-generated variable with static
5436 storage duration (like a virtual table) whose initializer is a
5437 compile-time constant. INIT must be either a TREE_LIST of values,
5438 or a CONSTRUCTOR. Initialize the variable and provide it to the
5442 initialize_artificial_var (tree decl, tree init)
5444 gcc_assert (DECL_ARTIFICIAL (decl));
5445 if (TREE_CODE (init) == TREE_LIST)
5446 init = build_constructor_from_list (TREE_TYPE (decl), init);
5447 gcc_assert (TREE_CODE (init) == CONSTRUCTOR);
5448 DECL_INITIAL (decl) = init;
5449 DECL_INITIALIZED_P (decl) = 1;
5450 determine_visibility (decl);
5451 layout_var_decl (decl);
5452 maybe_commonize_var (decl);
5453 make_rtl_for_nonlocal_decl (decl, init, /*asmspec=*/NULL);
5456 /* INIT is the initializer for a variable, as represented by the
5457 parser. Returns true iff INIT is value-dependent. */
5460 value_dependent_init_p (tree init)
5462 if (TREE_CODE (init) == TREE_LIST)
5463 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
5464 return any_value_dependent_elements_p (init);
5465 else if (TREE_CODE (init) == CONSTRUCTOR)
5466 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
5468 VEC(constructor_elt, gc) *elts;
5472 elts = CONSTRUCTOR_ELTS (init);
5473 nelts = VEC_length (constructor_elt, elts);
5474 for (i = 0; i < nelts; ++i)
5475 if (value_dependent_init_p (VEC_index (constructor_elt,
5480 /* It must be a simple expression, e.g., int i = 3; */
5481 return value_dependent_expression_p (init);
5486 /* Finish processing of a declaration;
5487 install its line number and initial value.
5488 If the length of an array type is not known before,
5489 it must be determined now, from the initial value, or it is an error.
5491 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
5492 true, then INIT is an integral constant expression.
5494 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
5495 if the (init) syntax was used. */
5498 cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
5499 tree asmspec_tree, int flags)
5503 const char *asmspec = NULL;
5504 int was_readonly = 0;
5505 bool var_definition_p = false;
5506 int saved_processing_template_decl;
5509 if (decl == error_mark_node)
5514 error ("assignment (not initialization) in declaration");
5518 gcc_assert (TREE_CODE (decl) != RESULT_DECL);
5519 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
5520 gcc_assert (TREE_CODE (decl) != PARM_DECL);
5522 type = TREE_TYPE (decl);
5523 if (type == error_mark_node)
5526 /* Assume no cleanup is required. */
5527 cleanup = NULL_TREE;
5528 saved_processing_template_decl = processing_template_decl;
5530 /* If a name was specified, get the string. */
5531 if (global_scope_p (current_binding_level))
5532 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
5533 if (asmspec_tree && asmspec_tree != error_mark_node)
5534 asmspec = TREE_STRING_POINTER (asmspec_tree);
5536 if (current_class_type
5537 && CP_DECL_CONTEXT (decl) == current_class_type
5538 && TYPE_BEING_DEFINED (current_class_type)
5539 && (DECL_INITIAL (decl) || init))
5540 DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
5542 auto_node = type_uses_auto (type);
5545 if (init == NULL_TREE)
5547 error ("declaration of %q#D has no initializer", decl);
5548 TREE_TYPE (decl) = error_mark_node;
5551 if (TREE_CODE (init) == TREE_LIST)
5552 init = build_x_compound_expr_from_list (init, "initializer");
5553 if (describable_type (init))
5555 type = TREE_TYPE (decl) = do_auto_deduction (type, init, auto_node);
5556 if (type == error_mark_node)
5561 if (init && TREE_CODE (decl) == FUNCTION_DECL)
5563 if (init == ridpointers[(int)RID_DELETE])
5565 /* FIXME check this is 1st decl. */
5566 DECL_DELETED_FN (decl) = 1;
5567 DECL_DECLARED_INLINE_P (decl) = 1;
5568 DECL_INITIAL (decl) = error_mark_node;
5571 else if (init == ridpointers[(int)RID_DEFAULT])
5573 if (!defaultable_fn_p (decl))
5575 error ("%qD cannot be defaulted", decl);
5576 DECL_INITIAL (decl) = NULL_TREE;
5579 DECL_DEFAULTED_FN (decl) = 1;
5583 if (processing_template_decl)
5585 bool type_dependent_p;
5587 /* Add this declaration to the statement-tree. */
5588 if (at_function_scope_p ())
5589 add_decl_expr (decl);
5591 type_dependent_p = dependent_type_p (type);
5593 if (check_for_bare_parameter_packs (init))
5596 DECL_INITIAL (decl) = NULL_TREE;
5599 if (init && init_const_expr_p && TREE_CODE (decl) == VAR_DECL)
5601 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
5602 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl))
5603 TREE_CONSTANT (decl) = 1;
5606 /* Generally, initializers in templates are expanded when the
5607 template is instantiated. But, if DECL is an integral
5608 constant static data member, then it can be used in future
5609 integral constant expressions, and its value must be
5612 && DECL_CLASS_SCOPE_P (decl)
5613 && DECL_INTEGRAL_CONSTANT_VAR_P (decl)
5614 && !type_dependent_p
5615 && !value_dependent_init_p (init)))
5618 DECL_INITIAL (decl) = init;
5619 if (TREE_CODE (decl) == VAR_DECL
5620 && !DECL_PRETTY_FUNCTION_P (decl)
5621 && !type_dependent_p)
5622 maybe_deduce_size_from_array_init (decl, init);
5626 if (TREE_CODE (init) == TREE_LIST)
5628 /* If the parenthesized-initializer form was used (e.g.,
5629 "int A<N>::i(X)"), then INIT will be a TREE_LIST of initializer
5630 arguments. (There is generally only one.) We convert them
5633 for (; list; list = TREE_CHAIN (list))
5635 tree elt = TREE_VALUE (list);
5636 TREE_VALUE (list) = fold_non_dependent_expr (elt);
5640 init = fold_non_dependent_expr (init);
5641 processing_template_decl = 0;
5644 /* Take care of TYPE_DECLs up front. */
5645 if (TREE_CODE (decl) == TYPE_DECL)
5647 if (type != error_mark_node
5648 && MAYBE_CLASS_TYPE_P (type) && DECL_NAME (decl))
5650 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
5651 warning (0, "shadowing previous type declaration of %q#D", decl);
5652 set_identifier_type_value (DECL_NAME (decl), decl);
5655 /* If we have installed this as the canonical typedef for this
5656 type, and that type has not been defined yet, delay emitting
5657 the debug information for it, as we will emit it later. */
5658 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
5659 && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
5660 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
5662 rest_of_decl_compilation (decl, DECL_CONTEXT (decl) == NULL_TREE,
5667 /* A reference will be modified here, as it is initialized. */
5668 if (! DECL_EXTERNAL (decl)
5669 && TREE_READONLY (decl)
5670 && TREE_CODE (type) == REFERENCE_TYPE)
5673 TREE_READONLY (decl) = 0;
5676 if (TREE_CODE (decl) == VAR_DECL)
5678 /* Only PODs can have thread-local storage. Other types may require
5679 various kinds of non-trivial initialization. */
5680 if (DECL_THREAD_LOCAL_P (decl) && !pod_type_p (TREE_TYPE (decl)))
5681 error ("%qD cannot be thread-local because it has non-POD type %qT",
5682 decl, TREE_TYPE (decl));
5683 /* If this is a local variable that will need a mangled name,
5684 register it now. We must do this before processing the
5685 initializer for the variable, since the initialization might
5686 require a guard variable, and since the mangled name of the
5687 guard variable will depend on the mangled name of this
5689 if (DECL_FUNCTION_SCOPE_P (decl)
5690 && TREE_STATIC (decl)
5691 && !DECL_ARTIFICIAL (decl))
5692 push_local_name (decl);
5693 /* Convert the initializer to the type of DECL, if we have not
5694 already initialized DECL. */
5695 if (!DECL_INITIALIZED_P (decl)
5696 /* If !DECL_EXTERNAL then DECL is being defined. In the
5697 case of a static data member initialized inside the
5698 class-specifier, there can be an initializer even if DECL
5699 is *not* defined. */
5700 && (!DECL_EXTERNAL (decl) || init))
5702 if (TYPE_FOR_JAVA (type) && MAYBE_CLASS_TYPE_P (type))
5705 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
5706 /* Allow libjava/prims.cc define primitive classes. */
5707 if (init != NULL_TREE
5708 || jclass == NULL_TREE
5709 || TREE_CODE (jclass) != TYPE_DECL
5710 || !POINTER_TYPE_P (TREE_TYPE (jclass))
5711 || !same_type_ignoring_top_level_qualifiers_p
5712 (type, TREE_TYPE (TREE_TYPE (jclass))))
5713 error ("Java object %qD not allocated with %<new%>", decl);
5718 DECL_NONTRIVIALLY_INITIALIZED_P (decl) = 1;
5719 if (init_const_expr_p)
5721 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
5722 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl))
5723 TREE_CONSTANT (decl) = 1;
5726 init = check_initializer (decl, init, flags, &cleanup);
5727 /* Thread-local storage cannot be dynamically initialized. */
5728 if (DECL_THREAD_LOCAL_P (decl) && init)
5730 error ("%qD is thread-local and so cannot be dynamically "
5731 "initialized", decl);
5735 /* Check that the initializer for a static data member was a
5736 constant. Although we check in the parser that the
5737 initializer is an integral constant expression, we do not
5738 simplify division-by-zero at the point at which it
5739 occurs. Therefore, in:
5741 struct S { static const int i = 7 / 0; };
5743 we issue an error at this point. It would
5744 probably be better to forbid division by zero in
5745 integral constant expressions. */
5746 if (DECL_EXTERNAL (decl) && init)
5748 error ("%qD cannot be initialized by a non-constant expression"
5749 " when being declared", decl);
5750 DECL_INITIALIZED_IN_CLASS_P (decl) = 0;
5758 The memory occupied by any object of static storage
5759 duration is zero-initialized at program startup before
5760 any other initialization takes place.
5762 We cannot create an appropriate initializer until after
5763 the type of DECL is finalized. If DECL_INITIAL is set,
5764 then the DECL is statically initialized, and any
5765 necessary zero-initialization has already been performed. */
5766 if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
5767 DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
5768 /*nelts=*/NULL_TREE,
5769 /*static_storage_p=*/true);
5770 /* Remember that the initialization for this variable has
5772 DECL_INITIALIZED_P (decl) = 1;
5773 /* This declaration is the definition of this variable,
5774 unless we are initializing a static data member within
5775 the class specifier. */
5776 if (!DECL_EXTERNAL (decl))
5777 var_definition_p = true;
5779 /* If the variable has an array type, lay out the type, even if
5780 there is no initializer. It is valid to index through the
5781 array, and we must get TYPE_ALIGN set correctly on the array
5783 else if (TREE_CODE (type) == ARRAY_TYPE)
5786 else if (TREE_CODE (decl) == FIELD_DECL
5787 && TYPE_FOR_JAVA (type) && MAYBE_CLASS_TYPE_P (type))
5788 error ("non-static data member %qD has Java class type", decl);
5790 /* Add this declaration to the statement-tree. This needs to happen
5791 after the call to check_initializer so that the DECL_EXPR for a
5792 reference temp is added before the DECL_EXPR for the reference itself. */
5793 if (at_function_scope_p ())
5794 add_decl_expr (decl);
5796 /* Let the middle end know about variables and functions -- but not
5797 static data members in uninstantiated class templates. */
5798 if (!saved_processing_template_decl
5799 && (TREE_CODE (decl) == VAR_DECL
5800 || TREE_CODE (decl) == FUNCTION_DECL))
5802 if (TREE_CODE (decl) == VAR_DECL)
5804 layout_var_decl (decl);
5805 maybe_commonize_var (decl);
5808 /* This needs to happen after the linkage is set. */
5809 determine_visibility (decl);
5811 if (var_definition_p && TREE_STATIC (decl))
5813 /* If a TREE_READONLY variable needs initialization
5814 at runtime, it is no longer readonly and we need to
5815 avoid MEM_READONLY_P being set on RTL created for it. */
5818 if (TREE_READONLY (decl))
5819 TREE_READONLY (decl) = 0;
5822 else if (was_readonly)
5823 TREE_READONLY (decl) = 1;
5826 make_rtl_for_nonlocal_decl (decl, init, asmspec);
5828 /* Check for abstractness of the type. Notice that there is no
5829 need to strip array types here since the check for those types
5830 is already done within create_array_type_for_decl. */
5831 if (TREE_CODE (type) == FUNCTION_TYPE
5832 || TREE_CODE (type) == METHOD_TYPE)
5833 abstract_virtuals_error (decl, TREE_TYPE (type));
5835 abstract_virtuals_error (decl, type);
5837 if (TREE_TYPE (decl) == error_mark_node)
5838 /* No initialization required. */
5840 else if (TREE_CODE (decl) == FUNCTION_DECL)
5844 if (init == ridpointers[(int)RID_DEFAULT])
5846 /* An out-of-class default definition is defined at
5847 the point where it is explicitly defaulted. */
5848 if (DECL_INITIAL (decl) == error_mark_node)
5849 synthesize_method (decl);
5852 error ("function %q#D is initialized like a variable", decl);
5854 /* else no initialization required. */
5856 else if (DECL_EXTERNAL (decl)
5857 && ! (DECL_LANG_SPECIFIC (decl)
5858 && DECL_NOT_REALLY_EXTERN (decl)))
5861 DECL_INITIAL (decl) = init;
5863 /* A variable definition. */
5864 else if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
5865 /* Initialize the local variable. */
5866 initialize_local_var (decl, init);
5868 /* If a variable is defined, and then a subsequent
5869 definition with external linkage is encountered, we will
5870 get here twice for the same variable. We want to avoid
5871 calling expand_static_init more than once. For variables
5872 that are not static data members, we can call
5873 expand_static_init only when we actually process the
5874 initializer. It is not legal to redeclare a static data
5875 member, so this issue does not arise in that case. */
5876 else if (var_definition_p && TREE_STATIC (decl))
5877 expand_static_init (decl, init);
5880 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
5881 reference, insert it in the statement-tree now. */
5883 push_cleanup (decl, cleanup, false);
5886 processing_template_decl = saved_processing_template_decl;
5889 TREE_READONLY (decl) = 1;
5891 /* If this was marked 'used', be sure it will be output. */
5892 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
5893 mark_decl_referenced (decl);
5896 /* Returns a declaration for a VAR_DECL as if:
5898 extern "C" TYPE NAME;
5900 had been seen. Used to create compiler-generated global
5904 declare_global_var (tree name, tree type)
5908 push_to_top_level ();
5909 decl = build_decl (input_location, VAR_DECL, name, type);
5910 TREE_PUBLIC (decl) = 1;
5911 DECL_EXTERNAL (decl) = 1;
5912 DECL_ARTIFICIAL (decl) = 1;
5913 /* If the user has explicitly declared this variable (perhaps
5914 because the code we are compiling is part of a low-level runtime
5915 library), then it is possible that our declaration will be merged
5916 with theirs by pushdecl. */
5917 decl = pushdecl (decl);
5918 cp_finish_decl (decl, NULL_TREE, false, NULL_TREE, 0);
5919 pop_from_top_level ();
5924 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
5925 if "__cxa_atexit" is not being used) corresponding to the function
5926 to be called when the program exits. */
5929 get_atexit_fn_ptr_type (void)
5934 if (!atexit_fn_ptr_type_node)
5936 if (flag_use_cxa_atexit
5937 && !targetm.cxx.use_atexit_for_cxa_atexit ())
5938 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
5939 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5941 /* The parameter to "atexit" is "void (*)(void)". */
5942 arg_types = void_list_node;
5944 fn_type = build_function_type (void_type_node, arg_types);
5945 atexit_fn_ptr_type_node = build_pointer_type (fn_type);
5948 return atexit_fn_ptr_type_node;
5951 /* Returns a pointer to the `atexit' function. Note that if
5952 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
5953 `__cxa_atexit' function specified in the IA64 C++ ABI. */
5956 get_atexit_node (void)
5963 bool use_aeabi_atexit;
5968 if (flag_use_cxa_atexit && !targetm.cxx.use_atexit_for_cxa_atexit ())
5970 /* The declaration for `__cxa_atexit' is:
5972 int __cxa_atexit (void (*)(void *), void *, void *)
5974 We build up the argument types and then then function type
5977 use_aeabi_atexit = targetm.cxx.use_aeabi_atexit ();
5978 /* First, build the pointer-to-function type for the first
5980 fn_ptr_type = get_atexit_fn_ptr_type ();
5981 /* Then, build the rest of the argument types. */
5982 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5983 if (use_aeabi_atexit)
5985 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
5986 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
5990 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
5991 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
5993 /* And the final __cxa_atexit type. */
5994 fn_type = build_function_type (integer_type_node, arg_types);
5995 fn_ptr_type = build_pointer_type (fn_type);
5996 if (use_aeabi_atexit)
5997 name = "__aeabi_atexit";
5999 name = "__cxa_atexit";
6003 /* The declaration for `atexit' is:
6005 int atexit (void (*)());
6007 We build up the argument types and then then function type
6009 fn_ptr_type = get_atexit_fn_ptr_type ();
6010 arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
6011 /* Build the final atexit type. */
6012 fn_type = build_function_type (integer_type_node, arg_types);
6016 /* Now, build the function declaration. */
6017 push_lang_context (lang_name_c);
6018 atexit_fndecl = build_library_fn_ptr (name, fn_type);
6019 mark_used (atexit_fndecl);
6020 pop_lang_context ();
6021 atexit_node = decay_conversion (atexit_fndecl);
6026 /* Returns the __dso_handle VAR_DECL. */
6029 get_dso_handle_node (void)
6031 if (dso_handle_node)
6032 return dso_handle_node;
6034 /* Declare the variable. */
6035 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
6038 return dso_handle_node;
6041 /* Begin a new function with internal linkage whose job will be simply
6042 to destroy some particular variable. */
6044 static GTY(()) int start_cleanup_cnt;
6047 start_cleanup_fn (void)
6052 bool use_cxa_atexit = flag_use_cxa_atexit
6053 && !targetm.cxx.use_atexit_for_cxa_atexit ();
6055 push_to_top_level ();
6057 /* No need to mangle this. */
6058 push_lang_context (lang_name_c);
6060 /* Build the name of the function. */
6061 sprintf (name, "__tcf_%d", start_cleanup_cnt++);
6062 /* Build the function declaration. */
6063 fntype = TREE_TYPE (get_atexit_fn_ptr_type ());
6064 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
6065 /* It's a function with internal linkage, generated by the
6067 TREE_PUBLIC (fndecl) = 0;
6068 DECL_ARTIFICIAL (fndecl) = 1;
6069 /* Make the function `inline' so that it is only emitted if it is
6070 actually needed. It is unlikely that it will be inlined, since
6071 it is only called via a function pointer, but we avoid unnecessary
6072 emissions this way. */
6073 DECL_DECLARED_INLINE_P (fndecl) = 1;
6074 DECL_INTERFACE_KNOWN (fndecl) = 1;
6075 /* Build the parameter. */
6080 parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
6081 DECL_CONTEXT (parmdecl) = fndecl;
6082 TREE_USED (parmdecl) = 1;
6083 DECL_ARGUMENTS (fndecl) = parmdecl;
6087 start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED);
6089 pop_lang_context ();
6091 return current_function_decl;
6094 /* Finish the cleanup function begun by start_cleanup_fn. */
6097 end_cleanup_fn (void)
6099 expand_or_defer_fn (finish_function (0));
6101 pop_from_top_level ();
6104 /* Generate code to handle the destruction of DECL, an object with
6105 static storage duration. */
6108 register_dtor_fn (tree decl)
6117 type = TREE_TYPE (decl);
6118 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
6119 return void_zero_node;
6121 /* If we're using "__cxa_atexit" (or "__aeabi_atexit"), and DECL is
6122 a class object, we can just pass the destructor to
6123 "__cxa_atexit"; we don't have to build a temporary function to do
6125 use_dtor = (flag_use_cxa_atexit
6126 && !targetm.cxx.use_atexit_for_cxa_atexit ()
6127 && CLASS_TYPE_P (type));
6132 /* Find the destructor. */
6133 idx = lookup_fnfields_1 (type, complete_dtor_identifier);
6134 gcc_assert (idx >= 0);
6135 cleanup = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), idx);
6136 /* Make sure it is accessible. */
6137 perform_or_defer_access_check (TYPE_BINFO (type), cleanup, cleanup);
6141 /* Call build_cleanup before we enter the anonymous function so
6142 that any access checks will be done relative to the current
6143 scope, rather than the scope of the anonymous function. */
6144 build_cleanup (decl);
6146 /* Now start the function. */
6147 cleanup = start_cleanup_fn ();
6149 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
6150 to the original function, rather than the anonymous one. That
6151 will make the back end think that nested functions are in use,
6152 which causes confusion. */
6153 push_deferring_access_checks (dk_no_check);
6154 fcall = build_cleanup (decl);
6155 pop_deferring_access_checks ();
6157 /* Create the body of the anonymous function. */
6158 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
6159 finish_expr_stmt (fcall);
6160 finish_compound_stmt (compound_stmt);
6164 /* Call atexit with the cleanup function. */
6165 mark_used (cleanup);
6166 cleanup = build_address (cleanup);
6167 if (flag_use_cxa_atexit && !targetm.cxx.use_atexit_for_cxa_atexit ())
6173 /* We must convert CLEANUP to the type that "__cxa_atexit"
6175 cleanup = build_nop (get_atexit_fn_ptr_type (), cleanup);
6176 /* "__cxa_atexit" will pass the address of DECL to the
6177 cleanup function. */
6179 addr = build_address (decl);
6180 /* The declared type of the parameter to "__cxa_atexit" is
6181 "void *". For plain "T*", we could just let the
6182 machinery in cp_build_function_call convert it -- but if the
6183 type is "cv-qualified T *", then we need to convert it
6184 before passing it in, to avoid spurious errors. */
6185 addr = build_nop (ptr_type_node, addr);
6188 /* Since the cleanup functions we build ignore the address
6189 they're given, there's no reason to pass the actual address
6190 in, and, in general, it's cheaper to pass NULL than any
6192 addr = null_pointer_node;
6193 args = tree_cons (NULL_TREE,
6194 cp_build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0,
6195 tf_warning_or_error),
6197 if (targetm.cxx.use_aeabi_atexit ())
6199 args = tree_cons (NULL_TREE, cleanup, args);
6200 args = tree_cons (NULL_TREE, addr, args);
6204 args = tree_cons (NULL_TREE, addr, args);
6205 args = tree_cons (NULL_TREE, cleanup, args);
6209 args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
6210 return cp_build_function_call (get_atexit_node (), args,
6211 tf_warning_or_error);
6214 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
6215 is its initializer. Generate code to handle the construction
6216 and destruction of DECL. */
6219 expand_static_init (tree decl, tree init)
6221 gcc_assert (TREE_CODE (decl) == VAR_DECL);
6222 gcc_assert (TREE_STATIC (decl));
6224 /* Some variables require no initialization. */
6226 && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
6227 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
6230 if (DECL_FUNCTION_SCOPE_P (decl))
6232 /* Emit code to perform this initialization but once. */
6233 tree if_stmt = NULL_TREE, inner_if_stmt = NULL_TREE;
6234 tree then_clause = NULL_TREE, inner_then_clause = NULL_TREE;
6235 tree guard, guard_addr;
6236 tree acquire_fn, release_fn, abort_fn;
6239 /* Emit code to perform this initialization but once. This code
6242 static <type> guard;
6243 if (!guard.first_byte) {
6244 if (__cxa_guard_acquire (&guard)) {
6247 // Do initialization.
6248 flag = true; __cxa_guard_release (&guard);
6249 // Register variable for destruction at end of program.
6251 if (!flag) __cxa_guard_abort (&guard);
6255 Note that the `flag' variable is only set to 1 *after* the
6256 initialization is complete. This ensures that an exception,
6257 thrown during the construction, will cause the variable to
6258 reinitialized when we pass through this code again, as per:
6262 If the initialization exits by throwing an exception, the
6263 initialization is not complete, so it will be tried again
6264 the next time control enters the declaration.
6266 This process should be thread-safe, too; multiple threads
6267 should not be able to initialize the variable more than
6270 /* Create the guard variable. */
6271 guard = get_guard (decl);
6273 /* This optimization isn't safe on targets with relaxed memory
6274 consistency. On such targets we force synchronization in
6275 __cxa_guard_acquire. */
6276 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
6278 /* Begin the conditional initialization. */
6279 if_stmt = begin_if_stmt ();
6280 finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
6281 then_clause = begin_compound_stmt (BCS_NO_SCOPE);
6284 if (flag_threadsafe_statics)
6286 guard_addr = build_address (guard);
6288 acquire_fn = get_identifier ("__cxa_guard_acquire");
6289 release_fn = get_identifier ("__cxa_guard_release");
6290 abort_fn = get_identifier ("__cxa_guard_abort");
6291 if (!get_global_value_if_present (acquire_fn, &acquire_fn))
6293 tree argtypes = tree_cons (NULL_TREE, TREE_TYPE (guard_addr),
6295 tree vfntype = build_function_type (void_type_node, argtypes);
6296 acquire_fn = push_library_fn
6297 (acquire_fn, build_function_type (integer_type_node, argtypes),
6299 release_fn = push_library_fn (release_fn, vfntype, NULL_TREE);
6300 abort_fn = push_library_fn (abort_fn, vfntype, NULL_TREE);
6304 release_fn = identifier_global_value (release_fn);
6305 abort_fn = identifier_global_value (abort_fn);
6308 inner_if_stmt = begin_if_stmt ();
6309 finish_if_stmt_cond (build_call_n (acquire_fn, 1, guard_addr),
6312 inner_then_clause = begin_compound_stmt (BCS_NO_SCOPE);
6313 begin = get_target_expr (boolean_false_node);
6314 flag = TARGET_EXPR_SLOT (begin);
6316 TARGET_EXPR_CLEANUP (begin)
6317 = build3 (COND_EXPR, void_type_node, flag,
6319 build_call_n (abort_fn, 1, guard_addr));
6320 CLEANUP_EH_ONLY (begin) = 1;
6322 /* Do the initialization itself. */
6323 init = add_stmt_to_compound (begin, init);
6324 init = add_stmt_to_compound
6325 (init, build2 (MODIFY_EXPR, void_type_node, flag, boolean_true_node));
6326 init = add_stmt_to_compound
6327 (init, build_call_n (release_fn, 1, guard_addr));
6330 init = add_stmt_to_compound (init, set_guard (guard));
6332 /* Use atexit to register a function for destroying this static
6334 init = add_stmt_to_compound (init, register_dtor_fn (decl));
6336 finish_expr_stmt (init);
6338 if (flag_threadsafe_statics)
6340 finish_compound_stmt (inner_then_clause);
6341 finish_then_clause (inner_if_stmt);
6342 finish_if_stmt (inner_if_stmt);
6345 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
6347 finish_compound_stmt (then_clause);
6348 finish_then_clause (if_stmt);
6349 finish_if_stmt (if_stmt);
6353 static_aggregates = tree_cons (init, decl, static_aggregates);
6357 /* Make TYPE a complete type based on INITIAL_VALUE.
6358 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6359 2 if there was no information (in which case assume 0 if DO_DEFAULT),
6360 3 if the initializer list is empty (in pedantic mode). */
6363 cp_complete_array_type (tree *ptype, tree initial_value, bool do_default)
6366 tree type, elt_type;
6370 unsigned HOST_WIDE_INT i;
6373 /* An array of character type can be initialized from a
6374 brace-enclosed string constant.
6376 FIXME: this code is duplicated from reshape_init. Probably
6377 we should just call reshape_init here? */
6378 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype)))
6379 && TREE_CODE (initial_value) == CONSTRUCTOR
6380 && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (initial_value)))
6382 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
6383 tree value = VEC_index (constructor_elt, v, 0)->value;
6385 if (TREE_CODE (value) == STRING_CST
6386 && VEC_length (constructor_elt, v) == 1)
6387 initial_value = value;
6390 /* If any of the elements are parameter packs, we can't actually
6391 complete this type now because the array size is dependent. */
6392 if (TREE_CODE (initial_value) == CONSTRUCTOR)
6394 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value),
6397 if (PACK_EXPANSION_P (value))
6403 failure = complete_array_type (ptype, initial_value, do_default);
6405 /* We can create the array before the element type is complete, which
6406 means that we didn't have these two bits set in the original type
6407 either. In completing the type, we are expected to propagate these
6408 bits. See also complete_type which does the same thing for arrays
6411 if (TYPE_DOMAIN (type))
6413 elt_type = TREE_TYPE (type);
6414 TYPE_NEEDS_CONSTRUCTING (type) = TYPE_NEEDS_CONSTRUCTING (elt_type);
6415 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
6416 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type);
6422 /* Return zero if something is declared to be a member of type
6423 CTYPE when in the context of CUR_TYPE. STRING is the error
6424 message to print in that case. Otherwise, quietly return 1. */
6427 member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
6429 if (ctype && ctype != cur_type)
6431 if (flags == DTOR_FLAG)
6432 error ("destructor for alien class %qT cannot be a member", ctype);
6434 error ("constructor for alien class %qT cannot be a member", ctype);
6440 /* Subroutine of `grokdeclarator'. */
6442 /* Generate errors possibly applicable for a given set of specifiers.
6443 This is for ARM $7.1.2. */
6446 bad_specifiers (tree object,
6455 error ("%qD declared as a %<virtual%> %s", object, type);
6457 error ("%qD declared as an %<inline%> %s", object, type);
6459 error ("%<const%> and %<volatile%> function specifiers on "
6460 "%qD invalid in %s declaration",
6463 error ("%q+D declared as a friend", object);
6465 && (TREE_CODE (object) == TYPE_DECL
6466 || (!TYPE_PTRFN_P (TREE_TYPE (object))
6467 && !TYPE_REFFN_P (TREE_TYPE (object))
6468 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
6469 error ("%q+D declared with an exception specification", object);
6472 /* DECL is a member function or static data member and is presently
6473 being defined. Check that the definition is taking place in a
6477 check_class_member_definition_namespace (tree decl)
6479 /* These checks only apply to member functions and static data
6481 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
6482 || TREE_CODE (decl) == VAR_DECL);
6483 /* We check for problems with specializations in pt.c in
6484 check_specialization_namespace, where we can issue better
6486 if (processing_specialization)
6488 /* There are no restrictions on the placement of
6489 explicit instantiations. */
6490 if (processing_explicit_instantiation)
6494 A member function definition that appears outside of the
6495 class definition shall appear in a namespace scope enclosing
6496 the class definition.
6500 The definition for a static data member shall appear in a
6501 namespace scope enclosing the member's class definition. */
6502 if (!is_ancestor (current_namespace, DECL_CONTEXT (decl)))
6503 permerror (input_location, "definition of %qD is not in namespace enclosing %qT",
6504 decl, DECL_CONTEXT (decl));
6507 /* Build a PARM_DECL for the "this" parameter. TYPE is the
6508 METHOD_TYPE for a non-static member function; QUALS are the
6509 cv-qualifiers that apply to the function. */
6512 build_this_parm (tree type, cp_cv_quals quals)
6517 cp_cv_quals this_quals;
6519 this_type = TREE_VALUE (TYPE_ARG_TYPES (type));
6520 /* The `this' parameter is implicitly `const'; it cannot be
6522 this_quals = (quals & TYPE_QUAL_RESTRICT) | TYPE_QUAL_CONST;
6523 qual_type = cp_build_qualified_type (this_type, this_quals);
6524 parm = build_artificial_parm (this_identifier, qual_type);
6525 cp_apply_type_quals_to_decl (this_quals, parm);
6529 /* CTYPE is class type, or null if non-class.
6530 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
6532 DECLARATOR is the function's name.
6533 PARMS is a chain of PARM_DECLs for the function.
6534 VIRTUALP is truthvalue of whether the function is virtual or not.
6535 FLAGS are to be passed through to `grokclassfn'.
6536 QUALS are qualifiers indicating whether the function is `const'
6538 RAISES is a list of exceptions that this function can raise.
6539 CHECK is 1 if we must find this method in CTYPE, 0 if we should
6540 not look, and -1 if we should not call `grokclassfn' at all.
6542 SFK is the kind of special function (if any) for the new function.
6544 Returns `NULL_TREE' if something goes wrong, after issuing
6545 applicable error messages. */
6548 grokfndecl (tree ctype,
6552 tree orig_declarator,
6554 enum overload_flags flags,
6561 special_function_kind sfk,
6566 location_t location)
6569 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
6573 type = build_exception_variant (type, raises);
6575 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
6577 /* If we have an explicit location, use it, otherwise use whatever
6578 build_lang_decl used (probably input_location). */
6579 if (location != UNKNOWN_LOCATION)
6580 DECL_SOURCE_LOCATION (decl) = location;
6582 if (TREE_CODE (type) == METHOD_TYPE)
6585 parm = build_this_parm (type, quals);
6586 TREE_CHAIN (parm) = parms;
6589 DECL_ARGUMENTS (decl) = parms;
6590 for (t = parms; t; t = TREE_CHAIN (t))
6591 DECL_CONTEXT (t) = decl;
6592 /* Propagate volatile out from type to decl. */
6593 if (TYPE_VOLATILE (type))
6594 TREE_THIS_VOLATILE (decl) = 1;
6596 /* Setup decl according to sfk. */
6599 case sfk_constructor:
6600 case sfk_copy_constructor:
6601 DECL_CONSTRUCTOR_P (decl) = 1;
6603 case sfk_destructor:
6604 DECL_DESTRUCTOR_P (decl) = 1;
6610 /* If pointers to member functions use the least significant bit to
6611 indicate whether a function is virtual, ensure a pointer
6612 to this function will have that bit clear. */
6613 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
6614 && TREE_CODE (type) == METHOD_TYPE
6615 && DECL_ALIGN (decl) < 2 * BITS_PER_UNIT)
6616 DECL_ALIGN (decl) = 2 * BITS_PER_UNIT;
6619 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
6623 ("defining explicit specialization %qD in friend declaration",
6627 tree fns = TREE_OPERAND (orig_declarator, 0);
6628 tree args = TREE_OPERAND (orig_declarator, 1);
6630 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
6632 /* Something like `template <class T> friend void f<T>()'. */
6633 error ("invalid use of template-id %qD in declaration "
6634 "of primary template",
6640 /* A friend declaration of the form friend void f<>(). Record
6641 the information in the TEMPLATE_ID_EXPR. */
6642 SET_DECL_IMPLICIT_INSTANTIATION (decl);
6644 if (TREE_CODE (fns) == COMPONENT_REF)
6646 /* Due to bison parser ickiness, we will have already looked
6647 up an operator_name or PFUNCNAME within the current class
6648 (see template_id in parse.y). If the current class contains
6649 such a name, we'll get a COMPONENT_REF here. Undo that. */
6651 gcc_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
6652 == current_class_type);
6653 fns = TREE_OPERAND (fns, 1);
6655 gcc_assert (TREE_CODE (fns) == IDENTIFIER_NODE
6656 || TREE_CODE (fns) == OVERLOAD);
6657 DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
6659 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
6660 if (TREE_PURPOSE (t)
6661 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
6663 error ("default arguments are not allowed in declaration "
6664 "of friend template specialization %qD",
6671 error ("%<inline%> is not allowed in declaration of friend "
6672 "template specialization %qD",
6679 /* If this decl has namespace scope, set that up. */
6681 set_decl_namespace (decl, in_namespace, friendp);
6683 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
6685 /* `main' and builtins have implicit 'C' linkage. */
6686 if ((MAIN_NAME_P (declarator)
6687 || (IDENTIFIER_LENGTH (declarator) > 10
6688 && IDENTIFIER_POINTER (declarator)[0] == '_'
6689 && IDENTIFIER_POINTER (declarator)[1] == '_'
6690 && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
6691 && current_lang_name == lang_name_cplusplus
6692 && ctype == NULL_TREE
6693 /* NULL_TREE means global namespace. */
6694 && DECL_CONTEXT (decl) == NULL_TREE)
6695 SET_DECL_LANGUAGE (decl, lang_c);
6697 /* Should probably propagate const out from type to decl I bet (mrs). */
6700 DECL_STATIC_FUNCTION_P (decl) = 1;
6701 DECL_CONTEXT (decl) = ctype;
6706 DECL_CONTEXT (decl) = ctype;
6708 check_class_member_definition_namespace (decl);
6711 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
6713 if (processing_template_decl)
6714 error ("cannot declare %<::main%> to be a template");
6716 error ("cannot declare %<::main%> to be inline");
6718 error ("cannot declare %<::main%> to be static");
6723 /* Members of anonymous types and local classes have no linkage; make
6724 them internal. If a typedef is made later, this will be changed. */
6725 if (ctype && (TYPE_ANONYMOUS_P (ctype)
6726 || decl_function_context (TYPE_MAIN_DECL (ctype))))
6731 /* [basic.link]: A name with no linkage (notably, the name of a class
6732 or enumeration declared in a local scope) shall not be used to
6733 declare an entity with linkage.
6735 Only check this for public decls for now. See core 319, 389. */
6736 t = no_linkage_check (TREE_TYPE (decl),
6737 /*relaxed_p=*/false);
6740 if (TYPE_ANONYMOUS_P (t))
6742 if (DECL_EXTERN_C_P (decl))
6743 /* Allow this; it's pretty common in C. */;
6746 permerror (input_location, "non-local function %q#D uses anonymous type",
6748 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
6749 permerror (input_location, "%q+#D does not refer to the unqualified "
6750 "type, so it is not used for linkage",
6755 permerror (input_location, "non-local function %q#D uses local type %qT", decl, t);
6759 TREE_PUBLIC (decl) = publicp;
6762 DECL_INTERFACE_KNOWN (decl) = 1;
6763 DECL_NOT_REALLY_EXTERN (decl) = 1;
6766 /* If the declaration was declared inline, mark it as such. */
6768 DECL_DECLARED_INLINE_P (decl) = 1;
6770 DECL_EXTERNAL (decl) = 1;
6771 if (quals && TREE_CODE (type) == FUNCTION_TYPE)
6774 ? G_("static member function %qD cannot have cv-qualifier")
6775 : G_("non-member function %qD cannot have cv-qualifier"),
6777 quals = TYPE_UNQUALIFIED;
6780 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl))
6781 && !grok_op_properties (decl, /*complain=*/true))
6784 if (ctype && decl_function_context (decl))
6785 DECL_NO_STATIC_CHAIN (decl) = 1;
6788 /* Make the init_value nonzero so pushdecl knows this is not
6789 tentative. error_mark_node is replaced later with the BLOCK. */
6790 DECL_INITIAL (decl) = error_mark_node;
6792 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
6793 TREE_NOTHROW (decl) = 1;
6795 /* Caller will do the rest of this. */
6799 if (ctype != NULL_TREE)
6800 grokclassfn (ctype, decl, flags);
6802 decl = check_explicit_specialization (orig_declarator, decl,
6805 4 * (friendp != 0));
6806 if (decl == error_mark_node)
6811 cplus_decl_attributes (&decl, *attrlist, 0);
6812 *attrlist = NULL_TREE;
6815 /* Check main's type after attributes have been applied. */
6816 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
6818 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
6821 tree oldtypeargs = TYPE_ARG_TYPES (TREE_TYPE (decl));
6823 error ("%<::main%> must return %<int%>");
6824 newtype = build_function_type (integer_type_node, oldtypeargs);
6825 TREE_TYPE (decl) = newtype;
6828 check_main_parameter_types (decl);
6831 if (ctype != NULL_TREE
6832 && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
6835 tree old_decl = check_classfn (ctype, decl,
6836 (processing_template_decl
6837 > template_class_depth (ctype))
6838 ? current_template_parms
6841 if (old_decl == error_mark_node)
6849 if (TREE_CODE (old_decl) == TEMPLATE_DECL)
6850 /* Because grokfndecl is always supposed to return a
6851 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
6852 here. We depend on our callers to figure out that its
6853 really a template that's being returned. */
6854 old_decl = DECL_TEMPLATE_RESULT (old_decl);
6856 if (DECL_STATIC_FUNCTION_P (old_decl)
6857 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
6858 /* Remove the `this' parm added by grokclassfn.
6859 XXX Isn't this done in start_function, too? */
6860 revert_static_member_fn (decl);
6861 if (DECL_ARTIFICIAL (old_decl))
6863 error ("definition of implicitly-declared %qD", old_decl);
6867 /* Since we've smashed OLD_DECL to its
6868 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
6869 if (TREE_CODE (decl) == TEMPLATE_DECL)
6870 decl = DECL_TEMPLATE_RESULT (decl);
6872 /* Attempt to merge the declarations. This can fail, in
6873 the case of some invalid specialization declarations. */
6874 pushed_scope = push_scope (ctype);
6875 ok = duplicate_decls (decl, old_decl, friendp);
6877 pop_scope (pushed_scope);
6880 error ("no %q#D member function declared in class %qT",
6888 if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
6891 if (ctype == NULL_TREE || check)
6895 DECL_VIRTUAL_P (decl) = 1;
6900 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
6901 the linkage that DECL will receive in the object file. */
6904 set_linkage_for_static_data_member (tree decl)
6906 /* A static data member always has static storage duration and
6907 external linkage. Note that static data members are forbidden in
6908 local classes -- the only situation in which a class has
6909 non-external linkage. */
6910 TREE_PUBLIC (decl) = 1;
6911 TREE_STATIC (decl) = 1;
6912 /* For non-template classes, static data members are always put
6913 out in exactly those files where they are defined, just as
6914 with ordinary namespace-scope variables. */
6915 if (!processing_template_decl)
6916 DECL_INTERFACE_KNOWN (decl) = 1;
6919 /* Create a VAR_DECL named NAME with the indicated TYPE.
6921 If SCOPE is non-NULL, it is the class type or namespace containing
6922 the variable. If SCOPE is NULL, the variable should is created in
6923 the innermost enclosings scope. */
6926 grokvardecl (tree type,
6928 const cp_decl_specifier_seq *declspecs,
6934 tree explicit_scope;
6936 gcc_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE);
6938 /* Compute the scope in which to place the variable, but remember
6939 whether or not that scope was explicitly specified by the user. */
6940 explicit_scope = scope;
6943 /* An explicit "extern" specifier indicates a namespace-scope
6945 if (declspecs->storage_class == sc_extern)
6946 scope = current_namespace;
6947 else if (!at_function_scope_p ())
6948 scope = current_scope ();
6952 && (/* If the variable is a namespace-scope variable declared in a
6953 template, we need DECL_LANG_SPECIFIC. */
6954 (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
6955 /* Similarly for namespace-scope variables with language linkage
6957 || (TREE_CODE (scope) == NAMESPACE_DECL
6958 && current_lang_name != lang_name_cplusplus)
6959 /* Similarly for static data members. */
6961 decl = build_lang_decl (VAR_DECL, name, type);
6963 decl = build_decl (input_location, VAR_DECL, name, type);
6965 if (explicit_scope && TREE_CODE (explicit_scope) == NAMESPACE_DECL)
6966 set_decl_namespace (decl, explicit_scope, 0);
6968 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
6970 if (declspecs->storage_class == sc_extern)
6972 DECL_THIS_EXTERN (decl) = 1;
6973 DECL_EXTERNAL (decl) = !initialized;
6976 if (DECL_CLASS_SCOPE_P (decl))
6978 set_linkage_for_static_data_member (decl);
6979 /* This function is only called with out-of-class definitions. */
6980 DECL_EXTERNAL (decl) = 0;
6981 check_class_member_definition_namespace (decl);
6983 /* At top level, either `static' or no s.c. makes a definition
6984 (perhaps tentative), and absence of `static' makes it public. */
6985 else if (toplevel_bindings_p ())
6987 TREE_PUBLIC (decl) = (declspecs->storage_class != sc_static
6988 && (DECL_THIS_EXTERN (decl) || ! constp));
6989 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
6991 /* Not at top level, only `static' makes a static definition. */
6994 TREE_STATIC (decl) = declspecs->storage_class == sc_static;
6995 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
6998 if (declspecs->specs[(int)ds_thread])
6999 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
7001 if (TREE_PUBLIC (decl))
7003 /* [basic.link]: A name with no linkage (notably, the name of a class
7004 or enumeration declared in a local scope) shall not be used to
7005 declare an entity with linkage.
7007 Only check this for public decls for now. */
7008 tree t = no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false);
7011 if (TYPE_ANONYMOUS_P (t))
7013 if (DECL_EXTERN_C_P (decl))
7014 /* Allow this; it's pretty common in C. */
7018 /* DRs 132, 319 and 389 seem to indicate types with
7019 no linkage can only be used to declare extern "C"
7020 entities. Since it's not always an error in the
7021 ISO C++ 90 Standard, we only issue a warning. */
7022 warning (0, "non-local variable %q#D uses anonymous type",
7024 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
7025 warning (0, "%q+#D does not refer to the unqualified "
7026 "type, so it is not used for linkage",
7031 warning (0, "non-local variable %q#D uses local type %qT", decl, t);
7035 DECL_INTERFACE_KNOWN (decl) = 1;
7040 /* Create and return a canonical pointer to member function type, for
7041 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
7044 build_ptrmemfunc_type (tree type)
7048 tree unqualified_variant = NULL_TREE;
7050 if (type == error_mark_node)
7053 /* If a canonical type already exists for this type, use it. We use
7054 this method instead of type_hash_canon, because it only does a
7055 simple equality check on the list of field members. */
7057 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
7060 /* Make sure that we always have the unqualified pointer-to-member
7062 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
7064 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
7066 t = make_class_type (RECORD_TYPE);
7067 xref_basetypes (t, NULL_TREE);
7069 /* Let the front end know this is a pointer to member function... */
7070 TYPE_PTRMEMFUNC_FLAG (t) = 1;
7071 /* ... and not really a class type. */
7072 SET_CLASS_TYPE_P (t, 0);
7074 field = build_decl (input_location, FIELD_DECL, pfn_identifier, type);
7077 field = build_decl (input_location, FIELD_DECL, delta_identifier,
7079 TREE_CHAIN (field) = fields;
7082 finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
7084 /* Zap out the name so that the back end will give us the debugging
7085 information for this anonymous RECORD_TYPE. */
7086 TYPE_NAME (t) = NULL_TREE;
7088 /* If this is not the unqualified form of this pointer-to-member
7089 type, set the TYPE_MAIN_VARIANT for this type to be the
7090 unqualified type. Since they are actually RECORD_TYPEs that are
7091 not variants of each other, we must do this manually. */
7092 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
7094 t = build_qualified_type (t, cp_type_quals (type));
7095 TYPE_MAIN_VARIANT (t) = unqualified_variant;
7096 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
7097 TYPE_NEXT_VARIANT (unqualified_variant) = t;
7098 TREE_TYPE (TYPE_BINFO (t)) = t;
7101 /* Cache this pointer-to-member type so that we can find it again
7103 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
7105 if (TYPE_STRUCTURAL_EQUALITY_P (type))
7106 SET_TYPE_STRUCTURAL_EQUALITY (t);
7107 else if (TYPE_CANONICAL (type) != type)
7108 TYPE_CANONICAL (t) = build_ptrmemfunc_type (TYPE_CANONICAL (type));
7113 /* Create and return a pointer to data member type. */
7116 build_ptrmem_type (tree class_type, tree member_type)
7118 if (TREE_CODE (member_type) == METHOD_TYPE)
7122 arg_types = TYPE_ARG_TYPES (member_type);
7123 class_type = (cp_build_qualified_type
7125 cp_type_quals (TREE_TYPE (TREE_VALUE (arg_types)))));
7127 = build_method_type_directly (class_type,
7128 TREE_TYPE (member_type),
7129 TREE_CHAIN (arg_types));
7130 return build_ptrmemfunc_type (build_pointer_type (member_type));
7134 gcc_assert (TREE_CODE (member_type) != FUNCTION_TYPE);
7135 return build_offset_type (class_type, member_type);
7139 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
7140 Check to see that the definition is valid. Issue appropriate error
7141 messages. Return 1 if the definition is particularly bad, or 0
7145 check_static_variable_definition (tree decl, tree type)
7147 /* Motion 10 at San Diego: If a static const integral data member is
7148 initialized with an integral constant expression, the initializer
7149 may appear either in the declaration (within the class), or in
7150 the definition, but not both. If it appears in the class, the
7151 member is a member constant. The file-scope definition is always
7153 if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
7155 error ("invalid in-class initialization of static data member "
7156 "of non-integral type %qT",
7158 /* If we just return the declaration, crashes will sometimes
7159 occur. We therefore return void_type_node, as if this were a
7160 friend declaration, to cause callers to completely ignore
7161 this declaration. */
7164 else if (!CP_TYPE_CONST_P (type))
7165 error ("ISO C++ forbids in-class initialization of non-const "
7166 "static member %qD",
7168 else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type))
7169 pedwarn (input_location, OPT_pedantic, "ISO C++ forbids initialization of member constant "
7170 "%qD of non-integral type %qT", decl, type);
7175 /* Given the SIZE (i.e., number of elements) in an array, compute an
7176 appropriate index type for the array. If non-NULL, NAME is the
7177 name of the thing being declared. */
7180 compute_array_index_type (tree name, tree size)
7184 tree abi_1_itype = NULL_TREE;
7186 if (error_operand_p (size))
7187 return error_mark_node;
7189 type = TREE_TYPE (size);
7190 /* The array bound must be an integer type. */
7191 if (!dependent_type_p (type) && !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
7194 error ("size of array %qD has non-integral type %qT", name, type);
7196 error ("size of array has non-integral type %qT", type);
7197 size = integer_one_node;
7198 type = TREE_TYPE (size);
7201 /* We can only call value_dependent_expression_p on integral constant
7202 expressions; the parser adds a dummy NOP_EXPR with TREE_SIDE_EFFECTS
7203 set if this isn't one. */
7204 if (processing_template_decl
7205 && (TREE_SIDE_EFFECTS (size) || value_dependent_expression_p (size)))
7207 /* We cannot do any checking for a SIZE that isn't known to be
7208 constant. Just build the index type and mark that it requires
7209 structural equality checks. */
7210 itype = build_index_type (build_min (MINUS_EXPR, sizetype,
7211 size, integer_one_node));
7212 if (!TREE_SIDE_EFFECTS (size))
7214 TYPE_DEPENDENT_P (itype) = 1;
7215 TYPE_DEPENDENT_P_VALID (itype) = 1;
7217 SET_TYPE_STRUCTURAL_EQUALITY (itype);
7221 if (!abi_version_at_least (2) && processing_template_decl)
7222 /* For abi-1, we handled all instances in templates the same way,
7223 even when they were non-dependent. This affects the manglings
7224 produced. So, we do the normal checking for non-dependent
7225 sizes, but at the end we'll return the same type that abi-1
7226 would have, but with TYPE_CANONICAL set to the "right"
7227 value that the current ABI would provide. */
7228 abi_1_itype = build_index_type (build_min (MINUS_EXPR, sizetype,
7229 size, integer_one_node));
7231 /* The size might be the result of a cast. */
7232 STRIP_TYPE_NOPS (size);
7234 /* It might be a const variable or enumeration constant. */
7235 size = integral_constant_value (size);
7237 /* Normally, the array-bound will be a constant. */
7238 if (TREE_CODE (size) == INTEGER_CST)
7240 /* Check to see if the array bound overflowed. Make that an
7241 error, no matter how generous we're being. */
7242 constant_expression_error (size);
7244 /* An array must have a positive number of elements. */
7245 if (INT_CST_LT (size, integer_zero_node))
7248 error ("size of array %qD is negative", name);
7250 error ("size of array is negative");
7251 size = integer_one_node;
7253 /* As an extension we allow zero-sized arrays. We always allow
7254 them in system headers because glibc uses them. */
7255 else if (integer_zerop (size) && !in_system_header)
7258 pedwarn (input_location, OPT_pedantic, "ISO C++ forbids zero-size array %qD", name);
7260 pedwarn (input_location, OPT_pedantic, "ISO C++ forbids zero-size array");
7263 else if (TREE_CONSTANT (size))
7265 /* `(int) &fn' is not a valid array bound. */
7267 error ("size of array %qD is not an integral constant-expression",
7270 error ("size of array is not an integral constant-expression");
7271 size = integer_one_node;
7273 else if (pedantic && warn_vla != 0)
7276 pedwarn (input_location, OPT_Wvla, "ISO C++ forbids variable length array %qD", name);
7278 pedwarn (input_location, OPT_Wvla, "ISO C++ forbids variable length array");
7280 else if (warn_vla > 0)
7284 "variable length array %qD is used", name);
7287 "variable length array is used");
7290 if (processing_template_decl && !TREE_CONSTANT (size))
7291 /* A variable sized array. */
7292 itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node);
7295 HOST_WIDE_INT saved_processing_template_decl;
7297 /* Compute the index of the largest element in the array. It is
7298 one less than the number of elements in the array. We save
7299 and restore PROCESSING_TEMPLATE_DECL so that computations in
7300 cp_build_binary_op will be appropriately folded. */
7301 saved_processing_template_decl = processing_template_decl;
7302 processing_template_decl = 0;
7303 itype = cp_build_binary_op (input_location,
7305 cp_convert (ssizetype, size),
7306 cp_convert (ssizetype, integer_one_node),
7307 tf_warning_or_error);
7308 itype = fold (itype);
7309 processing_template_decl = saved_processing_template_decl;
7311 if (!TREE_CONSTANT (itype))
7312 /* A variable sized array. */
7313 itype = variable_size (itype);
7314 /* Make sure that there was no overflow when creating to a signed
7315 index type. (For example, on a 32-bit machine, an array with
7316 size 2^32 - 1 is too big.) */
7317 else if (TREE_CODE (itype) == INTEGER_CST
7318 && TREE_OVERFLOW (itype))
7320 error ("overflow in array dimension");
7321 TREE_OVERFLOW (itype) = 0;
7325 /* Create and return the appropriate index type. */
7328 tree t = build_index_type (itype);
7329 TYPE_CANONICAL (abi_1_itype) = TYPE_CANONICAL (t);
7333 return build_index_type (itype);
7336 /* Returns the scope (if any) in which the entity declared by
7337 DECLARATOR will be located. If the entity was declared with an
7338 unqualified name, NULL_TREE is returned. */
7341 get_scope_of_declarator (const cp_declarator *declarator)
7343 while (declarator && declarator->kind != cdk_id)
7344 declarator = declarator->declarator;
7346 /* If the declarator-id is a SCOPE_REF, the scope in which the
7347 declaration occurs is the first operand. */
7349 && declarator->u.id.qualifying_scope)
7350 return declarator->u.id.qualifying_scope;
7352 /* Otherwise, the declarator is not a qualified name; the entity will
7353 be declared in the current scope. */
7357 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
7358 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
7362 create_array_type_for_decl (tree name, tree type, tree size)
7364 tree itype = NULL_TREE;
7365 const char* error_msg;
7367 /* If things have already gone awry, bail now. */
7368 if (type == error_mark_node || size == error_mark_node)
7369 return error_mark_node;
7371 /* Assume that everything will go OK. */
7374 /* There are some types which cannot be array elements. */
7375 switch (TREE_CODE (type))
7378 error_msg = "array of void";
7382 error_msg = "array of functions";
7385 case REFERENCE_TYPE:
7386 error_msg = "array of references";
7390 error_msg = "array of function members";
7397 /* If something went wrong, issue an error-message and return. */
7401 error ("declaration of %qD as %s", name, error_msg);
7403 error ("creating %s", error_msg);
7405 return error_mark_node;
7410 The constant expressions that specify the bounds of the arrays
7411 can be omitted only for the first member of the sequence. */
7412 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
7415 error ("declaration of %qD as multidimensional array must "
7416 "have bounds for all dimensions except the first",
7419 error ("multidimensional array must have bounds for all "
7420 "dimensions except the first");
7422 return error_mark_node;
7425 /* Figure out the index type for the array. */
7427 itype = compute_array_index_type (name, size);
7430 T is called the array element type; this type shall not be [...] an
7431 abstract class type. */
7432 abstract_virtuals_error (name, type);
7434 return build_cplus_array_type (type, itype);
7437 /* Check that it's OK to declare a function with the indicated TYPE.
7438 SFK indicates the kind of special function (if any) that this
7439 function is. OPTYPE is the type given in a conversion operator
7440 declaration, or the class type for a constructor/destructor.
7441 Returns the actual return type of the function; that
7442 may be different than TYPE if an error occurs, or for certain
7443 special functions. */
7446 check_special_function_return_type (special_function_kind sfk,
7452 case sfk_constructor:
7454 error ("return type specification for constructor invalid");
7456 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
7457 type = build_pointer_type (optype);
7459 type = void_type_node;
7462 case sfk_destructor:
7464 error ("return type specification for destructor invalid");
7465 /* We can't use the proper return type here because we run into
7466 problems with ambiguous bases and covariant returns.
7467 Java classes are left unchanged because (void *) isn't a valid
7468 Java type, and we don't want to change the Java ABI. */
7469 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
7470 type = build_pointer_type (void_type_node);
7472 type = void_type_node;
7475 case sfk_conversion:
7477 error ("return type specified for %<operator %T%>", optype);
7488 /* A variable or data member (whose unqualified name is IDENTIFIER)
7489 has been declared with the indicated TYPE. If the TYPE is not
7490 acceptable, issue an error message and return a type to use for
7491 error-recovery purposes. */
7494 check_var_type (tree identifier, tree type)
7496 if (VOID_TYPE_P (type))
7499 error ("unnamed variable or field declared void");
7500 else if (TREE_CODE (identifier) == IDENTIFIER_NODE)
7502 gcc_assert (!IDENTIFIER_OPNAME_P (identifier));
7503 error ("variable or field %qE declared void", identifier);
7506 error ("variable or field declared void");
7507 type = error_mark_node;
7513 /* Given declspecs and a declarator (abstract or otherwise), determine
7514 the name and type of the object declared and construct a DECL node
7517 DECLSPECS points to the representation of declaration-specifier
7518 sequence that precedes declarator.
7520 DECL_CONTEXT says which syntactic context this declaration is in:
7521 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
7522 FUNCDEF for a function definition. Like NORMAL but a few different
7523 error messages in each case. Return value may be zero meaning
7524 this definition is too screwy to try to parse.
7525 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
7526 handle member functions (which have FIELD context).
7527 Return value may be zero meaning this definition is too screwy to
7529 PARM for a parameter declaration (either within a function prototype
7530 or before a function body). Make a PARM_DECL, or return void_type_node.
7531 CATCHPARM for a parameter declaration before a catch clause.
7532 TYPENAME if for a typename (in a cast or sizeof).
7533 Don't make a DECL node; just return the ..._TYPE node.
7534 FIELD for a struct or union field; make a FIELD_DECL.
7535 BITFIELD for a field with specified width.
7536 INITIALIZED is as for start_decl.
7538 ATTRLIST is a pointer to the list of attributes, which may be NULL
7539 if there are none; *ATTRLIST may be modified if attributes from inside
7540 the declarator should be applied to the declaration.
7542 When this function is called, scoping variables (such as
7543 CURRENT_CLASS_TYPE) should reflect the scope in which the
7544 declaration occurs, not the scope in which the new declaration will
7545 be placed. For example, on:
7549 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
7552 Returns a DECL (if a declarator is present), a TYPE (if there is no
7553 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
7557 grokdeclarator (const cp_declarator *declarator,
7558 const cp_decl_specifier_seq *declspecs,
7559 enum decl_context decl_context,
7563 tree type = NULL_TREE;
7565 int virtualp, explicitp, friendp, inlinep, staticp;
7566 int explicit_int = 0;
7567 int explicit_char = 0;
7568 int defaulted_int = 0;
7569 tree dependent_name = NULL_TREE;
7571 tree typedef_decl = NULL_TREE;
7572 const char *name = NULL;
7573 tree typedef_type = NULL_TREE;
7574 /* True if this declarator is a function definition. */
7575 bool funcdef_flag = false;
7576 cp_declarator_kind innermost_code = cdk_error;
7579 /* See the code below that used this. */
7580 tree decl_attr = NULL_TREE;
7583 /* Keep track of what sort of function is being processed
7584 so that we can warn about default return values, or explicit
7585 return values which do not match prescribed defaults. */
7586 special_function_kind sfk = sfk_none;
7588 tree dname = NULL_TREE;
7589 tree ctor_return_type = NULL_TREE;
7590 enum overload_flags flags = NO_SPECIAL;
7591 /* cv-qualifiers that apply to the declarator, for a declaration of
7592 a member function. */
7593 cp_cv_quals memfn_quals = TYPE_UNQUALIFIED;
7594 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
7596 tree raises = NULL_TREE;
7597 int template_count = 0;
7598 tree returned_attrs = NULL_TREE;
7599 tree parms = NULL_TREE;
7600 const cp_declarator *id_declarator;
7601 /* The unqualified name of the declarator; either an
7602 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
7603 tree unqualified_id;
7604 /* The class type, if any, in which this entity is located,
7605 or NULL_TREE if none. Note that this value may be different from
7606 the current class type; for example if an attempt is made to declare
7607 "A::f" inside "B", this value will be "A". */
7608 tree ctype = current_class_type;
7609 /* The NAMESPACE_DECL for the namespace in which this entity is
7610 located. If an unqualified name is used to declare the entity,
7611 this value will be NULL_TREE, even if the entity is located at
7613 tree in_namespace = NULL_TREE;
7614 cp_storage_class storage_class;
7615 bool unsigned_p, signed_p, short_p, long_p, thread_p;
7616 bool type_was_error_mark_node = false;
7617 bool parameter_pack_p = declarator? declarator->parameter_pack_p : false;
7618 bool set_no_warning = false;
7619 bool template_type_arg = false;
7622 signed_p = declspecs->specs[(int)ds_signed];
7623 unsigned_p = declspecs->specs[(int)ds_unsigned];
7624 short_p = declspecs->specs[(int)ds_short];
7625 long_p = declspecs->specs[(int)ds_long];
7626 longlong = declspecs->specs[(int)ds_long] >= 2;
7627 thread_p = declspecs->specs[(int)ds_thread];
7629 if (decl_context == FUNCDEF)
7630 funcdef_flag = true, decl_context = NORMAL;
7631 else if (decl_context == MEMFUNCDEF)
7632 funcdef_flag = true, decl_context = FIELD;
7633 else if (decl_context == BITFIELD)
7634 bitfield = 1, decl_context = FIELD;
7635 else if (decl_context == TEMPLATE_TYPE_ARG)
7636 template_type_arg = true, decl_context = TYPENAME;
7638 if (initialized > 1)
7639 funcdef_flag = true;
7641 /* Look inside a declarator for the name being declared
7642 and get it as a string, for an error message. */
7643 for (id_declarator = declarator;
7645 id_declarator = id_declarator->declarator)
7647 if (id_declarator->kind != cdk_id)
7648 innermost_code = id_declarator->kind;
7650 switch (id_declarator->kind)
7653 if (id_declarator->declarator
7654 && id_declarator->declarator->kind == cdk_id)
7656 sfk = id_declarator->declarator->u.id.sfk;
7657 if (sfk == sfk_destructor)
7664 tree qualifying_scope = id_declarator->u.id.qualifying_scope;
7665 tree decl = id_declarator->u.id.unqualified_name;
7668 if (qualifying_scope)
7670 if (at_function_scope_p ())
7674 A declarator-id shall not be qualified except
7677 None of the cases are permitted in block
7679 if (qualifying_scope == global_namespace)
7680 error ("invalid use of qualified-name %<::%D%>",
7682 else if (TYPE_P (qualifying_scope))
7683 error ("invalid use of qualified-name %<%T::%D%>",
7684 qualifying_scope, decl);
7686 error ("invalid use of qualified-name %<%D::%D%>",
7687 qualifying_scope, decl);
7688 return error_mark_node;
7690 else if (TYPE_P (qualifying_scope))
7692 ctype = qualifying_scope;
7693 if (innermost_code != cdk_function
7694 && current_class_type
7695 && !UNIQUELY_DERIVED_FROM_P (ctype,
7696 current_class_type))
7698 error ("type %qT is not derived from type %qT",
7699 ctype, current_class_type);
7700 return error_mark_node;
7703 else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL)
7704 in_namespace = qualifying_scope;
7706 switch (TREE_CODE (decl))
7712 if (innermost_code != cdk_function)
7714 error ("declaration of %qD as non-function", decl);
7715 return error_mark_node;
7717 else if (!qualifying_scope
7718 && !(current_class_type && at_class_scope_p ()))
7720 error ("declaration of %qD as non-member", decl);
7721 return error_mark_node;
7724 type = TREE_OPERAND (decl, 0);
7726 type = constructor_name (type);
7727 name = identifier_to_locale (IDENTIFIER_POINTER (type));
7732 case TEMPLATE_ID_EXPR:
7734 tree fns = TREE_OPERAND (decl, 0);
7737 if (TREE_CODE (dname) != IDENTIFIER_NODE)
7739 gcc_assert (is_overloaded_fn (dname));
7740 dname = DECL_NAME (get_first_fn (dname));
7745 case IDENTIFIER_NODE:
7746 if (TREE_CODE (decl) == IDENTIFIER_NODE)
7749 if (C_IS_RESERVED_WORD (dname))
7751 error ("declarator-id missing; using reserved word %qD",
7753 name = identifier_to_locale (IDENTIFIER_POINTER (dname));
7755 else if (!IDENTIFIER_TYPENAME_P (dname))
7756 name = identifier_to_locale (IDENTIFIER_POINTER (dname));
7759 gcc_assert (flags == NO_SPECIAL);
7760 flags = TYPENAME_FLAG;
7761 ctor_return_type = TREE_TYPE (dname);
7762 sfk = sfk_conversion;
7763 if (is_typename_at_global_scope (dname))
7764 name = identifier_to_locale (IDENTIFIER_POINTER (dname));
7766 name = "<invalid operator>";
7783 return error_mark_node;
7788 if (id_declarator->kind == cdk_id)
7794 The declarator in a function-definition shall have the form
7795 D1 ( parameter-declaration-clause) ... */
7796 if (funcdef_flag && innermost_code != cdk_function)
7798 error ("function definition does not declare parameters");
7799 return error_mark_node;
7802 if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
7803 && innermost_code != cdk_function
7804 && ! (ctype && !declspecs->any_specifiers_p))
7806 error ("declaration of %qD as non-function", dname);
7807 return error_mark_node;
7810 /* Anything declared one level down from the top level
7811 must be one of the parameters of a function
7812 (because the body is at least two levels down). */
7814 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
7815 by not allowing C++ class definitions to specify their parameters
7816 with xdecls (must be spec.d in the parmlist).
7818 Since we now wait to push a class scope until we are sure that
7819 we are in a legitimate method context, we must set oldcname
7820 explicitly (since current_class_name is not yet alive).
7822 We also want to avoid calling this a PARM if it is in a namespace. */
7824 if (decl_context == NORMAL && !toplevel_bindings_p ())
7826 struct cp_binding_level *b = current_binding_level;
7827 current_binding_level = b->level_chain;
7828 if (current_binding_level != 0 && toplevel_bindings_p ())
7829 decl_context = PARM;
7830 current_binding_level = b;
7834 name = decl_context == PARM ? "parameter" : "type name";
7836 /* If there were multiple types specified in the decl-specifier-seq,
7837 issue an error message. */
7838 if (declspecs->multiple_types_p)
7840 error ("two or more data types in declaration of %qs", name);
7841 return error_mark_node;
7844 if (declspecs->conflicting_specifiers_p)
7846 error ("conflicting specifiers in declaration of %qs", name);
7847 return error_mark_node;
7850 /* Extract the basic type from the decl-specifier-seq. */
7851 type = declspecs->type;
7852 if (type == error_mark_node)
7855 type_was_error_mark_node = true;
7857 /* If the entire declaration is itself tagged as deprecated then
7858 suppress reports of deprecated items. */
7859 if (type && TREE_DEPRECATED (type)
7860 && deprecated_state != DEPRECATED_SUPPRESS)
7861 warn_deprecated_use (type, NULL_TREE);
7862 if (type && TREE_CODE (type) == TYPE_DECL)
7864 typedef_decl = type;
7865 type = TREE_TYPE (typedef_decl);
7866 if (TREE_DEPRECATED (type)
7867 && DECL_ARTIFICIAL (typedef_decl)
7868 && deprecated_state != DEPRECATED_SUPPRESS)
7869 warn_deprecated_use (type, NULL_TREE);
7871 /* No type at all: default to `int', and set DEFAULTED_INT
7872 because it was not a user-defined typedef. */
7873 if (type == NULL_TREE && (signed_p || unsigned_p || long_p || short_p))
7875 /* These imply 'int'. */
7876 type = integer_type_node;
7880 explicit_int = declspecs->explicit_int_p;
7881 explicit_char = declspecs->explicit_char_p;
7884 /* See the code below that used this. */
7886 decl_attr = DECL_ATTRIBUTES (typedef_decl);
7888 typedef_type = type;
7891 if (sfk != sfk_conversion)
7892 ctor_return_type = ctype;
7894 if (sfk != sfk_none)
7895 type = check_special_function_return_type (sfk, type,
7897 else if (type == NULL_TREE)
7903 /* We handle `main' specially here, because 'main () { }' is so
7904 common. With no options, it is allowed. With -Wreturn-type,
7905 it is a warning. It is only an error with -pedantic-errors. */
7906 is_main = (funcdef_flag
7907 && dname && MAIN_NAME_P (dname)
7908 && ctype == NULL_TREE
7909 && in_namespace == NULL_TREE
7910 && current_namespace == global_namespace);
7912 if (type_was_error_mark_node)
7913 /* We've already issued an error, don't complain more. */;
7914 else if (in_system_header || flag_ms_extensions)
7915 /* Allow it, sigh. */;
7917 permerror (input_location, "ISO C++ forbids declaration of %qs with no type", name);
7919 pedwarn (input_location, OPT_pedantic,
7920 "ISO C++ forbids declaration of %qs with no type", name);
7922 warning (OPT_Wreturn_type,
7923 "ISO C++ forbids declaration of %qs with no type", name);
7925 type = integer_type_node;
7930 /* Now process the modifiers that were specified
7931 and check for invalid combinations. */
7933 /* Long double is a special combination. */
7934 if (long_p && !longlong && TYPE_MAIN_VARIANT (type) == double_type_node)
7937 type = build_qualified_type (long_double_type_node,
7938 cp_type_quals (type));
7941 /* Check all other uses of type modifiers. */
7943 if (unsigned_p || signed_p || long_p || short_p)
7947 if ((signed_p || unsigned_p) && TREE_CODE (type) != INTEGER_TYPE)
7948 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
7949 else if (signed_p && unsigned_p)
7950 error ("%<signed%> and %<unsigned%> specified together for %qs", name);
7951 else if (longlong && TREE_CODE (type) != INTEGER_TYPE)
7952 error ("%<long long%> invalid for %qs", name);
7953 else if (long_p && TREE_CODE (type) == REAL_TYPE)
7954 error ("%<long%> invalid for %qs", name);
7955 else if (short_p && TREE_CODE (type) == REAL_TYPE)
7956 error ("%<short%> invalid for %qs", name);
7957 else if ((long_p || short_p) && TREE_CODE (type) != INTEGER_TYPE)
7958 error ("%<long%> or %<short%> invalid for %qs", name);
7959 else if ((long_p || short_p) && explicit_char)
7960 error ("%<long%> or %<short%> specified with char for %qs", name);
7961 else if (long_p && short_p)
7962 error ("%<long%> and %<short%> specified together for %qs", name);
7963 else if (type == char16_type_node || type == char32_type_node)
7965 if (signed_p || unsigned_p)
7966 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
7967 else if (short_p || long_p)
7968 error ("%<short%> or %<long%> invalid for %qs", name);
7973 if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
7975 pedwarn (input_location, OPT_pedantic,
7976 "long, short, signed or unsigned used invalidly for %qs",
7978 if (flag_pedantic_errors)
7983 /* Discard the type modifiers if they are invalid. */
7994 /* Decide whether an integer type is signed or not.
7995 Optionally treat bitfields as signed by default. */
7999 It is implementation-defined whether a plain (neither
8000 explicitly signed or unsigned) char, short, int, or long
8001 bit-field is signed or unsigned.
8003 Naturally, we extend this to long long as well. Note that
8004 this does not include wchar_t. */
8005 || (bitfield && !flag_signed_bitfields
8007 /* A typedef for plain `int' without `signed' can be
8008 controlled just like plain `int', but a typedef for
8009 `signed int' cannot be so controlled. */
8011 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
8012 && TREE_CODE (type) == INTEGER_TYPE
8013 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
8016 type = long_long_unsigned_type_node;
8018 type = long_unsigned_type_node;
8020 type = short_unsigned_type_node;
8021 else if (type == char_type_node)
8022 type = unsigned_char_type_node;
8023 else if (typedef_decl)
8024 type = unsigned_type_for (type);
8026 type = unsigned_type_node;
8028 else if (signed_p && type == char_type_node)
8029 type = signed_char_type_node;
8031 type = long_long_integer_type_node;
8033 type = long_integer_type_node;
8035 type = short_integer_type_node;
8037 if (declspecs->specs[(int)ds_complex])
8039 if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
8040 error ("complex invalid for %qs", name);
8041 /* If we just have "complex", it is equivalent to
8042 "complex double", but if any modifiers at all are specified it is
8043 the complex form of TYPE. E.g, "complex short" is
8044 "complex short int". */
8046 else if (defaulted_int && ! longlong
8047 && ! (long_p || short_p || signed_p || unsigned_p))
8048 type = complex_double_type_node;
8049 else if (type == integer_type_node)
8050 type = complex_integer_type_node;
8051 else if (type == float_type_node)
8052 type = complex_float_type_node;
8053 else if (type == double_type_node)
8054 type = complex_double_type_node;
8055 else if (type == long_double_type_node)
8056 type = complex_long_double_type_node;
8058 type = build_complex_type (type);
8061 type_quals = TYPE_UNQUALIFIED;
8062 if (declspecs->specs[(int)ds_const])
8063 type_quals |= TYPE_QUAL_CONST;
8064 if (declspecs->specs[(int)ds_volatile])
8065 type_quals |= TYPE_QUAL_VOLATILE;
8066 if (declspecs->specs[(int)ds_restrict])
8067 type_quals |= TYPE_QUAL_RESTRICT;
8068 if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
8069 error ("qualifiers are not allowed on declaration of %<operator %T%>",
8072 if (TREE_CODE (type) == FUNCTION_TYPE
8073 && type_quals != TYPE_UNQUALIFIED)
8075 /* This was an error in C++98 (cv-qualifiers cannot be added to
8076 a function type), but DR 295 makes the code well-formed by
8077 dropping the extra qualifiers. */
8080 tree bad_type = build_qualified_type (type, type_quals);
8081 pedwarn (input_location, OPT_pedantic,
8082 "ignoring %qV qualifiers added to function type %qT",
8085 type_quals = TYPE_UNQUALIFIED;
8087 type_quals |= cp_type_quals (type);
8088 type = cp_build_qualified_type_real
8089 (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
8090 ? tf_ignore_bad_quals : 0) | tf_warning_or_error));
8091 /* We might have ignored or rejected some of the qualifiers. */
8092 type_quals = cp_type_quals (type);
8095 inlinep = !! declspecs->specs[(int)ds_inline];
8096 virtualp = !! declspecs->specs[(int)ds_virtual];
8097 explicitp = !! declspecs->specs[(int)ds_explicit];
8099 storage_class = declspecs->storage_class;
8100 if (storage_class == sc_static)
8101 staticp = 1 + (decl_context == FIELD);
8103 if (virtualp && staticp == 2)
8105 error ("member %qD cannot be declared both virtual and static", dname);
8106 storage_class = sc_none;
8109 friendp = !! declspecs->specs[(int)ds_friend];
8111 if (dependent_name && !friendp)
8113 error ("%<%T::%D%> is not a valid declarator", ctype, dependent_name);
8114 return error_mark_node;
8117 /* Issue errors about use of storage classes for parameters. */
8118 if (decl_context == PARM)
8120 if (declspecs->specs[(int)ds_typedef])
8122 error ("typedef declaration invalid in parameter declaration");
8123 return error_mark_node;
8125 else if (storage_class == sc_static
8126 || storage_class == sc_extern
8128 error ("storage class specifiers invalid in parameter declarations");
8130 if (type_uses_auto (type))
8132 error ("parameter declared %<auto%>");
8133 type = error_mark_node;
8137 /* Give error if `virtual' is used outside of class declaration. */
8139 && (current_class_name == NULL_TREE || decl_context != FIELD))
8141 error ("%<virtual%> outside class declaration");
8145 /* Static anonymous unions are dealt with here. */
8146 if (staticp && decl_context == TYPENAME
8148 && ANON_AGGR_TYPE_P (declspecs->type))
8149 decl_context = FIELD;
8151 /* Warn about storage classes that are invalid for certain
8152 kinds of declarations (parameters, typenames, etc.). */
8155 && storage_class != sc_extern
8156 && storage_class != sc_static)
8157 || declspecs->specs[(int)ds_typedef]))
8159 error ("multiple storage classes in declaration of %qs", name);
8162 if (decl_context != NORMAL
8163 && ((storage_class != sc_none
8164 && storage_class != sc_mutable)
8167 if ((decl_context == PARM || decl_context == CATCHPARM)
8168 && (storage_class == sc_register
8169 || storage_class == sc_auto))
8171 else if (declspecs->specs[(int)ds_typedef])
8173 else if (decl_context == FIELD
8174 /* C++ allows static class elements. */
8175 && storage_class == sc_static)
8176 /* C++ also allows inlines and signed and unsigned elements,
8177 but in those cases we don't come in here. */
8181 if (decl_context == FIELD)
8182 error ("storage class specified for %qs", name);
8185 if (decl_context == PARM || decl_context == CATCHPARM)
8186 error ("storage class specified for parameter %qs", name);
8188 error ("storage class specified for typename");
8190 if (storage_class == sc_register
8191 || storage_class == sc_auto
8192 || storage_class == sc_extern
8194 storage_class = sc_none;
8197 else if (storage_class == sc_extern && funcdef_flag
8198 && ! toplevel_bindings_p ())
8199 error ("nested function %qs declared %<extern%>", name);
8200 else if (toplevel_bindings_p ())
8202 if (storage_class == sc_auto)
8203 error ("top-level declaration of %qs specifies %<auto%>", name);
8206 && storage_class != sc_extern
8207 && storage_class != sc_static)
8209 error ("function-scope %qs implicitly auto and declared %<__thread%>",
8214 if (storage_class && friendp)
8216 error ("storage class specifiers invalid in friend function declarations");
8217 storage_class = sc_none;
8222 unqualified_id = NULL_TREE;
8225 unqualified_id = id_declarator->u.id.unqualified_name;
8226 switch (TREE_CODE (unqualified_id))
8229 unqualified_id = TREE_OPERAND (unqualified_id, 0);
8230 if (TYPE_P (unqualified_id))
8231 unqualified_id = constructor_name (unqualified_id);
8234 case IDENTIFIER_NODE:
8235 case TEMPLATE_ID_EXPR:
8243 /* Determine the type of the entity declared by recurring on the
8245 for (; declarator; declarator = declarator->declarator)
8247 const cp_declarator *inner_declarator;
8250 if (type == error_mark_node)
8251 return error_mark_node;
8253 attrs = declarator->attributes;
8259 if (declarator == NULL || declarator->kind == cdk_id)
8260 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
8261 if (declarator->kind == cdk_function)
8262 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
8263 if (declarator->kind == cdk_array)
8264 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
8265 returned_attrs = decl_attributes (&type,
8266 chainon (returned_attrs, attrs),
8270 if (declarator->kind == cdk_id)
8273 inner_declarator = declarator->declarator;
8275 switch (declarator->kind)
8278 type = create_array_type_for_decl (dname, type,
8279 declarator->u.array.bounds);
8287 /* Declaring a function type.
8288 Make sure we have a valid type for the function to return. */
8290 if (type_quals != TYPE_UNQUALIFIED)
8292 if (SCALAR_TYPE_P (type) || VOID_TYPE_P (type))
8293 warning (OPT_Wignored_qualifiers,
8294 "type qualifiers ignored on function return type");
8295 /* We now know that the TYPE_QUALS don't apply to the
8296 decl, but to its return type. */
8297 type_quals = TYPE_UNQUALIFIED;
8298 set_no_warning = true;
8300 errmsg = targetm.invalid_return_type (type);
8304 type = integer_type_node;
8307 /* Error about some types functions can't return. */
8309 if (TREE_CODE (type) == FUNCTION_TYPE)
8311 error ("%qs declared as function returning a function", name);
8312 return error_mark_node;
8314 if (TREE_CODE (type) == ARRAY_TYPE)
8316 error ("%qs declared as function returning an array", name);
8317 return error_mark_node;
8320 /* Pick up type qualifiers which should be applied to `this'. */
8321 memfn_quals = declarator->u.function.qualifiers;
8323 /* Pick up the exception specifications. */
8324 raises = declarator->u.function.exception_specification;
8326 /* Say it's a definition only for the CALL_EXPR
8327 closest to the identifier. */
8328 funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id;
8330 /* Handle a late-specified return type. */
8333 if (type_uses_auto (type))
8335 if (!declarator->u.function.late_return_type)
8337 error ("%qs function uses %<auto%> type specifier without"
8338 " late return type", name);
8339 return error_mark_node;
8341 else if (!is_auto (type))
8343 error ("%qs function with late return type has"
8344 " %qT as its type rather than plain %<auto%>",
8346 return error_mark_node;
8349 else if (declarator->u.function.late_return_type)
8351 error ("%qs function with late return type not declared"
8352 " with %<auto%> type specifier", name);
8353 return error_mark_node;
8356 type = splice_late_return_type
8357 (type, declarator->u.function.late_return_type);
8358 if (type == error_mark_node)
8359 return error_mark_node;
8361 if (ctype == NULL_TREE
8362 && decl_context == FIELD
8364 && (friendp == 0 || dname == current_class_name))
8365 ctype = current_class_type;
8367 if (ctype && (sfk == sfk_constructor
8368 || sfk == sfk_destructor))
8370 /* We are within a class's scope. If our declarator name
8371 is the same as the class name, and we are defining
8372 a function, then it is a constructor/destructor, and
8373 therefore returns a void type. */
8375 /* ISO C++ 12.4/2. A destructor may not be declared
8376 const or volatile. A destructor may not be
8379 ISO C++ 12.1. A constructor may not be declared
8380 const or volatile. A constructor may not be
8381 virtual. A constructor may not be static. */
8383 error ((flags == DTOR_FLAG)
8384 ? "destructor cannot be static member function"
8385 : "constructor cannot be static member function");
8388 error ((flags == DTOR_FLAG)
8389 ? "destructors may not be cv-qualified"
8390 : "constructors may not be cv-qualified");
8391 memfn_quals = TYPE_UNQUALIFIED;
8394 if (decl_context == FIELD
8395 && !member_function_or_else (ctype,
8398 return error_mark_node;
8400 if (flags != DTOR_FLAG)
8402 /* It's a constructor. */
8407 permerror (input_location, "constructors cannot be declared virtual");
8410 if (decl_context == FIELD
8411 && sfk != sfk_constructor)
8412 return error_mark_node;
8414 if (decl_context == FIELD)
8420 error ("can't initialize friend function %qs", name);
8423 /* Cannot be both friend and virtual. */
8424 error ("virtual functions cannot be friends");
8427 if (decl_context == NORMAL)
8428 error ("friend declaration not in class definition");
8429 if (current_function_decl && funcdef_flag)
8430 error ("can't define friend function %qs in a local "
8434 else if (ctype && sfk == sfk_conversion)
8438 maybe_warn_cpp0x ("explicit conversion operators");
8443 arg_types = grokparms (declarator->u.function.parameters,
8446 if (inner_declarator
8447 && inner_declarator->kind == cdk_id
8448 && inner_declarator->u.id.sfk == sfk_destructor
8449 && arg_types != void_list_node)
8451 error ("destructors may not have parameters");
8452 arg_types = void_list_node;
8456 type = build_function_type (type, arg_types);
8463 /* Filter out pointers-to-references and references-to-references.
8464 We can get these if a TYPE_DECL is used. */
8466 if (TREE_CODE (type) == REFERENCE_TYPE)
8468 if (declarator->kind != cdk_reference)
8470 error ("cannot declare pointer to %q#T", type);
8471 type = TREE_TYPE (type);
8474 /* In C++0x, we allow reference to reference declarations
8475 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
8476 and template type arguments [14.3.1/4 temp.arg.type]. The
8477 check for direct reference to reference declarations, which
8478 are still forbidden, occurs below. Reasoning behind the change
8479 can be found in DR106, DR540, and the rvalue reference
8481 else if (cxx_dialect == cxx98)
8483 error ("cannot declare reference to %q#T", type);
8484 type = TREE_TYPE (type);
8487 else if (VOID_TYPE_P (type))
8489 if (declarator->kind == cdk_reference)
8490 error ("cannot declare reference to %q#T", type);
8491 else if (declarator->kind == cdk_ptrmem)
8492 error ("cannot declare pointer to %q#T member", type);
8495 /* We now know that the TYPE_QUALS don't apply to the decl,
8496 but to the target of the pointer. */
8497 type_quals = TYPE_UNQUALIFIED;
8499 if (declarator->kind == cdk_ptrmem
8500 && (TREE_CODE (type) == FUNCTION_TYPE
8501 || (memfn_quals && TREE_CODE (type) == METHOD_TYPE)))
8503 memfn_quals |= cp_type_quals (type);
8504 type = build_memfn_type (type,
8505 declarator->u.pointer.class_type,
8507 memfn_quals = TYPE_UNQUALIFIED;
8510 if (TREE_CODE (type) == FUNCTION_TYPE
8511 && cp_type_quals (type) != TYPE_UNQUALIFIED)
8512 error ("cannot declare %s to qualified function type %qT",
8513 declarator->kind == cdk_reference ? "reference" : "pointer",
8516 if (declarator->kind == cdk_reference)
8518 /* In C++0x, the type we are creating a reference to might be
8519 a typedef which is itself a reference type. In that case,
8520 we follow the reference collapsing rules in
8521 [7.1.3/8 dcl.typedef] to create the final reference type:
8523 "If a typedef TD names a type that is a reference to a type
8524 T, an attempt to create the type 'lvalue reference to cv TD'
8525 creates the type 'lvalue reference to T,' while an attempt
8526 to create the type "rvalue reference to cv TD' creates the
8529 if (!VOID_TYPE_P (type))
8530 type = cp_build_reference_type
8531 ((TREE_CODE (type) == REFERENCE_TYPE
8532 ? TREE_TYPE (type) : type),
8533 (declarator->u.reference.rvalue_ref
8534 && (TREE_CODE(type) != REFERENCE_TYPE
8535 || TYPE_REF_IS_RVALUE (type))));
8537 /* In C++0x, we need this check for direct reference to
8538 reference declarations, which are forbidden by
8539 [8.3.2/5 dcl.ref]. Reference to reference declarations
8540 are only allowed indirectly through typedefs and template
8541 type arguments. Example:
8543 void foo(int & &); // invalid ref-to-ref decl
8545 typedef int & int_ref;
8546 void foo(int_ref &); // valid ref-to-ref decl
8548 if (inner_declarator && inner_declarator->kind == cdk_reference)
8549 error ("cannot declare reference to %q#T, which is not "
8550 "a typedef or a template type argument", type);
8552 else if (TREE_CODE (type) == METHOD_TYPE)
8553 type = build_ptrmemfunc_type (build_pointer_type (type));
8554 else if (declarator->kind == cdk_ptrmem)
8556 gcc_assert (TREE_CODE (declarator->u.pointer.class_type)
8558 if (declarator->u.pointer.class_type == error_mark_node)
8559 /* We will already have complained. */
8560 type = error_mark_node;
8562 type = build_ptrmem_type (declarator->u.pointer.class_type,
8566 type = build_pointer_type (type);
8568 /* Process a list of type modifier keywords (such as
8569 const or volatile) that were given inside the `*' or `&'. */
8571 if (declarator->u.pointer.qualifiers)
8574 = cp_build_qualified_type (type,
8575 declarator->u.pointer.qualifiers);
8576 type_quals = cp_type_quals (type);
8589 if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR
8590 && TREE_CODE (type) != FUNCTION_TYPE
8591 && TREE_CODE (type) != METHOD_TYPE)
8593 error ("template-id %qD used as a declarator",
8595 unqualified_id = dname;
8598 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
8599 qualified with a class-name, turn it into a METHOD_TYPE, unless
8600 we know that the function is static. We take advantage of this
8601 opportunity to do other processing that pertains to entities
8602 explicitly declared to be class members. Note that if DECLARATOR
8603 is non-NULL, we know it is a cdk_id declarator; otherwise, we
8604 would not have exited the loop above. */
8606 && declarator->u.id.qualifying_scope
8607 && TYPE_P (declarator->u.id.qualifying_scope))
8611 ctype = declarator->u.id.qualifying_scope;
8612 ctype = TYPE_MAIN_VARIANT (ctype);
8614 while (t != NULL_TREE && CLASS_TYPE_P (t))
8616 /* You're supposed to have one `template <...>' for every
8617 template class, but you don't need one for a full
8618 specialization. For example:
8620 template <class T> struct S{};
8621 template <> struct S<int> { void f(); };
8622 void S<int>::f () {}
8624 is correct; there shouldn't be a `template <>' for the
8625 definition of `S<int>::f'. */
8626 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t)
8627 && !any_dependent_template_arguments_p (CLASSTYPE_TI_ARGS (t)))
8628 /* T is an explicit (not partial) specialization. All
8629 containing classes must therefore also be explicitly
8632 if ((CLASSTYPE_USE_TEMPLATE (t) || CLASSTYPE_IS_TEMPLATE (t))
8633 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
8634 template_count += 1;
8636 t = TYPE_MAIN_DECL (t);
8637 t = DECL_CONTEXT (t);
8640 if (ctype == current_class_type)
8644 permerror (input_location, "member functions are implicitly friends of their class");
8648 permerror (declarator->id_loc,
8649 "extra qualification %<%T::%> on member %qs",
8652 else if (/* If the qualifying type is already complete, then we
8653 can skip the following checks. */
8654 !COMPLETE_TYPE_P (ctype)
8655 && (/* If the function is being defined, then
8656 qualifying type must certainly be complete. */
8658 /* A friend declaration of "T::f" is OK, even if
8659 "T" is a template parameter. But, if this
8660 function is not a friend, the qualifying type
8662 || (!friendp && !CLASS_TYPE_P (ctype))
8663 /* For a declaration, the type need not be
8664 complete, if either it is dependent (since there
8665 is no meaningful definition of complete in that
8666 case) or the qualifying class is currently being
8668 || !(dependent_type_p (ctype)
8669 || currently_open_class (ctype)))
8670 /* Check that the qualifying type is complete. */
8671 && !complete_type_or_else (ctype, NULL_TREE))
8672 return error_mark_node;
8673 else if (TREE_CODE (type) == FUNCTION_TYPE)
8675 tree sname = declarator->u.id.unqualified_name;
8677 if (current_class_type
8678 && (!friendp || funcdef_flag))
8681 ? "cannot define member function %<%T::%s%> within %<%T%>"
8682 : "cannot declare member function %<%T::%s%> within %<%T%>",
8683 ctype, name, current_class_type);
8684 return error_mark_node;
8687 if (TREE_CODE (sname) == IDENTIFIER_NODE
8688 && NEW_DELETE_OPNAME_P (sname))
8689 /* Overloaded operator new and operator delete
8690 are always static functions. */
8693 type = build_memfn_type (type, ctype, memfn_quals);
8695 else if (declspecs->specs[(int)ds_typedef]
8696 && current_class_type)
8698 error ("cannot declare member %<%T::%s%> within %qT",
8699 ctype, name, current_class_type);
8700 return error_mark_node;
8704 /* Now TYPE has the actual type. */
8709 *attrlist = chainon (returned_attrs, *attrlist);
8711 attrlist = &returned_attrs;
8714 /* Handle parameter packs. */
8715 if (parameter_pack_p)
8717 if (decl_context == PARM)
8718 /* Turn the type into a pack expansion.*/
8719 type = make_pack_expansion (type);
8721 error ("non-parameter %qs cannot be a parameter pack", name);
8724 /* Did array size calculations overflow? */
8726 if (TREE_CODE (type) == ARRAY_TYPE
8727 && COMPLETE_TYPE_P (type)
8728 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
8729 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
8731 error ("size of array %qs is too large", name);
8732 /* If we proceed with the array type as it is, we'll eventually
8733 crash in tree_low_cst(). */
8734 type = error_mark_node;
8737 if ((decl_context == FIELD || decl_context == PARM)
8738 && !processing_template_decl
8739 && variably_modified_type_p (type, NULL_TREE))
8741 if (decl_context == FIELD)
8742 error ("data member may not have variably modified type %qT", type);
8744 error ("parameter may not have variably modified type %qT", type);
8745 type = error_mark_node;
8748 if (explicitp == 1 || (explicitp && friendp))
8750 /* [dcl.fct.spec] The explicit specifier shall only be used in
8751 declarations of constructors within a class definition. */
8752 error ("only declarations of constructors can be %<explicit%>");
8756 if (storage_class == sc_mutable)
8758 if (decl_context != FIELD || friendp)
8760 error ("non-member %qs cannot be declared %<mutable%>", name);
8761 storage_class = sc_none;
8763 else if (decl_context == TYPENAME || declspecs->specs[(int)ds_typedef])
8765 error ("non-object member %qs cannot be declared %<mutable%>", name);
8766 storage_class = sc_none;
8768 else if (TREE_CODE (type) == FUNCTION_TYPE
8769 || TREE_CODE (type) == METHOD_TYPE)
8771 error ("function %qs cannot be declared %<mutable%>", name);
8772 storage_class = sc_none;
8776 error ("static %qs cannot be declared %<mutable%>", name);
8777 storage_class = sc_none;
8779 else if (type_quals & TYPE_QUAL_CONST)
8781 error ("const %qs cannot be declared %<mutable%>", name);
8782 storage_class = sc_none;
8786 /* If this is declaring a typedef name, return a TYPE_DECL. */
8787 if (declspecs->specs[(int)ds_typedef] && decl_context != TYPENAME)
8791 /* Note that the grammar rejects storage classes
8792 in typenames, fields or parameters. */
8793 if (current_lang_name == lang_name_java)
8794 TYPE_FOR_JAVA (type) = 1;
8796 /* This declaration:
8798 typedef void f(int) const;
8800 declares a function type which is not a member of any
8801 particular class, but which is cv-qualified; for
8802 example "f S::*" declares a pointer to a const-qualified
8803 member function of S. We record the cv-qualification in the
8805 if (memfn_quals && TREE_CODE (type) == FUNCTION_TYPE)
8807 type = cp_build_qualified_type (type, memfn_quals);
8809 /* We have now dealt with these qualifiers. */
8810 memfn_quals = TYPE_UNQUALIFIED;
8813 if (decl_context == FIELD)
8814 decl = build_lang_decl (TYPE_DECL, unqualified_id, type);
8816 decl = build_decl (input_location, TYPE_DECL, unqualified_id, type);
8817 if (id_declarator && declarator->u.id.qualifying_scope) {
8818 error ("%Jtypedef name may not be a nested-name-specifier", decl);
8819 TREE_TYPE (decl) = error_mark_node;
8822 if (decl_context != FIELD)
8824 if (!current_function_decl)
8825 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8826 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl)
8827 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
8828 (current_function_decl)))
8829 /* The TYPE_DECL is "abstract" because there will be
8830 clones of this constructor/destructor, and there will
8831 be copies of this TYPE_DECL generated in those
8833 DECL_ABSTRACT (decl) = 1;
8835 else if (constructor_name_p (unqualified_id, current_class_type))
8836 permerror (input_location, "ISO C++ forbids nested type %qD with same name "
8837 "as enclosing class",
8840 /* If the user declares "typedef struct {...} foo" then the
8841 struct will have an anonymous name. Fill that name in now.
8842 Nothing can refer to it, so nothing needs know about the name
8844 if (type != error_mark_node
8847 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
8848 && TYPE_ANONYMOUS_P (type)
8849 && cp_type_quals (type) == TYPE_UNQUALIFIED)
8853 /* Replace the anonymous name with the real name everywhere. */
8854 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
8856 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8858 debug_hooks->set_name (t, decl);
8859 TYPE_NAME (t) = decl;
8863 if (TYPE_LANG_SPECIFIC (type))
8864 TYPE_WAS_ANONYMOUS (type) = 1;
8866 /* If this is a typedef within a template class, the nested
8867 type is a (non-primary) template. The name for the
8868 template needs updating as well. */
8869 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
8870 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
8871 = TYPE_IDENTIFIER (type);
8873 /* FIXME remangle member functions; member functions of a
8874 type with external linkage have external linkage. */
8878 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
8879 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
8881 bad_specifiers (decl, "type", virtualp,
8882 memfn_quals != TYPE_UNQUALIFIED,
8883 inlinep, friendp, raises != NULL_TREE);
8888 /* Detect the case of an array type of unspecified size
8889 which came, as such, direct from a typedef name.
8890 We must copy the type, so that the array's domain can be
8891 individually set by the object's initializer. */
8893 if (type && typedef_type
8894 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
8895 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
8896 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
8898 /* Detect where we're using a typedef of function type to declare a
8899 function. PARMS will not be set, so we must create it now. */
8901 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
8903 tree decls = NULL_TREE;
8906 for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
8908 tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
8910 TREE_CHAIN (decl) = decls;
8914 parms = nreverse (decls);
8916 if (decl_context != TYPENAME)
8918 /* A cv-qualifier-seq shall only be part of the function type
8919 for a non-static member function. [8.3.5/4 dcl.fct] */
8920 if (cp_type_quals (type) != TYPE_UNQUALIFIED
8921 && (current_class_type == NULL_TREE || staticp) )
8924 ? G_("qualified function types cannot be used to "
8925 "declare static member functions")
8926 : G_("qualified function types cannot be used to "
8927 "declare free functions"));
8928 type = TYPE_MAIN_VARIANT (type);
8931 /* The qualifiers on the function type become the qualifiers on
8932 the non-static member function. */
8933 memfn_quals |= cp_type_quals (type);
8937 /* If this is a type name (such as, in a cast or sizeof),
8938 compute the type and return it now. */
8940 if (decl_context == TYPENAME)
8942 /* Note that the grammar rejects storage classes
8943 in typenames, fields or parameters. */
8944 if (type_quals != TYPE_UNQUALIFIED)
8945 type_quals = TYPE_UNQUALIFIED;
8947 /* Special case: "friend class foo" looks like a TYPENAME context. */
8950 if (type_quals != TYPE_UNQUALIFIED)
8952 error ("type qualifiers specified for friend class declaration");
8953 type_quals = TYPE_UNQUALIFIED;
8957 error ("%<inline%> specified for friend class declaration");
8963 /* Don't allow friend declaration without a class-key. */
8964 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
8965 permerror (input_location, "template parameters cannot be friends");
8966 else if (TREE_CODE (type) == TYPENAME_TYPE)
8967 permerror (input_location, "friend declaration requires class-key, "
8968 "i.e. %<friend class %T::%D%>",
8969 TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
8971 permerror (input_location, "friend declaration requires class-key, "
8972 "i.e. %<friend %#T%>",
8976 /* Only try to do this stuff if we didn't already give up. */
8977 if (type != integer_type_node)
8979 /* A friendly class? */
8980 if (current_class_type)
8981 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
8984 error ("trying to make class %qT a friend of global scope",
8987 type = void_type_node;
8990 else if (memfn_quals)
8992 if (ctype == NULL_TREE
8993 && TREE_CODE (type) == METHOD_TYPE)
8994 ctype = TYPE_METHOD_BASETYPE (type);
8997 type = build_memfn_type (type, ctype, memfn_quals);
8998 /* Core issue #547: need to allow this in template type args. */
8999 else if (template_type_arg && TREE_CODE (type) == FUNCTION_TYPE)
9000 type = cp_build_qualified_type (type, memfn_quals);
9002 error ("invalid qualifiers on non-member function type");
9007 else if (unqualified_id == NULL_TREE && decl_context != PARM
9008 && decl_context != CATCHPARM
9009 && TREE_CODE (type) != UNION_TYPE
9012 error ("abstract declarator %qT used as declaration", type);
9013 return error_mark_node;
9016 /* Only functions may be declared using an operator-function-id. */
9018 && IDENTIFIER_OPNAME_P (unqualified_id)
9019 && TREE_CODE (type) != FUNCTION_TYPE
9020 && TREE_CODE (type) != METHOD_TYPE)
9022 error ("declaration of %qD as non-function", unqualified_id);
9023 return error_mark_node;
9026 /* We don't check parameter types here because we can emit a better
9027 error message later. */
9028 if (decl_context != PARM)
9030 type = check_var_type (unqualified_id, type);
9031 if (type == error_mark_node)
9032 return error_mark_node;
9035 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
9036 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
9038 if (decl_context == PARM || decl_context == CATCHPARM)
9040 if (ctype || in_namespace)
9041 error ("cannot use %<::%> in parameter declaration");
9043 /* A parameter declared as an array of T is really a pointer to T.
9044 One declared as a function is really a pointer to a function.
9045 One declared as a member is really a pointer to member. */
9047 if (TREE_CODE (type) == ARRAY_TYPE)
9049 /* Transfer const-ness of array into that of type pointed to. */
9050 type = build_pointer_type (TREE_TYPE (type));
9051 type_quals = TYPE_UNQUALIFIED;
9053 else if (TREE_CODE (type) == FUNCTION_TYPE)
9054 type = build_pointer_type (type);
9060 if (decl_context == PARM)
9062 decl = cp_build_parm_decl (unqualified_id, type);
9064 bad_specifiers (decl, "parameter", virtualp,
9065 memfn_quals != TYPE_UNQUALIFIED,
9066 inlinep, friendp, raises != NULL_TREE);
9068 else if (decl_context == FIELD)
9070 /* The C99 flexible array extension. */
9071 if (!staticp && TREE_CODE (type) == ARRAY_TYPE
9072 && TYPE_DOMAIN (type) == NULL_TREE)
9074 tree itype = compute_array_index_type (dname, integer_zero_node);
9075 type = build_cplus_array_type (TREE_TYPE (type), itype);
9078 if (type == error_mark_node)
9080 /* Happens when declaring arrays of sizes which
9081 are error_mark_node, for example. */
9084 else if (in_namespace && !friendp)
9086 /* Something like struct S { int N::j; }; */
9087 error ("invalid use of %<::%>");
9088 return error_mark_node;
9090 else if (TREE_CODE (type) == FUNCTION_TYPE)
9093 tree function_context;
9097 if (ctype == NULL_TREE)
9098 ctype = current_class_type;
9100 if (ctype == NULL_TREE)
9102 error ("can't make %qD into a method -- not in a class",
9104 return error_mark_node;
9107 /* ``A union may [ ... ] not [ have ] virtual functions.''
9109 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
9111 error ("function %qD declared virtual inside a union",
9113 return error_mark_node;
9116 if (NEW_DELETE_OPNAME_P (unqualified_id))
9120 error ("%qD cannot be declared virtual, since it "
9126 else if (staticp < 2)
9127 type = build_memfn_type (type, ctype, memfn_quals);
9130 /* Check that the name used for a destructor makes sense. */
9131 if (sfk == sfk_destructor)
9133 tree uqname = id_declarator->u.id.unqualified_name;
9137 gcc_assert (friendp);
9138 error ("expected qualified name in friend declaration "
9139 "for destructor %qD", uqname);
9140 return error_mark_node;
9143 if (!check_dtor_name (ctype, TREE_OPERAND (uqname, 0)))
9145 error ("declaration of %qD as member of %qT",
9147 return error_mark_node;
9150 else if (sfk == sfk_constructor && friendp)
9152 error ("expected qualified name in friend declaration "
9153 "for constructor %qD",
9154 id_declarator->u.id.unqualified_name);
9155 return error_mark_node;
9158 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
9159 function_context = (ctype != NULL_TREE) ?
9160 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
9161 publicp = (! friendp || ! staticp)
9162 && function_context == NULL_TREE;
9163 decl = grokfndecl (ctype, type,
9164 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
9165 ? unqualified_id : dname,
9168 virtualp, flags, memfn_quals, raises,
9169 friendp ? -1 : 0, friendp, publicp, inlinep,
9171 funcdef_flag, template_count, in_namespace,
9172 attrlist, declarator->id_loc);
9173 if (decl == NULL_TREE)
9174 return error_mark_node;
9176 /* This clobbers the attrs stored in `decl' from `attrlist'. */
9177 /* The decl and setting of decl_attr is also turned off. */
9178 decl = build_decl_attribute_variant (decl, decl_attr);
9181 /* [class.conv.ctor]
9183 A constructor declared without the function-specifier
9184 explicit that can be called with a single parameter
9185 specifies a conversion from the type of its first
9186 parameter to the type of its class. Such a constructor
9187 is called a converting constructor. */
9189 DECL_NONCONVERTING_P (decl) = 1;
9191 else if (TREE_CODE (type) == METHOD_TYPE)
9193 /* We only get here for friend declarations of
9194 members of other classes. */
9195 /* All method decls are public, so tell grokfndecl to set
9196 TREE_PUBLIC, also. */
9197 decl = grokfndecl (ctype, type,
9198 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
9199 ? unqualified_id : dname,
9202 virtualp, flags, memfn_quals, raises,
9203 friendp ? -1 : 0, friendp, 1, 0, sfk,
9204 funcdef_flag, template_count, in_namespace,
9206 declarator->id_loc);
9207 if (decl == NULL_TREE)
9208 return error_mark_node;
9210 else if (!staticp && !dependent_type_p (type)
9211 && !COMPLETE_TYPE_P (complete_type (type))
9212 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
9215 error ("field %qD has incomplete type", unqualified_id);
9217 error ("name %qT has incomplete type", type);
9219 /* If we're instantiating a template, tell them which
9220 instantiation made the field's type be incomplete. */
9221 if (current_class_type
9222 && TYPE_NAME (current_class_type)
9223 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
9225 && declspecs->type == type)
9226 error (" in instantiation of template %qT",
9227 current_class_type);
9229 return error_mark_node;
9235 error ("%qE is neither function nor member function; "
9236 "cannot be declared friend", unqualified_id);
9244 /* Friends are treated specially. */
9245 if (ctype == current_class_type)
9246 ; /* We already issued a permerror. */
9247 else if (decl && DECL_NAME (decl))
9249 if (template_class_depth (current_class_type) == 0)
9251 decl = check_explicit_specialization
9252 (unqualified_id, decl, template_count,
9253 2 * funcdef_flag + 4);
9254 if (decl == error_mark_node)
9255 return error_mark_node;
9258 decl = do_friend (ctype, unqualified_id, decl,
9264 return error_mark_node;
9267 /* Structure field. It may not be a function, except for C++. */
9269 if (decl == NULL_TREE)
9275 /* An attempt is being made to initialize a non-static
9276 member. But, from [class.mem]:
9278 4 A member-declarator can contain a
9279 constant-initializer only if it declares a static
9280 member (_class.static_) of integral or enumeration
9281 type, see _class.static.data_.
9283 This used to be relatively common practice, but
9284 the rest of the compiler does not correctly
9285 handle the initialization unless the member is
9286 static so we make it static below. */
9287 permerror (input_location, "ISO C++ forbids initialization of member %qD",
9289 permerror (input_location, "making %qD static", unqualified_id);
9293 if (uses_template_parms (type))
9294 /* We'll check at instantiation time. */
9296 else if (check_static_variable_definition (unqualified_id,
9298 /* If we just return the declaration, crashes
9299 will sometimes occur. We therefore return
9300 void_type_node, as if this was a friend
9301 declaration, to cause callers to completely
9302 ignore this declaration. */
9303 return error_mark_node;
9308 /* C++ allows static class members. All other work
9309 for this is done by grokfield. */
9310 decl = build_lang_decl (VAR_DECL, unqualified_id, type);
9311 set_linkage_for_static_data_member (decl);
9312 /* Even if there is an in-class initialization, DECL
9313 is considered undefined until an out-of-class
9314 definition is provided. */
9315 DECL_EXTERNAL (decl) = 1;
9318 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
9322 decl = build_decl (input_location,
9323 FIELD_DECL, unqualified_id, type);
9324 DECL_NONADDRESSABLE_P (decl) = bitfield;
9325 if (bitfield && !unqualified_id)
9326 TREE_NO_WARNING (decl) = 1;
9328 if (storage_class == sc_mutable)
9330 DECL_MUTABLE_P (decl) = 1;
9331 storage_class = sc_none;
9335 bad_specifiers (decl, "field", virtualp,
9336 memfn_quals != TYPE_UNQUALIFIED,
9337 inlinep, friendp, raises != NULL_TREE);
9340 else if (TREE_CODE (type) == FUNCTION_TYPE
9341 || TREE_CODE (type) == METHOD_TYPE)
9346 if (!unqualified_id)
9347 return error_mark_node;
9349 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
9350 original_name = dname;
9352 original_name = unqualified_id;
9354 if (storage_class == sc_auto)
9355 error ("storage class %<auto%> invalid for function %qs", name);
9356 else if (storage_class == sc_register)
9357 error ("storage class %<register%> invalid for function %qs", name);
9359 error ("storage class %<__thread%> invalid for function %qs", name);
9361 /* Function declaration not at top level.
9362 Storage classes other than `extern' are not allowed
9363 and `extern' makes no difference. */
9364 if (! toplevel_bindings_p ()
9365 && (storage_class == sc_static
9366 || declspecs->specs[(int)ds_inline])
9369 if (storage_class == sc_static)
9370 pedwarn (input_location, OPT_pedantic,
9371 "%<static%> specified invalid for function %qs "
9372 "declared out of global scope", name);
9374 pedwarn (input_location, OPT_pedantic,
9375 "%<inline%> specifier invalid for function %qs "
9376 "declared out of global scope", name);
9379 if (ctype != NULL_TREE
9380 && TREE_CODE (ctype) != NAMESPACE_DECL && !MAYBE_CLASS_TYPE_P (ctype))
9382 error ("%q#T is not a class or a namespace", ctype);
9386 if (ctype == NULL_TREE)
9390 error ("virtual non-class function %qs", name);
9393 else if (sfk == sfk_constructor
9394 || sfk == sfk_destructor)
9397 ? "%qs defined in a non-class scope"
9398 : "%qs declared in a non-class scope", name);
9402 else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2
9403 && !NEW_DELETE_OPNAME_P (original_name))
9404 type = build_method_type_directly (ctype,
9406 TYPE_ARG_TYPES (type));
9408 /* Record presence of `static'. */
9409 publicp = (ctype != NULL_TREE
9410 || storage_class == sc_extern
9411 || storage_class != sc_static);
9413 decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
9414 virtualp, flags, memfn_quals, raises,
9416 publicp, inlinep, sfk, funcdef_flag,
9417 template_count, in_namespace, attrlist,
9418 declarator->id_loc);
9419 if (decl == NULL_TREE)
9420 return error_mark_node;
9424 int invalid_static = 0;
9426 /* Don't allow a static member function in a class, and forbid
9427 declaring main to be static. */
9428 if (TREE_CODE (type) == METHOD_TYPE)
9430 permerror (input_location, "cannot declare member function %qD to have "
9431 "static linkage", decl);
9434 else if (current_function_decl)
9436 /* FIXME need arm citation */
9437 error ("cannot declare static function inside another function");
9444 storage_class = sc_none;
9450 /* It's a variable. */
9452 /* An uninitialized decl with `extern' is a reference. */
9453 decl = grokvardecl (type, unqualified_id,
9456 (type_quals & TYPE_QUAL_CONST) != 0,
9457 ctype ? ctype : in_namespace);
9458 bad_specifiers (decl, "variable", virtualp,
9459 memfn_quals != TYPE_UNQUALIFIED,
9460 inlinep, friendp, raises != NULL_TREE);
9464 DECL_CONTEXT (decl) = ctype;
9467 permerror (input_location, "%<static%> may not be used when defining "
9468 "(as opposed to declaring) a static data member");
9470 storage_class = sc_none;
9472 if (storage_class == sc_register && TREE_STATIC (decl))
9474 error ("static member %qD declared %<register%>", decl);
9475 storage_class = sc_none;
9477 if (storage_class == sc_extern && pedantic)
9479 pedwarn (input_location, OPT_pedantic,
9480 "cannot explicitly declare member %q#D to have "
9481 "extern linkage", decl);
9482 storage_class = sc_none;
9487 if (storage_class == sc_extern && initialized && !funcdef_flag)
9489 if (toplevel_bindings_p ())
9491 /* It's common practice (and completely valid) to have a const
9492 be initialized and declared extern. */
9493 if (!(type_quals & TYPE_QUAL_CONST))
9494 warning (0, "%qs initialized and declared %<extern%>", name);
9498 error ("%qs has both %<extern%> and initializer", name);
9499 return error_mark_node;
9503 /* Record `register' declaration for warnings on &
9504 and in case doing stupid register allocation. */
9506 if (storage_class == sc_register)
9507 DECL_REGISTER (decl) = 1;
9508 else if (storage_class == sc_extern)
9509 DECL_THIS_EXTERN (decl) = 1;
9510 else if (storage_class == sc_static)
9511 DECL_THIS_STATIC (decl) = 1;
9513 /* Record constancy and volatility on the DECL itself . There's
9514 no need to do this when processing a template; we'll do this
9515 for the instantiated declaration based on the type of DECL. */
9516 if (!processing_template_decl)
9517 cp_apply_type_quals_to_decl (type_quals, decl);
9520 TREE_NO_WARNING (decl) = 1;
9526 /* Subroutine of start_function. Ensure that each of the parameter
9527 types (as listed in PARMS) is complete, as is required for a
9528 function definition. */
9531 require_complete_types_for_parms (tree parms)
9533 for (; parms; parms = TREE_CHAIN (parms))
9535 if (dependent_type_p (TREE_TYPE (parms)))
9537 if (!VOID_TYPE_P (TREE_TYPE (parms))
9538 && complete_type_or_else (TREE_TYPE (parms), parms))
9540 relayout_decl (parms);
9541 DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
9544 /* grokparms or complete_type_or_else will have already issued
9546 TREE_TYPE (parms) = error_mark_node;
9550 /* Returns nonzero if T is a local variable. */
9553 local_variable_p (const_tree t)
9555 if ((TREE_CODE (t) == VAR_DECL
9556 /* A VAR_DECL with a context that is a _TYPE is a static data
9558 && !TYPE_P (CP_DECL_CONTEXT (t))
9559 /* Any other non-local variable must be at namespace scope. */
9560 && !DECL_NAMESPACE_SCOPE_P (t))
9561 || (TREE_CODE (t) == PARM_DECL))
9567 /* Like local_variable_p, but suitable for use as a tree-walking
9571 local_variable_p_walkfn (tree *tp, int *walk_subtrees,
9572 void *data ATTRIBUTE_UNUSED)
9574 if (local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
9576 else if (TYPE_P (*tp))
9583 /* Check that ARG, which is a default-argument expression for a
9584 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
9585 something goes wrong. DECL may also be a _TYPE node, rather than a
9586 DECL, if there is no DECL available. */
9589 check_default_argument (tree decl, tree arg)
9594 if (TREE_CODE (arg) == DEFAULT_ARG)
9595 /* We get a DEFAULT_ARG when looking at an in-class declaration
9596 with a default argument. Ignore the argument for now; we'll
9597 deal with it after the class is complete. */
9606 decl_type = TREE_TYPE (decl);
9608 if (arg == error_mark_node
9609 || decl == error_mark_node
9610 || TREE_TYPE (arg) == error_mark_node
9611 || decl_type == error_mark_node)
9612 /* Something already went wrong. There's no need to check
9614 return error_mark_node;
9616 /* [dcl.fct.default]
9618 A default argument expression is implicitly converted to the
9620 if (!TREE_TYPE (arg)
9621 || !can_convert_arg (decl_type, TREE_TYPE (arg), arg, LOOKUP_NORMAL))
9624 error ("default argument for %q#D has type %qT",
9625 decl, TREE_TYPE (arg));
9627 error ("default argument for parameter of type %qT has type %qT",
9628 decl_type, TREE_TYPE (arg));
9630 return error_mark_node;
9633 /* [dcl.fct.default]
9635 Local variables shall not be used in default argument
9638 The keyword `this' shall not be used in a default argument of a
9640 var = cp_walk_tree_without_duplicates (&arg, local_variable_p_walkfn, NULL);
9643 error ("default argument %qE uses local variable %qD", arg, var);
9644 return error_mark_node;
9651 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
9654 type_is_deprecated (tree type)
9656 enum tree_code code;
9657 if (TREE_DEPRECATED (type))
9659 if (TYPE_NAME (type)
9660 && TREE_DEPRECATED (TYPE_NAME (type)))
9663 code = TREE_CODE (type);
9665 if (code == POINTER_TYPE || code == REFERENCE_TYPE
9666 || code == OFFSET_TYPE || code == FUNCTION_TYPE
9667 || code == METHOD_TYPE || code == ARRAY_TYPE)
9668 return type_is_deprecated (TREE_TYPE (type));
9670 if (TYPE_PTRMEMFUNC_P (type))
9671 return type_is_deprecated
9672 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type))));
9677 /* Decode the list of parameter types for a function type.
9678 Given the list of things declared inside the parens,
9679 return a list of types.
9681 If this parameter does not end with an ellipsis, we append
9684 *PARMS is set to the chain of PARM_DECLs created. */
9687 grokparms (tree parmlist, tree *parms)
9689 tree result = NULL_TREE;
9690 tree decls = NULL_TREE;
9694 for (parm = parmlist; parm != NULL_TREE; parm = TREE_CHAIN (parm))
9696 tree type = NULL_TREE;
9697 tree init = TREE_PURPOSE (parm);
9698 tree decl = TREE_VALUE (parm);
9701 if (parm == void_list_node)
9704 if (! decl || TREE_TYPE (decl) == error_mark_node)
9707 type = TREE_TYPE (decl);
9708 if (VOID_TYPE_P (type))
9710 if (same_type_p (type, void_type_node)
9711 && DECL_SELF_REFERENCE_P (type)
9712 && !DECL_NAME (decl) && !result && TREE_CHAIN (parm) == void_list_node)
9713 /* this is a parmlist of `(void)', which is ok. */
9715 cxx_incomplete_type_error (decl, type);
9716 /* It's not a good idea to actually create parameters of
9717 type `void'; other parts of the compiler assume that a
9718 void type terminates the parameter list. */
9719 type = error_mark_node;
9720 TREE_TYPE (decl) = error_mark_node;
9723 if (type != error_mark_node
9724 && TYPE_FOR_JAVA (type)
9725 && MAYBE_CLASS_TYPE_P (type))
9727 error ("parameter %qD has Java class type", decl);
9728 type = error_mark_node;
9729 TREE_TYPE (decl) = error_mark_node;
9733 if (type != error_mark_node
9734 && (errmsg = targetm.invalid_parameter_type (type)))
9737 type = error_mark_node;
9738 TREE_TYPE (decl) = error_mark_node;
9741 if (type != error_mark_node)
9743 if (deprecated_state != DEPRECATED_SUPPRESS)
9745 tree deptype = type_is_deprecated (type);
9747 warn_deprecated_use (deptype, NULL_TREE);
9750 /* Top-level qualifiers on the parameters are
9751 ignored for function types. */
9752 type = cp_build_qualified_type (type, 0);
9753 if (TREE_CODE (type) == METHOD_TYPE)
9755 error ("parameter %qD invalidly declared method type", decl);
9756 type = build_pointer_type (type);
9757 TREE_TYPE (decl) = type;
9759 else if (abstract_virtuals_error (decl, type))
9760 any_error = 1; /* Seems like a good idea. */
9761 else if (POINTER_TYPE_P (type))
9763 /* [dcl.fct]/6, parameter types cannot contain pointers
9764 (references) to arrays of unknown bound. */
9765 tree t = TREE_TYPE (type);
9766 int ptr = TYPE_PTR_P (type);
9772 else if (TREE_CODE (t) != ARRAY_TYPE)
9774 else if (!TYPE_DOMAIN (t))
9778 if (TREE_CODE (t) == ARRAY_TYPE)
9779 error ("parameter %qD includes %s to array of unknown "
9781 decl, ptr ? "pointer" : "reference", t);
9786 else if (init && !processing_template_decl)
9787 init = check_default_argument (decl, init);
9790 if (TREE_CODE (decl) == PARM_DECL
9791 && FUNCTION_PARAMETER_PACK_P (decl)
9792 && TREE_CHAIN (parm)
9793 && TREE_CHAIN (parm) != void_list_node)
9794 error ("parameter packs must be at the end of the parameter list");
9796 TREE_CHAIN (decl) = decls;
9798 result = tree_cons (init, type, result);
9800 decls = nreverse (decls);
9801 result = nreverse (result);
9803 result = chainon (result, void_list_node);
9810 /* D is a constructor or overloaded `operator='.
9812 Let T be the class in which D is declared. Then, this function
9815 -1 if D's is an ill-formed constructor or copy assignment operator
9816 whose first parameter is of type `T'.
9817 0 if D is not a copy constructor or copy assignment
9819 1 if D is a copy constructor or copy assignment operator whose
9820 first parameter is a reference to const qualified T.
9821 2 if D is a copy constructor or copy assignment operator whose
9822 first parameter is a reference to non-const qualified T.
9824 This function can be used as a predicate. Positive values indicate
9825 a copy constructor and nonzero values indicate a copy assignment
9829 copy_fn_p (const_tree d)
9835 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
9837 if (TREE_CODE (d) == TEMPLATE_DECL
9838 || (DECL_TEMPLATE_INFO (d)
9839 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
9840 /* Instantiations of template member functions are never copy
9841 functions. Note that member functions of templated classes are
9842 represented as template functions internally, and we must
9843 accept those as copy functions. */
9846 args = FUNCTION_FIRST_USER_PARMTYPE (d);
9850 arg_type = TREE_VALUE (args);
9851 if (arg_type == error_mark_node)
9854 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
9856 /* Pass by value copy assignment operator. */
9859 else if (TREE_CODE (arg_type) == REFERENCE_TYPE
9860 && !TYPE_REF_IS_RVALUE (arg_type)
9861 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
9863 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
9869 args = TREE_CHAIN (args);
9871 if (args && args != void_list_node && !TREE_PURPOSE (args))
9872 /* There are more non-optional args. */
9878 /* D is a constructor or overloaded `operator='.
9880 Let T be the class in which D is declared. Then, this function
9881 returns true when D is a move constructor or move assignment
9882 operator, false otherwise. */
9885 move_fn_p (const_tree d)
9889 bool result = false;
9891 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
9893 if (cxx_dialect == cxx98)
9894 /* There are no move constructors if we are in C++98 mode. */
9897 if (TREE_CODE (d) == TEMPLATE_DECL
9898 || (DECL_TEMPLATE_INFO (d)
9899 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
9900 /* Instantiations of template member functions are never copy
9901 functions. Note that member functions of templated classes are
9902 represented as template functions internally, and we must
9903 accept those as copy functions. */
9906 args = FUNCTION_FIRST_USER_PARMTYPE (d);
9910 arg_type = TREE_VALUE (args);
9911 if (arg_type == error_mark_node)
9914 if (TREE_CODE (arg_type) == REFERENCE_TYPE
9915 && TYPE_REF_IS_RVALUE (arg_type)
9916 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)),
9920 args = TREE_CHAIN (args);
9922 if (args && args != void_list_node && !TREE_PURPOSE (args))
9923 /* There are more non-optional args. */
9929 /* Remember any special properties of member function DECL. */
9932 grok_special_member_properties (tree decl)
9936 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
9939 class_type = DECL_CONTEXT (decl);
9940 if (DECL_CONSTRUCTOR_P (decl))
9942 int ctor = copy_fn_p (decl);
9944 if (!DECL_ARTIFICIAL (decl))
9945 TYPE_HAS_USER_CONSTRUCTOR (class_type) = 1;
9951 A non-template constructor for class X is a copy
9952 constructor if its first parameter is of type X&, const
9953 X&, volatile X& or const volatile X&, and either there
9954 are no other parameters or else all other parameters have
9955 default arguments. */
9956 TYPE_HAS_INIT_REF (class_type) = 1;
9957 if (!DECL_DEFAULTED_FN (decl))
9958 TYPE_HAS_COMPLEX_INIT_REF (class_type) = 1;
9960 TYPE_HAS_CONST_INIT_REF (class_type) = 1;
9962 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
9964 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type) = 1;
9965 if (TREE_CODE (decl) == TEMPLATE_DECL || !DECL_DEFAULTED_FN (decl))
9966 TYPE_HAS_COMPLEX_DFLT (class_type) = 1;
9968 else if (is_list_ctor (decl))
9969 TYPE_HAS_LIST_CTOR (class_type) = 1;
9971 else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
9975 A non-template assignment operator for class X is a copy
9976 assignment operator if its parameter is of type X, X&, const
9977 X&, volatile X& or const volatile X&. */
9979 int assop = copy_fn_p (decl);
9983 TYPE_HAS_ASSIGN_REF (class_type) = 1;
9984 if (!DECL_DEFAULTED_FN (decl))
9985 TYPE_HAS_COMPLEX_ASSIGN_REF (class_type) = 1;
9987 TYPE_HAS_CONST_ASSIGN_REF (class_type) = 1;
9992 /* Check a constructor DECL has the correct form. Complains
9993 if the class has a constructor of the form X(X). */
9996 grok_ctor_properties (const_tree ctype, const_tree decl)
9998 int ctor_parm = copy_fn_p (decl);
10004 A declaration of a constructor for a class X is ill-formed if
10005 its first parameter is of type (optionally cv-qualified) X
10006 and either there are no other parameters or else all other
10007 parameters have default arguments.
10009 We *don't* complain about member template instantiations that
10010 have this form, though; they can occur as we try to decide
10011 what constructor to use during overload resolution. Since
10012 overload resolution will never prefer such a constructor to
10013 the non-template copy constructor (which is either explicitly
10014 or implicitly defined), there's no need to worry about their
10015 existence. Theoretically, they should never even be
10016 instantiated, but that's hard to forestall. */
10017 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
10025 /* An operator with this code is unary, but can also be binary. */
10028 ambi_op_p (enum tree_code code)
10030 return (code == INDIRECT_REF
10031 || code == ADDR_EXPR
10032 || code == UNARY_PLUS_EXPR
10033 || code == NEGATE_EXPR
10034 || code == PREINCREMENT_EXPR
10035 || code == PREDECREMENT_EXPR);
10038 /* An operator with this name can only be unary. */
10041 unary_op_p (enum tree_code code)
10043 return (code == TRUTH_NOT_EXPR
10044 || code == BIT_NOT_EXPR
10045 || code == COMPONENT_REF
10046 || code == TYPE_EXPR);
10049 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
10050 errors are issued for invalid declarations. */
10053 grok_op_properties (tree decl, bool complain)
10055 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
10057 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
10058 tree name = DECL_NAME (decl);
10059 enum tree_code operator_code;
10064 /* Count the number of arguments and check for ellipsis. */
10065 for (argtype = argtypes, arity = 0;
10066 argtype && argtype != void_list_node;
10067 argtype = TREE_CHAIN (argtype))
10069 ellipsis_p = !argtype;
10071 class_type = DECL_CONTEXT (decl);
10072 if (class_type && !CLASS_TYPE_P (class_type))
10073 class_type = NULL_TREE;
10075 if (DECL_CONV_FN_P (decl))
10076 operator_code = TYPE_EXPR;
10080 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
10081 if (ansi_opname (CODE) == name) \
10083 operator_code = (CODE); \
10086 else if (ansi_assopname (CODE) == name) \
10088 operator_code = (CODE); \
10089 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
10093 #include "operators.def"
10094 #undef DEF_OPERATOR
10096 gcc_unreachable ();
10099 gcc_assert (operator_code != MAX_TREE_CODES);
10100 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
10103 switch (operator_code)
10106 TYPE_HAS_NEW_OPERATOR (class_type) = 1;
10110 TYPE_GETS_DELETE (class_type) |= 1;
10114 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type) = 1;
10117 case VEC_DELETE_EXPR:
10118 TYPE_GETS_DELETE (class_type) |= 2;
10125 /* [basic.std.dynamic.allocation]/1:
10127 A program is ill-formed if an allocation function is declared
10128 in a namespace scope other than global scope or declared static
10131 The same also holds true for deallocation functions. */
10132 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR
10133 || operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
10135 if (DECL_NAMESPACE_SCOPE_P (decl))
10137 if (CP_DECL_CONTEXT (decl) != global_namespace)
10139 error ("%qD may not be declared within a namespace", decl);
10142 else if (!TREE_PUBLIC (decl))
10144 error ("%qD may not be declared as static", decl);
10150 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
10152 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
10153 DECL_IS_OPERATOR_NEW (decl) = 1;
10155 else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
10156 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
10159 /* An operator function must either be a non-static member function
10160 or have at least one parameter of a class, a reference to a class,
10161 an enumeration, or a reference to an enumeration. 13.4.0.6 */
10162 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
10164 if (operator_code == TYPE_EXPR
10165 || operator_code == CALL_EXPR
10166 || operator_code == COMPONENT_REF
10167 || operator_code == ARRAY_REF
10168 || operator_code == NOP_EXPR)
10170 error ("%qD must be a nonstatic member function", decl);
10177 if (DECL_STATIC_FUNCTION_P (decl))
10179 error ("%qD must be either a non-static member "
10180 "function or a non-member function", decl);
10184 for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
10186 tree arg = non_reference (TREE_VALUE (p));
10187 if (arg == error_mark_node)
10190 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
10191 because these checks are performed even on
10192 template functions. */
10193 if (MAYBE_CLASS_TYPE_P (arg)
10194 || TREE_CODE (arg) == ENUMERAL_TYPE)
10198 if (!p || p == void_list_node)
10201 error ("%qD must have an argument of class or "
10202 "enumerated type", decl);
10208 /* There are no restrictions on the arguments to an overloaded
10210 if (operator_code == CALL_EXPR)
10213 /* Warn about conversion operators that will never be used. */
10214 if (IDENTIFIER_TYPENAME_P (name)
10215 && ! DECL_TEMPLATE_INFO (decl)
10217 /* Warn only declaring the function; there is no need to
10218 warn again about out-of-class definitions. */
10219 && class_type == current_class_type)
10221 tree t = TREE_TYPE (name);
10222 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
10223 const char *what = 0;
10226 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
10228 if (TREE_CODE (t) == VOID_TYPE)
10230 else if (class_type)
10232 if (t == class_type)
10233 what = "the same type";
10234 /* Don't force t to be complete here. */
10235 else if (MAYBE_CLASS_TYPE_P (t)
10236 && COMPLETE_TYPE_P (t)
10237 && DERIVED_FROM_P (t, class_type))
10238 what = "a base class";
10242 warning (OPT_Wconversion, "conversion to %s%s will never use a type "
10243 "conversion operator",
10244 ref ? "a reference to " : "", what);
10247 if (operator_code == COND_EXPR)
10250 error ("ISO C++ prohibits overloading operator ?:");
10253 else if (ellipsis_p)
10255 error ("%qD must not have variable number of arguments", decl);
10258 else if (ambi_op_p (operator_code))
10261 /* We pick the one-argument operator codes by default, so
10262 we don't have to change anything. */
10264 else if (arity == 2)
10266 /* If we thought this was a unary operator, we now know
10267 it to be a binary operator. */
10268 switch (operator_code)
10271 operator_code = MULT_EXPR;
10275 operator_code = BIT_AND_EXPR;
10278 case UNARY_PLUS_EXPR:
10279 operator_code = PLUS_EXPR;
10283 operator_code = MINUS_EXPR;
10286 case PREINCREMENT_EXPR:
10287 operator_code = POSTINCREMENT_EXPR;
10290 case PREDECREMENT_EXPR:
10291 operator_code = POSTDECREMENT_EXPR;
10295 gcc_unreachable ();
10298 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
10300 if ((operator_code == POSTINCREMENT_EXPR
10301 || operator_code == POSTDECREMENT_EXPR)
10302 && ! processing_template_decl
10303 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
10306 error ("postfix %qD must take %<int%> as its argument",
10309 error ("postfix %qD must take %<int%> as its second "
10317 error ("%qD must take either zero or one argument", decl);
10319 error ("%qD must take either one or two arguments", decl);
10323 /* More Effective C++ rule 6. */
10325 && (operator_code == POSTINCREMENT_EXPR
10326 || operator_code == POSTDECREMENT_EXPR
10327 || operator_code == PREINCREMENT_EXPR
10328 || operator_code == PREDECREMENT_EXPR))
10330 tree arg = TREE_VALUE (argtypes);
10331 tree ret = TREE_TYPE (TREE_TYPE (decl));
10332 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
10333 arg = TREE_TYPE (arg);
10334 arg = TYPE_MAIN_VARIANT (arg);
10335 if (operator_code == PREINCREMENT_EXPR
10336 || operator_code == PREDECREMENT_EXPR)
10338 if (TREE_CODE (ret) != REFERENCE_TYPE
10339 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
10341 warning (OPT_Weffc__, "prefix %qD should return %qT", decl,
10342 build_reference_type (arg));
10346 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
10347 warning (OPT_Weffc__, "postfix %qD should return %qT", decl, arg);
10351 else if (unary_op_p (operator_code))
10356 error ("%qD must take %<void%>", decl);
10358 error ("%qD must take exactly one argument", decl);
10362 else /* if (binary_op_p (operator_code)) */
10367 error ("%qD must take exactly one argument", decl);
10369 error ("%qD must take exactly two arguments", decl);
10373 /* More Effective C++ rule 7. */
10375 && (operator_code == TRUTH_ANDIF_EXPR
10376 || operator_code == TRUTH_ORIF_EXPR
10377 || operator_code == COMPOUND_EXPR))
10378 warning (OPT_Weffc__, "user-defined %qD always evaluates both arguments",
10382 /* Effective C++ rule 23. */
10385 && !DECL_ASSIGNMENT_OPERATOR_P (decl)
10386 && (operator_code == PLUS_EXPR
10387 || operator_code == MINUS_EXPR
10388 || operator_code == TRUNC_DIV_EXPR
10389 || operator_code == MULT_EXPR
10390 || operator_code == TRUNC_MOD_EXPR)
10391 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
10392 warning (OPT_Weffc__, "%qD should return by value", decl);
10394 /* [over.oper]/8 */
10395 for (; argtypes && argtypes != void_list_node;
10396 argtypes = TREE_CHAIN (argtypes))
10397 if (TREE_PURPOSE (argtypes))
10399 TREE_PURPOSE (argtypes) = NULL_TREE;
10400 if (operator_code == POSTINCREMENT_EXPR
10401 || operator_code == POSTDECREMENT_EXPR)
10403 pedwarn (input_location, OPT_pedantic, "%qD cannot have default arguments",
10408 error ("%qD cannot have default arguments", decl);
10416 /* Return a string giving the keyword associate with CODE. */
10418 static const char *
10419 tag_name (enum tag_types code)
10431 case typename_type:
10434 gcc_unreachable ();
10438 /* Name lookup in an elaborated-type-specifier (after the keyword
10439 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
10440 elaborated-type-specifier is invalid, issue a diagnostic and return
10441 error_mark_node; otherwise, return the *_TYPE to which it referred.
10442 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
10445 check_elaborated_type_specifier (enum tag_types tag_code,
10447 bool allow_template_p)
10453 struct S { struct S *p; };
10455 name lookup will find the TYPE_DECL for the implicit "S::S"
10456 typedef. Adjust for that here. */
10457 if (DECL_SELF_REFERENCE_P (decl))
10458 decl = TYPE_NAME (TREE_TYPE (decl));
10460 type = TREE_TYPE (decl);
10462 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
10463 is false for this case as well. */
10464 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
10466 error ("using template type parameter %qT after %qs",
10467 type, tag_name (tag_code));
10468 return error_mark_node;
10472 If the identifier resolves to a typedef-name or a template
10473 type-parameter, the elaborated-type-specifier is ill-formed.
10475 In other words, the only legitimate declaration to use in the
10476 elaborated type specifier is the implicit typedef created when
10477 the type is declared. */
10478 else if (!DECL_IMPLICIT_TYPEDEF_P (decl)
10479 && tag_code != typename_type)
10481 error ("using typedef-name %qD after %qs", decl, tag_name (tag_code));
10482 error ("%q+D has a previous declaration here", decl);
10483 return error_mark_node;
10485 else if (TREE_CODE (type) != RECORD_TYPE
10486 && TREE_CODE (type) != UNION_TYPE
10487 && tag_code != enum_type
10488 && tag_code != typename_type)
10490 error ("%qT referred to as %qs", type, tag_name (tag_code));
10491 error ("%q+T has a previous declaration here", type);
10492 return error_mark_node;
10494 else if (TREE_CODE (type) != ENUMERAL_TYPE
10495 && tag_code == enum_type)
10497 error ("%qT referred to as enum", type);
10498 error ("%q+T has a previous declaration here", type);
10499 return error_mark_node;
10501 else if (!allow_template_p
10502 && TREE_CODE (type) == RECORD_TYPE
10503 && CLASSTYPE_IS_TEMPLATE (type))
10505 /* If a class template appears as elaborated type specifier
10506 without a template header such as:
10508 template <class T> class C {};
10509 void f(class C); // No template header here
10511 then the required template argument is missing. */
10512 error ("template argument required for %<%s %T%>",
10513 tag_name (tag_code),
10514 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
10515 return error_mark_node;
10521 /* Lookup NAME in elaborate type specifier in scope according to
10522 SCOPE and issue diagnostics if necessary.
10523 Return *_TYPE node upon success, NULL_TREE when the NAME is not
10524 found, and ERROR_MARK_NODE for type error. */
10527 lookup_and_check_tag (enum tag_types tag_code, tree name,
10528 tag_scope scope, bool template_header_p)
10532 if (scope == ts_global)
10534 /* First try ordinary name lookup, ignoring hidden class name
10535 injected via friend declaration. */
10536 decl = lookup_name_prefer_type (name, 2);
10537 /* If that fails, the name will be placed in the smallest
10538 non-class, non-function-prototype scope according to 3.3.1/5.
10539 We may already have a hidden name declared as friend in this
10540 scope. So lookup again but not ignoring hidden names.
10541 If we find one, that name will be made visible rather than
10542 creating a new tag. */
10544 decl = lookup_type_scope (name, ts_within_enclosing_non_class);
10547 decl = lookup_type_scope (name, scope);
10549 if (decl && DECL_CLASS_TEMPLATE_P (decl))
10550 decl = DECL_TEMPLATE_RESULT (decl);
10552 if (decl && TREE_CODE (decl) == TYPE_DECL)
10554 /* Look for invalid nested type:
10558 if (scope == ts_current && DECL_SELF_REFERENCE_P (decl))
10560 error ("%qD has the same name as the class in which it is "
10563 return error_mark_node;
10566 /* Two cases we need to consider when deciding if a class
10567 template is allowed as an elaborated type specifier:
10568 1. It is a self reference to its own class.
10569 2. It comes with a template header.
10573 template <class T> class C {
10574 class C *c1; // DECL_SELF_REFERENCE_P is true
10577 template <class U> class C; // template_header_p is true
10578 template <class T> class C<T>::D {
10579 class C *c2; // DECL_SELF_REFERENCE_P is true
10582 t = check_elaborated_type_specifier (tag_code,
10585 | DECL_SELF_REFERENCE_P (decl));
10588 else if (decl && TREE_CODE (decl) == TREE_LIST)
10590 error ("reference to %qD is ambiguous", name);
10591 print_candidates (decl);
10592 return error_mark_node;
10598 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
10599 Define the tag as a forward-reference if it is not defined.
10601 If a declaration is given, process it here, and report an error if
10602 multiple declarations are not identical.
10604 SCOPE is TS_CURRENT when this is also a definition. Only look in
10605 the current frame for the name (since C++ allows new names in any
10606 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
10607 declaration. Only look beginning from the current scope outward up
10608 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
10610 TEMPLATE_HEADER_P is true when this declaration is preceded by
10611 a set of template parameters. */
10614 xref_tag (enum tag_types tag_code, tree name,
10615 tag_scope scope, bool template_header_p)
10617 enum tree_code code;
10619 tree context = NULL_TREE;
10621 timevar_push (TV_NAME_LOOKUP);
10623 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
10629 code = RECORD_TYPE;
10635 code = ENUMERAL_TYPE;
10638 gcc_unreachable ();
10641 /* In case of anonymous name, xref_tag is only called to
10642 make type node and push name. Name lookup is not required. */
10643 if (ANON_AGGRNAME_P (name))
10646 t = lookup_and_check_tag (tag_code, name,
10647 scope, template_header_p);
10649 if (t == error_mark_node)
10650 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10652 if (scope != ts_current && t && current_class_type
10653 && template_class_depth (current_class_type)
10654 && template_header_p)
10656 /* Since SCOPE is not TS_CURRENT, we are not looking at a
10657 definition of this tag. Since, in addition, we are currently
10658 processing a (member) template declaration of a template
10659 class, we must be very careful; consider:
10666 { template <class V>
10667 friend struct S1; };
10669 Here, the S2::S1 declaration should not be confused with the
10670 outer declaration. In particular, the inner version should
10671 have a template parameter of level 2, not level 1. This
10672 would be particularly important if the member declaration
10675 template <class V = U> friend struct S1;
10677 say, when we should tsubst into `U' when instantiating
10678 S2. On the other hand, when presented with:
10688 we must find the inner binding eventually. We
10689 accomplish this by making sure that the new type we
10690 create to represent this declaration has the right
10692 context = TYPE_CONTEXT (t);
10698 /* If no such tag is yet defined, create a forward-reference node
10699 and record it as the "definition".
10700 When a real declaration of this type is found,
10701 the forward-reference will be altered into a real type. */
10702 if (code == ENUMERAL_TYPE)
10704 error ("use of enum %q#D without previous declaration", name);
10705 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10709 t = make_class_type (code);
10710 TYPE_CONTEXT (t) = context;
10711 t = pushtag (name, t, scope);
10716 if (template_header_p && MAYBE_CLASS_TYPE_P (t))
10718 if (!redeclare_class_template (t, current_template_parms))
10719 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10721 else if (!processing_template_decl
10722 && CLASS_TYPE_P (t)
10723 && CLASSTYPE_IS_TEMPLATE (t))
10725 error ("redeclaration of %qT as a non-template", t);
10726 error ("previous declaration %q+D", t);
10727 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10730 /* Make injected friend class visible. */
10731 if (scope != ts_within_enclosing_non_class
10732 && hidden_name_p (TYPE_NAME (t)))
10734 DECL_ANTICIPATED (TYPE_NAME (t)) = 0;
10735 DECL_FRIEND_P (TYPE_NAME (t)) = 0;
10737 if (TYPE_TEMPLATE_INFO (t))
10739 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t)) = 0;
10740 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t)) = 0;
10745 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
10749 xref_tag_from_type (tree old, tree id, tag_scope scope)
10751 enum tag_types tag_kind;
10753 if (TREE_CODE (old) == RECORD_TYPE)
10754 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
10756 tag_kind = union_type;
10758 if (id == NULL_TREE)
10759 id = TYPE_IDENTIFIER (old);
10761 return xref_tag (tag_kind, id, scope, false);
10764 /* Create the binfo hierarchy for REF with (possibly NULL) base list
10765 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
10766 access_* node, and the TREE_VALUE is the type of the base-class.
10767 Non-NULL TREE_TYPE indicates virtual inheritance.
10769 Returns true if the binfo hierarchy was successfully created,
10770 false if an error was detected. */
10773 xref_basetypes (tree ref, tree base_list)
10776 tree binfo, base_binfo;
10777 unsigned max_vbases = 0; /* Maximum direct & indirect virtual bases. */
10778 unsigned max_bases = 0; /* Maximum direct bases. */
10780 tree default_access;
10781 tree igo_prev; /* Track Inheritance Graph Order. */
10783 if (ref == error_mark_node)
10786 /* The base of a derived class is private by default, all others are
10788 default_access = (TREE_CODE (ref) == RECORD_TYPE
10789 && CLASSTYPE_DECLARED_CLASS (ref)
10790 ? access_private_node : access_public_node);
10792 /* First, make sure that any templates in base-classes are
10793 instantiated. This ensures that if we call ourselves recursively
10794 we do not get confused about which classes are marked and which
10796 basep = &base_list;
10799 tree basetype = TREE_VALUE (*basep);
10801 if (!(processing_template_decl && uses_template_parms (basetype))
10802 && !complete_type_or_else (basetype, NULL))
10803 /* An incomplete type. Remove it from the list. */
10804 *basep = TREE_CHAIN (*basep);
10808 if (TREE_TYPE (*basep))
10810 if (CLASS_TYPE_P (basetype))
10811 max_vbases += VEC_length (tree, CLASSTYPE_VBASECLASSES (basetype));
10812 basep = &TREE_CHAIN (*basep);
10816 TYPE_MARKED_P (ref) = 1;
10818 /* The binfo slot should be empty, unless this is an (ill-formed)
10820 gcc_assert (!TYPE_BINFO (ref) || TYPE_SIZE (ref));
10821 gcc_assert (TYPE_MAIN_VARIANT (ref) == ref);
10823 binfo = make_tree_binfo (max_bases);
10825 TYPE_BINFO (ref) = binfo;
10826 BINFO_OFFSET (binfo) = size_zero_node;
10827 BINFO_TYPE (binfo) = ref;
10829 /* Apply base-class info set up to the variants of this type. */
10830 fixup_type_variants (ref);
10834 BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, gc, max_bases);
10835 /* An aggregate cannot have baseclasses. */
10836 CLASSTYPE_NON_AGGREGATE (ref) = 1;
10838 if (TREE_CODE (ref) == UNION_TYPE)
10840 error ("derived union %qT invalid", ref);
10847 if (TYPE_FOR_JAVA (ref))
10849 error ("Java class %qT cannot have multiple bases", ref);
10856 CLASSTYPE_VBASECLASSES (ref) = VEC_alloc (tree, gc, max_vbases);
10858 if (TYPE_FOR_JAVA (ref))
10860 error ("Java class %qT cannot have virtual bases", ref);
10865 for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list))
10867 tree access = TREE_PURPOSE (base_list);
10868 int via_virtual = TREE_TYPE (base_list) != NULL_TREE;
10869 tree basetype = TREE_VALUE (base_list);
10871 if (access == access_default_node)
10872 access = default_access;
10874 if (PACK_EXPANSION_P (basetype))
10875 basetype = PACK_EXPANSION_PATTERN (basetype);
10876 if (TREE_CODE (basetype) == TYPE_DECL)
10877 basetype = TREE_TYPE (basetype);
10878 if (!MAYBE_CLASS_TYPE_P (basetype) || TREE_CODE (basetype) == UNION_TYPE)
10880 error ("base type %qT fails to be a struct or class type",
10885 if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0))
10886 TYPE_FOR_JAVA (ref) = 1;
10888 base_binfo = NULL_TREE;
10889 if (CLASS_TYPE_P (basetype) && !dependent_type_p (basetype))
10891 base_binfo = TYPE_BINFO (basetype);
10892 /* The original basetype could have been a typedef'd type. */
10893 basetype = BINFO_TYPE (base_binfo);
10895 /* Inherit flags from the base. */
10896 TYPE_HAS_NEW_OPERATOR (ref)
10897 |= TYPE_HAS_NEW_OPERATOR (basetype);
10898 TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
10899 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
10900 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
10901 TYPE_HAS_CONVERSION (ref) |= TYPE_HAS_CONVERSION (basetype);
10902 CLASSTYPE_DIAMOND_SHAPED_P (ref)
10903 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype);
10904 CLASSTYPE_REPEATED_BASE_P (ref)
10905 |= CLASSTYPE_REPEATED_BASE_P (basetype);
10908 /* We must do this test after we've seen through a typedef
10910 if (TYPE_MARKED_P (basetype))
10912 if (basetype == ref)
10913 error ("recursive type %qT undefined", basetype);
10915 error ("duplicate base type %qT invalid", basetype);
10919 if (PACK_EXPANSION_P (TREE_VALUE (base_list)))
10920 /* Regenerate the pack expansion for the bases. */
10921 basetype = make_pack_expansion (basetype);
10923 TYPE_MARKED_P (basetype) = 1;
10925 base_binfo = copy_binfo (base_binfo, basetype, ref,
10926 &igo_prev, via_virtual);
10927 if (!BINFO_INHERITANCE_CHAIN (base_binfo))
10928 BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
10930 BINFO_BASE_APPEND (binfo, base_binfo);
10931 BINFO_BASE_ACCESS_APPEND (binfo, access);
10934 if (VEC_space (tree, CLASSTYPE_VBASECLASSES (ref), 1))
10935 /* If we have space in the vbase vector, we must have shared at
10936 least one of them, and are therefore diamond shaped. */
10937 CLASSTYPE_DIAMOND_SHAPED_P (ref) = 1;
10939 /* Unmark all the types. */
10940 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
10941 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
10942 TYPE_MARKED_P (ref) = 0;
10944 /* Now see if we have a repeated base type. */
10945 if (!CLASSTYPE_REPEATED_BASE_P (ref))
10947 for (base_binfo = binfo; base_binfo;
10948 base_binfo = TREE_CHAIN (base_binfo))
10950 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
10952 CLASSTYPE_REPEATED_BASE_P (ref) = 1;
10955 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 1;
10957 for (base_binfo = binfo; base_binfo;
10958 base_binfo = TREE_CHAIN (base_binfo))
10959 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
10960 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
10969 /* Begin compiling the definition of an enumeration type.
10972 UNDERLYING_TYPE is the type that will be used as the storage for
10973 the enumeration type. This should be NULL_TREE if no storage type
10976 SCOPED_ENUM_P is true if this is a scoped enumeration type.
10978 Returns the type object, as yet incomplete.
10979 Also records info about it so that build_enumerator
10980 may be used to declare the individual values as they are read. */
10983 start_enum (tree name, tree underlying_type, bool scoped_enum_p)
10987 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
10989 /* If this is the real definition for a previous forward reference,
10990 fill in the contents in the same object that used to be the
10991 forward reference. */
10993 enumtype = lookup_and_check_tag (enum_type, name,
10994 /*tag_scope=*/ts_current,
10995 /*template_header_p=*/false);
10997 if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
10999 error ("multiple definition of %q#T", enumtype);
11000 error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype));
11001 /* Clear out TYPE_VALUES, and start again. */
11002 TYPE_VALUES (enumtype) = NULL_TREE;
11006 /* In case of error, make a dummy enum to allow parsing to
11008 if (enumtype == error_mark_node)
11009 name = make_anon_name ();
11011 enumtype = make_node (ENUMERAL_TYPE);
11012 enumtype = pushtag (name, enumtype, /*tag_scope=*/ts_current);
11015 if (enumtype == error_mark_node)
11020 SET_SCOPED_ENUM_P (enumtype, 1);
11021 begin_scope (sk_scoped_enum, enumtype);
11023 /* [C++0x dcl.enum]p5:
11025 If not explicitly specified, the underlying type of a scoped
11026 enumeration type is int. */
11027 if (!underlying_type)
11028 underlying_type = integer_type_node;
11031 if (underlying_type)
11033 if (CP_INTEGRAL_TYPE_P (underlying_type))
11035 TYPE_MIN_VALUE (enumtype) = TYPE_MIN_VALUE (underlying_type);
11036 TYPE_MAX_VALUE (enumtype) = TYPE_MAX_VALUE (underlying_type);
11037 TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
11038 TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
11039 SET_TYPE_MODE (enumtype, TYPE_MODE (underlying_type));
11040 TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type);
11041 TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
11042 TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
11043 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);
11044 ENUM_UNDERLYING_TYPE (enumtype) = underlying_type;
11047 error ("underlying type %<%T%> of %<%T%> must be an integral type",
11048 underlying_type, enumtype);
11054 /* After processing and defining all the values of an enumeration type,
11055 install their decls in the enumeration type and finish it off.
11056 ENUMTYPE is the type object and VALUES a list of name-value pairs. */
11059 finish_enum (tree enumtype)
11068 bool use_short_enum;
11073 tree underlying_type = NULL_TREE;
11074 bool fixed_underlying_type_p
11075 = ENUM_UNDERLYING_TYPE (enumtype) != NULL_TREE;
11077 /* We built up the VALUES in reverse order. */
11078 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
11080 /* For an enum defined in a template, just set the type of the values;
11081 all further processing is postponed until the template is
11082 instantiated. We need to set the type so that tsubst of a CONST_DECL
11084 if (processing_template_decl)
11086 for (values = TYPE_VALUES (enumtype);
11088 values = TREE_CHAIN (values))
11089 TREE_TYPE (TREE_VALUE (values)) = enumtype;
11090 if (at_function_scope_p ())
11091 add_stmt (build_min (TAG_DEFN, enumtype));
11095 /* Determine the minimum and maximum values of the enumerators. */
11096 if (TYPE_VALUES (enumtype))
11098 minnode = maxnode = NULL_TREE;
11100 for (values = TYPE_VALUES (enumtype);
11102 values = TREE_CHAIN (values))
11104 decl = TREE_VALUE (values);
11106 /* [dcl.enum]: Following the closing brace of an enum-specifier,
11107 each enumerator has the type of its enumeration. Prior to the
11108 closing brace, the type of each enumerator is the type of its
11109 initializing value. */
11110 TREE_TYPE (decl) = enumtype;
11112 /* Update the minimum and maximum values, if appropriate. */
11113 value = DECL_INITIAL (decl);
11114 if (value == error_mark_node)
11115 value = integer_zero_node;
11116 /* Figure out what the minimum and maximum values of the
11117 enumerators are. */
11119 minnode = maxnode = value;
11120 else if (tree_int_cst_lt (maxnode, value))
11122 else if (tree_int_cst_lt (value, minnode))
11129 If the enumerator-list is empty, the underlying type is as if
11130 the enumeration had a single enumerator with value 0. */
11131 minnode = maxnode = integer_zero_node;
11133 /* Compute the number of bits require to represent all values of the
11134 enumeration. We must do this before the type of MINNODE and
11135 MAXNODE are transformed, since tree_int_cst_min_precision relies
11136 on the TREE_TYPE of the value it is passed. */
11137 unsignedp = tree_int_cst_sgn (minnode) >= 0;
11138 lowprec = tree_int_cst_min_precision (minnode, unsignedp);
11139 highprec = tree_int_cst_min_precision (maxnode, unsignedp);
11140 precision = MAX (lowprec, highprec);
11142 if (!fixed_underlying_type_p)
11144 /* Determine the underlying type of the enumeration.
11148 The underlying type of an enumeration is an integral type that
11149 can represent all the enumerator values defined in the
11150 enumeration. It is implementation-defined which integral type is
11151 used as the underlying type for an enumeration except that the
11152 underlying type shall not be larger than int unless the value of
11153 an enumerator cannot fit in an int or unsigned int.
11155 We use "int" or an "unsigned int" as the underlying type, even if
11156 a smaller integral type would work, unless the user has
11157 explicitly requested that we use the smallest possible type. The
11158 user can request that for all enumerations with a command line
11159 flag, or for just one enumeration with an attribute. */
11161 use_short_enum = flag_short_enums
11162 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype));
11164 for (itk = (use_short_enum ? itk_char : itk_int);
11168 underlying_type = integer_types[itk];
11169 if (TYPE_PRECISION (underlying_type) >= precision
11170 && TYPE_UNSIGNED (underlying_type) == unsignedp)
11173 if (itk == itk_none)
11177 IF no integral type can represent all the enumerator values, the
11178 enumeration is ill-formed. */
11179 error ("no integral type can represent all of the enumerator values "
11180 "for %qT", enumtype);
11181 precision = TYPE_PRECISION (long_long_integer_type_node);
11182 underlying_type = integer_types[itk_unsigned_long_long];
11187 The value of sizeof() applied to an enumeration type, an object
11188 of an enumeration type, or an enumerator, is the value of sizeof()
11189 applied to the underlying type. */
11190 TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
11191 TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
11192 SET_TYPE_MODE (enumtype, TYPE_MODE (underlying_type));
11193 TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
11194 TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
11195 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);
11197 /* Set the underlying type of the enumeration type to the
11198 computed enumeration type, restricted to the enumerator
11200 ENUM_UNDERLYING_TYPE (enumtype) = copy_node (underlying_type);
11201 set_min_and_max_values_for_integral_type
11202 (ENUM_UNDERLYING_TYPE (enumtype), precision, unsignedp);
11205 underlying_type = ENUM_UNDERLYING_TYPE (enumtype);
11207 /* Compute the minimum and maximum values for the type.
11211 For an enumeration where emin is the smallest enumerator and emax
11212 is the largest, the values of the enumeration are the values of the
11213 underlying type in the range bmin to bmax, where bmin and bmax are,
11214 respectively, the smallest and largest values of the smallest bit-
11215 field that can store emin and emax. */
11217 /* The middle-end currently assumes that types with TYPE_PRECISION
11218 narrower than their underlying type are suitably zero or sign
11219 extended to fill their mode. g++ doesn't make these guarantees.
11220 Until the middle-end can represent such paradoxical types, we
11221 set the TYPE_PRECISION to the width of the underlying type. */
11222 TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type);
11224 set_min_and_max_values_for_integral_type (enumtype, precision, unsignedp);
11226 /* Convert each of the enumerators to the type of the underlying
11227 type of the enumeration. */
11228 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
11230 location_t saved_location;
11232 decl = TREE_VALUE (values);
11233 saved_location = input_location;
11234 input_location = DECL_SOURCE_LOCATION (decl);
11235 if (fixed_underlying_type_p)
11236 /* If the enumeration type has a fixed underlying type, we
11237 already checked all of the enumerator values. */
11238 value = DECL_INITIAL (decl);
11240 value = perform_implicit_conversion (underlying_type,
11241 DECL_INITIAL (decl),
11242 tf_warning_or_error);
11243 input_location = saved_location;
11245 /* Do not clobber shared ints. */
11246 value = copy_node (value);
11248 TREE_TYPE (value) = enumtype;
11249 DECL_INITIAL (decl) = value;
11252 /* Fix up all variant types of this enum type. */
11253 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
11255 TYPE_VALUES (t) = TYPE_VALUES (enumtype);
11256 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
11257 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
11258 TYPE_SIZE (t) = TYPE_SIZE (enumtype);
11259 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
11260 SET_TYPE_MODE (t, TYPE_MODE (enumtype));
11261 TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
11262 TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
11263 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
11264 TYPE_UNSIGNED (t) = TYPE_UNSIGNED (enumtype);
11265 ENUM_UNDERLYING_TYPE (t) = ENUM_UNDERLYING_TYPE (enumtype);
11268 /* Finish up the scope of a scoped enumeration. */
11269 if (SCOPED_ENUM_P (enumtype))
11272 /* Finish debugging output for this type. */
11273 rest_of_type_compilation (enumtype, namespace_bindings_p ());
11276 /* Build and install a CONST_DECL for an enumeration constant of the
11277 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
11278 Assignment of sequential values by default is handled here. */
11281 build_enumerator (tree name, tree value, tree enumtype)
11287 /* If the VALUE was erroneous, pretend it wasn't there; that will
11288 result in the enum being assigned the next value in sequence. */
11289 if (value == error_mark_node)
11292 /* Remove no-op casts from the value. */
11294 STRIP_TYPE_NOPS (value);
11296 if (! processing_template_decl)
11298 /* Validate and default VALUE. */
11299 if (value != NULL_TREE)
11301 value = integral_constant_value (value);
11303 if (TREE_CODE (value) == INTEGER_CST)
11305 value = perform_integral_promotions (value);
11306 constant_expression_warning (value);
11310 error ("enumerator value for %qD is not an integer constant", name);
11315 /* Default based on previous value. */
11316 if (value == NULL_TREE)
11318 if (TYPE_VALUES (enumtype))
11321 unsigned HOST_WIDE_INT lo;
11325 /* The next value is the previous value plus one.
11326 add_double doesn't know the type of the target expression,
11327 so we must check with int_fits_type_p as well. */
11328 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
11329 if (error_operand_p (prev_value))
11330 value = error_mark_node;
11333 overflowed = add_double (TREE_INT_CST_LOW (prev_value),
11334 TREE_INT_CST_HIGH (prev_value),
11336 value = build_int_cst_wide (TREE_TYPE (prev_value), lo, hi);
11338 |= !int_fits_type_p (value, TREE_TYPE (prev_value));
11342 error ("overflow in enumeration values at %qD", name);
11343 value = error_mark_node;
11348 value = integer_zero_node;
11351 /* Remove no-op casts from the value. */
11352 STRIP_TYPE_NOPS (value);
11354 /* If the underlying type of the enum is fixed, check whether
11355 the enumerator values fits in the underlying type. If it
11356 does not fit, the program is ill-formed [C++0x dcl.enum]. */
11357 if (ENUM_UNDERLYING_TYPE (enumtype)
11359 && TREE_CODE (value) == INTEGER_CST
11360 && !int_fits_type_p (value, ENUM_UNDERLYING_TYPE (enumtype)))
11362 error ("enumerator value %E is too large for underlying type %<%T%>",
11363 value, ENUM_UNDERLYING_TYPE (enumtype));
11365 /* Silently convert the value so that we can continue. */
11366 value = perform_implicit_conversion (ENUM_UNDERLYING_TYPE (enumtype),
11371 /* C++ associates enums with global, function, or class declarations. */
11372 context = current_scope ();
11374 /* Build the actual enumeration constant. Note that the enumeration
11375 constants have the underlying type of the enum (if it is fixed)
11376 or the type of their initializer (if the underlying type of the
11377 enum is not fixed):
11381 If the underlying type is fixed, the type of each enumerator
11382 prior to the closing brace is the underlying type; if the
11383 initializing value of an enumerator cannot be represented by
11384 the underlying type, the program is ill-formed. If the
11385 underlying type is not fixed, the type of each enumerator is
11386 the type of its initializing value.
11388 If the underlying type is not fixed, it will be computed by
11389 finish_enum and we will reset the type of this enumerator. Of
11390 course, if we're processing a template, there may be no value. */
11391 type = value ? TREE_TYPE (value) : NULL_TREE;
11393 if (context && context == current_class_type)
11394 /* This enum declaration is local to the class. We need the full
11395 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
11396 decl = build_lang_decl (CONST_DECL, name, type);
11398 /* It's a global enum, or it's local to a function. (Note local to
11399 a function could mean local to a class method. */
11400 decl = build_decl (input_location, CONST_DECL, name, type);
11402 DECL_CONTEXT (decl) = FROB_CONTEXT (context);
11403 TREE_CONSTANT (decl) = 1;
11404 TREE_READONLY (decl) = 1;
11405 DECL_INITIAL (decl) = value;
11407 if (context && context == current_class_type)
11408 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
11409 on the TYPE_FIELDS list for `S'. (That's so that you can say
11410 things like `S::i' later.) */
11411 finish_member_declaration (decl);
11415 /* Add this enumeration constant to the list for this type. */
11416 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
11419 /* Look for an enumerator with the given NAME within the enumeration
11420 type ENUMTYPE. This routine is used primarily for qualified name
11421 lookup into an enumerator in C++0x, e.g.,
11423 enum class Color { Red, Green, Blue };
11425 Color color = Color::Red;
11427 Returns the value corresponding to the enumerator, or
11428 NULL_TREE if no such enumerator was found. */
11430 lookup_enumerator (tree enumtype, tree name)
11433 gcc_assert (enumtype && TREE_CODE (enumtype) == ENUMERAL_TYPE);
11435 e = purpose_member (name, TYPE_VALUES (enumtype));
11436 return e? TREE_VALUE (e) : NULL_TREE;
11440 /* We're defining DECL. Make sure that it's type is OK. */
11443 check_function_type (tree decl, tree current_function_parms)
11445 tree fntype = TREE_TYPE (decl);
11446 tree return_type = complete_type (TREE_TYPE (fntype));
11448 /* In a function definition, arg types must be complete. */
11449 require_complete_types_for_parms (current_function_parms);
11451 if (dependent_type_p (return_type))
11453 if (!COMPLETE_OR_VOID_TYPE_P (return_type)
11454 || (TYPE_FOR_JAVA (return_type) && MAYBE_CLASS_TYPE_P (return_type)))
11456 tree args = TYPE_ARG_TYPES (fntype);
11458 if (!COMPLETE_OR_VOID_TYPE_P (return_type))
11459 error ("return type %q#T is incomplete", return_type);
11461 error ("return type has Java class type %q#T", return_type);
11463 /* Make it return void instead. */
11464 if (TREE_CODE (fntype) == METHOD_TYPE)
11465 fntype = build_method_type_directly (TREE_TYPE (TREE_VALUE (args)),
11467 TREE_CHAIN (args));
11469 fntype = build_function_type (void_type_node, args);
11471 = build_exception_variant (fntype,
11472 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)));
11475 abstract_virtuals_error (decl, TREE_TYPE (fntype));
11478 /* Create the FUNCTION_DECL for a function definition.
11479 DECLSPECS and DECLARATOR are the parts of the declaration;
11480 they describe the function's name and the type it returns,
11481 but twisted together in a fashion that parallels the syntax of C.
11483 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
11484 DECLARATOR is really the DECL for the function we are about to
11485 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
11486 indicating that the function is an inline defined in-class.
11488 This function creates a binding context for the function body
11489 as well as setting up the FUNCTION_DECL in current_function_decl.
11491 For C++, we must first check whether that datum makes any sense.
11492 For example, "class A local_a(1,2);" means that variable local_a
11493 is an aggregate of type A, which should have a constructor
11494 applied to it with the argument list [1, 2].
11496 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
11497 or may be a BLOCK if the function has been defined previously
11498 in this translation unit. On exit, DECL_INITIAL (decl1) will be
11499 error_mark_node if the function has never been defined, or
11500 a BLOCK if the function has been defined somewhere. */
11503 start_preparsed_function (tree decl1, tree attrs, int flags)
11505 tree ctype = NULL_TREE;
11508 int doing_friend = 0;
11509 struct cp_binding_level *bl;
11510 tree current_function_parms;
11511 struct c_fileinfo *finfo
11512 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1)));
11513 bool honor_interface;
11515 /* Sanity check. */
11516 gcc_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE);
11517 gcc_assert (TREE_CHAIN (void_list_node) == NULL_TREE);
11519 fntype = TREE_TYPE (decl1);
11520 if (TREE_CODE (fntype) == METHOD_TYPE)
11521 ctype = TYPE_METHOD_BASETYPE (fntype);
11523 /* ISO C++ 11.4/5. A friend function defined in a class is in
11524 the (lexical) scope of the class in which it is defined. */
11525 if (!ctype && DECL_FRIEND_P (decl1))
11527 ctype = DECL_FRIEND_CONTEXT (decl1);
11529 /* CTYPE could be null here if we're dealing with a template;
11530 for example, `inline friend float foo()' inside a template
11531 will have no CTYPE set. */
11532 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
11538 if (DECL_DECLARED_INLINE_P (decl1)
11539 && lookup_attribute ("noinline", attrs))
11540 warning (0, "inline function %q+D given attribute noinline", decl1);
11542 /* Handle gnu_inline attribute. */
11543 if (GNU_INLINE_P (decl1))
11545 DECL_EXTERNAL (decl1) = 1;
11546 DECL_NOT_REALLY_EXTERN (decl1) = 0;
11547 DECL_INTERFACE_KNOWN (decl1) = 1;
11548 DECL_DISREGARD_INLINE_LIMITS (decl1) = 1;
11551 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
11552 /* This is a constructor, we must ensure that any default args
11553 introduced by this definition are propagated to the clones
11554 now. The clones are used directly in overload resolution. */
11555 adjust_clone_args (decl1);
11557 /* Sometimes we don't notice that a function is a static member, and
11558 build a METHOD_TYPE for it. Fix that up now. */
11559 if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
11560 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
11562 revert_static_member_fn (decl1);
11566 /* Set up current_class_type, and enter the scope of the class, if
11569 push_nested_class (ctype);
11570 else if (DECL_STATIC_FUNCTION_P (decl1))
11571 push_nested_class (DECL_CONTEXT (decl1));
11573 /* Now that we have entered the scope of the class, we must restore
11574 the bindings for any template parameters surrounding DECL1, if it
11575 is an inline member template. (Order is important; consider the
11576 case where a template parameter has the same name as a field of
11577 the class.) It is not until after this point that
11578 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
11579 if (flags & SF_INCLASS_INLINE)
11580 maybe_begin_member_template_processing (decl1);
11582 /* Effective C++ rule 15. */
11584 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
11585 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
11586 warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");
11588 /* Make the init_value nonzero so pushdecl knows this is not tentative.
11589 error_mark_node is replaced below (in poplevel) with the BLOCK. */
11590 if (!DECL_INITIAL (decl1))
11591 DECL_INITIAL (decl1) = error_mark_node;
11593 /* This function exists in static storage.
11594 (This does not mean `static' in the C sense!) */
11595 TREE_STATIC (decl1) = 1;
11597 /* We must call push_template_decl after current_class_type is set
11598 up. (If we are processing inline definitions after exiting a
11599 class scope, current_class_type will be NULL_TREE until set above
11600 by push_nested_class.) */
11601 if (processing_template_decl)
11603 /* FIXME: Handle error_mark_node more gracefully. */
11604 tree newdecl1 = push_template_decl (decl1);
11605 if (newdecl1 != error_mark_node)
11609 /* We are now in the scope of the function being defined. */
11610 current_function_decl = decl1;
11612 /* Save the parm names or decls from this function's declarator
11613 where store_parm_decls will find them. */
11614 current_function_parms = DECL_ARGUMENTS (decl1);
11616 /* Make sure the parameter and return types are reasonable. When
11617 you declare a function, these types can be incomplete, but they
11618 must be complete when you define the function. */
11619 check_function_type (decl1, current_function_parms);
11621 /* Build the return declaration for the function. */
11622 restype = TREE_TYPE (fntype);
11623 if (DECL_RESULT (decl1) == NULL_TREE)
11627 resdecl = build_decl (input_location, RESULT_DECL, 0, restype);
11628 DECL_ARTIFICIAL (resdecl) = 1;
11629 DECL_IGNORED_P (resdecl) = 1;
11630 DECL_RESULT (decl1) = resdecl;
11632 cp_apply_type_quals_to_decl (cp_type_quals (restype), resdecl);
11635 /* Let the user know we're compiling this function. */
11636 announce_function (decl1);
11638 /* Record the decl so that the function name is defined.
11639 If we already have a decl for this name, and it is a FUNCTION_DECL,
11640 use the old decl. */
11641 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
11643 /* A specialization is not used to guide overload resolution. */
11644 if (!DECL_FUNCTION_MEMBER_P (decl1)
11645 && !(DECL_USE_TEMPLATE (decl1) &&
11646 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1))))
11648 tree olddecl = pushdecl (decl1);
11650 if (olddecl == error_mark_node)
11651 /* If something went wrong when registering the declaration,
11652 use DECL1; we have to have a FUNCTION_DECL to use when
11653 parsing the body of the function. */
11657 /* Otherwise, OLDDECL is either a previous declaration
11658 of the same function or DECL1 itself. */
11660 if (warn_missing_declarations
11661 && olddecl == decl1
11662 && !DECL_MAIN_P (decl1)
11663 && TREE_PUBLIC (decl1)
11664 && !DECL_DECLARED_INLINE_P (decl1))
11668 /* Check whether DECL1 is in an anonymous
11670 for (context = DECL_CONTEXT (decl1);
11672 context = DECL_CONTEXT (context))
11674 if (TREE_CODE (context) == NAMESPACE_DECL
11675 && DECL_NAME (context) == NULL_TREE)
11679 if (context == NULL)
11680 warning (OPT_Wmissing_declarations,
11681 "no previous declaration for %q+D", decl1);
11689 /* We need to set the DECL_CONTEXT. */
11690 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
11691 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
11693 fntype = TREE_TYPE (decl1);
11695 /* If #pragma weak applies, mark the decl appropriately now.
11696 The pragma only applies to global functions. Because
11697 determining whether or not the #pragma applies involves
11698 computing the mangled name for the declaration, we cannot
11699 apply the pragma until after we have merged this declaration
11700 with any previous declarations; if the original declaration
11701 has a linkage specification, that specification applies to
11702 the definition as well, and may affect the mangled name. */
11703 if (!DECL_CONTEXT (decl1))
11704 maybe_apply_pragma_weak (decl1);
11707 /* Reset this in case the call to pushdecl changed it. */
11708 current_function_decl = decl1;
11710 gcc_assert (DECL_INITIAL (decl1));
11712 /* This function may already have been parsed, in which case just
11713 return; our caller will skip over the body without parsing. */
11714 if (DECL_INITIAL (decl1) != error_mark_node)
11717 /* Initialize RTL machinery. We cannot do this until
11718 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
11719 even when processing a template; this is how we get
11720 CFUN set up, and our per-function variables initialized.
11721 FIXME factor out the non-RTL stuff. */
11722 bl = current_binding_level;
11723 allocate_struct_function (decl1, processing_template_decl);
11725 /* Initialize the language data structures. Whenever we start
11726 a new function, we destroy temporaries in the usual way. */
11727 cfun->language = GGC_CNEW (struct language_function);
11728 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
11729 current_binding_level = bl;
11731 /* Even though we're inside a function body, we still don't want to
11732 call expand_expr to calculate the size of a variable-sized array.
11733 We haven't necessarily assigned RTL to all variables yet, so it's
11734 not safe to try to expand expressions involving them. */
11735 cfun->dont_save_pending_sizes_p = 1;
11737 /* Start the statement-tree, start the tree now. */
11738 DECL_SAVED_TREE (decl1) = push_stmt_list ();
11740 /* If we are (erroneously) defining a function that we have already
11741 defined before, wipe out what we knew before. */
11742 if (!DECL_PENDING_INLINE_P (decl1))
11743 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
11745 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
11747 /* We know that this was set up by `grokclassfn'. We do not
11748 wait until `store_parm_decls', since evil parse errors may
11749 never get us to that point. Here we keep the consistency
11750 between `current_class_type' and `current_class_ptr'. */
11751 tree t = DECL_ARGUMENTS (decl1);
11753 gcc_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL);
11754 gcc_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE);
11756 cp_function_chain->x_current_class_ref
11757 = cp_build_indirect_ref (t, NULL, tf_warning_or_error);
11758 cp_function_chain->x_current_class_ptr = t;
11760 /* Constructors and destructors need to know whether they're "in
11761 charge" of initializing virtual base classes. */
11762 t = TREE_CHAIN (t);
11763 if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
11765 current_in_charge_parm = t;
11766 t = TREE_CHAIN (t);
11768 if (DECL_HAS_VTT_PARM_P (decl1))
11770 gcc_assert (DECL_NAME (t) == vtt_parm_identifier);
11771 current_vtt_parm = t;
11775 honor_interface = (!DECL_TEMPLATE_INSTANTIATION (decl1)
11776 /* Implicitly-defined methods (like the
11777 destructor for a class in which no destructor
11778 is explicitly declared) must not be defined
11779 until their definition is needed. So, we
11780 ignore interface specifications for
11781 compiler-generated functions. */
11782 && !DECL_ARTIFICIAL (decl1));
11784 if (DECL_INTERFACE_KNOWN (decl1))
11786 tree ctx = decl_function_context (decl1);
11788 if (DECL_NOT_REALLY_EXTERN (decl1))
11789 DECL_EXTERNAL (decl1) = 0;
11791 if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
11792 && TREE_PUBLIC (ctx))
11793 /* This is a function in a local class in an extern inline
11795 comdat_linkage (decl1);
11797 /* If this function belongs to an interface, it is public.
11798 If it belongs to someone else's interface, it is also external.
11799 This only affects inlines and template instantiations. */
11800 else if (!finfo->interface_unknown && honor_interface)
11802 if (DECL_DECLARED_INLINE_P (decl1)
11803 || DECL_TEMPLATE_INSTANTIATION (decl1)
11804 || processing_template_decl)
11806 DECL_EXTERNAL (decl1)
11807 = (finfo->interface_only
11808 || (DECL_DECLARED_INLINE_P (decl1)
11809 && ! flag_implement_inlines
11810 && !DECL_VINDEX (decl1)));
11812 /* For WIN32 we also want to put these in linkonce sections. */
11813 maybe_make_one_only (decl1);
11816 DECL_EXTERNAL (decl1) = 0;
11817 DECL_INTERFACE_KNOWN (decl1) = 1;
11818 /* If this function is in an interface implemented in this file,
11819 make sure that the back end knows to emit this function
11821 if (!DECL_EXTERNAL (decl1))
11822 mark_needed (decl1);
11824 else if (finfo->interface_unknown && finfo->interface_only
11825 && honor_interface)
11827 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
11828 interface, we will have both finfo->interface_unknown and
11829 finfo->interface_only set. In that case, we don't want to
11830 use the normal heuristics because someone will supply a
11831 #pragma implementation elsewhere, and deducing it here would
11832 produce a conflict. */
11833 comdat_linkage (decl1);
11834 DECL_EXTERNAL (decl1) = 0;
11835 DECL_INTERFACE_KNOWN (decl1) = 1;
11836 DECL_DEFER_OUTPUT (decl1) = 1;
11840 /* This is a definition, not a reference.
11841 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
11842 if (!GNU_INLINE_P (decl1))
11843 DECL_EXTERNAL (decl1) = 0;
11845 if ((DECL_DECLARED_INLINE_P (decl1)
11846 || DECL_TEMPLATE_INSTANTIATION (decl1))
11847 && ! DECL_INTERFACE_KNOWN (decl1)
11848 /* Don't try to defer nested functions for now. */
11849 && ! decl_function_context (decl1))
11850 DECL_DEFER_OUTPUT (decl1) = 1;
11852 DECL_INTERFACE_KNOWN (decl1) = 1;
11855 /* Determine the ELF visibility attribute for the function. We must not
11856 do this before calling "pushdecl", as we must allow "duplicate_decls"
11857 to merge any attributes appropriately. We also need to wait until
11859 if (!DECL_CLONED_FUNCTION_P (decl1))
11860 determine_visibility (decl1);
11862 begin_scope (sk_function_parms, decl1);
11866 if (DECL_DESTRUCTOR_P (decl1)
11867 || (DECL_CONSTRUCTOR_P (decl1)
11868 && targetm.cxx.cdtor_returns_this ()))
11870 cdtor_label = build_decl (input_location,
11871 LABEL_DECL, NULL_TREE, NULL_TREE);
11872 DECL_CONTEXT (cdtor_label) = current_function_decl;
11875 start_fname_decls ();
11877 store_parm_decls (current_function_parms);
11881 /* Like start_preparsed_function, except that instead of a
11882 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
11884 Returns 1 on success. If the DECLARATOR is not suitable for a function
11885 (it defines a datum instead), we return 0, which tells
11886 yyparse to report a parse error. */
11889 start_function (cp_decl_specifier_seq *declspecs,
11890 const cp_declarator *declarator,
11895 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
11896 if (decl1 == error_mark_node)
11898 /* If the declarator is not suitable for a function definition,
11899 cause a syntax error. */
11900 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
11902 error ("invalid function declaration");
11906 if (DECL_MAIN_P (decl1))
11907 /* main must return int. grokfndecl should have corrected it
11908 (and issued a diagnostic) if the user got it wrong. */
11909 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1)),
11910 integer_type_node));
11912 start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT);
11917 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
11921 use_eh_spec_block (tree fn)
11923 return (flag_exceptions && flag_enforce_eh_specs
11924 && !processing_template_decl
11925 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn))
11926 /* We insert the EH_SPEC_BLOCK only in the original
11927 function; then, it is copied automatically to the
11929 && !DECL_CLONED_FUNCTION_P (fn)
11930 /* Implicitly-generated constructors and destructors have
11931 exception specifications. However, those specifications
11932 are the union of the possible exceptions specified by the
11933 constructors/destructors for bases and members, so no
11934 unallowed exception will ever reach this function. By
11935 not creating the EH_SPEC_BLOCK we save a little memory,
11936 and we avoid spurious warnings about unreachable
11938 && !DECL_ARTIFICIAL (fn));
11941 /* Store the parameter declarations into the current function declaration.
11942 This is called after parsing the parameter declarations, before
11943 digesting the body of the function.
11945 Also install to binding contour return value identifier, if any. */
11948 store_parm_decls (tree current_function_parms)
11950 tree fndecl = current_function_decl;
11953 /* This is a chain of any other decls that came in among the parm
11954 declarations. If a parm is declared with enum {foo, bar} x;
11955 then CONST_DECLs for foo and bar are put here. */
11956 tree nonparms = NULL_TREE;
11958 if (current_function_parms)
11960 /* This case is when the function was defined with an ANSI prototype.
11961 The parms already have decls, so we need not do anything here
11962 except record them as in effect
11963 and complain if any redundant old-style parm decls were written. */
11965 tree specparms = current_function_parms;
11968 /* Must clear this because it might contain TYPE_DECLs declared
11970 current_binding_level->names = NULL;
11972 /* If we're doing semantic analysis, then we'll call pushdecl
11973 for each of these. We must do them in reverse order so that
11974 they end in the correct forward order. */
11975 specparms = nreverse (specparms);
11977 for (parm = specparms; parm; parm = next)
11979 next = TREE_CHAIN (parm);
11980 if (TREE_CODE (parm) == PARM_DECL)
11982 if (DECL_NAME (parm) == NULL_TREE
11983 || TREE_CODE (parm) != VOID_TYPE)
11986 error ("parameter %qD declared void", parm);
11990 /* If we find an enum constant or a type tag,
11991 put it aside for the moment. */
11992 TREE_CHAIN (parm) = NULL_TREE;
11993 nonparms = chainon (nonparms, parm);
11997 /* Get the decls in their original chain order and record in the
11998 function. This is all and only the PARM_DECLs that were
11999 pushed into scope by the loop above. */
12000 DECL_ARGUMENTS (fndecl) = getdecls ();
12003 DECL_ARGUMENTS (fndecl) = NULL_TREE;
12005 /* Now store the final chain of decls for the arguments
12006 as the decl-chain of the current lexical scope.
12007 Put the enumerators in as well, at the front so that
12008 DECL_ARGUMENTS is not modified. */
12009 current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));
12011 if (use_eh_spec_block (current_function_decl))
12012 current_eh_spec_block = begin_eh_spec_block ();
12016 /* We have finished doing semantic analysis on DECL, but have not yet
12017 generated RTL for its body. Save away our current state, so that
12018 when we want to generate RTL later we know what to do. */
12021 save_function_data (tree decl)
12023 struct language_function *f;
12025 /* Save the language-specific per-function data so that we can
12026 get it back when we really expand this function. */
12027 gcc_assert (!DECL_PENDING_INLINE_P (decl));
12030 f = GGC_NEW (struct language_function);
12031 memcpy (f, cp_function_chain, sizeof (struct language_function));
12032 DECL_SAVED_FUNCTION_DATA (decl) = f;
12034 /* Clear out the bits we don't need. */
12035 f->base.x_stmt_tree.x_cur_stmt_list = NULL_TREE;
12036 f->bindings = NULL;
12037 f->x_local_names = NULL;
12041 /* Set the return value of the constructor (if present). */
12044 finish_constructor_body (void)
12049 if (targetm.cxx.cdtor_returns_this ()
12050 && (! TYPE_FOR_JAVA (current_class_type)))
12052 /* Any return from a constructor will end up here. */
12053 add_stmt (build_stmt (input_location, LABEL_EXPR, cdtor_label));
12055 val = DECL_ARGUMENTS (current_function_decl);
12056 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
12057 DECL_RESULT (current_function_decl), val);
12058 /* Return the address of the object. */
12059 exprstmt = build_stmt (input_location, RETURN_EXPR, val);
12060 add_stmt (exprstmt);
12064 /* Do all the processing for the beginning of a destructor; set up the
12065 vtable pointers and cleanups for bases and members. */
12068 begin_destructor_body (void)
12070 tree compound_stmt;
12072 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
12073 issued an error message. We still want to try to process the
12074 body of the function, but initialize_vtbl_ptrs will crash if
12075 TYPE_BINFO is NULL. */
12076 if (COMPLETE_TYPE_P (current_class_type))
12078 compound_stmt = begin_compound_stmt (0);
12079 /* Make all virtual function table pointers in non-virtual base
12080 classes point to CURRENT_CLASS_TYPE's virtual function
12082 initialize_vtbl_ptrs (current_class_ptr);
12083 finish_compound_stmt (compound_stmt);
12085 /* And insert cleanups for our bases and members so that they
12086 will be properly destroyed if we throw. */
12087 push_base_cleanups ();
12091 /* At the end of every destructor we generate code to delete the object if
12092 necessary. Do that now. */
12095 finish_destructor_body (void)
12099 /* Any return from a destructor will end up here; that way all base
12100 and member cleanups will be run when the function returns. */
12101 add_stmt (build_stmt (input_location, LABEL_EXPR, cdtor_label));
12103 /* In a virtual destructor, we must call delete. */
12104 if (DECL_VIRTUAL_P (current_function_decl))
12107 tree virtual_size = cxx_sizeof (current_class_type);
12111 At the point of definition of a virtual destructor (including
12112 an implicit definition), non-placement operator delete shall
12113 be looked up in the scope of the destructor's class and if
12114 found shall be accessible and unambiguous. */
12115 exprstmt = build_op_delete_call(DELETE_EXPR, current_class_ptr,
12117 /*global_p=*/false,
12118 /*placement=*/NULL_TREE,
12119 /*alloc_fn=*/NULL_TREE);
12121 if_stmt = begin_if_stmt ();
12122 finish_if_stmt_cond (build2 (BIT_AND_EXPR, integer_type_node,
12123 current_in_charge_parm,
12126 finish_expr_stmt (exprstmt);
12127 finish_then_clause (if_stmt);
12128 finish_if_stmt (if_stmt);
12131 if (targetm.cxx.cdtor_returns_this ())
12135 val = DECL_ARGUMENTS (current_function_decl);
12136 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
12137 DECL_RESULT (current_function_decl), val);
12138 /* Return the address of the object. */
12139 exprstmt = build_stmt (input_location, RETURN_EXPR, val);
12140 add_stmt (exprstmt);
12144 /* Do the necessary processing for the beginning of a function body, which
12145 in this case includes member-initializers, but not the catch clauses of
12146 a function-try-block. Currently, this means opening a binding level
12147 for the member-initializers (in a ctor) and member cleanups (in a dtor). */
12150 begin_function_body (void)
12154 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
12157 if (processing_template_decl)
12158 /* Do nothing now. */;
12160 /* Always keep the BLOCK node associated with the outermost pair of
12161 curly braces of a function. These are needed for correct
12162 operation of dwarfout.c. */
12163 keep_next_level (true);
12165 stmt = begin_compound_stmt (BCS_FN_BODY);
12167 if (processing_template_decl)
12168 /* Do nothing now. */;
12169 else if (DECL_DESTRUCTOR_P (current_function_decl))
12170 begin_destructor_body ();
12175 /* Do the processing for the end of a function body. Currently, this means
12176 closing out the cleanups for fully-constructed bases and members, and in
12177 the case of the destructor, deleting the object if desired. Again, this
12178 is only meaningful for [cd]tors, since they are the only functions where
12179 there is a significant distinction between the main body and any
12180 function catch clauses. Handling, say, main() return semantics here
12181 would be wrong, as flowing off the end of a function catch clause for
12182 main() would also need to return 0. */
12185 finish_function_body (tree compstmt)
12187 if (compstmt == NULL_TREE)
12190 /* Close the block. */
12191 finish_compound_stmt (compstmt);
12193 if (processing_template_decl)
12194 /* Do nothing now. */;
12195 else if (DECL_CONSTRUCTOR_P (current_function_decl))
12196 finish_constructor_body ();
12197 else if (DECL_DESTRUCTOR_P (current_function_decl))
12198 finish_destructor_body ();
12201 /* Given a function, returns the BLOCK corresponding to the outermost level
12202 of curly braces, skipping the artificial block created for constructor
12206 outer_curly_brace_block (tree fndecl)
12208 tree block = BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl));
12209 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
12210 /* Skip the artificial function body block. */
12211 block = BLOCK_SUBBLOCKS (block);
12215 /* Finish up a function declaration and compile that function
12216 all the way to assembler language output. The free the storage
12217 for the function definition.
12219 FLAGS is a bitwise or of the following values:
12221 We just finished processing the body of an in-class inline
12222 function definition. (This processing will have taken place
12223 after the class definition is complete.) */
12226 finish_function (int flags)
12228 tree fndecl = current_function_decl;
12229 tree fntype, ctype = NULL_TREE;
12230 int inclass_inline = (flags & 2) != 0;
12233 /* When we get some parse errors, we can end up without a
12234 current_function_decl, so cope. */
12235 if (fndecl == NULL_TREE)
12236 return error_mark_node;
12238 gcc_assert (!defer_mark_used_calls);
12239 defer_mark_used_calls = true;
12241 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
12242 && DECL_VIRTUAL_P (fndecl)
12243 && !processing_template_decl)
12245 tree fnclass = DECL_CONTEXT (fndecl);
12246 if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
12247 keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
12250 nested = function_depth > 1;
12251 fntype = TREE_TYPE (fndecl);
12253 /* TREE_READONLY (fndecl) = 1;
12254 This caused &foo to be of type ptr-to-const-function
12255 which then got a warning when stored in a ptr-to-function variable. */
12257 gcc_assert (building_stmt_tree ());
12258 /* The current function is being defined, so its DECL_INITIAL should
12259 be set, and unless there's a multiple definition, it should be
12260 error_mark_node. */
12261 gcc_assert (DECL_INITIAL (fndecl) == error_mark_node);
12263 /* For a cloned function, we've already got all the code we need;
12264 there's no need to add any extra bits. */
12265 if (!DECL_CLONED_FUNCTION_P (fndecl))
12267 if (DECL_MAIN_P (current_function_decl))
12271 /* Make it so that `main' always returns 0 by default (or
12274 stmt = finish_return_stmt (integer_one_node);
12276 stmt = finish_return_stmt (integer_zero_node);
12278 /* Hack. We don't want the middle-end to warn that this
12279 return is unreachable, so put the statement on the
12282 location_t linezero = linemap_line_start (line_table, 0, 1);
12283 SET_EXPR_LOCATION (stmt, linezero);
12287 if (use_eh_spec_block (current_function_decl))
12288 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
12289 (TREE_TYPE (current_function_decl)),
12290 current_eh_spec_block);
12293 /* If we're saving up tree structure, tie off the function now. */
12294 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
12296 finish_fname_decls ();
12298 /* If this function can't throw any exceptions, remember that. */
12299 if (!processing_template_decl
12300 && !cp_function_chain->can_throw
12301 && !flag_non_call_exceptions
12302 && !DECL_REPLACEABLE_P (fndecl))
12303 TREE_NOTHROW (fndecl) = 1;
12305 /* This must come after expand_function_end because cleanups might
12306 have declarations (from inline functions) that need to go into
12307 this function's blocks. */
12309 /* If the current binding level isn't the outermost binding level
12310 for this function, either there is a bug, or we have experienced
12311 syntax errors and the statement tree is malformed. */
12312 if (current_binding_level->kind != sk_function_parms)
12314 /* Make sure we have already experienced errors. */
12315 gcc_assert (errorcount);
12317 /* Throw away the broken statement tree and extra binding
12319 DECL_SAVED_TREE (fndecl) = alloc_stmt_list ();
12321 while (current_binding_level->kind != sk_function_parms)
12323 if (current_binding_level->kind == sk_class)
12324 pop_nested_class ();
12326 poplevel (0, 0, 0);
12329 poplevel (1, 0, 1);
12331 /* Statements should always be full-expressions at the outermost set
12332 of curly braces for a function. */
12333 gcc_assert (stmts_are_full_exprs_p ());
12335 /* Set up the named return value optimization, if we can. Candidate
12336 variables are selected in check_return_expr. */
12337 if (current_function_return_value)
12339 tree r = current_function_return_value;
12342 if (r != error_mark_node
12343 /* This is only worth doing for fns that return in memory--and
12344 simpler, since we don't have to worry about promoted modes. */
12345 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
12346 /* Only allow this for variables declared in the outer scope of
12347 the function so we know that their lifetime always ends with a
12348 return; see g++.dg/opt/nrv6.C. We could be more flexible if
12349 we were to do this optimization in tree-ssa. */
12350 && (outer = outer_curly_brace_block (fndecl))
12351 && chain_member (r, BLOCK_VARS (outer)))
12352 finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));
12354 current_function_return_value = NULL_TREE;
12357 /* Remember that we were in class scope. */
12358 if (current_class_name)
12359 ctype = current_class_type;
12361 /* Must mark the RESULT_DECL as being in this function. */
12362 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
12364 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
12365 to the FUNCTION_DECL node itself. */
12366 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
12368 /* Save away current state, if appropriate. */
12369 if (!processing_template_decl)
12370 save_function_data (fndecl);
12372 /* Complain if there's just no return statement. */
12373 if (warn_return_type
12374 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
12375 && !dependent_type_p (TREE_TYPE (fntype))
12376 && !current_function_returns_value && !current_function_returns_null
12377 /* Don't complain if we abort or throw. */
12378 && !current_function_returns_abnormally
12379 && !DECL_NAME (DECL_RESULT (fndecl))
12380 && !TREE_NO_WARNING (fndecl)
12381 /* Structor return values (if any) are set by the compiler. */
12382 && !DECL_CONSTRUCTOR_P (fndecl)
12383 && !DECL_DESTRUCTOR_P (fndecl))
12385 warning (OPT_Wreturn_type,
12386 "no return statement in function returning non-void");
12387 TREE_NO_WARNING (fndecl) = 1;
12390 /* Store the end of the function, so that we get good line number
12391 info for the epilogue. */
12392 cfun->function_end_locus = input_location;
12394 /* Genericize before inlining. */
12395 if (!processing_template_decl)
12397 struct language_function *f = DECL_SAVED_FUNCTION_DATA (fndecl);
12398 invoke_plugin_callbacks (PLUGIN_CXX_CP_PRE_GENERICIZE, fndecl);
12399 cp_genericize (fndecl);
12400 /* Clear out the bits we don't need. */
12401 f->x_current_class_ptr = NULL;
12402 f->x_current_class_ref = NULL;
12403 f->x_eh_spec_block = NULL;
12404 f->x_in_charge_parm = NULL;
12405 f->x_vtt_parm = NULL;
12406 f->x_return_value = NULL;
12407 f->bindings = NULL;
12408 f->extern_decl_map = NULL;
12410 /* Handle attribute((warn_unused_result)). Relies on gimple input. */
12411 c_warn_unused_result (gimple_body (fndecl));
12413 /* Clear out the bits we don't need. */
12414 local_names = NULL;
12416 /* We're leaving the context of this function, so zap cfun. It's still in
12417 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
12419 current_function_decl = NULL;
12421 /* If this is an in-class inline definition, we may have to pop the
12422 bindings for the template parameters that we added in
12423 maybe_begin_member_template_processing when start_function was
12425 if (inclass_inline)
12426 maybe_end_member_template_processing ();
12428 /* Leave the scope of the class. */
12430 pop_nested_class ();
12436 /* Let the error reporting routines know that we're outside a
12437 function. For a nested function, this value is used in
12438 cxx_pop_function_context and then reset via pop_function_context. */
12439 current_function_decl = NULL_TREE;
12441 defer_mark_used_calls = false;
12442 if (deferred_mark_used_calls)
12447 for (i = 0; VEC_iterate (tree, deferred_mark_used_calls, i, decl); i++)
12449 VEC_free (tree, gc, deferred_mark_used_calls);
12455 /* Create the FUNCTION_DECL for a function definition.
12456 DECLSPECS and DECLARATOR are the parts of the declaration;
12457 they describe the return type and the name of the function,
12458 but twisted together in a fashion that parallels the syntax of C.
12460 This function creates a binding context for the function body
12461 as well as setting up the FUNCTION_DECL in current_function_decl.
12463 Returns a FUNCTION_DECL on success.
12465 If the DECLARATOR is not suitable for a function (it defines a datum
12466 instead), we return 0, which tells yyparse to report a parse error.
12468 May return void_type_node indicating that this method is actually
12469 a friend. See grokfield for more details.
12471 Came here with a `.pushlevel' .
12473 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
12474 CHANGES TO CODE IN `grokfield'. */
12477 start_method (cp_decl_specifier_seq *declspecs,
12478 const cp_declarator *declarator, tree attrlist)
12480 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
12483 if (fndecl == error_mark_node)
12484 return error_mark_node;
12486 if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
12488 error ("invalid member function declaration");
12489 return error_mark_node;
12493 cplus_decl_attributes (&fndecl, attrlist, 0);
12495 /* Pass friends other than inline friend functions back. */
12496 if (fndecl == void_type_node)
12499 if (DECL_IN_AGGR_P (fndecl))
12501 if (DECL_CONTEXT (fndecl)
12502 && TREE_CODE (DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
12503 error ("%qD is already defined in class %qT", fndecl,
12504 DECL_CONTEXT (fndecl));
12505 return error_mark_node;
12508 check_template_shadow (fndecl);
12510 DECL_DECLARED_INLINE_P (fndecl) = 1;
12511 DECL_NO_INLINE_WARNING_P (fndecl) = 1;
12513 /* We process method specializations in finish_struct_1. */
12514 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
12516 fndecl = push_template_decl (fndecl);
12517 if (fndecl == error_mark_node)
12521 if (! DECL_FRIEND_P (fndecl))
12523 if (TREE_CHAIN (fndecl))
12525 fndecl = copy_node (fndecl);
12526 TREE_CHAIN (fndecl) = NULL_TREE;
12530 cp_finish_decl (fndecl, NULL_TREE, false, NULL_TREE, 0);
12532 /* Make a place for the parms. */
12533 begin_scope (sk_function_parms, fndecl);
12535 DECL_IN_AGGR_P (fndecl) = 1;
12539 /* Go through the motions of finishing a function definition.
12540 We don't compile this method until after the whole class has
12543 FINISH_METHOD must return something that looks as though it
12544 came from GROKFIELD (since we are defining a method, after all).
12546 This is called after parsing the body of the function definition.
12547 STMTS is the chain of statements that makes up the function body.
12549 DECL is the ..._DECL that `start_method' provided. */
12552 finish_method (tree decl)
12554 tree fndecl = decl;
12559 if (decl == void_type_node)
12562 old_initial = DECL_INITIAL (fndecl);
12564 /* Undo the level for the parms (from start_method).
12565 This is like poplevel, but it causes nothing to be
12566 saved. Saving information here confuses symbol-table
12567 output routines. Besides, this information will
12568 be correctly output when this method is actually
12571 /* Clear out the meanings of the local variables of this level;
12572 also record in each decl which block it belongs to. */
12574 for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
12576 if (DECL_NAME (link) != NULL_TREE)
12577 pop_binding (DECL_NAME (link), link);
12578 gcc_assert (TREE_CODE (link) != FUNCTION_DECL);
12579 DECL_CONTEXT (link) = NULL_TREE;
12582 poplevel (0, 0, 0);
12584 DECL_INITIAL (fndecl) = old_initial;
12590 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
12591 we can lay it out later, when and if its type becomes complete. */
12594 maybe_register_incomplete_var (tree var)
12596 gcc_assert (TREE_CODE (var) == VAR_DECL);
12598 /* Keep track of variables with incomplete types. */
12599 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
12600 && DECL_EXTERNAL (var))
12602 tree inner_type = TREE_TYPE (var);
12604 while (TREE_CODE (inner_type) == ARRAY_TYPE)
12605 inner_type = TREE_TYPE (inner_type);
12606 inner_type = TYPE_MAIN_VARIANT (inner_type);
12608 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
12609 /* RTTI TD entries are created while defining the type_info. */
12610 || (TYPE_LANG_SPECIFIC (inner_type)
12611 && TYPE_BEING_DEFINED (inner_type)))
12612 incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
12616 /* Called when a class type (given by TYPE) is defined. If there are
12617 any existing VAR_DECLs whose type has been completed by this
12618 declaration, update them now. */
12621 complete_vars (tree type)
12623 tree *list = &incomplete_vars;
12625 gcc_assert (CLASS_TYPE_P (type));
12628 if (same_type_p (type, TREE_PURPOSE (*list)))
12630 tree var = TREE_VALUE (*list);
12631 tree type = TREE_TYPE (var);
12632 /* Complete the type of the variable. The VAR_DECL itself
12633 will be laid out in expand_expr. */
12634 complete_type (type);
12635 cp_apply_type_quals_to_decl (cp_type_quals (type), var);
12636 /* Remove this entry from the list. */
12637 *list = TREE_CHAIN (*list);
12640 list = &TREE_CHAIN (*list);
12643 /* Check for pending declarations which may have abstract type. */
12644 complete_type_check_abstract (type);
12647 /* If DECL is of a type which needs a cleanup, build and return an
12648 expression to perform that cleanup here. Return NULL_TREE if no
12649 cleanup need be done. */
12652 cxx_maybe_build_cleanup (tree decl)
12658 /* Assume no cleanup is required. */
12659 cleanup = NULL_TREE;
12661 if (error_operand_p (decl))
12664 /* Handle "__attribute__((cleanup))". We run the cleanup function
12665 before the destructor since the destructor is what actually
12666 terminates the lifetime of the object. */
12667 attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
12674 /* Get the name specified by the user for the cleanup function. */
12675 id = TREE_VALUE (TREE_VALUE (attr));
12676 /* Look up the name to find the cleanup function to call. It is
12677 important to use lookup_name here because that is what is
12678 used in c-common.c:handle_cleanup_attribute when performing
12679 initial checks on the attribute. Note that those checks
12680 include ensuring that the function found is not an overloaded
12681 function, or an object with an overloaded call operator,
12682 etc.; we can rely on the fact that the function found is an
12683 ordinary FUNCTION_DECL. */
12684 fn = lookup_name (id);
12685 arg = build_address (decl);
12687 cleanup = cp_build_function_call (fn, build_tree_list (NULL_TREE,
12689 tf_warning_or_error);
12691 /* Handle ordinary C++ destructors. */
12692 type = TREE_TYPE (decl);
12693 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
12695 int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
12696 bool has_vbases = (TREE_CODE (type) == RECORD_TYPE
12697 && CLASSTYPE_VBASECLASSES (type));
12701 if (TREE_CODE (type) == ARRAY_TYPE)
12704 addr = build_address (decl);
12706 /* Optimize for space over speed here. */
12707 if (!has_vbases || flag_expensive_optimizations)
12708 flags |= LOOKUP_NONVIRTUAL;
12710 call = build_delete (TREE_TYPE (addr), addr,
12711 sfk_complete_destructor, flags, 0);
12713 cleanup = build_compound_expr (input_location, cleanup, call);
12721 /* When a stmt has been parsed, this function is called. */
12728 /* DECL was originally constructed as a non-static member function,
12729 but turned out to be static. Update it accordingly. */
12732 revert_static_member_fn (tree decl)
12735 tree function = TREE_TYPE (decl);
12736 tree args = TYPE_ARG_TYPES (function);
12738 if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
12739 != TYPE_UNQUALIFIED)
12740 error ("static member function %q#D declared with type qualifiers", decl);
12742 args = TREE_CHAIN (args);
12743 tmp = build_function_type (TREE_TYPE (function), args);
12744 tmp = build_qualified_type (tmp, cp_type_quals (function));
12745 tmp = build_exception_variant (tmp,
12746 TYPE_RAISES_EXCEPTIONS (function));
12747 TREE_TYPE (decl) = tmp;
12748 if (DECL_ARGUMENTS (decl))
12749 DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
12750 DECL_STATIC_FUNCTION_P (decl) = 1;
12753 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
12754 one of the language-independent trees. */
12756 enum cp_tree_node_structure_enum
12757 cp_tree_node_structure (union lang_tree_node * t)
12759 switch (TREE_CODE (&t->generic))
12761 case DEFAULT_ARG: return TS_CP_DEFAULT_ARG;
12762 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER;
12763 case OVERLOAD: return TS_CP_OVERLOAD;
12764 case TEMPLATE_PARM_INDEX: return TS_CP_TPI;
12765 case PTRMEM_CST: return TS_CP_PTRMEM;
12766 case BASELINK: return TS_CP_BASELINK;
12767 case STATIC_ASSERT: return TS_CP_STATIC_ASSERT;
12768 case ARGUMENT_PACK_SELECT: return TS_CP_ARGUMENT_PACK_SELECT;
12769 case TRAIT_EXPR: return TS_CP_TRAIT_EXPR;
12770 default: return TS_CP_GENERIC;
12774 /* Build the void_list_node (void_type_node having been created). */
12776 build_void_list_node (void)
12778 tree t = build_tree_list (NULL_TREE, void_type_node);
12783 cp_missing_noreturn_ok_p (tree decl)
12785 /* A missing noreturn is ok for the `main' function. */
12786 return DECL_MAIN_P (decl);
12789 /* Return the COMDAT group into which DECL should be placed. */
12792 cxx_comdat_group (tree decl)
12796 /* Virtual tables, construction virtual tables, and virtual table
12797 tables all go in a single COMDAT group, named after the primary
12799 if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
12800 name = DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl)));
12801 /* For all other DECLs, the COMDAT group is the mangled name of the
12802 declaration itself. */
12805 while (DECL_THUNK_P (decl))
12807 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
12808 into the same section as the target function. In that case
12809 we must return target's name. */
12810 tree target = THUNK_TARGET (decl);
12811 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target)
12812 && DECL_SECTION_NAME (target) != NULL
12813 && DECL_ONE_ONLY (target))
12818 name = DECL_ASSEMBLER_NAME (decl);
12824 #include "gt-cp-decl.h"