1 /* Process declarations and variables for C++ compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
5 Contributed by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
24 /* Process declarations and symbol lookup for C++ front end.
25 Also constructs types; the standard scalar types at initialization,
26 and structure, union, array and enum types when they are declared. */
28 /* ??? not all decl nodes are given the most useful possible
29 line numbers. For example, the CONST_DECLs for enum values. */
33 #include "coretypes.h"
40 #include "tree-inline.h"
50 #include "diagnostic.h"
54 #include "tree-flow.h"
55 #include "pointer-set.h"
58 static tree grokparms (tree parmlist, tree *);
59 static const char *redeclaration_error_message (tree, tree);
61 static int decl_jump_unsafe (tree);
62 static void require_complete_types_for_parms (tree);
63 static int ambi_op_p (enum tree_code);
64 static int unary_op_p (enum tree_code);
65 static void push_local_name (tree);
66 static tree grok_reference_init (tree, tree, tree, tree *);
67 static tree grokvardecl (tree, tree, const cp_decl_specifier_seq *,
69 static void record_unknown_type (tree, const char *);
70 static tree builtin_function_1 (tree, tree, bool);
71 static tree build_library_fn_1 (tree, enum tree_code, tree);
72 static int member_function_or_else (tree, tree, enum overload_flags);
73 static void bad_specifiers (tree, const char *, int, int, int, int,
75 static void check_for_uninitialized_const_var (tree);
76 static hashval_t typename_hash (const void *);
77 static int typename_compare (const void *, const void *);
78 static tree local_variable_p_walkfn (tree *, int *, void *);
79 static tree record_builtin_java_type (const char *, int);
80 static const char *tag_name (enum tag_types);
81 static tree lookup_and_check_tag (enum tag_types, tree, tag_scope, bool);
82 static int walk_namespaces_r (tree, walk_namespaces_fn, void *);
83 static void maybe_deduce_size_from_array_init (tree, tree);
84 static void layout_var_decl (tree);
85 static tree check_initializer (tree, tree, int, tree *);
86 static void make_rtl_for_nonlocal_decl (tree, tree, const char *);
87 static void save_function_data (tree);
88 static void check_function_type (tree, tree);
89 static void finish_constructor_body (void);
90 static void begin_destructor_body (void);
91 static void finish_destructor_body (void);
92 static tree create_array_type_for_decl (tree, tree, tree);
93 static tree get_atexit_node (void);
94 static tree get_dso_handle_node (void);
95 static tree start_cleanup_fn (void);
96 static void end_cleanup_fn (void);
97 static tree cp_make_fname_decl (tree, int);
98 static void initialize_predefined_identifiers (void);
99 static tree check_special_function_return_type
100 (special_function_kind, tree, tree);
101 static tree push_cp_library_fn (enum tree_code, tree);
102 static tree build_cp_library_fn (tree, enum tree_code, tree);
103 static void store_parm_decls (tree);
104 static void initialize_local_var (tree, tree);
105 static void expand_static_init (tree, tree);
106 static tree next_initializable_field (tree);
108 /* The following symbols are subsumed in the cp_global_trees array, and
109 listed here individually for documentation purposes.
112 tree wchar_decl_node;
114 tree vtable_entry_type;
115 tree delta_type_node;
116 tree __t_desc_type_node;
118 tree class_type_node;
119 tree unknown_type_node;
121 Array type `vtable_entry_type[]'
124 tree vtbl_ptr_type_node;
131 A FUNCTION_DECL which can call `abort'. Not necessarily the
132 one that the user will declare, but sufficient to be called
133 by routines that want to abort the program.
137 The FUNCTION_DECL for the default `::operator delete'.
139 tree global_delete_fndecl;
142 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
143 tree tinfo_var_id; */
145 tree cp_global_trees[CPTI_MAX];
147 /* Indicates that there is a type value in some namespace, although
148 that is not necessarily in scope at the moment. */
150 tree global_type_node;
152 /* The node that holds the "name" of the global scope. */
153 tree global_scope_name;
155 #define local_names cp_function_chain->x_local_names
157 /* A list of objects which have constructors or destructors
158 which reside in the global scope. The decl is stored in
159 the TREE_VALUE slot and the initializer is stored
160 in the TREE_PURPOSE slot. */
161 tree static_aggregates;
165 /* A node for the integer constants 2, and 3. */
167 tree integer_two_node, integer_three_node;
169 /* Used only for jumps to as-yet undefined labels, since jumps to
170 defined labels can have their validity checked immediately. */
172 struct named_label_use_entry GTY(())
174 struct named_label_use_entry *next;
175 /* The binding level to which this entry is *currently* attached.
176 This is initially the binding level in which the goto appeared,
177 but is modified as scopes are closed. */
178 struct cp_binding_level *binding_level;
179 /* The head of the names list that was current when the goto appeared,
180 or the inner scope popped. These are the decls that will *not* be
181 skipped when jumping to the label. */
183 /* The location of the goto, for error reporting. */
184 location_t o_goto_locus;
185 /* True if an OpenMP structured block scope has been closed since
186 the goto appeared. This means that the branch from the label will
187 illegally exit an OpenMP scope. */
191 /* A list of all LABEL_DECLs in the function that have names. Here so
192 we can clear out their names' definitions at the end of the
193 function, and so we can check the validity of jumps to these labels. */
195 struct named_label_entry GTY(())
197 /* The decl itself. */
200 /* The binding level to which the label is *currently* attached.
201 This is initially set to the binding level in which the label
202 is defined, but is modified as scopes are closed. */
203 struct cp_binding_level *binding_level;
204 /* The head of the names list that was current when the label was
205 defined, or the inner scope popped. These are the decls that will
206 be skipped when jumping to the label. */
208 /* A tree list of all decls from all binding levels that would be
209 crossed by a backward branch to the label. */
212 /* A list of uses of the label, before the label is defined. */
213 struct named_label_use_entry *uses;
215 /* The following bits are set after the label is defined, and are
216 updated as scopes are popped. They indicate that a backward jump
217 to the label will illegally enter a scope of the given flavor. */
223 #define named_labels cp_function_chain->x_named_labels
225 /* The number of function bodies which we are currently processing.
226 (Zero if we are at namespace scope, one inside the body of a
227 function, two inside the body of a function in a local class, etc.) */
230 /* To avoid unwanted recursion, finish_function defers all mark_used calls
231 encountered during its execution until it finishes. */
232 bool defer_mark_used_calls;
233 VEC(tree, gc) *deferred_mark_used_calls;
235 /* States indicating how grokdeclarator() should handle declspecs marked
236 with __attribute__((deprecated)). An object declared as
237 __attribute__((deprecated)) suppresses warnings of uses of other
239 enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
242 /* A TREE_LIST of VAR_DECLs. The TREE_PURPOSE is a RECORD_TYPE or
243 UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type. At the
244 time the VAR_DECL was declared, the type was incomplete. */
246 static GTY(()) tree incomplete_vars;
248 /* Returns the kind of template specialization we are currently
249 processing, given that it's declaration contained N_CLASS_SCOPES
250 explicit scope qualifications. */
253 current_tmpl_spec_kind (int n_class_scopes)
255 int n_template_parm_scopes = 0;
256 int seen_specialization_p = 0;
257 int innermost_specialization_p = 0;
258 struct cp_binding_level *b;
260 /* Scan through the template parameter scopes. */
261 for (b = current_binding_level;
262 b->kind == sk_template_parms;
265 /* If we see a specialization scope inside a parameter scope,
266 then something is wrong. That corresponds to a declaration
269 template <class T> template <> ...
271 which is always invalid since [temp.expl.spec] forbids the
272 specialization of a class member template if the enclosing
273 class templates are not explicitly specialized as well. */
274 if (b->explicit_spec_p)
276 if (n_template_parm_scopes == 0)
277 innermost_specialization_p = 1;
279 seen_specialization_p = 1;
281 else if (seen_specialization_p == 1)
282 return tsk_invalid_member_spec;
284 ++n_template_parm_scopes;
287 /* Handle explicit instantiations. */
288 if (processing_explicit_instantiation)
290 if (n_template_parm_scopes != 0)
291 /* We've seen a template parameter list during an explicit
292 instantiation. For example:
294 template <class T> template void f(int);
296 This is erroneous. */
297 return tsk_invalid_expl_inst;
299 return tsk_expl_inst;
302 if (n_template_parm_scopes < n_class_scopes)
303 /* We've not seen enough template headers to match all the
304 specialized classes present. For example:
306 template <class T> void R<T>::S<T>::f(int);
308 This is invalid; there needs to be one set of template
309 parameters for each class. */
310 return tsk_insufficient_parms;
311 else if (n_template_parm_scopes == n_class_scopes)
312 /* We're processing a non-template declaration (even though it may
313 be a member of a template class.) For example:
315 template <class T> void S<T>::f(int);
317 The `class T' matches the `S<T>', leaving no template headers
318 corresponding to the `f'. */
320 else if (n_template_parm_scopes > n_class_scopes + 1)
321 /* We've got too many template headers. For example:
323 template <> template <class T> void f (T);
325 There need to be more enclosing classes. */
326 return tsk_excessive_parms;
328 /* This must be a template. It's of the form:
330 template <class T> template <class U> void S<T>::f(U);
332 This is a specialization if the innermost level was a
333 specialization; otherwise it's just a definition of the
335 return innermost_specialization_p ? tsk_expl_spec : tsk_template;
338 /* Exit the current scope. */
346 /* When a label goes out of scope, check to see if that label was used
347 in a valid manner, and issue any appropriate warnings or errors. */
350 pop_label (tree label, tree old_value)
352 if (!processing_template_decl)
354 if (DECL_INITIAL (label) == NULL_TREE)
358 error ("label %q+D used but not defined", label);
359 location = input_location; /* FIXME want (input_filename, (line)0) */
360 /* Avoid crashing later. */
361 define_label (location, DECL_NAME (label));
364 warn_for_unused_label (label);
367 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
370 /* At the end of a function, all labels declared within the function
371 go out of scope. BLOCK is the top-level block for the
375 pop_labels_1 (void **slot, void *data)
377 struct named_label_entry *ent = (struct named_label_entry *) *slot;
378 tree block = (tree) data;
380 pop_label (ent->label_decl, NULL_TREE);
382 /* Put the labels into the "variables" of the top-level block,
383 so debugger can see them. */
384 TREE_CHAIN (ent->label_decl) = BLOCK_VARS (block);
385 BLOCK_VARS (block) = ent->label_decl;
387 htab_clear_slot (named_labels, slot);
393 pop_labels (tree block)
397 htab_traverse (named_labels, pop_labels_1, block);
402 /* At the end of a block with local labels, restore the outer definition. */
405 pop_local_label (tree label, tree old_value)
407 struct named_label_entry dummy;
410 pop_label (label, old_value);
412 dummy.label_decl = label;
413 slot = htab_find_slot (named_labels, &dummy, NO_INSERT);
414 htab_clear_slot (named_labels, slot);
417 /* The following two routines are used to interface to Objective-C++.
418 The binding level is purposely treated as an opaque type. */
421 objc_get_current_scope (void)
423 return current_binding_level;
426 /* The following routine is used by the NeXT-style SJLJ exceptions;
427 variables get marked 'volatile' so as to not be clobbered by
428 _setjmp()/_longjmp() calls. All variables in the current scope,
429 as well as parent scopes up to (but not including) ENCLOSING_BLK
430 shall be thusly marked. */
433 objc_mark_locals_volatile (void *enclosing_blk)
435 struct cp_binding_level *scope;
437 for (scope = current_binding_level;
438 scope && scope != enclosing_blk;
439 scope = scope->level_chain)
443 for (decl = scope->names; decl; decl = TREE_CHAIN (decl))
444 objc_volatilize_decl (decl);
446 /* Do not climb up past the current function. */
447 if (scope->kind == sk_function_parms)
452 /* Update data for defined and undefined labels when leaving a scope. */
455 poplevel_named_label_1 (void **slot, void *data)
457 struct named_label_entry *ent = (struct named_label_entry *) *slot;
458 struct cp_binding_level *bl = (struct cp_binding_level *) data;
459 struct cp_binding_level *obl = bl->level_chain;
461 if (ent->binding_level == bl)
465 for (decl = ent->names_in_scope; decl; decl = TREE_CHAIN (decl))
466 if (decl_jump_unsafe (decl))
467 ent->bad_decls = tree_cons (NULL, decl, ent->bad_decls);
469 ent->binding_level = obl;
470 ent->names_in_scope = obl->names;
474 ent->in_try_scope = true;
477 ent->in_catch_scope = true;
480 ent->in_omp_scope = true;
488 struct named_label_use_entry *use;
490 for (use = ent->uses; use ; use = use->next)
491 if (use->binding_level == bl)
493 use->binding_level = obl;
494 use->names_in_scope = obl->names;
495 if (bl->kind == sk_omp)
496 use->in_omp_scope = true;
503 /* Exit a binding level.
504 Pop the level off, and restore the state of the identifier-decl mappings
505 that were in effect when this level was entered.
507 If KEEP == 1, this level had explicit declarations, so
508 and create a "block" (a BLOCK node) for the level
509 to record its declarations and subblocks for symbol table output.
511 If FUNCTIONBODY is nonzero, this level is the body of a function,
512 so create a block as if KEEP were set and also clear out all
515 If REVERSE is nonzero, reverse the order of decls before putting
516 them into the BLOCK. */
519 poplevel (int keep, int reverse, int functionbody)
522 /* The chain of decls was accumulated in reverse order.
523 Put it into forward order, just for cleanliness. */
525 int tmp = functionbody;
526 int real_functionbody;
530 int leaving_for_scope;
533 timevar_push (TV_NAME_LOOKUP);
538 gcc_assert (current_binding_level->kind != sk_class);
540 real_functionbody = (current_binding_level->kind == sk_cleanup
541 ? ((functionbody = 0), tmp) : functionbody);
542 subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
544 gcc_assert (!VEC_length(cp_class_binding,
545 current_binding_level->class_shadowed));
547 /* We used to use KEEP == 2 to indicate that the new block should go
548 at the beginning of the list of blocks at this binding level,
549 rather than the end. This hack is no longer used. */
550 gcc_assert (keep == 0 || keep == 1);
552 if (current_binding_level->keep)
555 /* Any uses of undefined labels, and any defined labels, now operate
556 under constraints of next binding contour. */
557 if (cfun && !functionbody && named_labels)
558 htab_traverse (named_labels, poplevel_named_label_1,
559 current_binding_level);
561 /* Get the decls in the order they were written.
562 Usually current_binding_level->names is in reverse order.
563 But parameter decls were previously put in forward order. */
566 current_binding_level->names
567 = decls = nreverse (current_binding_level->names);
569 decls = current_binding_level->names;
571 /* If there were any declarations or structure tags in that level,
572 or if this level is a function body,
573 create a BLOCK to record them for the life of this function. */
575 if (keep == 1 || functionbody)
576 block = make_node (BLOCK);
577 if (block != NULL_TREE)
579 BLOCK_VARS (block) = decls;
580 BLOCK_SUBBLOCKS (block) = subblocks;
583 /* In each subblock, record that this is its superior. */
585 for (link = subblocks; link; link = BLOCK_CHAIN (link))
586 BLOCK_SUPERCONTEXT (link) = block;
588 /* We still support the old for-scope rules, whereby the variables
589 in a for-init statement were in scope after the for-statement
590 ended. We only use the new rules if flag_new_for_scope is
593 = current_binding_level->kind == sk_for && flag_new_for_scope == 1;
595 /* Before we remove the declarations first check for unused variables. */
596 if (warn_unused_variable
597 && !processing_template_decl)
598 for (decl = getdecls (); decl; decl = TREE_CHAIN (decl))
599 if (TREE_CODE (decl) == VAR_DECL
600 && ! TREE_USED (decl)
601 && ! DECL_IN_SYSTEM_HEADER (decl)
602 && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl))
603 warning (OPT_Wunused_variable, "unused variable %q+D", decl);
605 /* Remove declarations for all the DECLs in this level. */
606 for (link = decls; link; link = TREE_CHAIN (link))
608 if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
611 tree name = DECL_NAME (link);
615 ob = outer_binding (name,
616 IDENTIFIER_BINDING (name),
619 ns_binding = IDENTIFIER_NAMESPACE_VALUE (name);
621 ns_binding = NULL_TREE;
623 if (ob && ob->scope == current_binding_level->level_chain)
624 /* We have something like:
629 and we are leaving the `for' scope. There's no reason to
630 keep the binding of the inner `i' in this case. */
631 pop_binding (name, link);
632 else if ((ob && (TREE_CODE (ob->value) == TYPE_DECL))
633 || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL))
634 /* Here, we have something like:
642 We must pop the for-scope binding so we know what's a
643 type and what isn't. */
644 pop_binding (name, link);
647 /* Mark this VAR_DECL as dead so that we can tell we left it
648 there only for backward compatibility. */
649 DECL_DEAD_FOR_LOCAL (link) = 1;
651 /* Keep track of what should have happened when we
652 popped the binding. */
655 SET_DECL_SHADOWED_FOR_VAR (link, ob->value);
656 DECL_HAS_SHADOWED_FOR_VAR_P (link) = 1;
659 /* Add it to the list of dead variables in the next
660 outermost binding to that we can remove these when we
661 leave that binding. */
662 current_binding_level->level_chain->dead_vars_from_for
663 = tree_cons (NULL_TREE, link,
664 current_binding_level->level_chain->
667 /* Although we don't pop the cxx_binding, we do clear
668 its SCOPE since the scope is going away now. */
669 IDENTIFIER_BINDING (name)->scope
670 = current_binding_level->level_chain;
677 /* Remove the binding. */
680 if (TREE_CODE (decl) == TREE_LIST)
681 decl = TREE_VALUE (decl);
684 if (TREE_CODE (name) == OVERLOAD)
685 name = OVL_FUNCTION (name);
687 gcc_assert (DECL_P (name));
688 pop_binding (DECL_NAME (name), decl);
692 /* Remove declarations for any `for' variables from inner scopes
693 that we kept around. */
694 for (link = current_binding_level->dead_vars_from_for;
695 link; link = TREE_CHAIN (link))
696 pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
698 /* Restore the IDENTIFIER_TYPE_VALUEs. */
699 for (link = current_binding_level->type_shadowed;
700 link; link = TREE_CHAIN (link))
701 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
703 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
704 for (link = current_binding_level->shadowed_labels;
706 link = TREE_CHAIN (link))
707 pop_local_label (TREE_VALUE (link), TREE_PURPOSE (link));
709 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
710 list if a `using' declaration put them there. The debugging
711 back ends won't understand OVERLOAD, so we remove them here.
712 Because the BLOCK_VARS are (temporarily) shared with
713 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
714 popped all the bindings. */
719 for (d = &BLOCK_VARS (block); *d; )
721 if (TREE_CODE (*d) == TREE_LIST)
722 *d = TREE_CHAIN (*d);
724 d = &TREE_CHAIN (*d);
728 /* If the level being exited is the top level of a function,
729 check over all the labels. */
732 /* Since this is the top level block of a function, the vars are
733 the function's parameters. Don't leave them in the BLOCK
734 because they are found in the FUNCTION_DECL instead. */
735 BLOCK_VARS (block) = 0;
739 kind = current_binding_level->kind;
740 if (kind == sk_cleanup)
744 /* If this is a temporary binding created for a cleanup, then we'll
745 have pushed a statement list level. Pop that, create a new
746 BIND_EXPR for the block, and insert it into the stream. */
747 stmt = pop_stmt_list (current_binding_level->statement_list);
748 stmt = c_build_bind_expr (block, stmt);
755 /* The current function is being defined, so its DECL_INITIAL
756 should be error_mark_node. */
757 gcc_assert (DECL_INITIAL (current_function_decl) == error_mark_node);
758 DECL_INITIAL (current_function_decl) = block;
761 current_binding_level->blocks
762 = chainon (current_binding_level->blocks, block);
764 /* If we did not make a block for the level just exited,
765 any blocks made for inner levels
766 (since they cannot be recorded as subblocks in that level)
767 must be carried forward so they will later become subblocks
768 of something else. */
770 current_binding_level->blocks
771 = chainon (current_binding_level->blocks, subblocks);
773 /* Each and every BLOCK node created here in `poplevel' is important
774 (e.g. for proper debugging information) so if we created one
775 earlier, mark it as "used". */
777 TREE_USED (block) = 1;
779 /* All temporary bindings created for cleanups are popped silently. */
780 if (kind == sk_cleanup)
783 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, block);
786 /* Insert BLOCK at the end of the list of subblocks of the
787 current binding level. This is used when a BIND_EXPR is expanded,
788 to handle the BLOCK node inside the BIND_EXPR. */
791 insert_block (tree block)
793 TREE_USED (block) = 1;
794 current_binding_level->blocks
795 = chainon (current_binding_level->blocks, block);
798 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
799 itself, calling F for each. The DATA is passed to F as well. */
802 walk_namespaces_r (tree name_space, walk_namespaces_fn f, void* data)
805 tree current = NAMESPACE_LEVEL (name_space)->namespaces;
807 result |= (*f) (name_space, data);
809 for (; current; current = TREE_CHAIN (current))
810 result |= walk_namespaces_r (current, f, data);
815 /* Walk all the namespaces, calling F for each. The DATA is passed to
819 walk_namespaces (walk_namespaces_fn f, void* data)
821 return walk_namespaces_r (global_namespace, f, data);
824 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
825 DATA is non-NULL, this is the last time we will call
826 wrapup_global_declarations for this NAMESPACE. */
829 wrapup_globals_for_namespace (tree name_space, void* data)
831 struct cp_binding_level *level = NAMESPACE_LEVEL (name_space);
832 VEC(tree,gc) *statics = level->static_decls;
833 tree *vec = VEC_address (tree, statics);
834 int len = VEC_length (tree, statics);
835 int last_time = (data != 0);
839 check_global_declarations (vec, len);
840 emit_debug_global_declarations (vec, len);
844 /* Write out any globals that need to be output. */
845 return wrapup_global_declarations (vec, len);
849 /* In C++, you don't have to write `struct S' to refer to `S'; you
850 can just use `S'. We accomplish this by creating a TYPE_DECL as
851 if the user had written `typedef struct S S'. Create and return
852 the TYPE_DECL for TYPE. */
855 create_implicit_typedef (tree name, tree type)
859 decl = build_decl (TYPE_DECL, name, type);
860 DECL_ARTIFICIAL (decl) = 1;
861 /* There are other implicit type declarations, like the one *within*
862 a class that allows you to write `S::S'. We must distinguish
864 SET_DECL_IMPLICIT_TYPEDEF_P (decl);
865 TYPE_NAME (type) = decl;
870 /* Remember a local name for name-mangling purposes. */
873 push_local_name (tree decl)
878 timevar_push (TV_NAME_LOOKUP);
880 name = DECL_NAME (decl);
882 nelts = VEC_length (tree, local_names);
883 for (i = 0; i < nelts; i++)
885 t = VEC_index (tree, local_names, i);
886 if (DECL_NAME (t) == name)
888 if (!DECL_LANG_SPECIFIC (decl))
889 retrofit_lang_decl (decl);
890 DECL_LANG_SPECIFIC (decl)->decl_flags.u2sel = 1;
891 if (DECL_LANG_SPECIFIC (t))
892 DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
894 DECL_DISCRIMINATOR (decl) = 1;
896 VEC_replace (tree, local_names, i, decl);
897 timevar_pop (TV_NAME_LOOKUP);
902 VEC_safe_push (tree, gc, local_names, decl);
903 timevar_pop (TV_NAME_LOOKUP);
906 /* Subroutine of duplicate_decls: return truthvalue of whether
907 or not types of these decls match.
909 For C++, we must compare the parameter list so that `int' can match
910 `int&' in a parameter position, but `int&' is not confused with
914 decls_match (tree newdecl, tree olddecl)
918 if (newdecl == olddecl)
921 if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
922 /* If the two DECLs are not even the same kind of thing, we're not
923 interested in their types. */
926 if (TREE_CODE (newdecl) == FUNCTION_DECL)
928 tree f1 = TREE_TYPE (newdecl);
929 tree f2 = TREE_TYPE (olddecl);
930 tree p1 = TYPE_ARG_TYPES (f1);
931 tree p2 = TYPE_ARG_TYPES (f2);
933 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
934 && ! (DECL_EXTERN_C_P (newdecl)
935 && DECL_EXTERN_C_P (olddecl)))
938 if (TREE_CODE (f1) != TREE_CODE (f2))
941 if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
943 if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
944 && (DECL_BUILT_IN (olddecl)
945 #ifndef NO_IMPLICIT_EXTERN_C
946 || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
947 || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
951 types_match = self_promoting_args_p (p1);
952 if (p1 == void_list_node)
953 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
955 #ifndef NO_IMPLICIT_EXTERN_C
956 else if (p1 == NULL_TREE
957 && (DECL_EXTERN_C_P (olddecl)
958 && DECL_IN_SYSTEM_HEADER (olddecl)
959 && !DECL_CLASS_SCOPE_P (olddecl))
960 && (DECL_EXTERN_C_P (newdecl)
961 && DECL_IN_SYSTEM_HEADER (newdecl)
962 && !DECL_CLASS_SCOPE_P (newdecl)))
964 types_match = self_promoting_args_p (p2);
965 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
969 types_match = compparms (p1, p2);
974 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
976 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
977 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
980 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
981 DECL_TEMPLATE_PARMS (olddecl)))
984 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
985 types_match = same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)),
986 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl)));
988 types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
989 DECL_TEMPLATE_RESULT (newdecl));
993 /* Need to check scope for variable declaration (VAR_DECL).
994 For typedef (TYPE_DECL), scope is ignored. */
995 if (TREE_CODE (newdecl) == VAR_DECL
996 && CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
998 Two declarations for an object with C language linkage
999 with the same name (ignoring the namespace that qualify
1000 it) that appear in different namespace scopes refer to
1002 && !(DECL_EXTERN_C_P (olddecl) && DECL_EXTERN_C_P (newdecl)))
1005 if (TREE_TYPE (newdecl) == error_mark_node)
1006 types_match = TREE_TYPE (olddecl) == error_mark_node;
1007 else if (TREE_TYPE (olddecl) == NULL_TREE)
1008 types_match = TREE_TYPE (newdecl) == NULL_TREE;
1009 else if (TREE_TYPE (newdecl) == NULL_TREE)
1012 types_match = comptypes (TREE_TYPE (newdecl),
1013 TREE_TYPE (olddecl),
1014 COMPARE_REDECLARATION);
1020 /* If NEWDECL is `static' and an `extern' was seen previously,
1021 warn about it. OLDDECL is the previous declaration.
1023 Note that this does not apply to the C++ case of declaring
1024 a variable `extern const' and then later `const'.
1026 Don't complain about built-in functions, since they are beyond
1027 the user's control. */
1030 warn_extern_redeclared_static (tree newdecl, tree olddecl)
1034 if (TREE_CODE (newdecl) == TYPE_DECL
1035 || TREE_CODE (newdecl) == TEMPLATE_DECL
1036 || TREE_CODE (newdecl) == CONST_DECL
1037 || TREE_CODE (newdecl) == NAMESPACE_DECL)
1040 /* Don't get confused by static member functions; that's a different
1042 if (TREE_CODE (newdecl) == FUNCTION_DECL
1043 && DECL_STATIC_FUNCTION_P (newdecl))
1046 /* If the old declaration was `static', or the new one isn't, then
1047 then everything is OK. */
1048 if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
1051 /* It's OK to declare a builtin function as `static'. */
1052 if (TREE_CODE (olddecl) == FUNCTION_DECL
1053 && DECL_ARTIFICIAL (olddecl))
1056 name = DECL_ASSEMBLER_NAME (newdecl);
1057 permerror (input_location, "%qD was declared %<extern%> and later %<static%>", newdecl);
1058 permerror (input_location, "previous declaration of %q+D", olddecl);
1061 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1062 function templates. If their exception specifications do not
1063 match, issue a diagnostic. */
1066 check_redeclaration_exception_specification (tree new_decl,
1071 tree new_exceptions;
1072 tree old_exceptions;
1074 new_type = TREE_TYPE (new_decl);
1075 new_exceptions = TYPE_RAISES_EXCEPTIONS (new_type);
1076 old_type = TREE_TYPE (old_decl);
1077 old_exceptions = TYPE_RAISES_EXCEPTIONS (old_type);
1081 If any declaration of a function has an exception-specification,
1082 all declarations, including the definition and an explicit
1083 specialization, of that function shall have an
1084 exception-specification with the same set of type-ids. */
1085 if ((pedantic || ! DECL_IN_SYSTEM_HEADER (old_decl))
1086 && ! DECL_IS_BUILTIN (old_decl)
1088 && !comp_except_specs (new_exceptions, old_exceptions,
1091 error ("declaration of %qF throws different exceptions", new_decl);
1092 error ("from previous declaration %q+F", old_decl);
1096 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1097 && lookup_attribute ("gnu_inline", \
1098 DECL_ATTRIBUTES (fn)))
1100 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1101 If the redeclaration is invalid, a diagnostic is issued, and the
1102 error_mark_node is returned. Otherwise, OLDDECL is returned.
1104 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1107 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1110 duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend)
1112 unsigned olddecl_uid = DECL_UID (olddecl);
1113 int olddecl_friend = 0, types_match = 0, hidden_friend = 0;
1114 int new_defines_function = 0;
1117 if (newdecl == olddecl)
1120 types_match = decls_match (newdecl, olddecl);
1122 /* If either the type of the new decl or the type of the old decl is an
1123 error_mark_node, then that implies that we have already issued an
1124 error (earlier) for some bogus type specification, and in that case,
1125 it is rather pointless to harass the user with yet more error message
1126 about the same declaration, so just pretend the types match here. */
1127 if (TREE_TYPE (newdecl) == error_mark_node
1128 || TREE_TYPE (olddecl) == error_mark_node)
1129 return error_mark_node;
1131 if (DECL_P (olddecl)
1132 && TREE_CODE (newdecl) == FUNCTION_DECL
1133 && TREE_CODE (olddecl) == FUNCTION_DECL
1134 && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
1136 if (DECL_DECLARED_INLINE_P (newdecl)
1137 && DECL_UNINLINABLE (newdecl)
1138 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1139 /* Already warned elsewhere. */;
1140 else if (DECL_DECLARED_INLINE_P (olddecl)
1141 && DECL_UNINLINABLE (olddecl)
1142 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1143 /* Already warned. */;
1144 else if (DECL_DECLARED_INLINE_P (newdecl)
1145 && DECL_UNINLINABLE (olddecl)
1146 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1148 warning (OPT_Wattributes, "function %q+D redeclared as inline",
1150 warning (OPT_Wattributes, "previous declaration of %q+D "
1151 "with attribute noinline", olddecl);
1153 else if (DECL_DECLARED_INLINE_P (olddecl)
1154 && DECL_UNINLINABLE (newdecl)
1155 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1157 warning (OPT_Wattributes, "function %q+D redeclared with "
1158 "attribute noinline", newdecl);
1159 warning (OPT_Wattributes, "previous declaration of %q+D was inline",
1164 /* Check for redeclaration and other discrepancies. */
1165 if (TREE_CODE (olddecl) == FUNCTION_DECL
1166 && DECL_ARTIFICIAL (olddecl))
1168 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl));
1169 if (TREE_CODE (newdecl) != FUNCTION_DECL)
1171 /* Avoid warnings redeclaring built-ins which have not been
1172 explicitly declared. */
1173 if (DECL_ANTICIPATED (olddecl))
1176 /* If you declare a built-in or predefined function name as static,
1177 the old definition is overridden, but optionally warn this was a
1178 bad choice of name. */
1179 if (! TREE_PUBLIC (newdecl))
1181 warning (OPT_Wshadow, "shadowing %s function %q#D",
1182 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
1184 /* Discard the old built-in function. */
1187 /* If the built-in is not ansi, then programs can override
1188 it even globally without an error. */
1189 else if (! DECL_BUILT_IN (olddecl))
1190 warning (0, "library function %q#D redeclared as non-function %q#D",
1194 error ("declaration of %q#D", newdecl);
1195 error ("conflicts with built-in declaration %q#D",
1200 else if (!types_match)
1202 /* Avoid warnings redeclaring built-ins which have not been
1203 explicitly declared. */
1204 if (DECL_ANTICIPATED (olddecl))
1206 /* Deal with fileptr_type_node. FILE type is not known
1207 at the time we create the builtins. */
1210 for (t1 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1211 t2 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1213 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1216 else if (TREE_VALUE (t2) == fileptr_type_node)
1218 tree t = TREE_VALUE (t1);
1220 if (TREE_CODE (t) == POINTER_TYPE
1221 && TYPE_NAME (TREE_TYPE (t))
1222 && DECL_NAME (TYPE_NAME (TREE_TYPE (t)))
1223 == get_identifier ("FILE")
1224 && compparms (TREE_CHAIN (t1), TREE_CHAIN (t2)))
1226 tree oldargs = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1228 TYPE_ARG_TYPES (TREE_TYPE (olddecl))
1229 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1230 types_match = decls_match (newdecl, olddecl);
1232 return duplicate_decls (newdecl, olddecl,
1234 TYPE_ARG_TYPES (TREE_TYPE (olddecl)) = oldargs;
1237 else if (! same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1240 else if ((DECL_EXTERN_C_P (newdecl)
1241 && DECL_EXTERN_C_P (olddecl))
1242 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1243 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1245 /* A near match; override the builtin. */
1247 if (TREE_PUBLIC (newdecl))
1249 warning (0, "new declaration %q#D", newdecl);
1250 warning (0, "ambiguates built-in declaration %q#D",
1254 warning (OPT_Wshadow, "shadowing %s function %q#D",
1255 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
1259 /* Discard the old built-in function. */
1262 /* Replace the old RTL to avoid problems with inlining. */
1263 COPY_DECL_RTL (newdecl, olddecl);
1265 /* Even if the types match, prefer the new declarations type for
1266 built-ins which have not been explicitly declared, for
1267 exception lists, etc... */
1268 else if (DECL_ANTICIPATED (olddecl))
1270 tree type = TREE_TYPE (newdecl);
1271 tree attribs = (*targetm.merge_type_attributes)
1272 (TREE_TYPE (olddecl), type);
1274 type = cp_build_type_attribute_variant (type, attribs);
1275 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = type;
1278 /* If a function is explicitly declared "throw ()", propagate that to
1279 the corresponding builtin. */
1280 if (DECL_BUILT_IN_CLASS (olddecl) == BUILT_IN_NORMAL
1281 && DECL_ANTICIPATED (olddecl)
1282 && TREE_NOTHROW (newdecl)
1283 && !TREE_NOTHROW (olddecl)
1284 && built_in_decls [DECL_FUNCTION_CODE (olddecl)] != NULL_TREE
1285 && built_in_decls [DECL_FUNCTION_CODE (olddecl)] != olddecl
1287 TREE_NOTHROW (built_in_decls [DECL_FUNCTION_CODE (olddecl)]) = 1;
1289 /* Whether or not the builtin can throw exceptions has no
1290 bearing on this declarator. */
1291 TREE_NOTHROW (olddecl) = 0;
1293 if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
1295 /* If a builtin function is redeclared as `static', merge
1296 the declarations, but make the original one static. */
1297 DECL_THIS_STATIC (olddecl) = 1;
1298 TREE_PUBLIC (olddecl) = 0;
1300 /* Make the old declaration consistent with the new one so
1301 that all remnants of the builtin-ness of this function
1302 will be banished. */
1303 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1304 COPY_DECL_RTL (newdecl, olddecl);
1307 else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1309 /* C++ Standard, 3.3, clause 4:
1310 "[Note: a namespace name or a class template name must be unique
1311 in its declarative region (7.3.2, clause 14). ]" */
1312 if (TREE_CODE (olddecl) != NAMESPACE_DECL
1313 && TREE_CODE (newdecl) != NAMESPACE_DECL
1314 && (TREE_CODE (olddecl) != TEMPLATE_DECL
1315 || TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) != TYPE_DECL)
1316 && (TREE_CODE (newdecl) != TEMPLATE_DECL
1317 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != TYPE_DECL))
1319 if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
1320 && TREE_CODE (newdecl) != TYPE_DECL)
1321 || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
1322 && TREE_CODE (olddecl) != TYPE_DECL))
1324 /* We do nothing special here, because C++ does such nasty
1325 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1326 get shadowed, and know that if we need to find a TYPE_DECL
1327 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1328 slot of the identifier. */
1332 if ((TREE_CODE (newdecl) == FUNCTION_DECL
1333 && DECL_FUNCTION_TEMPLATE_P (olddecl))
1334 || (TREE_CODE (olddecl) == FUNCTION_DECL
1335 && DECL_FUNCTION_TEMPLATE_P (newdecl)))
1339 error ("%q#D redeclared as different kind of symbol", newdecl);
1340 if (TREE_CODE (olddecl) == TREE_LIST)
1341 olddecl = TREE_VALUE (olddecl);
1342 error ("previous declaration of %q+#D", olddecl);
1344 return error_mark_node;
1346 else if (!types_match)
1348 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
1349 /* These are certainly not duplicate declarations; they're
1350 from different scopes. */
1353 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1355 /* The name of a class template may not be declared to refer to
1356 any other template, class, function, object, namespace, value,
1357 or type in the same scope. */
1358 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
1359 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1361 error ("declaration of template %q#D", newdecl);
1362 error ("conflicts with previous declaration %q+#D", olddecl);
1364 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
1365 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
1366 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
1367 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
1368 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1369 DECL_TEMPLATE_PARMS (olddecl))
1370 /* Template functions can be disambiguated by
1372 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
1373 TREE_TYPE (TREE_TYPE (olddecl))))
1375 error ("new declaration %q#D", newdecl);
1376 error ("ambiguates old declaration %q+#D", olddecl);
1380 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1382 if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
1384 error ("declaration of C function %q#D conflicts with",
1386 error ("previous declaration %q+#D here", olddecl);
1388 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1389 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1391 error ("new declaration %q#D", newdecl);
1392 error ("ambiguates old declaration %q+#D", olddecl);
1393 return error_mark_node;
1400 error ("conflicting declaration %q#D", newdecl);
1401 error ("%q+D has a previous declaration as %q#D", olddecl, olddecl);
1402 return error_mark_node;
1405 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1406 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
1407 && (!DECL_TEMPLATE_INFO (newdecl)
1408 || (DECL_TI_TEMPLATE (newdecl)
1409 != DECL_TI_TEMPLATE (olddecl))))
1410 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
1411 && (!DECL_TEMPLATE_INFO (olddecl)
1412 || (DECL_TI_TEMPLATE (olddecl)
1413 != DECL_TI_TEMPLATE (newdecl))))))
1414 /* It's OK to have a template specialization and a non-template
1415 with the same type, or to have specializations of two
1416 different templates with the same type. Note that if one is a
1417 specialization, and the other is an instantiation of the same
1418 template, that we do not exit at this point. That situation
1419 can occur if we instantiate a template class, and then
1420 specialize one of its methods. This situation is valid, but
1421 the declarations must be merged in the usual way. */
1423 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1424 && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
1425 && !DECL_USE_TEMPLATE (newdecl))
1426 || (DECL_TEMPLATE_INSTANTIATION (newdecl)
1427 && !DECL_USE_TEMPLATE (olddecl))))
1428 /* One of the declarations is a template instantiation, and the
1429 other is not a template at all. That's OK. */
1431 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1433 /* In [namespace.alias] we have:
1435 In a declarative region, a namespace-alias-definition can be
1436 used to redefine a namespace-alias declared in that declarative
1437 region to refer only to the namespace to which it already
1440 Therefore, if we encounter a second alias directive for the same
1441 alias, we can just ignore the second directive. */
1442 if (DECL_NAMESPACE_ALIAS (newdecl)
1443 && (DECL_NAMESPACE_ALIAS (newdecl)
1444 == DECL_NAMESPACE_ALIAS (olddecl)))
1446 /* [namespace.alias]
1448 A namespace-name or namespace-alias shall not be declared as
1449 the name of any other entity in the same declarative region.
1450 A namespace-name defined at global scope shall not be
1451 declared as the name of any other entity in any global scope
1453 error ("declaration of namespace %qD conflicts with", newdecl);
1454 error ("previous declaration of namespace %q+D here", olddecl);
1455 return error_mark_node;
1459 const char *errmsg = redeclaration_error_message (newdecl, olddecl);
1462 error_at (DECL_SOURCE_LOCATION (newdecl), errmsg, newdecl);
1463 if (DECL_NAME (olddecl) != NULL_TREE)
1464 error ((DECL_INITIAL (olddecl) && namespace_bindings_p ())
1465 ? "%q+#D previously defined here"
1466 : "%q+#D previously declared here", olddecl);
1467 return error_mark_node;
1469 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1470 && DECL_INITIAL (olddecl) != NULL_TREE
1471 && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
1472 && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
1474 /* Prototype decl follows defn w/o prototype. */
1475 warning (0, "prototype for %q+#D", newdecl);
1476 warning (0, "%Jfollows non-prototype definition here", olddecl);
1478 else if ((TREE_CODE (olddecl) == FUNCTION_DECL
1479 || TREE_CODE (olddecl) == VAR_DECL)
1480 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
1483 If two declarations of the same function or object
1484 specify different linkage-specifications ..., the program
1485 is ill-formed.... Except for functions with C++ linkage,
1486 a function declaration without a linkage specification
1487 shall not precede the first linkage specification for
1488 that function. A function can be declared without a
1489 linkage specification after an explicit linkage
1490 specification has been seen; the linkage explicitly
1491 specified in the earlier declaration is not affected by
1492 such a function declaration.
1494 DR 563 raises the question why the restrictions on
1495 functions should not also apply to objects. Older
1496 versions of G++ silently ignore the linkage-specification
1504 which is clearly wrong. Therefore, we now treat objects
1506 if (current_lang_depth () == 0)
1508 /* There is no explicit linkage-specification, so we use
1509 the linkage from the previous declaration. */
1510 if (!DECL_LANG_SPECIFIC (newdecl))
1511 retrofit_lang_decl (newdecl);
1512 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1516 error ("previous declaration of %q+#D with %qL linkage",
1517 olddecl, DECL_LANGUAGE (olddecl));
1518 error ("conflicts with new declaration with %qL linkage",
1519 DECL_LANGUAGE (newdecl));
1523 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
1525 else if (TREE_CODE (olddecl) == FUNCTION_DECL)
1527 tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1528 tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1531 if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
1532 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
1534 for (; t1 && t1 != void_list_node;
1535 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
1536 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
1538 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
1541 permerror (input_location, "default argument given for parameter %d of %q#D",
1543 permerror (input_location, "after previous specification in %q+#D", olddecl);
1547 error ("default argument given for parameter %d of %q#D",
1549 error ("after previous specification in %q+#D",
1556 /* Do not merge an implicit typedef with an explicit one. In:
1560 typedef class A A __attribute__ ((foo));
1562 the attribute should apply only to the typedef. */
1563 if (TREE_CODE (olddecl) == TYPE_DECL
1564 && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
1565 || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
1568 /* If new decl is `static' and an `extern' was seen previously,
1570 warn_extern_redeclared_static (newdecl, olddecl);
1572 /* We have committed to returning 1 at this point. */
1573 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1575 /* Now that functions must hold information normally held
1576 by field decls, there is extra work to do so that
1577 declaration information does not get destroyed during
1579 if (DECL_VINDEX (olddecl))
1580 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
1581 if (DECL_CONTEXT (olddecl))
1582 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1583 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
1584 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1585 DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
1586 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
1587 DECL_INVALID_OVERRIDER_P (newdecl) |= DECL_INVALID_OVERRIDER_P (olddecl);
1588 DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
1589 if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
1590 SET_OVERLOADED_OPERATOR_CODE
1591 (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
1592 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
1594 /* Optionally warn about more than one declaration for the same
1595 name, but don't warn about a function declaration followed by a
1597 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
1598 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
1599 /* Don't warn about extern decl followed by definition. */
1600 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
1601 /* Don't warn about friends, let add_friend take care of it. */
1602 && ! (newdecl_is_friend || DECL_FRIEND_P (olddecl)))
1604 warning (OPT_Wredundant_decls, "redundant redeclaration of %qD in same scope", newdecl);
1605 warning (OPT_Wredundant_decls, "previous declaration of %q+D", olddecl);
1608 if (DECL_DELETED_FN (newdecl))
1610 error ("deleted definition of %qD", newdecl);
1611 error ("after previous declaration %q+D", olddecl);
1615 /* Deal with C++: must preserve virtual function table size. */
1616 if (TREE_CODE (olddecl) == TYPE_DECL)
1618 tree newtype = TREE_TYPE (newdecl);
1619 tree oldtype = TREE_TYPE (olddecl);
1621 if (newtype != error_mark_node && oldtype != error_mark_node
1622 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
1623 CLASSTYPE_FRIEND_CLASSES (newtype)
1624 = CLASSTYPE_FRIEND_CLASSES (oldtype);
1626 DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
1629 /* Copy all the DECL_... slots specified in the new decl
1630 except for any that we copy here from the old type. */
1631 DECL_ATTRIBUTES (newdecl)
1632 = (*targetm.merge_decl_attributes) (olddecl, newdecl);
1634 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1638 old_result = DECL_TEMPLATE_RESULT (olddecl);
1639 new_result = DECL_TEMPLATE_RESULT (newdecl);
1640 TREE_TYPE (olddecl) = TREE_TYPE (old_result);
1641 DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
1642 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
1643 DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
1645 DECL_ATTRIBUTES (old_result)
1646 = (*targetm.merge_decl_attributes) (old_result, new_result);
1648 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1650 if (GNU_INLINE_P (old_result) != GNU_INLINE_P (new_result)
1651 && DECL_INITIAL (new_result))
1653 if (DECL_INITIAL (old_result))
1654 DECL_UNINLINABLE (old_result) = 1;
1656 DECL_UNINLINABLE (old_result) = DECL_UNINLINABLE (new_result);
1657 DECL_EXTERNAL (old_result) = DECL_EXTERNAL (new_result);
1658 DECL_NOT_REALLY_EXTERN (old_result)
1659 = DECL_NOT_REALLY_EXTERN (new_result);
1660 DECL_INTERFACE_KNOWN (old_result)
1661 = DECL_INTERFACE_KNOWN (new_result);
1662 DECL_DECLARED_INLINE_P (old_result)
1663 = DECL_DECLARED_INLINE_P (new_result);
1664 DECL_DISREGARD_INLINE_LIMITS (old_result)
1665 |= DECL_DISREGARD_INLINE_LIMITS (new_result);
1670 DECL_DECLARED_INLINE_P (old_result)
1671 |= DECL_DECLARED_INLINE_P (new_result);
1672 DECL_DISREGARD_INLINE_LIMITS (old_result)
1673 |= DECL_DISREGARD_INLINE_LIMITS (new_result);
1674 check_redeclaration_exception_specification (newdecl, olddecl);
1678 /* If the new declaration is a definition, update the file and
1679 line information on the declaration, and also make
1680 the old declaration the same definition. */
1681 if (DECL_INITIAL (new_result) != NULL_TREE)
1683 DECL_SOURCE_LOCATION (olddecl)
1684 = DECL_SOURCE_LOCATION (old_result)
1685 = DECL_SOURCE_LOCATION (newdecl);
1686 DECL_INITIAL (old_result) = DECL_INITIAL (new_result);
1687 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1690 DECL_ARGUMENTS (old_result)
1691 = DECL_ARGUMENTS (new_result);
1692 for (parm = DECL_ARGUMENTS (old_result); parm;
1693 parm = TREE_CHAIN (parm))
1694 DECL_CONTEXT (parm) = old_result;
1703 /* Automatically handles default parameters. */
1704 tree oldtype = TREE_TYPE (olddecl);
1707 /* Merge the data types specified in the two decls. */
1708 newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1710 /* If merge_types produces a non-typedef type, just use the old type. */
1711 if (TREE_CODE (newdecl) == TYPE_DECL
1712 && newtype == DECL_ORIGINAL_TYPE (newdecl))
1715 if (TREE_CODE (newdecl) == VAR_DECL)
1717 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
1718 DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
1719 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl)
1720 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl);
1721 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl)
1722 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl);
1724 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
1725 if (DECL_LANG_SPECIFIC (olddecl)
1726 && CP_DECL_THREADPRIVATE_P (olddecl))
1728 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
1729 if (!DECL_LANG_SPECIFIC (newdecl))
1730 retrofit_lang_decl (newdecl);
1732 DECL_TLS_MODEL (newdecl) = DECL_TLS_MODEL (olddecl);
1733 CP_DECL_THREADPRIVATE_P (newdecl) = 1;
1737 /* Do this after calling `merge_types' so that default
1738 parameters don't confuse us. */
1739 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1740 check_redeclaration_exception_specification (newdecl, olddecl);
1741 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
1743 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1744 check_default_args (newdecl);
1746 /* Lay the type out, unless already done. */
1747 if (! same_type_p (newtype, oldtype)
1748 && TREE_TYPE (newdecl) != error_mark_node
1749 && !(processing_template_decl && uses_template_parms (newdecl)))
1750 layout_type (TREE_TYPE (newdecl));
1752 if ((TREE_CODE (newdecl) == VAR_DECL
1753 || TREE_CODE (newdecl) == PARM_DECL
1754 || TREE_CODE (newdecl) == RESULT_DECL
1755 || TREE_CODE (newdecl) == FIELD_DECL
1756 || TREE_CODE (newdecl) == TYPE_DECL)
1757 && !(processing_template_decl && uses_template_parms (newdecl)))
1758 layout_decl (newdecl, 0);
1760 /* Merge the type qualifiers. */
1761 if (TREE_READONLY (newdecl))
1762 TREE_READONLY (olddecl) = 1;
1763 if (TREE_THIS_VOLATILE (newdecl))
1764 TREE_THIS_VOLATILE (olddecl) = 1;
1765 if (TREE_NOTHROW (newdecl))
1766 TREE_NOTHROW (olddecl) = 1;
1768 /* Merge deprecatedness. */
1769 if (TREE_DEPRECATED (newdecl))
1770 TREE_DEPRECATED (olddecl) = 1;
1772 /* Preserve function specific target and optimization options */
1773 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1775 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl)
1776 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl))
1777 DECL_FUNCTION_SPECIFIC_TARGET (newdecl)
1778 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl);
1780 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl)
1781 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl))
1782 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl)
1783 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl);
1786 /* Merge the initialization information. */
1787 if (DECL_INITIAL (newdecl) == NULL_TREE
1788 && DECL_INITIAL (olddecl) != NULL_TREE)
1790 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1791 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
1792 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
1793 && DECL_LANG_SPECIFIC (newdecl)
1794 && DECL_LANG_SPECIFIC (olddecl))
1796 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1797 DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
1801 /* Merge the section attribute.
1802 We want to issue an error if the sections conflict but that must be
1803 done later in decl_attributes since we are called before attributes
1805 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1806 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1808 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1810 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1811 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1812 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1813 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1814 TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl);
1815 DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
1816 DECL_IS_OPERATOR_NEW (newdecl) |= DECL_IS_OPERATOR_NEW (olddecl);
1817 DECL_PURE_P (newdecl) |= DECL_PURE_P (olddecl);
1818 TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
1819 DECL_LOOPING_CONST_OR_PURE_P (newdecl)
1820 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl);
1821 /* Keep the old RTL. */
1822 COPY_DECL_RTL (olddecl, newdecl);
1824 else if (TREE_CODE (newdecl) == VAR_DECL
1825 && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
1827 /* Keep the old RTL. We cannot keep the old RTL if the old
1828 declaration was for an incomplete object and the new
1829 declaration is not since many attributes of the RTL will
1831 COPY_DECL_RTL (olddecl, newdecl);
1834 /* If cannot merge, then use the new type and qualifiers,
1835 and don't preserve the old rtl. */
1838 /* Clean out any memory we had of the old declaration. */
1839 tree oldstatic = value_member (olddecl, static_aggregates);
1841 TREE_VALUE (oldstatic) = error_mark_node;
1843 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1844 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1845 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1846 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1849 /* Merge the storage class information. */
1850 merge_weak (newdecl, olddecl);
1852 DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
1853 DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
1854 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1855 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
1856 if (! DECL_EXTERNAL (olddecl))
1857 DECL_EXTERNAL (newdecl) = 0;
1859 new_template = NULL_TREE;
1860 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
1862 bool new_redefines_gnu_inline = false;
1864 if (new_defines_function
1865 && ((DECL_INTERFACE_KNOWN (olddecl)
1866 && TREE_CODE (olddecl) == FUNCTION_DECL)
1867 || (TREE_CODE (olddecl) == TEMPLATE_DECL
1868 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
1869 == FUNCTION_DECL))))
1873 if (TREE_CODE (fn) == TEMPLATE_DECL)
1874 fn = DECL_TEMPLATE_RESULT (olddecl);
1876 new_redefines_gnu_inline = GNU_INLINE_P (fn) && DECL_INITIAL (fn);
1879 if (!new_redefines_gnu_inline)
1881 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
1882 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
1883 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
1885 DECL_TEMPLATE_INSTANTIATED (newdecl)
1886 |= DECL_TEMPLATE_INSTANTIATED (olddecl);
1888 /* If the OLDDECL is an instantiation and/or specialization,
1889 then the NEWDECL must be too. But, it may not yet be marked
1890 as such if the caller has created NEWDECL, but has not yet
1891 figured out that it is a redeclaration. */
1892 if (!DECL_USE_TEMPLATE (newdecl))
1893 DECL_USE_TEMPLATE (newdecl) = DECL_USE_TEMPLATE (olddecl);
1895 /* Don't really know how much of the language-specific
1896 values we should copy from old to new. */
1897 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
1898 DECL_LANG_SPECIFIC (newdecl)->decl_flags.u2 =
1899 DECL_LANG_SPECIFIC (olddecl)->decl_flags.u2;
1900 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
1901 DECL_REPO_AVAILABLE_P (newdecl) = DECL_REPO_AVAILABLE_P (olddecl);
1902 if (DECL_TEMPLATE_INFO (newdecl))
1903 new_template = DECL_TI_TEMPLATE (newdecl);
1904 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
1905 DECL_INITIALIZED_IN_CLASS_P (newdecl)
1906 |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
1907 olddecl_friend = DECL_FRIEND_P (olddecl);
1908 hidden_friend = (DECL_ANTICIPATED (olddecl)
1909 && DECL_HIDDEN_FRIEND_P (olddecl)
1910 && newdecl_is_friend);
1912 /* Only functions have DECL_BEFRIENDING_CLASSES. */
1913 if (TREE_CODE (newdecl) == FUNCTION_DECL
1914 || DECL_FUNCTION_TEMPLATE_P (newdecl))
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 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
1931 && !DECL_TEMPLATE_INSTANTIATION (newdecl))
1933 /* If newdecl is not a specialization, then it is not a
1934 template-related function at all. And that means that we
1935 should have exited above, returning 0. */
1936 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl));
1938 if (TREE_USED (olddecl))
1939 /* From [temp.expl.spec]:
1941 If a template, a member template or the member of a class
1942 template is explicitly specialized then that
1943 specialization shall be declared before the first use of
1944 that specialization that would cause an implicit
1945 instantiation to take place, in every translation unit in
1946 which such a use occurs. */
1947 error ("explicit specialization of %qD after first use",
1950 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
1952 /* Don't propagate visibility from the template to the
1953 specialization here. We'll do that in determine_visibility if
1955 DECL_VISIBILITY_SPECIFIED (olddecl) = 0;
1957 /* [temp.expl.spec/14] We don't inline explicit specialization
1958 just because the primary template says so. */
1960 else if (new_defines_function && DECL_INITIAL (olddecl))
1962 /* Never inline re-defined extern inline functions.
1963 FIXME: this could be better handled by keeping both
1964 function as separate declarations. */
1965 DECL_UNINLINABLE (newdecl) = 1;
1969 if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
1970 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
1972 DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
1974 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
1975 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
1977 DECL_DISREGARD_INLINE_LIMITS (newdecl)
1978 = DECL_DISREGARD_INLINE_LIMITS (olddecl)
1979 = (DECL_DISREGARD_INLINE_LIMITS (newdecl)
1980 || DECL_DISREGARD_INLINE_LIMITS (olddecl));
1983 /* Preserve abstractness on cloned [cd]tors. */
1984 DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
1986 /* Update newdecl's parms to point at olddecl. */
1987 for (parm = DECL_ARGUMENTS (newdecl); parm;
1988 parm = TREE_CHAIN (parm))
1989 DECL_CONTEXT (parm) = olddecl;
1993 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1994 COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
1995 COPY_DECL_RTL (newdecl, olddecl);
1997 if (! types_match || new_defines_function)
1999 /* These need to be copied so that the names are available.
2000 Note that if the types do match, we'll preserve inline
2001 info and other bits, but if not, we won't. */
2002 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
2003 DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
2005 if (new_defines_function)
2006 /* If defining a function declared with other language
2007 linkage, use the previously declared language linkage. */
2008 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
2009 else if (types_match)
2011 /* If redeclaring a builtin function, and not a definition,
2012 it stays built in. */
2013 if (DECL_BUILT_IN (olddecl))
2015 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
2016 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
2017 /* If we're keeping the built-in definition, keep the rtl,
2018 regardless of declaration matches. */
2019 COPY_DECL_RTL (olddecl, newdecl);
2022 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
2023 /* Don't clear out the arguments if we're just redeclaring a
2025 if (DECL_ARGUMENTS (olddecl))
2026 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
2029 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
2030 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
2032 /* Now preserve various other info from the definition. */
2033 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
2034 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
2035 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
2036 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
2038 /* Warn about conflicting visibility specifications. */
2039 if (DECL_VISIBILITY_SPECIFIED (olddecl)
2040 && DECL_VISIBILITY_SPECIFIED (newdecl)
2041 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
2043 warning (OPT_Wattributes, "%q+D: visibility attribute ignored "
2044 "because it", newdecl);
2045 warning (OPT_Wattributes, "%Jconflicts with previous "
2046 "declaration here", olddecl);
2048 /* Choose the declaration which specified visibility. */
2049 if (DECL_VISIBILITY_SPECIFIED (olddecl))
2051 DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
2052 DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
2054 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2055 so keep this behavior. */
2056 if (TREE_CODE (newdecl) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (newdecl))
2058 SET_DECL_INIT_PRIORITY (olddecl, DECL_INIT_PRIORITY (newdecl));
2059 DECL_HAS_INIT_PRIORITY_P (olddecl) = 1;
2062 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2063 with that from NEWDECL below. */
2064 if (DECL_LANG_SPECIFIC (olddecl))
2066 gcc_assert (DECL_LANG_SPECIFIC (olddecl)
2067 != DECL_LANG_SPECIFIC (newdecl));
2068 ggc_free (DECL_LANG_SPECIFIC (olddecl));
2071 /* Merge the USED information. */
2072 if (TREE_USED (olddecl))
2073 TREE_USED (newdecl) = 1;
2074 else if (TREE_USED (newdecl))
2075 TREE_USED (olddecl) = 1;
2077 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2081 function_size = sizeof (struct tree_decl_common);
2083 memcpy ((char *) olddecl + sizeof (struct tree_common),
2084 (char *) newdecl + sizeof (struct tree_common),
2085 function_size - sizeof (struct tree_common));
2087 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2088 (char *) newdecl + sizeof (struct tree_decl_common),
2089 sizeof (struct tree_function_decl) - sizeof (struct tree_decl_common));
2091 /* If newdecl is a template instantiation, it is possible that
2092 the following sequence of events has occurred:
2094 o A friend function was declared in a class template. The
2095 class template was instantiated.
2097 o The instantiation of the friend declaration was
2098 recorded on the instantiation list, and is newdecl.
2100 o Later, however, instantiate_class_template called pushdecl
2101 on the newdecl to perform name injection. But, pushdecl in
2102 turn called duplicate_decls when it discovered that another
2103 declaration of a global function with the same name already
2106 o Here, in duplicate_decls, we decided to clobber newdecl.
2108 If we're going to do that, we'd better make sure that
2109 olddecl, and not newdecl, is on the list of
2110 instantiations so that if we try to do the instantiation
2111 again we won't get the clobbered declaration. */
2112 reregister_specialization (newdecl,
2118 size_t size = tree_code_size (TREE_CODE (olddecl));
2119 memcpy ((char *) olddecl + sizeof (struct tree_common),
2120 (char *) newdecl + sizeof (struct tree_common),
2121 sizeof (struct tree_decl_common) - sizeof (struct tree_common));
2122 switch (TREE_CODE (olddecl))
2132 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2133 (char *) newdecl + sizeof (struct tree_decl_common),
2134 size - sizeof (struct tree_decl_common)
2135 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2139 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2140 (char *) newdecl + sizeof (struct tree_decl_common),
2141 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common)
2142 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2146 DECL_UID (olddecl) = olddecl_uid;
2148 DECL_FRIEND_P (olddecl) = 1;
2151 DECL_ANTICIPATED (olddecl) = 1;
2152 DECL_HIDDEN_FRIEND_P (olddecl) = 1;
2155 /* NEWDECL contains the merged attribute lists.
2156 Update OLDDECL to be the same. */
2157 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
2159 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2160 so that encode_section_info has a chance to look at the new decl
2161 flags and attributes. */
2162 if (DECL_RTL_SET_P (olddecl)
2163 && (TREE_CODE (olddecl) == FUNCTION_DECL
2164 || (TREE_CODE (olddecl) == VAR_DECL
2165 && TREE_STATIC (olddecl))))
2166 make_decl_rtl (olddecl);
2168 /* The NEWDECL will no longer be needed. Because every out-of-class
2169 declaration of a member results in a call to duplicate_decls,
2170 freeing these nodes represents in a significant savings. */
2176 /* Return zero if the declaration NEWDECL is valid
2177 when the declaration OLDDECL (assumed to be for the same name)
2178 has already been seen.
2179 Otherwise return an error message format string with a %s
2180 where the identifier should go. */
2183 redeclaration_error_message (tree newdecl, tree olddecl)
2185 if (TREE_CODE (newdecl) == TYPE_DECL)
2187 /* Because C++ can put things into name space for free,
2188 constructs like "typedef struct foo { ... } foo"
2189 would look like an erroneous redeclaration. */
2190 if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
2193 return "redefinition of %q#D";
2195 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
2197 /* If this is a pure function, its olddecl will actually be
2198 the original initialization to `0' (which we force to call
2199 abort()). Don't complain about redefinition in this case. */
2200 if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl)
2201 && DECL_INITIAL (olddecl) == NULL_TREE)
2204 /* If both functions come from different namespaces, this is not
2205 a redeclaration - this is a conflict with a used function. */
2206 if (DECL_NAMESPACE_SCOPE_P (olddecl)
2207 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl)
2208 && ! decls_match (olddecl, newdecl))
2209 return "%qD conflicts with used function";
2211 /* We'll complain about linkage mismatches in
2212 warn_extern_redeclared_static. */
2214 /* Defining the same name twice is no good. */
2215 if (DECL_INITIAL (olddecl) != NULL_TREE
2216 && DECL_INITIAL (newdecl) != NULL_TREE)
2218 if (DECL_NAME (olddecl) == NULL_TREE)
2219 return "%q#D not declared in class";
2220 else if (!GNU_INLINE_P (olddecl)
2221 || GNU_INLINE_P (newdecl))
2222 return "redefinition of %q#D";
2225 if (DECL_DECLARED_INLINE_P (olddecl) && DECL_DECLARED_INLINE_P (newdecl))
2227 bool olda = GNU_INLINE_P (olddecl);
2228 bool newa = GNU_INLINE_P (newdecl);
2233 return "%q+D redeclared inline with %<gnu_inline%> attribute";
2235 return "%q+D redeclared inline without %<gnu_inline%> attribute";
2241 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2245 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2247 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl))
2248 && COMPLETE_TYPE_P (TREE_TYPE (olddecl)))
2249 return "redefinition of %q#D";
2253 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL
2254 || (DECL_TEMPLATE_RESULT (newdecl)
2255 == DECL_TEMPLATE_RESULT (olddecl)))
2258 nt = DECL_TEMPLATE_RESULT (newdecl);
2259 if (DECL_TEMPLATE_INFO (nt))
2260 nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt));
2261 ot = DECL_TEMPLATE_RESULT (olddecl);
2262 if (DECL_TEMPLATE_INFO (ot))
2263 ot = DECL_TEMPLATE_RESULT (template_for_substitution (ot));
2264 if (DECL_INITIAL (nt) && DECL_INITIAL (ot)
2265 && (!GNU_INLINE_P (ot) || GNU_INLINE_P (nt)))
2266 return "redefinition of %q#D";
2268 if (DECL_DECLARED_INLINE_P (ot) && DECL_DECLARED_INLINE_P (nt))
2270 bool olda = GNU_INLINE_P (ot);
2271 bool newa = GNU_INLINE_P (nt);
2276 return "%q+D redeclared inline with %<gnu_inline%> attribute";
2278 return "%q+D redeclared inline without %<gnu_inline%> attribute";
2282 /* Core issue #226 (C++0x):
2284 If a friend function template declaration specifies a
2285 default template-argument, that declaration shall be a
2286 definition and shall be the only declaration of the
2287 function template in the translation unit. */
2288 if ((cxx_dialect != cxx98)
2289 && TREE_CODE (ot) == FUNCTION_DECL && DECL_FRIEND_P (ot)
2290 && !check_default_tmpl_args (nt, DECL_TEMPLATE_PARMS (newdecl),
2291 /*is_primary=*/1, /*is_partial=*/0,
2292 /*is_friend_decl=*/2))
2293 return "redeclaration of friend %q#D may not have default template arguments";
2297 else if (TREE_CODE (newdecl) == VAR_DECL
2298 && DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl)
2299 && (! DECL_LANG_SPECIFIC (olddecl)
2300 || ! CP_DECL_THREADPRIVATE_P (olddecl)
2301 || DECL_THREAD_LOCAL_P (newdecl)))
2303 /* Only variables can be thread-local, and all declarations must
2304 agree on this property. */
2305 if (DECL_THREAD_LOCAL_P (newdecl))
2306 return "thread-local declaration of %q#D follows "
2307 "non-thread-local declaration";
2309 return "non-thread-local declaration of %q#D follows "
2310 "thread-local declaration";
2312 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
2314 /* The objects have been declared at namespace scope. If either
2315 is a member of an anonymous union, then this is an invalid
2316 redeclaration. For example:
2322 if ((TREE_CODE (newdecl) == VAR_DECL && DECL_ANON_UNION_VAR_P (newdecl))
2323 || (TREE_CODE (olddecl) == VAR_DECL && DECL_ANON_UNION_VAR_P (olddecl)))
2324 return "redeclaration of %q#D";
2325 /* If at least one declaration is a reference, there is no
2326 conflict. For example:
2332 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2334 /* Reject two definitions. */
2335 return "redefinition of %q#D";
2339 /* Objects declared with block scope: */
2340 /* Reject two definitions, and reject a definition
2341 together with an external reference. */
2342 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
2343 return "redeclaration of %q#D";
2348 /* Hash and equality functions for the named_label table. */
2351 named_label_entry_hash (const void *data)
2353 const struct named_label_entry *ent = (const struct named_label_entry *) data;
2354 return DECL_UID (ent->label_decl);
2358 named_label_entry_eq (const void *a, const void *b)
2360 const struct named_label_entry *ent_a = (const struct named_label_entry *) a;
2361 const struct named_label_entry *ent_b = (const struct named_label_entry *) b;
2362 return ent_a->label_decl == ent_b->label_decl;
2365 /* Create a new label, named ID. */
2368 make_label_decl (tree id, int local_p)
2370 struct named_label_entry *ent;
2374 decl = build_decl (LABEL_DECL, id, void_type_node);
2376 DECL_CONTEXT (decl) = current_function_decl;
2377 DECL_MODE (decl) = VOIDmode;
2378 C_DECLARED_LABEL_FLAG (decl) = local_p;
2380 /* Say where one reference is to the label, for the sake of the
2381 error if it is not defined. */
2382 DECL_SOURCE_LOCATION (decl) = input_location;
2384 /* Record the fact that this identifier is bound to this label. */
2385 SET_IDENTIFIER_LABEL_VALUE (id, decl);
2387 /* Create the label htab for the function on demand. */
2389 named_labels = htab_create_ggc (13, named_label_entry_hash,
2390 named_label_entry_eq, NULL);
2392 /* Record this label on the list of labels used in this function.
2393 We do this before calling make_label_decl so that we get the
2394 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2395 ent = GGC_CNEW (struct named_label_entry);
2396 ent->label_decl = decl;
2398 slot = htab_find_slot (named_labels, ent, INSERT);
2399 gcc_assert (*slot == NULL);
2405 /* Look for a label named ID in the current function. If one cannot
2406 be found, create one. (We keep track of used, but undefined,
2407 labels, and complain about them at the end of a function.) */
2410 lookup_label (tree id)
2414 timevar_push (TV_NAME_LOOKUP);
2415 /* You can't use labels at global scope. */
2416 if (current_function_decl == NULL_TREE)
2418 error ("label %qE referenced outside of any function", id);
2419 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2422 /* See if we've already got this label. */
2423 decl = IDENTIFIER_LABEL_VALUE (id);
2424 if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
2425 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2427 decl = make_label_decl (id, /*local_p=*/0);
2428 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2431 /* Declare a local label named ID. */
2434 declare_local_label (tree id)
2438 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2439 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2440 shadow = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
2441 current_binding_level->shadowed_labels);
2442 current_binding_level->shadowed_labels = shadow;
2444 decl = make_label_decl (id, /*local_p=*/1);
2445 TREE_VALUE (shadow) = decl;
2450 /* Returns nonzero if it is ill-formed to jump past the declaration of
2451 DECL. Returns 2 if it's also a real problem. */
2454 decl_jump_unsafe (tree decl)
2456 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl)
2457 || TREE_TYPE (decl) == error_mark_node)
2460 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
2461 || DECL_NONTRIVIALLY_INITIALIZED_P (decl))
2464 if (pod_type_p (TREE_TYPE (decl)))
2467 /* The POD stuff is just pedantry; why should it matter if the class
2468 contains a field of pointer to member type? */
2472 /* A subroutine of check_previous_goto_1 to identify a branch to the user. */
2475 identify_goto (tree decl, const location_t *locus)
2478 permerror (input_location, "jump to label %qD", decl);
2480 permerror (input_location, "jump to case label");
2482 permerror (input_location, "%H from here", locus);
2485 /* Check that a single previously seen jump to a newly defined label
2486 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2487 the jump context; NAMES are the names in scope in LEVEL at the jump
2488 context; LOCUS is the source position of the jump or 0. Returns
2489 true if all is well. */
2492 check_previous_goto_1 (tree decl, struct cp_binding_level* level, tree names,
2493 bool exited_omp, const location_t *locus)
2495 struct cp_binding_level *b;
2496 bool identified = false, saw_eh = false, saw_omp = false;
2500 identify_goto (decl, locus);
2501 error (" exits OpenMP structured block");
2502 identified = saw_omp = true;
2505 for (b = current_binding_level; b ; b = b->level_chain)
2507 tree new_decls, old_decls = (b == level ? names : NULL_TREE);
2509 for (new_decls = b->names; new_decls != old_decls;
2510 new_decls = TREE_CHAIN (new_decls))
2512 int problem = decl_jump_unsafe (new_decls);
2518 identify_goto (decl, locus);
2522 error (" crosses initialization of %q+#D", new_decls);
2524 permerror (input_location, " enters scope of non-POD %q+#D", new_decls);
2529 if ((b->kind == sk_try || b->kind == sk_catch) && !saw_eh)
2533 identify_goto (decl, locus);
2536 if (b->kind == sk_try)
2537 error (" enters try block");
2539 error (" enters catch block");
2542 if (b->kind == sk_omp && !saw_omp)
2546 identify_goto (decl, locus);
2549 error (" enters OpenMP structured block");
2558 check_previous_goto (tree decl, struct named_label_use_entry *use)
2560 check_previous_goto_1 (decl, use->binding_level,
2561 use->names_in_scope, use->in_omp_scope,
2562 &use->o_goto_locus);
2566 check_switch_goto (struct cp_binding_level* level)
2568 return check_previous_goto_1 (NULL_TREE, level, level->names, false, NULL);
2571 /* Check that a new jump to a label DECL is OK. Called by
2572 finish_goto_stmt. */
2575 check_goto (tree decl)
2577 struct named_label_entry *ent, dummy;
2578 bool saw_catch = false, identified = false;
2581 /* We can't know where a computed goto is jumping.
2582 So we assume that it's OK. */
2583 if (TREE_CODE (decl) != LABEL_DECL)
2586 /* We didn't record any information about this label when we created it,
2587 and there's not much point since it's trivial to analyze as a return. */
2588 if (decl == cdtor_label)
2591 dummy.label_decl = decl;
2592 ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2593 gcc_assert (ent != NULL);
2595 /* If the label hasn't been defined yet, defer checking. */
2596 if (! DECL_INITIAL (decl))
2598 struct named_label_use_entry *new_use;
2600 /* Don't bother creating another use if the last goto had the
2601 same data, and will therefore create the same set of errors. */
2603 && ent->uses->names_in_scope == current_binding_level->names)
2606 new_use = GGC_NEW (struct named_label_use_entry);
2607 new_use->binding_level = current_binding_level;
2608 new_use->names_in_scope = current_binding_level->names;
2609 new_use->o_goto_locus = input_location;
2610 new_use->in_omp_scope = false;
2612 new_use->next = ent->uses;
2613 ent->uses = new_use;
2617 if (ent->in_try_scope || ent->in_catch_scope
2618 || ent->in_omp_scope || ent->bad_decls)
2620 permerror (input_location, "jump to label %q+D", decl);
2621 permerror (input_location, " from here");
2625 for (bad = ent->bad_decls; bad; bad = TREE_CHAIN (bad))
2627 tree b = TREE_VALUE (bad);
2628 int u = decl_jump_unsafe (b);
2630 if (u > 1 && DECL_ARTIFICIAL (b))
2632 /* Can't skip init of __exception_info. */
2633 error ("%J enters catch block", b);
2637 error (" skips initialization of %q+#D", b);
2639 permerror (input_location, " enters scope of non-POD %q+#D", b);
2642 if (ent->in_try_scope)
2643 error (" enters try block");
2644 else if (ent->in_catch_scope && !saw_catch)
2645 error (" enters catch block");
2647 if (ent->in_omp_scope)
2648 error (" enters OpenMP structured block");
2649 else if (flag_openmp)
2651 struct cp_binding_level *b;
2652 for (b = current_binding_level; b ; b = b->level_chain)
2654 if (b == ent->binding_level)
2656 if (b->kind == sk_omp)
2660 permerror (input_location, "jump to label %q+D", decl);
2661 permerror (input_location, " from here");
2664 error (" exits OpenMP structured block");
2671 /* Check that a return is ok wrt OpenMP structured blocks.
2672 Called by finish_return_stmt. Returns true if all is well. */
2675 check_omp_return (void)
2677 struct cp_binding_level *b;
2678 for (b = current_binding_level; b ; b = b->level_chain)
2679 if (b->kind == sk_omp)
2681 error ("invalid exit from OpenMP structured block");
2687 /* Define a label, specifying the location in the source file.
2688 Return the LABEL_DECL node for the label. */
2691 define_label (location_t location, tree name)
2693 struct named_label_entry *ent, dummy;
2694 struct cp_binding_level *p;
2697 timevar_push (TV_NAME_LOOKUP);
2699 decl = lookup_label (name);
2701 dummy.label_decl = decl;
2702 ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2703 gcc_assert (ent != NULL);
2705 /* After labels, make any new cleanups in the function go into their
2706 own new (temporary) binding contour. */
2707 for (p = current_binding_level;
2708 p->kind != sk_function_parms;
2710 p->more_cleanups_ok = 0;
2712 if (name == get_identifier ("wchar_t"))
2713 permerror (input_location, "label named wchar_t");
2715 if (DECL_INITIAL (decl) != NULL_TREE)
2717 error ("duplicate label %qD", decl);
2718 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
2722 struct named_label_use_entry *use;
2724 /* Mark label as having been defined. */
2725 DECL_INITIAL (decl) = error_mark_node;
2726 /* Say where in the source. */
2727 DECL_SOURCE_LOCATION (decl) = location;
2729 ent->binding_level = current_binding_level;
2730 ent->names_in_scope = current_binding_level->names;
2732 for (use = ent->uses; use ; use = use->next)
2733 check_previous_goto (decl, use);
2737 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2742 struct cp_binding_level *level;
2743 struct cp_switch *next;
2744 /* The SWITCH_STMT being built. */
2746 /* A splay-tree mapping the low element of a case range to the high
2747 element, or NULL_TREE if there is no high element. Used to
2748 determine whether or not a new case label duplicates an old case
2749 label. We need a tree, rather than simply a hash table, because
2750 of the GNU case range extension. */
2754 /* A stack of the currently active switch statements. The innermost
2755 switch statement is on the top of the stack. There is no need to
2756 mark the stack for garbage collection because it is only active
2757 during the processing of the body of a function, and we never
2758 collect at that point. */
2760 static struct cp_switch *switch_stack;
2762 /* Called right after a switch-statement condition is parsed.
2763 SWITCH_STMT is the switch statement being parsed. */
2766 push_switch (tree switch_stmt)
2768 struct cp_switch *p = XNEW (struct cp_switch);
2769 p->level = current_binding_level;
2770 p->next = switch_stack;
2771 p->switch_stmt = switch_stmt;
2772 p->cases = splay_tree_new (case_compare, NULL, NULL);
2779 struct cp_switch *cs = switch_stack;
2780 location_t switch_location;
2782 /* Emit warnings as needed. */
2783 if (EXPR_HAS_LOCATION (cs->switch_stmt))
2784 switch_location = EXPR_LOCATION (cs->switch_stmt);
2786 switch_location = input_location;
2787 if (!processing_template_decl)
2788 c_do_switch_warnings (cs->cases, switch_location,
2789 SWITCH_STMT_TYPE (cs->switch_stmt),
2790 SWITCH_STMT_COND (cs->switch_stmt));
2792 splay_tree_delete (cs->cases);
2793 switch_stack = switch_stack->next;
2797 /* Note that we've seen a definition of a case label, and complain if this
2798 is a bad place for one. */
2801 finish_case_label (tree low_value, tree high_value)
2804 struct cp_binding_level *p;
2806 if (processing_template_decl)
2810 /* For templates, just add the case label; we'll do semantic
2811 analysis at instantiation-time. */
2812 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
2813 return add_stmt (build_case_label (low_value, high_value, label));
2816 /* Find the condition on which this switch statement depends. */
2817 cond = SWITCH_STMT_COND (switch_stack->switch_stmt);
2818 if (cond && TREE_CODE (cond) == TREE_LIST)
2819 cond = TREE_VALUE (cond);
2821 if (!check_switch_goto (switch_stack->level))
2822 return error_mark_node;
2824 r = c_add_case_label (switch_stack->cases, cond,
2825 SWITCH_STMT_TYPE (switch_stack->switch_stmt),
2826 low_value, high_value);
2828 /* After labels, make any new cleanups in the function go into their
2829 own new (temporary) binding contour. */
2830 for (p = current_binding_level;
2831 p->kind != sk_function_parms;
2833 p->more_cleanups_ok = 0;
2838 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
2841 typename_hash (const void* k)
2844 const_tree const t = (const_tree) k;
2846 hash = (htab_hash_pointer (TYPE_CONTEXT (t))
2847 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));
2852 typedef struct typename_info {
2860 /* Compare two TYPENAME_TYPEs. K1 is really of type `tree', K2 is
2861 really of type `typename_info*' */
2864 typename_compare (const void * k1, const void * k2)
2866 const_tree const t1 = (const_tree) k1;
2867 const typename_info *const t2 = (const typename_info *) k2;
2869 return (DECL_NAME (TYPE_NAME (t1)) == t2->name
2870 && TYPE_CONTEXT (t1) == t2->scope
2871 && TYPENAME_TYPE_FULLNAME (t1) == t2->template_id
2872 && TYPENAME_IS_ENUM_P (t1) == t2->enum_p
2873 && TYPENAME_IS_CLASS_P (t1) == t2->class_p);
2876 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
2877 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
2879 Returns the new TYPENAME_TYPE. */
2881 static GTY ((param_is (union tree_node))) htab_t typename_htab;
2884 build_typename_type (tree context, tree name, tree fullname,
2885 enum tag_types tag_type)
2893 if (typename_htab == NULL)
2894 typename_htab = htab_create_ggc (61, &typename_hash,
2895 &typename_compare, NULL);
2897 ti.scope = FROB_CONTEXT (context);
2899 ti.template_id = fullname;
2900 ti.enum_p = tag_type == enum_type;
2901 ti.class_p = (tag_type == class_type
2902 || tag_type == record_type
2903 || tag_type == union_type);
2904 hash = (htab_hash_pointer (ti.scope)
2905 ^ htab_hash_pointer (ti.name));
2907 /* See if we already have this type. */
2908 e = htab_find_slot_with_hash (typename_htab, &ti, hash, INSERT);
2913 /* Build the TYPENAME_TYPE. */
2914 t = cxx_make_type (TYPENAME_TYPE);
2915 TYPE_CONTEXT (t) = ti.scope;
2916 TYPENAME_TYPE_FULLNAME (t) = ti.template_id;
2917 TYPENAME_IS_ENUM_P (t) = ti.enum_p;
2918 TYPENAME_IS_CLASS_P (t) = ti.class_p;
2920 /* Build the corresponding TYPE_DECL. */
2921 d = build_decl (TYPE_DECL, name, t);
2922 TYPE_NAME (TREE_TYPE (d)) = d;
2923 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2924 DECL_CONTEXT (d) = FROB_CONTEXT (context);
2925 DECL_ARTIFICIAL (d) = 1;
2927 /* Store it in the hash table. */
2930 /* TYPENAME_TYPEs must always be compared structurally, because
2931 they may or may not resolve down to another type depending on
2932 the currently open classes. */
2933 SET_TYPE_STRUCTURAL_EQUALITY (t);
2939 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
2940 provided to name the type. Returns an appropriate type, unless an
2941 error occurs, in which case error_mark_node is returned. If we
2942 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
2943 return that, rather than the _TYPE it corresponds to, in other
2944 cases we look through the type decl. If TF_ERROR is set, complain
2945 about errors, otherwise be quiet. */
2948 make_typename_type (tree context, tree name, enum tag_types tag_type,
2949 tsubst_flags_t complain)
2955 if (name == error_mark_node
2956 || context == NULL_TREE
2957 || context == error_mark_node)
2958 return error_mark_node;
2962 if (!(TYPE_LANG_SPECIFIC (name)
2963 && (CLASSTYPE_IS_TEMPLATE (name)
2964 || CLASSTYPE_USE_TEMPLATE (name))))
2965 name = TYPE_IDENTIFIER (name);
2967 /* Create a TEMPLATE_ID_EXPR for the type. */
2968 name = build_nt (TEMPLATE_ID_EXPR,
2969 CLASSTYPE_TI_TEMPLATE (name),
2970 CLASSTYPE_TI_ARGS (name));
2972 else if (TREE_CODE (name) == TYPE_DECL)
2973 name = DECL_NAME (name);
2977 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
2979 name = TREE_OPERAND (name, 0);
2980 if (TREE_CODE (name) == TEMPLATE_DECL)
2981 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
2982 else if (TREE_CODE (name) == OVERLOAD)
2984 error ("%qD is not a type", name);
2985 return error_mark_node;
2988 if (TREE_CODE (name) == TEMPLATE_DECL)
2990 error ("%qD used without template parameters", name);
2991 return error_mark_node;
2993 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
2994 gcc_assert (TYPE_P (context));
2996 if (!MAYBE_CLASS_TYPE_P (context))
2998 if (complain & tf_error)
2999 error ("%q#T is not a class", context);
3000 return error_mark_node;
3003 /* When the CONTEXT is a dependent type, NAME could refer to a
3004 dependent base class of CONTEXT. But look inside it anyway
3005 if CONTEXT is a currently open scope, in case it refers to a
3006 member of the current instantiation or a non-dependent base;
3007 lookup will stop when we hit a dependent base. */
3008 if (!dependent_scope_p (context))
3009 /* We should only set WANT_TYPE when we're a nested typename type.
3010 Then we can give better diagnostics if we find a non-type. */
3011 t = lookup_field (context, name, 0, /*want_type=*/true);
3015 if (!t && dependent_type_p (context))
3016 return build_typename_type (context, name, fullname, tag_type);
3018 want_template = TREE_CODE (fullname) == TEMPLATE_ID_EXPR;
3022 if (complain & tf_error)
3023 error (want_template ? "no class template named %q#T in %q#T"
3024 : "no type named %q#T in %q#T", name, context);
3025 return error_mark_node;
3028 if (want_template && !DECL_CLASS_TEMPLATE_P (t))
3030 if (complain & tf_error)
3031 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3033 return error_mark_node;
3035 if (!want_template && TREE_CODE (t) != TYPE_DECL)
3037 if (complain & tf_error)
3038 error ("%<typename %T::%D%> names %q#T, which is not a type",
3040 return error_mark_node;
3043 if (complain & tf_error)
3044 perform_or_defer_access_check (TYPE_BINFO (context), t, t);
3047 return lookup_template_class (t, TREE_OPERAND (fullname, 1),
3049 /*entering_scope=*/0,
3050 tf_warning_or_error | tf_user);
3052 if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
3058 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3059 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3060 in which case error_mark_node is returned.
3062 If PARM_LIST is non-NULL, also make sure that the template parameter
3063 list of TEMPLATE_DECL matches.
3065 If COMPLAIN zero, don't complain about any errors that occur. */
3068 make_unbound_class_template (tree context, tree name, tree parm_list,
3069 tsubst_flags_t complain)
3075 name = TYPE_IDENTIFIER (name);
3076 else if (DECL_P (name))
3077 name = DECL_NAME (name);
3078 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
3080 if (!dependent_type_p (context)
3081 || currently_open_class (context))
3083 tree tmpl = NULL_TREE;
3085 if (MAYBE_CLASS_TYPE_P (context))
3086 tmpl = lookup_field (context, name, 0, false);
3088 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
3090 if (complain & tf_error)
3091 error ("no class template named %q#T in %q#T", name, context);
3092 return error_mark_node;
3096 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl), parm_list))
3098 if (complain & tf_error)
3100 error ("template parameters do not match template");
3101 error ("%q+D declared here", tmpl);
3103 return error_mark_node;
3106 if (complain & tf_error)
3107 perform_or_defer_access_check (TYPE_BINFO (context), tmpl, tmpl);
3112 /* Build the UNBOUND_CLASS_TEMPLATE. */
3113 t = cxx_make_type (UNBOUND_CLASS_TEMPLATE);
3114 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
3115 TREE_TYPE (t) = NULL_TREE;
3116 SET_TYPE_STRUCTURAL_EQUALITY (t);
3118 /* Build the corresponding TEMPLATE_DECL. */
3119 d = build_decl (TEMPLATE_DECL, name, t);
3120 TYPE_NAME (TREE_TYPE (d)) = d;
3121 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
3122 DECL_CONTEXT (d) = FROB_CONTEXT (context);
3123 DECL_ARTIFICIAL (d) = 1;
3124 DECL_TEMPLATE_PARMS (d) = parm_list;
3131 /* Push the declarations of builtin types into the namespace.
3132 RID_INDEX is the index of the builtin type in the array
3133 RID_POINTERS. NAME is the name used when looking up the builtin
3134 type. TYPE is the _TYPE node for the builtin type. */
3137 record_builtin_type (enum rid rid_index,
3141 tree rname = NULL_TREE, tname = NULL_TREE;
3142 tree tdecl = NULL_TREE;
3144 if ((int) rid_index < (int) RID_MAX)
3145 rname = ridpointers[(int) rid_index];
3147 tname = get_identifier (name);
3149 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
3150 eliminated. Built-in types should not be looked up name; their
3151 names are keywords that the parser can recognize. However, there
3152 is code in c-common.c that uses identifier_global_value to look
3153 up built-in types by name. */
3156 tdecl = build_decl (TYPE_DECL, tname, type);
3157 DECL_ARTIFICIAL (tdecl) = 1;
3158 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
3164 tdecl = build_decl (TYPE_DECL, rname, type);
3165 DECL_ARTIFICIAL (tdecl) = 1;
3167 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
3170 if (!TYPE_NAME (type))
3171 TYPE_NAME (type) = tdecl;
3174 debug_hooks->type_decl (tdecl, 0);
3177 /* Record one of the standard Java types.
3178 * Declare it as having the given NAME.
3179 * If SIZE > 0, it is the size of one of the integral types;
3180 * otherwise it is the negative of the size of one of the other types. */
3183 record_builtin_java_type (const char* name, int size)
3187 type = build_nonstandard_integer_type (size, 0);
3188 else if (size > -32)
3191 /* "__java_char" or ""__java_boolean". */
3192 type = build_nonstandard_integer_type (-size, 1);
3193 /* Get the signed type cached and attached to the unsigned type,
3194 so it doesn't get garbage-collected at "random" times,
3195 causing potential codegen differences out of different UIDs
3196 and different alias set numbers. */
3197 stype = build_nonstandard_integer_type (-size, 0);
3198 TREE_CHAIN (type) = stype;
3199 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
3202 { /* "__java_float" or ""__java_double". */
3203 type = make_node (REAL_TYPE);
3204 TYPE_PRECISION (type) = - size;
3207 record_builtin_type (RID_MAX, name, type);
3208 decl = TYPE_NAME (type);
3210 /* Suppress generate debug symbol entries for these types,
3211 since for normal C++ they are just clutter.
3212 However, push_lang_context undoes this if extern "Java" is seen. */
3213 DECL_IGNORED_P (decl) = 1;
3215 TYPE_FOR_JAVA (type) = 1;
3219 /* Push a type into the namespace so that the back ends ignore it. */
3222 record_unknown_type (tree type, const char* name)
3224 tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
3225 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3226 DECL_IGNORED_P (decl) = 1;
3227 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
3228 TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
3229 TYPE_ALIGN (type) = 1;
3230 TYPE_USER_ALIGN (type) = 0;
3231 SET_TYPE_MODE (type, TYPE_MODE (void_type_node));
3234 /* A string for which we should create an IDENTIFIER_NODE at
3237 typedef struct predefined_identifier
3239 /* The name of the identifier. */
3240 const char *const name;
3241 /* The place where the IDENTIFIER_NODE should be stored. */
3243 /* Nonzero if this is the name of a constructor or destructor. */
3244 const int ctor_or_dtor_p;
3245 } predefined_identifier;
3247 /* Create all the predefined identifiers. */
3250 initialize_predefined_identifiers (void)
3252 const predefined_identifier *pid;
3254 /* A table of identifiers to create at startup. */
3255 static const predefined_identifier predefined_identifiers[] = {
3256 { "C++", &lang_name_cplusplus, 0 },
3257 { "C", &lang_name_c, 0 },
3258 { "Java", &lang_name_java, 0 },
3259 /* Some of these names have a trailing space so that it is
3260 impossible for them to conflict with names written by users. */
3261 { "__ct ", &ctor_identifier, 1 },
3262 { "__base_ctor ", &base_ctor_identifier, 1 },
3263 { "__comp_ctor ", &complete_ctor_identifier, 1 },
3264 { "__dt ", &dtor_identifier, 1 },
3265 { "__comp_dtor ", &complete_dtor_identifier, 1 },
3266 { "__base_dtor ", &base_dtor_identifier, 1 },
3267 { "__deleting_dtor ", &deleting_dtor_identifier, 1 },
3268 { IN_CHARGE_NAME, &in_charge_identifier, 0 },
3269 { "nelts", &nelts_identifier, 0 },
3270 { THIS_NAME, &this_identifier, 0 },
3271 { VTABLE_DELTA_NAME, &delta_identifier, 0 },
3272 { VTABLE_PFN_NAME, &pfn_identifier, 0 },
3273 { "_vptr", &vptr_identifier, 0 },
3274 { "__vtt_parm", &vtt_parm_identifier, 0 },
3275 { "::", &global_scope_name, 0 },
3276 { "std", &std_identifier, 0 },
3280 for (pid = predefined_identifiers; pid->name; ++pid)
3282 *pid->node = get_identifier (pid->name);
3283 if (pid->ctor_or_dtor_p)
3284 IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
3288 /* Create the predefined scalar types of C,
3289 and some nodes representing standard constants (0, 1, (void *)0).
3290 Initialize the global binding level.
3291 Make definitions for built-in primitive functions. */
3294 cxx_init_decl_processing (void)
3297 tree void_ftype_ptr;
3299 build_common_tree_nodes (flag_signed_char, false);
3301 /* Create all the identifiers we need. */
3302 initialize_predefined_identifiers ();
3304 /* Create the global variables. */
3305 push_to_top_level ();
3307 current_function_decl = NULL_TREE;
3308 current_binding_level = NULL;
3309 /* Enter the global namespace. */
3310 gcc_assert (global_namespace == NULL_TREE);
3311 global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name,
3313 TREE_PUBLIC (global_namespace) = 1;
3314 begin_scope (sk_namespace, global_namespace);
3316 current_lang_name = NULL_TREE;
3318 if (flag_visibility_ms_compat)
3319 default_visibility = VISIBILITY_HIDDEN;
3322 current_lang_name = lang_name_c;
3324 /* Create the `std' namespace. */
3325 push_namespace (std_identifier);
3326 std_node = current_namespace;
3329 c_common_nodes_and_builtins ();
3331 java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
3332 java_short_type_node = record_builtin_java_type ("__java_short", 16);
3333 java_int_type_node = record_builtin_java_type ("__java_int", 32);
3334 java_long_type_node = record_builtin_java_type ("__java_long", 64);
3335 java_float_type_node = record_builtin_java_type ("__java_float", -32);
3336 java_double_type_node = record_builtin_java_type ("__java_double", -64);
3337 java_char_type_node = record_builtin_java_type ("__java_char", -16);
3338 java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
3340 integer_two_node = build_int_cst (NULL_TREE, 2);
3341 integer_three_node = build_int_cst (NULL_TREE, 3);
3343 record_builtin_type (RID_BOOL, "bool", boolean_type_node);
3344 truthvalue_type_node = boolean_type_node;
3345 truthvalue_false_node = boolean_false_node;
3346 truthvalue_true_node = boolean_true_node;
3348 empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
3351 record_builtin_type (RID_MAX, NULL, string_type_node);
3354 delta_type_node = ptrdiff_type_node;
3355 vtable_index_type = ptrdiff_type_node;
3357 vtt_parm_type = build_pointer_type (const_ptr_type_node);
3358 void_ftype = build_function_type (void_type_node, void_list_node);
3359 void_ftype_ptr = build_function_type (void_type_node,
3360 tree_cons (NULL_TREE,
3364 = build_exception_variant (void_ftype_ptr, empty_except_spec);
3366 /* C++ extensions */
3368 unknown_type_node = make_node (UNKNOWN_TYPE);
3369 record_unknown_type (unknown_type_node, "unknown type");
3371 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3372 TREE_TYPE (unknown_type_node) = unknown_type_node;
3374 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3376 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
3377 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
3379 init_list_type_node = make_node (UNKNOWN_TYPE);
3380 record_unknown_type (init_list_type_node, "init list");
3383 /* Make sure we get a unique function type, so we can give
3384 its pointer type a name. (This wins for gdb.) */
3385 tree vfunc_type = make_node (FUNCTION_TYPE);
3386 TREE_TYPE (vfunc_type) = integer_type_node;
3387 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
3388 layout_type (vfunc_type);
3390 vtable_entry_type = build_pointer_type (vfunc_type);
3392 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
3395 = build_cplus_array_type (vtable_entry_type, NULL_TREE);
3396 layout_type (vtbl_type_node);
3397 vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
3398 record_builtin_type (RID_MAX, NULL, vtbl_type_node);
3399 vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
3400 layout_type (vtbl_ptr_type_node);
3401 record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
3403 push_namespace (get_identifier ("__cxxabiv1"));
3404 abi_node = current_namespace;
3407 global_type_node = make_node (LANG_TYPE);
3408 record_unknown_type (global_type_node, "global type");
3411 current_lang_name = lang_name_cplusplus;
3415 tree bad_alloc_type_node;
3416 tree bad_alloc_decl;
3417 tree newtype, deltype;
3418 tree ptr_ftype_sizetype;
3420 push_namespace (std_identifier);
3421 bad_alloc_id = get_identifier ("bad_alloc");
3422 bad_alloc_type_node = make_class_type (RECORD_TYPE);
3423 TYPE_CONTEXT (bad_alloc_type_node) = current_namespace;
3425 = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node);
3426 DECL_CONTEXT (bad_alloc_decl) = current_namespace;
3427 TYPE_STUB_DECL (bad_alloc_type_node) = bad_alloc_decl;
3431 = build_function_type (ptr_type_node,
3432 tree_cons (NULL_TREE,
3435 newtype = build_exception_variant
3436 (ptr_ftype_sizetype, add_exception_specifier
3437 (NULL_TREE, bad_alloc_type_node, -1));
3438 deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
3439 push_cp_library_fn (NEW_EXPR, newtype);
3440 push_cp_library_fn (VEC_NEW_EXPR, newtype);
3441 global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
3442 push_cp_library_fn (VEC_DELETE_EXPR, deltype);
3446 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
3448 /* Perform other language dependent initializations. */
3449 init_class_processing ();
3450 init_rtti_processing ();
3452 if (flag_exceptions)
3453 init_exception_processing ();
3455 if (! supports_one_only ())
3458 make_fname_decl = cp_make_fname_decl;
3459 start_fname_decls ();
3461 /* Show we use EH for cleanups. */
3462 if (flag_exceptions)
3463 using_eh_for_cleanups ();
3466 /* Generate an initializer for a function naming variable from
3467 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3468 filled in with the type of the init. */
3471 cp_fname_init (const char* name, tree *type_p)
3473 tree domain = NULL_TREE;
3475 tree init = NULL_TREE;
3480 length = strlen (name);
3481 domain = build_index_type (size_int (length));
3482 init = build_string (length + 1, name);
3485 type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
3486 type = build_cplus_array_type (type, domain);
3491 TREE_TYPE (init) = type;
3493 init = error_mark_node;
3498 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
3499 decl, NAME is the initialization string and TYPE_DEP indicates whether
3500 NAME depended on the type of the function. We make use of that to detect
3501 __PRETTY_FUNCTION__ inside a template fn. This is being done
3502 lazily at the point of first use, so we mustn't push the decl now. */
3505 cp_make_fname_decl (tree id, int type_dep)
3507 const char *const name = (type_dep && processing_template_decl
3508 ? NULL : fname_as_string (type_dep));
3510 tree init = cp_fname_init (name, &type);
3511 tree decl = build_decl (VAR_DECL, id, type);
3514 free (CONST_CAST (char *, name));
3516 /* As we're using pushdecl_with_scope, we must set the context. */
3517 DECL_CONTEXT (decl) = current_function_decl;
3518 DECL_PRETTY_FUNCTION_P (decl) = type_dep;
3520 TREE_STATIC (decl) = 1;
3521 TREE_READONLY (decl) = 1;
3522 DECL_ARTIFICIAL (decl) = 1;
3524 TREE_USED (decl) = 1;
3526 if (current_function_decl)
3528 struct cp_binding_level *b = current_binding_level;
3529 while (b->level_chain->kind != sk_function_parms)
3531 pushdecl_with_scope (decl, b, /*is_friend=*/false);
3532 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE,
3533 LOOKUP_ONLYCONVERTING);
3536 pushdecl_top_level_and_finish (decl, init);
3542 builtin_function_1 (tree decl, tree context, bool is_global)
3544 tree id = DECL_NAME (decl);
3545 const char *name = IDENTIFIER_POINTER (id);
3547 retrofit_lang_decl (decl);
3549 /* All nesting of C++ functions is lexical; there is never a "static
3550 chain" in the sense of GNU C nested functions. */
3551 DECL_NO_STATIC_CHAIN (decl) = 1;
3553 DECL_ARTIFICIAL (decl) = 1;
3554 SET_OVERLOADED_OPERATOR_CODE (decl, ERROR_MARK);
3555 SET_DECL_LANGUAGE (decl, lang_c);
3556 /* Runtime library routines are, by definition, available in an
3557 external shared object. */
3558 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
3559 DECL_VISIBILITY_SPECIFIED (decl) = 1;
3561 DECL_CONTEXT (decl) = context;
3564 pushdecl_top_level (decl);
3568 /* A function in the user's namespace should have an explicit
3569 declaration before it is used. Mark the built-in function as
3570 anticipated but not actually declared. */
3571 if (name[0] != '_' || name[1] != '_')
3572 DECL_ANTICIPATED (decl) = 1;
3573 else if (strncmp (name + 2, "builtin_", strlen ("builtin_")) != 0)
3575 size_t len = strlen (name);
3577 /* Treat __*_chk fortification functions as anticipated as well,
3578 unless they are __builtin_*. */
3579 if (len > strlen ("___chk")
3580 && memcmp (name + len - strlen ("_chk"),
3581 "_chk", strlen ("_chk") + 1) == 0)
3582 DECL_ANTICIPATED (decl) = 1;
3589 cxx_builtin_function (tree decl)
3591 tree id = DECL_NAME (decl);
3592 const char *name = IDENTIFIER_POINTER (id);
3593 /* All builtins that don't begin with an '_' should additionally
3594 go in the 'std' namespace. */
3597 tree decl2 = copy_node(decl);
3598 push_namespace (std_identifier);
3599 builtin_function_1 (decl2, std_node, false);
3603 return builtin_function_1 (decl, NULL_TREE, false);
3606 /* Like cxx_builtin_function, but guarantee the function is added to the global
3607 scope. This is to allow function specific options to add new machine
3608 dependent builtins when the target ISA changes via attribute((target(...)))
3609 which saves space on program startup if the program does not use non-generic
3613 cxx_builtin_function_ext_scope (tree decl)
3616 tree id = DECL_NAME (decl);
3617 const char *name = IDENTIFIER_POINTER (id);
3618 /* All builtins that don't begin with an '_' should additionally
3619 go in the 'std' namespace. */
3622 tree decl2 = copy_node(decl);
3623 push_namespace (std_identifier);
3624 builtin_function_1 (decl2, std_node, true);
3628 return builtin_function_1 (decl, NULL_TREE, true);
3631 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
3632 function. Not called directly. */
3635 build_library_fn_1 (tree name, enum tree_code operator_code, tree type)
3637 tree fn = build_lang_decl (FUNCTION_DECL, name, type);
3638 DECL_EXTERNAL (fn) = 1;
3639 TREE_PUBLIC (fn) = 1;
3640 DECL_ARTIFICIAL (fn) = 1;
3641 SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
3642 SET_DECL_LANGUAGE (fn, lang_c);
3643 /* Runtime library routines are, by definition, available in an
3644 external shared object. */
3645 DECL_VISIBILITY (fn) = VISIBILITY_DEFAULT;
3646 DECL_VISIBILITY_SPECIFIED (fn) = 1;
3650 /* Returns the _DECL for a library function with C linkage.
3651 We assume that such functions never throw; if this is incorrect,
3652 callers should unset TREE_NOTHROW. */
3655 build_library_fn (tree name, tree type)
3657 tree fn = build_library_fn_1 (name, ERROR_MARK, type);
3658 TREE_NOTHROW (fn) = 1;
3662 /* Returns the _DECL for a library function with C++ linkage. */
3665 build_cp_library_fn (tree name, enum tree_code operator_code, tree type)
3667 tree fn = build_library_fn_1 (name, operator_code, type);
3668 TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
3669 DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
3670 SET_DECL_LANGUAGE (fn, lang_cplusplus);
3674 /* Like build_library_fn, but takes a C string instead of an
3678 build_library_fn_ptr (const char* name, tree type)
3680 return build_library_fn (get_identifier (name), type);
3683 /* Like build_cp_library_fn, but takes a C string instead of an
3687 build_cp_library_fn_ptr (const char* name, tree type)
3689 return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
3692 /* Like build_library_fn, but also pushes the function so that we will
3693 be able to find it via IDENTIFIER_GLOBAL_VALUE. Also, the function
3694 may throw exceptions listed in RAISES. */
3697 push_library_fn (tree name, tree type, tree raises)
3702 type = build_exception_variant (type, raises);
3704 fn = build_library_fn (name, type);
3705 pushdecl_top_level (fn);
3709 /* Like build_cp_library_fn, but also pushes the function so that it
3710 will be found by normal lookup. */
3713 push_cp_library_fn (enum tree_code operator_code, tree type)
3715 tree fn = build_cp_library_fn (ansi_opname (operator_code),
3722 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
3726 push_void_library_fn (tree name, tree parmtypes)
3728 tree type = build_function_type (void_type_node, parmtypes);
3729 return push_library_fn (name, type, NULL_TREE);
3732 /* Like push_library_fn, but also note that this function throws
3733 and does not return. Used for __throw_foo and the like. */
3736 push_throw_library_fn (tree name, tree type)
3738 tree fn = push_library_fn (name, type, NULL_TREE);
3739 TREE_THIS_VOLATILE (fn) = 1;
3740 TREE_NOTHROW (fn) = 0;
3744 /* When we call finish_struct for an anonymous union, we create
3745 default copy constructors and such. But, an anonymous union
3746 shouldn't have such things; this function undoes the damage to the
3747 anonymous union type T.
3749 (The reason that we create the synthesized methods is that we don't
3750 distinguish `union { int i; }' from `typedef union { int i; } U'.
3751 The first is an anonymous union; the second is just an ordinary
3755 fixup_anonymous_aggr (tree t)
3759 /* Wipe out memory of synthesized methods. */
3760 TYPE_HAS_USER_CONSTRUCTOR (t) = 0;
3761 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
3762 TYPE_HAS_INIT_REF (t) = 0;
3763 TYPE_HAS_CONST_INIT_REF (t) = 0;
3764 TYPE_HAS_ASSIGN_REF (t) = 0;
3765 TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
3767 /* Splice the implicitly generated functions out of the TYPE_METHODS
3769 q = &TYPE_METHODS (t);
3772 if (DECL_ARTIFICIAL (*q))
3773 *q = TREE_CHAIN (*q);
3775 q = &TREE_CHAIN (*q);
3778 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
3779 if (TYPE_METHODS (t))
3781 tree decl = TYPE_MAIN_DECL (t);
3783 if (TREE_CODE (t) != UNION_TYPE)
3784 error ("%Jan anonymous struct cannot have function members", decl);
3786 error ("%Jan anonymous union cannot have function members", decl);
3789 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
3790 assignment operators (because they cannot have these methods themselves).
3791 For anonymous unions this is already checked because they are not allowed
3792 in any union, otherwise we have to check it. */
3793 if (TREE_CODE (t) != UNION_TYPE)
3797 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
3798 if (TREE_CODE (field) == FIELD_DECL)
3800 type = TREE_TYPE (field);
3801 if (CLASS_TYPE_P (type))
3803 if (TYPE_NEEDS_CONSTRUCTING (type))
3804 error ("member %q+#D with constructor not allowed "
3805 "in anonymous aggregate", field);
3806 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
3807 error ("member %q+#D with destructor not allowed "
3808 "in anonymous aggregate", field);
3809 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
3810 error ("member %q+#D with copy assignment operator "
3811 "not allowed in anonymous aggregate", field);
3817 /* Make sure that a declaration with no declarator is well-formed, i.e.
3818 just declares a tagged type or anonymous union.
3820 Returns the type declared; or NULL_TREE if none. */
3823 check_tag_decl (cp_decl_specifier_seq *declspecs)
3825 int saw_friend = declspecs->specs[(int)ds_friend] != 0;
3826 int saw_typedef = declspecs->specs[(int)ds_typedef] != 0;
3827 /* If a class, struct, or enum type is declared by the DECLSPECS
3828 (i.e, if a class-specifier, enum-specifier, or non-typename
3829 elaborated-type-specifier appears in the DECLSPECS),
3830 DECLARED_TYPE is set to the corresponding type. */
3831 tree declared_type = NULL_TREE;
3832 bool error_p = false;
3834 if (declspecs->multiple_types_p)
3835 error ("multiple types in one declaration");
3836 else if (declspecs->redefined_builtin_type)
3838 if (!in_system_header)
3839 permerror (input_location, "redeclaration of C++ built-in type %qT",
3840 declspecs->redefined_builtin_type);
3845 && TYPE_P (declspecs->type)
3846 && ((TREE_CODE (declspecs->type) != TYPENAME_TYPE
3847 && MAYBE_CLASS_TYPE_P (declspecs->type))
3848 || TREE_CODE (declspecs->type) == ENUMERAL_TYPE))
3849 declared_type = declspecs->type;
3850 else if (declspecs->type == error_mark_node)
3852 if (declared_type == NULL_TREE && ! saw_friend && !error_p)
3853 permerror (input_location, "declaration does not declare anything");
3854 /* Check for an anonymous union. */
3855 else if (declared_type && RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type))
3856 && TYPE_ANONYMOUS_P (declared_type))
3858 /* 7/3 In a simple-declaration, the optional init-declarator-list
3859 can be omitted only when declaring a class (clause 9) or
3860 enumeration (7.2), that is, when the decl-specifier-seq contains
3861 either a class-specifier, an elaborated-type-specifier with
3862 a class-key (9.1), or an enum-specifier. In these cases and
3863 whenever a class-specifier or enum-specifier is present in the
3864 decl-specifier-seq, the identifiers in these specifiers are among
3865 the names being declared by the declaration (as class-name,
3866 enum-names, or enumerators, depending on the syntax). In such
3867 cases, and except for the declaration of an unnamed bit-field (9.6),
3868 the decl-specifier-seq shall introduce one or more names into the
3869 program, or shall redeclare a name introduced by a previous
3870 declaration. [Example:
3871 enum { }; // ill-formed
3872 typedef class { }; // ill-formed
3876 error ("missing type-name in typedef-declaration");
3879 /* Anonymous unions are objects, so they can have specifiers. */;
3880 SET_ANON_AGGR_TYPE_P (declared_type);
3882 if (TREE_CODE (declared_type) != UNION_TYPE && !in_system_header)
3883 pedwarn (input_location, OPT_pedantic, "ISO C++ prohibits anonymous structs");
3888 if (declspecs->specs[(int)ds_inline]
3889 || declspecs->specs[(int)ds_virtual])
3890 error ("%qs can only be specified for functions",
3891 declspecs->specs[(int)ds_inline]
3892 ? "inline" : "virtual");
3894 && (!current_class_type
3895 || current_scope () != current_class_type))
3896 error ("%<friend%> can only be specified inside a class");
3897 else if (declspecs->specs[(int)ds_explicit])
3898 error ("%<explicit%> can only be specified for constructors");
3899 else if (declspecs->storage_class)
3900 error ("a storage class can only be specified for objects "
3902 else if (declspecs->specs[(int)ds_const]
3903 || declspecs->specs[(int)ds_volatile]
3904 || declspecs->specs[(int)ds_restrict]
3905 || declspecs->specs[(int)ds_thread])
3906 error ("qualifiers can only be specified for objects "
3908 else if (saw_typedef)
3909 warning (0, "%<typedef%> was ignored in this declaration");
3912 return declared_type;
3915 /* Called when a declaration is seen that contains no names to declare.
3916 If its type is a reference to a structure, union or enum inherited
3917 from a containing scope, shadow that tag name for the current scope
3918 with a forward reference.
3919 If its type defines a new named structure or union
3920 or defines an enum, it is valid but we need not do anything here.
3921 Otherwise, it is an error.
3923 C++: may have to grok the declspecs to learn about static,
3924 complain for anonymous unions.
3926 Returns the TYPE declared -- or NULL_TREE if none. */
3929 shadow_tag (cp_decl_specifier_seq *declspecs)
3931 tree t = check_tag_decl (declspecs);
3936 if (declspecs->attributes)
3938 warning (0, "attribute ignored in declaration of %q+#T", t);
3939 warning (0, "attribute for %q+#T must follow the %qs keyword",
3940 t, class_key_or_enum_as_string (t));
3944 if (maybe_process_partial_specialization (t) == error_mark_node)
3947 /* This is where the variables in an anonymous union are
3948 declared. An anonymous union declaration looks like:
3950 because there is no declarator after the union, the parser
3951 sends that declaration here. */
3952 if (ANON_AGGR_TYPE_P (t))
3954 fixup_anonymous_aggr (t);
3956 if (TYPE_FIELDS (t))
3958 tree decl = grokdeclarator (/*declarator=*/NULL,
3959 declspecs, NORMAL, 0, NULL);
3960 finish_anon_union (decl);
3967 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
3970 groktypename (cp_decl_specifier_seq *type_specifiers,
3971 const cp_declarator *declarator,
3972 bool is_template_arg)
3976 enum decl_context context
3977 = is_template_arg ? TEMPLATE_TYPE_ARG : TYPENAME;
3978 attrs = type_specifiers->attributes;
3979 type_specifiers->attributes = NULL_TREE;
3980 type = grokdeclarator (declarator, type_specifiers, context, 0, &attrs);
3981 if (attrs && type != error_mark_node)
3983 if (CLASS_TYPE_P (type))
3984 warning (OPT_Wattributes, "ignoring attributes applied to class type %qT "
3985 "outside of definition", type);
3986 else if (MAYBE_CLASS_TYPE_P (type))
3987 /* A template type parameter or other dependent type. */
3988 warning (OPT_Wattributes, "ignoring attributes applied to dependent "
3989 "type %qT without an associated declaration", type);
3991 cplus_decl_attributes (&type, attrs, 0);
3996 /* Process a DECLARATOR for a function-scope variable declaration,
3997 namespace-scope variable declaration, or function declaration.
3998 (Function definitions go through start_function; class member
3999 declarations appearing in the body of the class go through
4000 grokfield.) The DECL corresponding to the DECLARATOR is returned.
4001 If an error occurs, the error_mark_node is returned instead.
4003 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
4004 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
4005 for an explicitly defaulted function, or SD_DELETED for an explicitly
4006 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
4007 implicitly initialized via a default constructor. ATTRIBUTES and
4008 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
4009 *PUSHED_SCOPE_P is set to the scope entered in this function, if any; if
4010 set, the caller is responsible for calling pop_scope. */
4013 start_decl (const cp_declarator *declarator,
4014 cp_decl_specifier_seq *declspecs,
4017 tree prefix_attributes,
4018 tree *pushed_scope_p)
4026 *pushed_scope_p = NULL_TREE;
4028 /* An object declared as __attribute__((deprecated)) suppresses
4029 warnings of uses of other deprecated items. */
4030 if (lookup_attribute ("deprecated", attributes))
4031 deprecated_state = DEPRECATED_SUPPRESS;
4033 attributes = chainon (attributes, prefix_attributes);
4035 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
4038 deprecated_state = DEPRECATED_NORMAL;
4040 if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE
4041 || decl == error_mark_node)
4042 return error_mark_node;
4044 type = TREE_TYPE (decl);
4046 context = DECL_CONTEXT (decl);
4050 *pushed_scope_p = push_scope (context);
4052 /* We are only interested in class contexts, later. */
4053 if (TREE_CODE (context) == NAMESPACE_DECL)
4054 context = NULL_TREE;
4058 /* Is it valid for this decl to have an initializer at all?
4059 If not, set INITIALIZED to zero, which will indirectly
4060 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
4061 switch (TREE_CODE (decl))
4064 error ("typedef %qD is initialized (use decltype instead)", decl);
4065 return error_mark_node;
4068 if (initialized == SD_DELETED)
4069 /* We'll handle the rest of the semantics later, but we need to
4070 set this now so it's visible to duplicate_decls. */
4071 DECL_DELETED_FN (decl) = 1;
4080 if (! toplevel_bindings_p ()
4081 && DECL_EXTERNAL (decl))
4082 warning (0, "declaration of %q#D has %<extern%> and is initialized",
4084 DECL_EXTERNAL (decl) = 0;
4085 if (toplevel_bindings_p ())
4086 TREE_STATIC (decl) = 1;
4089 /* If this is a typedef that names the class for linkage purposes
4090 (7.1.3p8), apply any attributes directly to the type. */
4091 if (TREE_CODE (decl) == TYPE_DECL
4092 && TAGGED_TYPE_P (TREE_TYPE (decl))
4093 && decl == TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl))))
4094 flags = ATTR_FLAG_TYPE_IN_PLACE;
4098 /* Set attributes here so if duplicate decl, will have proper attributes. */
4099 cplus_decl_attributes (&decl, attributes, flags);
4101 /* Dllimported symbols cannot be defined. Static data members (which
4102 can be initialized in-class and dllimported) go through grokfield,
4103 not here, so we don't need to exclude those decls when checking for
4105 if (initialized && DECL_DLLIMPORT_P (decl))
4107 error ("definition of %q#D is marked %<dllimport%>", decl);
4108 DECL_DLLIMPORT_P (decl) = 0;
4111 /* If #pragma weak was used, mark the decl weak now. */
4112 maybe_apply_pragma_weak (decl);
4114 if (TREE_CODE (decl) == FUNCTION_DECL
4115 && DECL_DECLARED_INLINE_P (decl)
4116 && DECL_UNINLINABLE (decl)
4117 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
4118 warning (0, "inline function %q+D given attribute noinline", decl);
4120 if (context && COMPLETE_TYPE_P (complete_type (context)))
4122 if (TREE_CODE (decl) == VAR_DECL)
4124 tree field = lookup_field (context, DECL_NAME (decl), 0, false);
4125 if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
4126 error ("%q#D is not a static member of %q#T", decl, context);
4129 if (DECL_CONTEXT (field) != context)
4131 if (!same_type_p (DECL_CONTEXT (field), context))
4132 permerror (input_location, "ISO C++ does not permit %<%T::%D%> "
4133 "to be defined as %<%T::%D%>",
4134 DECL_CONTEXT (field), DECL_NAME (decl),
4135 context, DECL_NAME (decl));
4136 DECL_CONTEXT (decl) = DECL_CONTEXT (field);
4138 if (processing_specialization
4139 && template_class_depth (context) == 0
4140 && CLASSTYPE_TEMPLATE_SPECIALIZATION (context))
4141 error ("template header not allowed in member definition "
4142 "of explicitly specialized class");
4143 /* Static data member are tricky; an in-class initialization
4144 still doesn't provide a definition, so the in-class
4145 declaration will have DECL_EXTERNAL set, but will have an
4146 initialization. Thus, duplicate_decls won't warn
4147 about this situation, and so we check here. */
4148 if (initialized && DECL_INITIALIZED_IN_CLASS_P (field))
4149 error ("duplicate initialization of %qD", decl);
4150 if (duplicate_decls (decl, field, /*newdecl_is_friend=*/false))
4156 tree field = check_classfn (context, decl,
4157 (processing_template_decl
4158 > template_class_depth (context))
4159 ? current_template_parms
4161 if (field && field != error_mark_node
4162 && duplicate_decls (decl, field,
4163 /*newdecl_is_friend=*/false))
4167 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
4168 DECL_IN_AGGR_P (decl) = 0;
4169 /* Do not mark DECL as an explicit specialization if it was not
4170 already marked as an instantiation; a declaration should
4171 never be marked as a specialization unless we know what
4172 template is being specialized. */
4173 if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
4175 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
4177 /* [temp.expl.spec] An explicit specialization of a static data
4178 member of a template is a definition if the declaration
4179 includes an initializer; otherwise, it is a declaration.
4181 We check for processing_specialization so this only applies
4182 to the new specialization syntax. */
4183 if (!initialized && processing_specialization)
4184 DECL_EXTERNAL (decl) = 1;
4187 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
4188 permerror (input_location, "declaration of %q#D outside of class is not definition",
4192 was_public = TREE_PUBLIC (decl);
4194 /* Enter this declaration into the symbol table. */
4195 decl = maybe_push_decl (decl);
4197 if (processing_template_decl)
4198 decl = push_template_decl (decl);
4199 if (decl == error_mark_node)
4200 return error_mark_node;
4202 /* Tell the back end to use or not use .common as appropriate. If we say
4203 -fconserve-space, we want this to save .data space, at the expense of
4204 wrong semantics. If we say -fno-conserve-space, we want this to
4205 produce errors about redefs; to do this we force variables into the
4207 if (flag_conserve_space
4208 && TREE_CODE (decl) == VAR_DECL
4209 && TREE_PUBLIC (decl)
4210 && !DECL_THREAD_LOCAL_P (decl)
4211 && !have_global_bss_p ())
4212 DECL_COMMON (decl) = 1;
4214 if (TREE_CODE (decl) == VAR_DECL
4215 && DECL_NAMESPACE_SCOPE_P (decl) && !TREE_PUBLIC (decl) && !was_public
4216 && !DECL_THIS_STATIC (decl) && !DECL_ARTIFICIAL (decl))
4218 /* This is a const variable with implicit 'static'. Set
4219 DECL_THIS_STATIC so we can tell it from variables that are
4220 !TREE_PUBLIC because of the anonymous namespace. */
4221 gcc_assert (cp_type_readonly (TREE_TYPE (decl)));
4222 DECL_THIS_STATIC (decl) = 1;
4225 if (!processing_template_decl && TREE_CODE (decl) == VAR_DECL)
4226 start_decl_1 (decl, initialized);
4231 /* Process the declaration of a variable DECL. INITIALIZED is true
4232 iff DECL is explicitly initialized. (INITIALIZED is false if the
4233 variable is initialized via an implicitly-called constructor.)
4234 This function must be called for ordinary variables (including, for
4235 example, implicit instantiations of templates), but must not be
4236 called for template declarations. */
4239 start_decl_1 (tree decl, bool initialized)
4243 bool aggregate_definition_p;
4245 gcc_assert (!processing_template_decl);
4247 if (error_operand_p (decl))
4250 gcc_assert (TREE_CODE (decl) == VAR_DECL);
4252 type = TREE_TYPE (decl);
4253 complete_p = COMPLETE_TYPE_P (type);
4254 aggregate_definition_p = MAYBE_CLASS_TYPE_P (type) && !DECL_EXTERNAL (decl);
4256 /* If an explicit initializer is present, or if this is a definition
4257 of an aggregate, then we need a complete type at this point.
4258 (Scalars are always complete types, so there is nothing to
4259 check.) This code just sets COMPLETE_P; errors (if necessary)
4260 are issued below. */
4261 if ((initialized || aggregate_definition_p)
4263 && COMPLETE_TYPE_P (complete_type (type)))
4266 /* We will not yet have set TREE_READONLY on DECL if the type
4267 was "const", but incomplete, before this point. But, now, we
4268 have a complete type, so we can try again. */
4269 cp_apply_type_quals_to_decl (cp_type_quals (type), decl);
4273 /* Is it valid for this decl to have an initializer at all? */
4275 /* Don't allow initializations for incomplete types except for
4276 arrays which might be completed by the initialization. */
4278 ; /* A complete type is ok. */
4279 else if (type_uses_auto (type))
4280 ; /* An auto type is ok. */
4281 else if (TREE_CODE (type) != ARRAY_TYPE)
4283 error ("variable %q#D has initializer but incomplete type", decl);
4284 type = TREE_TYPE (decl) = error_mark_node;
4286 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
4288 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
4289 error ("elements of array %q#D have incomplete type", decl);
4290 /* else we already gave an error in start_decl. */
4293 else if (aggregate_definition_p && !complete_p)
4295 if (type_uses_auto (type))
4296 error ("declaration of %q#D has no initializer", decl);
4298 error ("aggregate %q#D has incomplete type and cannot be defined",
4300 /* Change the type so that assemble_variable will give
4301 DECL an rtl we can live with: (mem (const_int 0)). */
4302 type = TREE_TYPE (decl) = error_mark_node;
4305 /* Create a new scope to hold this declaration if necessary.
4306 Whether or not a new scope is necessary cannot be determined
4307 until after the type has been completed; if the type is a
4308 specialization of a class template it is not until after
4309 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4310 will be set correctly. */
4311 maybe_push_cleanup_level (type);
4314 /* Handle initialization of references. DECL, TYPE, and INIT have the
4315 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
4316 but will be set to a new CLEANUP_STMT if a temporary is created
4317 that must be destroyed subsequently.
4319 Returns an initializer expression to use to initialize DECL, or
4320 NULL if the initialization can be performed statically.
4322 Quotes on semantics can be found in ARM 8.4.3. */
4325 grok_reference_init (tree decl, tree type, tree init, tree *cleanup)
4329 if (init == NULL_TREE)
4331 if ((DECL_LANG_SPECIFIC (decl) == 0
4332 || DECL_IN_AGGR_P (decl) == 0)
4333 && ! DECL_THIS_EXTERN (decl))
4334 error ("%qD declared as reference but not initialized", decl);
4338 if (TREE_CODE (init) == CONSTRUCTOR)
4340 error ("ISO C++ forbids use of initializer list to "
4341 "initialize reference %qD", decl);
4345 if (TREE_CODE (init) == TREE_LIST)
4346 init = build_x_compound_expr_from_list (init, "initializer");
4348 if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
4349 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
4350 /* Note: default conversion is only called in very special cases. */
4351 init = decay_conversion (init);
4353 /* Convert INIT to the reference type TYPE. This may involve the
4354 creation of a temporary, whose lifetime must be the same as that
4355 of the reference. If so, a DECL_EXPR for the temporary will be
4356 added just after the DECL_EXPR for DECL. That's why we don't set
4357 DECL_INITIAL for local references (instead assigning to them
4358 explicitly); we need to allow the temporary to be initialized
4360 tmp = initialize_reference (type, init, decl, cleanup);
4362 if (tmp == error_mark_node)
4364 else if (tmp == NULL_TREE)
4366 error ("cannot initialize %qT from %qT", type, TREE_TYPE (init));
4370 if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
4373 DECL_INITIAL (decl) = tmp;
4378 /* Subroutine of check_initializer. We're initializing a DECL of
4379 std::initializer_list<T> TYPE from a braced-init-list INIT, and need to
4380 extend the lifetime of the underlying array to match that of the decl,
4381 just like for reference initialization. CLEANUP is as for
4382 grok_reference_init. */
4385 build_init_list_var_init (tree decl, tree type, tree init, tree *cleanup)
4387 tree aggr_init, array, arrtype;
4388 init = perform_implicit_conversion (type, init, tf_warning_or_error);
4389 aggr_init = TARGET_EXPR_INITIAL (init);
4390 init = build2 (INIT_EXPR, type, decl, init);
4392 array = AGGR_INIT_EXPR_ARG (aggr_init, 1);
4393 arrtype = TREE_TYPE (array);
4395 gcc_assert (TREE_CODE (array) == ADDR_EXPR);
4396 array = TREE_OPERAND (array, 0);
4397 /* If the array is constant, finish_compound_literal already made it a
4398 static variable and we don't need to do anything here. */
4399 if (decl && TREE_CODE (array) == TARGET_EXPR)
4402 tree var = set_up_extended_ref_temp (decl, array, cleanup, &subinit);
4403 var = build_address (var);
4404 var = convert (arrtype, var);
4405 AGGR_INIT_EXPR_ARG (aggr_init, 1) = var;
4406 init = build2 (COMPOUND_EXPR, TREE_TYPE (init), subinit, init);
4411 /* Designated initializers in arrays are not supported in GNU C++.
4412 The parser cannot detect this error since it does not know whether
4413 a given brace-enclosed initializer is for a class type or for an
4414 array. This function checks that CE does not use a designated
4415 initializer. If it does, an error is issued. Returns true if CE
4416 is valid, i.e., does not have a designated initializer. */
4419 check_array_designated_initializer (const constructor_elt *ce)
4421 /* Designated initializers for array elements are not supported. */
4424 /* The parser only allows identifiers as designated
4426 if (ce->index == error_mark_node)
4427 error ("name used in a GNU-style designated "
4428 "initializer for an array");
4431 gcc_assert (TREE_CODE (ce->index) == IDENTIFIER_NODE);
4432 error ("name %qD used in a GNU-style designated "
4433 "initializer for an array", ce->index);
4441 /* When parsing `int a[] = {1, 2};' we don't know the size of the
4442 array until we finish parsing the initializer. If that's the
4443 situation we're in, update DECL accordingly. */
4446 maybe_deduce_size_from_array_init (tree decl, tree init)
4448 tree type = TREE_TYPE (decl);
4450 if (TREE_CODE (type) == ARRAY_TYPE
4451 && TYPE_DOMAIN (type) == NULL_TREE
4452 && TREE_CODE (decl) != TYPE_DECL)
4454 /* do_default is really a C-ism to deal with tentative definitions.
4455 But let's leave it here to ease the eventual merge. */
4456 int do_default = !DECL_EXTERNAL (decl);
4457 tree initializer = init ? init : DECL_INITIAL (decl);
4460 /* Check that there are no designated initializers in INIT, as
4461 those are not supported in GNU C++, and as the middle-end
4462 will crash if presented with a non-numeric designated
4464 if (initializer && TREE_CODE (initializer) == CONSTRUCTOR)
4466 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initializer);
4467 constructor_elt *ce;
4470 VEC_iterate (constructor_elt, v, i, ce);
4472 if (!check_array_designated_initializer (ce))
4478 failure = cp_complete_array_type (&TREE_TYPE (decl), initializer,
4482 error ("initializer fails to determine size of %qD", decl);
4483 TREE_TYPE (decl) = error_mark_node;
4485 else if (failure == 2)
4489 error ("array size missing in %qD", decl);
4490 TREE_TYPE (decl) = error_mark_node;
4492 /* If a `static' var's size isn't known, make it extern as
4493 well as static, so it does not get allocated. If it's not
4494 `static', then don't mark it extern; finish_incomplete_decl
4495 will give it a default size and it will get allocated. */
4496 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
4497 DECL_EXTERNAL (decl) = 1;
4499 else if (failure == 3)
4501 error ("zero-size array %qD", decl);
4502 TREE_TYPE (decl) = error_mark_node;
4506 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl)), decl);
4508 layout_decl (decl, 0);
4512 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
4513 any appropriate error messages regarding the layout. */
4516 layout_var_decl (tree decl)
4520 type = TREE_TYPE (decl);
4521 if (type == error_mark_node)
4524 /* If we haven't already layed out this declaration, do so now.
4525 Note that we must not call complete type for an external object
4526 because it's type might involve templates that we are not
4527 supposed to instantiate yet. (And it's perfectly valid to say
4528 `extern X x' for some incomplete type `X'.) */
4529 if (!DECL_EXTERNAL (decl))
4530 complete_type (type);
4531 if (!DECL_SIZE (decl)
4532 && TREE_TYPE (decl) != error_mark_node
4533 && (COMPLETE_TYPE_P (type)
4534 || (TREE_CODE (type) == ARRAY_TYPE
4535 && !TYPE_DOMAIN (type)
4536 && COMPLETE_TYPE_P (TREE_TYPE (type)))))
4537 layout_decl (decl, 0);
4539 if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
4541 /* An automatic variable with an incomplete type: that is an error.
4542 Don't talk about array types here, since we took care of that
4543 message in grokdeclarator. */
4544 error ("storage size of %qD isn't known", decl);
4545 TREE_TYPE (decl) = error_mark_node;
4548 /* Keep this code around in case we later want to control debug info
4549 based on whether a type is "used". (jason 1999-11-11) */
4551 else if (!DECL_EXTERNAL (decl) && MAYBE_CLASS_TYPE_P (ttype))
4552 /* Let debugger know it should output info for this type. */
4553 note_debug_info_needed (ttype);
4555 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
4556 note_debug_info_needed (DECL_CONTEXT (decl));
4559 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
4560 && DECL_SIZE (decl) != NULL_TREE
4561 && ! TREE_CONSTANT (DECL_SIZE (decl)))
4563 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
4564 constant_expression_warning (DECL_SIZE (decl));
4567 error ("storage size of %qD isn't constant", decl);
4568 TREE_TYPE (decl) = error_mark_node;
4573 /* If a local static variable is declared in an inline function, or if
4574 we have a weak definition, we must endeavor to create only one
4575 instance of the variable at link-time. */
4578 maybe_commonize_var (tree decl)
4580 /* Static data in a function with comdat linkage also has comdat
4582 if (TREE_STATIC (decl)
4583 /* Don't mess with __FUNCTION__. */
4584 && ! DECL_ARTIFICIAL (decl)
4585 && DECL_FUNCTION_SCOPE_P (decl)
4586 /* Unfortunately, import_export_decl has not always been called
4587 before the function is processed, so we cannot simply check
4589 && (DECL_COMDAT (DECL_CONTEXT (decl))
4590 || ((DECL_DECLARED_INLINE_P (DECL_CONTEXT (decl))
4591 || DECL_TEMPLATE_INSTANTIATION (DECL_CONTEXT (decl)))
4592 && TREE_PUBLIC (DECL_CONTEXT (decl)))))
4596 /* With weak symbols, we simply make the variable COMDAT;
4597 that will cause copies in multiple translations units to
4599 comdat_linkage (decl);
4603 if (DECL_INITIAL (decl) == NULL_TREE
4604 || DECL_INITIAL (decl) == error_mark_node)
4606 /* Without weak symbols, we can use COMMON to merge
4607 uninitialized variables. */
4608 TREE_PUBLIC (decl) = 1;
4609 DECL_COMMON (decl) = 1;
4613 /* While for initialized variables, we must use internal
4614 linkage -- which means that multiple copies will not
4616 TREE_PUBLIC (decl) = 0;
4617 DECL_COMMON (decl) = 0;
4618 warning (0, "sorry: semantics of inline function static "
4619 "data %q+#D are wrong (you'll wind up "
4620 "with multiple copies)", decl);
4621 warning (0, "%J you can work around this by removing "
4627 else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
4628 /* Set it up again; we might have set DECL_INITIAL since the last
4630 comdat_linkage (decl);
4633 /* Issue an error message if DECL is an uninitialized const variable. */
4636 check_for_uninitialized_const_var (tree decl)
4638 tree type = TREE_TYPE (decl);
4640 /* ``Unless explicitly declared extern, a const object does not have
4641 external linkage and must be initialized. ($8.4; $12.1)'' ARM
4643 if (TREE_CODE (decl) == VAR_DECL
4644 && TREE_CODE (type) != REFERENCE_TYPE
4645 && CP_TYPE_CONST_P (type)
4646 && !TYPE_NEEDS_CONSTRUCTING (type)
4647 && !DECL_INITIAL (decl))
4648 error ("uninitialized const %qD", decl);
4652 /* Structure holding the current initializer being processed by reshape_init.
4653 CUR is a pointer to the current element being processed, END is a pointer
4654 after the last element present in the initializer. */
4655 typedef struct reshape_iterator_t
4657 constructor_elt *cur;
4658 constructor_elt *end;
4661 static tree reshape_init_r (tree, reshape_iter *, bool);
4663 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
4664 returned is the next FIELD_DECL (possibly FIELD itself) that can be
4665 initialized. If there are no more such fields, the return value
4669 next_initializable_field (tree field)
4672 && (TREE_CODE (field) != FIELD_DECL
4673 || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
4674 || DECL_ARTIFICIAL (field)))
4675 field = TREE_CHAIN (field);
4680 /* Subroutine of reshape_init_array and reshape_init_vector, which does
4681 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
4682 INTEGER_CST representing the size of the array minus one (the maximum index),
4683 or NULL_TREE if the array was declared without specifying the size. D is
4684 the iterator within the constructor. */
4687 reshape_init_array_1 (tree elt_type, tree max_index, reshape_iter *d)
4690 bool sized_array_p = (max_index != NULL_TREE);
4691 unsigned HOST_WIDE_INT max_index_cst = 0;
4692 unsigned HOST_WIDE_INT index;
4694 /* The initializer for an array is always a CONSTRUCTOR. */
4695 new_init = build_constructor (init_list_type_node, NULL);
4699 /* Minus 1 is used for zero sized arrays. */
4700 if (integer_all_onesp (max_index))
4703 if (host_integerp (max_index, 1))
4704 max_index_cst = tree_low_cst (max_index, 1);
4705 /* sizetype is sign extended, not zero extended. */
4707 max_index_cst = tree_low_cst (fold_convert (size_type_node, max_index),
4711 /* Loop until there are no more initializers. */
4713 d->cur != d->end && (!sized_array_p || index <= max_index_cst);
4718 check_array_designated_initializer (d->cur);
4719 elt_init = reshape_init_r (elt_type, d, /*first_initializer_p=*/false);
4720 if (elt_init == error_mark_node)
4721 return error_mark_node;
4722 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), NULL_TREE, elt_init);
4728 /* Subroutine of reshape_init_r, processes the initializers for arrays.
4729 Parameters are the same of reshape_init_r. */
4732 reshape_init_array (tree type, reshape_iter *d)
4734 tree max_index = NULL_TREE;
4736 gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
4738 if (TYPE_DOMAIN (type))
4739 max_index = array_type_nelts (type);
4741 return reshape_init_array_1 (TREE_TYPE (type), max_index, d);
4744 /* Subroutine of reshape_init_r, processes the initializers for vectors.
4745 Parameters are the same of reshape_init_r. */
4748 reshape_init_vector (tree type, reshape_iter *d)
4750 tree max_index = NULL_TREE;
4753 gcc_assert (TREE_CODE (type) == VECTOR_TYPE);
4755 if (COMPOUND_LITERAL_P (d->cur->value))
4757 tree value = d->cur->value;
4758 if (!same_type_p (TREE_TYPE (value), type))
4760 error ("invalid type %qT as initializer for a vector of type %qT",
4761 TREE_TYPE (d->cur->value), type);
4762 value = error_mark_node;
4768 /* For a vector, the representation type is a struct
4769 containing a single member which is an array of the
4770 appropriate size. */
4771 rtype = TYPE_DEBUG_REPRESENTATION_TYPE (type);
4772 if (rtype && TYPE_DOMAIN (TREE_TYPE (TYPE_FIELDS (rtype))))
4773 max_index = array_type_nelts (TREE_TYPE (TYPE_FIELDS (rtype)));
4775 return reshape_init_array_1 (TREE_TYPE (type), max_index, d);
4778 /* Subroutine of reshape_init_r, processes the initializers for classes
4779 or union. Parameters are the same of reshape_init_r. */
4782 reshape_init_class (tree type, reshape_iter *d, bool first_initializer_p)
4787 gcc_assert (CLASS_TYPE_P (type));
4789 /* The initializer for a class is always a CONSTRUCTOR. */
4790 new_init = build_constructor (init_list_type_node, NULL);
4791 field = next_initializable_field (TYPE_FIELDS (type));
4797 An initializer for an aggregate member that is an
4798 empty class shall have the form of an empty
4799 initializer-list {}. */
4800 if (!first_initializer_p)
4802 error ("initializer for %qT must be brace-enclosed", type);
4803 return error_mark_node;
4808 /* Loop through the initializable fields, gathering initializers. */
4809 while (d->cur != d->end)
4813 /* Handle designated initializers, as an extension. */
4816 field = lookup_field_1 (type, d->cur->index, /*want_type=*/false);
4818 if (!field || TREE_CODE (field) != FIELD_DECL)
4820 error ("%qT has no non-static data member named %qD", type,
4822 return error_mark_node;
4826 /* If we processed all the member of the class, we are done. */
4830 field_init = reshape_init_r (TREE_TYPE (field), d,
4831 /*first_initializer_p=*/false);
4832 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), field, field_init);
4836 When a union is initialized with a brace-enclosed
4837 initializer, the braces shall only contain an
4838 initializer for the first member of the union. */
4839 if (TREE_CODE (type) == UNION_TYPE)
4842 field = next_initializable_field (TREE_CHAIN (field));
4848 /* Subroutine of reshape_init, which processes a single initializer (part of
4849 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
4850 iterator within the CONSTRUCTOR which points to the initializer to process.
4851 FIRST_INITIALIZER_P is true if this is the first initializer of the
4852 CONSTRUCTOR node. */
4855 reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p)
4857 tree init = d->cur->value;
4859 if (error_operand_p (init))
4860 return error_mark_node;
4862 /* A non-aggregate type is always initialized with a single
4864 if (!CP_AGGREGATE_TYPE_P (type))
4866 /* It is invalid to initialize a non-aggregate type with a
4867 brace-enclosed initializer before C++0x.
4868 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
4869 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
4870 a CONSTRUCTOR (with a record type). */
4871 if (TREE_CODE (init) == CONSTRUCTOR
4872 && BRACE_ENCLOSED_INITIALIZER_P (init)) /* p7626.C */
4874 if (SCALAR_TYPE_P (type))
4876 error ("braces around scalar initializer for type %qT", type);
4877 init = error_mark_node;
4880 maybe_warn_cpp0x ("extended initializer lists");
4889 All implicit type conversions (clause _conv_) are considered when
4890 initializing the aggregate member with an initializer from an
4891 initializer-list. If the initializer can initialize a member,
4892 the member is initialized. Otherwise, if the member is itself a
4893 non-empty subaggregate, brace elision is assumed and the
4894 initializer is considered for the initialization of the first
4895 member of the subaggregate. */
4896 if (TREE_CODE (init) != CONSTRUCTOR
4897 && can_convert_arg (type, TREE_TYPE (init), init, LOOKUP_NORMAL))
4903 /* [dcl.init.string]
4905 A char array (whether plain char, signed char, or unsigned char)
4906 can be initialized by a string-literal (optionally enclosed in
4907 braces); a wchar_t array can be initialized by a wide
4908 string-literal (optionally enclosed in braces). */
4909 if (TREE_CODE (type) == ARRAY_TYPE
4910 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
4912 tree str_init = init;
4914 /* Strip one level of braces if and only if they enclose a single
4915 element (as allowed by [dcl.init.string]). */
4916 if (!first_initializer_p
4917 && TREE_CODE (str_init) == CONSTRUCTOR
4918 && VEC_length (constructor_elt, CONSTRUCTOR_ELTS (str_init)) == 1)
4920 str_init = VEC_index (constructor_elt,
4921 CONSTRUCTOR_ELTS (str_init), 0)->value;
4924 /* If it's a string literal, then it's the initializer for the array
4925 as a whole. Otherwise, continue with normal initialization for
4926 array types (one value per array element). */
4927 if (TREE_CODE (str_init) == STRING_CST)
4934 /* The following cases are about aggregates. If we are not within a full
4935 initializer already, and there is not a CONSTRUCTOR, it means that there
4936 is a missing set of braces (that is, we are processing the case for
4937 which reshape_init exists). */
4938 if (!first_initializer_p)
4940 if (TREE_CODE (init) == CONSTRUCTOR)
4942 if (TREE_TYPE (init) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init)))
4943 /* There is no need to reshape pointer-to-member function
4944 initializers, as they are always constructed correctly
4945 by the front end. */
4947 else if (COMPOUND_LITERAL_P (init))
4948 /* For a nested compound literal, there is no need to reshape since
4949 brace elision is not allowed. Even if we decided to allow it,
4950 we should add a call to reshape_init in finish_compound_literal,
4951 before calling digest_init, so changing this code would still
4952 not be necessary. */
4953 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init));
4957 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
4958 return reshape_init (type, init);
4962 warning (OPT_Wmissing_braces, "missing braces around initializer for %qT",
4966 /* Dispatch to specialized routines. */
4967 if (CLASS_TYPE_P (type))
4968 return reshape_init_class (type, d, first_initializer_p);
4969 else if (TREE_CODE (type) == ARRAY_TYPE)
4970 return reshape_init_array (type, d);
4971 else if (TREE_CODE (type) == VECTOR_TYPE)
4972 return reshape_init_vector (type, d);
4977 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
4978 brace-enclosed aggregate initializer.
4980 INIT is the CONSTRUCTOR containing the list of initializers describing
4981 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
4982 It may not presently match the shape of the TYPE; for example:
4984 struct S { int a; int b; };
4985 struct S a[] = { 1, 2, 3, 4 };
4987 Here INIT will hold a VEC of four elements, rather than a
4988 VEC of two elements, each itself a VEC of two elements. This
4989 routine transforms INIT from the former form into the latter. The
4990 revised CONSTRUCTOR node is returned. */
4993 reshape_init (tree type, tree init)
4995 VEC(constructor_elt, gc) *v;
4999 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
5001 v = CONSTRUCTOR_ELTS (init);
5003 /* An empty constructor does not need reshaping, and it is always a valid
5005 if (VEC_empty (constructor_elt, v))
5008 /* Recurse on this CONSTRUCTOR. */
5009 d.cur = VEC_index (constructor_elt, v, 0);
5010 d.end = d.cur + VEC_length (constructor_elt, v);
5012 new_init = reshape_init_r (type, &d, true);
5013 if (new_init == error_mark_node)
5014 return error_mark_node;
5016 /* Make sure all the element of the constructor were used. Otherwise,
5017 issue an error about exceeding initializers. */
5019 error ("too many initializers for %qT", type);
5024 /* Verify array initializer. Returns true if errors have been reported. */
5027 check_array_initializer (tree decl, tree type, tree init)
5029 tree element_type = TREE_TYPE (type);
5031 /* The array type itself need not be complete, because the
5032 initializer may tell us how many elements are in the array.
5033 But, the elements of the array must be complete. */
5034 if (!COMPLETE_TYPE_P (complete_type (element_type)))
5037 error ("elements of array %q#D have incomplete type", decl);
5039 error ("elements of array %q#T have incomplete type", type);
5042 /* It is not valid to initialize a VLA. */
5044 && ((COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
5045 || !TREE_CONSTANT (TYPE_SIZE (element_type))))
5048 error ("variable-sized object %qD may not be initialized", decl);
5050 error ("variable-sized compound literal");
5056 /* Subroutine of check_initializer; args are passed down from that function.
5057 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
5060 build_aggr_init_full_exprs (tree decl, tree init, int flags)
5063 int saved_stmts_are_full_exprs_p = 0;
5064 if (building_stmt_tree ())
5066 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
5067 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
5069 init = build_aggr_init (decl, init, flags, tf_warning_or_error);
5070 if (building_stmt_tree ())
5071 current_stmt_tree ()->stmts_are_full_exprs_p =
5072 saved_stmts_are_full_exprs_p;
5076 /* Verify INIT (the initializer for DECL), and record the
5077 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
5078 grok_reference_init.
5080 If the return value is non-NULL, it is an expression that must be
5081 evaluated dynamically to initialize DECL. */
5084 check_initializer (tree decl, tree init, int flags, tree *cleanup)
5086 tree type = TREE_TYPE (decl);
5087 tree init_code = NULL;
5089 /* Things that are going to be initialized need to have complete
5091 TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
5093 if (type == error_mark_node)
5094 /* We will have already complained. */
5097 if (TREE_CODE (type) == ARRAY_TYPE)
5099 if (check_array_initializer (decl, type, init))
5102 else if (!COMPLETE_TYPE_P (type))
5104 error ("%qD has incomplete type", decl);
5105 TREE_TYPE (decl) = error_mark_node;
5109 /* There is no way to make a variable-sized class type in GNU C++. */
5110 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type)));
5112 if (init && BRACE_ENCLOSED_INITIALIZER_P (init))
5114 int init_len = VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init));
5115 if (SCALAR_TYPE_P (type))
5119 maybe_warn_cpp0x ("extended initializer lists");
5120 init = build_zero_init (type, NULL_TREE, false);
5122 else if (init_len != 1)
5124 error ("scalar object %qD requires one element in initializer",
5126 TREE_TYPE (decl) = error_mark_node;
5132 if (TREE_CODE (decl) == CONST_DECL)
5134 gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);
5136 DECL_INITIAL (decl) = init;
5138 gcc_assert (init != NULL_TREE);
5141 else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
5142 init = grok_reference_init (decl, type, init, cleanup);
5145 /* Do not reshape constructors of vectors (they don't need to be
5147 if (BRACE_ENCLOSED_INITIALIZER_P (init))
5149 if (is_std_init_list (type))
5150 return build_init_list_var_init (decl, type, init, cleanup);
5151 else if (TYPE_NON_AGGREGATE_CLASS (type))
5153 /* Don't reshape if the class has constructors. */
5154 if (cxx_dialect == cxx98)
5155 error ("in C++98 %qD must be initialized by constructor, "
5158 init = build_tree_list (NULL_TREE, init);
5160 else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_VECTOR_OPAQUE (type))
5162 error ("opaque vector types cannot be initialized");
5163 init = error_mark_node;
5166 init = reshape_init (type, init);
5169 /* If DECL has an array type without a specific bound, deduce the
5170 array size from the initializer. */
5171 maybe_deduce_size_from_array_init (decl, init);
5172 type = TREE_TYPE (decl);
5173 if (type == error_mark_node)
5176 if (TYPE_NEEDS_CONSTRUCTING (type)
5177 || (CLASS_TYPE_P (type)
5178 && !BRACE_ENCLOSED_INITIALIZER_P (init)))
5179 return build_aggr_init_full_exprs (decl, init, flags);
5180 else if (TREE_CODE (init) != TREE_VEC)
5182 init_code = store_init_value (decl, init);
5183 if (pedantic && TREE_CODE (type) == ARRAY_TYPE
5184 && DECL_INITIAL (decl)
5185 && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST
5186 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl)))
5187 warning (0, "array %qD initialized by parenthesized string literal %qE",
5188 decl, DECL_INITIAL (decl));
5192 else if (DECL_EXTERNAL (decl))
5194 else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
5195 return build_aggr_init_full_exprs (decl, init, flags);
5196 else if (MAYBE_CLASS_TYPE_P (type))
5198 tree core_type = strip_array_types (type);
5200 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
5201 error ("structure %qD with uninitialized const members", decl);
5202 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
5203 error ("structure %qD with uninitialized reference members", decl);
5205 check_for_uninitialized_const_var (decl);
5208 check_for_uninitialized_const_var (decl);
5210 if (init && init != error_mark_node)
5211 init_code = build2 (INIT_EXPR, type, decl, init);
5216 /* If DECL is not a local variable, give it RTL. */
5219 make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
5221 int toplev = toplevel_bindings_p ();
5223 const char *filename;
5225 /* Set the DECL_ASSEMBLER_NAME for the object. */
5228 /* The `register' keyword, when used together with an
5229 asm-specification, indicates that the variable should be
5230 placed in a particular register. */
5231 if (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
5233 set_user_assembler_name (decl, asmspec);
5234 DECL_HARD_REGISTER (decl) = 1;
5238 if (TREE_CODE (decl) == FUNCTION_DECL
5239 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
5240 set_builtin_user_assembler_name (decl, asmspec);
5241 set_user_assembler_name (decl, asmspec);
5245 /* Handle non-variables up front. */
5246 if (TREE_CODE (decl) != VAR_DECL)
5248 rest_of_decl_compilation (decl, toplev, at_eof);
5252 /* If we see a class member here, it should be a static data
5254 if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
5256 gcc_assert (TREE_STATIC (decl));
5257 /* An in-class declaration of a static data member should be
5258 external; it is only a declaration, and not a definition. */
5259 if (init == NULL_TREE)
5260 gcc_assert (DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl));
5263 /* We don't create any RTL for local variables. */
5264 if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
5267 /* We defer emission of local statics until the corresponding
5268 DECL_EXPR is expanded. */
5269 defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
5271 /* We try to defer namespace-scope static constants so that they are
5272 not emitted into the object file unnecessarily. */
5273 filename = input_filename;
5274 if (!DECL_VIRTUAL_P (decl)
5275 && TREE_READONLY (decl)
5276 && DECL_INITIAL (decl) != NULL_TREE
5277 && DECL_INITIAL (decl) != error_mark_node
5279 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
5281 && !TREE_PUBLIC (decl))
5283 /* Fool with the linkage of static consts according to #pragma
5285 struct c_fileinfo *finfo = get_fileinfo (filename);
5286 if (!finfo->interface_unknown && !TREE_PUBLIC (decl))
5288 TREE_PUBLIC (decl) = 1;
5289 DECL_EXTERNAL (decl) = finfo->interface_only;
5294 /* Likewise for template instantiations. */
5295 else if (DECL_LANG_SPECIFIC (decl)
5296 && DECL_IMPLICIT_INSTANTIATION (decl))
5299 /* If we're not deferring, go ahead and assemble the variable. */
5301 rest_of_decl_compilation (decl, toplev, at_eof);
5304 /* walk_tree helper for wrap_temporary_cleanups, below. */
5307 wrap_cleanups_r (tree *stmt_p, int *walk_subtrees, void *data)
5309 if (TYPE_P (*stmt_p))
5315 if (TREE_CODE (*stmt_p) == TARGET_EXPR)
5317 tree guard = (tree)data;
5318 tree tcleanup = TARGET_EXPR_CLEANUP (*stmt_p);
5320 tcleanup = build2 (TRY_CATCH_EXPR, void_type_node, tcleanup, guard);
5321 /* Tell honor_protect_cleanup_actions to handle this as a separate
5323 TRY_CATCH_IS_CLEANUP (tcleanup) = 1;
5325 TARGET_EXPR_CLEANUP (*stmt_p) = tcleanup;
5331 /* We're initializing a local variable which has a cleanup GUARD. If there
5332 are any temporaries used in the initializer INIT of this variable, we
5333 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
5334 variable will be cleaned up properly if one of them throws.
5336 Unfortunately, there's no way to express this properly in terms of
5337 nesting, as the regions for the temporaries overlap the region for the
5338 variable itself; if there are two temporaries, the variable needs to be
5339 the first thing destroyed if either of them throws. However, we only
5340 want to run the variable's cleanup if it actually got constructed. So
5341 we need to guard the temporary cleanups with the variable's cleanup if
5342 they are run on the normal path, but not if they are run on the
5343 exceptional path. We implement this by telling
5344 honor_protect_cleanup_actions to strip the variable cleanup from the
5345 exceptional path. */
5348 wrap_temporary_cleanups (tree init, tree guard)
5350 cp_walk_tree_without_duplicates (&init, wrap_cleanups_r, (void *)guard);
5353 /* Generate code to initialize DECL (a local variable). */
5356 initialize_local_var (tree decl, tree init)
5358 tree type = TREE_TYPE (decl);
5362 gcc_assert (TREE_CODE (decl) == VAR_DECL
5363 || TREE_CODE (decl) == RESULT_DECL);
5364 gcc_assert (!TREE_STATIC (decl));
5366 if (DECL_SIZE (decl) == NULL_TREE)
5368 /* If we used it already as memory, it must stay in memory. */
5369 DECL_INITIAL (decl) = NULL_TREE;
5370 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
5374 if (type == error_mark_node)
5377 /* Compute and store the initial value. */
5378 already_used = TREE_USED (decl) || TREE_USED (type);
5380 /* Generate a cleanup, if necessary. */
5381 cleanup = cxx_maybe_build_cleanup (decl);
5383 /* Perform the initialization. */
5386 int saved_stmts_are_full_exprs_p;
5388 /* If we're only initializing a single object, guard the destructors
5389 of any temporaries used in its initializer with its destructor.
5390 This isn't right for arrays because each element initialization is
5391 a full-expression. */
5392 if (cleanup && TREE_CODE (type) != ARRAY_TYPE)
5393 wrap_temporary_cleanups (init, cleanup);
5395 gcc_assert (building_stmt_tree ());
5396 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
5397 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
5398 finish_expr_stmt (init);
5399 current_stmt_tree ()->stmts_are_full_exprs_p =
5400 saved_stmts_are_full_exprs_p;
5403 /* Set this to 0 so we can tell whether an aggregate which was
5404 initialized was ever used. Don't do this if it has a
5405 destructor, so we don't complain about the 'resource
5406 allocation is initialization' idiom. Now set
5407 attribute((unused)) on types so decls of that type will be
5408 marked used. (see TREE_USED, above.) */
5409 if (TYPE_NEEDS_CONSTRUCTING (type)
5411 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
5412 && DECL_NAME (decl))
5413 TREE_USED (decl) = 0;
5414 else if (already_used)
5415 TREE_USED (decl) = 1;
5418 finish_decl_cleanup (decl, cleanup);
5421 /* DECL is a VAR_DECL for a compiler-generated variable with static
5422 storage duration (like a virtual table) whose initializer is a
5423 compile-time constant. INIT must be either a TREE_LIST of values,
5424 or a CONSTRUCTOR. Initialize the variable and provide it to the
5428 initialize_artificial_var (tree decl, tree init)
5430 gcc_assert (DECL_ARTIFICIAL (decl));
5431 if (TREE_CODE (init) == TREE_LIST)
5432 init = build_constructor_from_list (TREE_TYPE (decl), init);
5433 gcc_assert (TREE_CODE (init) == CONSTRUCTOR);
5434 DECL_INITIAL (decl) = init;
5435 DECL_INITIALIZED_P (decl) = 1;
5436 determine_visibility (decl);
5437 layout_var_decl (decl);
5438 maybe_commonize_var (decl);
5439 make_rtl_for_nonlocal_decl (decl, init, /*asmspec=*/NULL);
5442 /* INIT is the initializer for a variable, as represented by the
5443 parser. Returns true iff INIT is value-dependent. */
5446 value_dependent_init_p (tree init)
5448 if (TREE_CODE (init) == TREE_LIST)
5449 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
5450 return any_value_dependent_elements_p (init);
5451 else if (TREE_CODE (init) == CONSTRUCTOR)
5452 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
5454 VEC(constructor_elt, gc) *elts;
5458 elts = CONSTRUCTOR_ELTS (init);
5459 nelts = VEC_length (constructor_elt, elts);
5460 for (i = 0; i < nelts; ++i)
5461 if (value_dependent_init_p (VEC_index (constructor_elt,
5466 /* It must be a simple expression, e.g., int i = 3; */
5467 return value_dependent_expression_p (init);
5472 /* Finish processing of a declaration;
5473 install its line number and initial value.
5474 If the length of an array type is not known before,
5475 it must be determined now, from the initial value, or it is an error.
5477 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
5478 true, then INIT is an integral constant expression.
5480 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
5481 if the (init) syntax was used. */
5484 cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
5485 tree asmspec_tree, int flags)
5489 const char *asmspec = NULL;
5490 int was_readonly = 0;
5491 bool var_definition_p = false;
5492 int saved_processing_template_decl;
5495 if (decl == error_mark_node)
5500 error ("assignment (not initialization) in declaration");
5504 gcc_assert (TREE_CODE (decl) != RESULT_DECL);
5505 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
5506 gcc_assert (TREE_CODE (decl) != PARM_DECL);
5508 type = TREE_TYPE (decl);
5509 if (type == error_mark_node)
5512 /* Assume no cleanup is required. */
5513 cleanup = NULL_TREE;
5514 saved_processing_template_decl = processing_template_decl;
5516 /* If a name was specified, get the string. */
5517 if (global_scope_p (current_binding_level))
5518 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
5519 if (asmspec_tree && asmspec_tree != error_mark_node)
5520 asmspec = TREE_STRING_POINTER (asmspec_tree);
5522 if (current_class_type
5523 && CP_DECL_CONTEXT (decl) == current_class_type
5524 && TYPE_BEING_DEFINED (current_class_type)
5525 && (DECL_INITIAL (decl) || init))
5526 DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
5528 auto_node = type_uses_auto (type);
5531 if (init == NULL_TREE)
5533 error ("declaration of %q#D has no initializer", decl);
5534 TREE_TYPE (decl) = error_mark_node;
5537 else if (describable_type (init))
5539 type = TREE_TYPE (decl) = do_auto_deduction (type, init, auto_node);
5540 if (type == error_mark_node)
5545 if (init && TREE_CODE (decl) == FUNCTION_DECL)
5547 if (init == ridpointers[(int)RID_DELETE])
5549 /* FIXME check this is 1st decl. */
5550 DECL_DELETED_FN (decl) = 1;
5551 DECL_DECLARED_INLINE_P (decl) = 1;
5552 DECL_INITIAL (decl) = error_mark_node;
5555 else if (init == ridpointers[(int)RID_DEFAULT])
5557 if (!defaultable_fn_p (decl))
5559 error ("%qD cannot be defaulted", decl);
5560 DECL_INITIAL (decl) = NULL_TREE;
5563 DECL_DEFAULTED_FN (decl) = 1;
5567 if (processing_template_decl)
5569 bool type_dependent_p;
5571 /* Add this declaration to the statement-tree. */
5572 if (at_function_scope_p ())
5573 add_decl_expr (decl);
5575 type_dependent_p = dependent_type_p (type);
5577 if (check_for_bare_parameter_packs (init))
5580 DECL_INITIAL (decl) = NULL_TREE;
5583 if (init && init_const_expr_p && TREE_CODE (decl) == VAR_DECL)
5585 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
5586 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl))
5587 TREE_CONSTANT (decl) = 1;
5590 /* Generally, initializers in templates are expanded when the
5591 template is instantiated. But, if DECL is an integral
5592 constant static data member, then it can be used in future
5593 integral constant expressions, and its value must be
5596 && DECL_CLASS_SCOPE_P (decl)
5597 && DECL_INTEGRAL_CONSTANT_VAR_P (decl)
5598 && !type_dependent_p
5599 && !value_dependent_init_p (init)))
5602 DECL_INITIAL (decl) = init;
5603 if (TREE_CODE (decl) == VAR_DECL
5604 && !DECL_PRETTY_FUNCTION_P (decl)
5605 && !type_dependent_p)
5606 maybe_deduce_size_from_array_init (decl, init);
5610 if (TREE_CODE (init) == TREE_LIST)
5612 /* If the parenthesized-initializer form was used (e.g.,
5613 "int A<N>::i(X)"), then INIT will be a TREE_LIST of initializer
5614 arguments. (There is generally only one.) We convert them
5617 for (; list; list = TREE_CHAIN (list))
5619 tree elt = TREE_VALUE (list);
5620 TREE_VALUE (list) = fold_non_dependent_expr (elt);
5624 init = fold_non_dependent_expr (init);
5625 processing_template_decl = 0;
5628 /* Take care of TYPE_DECLs up front. */
5629 if (TREE_CODE (decl) == TYPE_DECL)
5631 if (type != error_mark_node
5632 && MAYBE_CLASS_TYPE_P (type) && DECL_NAME (decl))
5634 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
5635 warning (0, "shadowing previous type declaration of %q#D", decl);
5636 set_identifier_type_value (DECL_NAME (decl), decl);
5639 /* If we have installed this as the canonical typedef for this
5640 type, and that type has not been defined yet, delay emitting
5641 the debug information for it, as we will emit it later. */
5642 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
5643 && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
5644 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
5646 rest_of_decl_compilation (decl, DECL_CONTEXT (decl) == NULL_TREE,
5651 /* A reference will be modified here, as it is initialized. */
5652 if (! DECL_EXTERNAL (decl)
5653 && TREE_READONLY (decl)
5654 && TREE_CODE (type) == REFERENCE_TYPE)
5657 TREE_READONLY (decl) = 0;
5660 if (TREE_CODE (decl) == VAR_DECL)
5662 /* Only PODs can have thread-local storage. Other types may require
5663 various kinds of non-trivial initialization. */
5664 if (DECL_THREAD_LOCAL_P (decl) && !pod_type_p (TREE_TYPE (decl)))
5665 error ("%qD cannot be thread-local because it has non-POD type %qT",
5666 decl, TREE_TYPE (decl));
5667 /* If this is a local variable that will need a mangled name,
5668 register it now. We must do this before processing the
5669 initializer for the variable, since the initialization might
5670 require a guard variable, and since the mangled name of the
5671 guard variable will depend on the mangled name of this
5673 if (DECL_FUNCTION_SCOPE_P (decl)
5674 && TREE_STATIC (decl)
5675 && !DECL_ARTIFICIAL (decl))
5676 push_local_name (decl);
5677 /* Convert the initializer to the type of DECL, if we have not
5678 already initialized DECL. */
5679 if (!DECL_INITIALIZED_P (decl)
5680 /* If !DECL_EXTERNAL then DECL is being defined. In the
5681 case of a static data member initialized inside the
5682 class-specifier, there can be an initializer even if DECL
5683 is *not* defined. */
5684 && (!DECL_EXTERNAL (decl) || init))
5686 if (TYPE_FOR_JAVA (type) && MAYBE_CLASS_TYPE_P (type))
5689 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
5690 /* Allow libjava/prims.cc define primitive classes. */
5691 if (init != NULL_TREE
5692 || jclass == NULL_TREE
5693 || TREE_CODE (jclass) != TYPE_DECL
5694 || !POINTER_TYPE_P (TREE_TYPE (jclass))
5695 || !same_type_ignoring_top_level_qualifiers_p
5696 (type, TREE_TYPE (TREE_TYPE (jclass))))
5697 error ("Java object %qD not allocated with %<new%>", decl);
5702 DECL_NONTRIVIALLY_INITIALIZED_P (decl) = 1;
5703 if (init_const_expr_p)
5705 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
5706 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl))
5707 TREE_CONSTANT (decl) = 1;
5710 init = check_initializer (decl, init, flags, &cleanup);
5711 /* Thread-local storage cannot be dynamically initialized. */
5712 if (DECL_THREAD_LOCAL_P (decl) && init)
5714 error ("%qD is thread-local and so cannot be dynamically "
5715 "initialized", decl);
5719 /* Check that the initializer for a static data member was a
5720 constant. Although we check in the parser that the
5721 initializer is an integral constant expression, we do not
5722 simplify division-by-zero at the point at which it
5723 occurs. Therefore, in:
5725 struct S { static const int i = 7 / 0; };
5727 we issue an error at this point. It would
5728 probably be better to forbid division by zero in
5729 integral constant expressions. */
5730 if (DECL_EXTERNAL (decl) && init)
5732 error ("%qD cannot be initialized by a non-constant expression"
5733 " when being declared", decl);
5734 DECL_INITIALIZED_IN_CLASS_P (decl) = 0;
5742 The memory occupied by any object of static storage
5743 duration is zero-initialized at program startup before
5744 any other initialization takes place.
5746 We cannot create an appropriate initializer until after
5747 the type of DECL is finalized. If DECL_INITIAL is set,
5748 then the DECL is statically initialized, and any
5749 necessary zero-initialization has already been performed. */
5750 if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
5751 DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
5752 /*nelts=*/NULL_TREE,
5753 /*static_storage_p=*/true);
5754 /* Remember that the initialization for this variable has
5756 DECL_INITIALIZED_P (decl) = 1;
5757 /* This declaration is the definition of this variable,
5758 unless we are initializing a static data member within
5759 the class specifier. */
5760 if (!DECL_EXTERNAL (decl))
5761 var_definition_p = true;
5763 /* If the variable has an array type, lay out the type, even if
5764 there is no initializer. It is valid to index through the
5765 array, and we must get TYPE_ALIGN set correctly on the array
5767 else if (TREE_CODE (type) == ARRAY_TYPE)
5770 else if (TREE_CODE (decl) == FIELD_DECL
5771 && TYPE_FOR_JAVA (type) && MAYBE_CLASS_TYPE_P (type))
5772 error ("non-static data member %qD has Java class type", decl);
5774 /* Add this declaration to the statement-tree. This needs to happen
5775 after the call to check_initializer so that the DECL_EXPR for a
5776 reference temp is added before the DECL_EXPR for the reference itself. */
5777 if (at_function_scope_p ())
5778 add_decl_expr (decl);
5780 /* Let the middle end know about variables and functions -- but not
5781 static data members in uninstantiated class templates. */
5782 if (!saved_processing_template_decl
5783 && (TREE_CODE (decl) == VAR_DECL
5784 || TREE_CODE (decl) == FUNCTION_DECL))
5786 if (TREE_CODE (decl) == VAR_DECL)
5788 layout_var_decl (decl);
5789 maybe_commonize_var (decl);
5792 /* This needs to happen after the linkage is set. */
5793 determine_visibility (decl);
5795 if (var_definition_p && TREE_STATIC (decl))
5797 /* If a TREE_READONLY variable needs initialization
5798 at runtime, it is no longer readonly and we need to
5799 avoid MEM_READONLY_P being set on RTL created for it. */
5802 if (TREE_READONLY (decl))
5803 TREE_READONLY (decl) = 0;
5806 else if (was_readonly)
5807 TREE_READONLY (decl) = 1;
5810 make_rtl_for_nonlocal_decl (decl, init, asmspec);
5812 /* Check for abstractness of the type. Notice that there is no
5813 need to strip array types here since the check for those types
5814 is already done within create_array_type_for_decl. */
5815 if (TREE_CODE (type) == FUNCTION_TYPE
5816 || TREE_CODE (type) == METHOD_TYPE)
5817 abstract_virtuals_error (decl, TREE_TYPE (type));
5819 abstract_virtuals_error (decl, type);
5821 if (TREE_TYPE (decl) == error_mark_node)
5822 /* No initialization required. */
5824 else if (TREE_CODE (decl) == FUNCTION_DECL)
5828 if (init == ridpointers[(int)RID_DEFAULT])
5830 /* An out-of-class default definition is defined at
5831 the point where it is explicitly defaulted. */
5832 if (DECL_INITIAL (decl) == error_mark_node)
5833 synthesize_method (decl);
5836 error ("function %q#D is initialized like a variable", decl);
5838 /* else no initialization required. */
5840 else if (DECL_EXTERNAL (decl)
5841 && ! (DECL_LANG_SPECIFIC (decl)
5842 && DECL_NOT_REALLY_EXTERN (decl)))
5845 DECL_INITIAL (decl) = init;
5847 /* A variable definition. */
5848 else if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
5849 /* Initialize the local variable. */
5850 initialize_local_var (decl, init);
5852 /* If a variable is defined, and then a subsequent
5853 definition with external linkage is encountered, we will
5854 get here twice for the same variable. We want to avoid
5855 calling expand_static_init more than once. For variables
5856 that are not static data members, we can call
5857 expand_static_init only when we actually process the
5858 initializer. It is not legal to redeclare a static data
5859 member, so this issue does not arise in that case. */
5860 else if (var_definition_p && TREE_STATIC (decl))
5861 expand_static_init (decl, init);
5864 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
5865 reference, insert it in the statement-tree now. */
5867 push_cleanup (decl, cleanup, false);
5870 processing_template_decl = saved_processing_template_decl;
5873 TREE_READONLY (decl) = 1;
5875 /* If this was marked 'used', be sure it will be output. */
5876 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
5877 mark_decl_referenced (decl);
5880 /* This is here for a midend callback from c-common.c. */
5883 finish_decl (tree decl, tree init, tree asmspec_tree)
5885 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, asmspec_tree, 0);
5888 /* Returns a declaration for a VAR_DECL as if:
5890 extern "C" TYPE NAME;
5892 had been seen. Used to create compiler-generated global
5896 declare_global_var (tree name, tree type)
5900 push_to_top_level ();
5901 decl = build_decl (VAR_DECL, name, type);
5902 TREE_PUBLIC (decl) = 1;
5903 DECL_EXTERNAL (decl) = 1;
5904 DECL_ARTIFICIAL (decl) = 1;
5905 /* If the user has explicitly declared this variable (perhaps
5906 because the code we are compiling is part of a low-level runtime
5907 library), then it is possible that our declaration will be merged
5908 with theirs by pushdecl. */
5909 decl = pushdecl (decl);
5910 finish_decl (decl, NULL_TREE, NULL_TREE);
5911 pop_from_top_level ();
5916 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
5917 if "__cxa_atexit" is not being used) corresponding to the function
5918 to be called when the program exits. */
5921 get_atexit_fn_ptr_type (void)
5926 if (!atexit_fn_ptr_type_node)
5928 if (flag_use_cxa_atexit
5929 && !targetm.cxx.use_atexit_for_cxa_atexit ())
5930 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
5931 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5933 /* The parameter to "atexit" is "void (*)(void)". */
5934 arg_types = void_list_node;
5936 fn_type = build_function_type (void_type_node, arg_types);
5937 atexit_fn_ptr_type_node = build_pointer_type (fn_type);
5940 return atexit_fn_ptr_type_node;
5943 /* Returns a pointer to the `atexit' function. Note that if
5944 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
5945 `__cxa_atexit' function specified in the IA64 C++ ABI. */
5948 get_atexit_node (void)
5955 bool use_aeabi_atexit;
5960 if (flag_use_cxa_atexit && !targetm.cxx.use_atexit_for_cxa_atexit ())
5962 /* The declaration for `__cxa_atexit' is:
5964 int __cxa_atexit (void (*)(void *), void *, void *)
5966 We build up the argument types and then then function type
5969 use_aeabi_atexit = targetm.cxx.use_aeabi_atexit ();
5970 /* First, build the pointer-to-function type for the first
5972 fn_ptr_type = get_atexit_fn_ptr_type ();
5973 /* Then, build the rest of the argument types. */
5974 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5975 if (use_aeabi_atexit)
5977 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
5978 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
5982 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
5983 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
5985 /* And the final __cxa_atexit type. */
5986 fn_type = build_function_type (integer_type_node, arg_types);
5987 fn_ptr_type = build_pointer_type (fn_type);
5988 if (use_aeabi_atexit)
5989 name = "__aeabi_atexit";
5991 name = "__cxa_atexit";
5995 /* The declaration for `atexit' is:
5997 int atexit (void (*)());
5999 We build up the argument types and then then function type
6001 fn_ptr_type = get_atexit_fn_ptr_type ();
6002 arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
6003 /* Build the final atexit type. */
6004 fn_type = build_function_type (integer_type_node, arg_types);
6008 /* Now, build the function declaration. */
6009 push_lang_context (lang_name_c);
6010 atexit_fndecl = build_library_fn_ptr (name, fn_type);
6011 mark_used (atexit_fndecl);
6012 pop_lang_context ();
6013 atexit_node = decay_conversion (atexit_fndecl);
6018 /* Returns the __dso_handle VAR_DECL. */
6021 get_dso_handle_node (void)
6023 if (dso_handle_node)
6024 return dso_handle_node;
6026 /* Declare the variable. */
6027 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
6030 return dso_handle_node;
6033 /* Begin a new function with internal linkage whose job will be simply
6034 to destroy some particular variable. */
6036 static GTY(()) int start_cleanup_cnt;
6039 start_cleanup_fn (void)
6044 bool use_cxa_atexit = flag_use_cxa_atexit
6045 && !targetm.cxx.use_atexit_for_cxa_atexit ();
6047 push_to_top_level ();
6049 /* No need to mangle this. */
6050 push_lang_context (lang_name_c);
6052 /* Build the name of the function. */
6053 sprintf (name, "__tcf_%d", start_cleanup_cnt++);
6054 /* Build the function declaration. */
6055 fntype = TREE_TYPE (get_atexit_fn_ptr_type ());
6056 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
6057 /* It's a function with internal linkage, generated by the
6059 TREE_PUBLIC (fndecl) = 0;
6060 DECL_ARTIFICIAL (fndecl) = 1;
6061 /* Make the function `inline' so that it is only emitted if it is
6062 actually needed. It is unlikely that it will be inlined, since
6063 it is only called via a function pointer, but we avoid unnecessary
6064 emissions this way. */
6065 DECL_DECLARED_INLINE_P (fndecl) = 1;
6066 DECL_INTERFACE_KNOWN (fndecl) = 1;
6067 /* Build the parameter. */
6072 parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
6073 DECL_CONTEXT (parmdecl) = fndecl;
6074 TREE_USED (parmdecl) = 1;
6075 DECL_ARGUMENTS (fndecl) = parmdecl;
6079 start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED);
6081 pop_lang_context ();
6083 return current_function_decl;
6086 /* Finish the cleanup function begun by start_cleanup_fn. */
6089 end_cleanup_fn (void)
6091 expand_or_defer_fn (finish_function (0));
6093 pop_from_top_level ();
6096 /* Generate code to handle the destruction of DECL, an object with
6097 static storage duration. */
6100 register_dtor_fn (tree decl)
6109 type = TREE_TYPE (decl);
6110 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
6111 return void_zero_node;
6113 /* If we're using "__cxa_atexit" (or "__aeabi_atexit"), and DECL is
6114 a class object, we can just pass the destructor to
6115 "__cxa_atexit"; we don't have to build a temporary function to do
6117 use_dtor = (flag_use_cxa_atexit
6118 && !targetm.cxx.use_atexit_for_cxa_atexit ()
6119 && CLASS_TYPE_P (type));
6124 /* Find the destructor. */
6125 idx = lookup_fnfields_1 (type, complete_dtor_identifier);
6126 gcc_assert (idx >= 0);
6127 cleanup = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), idx);
6128 /* Make sure it is accessible. */
6129 perform_or_defer_access_check (TYPE_BINFO (type), cleanup, cleanup);
6133 /* Call build_cleanup before we enter the anonymous function so
6134 that any access checks will be done relative to the current
6135 scope, rather than the scope of the anonymous function. */
6136 build_cleanup (decl);
6138 /* Now start the function. */
6139 cleanup = start_cleanup_fn ();
6141 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
6142 to the original function, rather than the anonymous one. That
6143 will make the back end think that nested functions are in use,
6144 which causes confusion. */
6145 push_deferring_access_checks (dk_no_check);
6146 fcall = build_cleanup (decl);
6147 pop_deferring_access_checks ();
6149 /* Create the body of the anonymous function. */
6150 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
6151 finish_expr_stmt (fcall);
6152 finish_compound_stmt (compound_stmt);
6156 /* Call atexit with the cleanup function. */
6157 mark_used (cleanup);
6158 cleanup = build_address (cleanup);
6159 if (flag_use_cxa_atexit && !targetm.cxx.use_atexit_for_cxa_atexit ())
6165 /* We must convert CLEANUP to the type that "__cxa_atexit"
6167 cleanup = build_nop (get_atexit_fn_ptr_type (), cleanup);
6168 /* "__cxa_atexit" will pass the address of DECL to the
6169 cleanup function. */
6171 addr = build_address (decl);
6172 /* The declared type of the parameter to "__cxa_atexit" is
6173 "void *". For plain "T*", we could just let the
6174 machinery in cp_build_function_call convert it -- but if the
6175 type is "cv-qualified T *", then we need to convert it
6176 before passing it in, to avoid spurious errors. */
6177 addr = build_nop (ptr_type_node, addr);
6180 /* Since the cleanup functions we build ignore the address
6181 they're given, there's no reason to pass the actual address
6182 in, and, in general, it's cheaper to pass NULL than any
6184 addr = null_pointer_node;
6185 args = tree_cons (NULL_TREE,
6186 cp_build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0,
6187 tf_warning_or_error),
6189 if (targetm.cxx.use_aeabi_atexit ())
6191 args = tree_cons (NULL_TREE, cleanup, args);
6192 args = tree_cons (NULL_TREE, addr, args);
6196 args = tree_cons (NULL_TREE, addr, args);
6197 args = tree_cons (NULL_TREE, cleanup, args);
6201 args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
6202 return cp_build_function_call (get_atexit_node (), args,
6203 tf_warning_or_error);
6206 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
6207 is its initializer. Generate code to handle the construction
6208 and destruction of DECL. */
6211 expand_static_init (tree decl, tree init)
6213 gcc_assert (TREE_CODE (decl) == VAR_DECL);
6214 gcc_assert (TREE_STATIC (decl));
6216 /* Some variables require no initialization. */
6218 && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
6219 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
6222 if (DECL_FUNCTION_SCOPE_P (decl))
6224 /* Emit code to perform this initialization but once. */
6225 tree if_stmt = NULL_TREE, inner_if_stmt = NULL_TREE;
6226 tree then_clause = NULL_TREE, inner_then_clause = NULL_TREE;
6227 tree guard, guard_addr;
6228 tree acquire_fn, release_fn, abort_fn;
6231 /* Emit code to perform this initialization but once. This code
6234 static <type> guard;
6235 if (!guard.first_byte) {
6236 if (__cxa_guard_acquire (&guard)) {
6239 // Do initialization.
6240 flag = true; __cxa_guard_release (&guard);
6241 // Register variable for destruction at end of program.
6243 if (!flag) __cxa_guard_abort (&guard);
6247 Note that the `flag' variable is only set to 1 *after* the
6248 initialization is complete. This ensures that an exception,
6249 thrown during the construction, will cause the variable to
6250 reinitialized when we pass through this code again, as per:
6254 If the initialization exits by throwing an exception, the
6255 initialization is not complete, so it will be tried again
6256 the next time control enters the declaration.
6258 This process should be thread-safe, too; multiple threads
6259 should not be able to initialize the variable more than
6262 /* Create the guard variable. */
6263 guard = get_guard (decl);
6265 /* This optimization isn't safe on targets with relaxed memory
6266 consistency. On such targets we force synchronization in
6267 __cxa_guard_acquire. */
6268 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
6270 /* Begin the conditional initialization. */
6271 if_stmt = begin_if_stmt ();
6272 finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
6273 then_clause = begin_compound_stmt (BCS_NO_SCOPE);
6276 if (flag_threadsafe_statics)
6278 guard_addr = build_address (guard);
6280 acquire_fn = get_identifier ("__cxa_guard_acquire");
6281 release_fn = get_identifier ("__cxa_guard_release");
6282 abort_fn = get_identifier ("__cxa_guard_abort");
6283 if (!get_global_value_if_present (acquire_fn, &acquire_fn))
6285 tree argtypes = tree_cons (NULL_TREE, TREE_TYPE (guard_addr),
6287 tree vfntype = build_function_type (void_type_node, argtypes);
6288 acquire_fn = push_library_fn
6289 (acquire_fn, build_function_type (integer_type_node, argtypes),
6291 release_fn = push_library_fn (release_fn, vfntype, NULL_TREE);
6292 abort_fn = push_library_fn (abort_fn, vfntype, NULL_TREE);
6296 release_fn = identifier_global_value (release_fn);
6297 abort_fn = identifier_global_value (abort_fn);
6300 inner_if_stmt = begin_if_stmt ();
6301 finish_if_stmt_cond (build_call_n (acquire_fn, 1, guard_addr),
6304 inner_then_clause = begin_compound_stmt (BCS_NO_SCOPE);
6305 begin = get_target_expr (boolean_false_node);
6306 flag = TARGET_EXPR_SLOT (begin);
6308 TARGET_EXPR_CLEANUP (begin)
6309 = build3 (COND_EXPR, void_type_node, flag,
6311 build_call_n (abort_fn, 1, guard_addr));
6312 CLEANUP_EH_ONLY (begin) = 1;
6314 /* Do the initialization itself. */
6315 init = add_stmt_to_compound (begin, init);
6316 init = add_stmt_to_compound
6317 (init, build2 (MODIFY_EXPR, void_type_node, flag, boolean_true_node));
6318 init = add_stmt_to_compound
6319 (init, build_call_n (release_fn, 1, guard_addr));
6322 init = add_stmt_to_compound (init, set_guard (guard));
6324 /* Use atexit to register a function for destroying this static
6326 init = add_stmt_to_compound (init, register_dtor_fn (decl));
6328 finish_expr_stmt (init);
6330 if (flag_threadsafe_statics)
6332 finish_compound_stmt (inner_then_clause);
6333 finish_then_clause (inner_if_stmt);
6334 finish_if_stmt (inner_if_stmt);
6337 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
6339 finish_compound_stmt (then_clause);
6340 finish_then_clause (if_stmt);
6341 finish_if_stmt (if_stmt);
6345 static_aggregates = tree_cons (init, decl, static_aggregates);
6349 /* Make TYPE a complete type based on INITIAL_VALUE.
6350 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6351 2 if there was no information (in which case assume 0 if DO_DEFAULT),
6352 3 if the initializer list is empty (in pedantic mode). */
6355 cp_complete_array_type (tree *ptype, tree initial_value, bool do_default)
6358 tree type, elt_type;
6362 unsigned HOST_WIDE_INT i;
6365 /* An array of character type can be initialized from a
6366 brace-enclosed string constant.
6368 FIXME: this code is duplicated from reshape_init. Probably
6369 we should just call reshape_init here? */
6370 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype)))
6371 && TREE_CODE (initial_value) == CONSTRUCTOR
6372 && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (initial_value)))
6374 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
6375 tree value = VEC_index (constructor_elt, v, 0)->value;
6377 if (TREE_CODE (value) == STRING_CST
6378 && VEC_length (constructor_elt, v) == 1)
6379 initial_value = value;
6382 /* If any of the elements are parameter packs, we can't actually
6383 complete this type now because the array size is dependent. */
6384 if (TREE_CODE (initial_value) == CONSTRUCTOR)
6386 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value),
6389 if (PACK_EXPANSION_P (value))
6395 failure = complete_array_type (ptype, initial_value, do_default);
6397 /* We can create the array before the element type is complete, which
6398 means that we didn't have these two bits set in the original type
6399 either. In completing the type, we are expected to propagate these
6400 bits. See also complete_type which does the same thing for arrays
6403 if (TYPE_DOMAIN (type))
6405 elt_type = TREE_TYPE (type);
6406 TYPE_NEEDS_CONSTRUCTING (type) = TYPE_NEEDS_CONSTRUCTING (elt_type);
6407 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
6408 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type);
6414 /* Return zero if something is declared to be a member of type
6415 CTYPE when in the context of CUR_TYPE. STRING is the error
6416 message to print in that case. Otherwise, quietly return 1. */
6419 member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
6421 if (ctype && ctype != cur_type)
6423 if (flags == DTOR_FLAG)
6424 error ("destructor for alien class %qT cannot be a member", ctype);
6426 error ("constructor for alien class %qT cannot be a member", ctype);
6432 /* Subroutine of `grokdeclarator'. */
6434 /* Generate errors possibly applicable for a given set of specifiers.
6435 This is for ARM $7.1.2. */
6438 bad_specifiers (tree object,
6447 error ("%qD declared as a %<virtual%> %s", object, type);
6449 error ("%qD declared as an %<inline%> %s", object, type);
6451 error ("%<const%> and %<volatile%> function specifiers on "
6452 "%qD invalid in %s declaration",
6455 error ("%q+D declared as a friend", object);
6457 && (TREE_CODE (object) == TYPE_DECL
6458 || (!TYPE_PTRFN_P (TREE_TYPE (object))
6459 && !TYPE_REFFN_P (TREE_TYPE (object))
6460 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
6461 error ("%q+D declared with an exception specification", object);
6464 /* DECL is a member function or static data member and is presently
6465 being defined. Check that the definition is taking place in a
6469 check_class_member_definition_namespace (tree decl)
6471 /* These checks only apply to member functions and static data
6473 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
6474 || TREE_CODE (decl) == VAR_DECL);
6475 /* We check for problems with specializations in pt.c in
6476 check_specialization_namespace, where we can issue better
6478 if (processing_specialization)
6480 /* There are no restrictions on the placement of
6481 explicit instantiations. */
6482 if (processing_explicit_instantiation)
6486 A member function definition that appears outside of the
6487 class definition shall appear in a namespace scope enclosing
6488 the class definition.
6492 The definition for a static data member shall appear in a
6493 namespace scope enclosing the member's class definition. */
6494 if (!is_ancestor (current_namespace, DECL_CONTEXT (decl)))
6495 permerror (input_location, "definition of %qD is not in namespace enclosing %qT",
6496 decl, DECL_CONTEXT (decl));
6499 /* Build a PARM_DECL for the "this" parameter. TYPE is the
6500 METHOD_TYPE for a non-static member function; QUALS are the
6501 cv-qualifiers that apply to the function. */
6504 build_this_parm (tree type, cp_cv_quals quals)
6509 cp_cv_quals this_quals;
6511 this_type = TREE_VALUE (TYPE_ARG_TYPES (type));
6512 /* The `this' parameter is implicitly `const'; it cannot be
6514 this_quals = (quals & TYPE_QUAL_RESTRICT) | TYPE_QUAL_CONST;
6515 qual_type = cp_build_qualified_type (this_type, this_quals);
6516 parm = build_artificial_parm (this_identifier, qual_type);
6517 cp_apply_type_quals_to_decl (this_quals, parm);
6521 /* CTYPE is class type, or null if non-class.
6522 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
6524 DECLARATOR is the function's name.
6525 PARMS is a chain of PARM_DECLs for the function.
6526 VIRTUALP is truthvalue of whether the function is virtual or not.
6527 FLAGS are to be passed through to `grokclassfn'.
6528 QUALS are qualifiers indicating whether the function is `const'
6530 RAISES is a list of exceptions that this function can raise.
6531 CHECK is 1 if we must find this method in CTYPE, 0 if we should
6532 not look, and -1 if we should not call `grokclassfn' at all.
6534 SFK is the kind of special function (if any) for the new function.
6536 Returns `NULL_TREE' if something goes wrong, after issuing
6537 applicable error messages. */
6540 grokfndecl (tree ctype,
6544 tree orig_declarator,
6546 enum overload_flags flags,
6553 special_function_kind sfk,
6558 location_t location)
6561 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
6565 type = build_exception_variant (type, raises);
6567 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
6569 /* If we have an explicit location, use it, otherwise use whatever
6570 build_lang_decl used (probably input_location). */
6571 if (location != UNKNOWN_LOCATION)
6572 DECL_SOURCE_LOCATION (decl) = location;
6574 if (TREE_CODE (type) == METHOD_TYPE)
6577 parm = build_this_parm (type, quals);
6578 TREE_CHAIN (parm) = parms;
6581 DECL_ARGUMENTS (decl) = parms;
6582 for (t = parms; t; t = TREE_CHAIN (t))
6583 DECL_CONTEXT (t) = decl;
6584 /* Propagate volatile out from type to decl. */
6585 if (TYPE_VOLATILE (type))
6586 TREE_THIS_VOLATILE (decl) = 1;
6588 /* Setup decl according to sfk. */
6591 case sfk_constructor:
6592 case sfk_copy_constructor:
6593 DECL_CONSTRUCTOR_P (decl) = 1;
6595 case sfk_destructor:
6596 DECL_DESTRUCTOR_P (decl) = 1;
6602 /* If pointers to member functions use the least significant bit to
6603 indicate whether a function is virtual, ensure a pointer
6604 to this function will have that bit clear. */
6605 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
6606 && TREE_CODE (type) == METHOD_TYPE
6607 && DECL_ALIGN (decl) < 2 * BITS_PER_UNIT)
6608 DECL_ALIGN (decl) = 2 * BITS_PER_UNIT;
6611 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
6615 ("defining explicit specialization %qD in friend declaration",
6619 tree fns = TREE_OPERAND (orig_declarator, 0);
6620 tree args = TREE_OPERAND (orig_declarator, 1);
6622 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
6624 /* Something like `template <class T> friend void f<T>()'. */
6625 error ("invalid use of template-id %qD in declaration "
6626 "of primary template",
6632 /* A friend declaration of the form friend void f<>(). Record
6633 the information in the TEMPLATE_ID_EXPR. */
6634 SET_DECL_IMPLICIT_INSTANTIATION (decl);
6636 if (TREE_CODE (fns) == COMPONENT_REF)
6638 /* Due to bison parser ickiness, we will have already looked
6639 up an operator_name or PFUNCNAME within the current class
6640 (see template_id in parse.y). If the current class contains
6641 such a name, we'll get a COMPONENT_REF here. Undo that. */
6643 gcc_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
6644 == current_class_type);
6645 fns = TREE_OPERAND (fns, 1);
6647 gcc_assert (TREE_CODE (fns) == IDENTIFIER_NODE
6648 || TREE_CODE (fns) == OVERLOAD);
6649 DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
6651 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
6652 if (TREE_PURPOSE (t)
6653 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
6655 error ("default arguments are not allowed in declaration "
6656 "of friend template specialization %qD",
6663 error ("%<inline%> is not allowed in declaration of friend "
6664 "template specialization %qD",
6671 /* If this decl has namespace scope, set that up. */
6673 set_decl_namespace (decl, in_namespace, friendp);
6675 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
6677 /* `main' and builtins have implicit 'C' linkage. */
6678 if ((MAIN_NAME_P (declarator)
6679 || (IDENTIFIER_LENGTH (declarator) > 10
6680 && IDENTIFIER_POINTER (declarator)[0] == '_'
6681 && IDENTIFIER_POINTER (declarator)[1] == '_'
6682 && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
6683 && current_lang_name == lang_name_cplusplus
6684 && ctype == NULL_TREE
6685 /* NULL_TREE means global namespace. */
6686 && DECL_CONTEXT (decl) == NULL_TREE)
6687 SET_DECL_LANGUAGE (decl, lang_c);
6689 /* Should probably propagate const out from type to decl I bet (mrs). */
6692 DECL_STATIC_FUNCTION_P (decl) = 1;
6693 DECL_CONTEXT (decl) = ctype;
6698 DECL_CONTEXT (decl) = ctype;
6700 check_class_member_definition_namespace (decl);
6703 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
6705 if (processing_template_decl)
6706 error ("cannot declare %<::main%> to be a template");
6708 error ("cannot declare %<::main%> to be inline");
6710 error ("cannot declare %<::main%> to be static");
6715 /* Members of anonymous types and local classes have no linkage; make
6716 them internal. If a typedef is made later, this will be changed. */
6717 if (ctype && (TYPE_ANONYMOUS_P (ctype)
6718 || decl_function_context (TYPE_MAIN_DECL (ctype))))
6723 /* [basic.link]: A name with no linkage (notably, the name of a class
6724 or enumeration declared in a local scope) shall not be used to
6725 declare an entity with linkage.
6727 Only check this for public decls for now. See core 319, 389. */
6728 t = no_linkage_check (TREE_TYPE (decl),
6729 /*relaxed_p=*/false);
6732 if (TYPE_ANONYMOUS_P (t))
6734 if (DECL_EXTERN_C_P (decl))
6735 /* Allow this; it's pretty common in C. */;
6738 permerror (input_location, "non-local function %q#D uses anonymous type",
6740 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
6741 permerror (input_location, "%q+#D does not refer to the unqualified "
6742 "type, so it is not used for linkage",
6747 permerror (input_location, "non-local function %q#D uses local type %qT", decl, t);
6751 TREE_PUBLIC (decl) = publicp;
6754 DECL_INTERFACE_KNOWN (decl) = 1;
6755 DECL_NOT_REALLY_EXTERN (decl) = 1;
6758 /* If the declaration was declared inline, mark it as such. */
6760 DECL_DECLARED_INLINE_P (decl) = 1;
6762 DECL_EXTERNAL (decl) = 1;
6763 if (quals && TREE_CODE (type) == FUNCTION_TYPE)
6766 ? G_("static member function %qD cannot have cv-qualifier")
6767 : G_("non-member function %qD cannot have cv-qualifier"),
6769 quals = TYPE_UNQUALIFIED;
6772 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl))
6773 && !grok_op_properties (decl, /*complain=*/true))
6776 if (ctype && decl_function_context (decl))
6777 DECL_NO_STATIC_CHAIN (decl) = 1;
6780 /* Make the init_value nonzero so pushdecl knows this is not
6781 tentative. error_mark_node is replaced later with the BLOCK. */
6782 DECL_INITIAL (decl) = error_mark_node;
6784 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
6785 TREE_NOTHROW (decl) = 1;
6787 /* Caller will do the rest of this. */
6791 if (ctype != NULL_TREE)
6792 grokclassfn (ctype, decl, flags);
6794 decl = check_explicit_specialization (orig_declarator, decl,
6797 4 * (friendp != 0));
6798 if (decl == error_mark_node)
6803 cplus_decl_attributes (&decl, *attrlist, 0);
6804 *attrlist = NULL_TREE;
6807 /* Check main's type after attributes have been applied. */
6808 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
6810 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
6813 tree oldtypeargs = TYPE_ARG_TYPES (TREE_TYPE (decl));
6815 error ("%<::main%> must return %<int%>");
6816 newtype = build_function_type (integer_type_node, oldtypeargs);
6817 TREE_TYPE (decl) = newtype;
6820 check_main_parameter_types (decl);
6823 if (ctype != NULL_TREE
6824 && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
6827 tree old_decl = check_classfn (ctype, decl,
6828 (processing_template_decl
6829 > template_class_depth (ctype))
6830 ? current_template_parms
6833 if (old_decl == error_mark_node)
6841 if (TREE_CODE (old_decl) == TEMPLATE_DECL)
6842 /* Because grokfndecl is always supposed to return a
6843 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
6844 here. We depend on our callers to figure out that its
6845 really a template that's being returned. */
6846 old_decl = DECL_TEMPLATE_RESULT (old_decl);
6848 if (DECL_STATIC_FUNCTION_P (old_decl)
6849 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
6850 /* Remove the `this' parm added by grokclassfn.
6851 XXX Isn't this done in start_function, too? */
6852 revert_static_member_fn (decl);
6853 if (DECL_ARTIFICIAL (old_decl))
6855 error ("definition of implicitly-declared %qD", old_decl);
6859 /* Since we've smashed OLD_DECL to its
6860 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
6861 if (TREE_CODE (decl) == TEMPLATE_DECL)
6862 decl = DECL_TEMPLATE_RESULT (decl);
6864 /* Attempt to merge the declarations. This can fail, in
6865 the case of some invalid specialization declarations. */
6866 pushed_scope = push_scope (ctype);
6867 ok = duplicate_decls (decl, old_decl, friendp);
6869 pop_scope (pushed_scope);
6872 error ("no %q#D member function declared in class %qT",
6880 if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
6883 if (ctype == NULL_TREE || check)
6887 DECL_VIRTUAL_P (decl) = 1;
6892 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
6893 the linkage that DECL will receive in the object file. */
6896 set_linkage_for_static_data_member (tree decl)
6898 /* A static data member always has static storage duration and
6899 external linkage. Note that static data members are forbidden in
6900 local classes -- the only situation in which a class has
6901 non-external linkage. */
6902 TREE_PUBLIC (decl) = 1;
6903 TREE_STATIC (decl) = 1;
6904 /* For non-template classes, static data members are always put
6905 out in exactly those files where they are defined, just as
6906 with ordinary namespace-scope variables. */
6907 if (!processing_template_decl)
6908 DECL_INTERFACE_KNOWN (decl) = 1;
6911 /* Create a VAR_DECL named NAME with the indicated TYPE.
6913 If SCOPE is non-NULL, it is the class type or namespace containing
6914 the variable. If SCOPE is NULL, the variable should is created in
6915 the innermost enclosings scope. */
6918 grokvardecl (tree type,
6920 const cp_decl_specifier_seq *declspecs,
6926 tree explicit_scope;
6928 gcc_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE);
6930 /* Compute the scope in which to place the variable, but remember
6931 whether or not that scope was explicitly specified by the user. */
6932 explicit_scope = scope;
6935 /* An explicit "extern" specifier indicates a namespace-scope
6937 if (declspecs->storage_class == sc_extern)
6938 scope = current_namespace;
6939 else if (!at_function_scope_p ())
6940 scope = current_scope ();
6944 && (/* If the variable is a namespace-scope variable declared in a
6945 template, we need DECL_LANG_SPECIFIC. */
6946 (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
6947 /* Similarly for namespace-scope variables with language linkage
6949 || (TREE_CODE (scope) == NAMESPACE_DECL
6950 && current_lang_name != lang_name_cplusplus)
6951 /* Similarly for static data members. */
6953 decl = build_lang_decl (VAR_DECL, name, type);
6955 decl = build_decl (VAR_DECL, name, type);
6957 if (explicit_scope && TREE_CODE (explicit_scope) == NAMESPACE_DECL)
6958 set_decl_namespace (decl, explicit_scope, 0);
6960 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
6962 if (declspecs->storage_class == sc_extern)
6964 DECL_THIS_EXTERN (decl) = 1;
6965 DECL_EXTERNAL (decl) = !initialized;
6968 if (DECL_CLASS_SCOPE_P (decl))
6970 set_linkage_for_static_data_member (decl);
6971 /* This function is only called with out-of-class definitions. */
6972 DECL_EXTERNAL (decl) = 0;
6973 check_class_member_definition_namespace (decl);
6975 /* At top level, either `static' or no s.c. makes a definition
6976 (perhaps tentative), and absence of `static' makes it public. */
6977 else if (toplevel_bindings_p ())
6979 TREE_PUBLIC (decl) = (declspecs->storage_class != sc_static
6980 && (DECL_THIS_EXTERN (decl) || ! constp));
6981 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
6983 /* Not at top level, only `static' makes a static definition. */
6986 TREE_STATIC (decl) = declspecs->storage_class == sc_static;
6987 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
6990 if (declspecs->specs[(int)ds_thread])
6991 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
6993 if (TREE_PUBLIC (decl))
6995 /* [basic.link]: A name with no linkage (notably, the name of a class
6996 or enumeration declared in a local scope) shall not be used to
6997 declare an entity with linkage.
6999 Only check this for public decls for now. */
7000 tree t = no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false);
7003 if (TYPE_ANONYMOUS_P (t))
7005 if (DECL_EXTERN_C_P (decl))
7006 /* Allow this; it's pretty common in C. */
7010 /* DRs 132, 319 and 389 seem to indicate types with
7011 no linkage can only be used to declare extern "C"
7012 entities. Since it's not always an error in the
7013 ISO C++ 90 Standard, we only issue a warning. */
7014 warning (0, "non-local variable %q#D uses anonymous type",
7016 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
7017 warning (0, "%q+#D does not refer to the unqualified "
7018 "type, so it is not used for linkage",
7023 warning (0, "non-local variable %q#D uses local type %qT", decl, t);
7027 DECL_INTERFACE_KNOWN (decl) = 1;
7032 /* Create and return a canonical pointer to member function type, for
7033 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
7036 build_ptrmemfunc_type (tree type)
7040 tree unqualified_variant = NULL_TREE;
7042 if (type == error_mark_node)
7045 /* If a canonical type already exists for this type, use it. We use
7046 this method instead of type_hash_canon, because it only does a
7047 simple equality check on the list of field members. */
7049 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
7052 /* Make sure that we always have the unqualified pointer-to-member
7054 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
7056 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
7058 t = make_class_type (RECORD_TYPE);
7059 xref_basetypes (t, NULL_TREE);
7061 /* Let the front end know this is a pointer to member function... */
7062 TYPE_PTRMEMFUNC_FLAG (t) = 1;
7063 /* ... and not really a class type. */
7064 SET_CLASS_TYPE_P (t, 0);
7066 field = build_decl (FIELD_DECL, pfn_identifier, type);
7069 field = build_decl (FIELD_DECL, delta_identifier, delta_type_node);
7070 TREE_CHAIN (field) = fields;
7073 finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
7075 /* Zap out the name so that the back end will give us the debugging
7076 information for this anonymous RECORD_TYPE. */
7077 TYPE_NAME (t) = NULL_TREE;
7079 /* If this is not the unqualified form of this pointer-to-member
7080 type, set the TYPE_MAIN_VARIANT for this type to be the
7081 unqualified type. Since they are actually RECORD_TYPEs that are
7082 not variants of each other, we must do this manually. */
7083 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
7085 t = build_qualified_type (t, cp_type_quals (type));
7086 TYPE_MAIN_VARIANT (t) = unqualified_variant;
7087 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
7088 TYPE_NEXT_VARIANT (unqualified_variant) = t;
7089 TREE_TYPE (TYPE_BINFO (t)) = t;
7092 /* Cache this pointer-to-member type so that we can find it again
7094 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
7096 if (TYPE_STRUCTURAL_EQUALITY_P (type))
7097 SET_TYPE_STRUCTURAL_EQUALITY (t);
7098 else if (TYPE_CANONICAL (type) != type)
7099 TYPE_CANONICAL (t) = build_ptrmemfunc_type (TYPE_CANONICAL (type));
7104 /* Create and return a pointer to data member type. */
7107 build_ptrmem_type (tree class_type, tree member_type)
7109 if (TREE_CODE (member_type) == METHOD_TYPE)
7113 arg_types = TYPE_ARG_TYPES (member_type);
7114 class_type = (cp_build_qualified_type
7116 cp_type_quals (TREE_TYPE (TREE_VALUE (arg_types)))));
7118 = build_method_type_directly (class_type,
7119 TREE_TYPE (member_type),
7120 TREE_CHAIN (arg_types));
7121 return build_ptrmemfunc_type (build_pointer_type (member_type));
7125 gcc_assert (TREE_CODE (member_type) != FUNCTION_TYPE);
7126 return build_offset_type (class_type, member_type);
7130 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
7131 Check to see that the definition is valid. Issue appropriate error
7132 messages. Return 1 if the definition is particularly bad, or 0
7136 check_static_variable_definition (tree decl, tree type)
7138 /* Motion 10 at San Diego: If a static const integral data member is
7139 initialized with an integral constant expression, the initializer
7140 may appear either in the declaration (within the class), or in
7141 the definition, but not both. If it appears in the class, the
7142 member is a member constant. The file-scope definition is always
7144 if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
7146 error ("invalid in-class initialization of static data member "
7147 "of non-integral type %qT",
7149 /* If we just return the declaration, crashes will sometimes
7150 occur. We therefore return void_type_node, as if this were a
7151 friend declaration, to cause callers to completely ignore
7152 this declaration. */
7155 else if (!CP_TYPE_CONST_P (type))
7156 error ("ISO C++ forbids in-class initialization of non-const "
7157 "static member %qD",
7159 else if (!INTEGRAL_TYPE_P (type))
7160 pedwarn (input_location, OPT_pedantic, "ISO C++ forbids initialization of member constant "
7161 "%qD of non-integral type %qT", decl, type);
7166 /* Given the SIZE (i.e., number of elements) in an array, compute an
7167 appropriate index type for the array. If non-NULL, NAME is the
7168 name of the thing being declared. */
7171 compute_array_index_type (tree name, tree size)
7175 tree abi_1_itype = NULL_TREE;
7177 if (error_operand_p (size))
7178 return error_mark_node;
7180 type = TREE_TYPE (size);
7181 /* The array bound must be an integer type. */
7182 if (!dependent_type_p (type) && !INTEGRAL_TYPE_P (type))
7185 error ("size of array %qD has non-integral type %qT", name, type);
7187 error ("size of array has non-integral type %qT", type);
7188 size = integer_one_node;
7189 type = TREE_TYPE (size);
7192 /* We can only call value_dependent_expression_p on integral constant
7193 expressions; the parser adds a dummy NOP_EXPR with TREE_SIDE_EFFECTS
7194 set if this isn't one. */
7195 if (processing_template_decl
7196 && (TREE_SIDE_EFFECTS (size) || value_dependent_expression_p (size)))
7198 /* We cannot do any checking for a SIZE that isn't known to be
7199 constant. Just build the index type and mark that it requires
7200 structural equality checks. */
7201 itype = build_index_type (build_min (MINUS_EXPR, sizetype,
7202 size, integer_one_node));
7203 if (!TREE_SIDE_EFFECTS (size))
7205 TYPE_DEPENDENT_P (itype) = 1;
7206 TYPE_DEPENDENT_P_VALID (itype) = 1;
7208 SET_TYPE_STRUCTURAL_EQUALITY (itype);
7212 if (!abi_version_at_least (2) && processing_template_decl)
7213 /* For abi-1, we handled all instances in templates the same way,
7214 even when they were non-dependent. This affects the manglings
7215 produced. So, we do the normal checking for non-dependent
7216 sizes, but at the end we'll return the same type that abi-1
7217 would have, but with TYPE_CANONICAL set to the "right"
7218 value that the current ABI would provide. */
7219 abi_1_itype = build_index_type (build_min (MINUS_EXPR, sizetype,
7220 size, integer_one_node));
7222 /* The size might be the result of a cast. */
7223 STRIP_TYPE_NOPS (size);
7225 /* It might be a const variable or enumeration constant. */
7226 size = integral_constant_value (size);
7228 /* Normally, the array-bound will be a constant. */
7229 if (TREE_CODE (size) == INTEGER_CST)
7231 /* Check to see if the array bound overflowed. Make that an
7232 error, no matter how generous we're being. */
7233 constant_expression_error (size);
7235 /* An array must have a positive number of elements. */
7236 if (INT_CST_LT (size, integer_zero_node))
7239 error ("size of array %qD is negative", name);
7241 error ("size of array is negative");
7242 size = integer_one_node;
7244 /* As an extension we allow zero-sized arrays. We always allow
7245 them in system headers because glibc uses them. */
7246 else if (integer_zerop (size) && !in_system_header)
7249 pedwarn (input_location, OPT_pedantic, "ISO C++ forbids zero-size array %qD", name);
7251 pedwarn (input_location, OPT_pedantic, "ISO C++ forbids zero-size array");
7254 else if (TREE_CONSTANT (size))
7256 /* `(int) &fn' is not a valid array bound. */
7258 error ("size of array %qD is not an integral constant-expression",
7261 error ("size of array is not an integral constant-expression");
7262 size = integer_one_node;
7264 else if (pedantic && warn_vla != 0)
7267 pedwarn (input_location, OPT_Wvla, "ISO C++ forbids variable length array %qD", name);
7269 pedwarn (input_location, OPT_Wvla, "ISO C++ forbids variable length array");
7271 else if (warn_vla > 0)
7275 "variable length array %qD is used", name);
7278 "variable length array is used");
7281 if (processing_template_decl && !TREE_CONSTANT (size))
7282 /* A variable sized array. */
7283 itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node);
7286 HOST_WIDE_INT saved_processing_template_decl;
7288 /* Compute the index of the largest element in the array. It is
7289 one less than the number of elements in the array. We save
7290 and restore PROCESSING_TEMPLATE_DECL so that computations in
7291 cp_build_binary_op will be appropriately folded. */
7292 saved_processing_template_decl = processing_template_decl;
7293 processing_template_decl = 0;
7294 itype = cp_build_binary_op (input_location,
7296 cp_convert (ssizetype, size),
7297 cp_convert (ssizetype, integer_one_node),
7298 tf_warning_or_error);
7299 itype = fold (itype);
7300 processing_template_decl = saved_processing_template_decl;
7302 if (!TREE_CONSTANT (itype))
7303 /* A variable sized array. */
7304 itype = variable_size (itype);
7305 /* Make sure that there was no overflow when creating to a signed
7306 index type. (For example, on a 32-bit machine, an array with
7307 size 2^32 - 1 is too big.) */
7308 else if (TREE_CODE (itype) == INTEGER_CST
7309 && TREE_OVERFLOW (itype))
7311 error ("overflow in array dimension");
7312 TREE_OVERFLOW (itype) = 0;
7316 /* Create and return the appropriate index type. */
7319 tree t = build_index_type (itype);
7320 TYPE_CANONICAL (abi_1_itype) = TYPE_CANONICAL (t);
7324 return build_index_type (itype);
7327 /* Returns the scope (if any) in which the entity declared by
7328 DECLARATOR will be located. If the entity was declared with an
7329 unqualified name, NULL_TREE is returned. */
7332 get_scope_of_declarator (const cp_declarator *declarator)
7334 while (declarator && declarator->kind != cdk_id)
7335 declarator = declarator->declarator;
7337 /* If the declarator-id is a SCOPE_REF, the scope in which the
7338 declaration occurs is the first operand. */
7340 && declarator->u.id.qualifying_scope)
7341 return declarator->u.id.qualifying_scope;
7343 /* Otherwise, the declarator is not a qualified name; the entity will
7344 be declared in the current scope. */
7348 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
7349 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
7353 create_array_type_for_decl (tree name, tree type, tree size)
7355 tree itype = NULL_TREE;
7356 const char* error_msg;
7358 /* If things have already gone awry, bail now. */
7359 if (type == error_mark_node || size == error_mark_node)
7360 return error_mark_node;
7362 /* Assume that everything will go OK. */
7365 /* There are some types which cannot be array elements. */
7366 switch (TREE_CODE (type))
7369 error_msg = "array of void";
7373 error_msg = "array of functions";
7376 case REFERENCE_TYPE:
7377 error_msg = "array of references";
7381 error_msg = "array of function members";
7388 /* If something went wrong, issue an error-message and return. */
7392 error ("declaration of %qD as %s", name, error_msg);
7394 error ("creating %s", error_msg);
7396 return error_mark_node;
7401 The constant expressions that specify the bounds of the arrays
7402 can be omitted only for the first member of the sequence. */
7403 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
7406 error ("declaration of %qD as multidimensional array must "
7407 "have bounds for all dimensions except the first",
7410 error ("multidimensional array must have bounds for all "
7411 "dimensions except the first");
7413 return error_mark_node;
7416 /* Figure out the index type for the array. */
7418 itype = compute_array_index_type (name, size);
7421 T is called the array element type; this type shall not be [...] an
7422 abstract class type. */
7423 abstract_virtuals_error (name, type);
7425 return build_cplus_array_type (type, itype);
7428 /* Check that it's OK to declare a function with the indicated TYPE.
7429 SFK indicates the kind of special function (if any) that this
7430 function is. OPTYPE is the type given in a conversion operator
7431 declaration, or the class type for a constructor/destructor.
7432 Returns the actual return type of the function; that
7433 may be different than TYPE if an error occurs, or for certain
7434 special functions. */
7437 check_special_function_return_type (special_function_kind sfk,
7443 case sfk_constructor:
7445 error ("return type specification for constructor invalid");
7447 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
7448 type = build_pointer_type (optype);
7450 type = void_type_node;
7453 case sfk_destructor:
7455 error ("return type specification for destructor invalid");
7456 /* We can't use the proper return type here because we run into
7457 problems with ambiguous bases and covariant returns.
7458 Java classes are left unchanged because (void *) isn't a valid
7459 Java type, and we don't want to change the Java ABI. */
7460 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
7461 type = build_pointer_type (void_type_node);
7463 type = void_type_node;
7466 case sfk_conversion:
7468 error ("return type specified for %<operator %T%>", optype);
7479 /* A variable or data member (whose unqualified name is IDENTIFIER)
7480 has been declared with the indicated TYPE. If the TYPE is not
7481 acceptable, issue an error message and return a type to use for
7482 error-recovery purposes. */
7485 check_var_type (tree identifier, tree type)
7487 if (VOID_TYPE_P (type))
7490 error ("unnamed variable or field declared void");
7491 else if (TREE_CODE (identifier) == IDENTIFIER_NODE)
7493 gcc_assert (!IDENTIFIER_OPNAME_P (identifier));
7494 error ("variable or field %qE declared void", identifier);
7497 error ("variable or field declared void");
7498 type = error_mark_node;
7504 /* Given declspecs and a declarator (abstract or otherwise), determine
7505 the name and type of the object declared and construct a DECL node
7508 DECLSPECS points to the representation of declaration-specifier
7509 sequence that precedes declarator.
7511 DECL_CONTEXT says which syntactic context this declaration is in:
7512 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
7513 FUNCDEF for a function definition. Like NORMAL but a few different
7514 error messages in each case. Return value may be zero meaning
7515 this definition is too screwy to try to parse.
7516 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
7517 handle member functions (which have FIELD context).
7518 Return value may be zero meaning this definition is too screwy to
7520 PARM for a parameter declaration (either within a function prototype
7521 or before a function body). Make a PARM_DECL, or return void_type_node.
7522 CATCHPARM for a parameter declaration before a catch clause.
7523 TYPENAME if for a typename (in a cast or sizeof).
7524 Don't make a DECL node; just return the ..._TYPE node.
7525 FIELD for a struct or union field; make a FIELD_DECL.
7526 BITFIELD for a field with specified width.
7527 INITIALIZED is as for start_decl.
7529 ATTRLIST is a pointer to the list of attributes, which may be NULL
7530 if there are none; *ATTRLIST may be modified if attributes from inside
7531 the declarator should be applied to the declaration.
7533 When this function is called, scoping variables (such as
7534 CURRENT_CLASS_TYPE) should reflect the scope in which the
7535 declaration occurs, not the scope in which the new declaration will
7536 be placed. For example, on:
7540 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
7543 Returns a DECL (if a declarator is present), a TYPE (if there is no
7544 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
7548 grokdeclarator (const cp_declarator *declarator,
7549 const cp_decl_specifier_seq *declspecs,
7550 enum decl_context decl_context,
7554 tree type = NULL_TREE;
7556 int virtualp, explicitp, friendp, inlinep, staticp;
7557 int explicit_int = 0;
7558 int explicit_char = 0;
7559 int defaulted_int = 0;
7560 tree dependent_name = NULL_TREE;
7562 tree typedef_decl = NULL_TREE;
7563 const char *name = NULL;
7564 tree typedef_type = NULL_TREE;
7565 /* True if this declarator is a function definition. */
7566 bool funcdef_flag = false;
7567 cp_declarator_kind innermost_code = cdk_error;
7570 /* See the code below that used this. */
7571 tree decl_attr = NULL_TREE;
7574 /* Keep track of what sort of function is being processed
7575 so that we can warn about default return values, or explicit
7576 return values which do not match prescribed defaults. */
7577 special_function_kind sfk = sfk_none;
7579 tree dname = NULL_TREE;
7580 tree ctor_return_type = NULL_TREE;
7581 enum overload_flags flags = NO_SPECIAL;
7582 /* cv-qualifiers that apply to the declarator, for a declaration of
7583 a member function. */
7584 cp_cv_quals memfn_quals = TYPE_UNQUALIFIED;
7585 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
7587 tree raises = NULL_TREE;
7588 int template_count = 0;
7589 tree returned_attrs = NULL_TREE;
7590 tree parms = NULL_TREE;
7591 const cp_declarator *id_declarator;
7592 /* The unqualified name of the declarator; either an
7593 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
7594 tree unqualified_id;
7595 /* The class type, if any, in which this entity is located,
7596 or NULL_TREE if none. Note that this value may be different from
7597 the current class type; for example if an attempt is made to declare
7598 "A::f" inside "B", this value will be "A". */
7599 tree ctype = current_class_type;
7600 /* The NAMESPACE_DECL for the namespace in which this entity is
7601 located. If an unqualified name is used to declare the entity,
7602 this value will be NULL_TREE, even if the entity is located at
7604 tree in_namespace = NULL_TREE;
7605 cp_storage_class storage_class;
7606 bool unsigned_p, signed_p, short_p, long_p, thread_p;
7607 bool type_was_error_mark_node = false;
7608 bool parameter_pack_p = declarator? declarator->parameter_pack_p : false;
7609 bool set_no_warning = false;
7610 bool template_type_arg = false;
7612 signed_p = declspecs->specs[(int)ds_signed];
7613 unsigned_p = declspecs->specs[(int)ds_unsigned];
7614 short_p = declspecs->specs[(int)ds_short];
7615 long_p = declspecs->specs[(int)ds_long];
7616 longlong = declspecs->specs[(int)ds_long] >= 2;
7617 thread_p = declspecs->specs[(int)ds_thread];
7619 if (decl_context == FUNCDEF)
7620 funcdef_flag = true, decl_context = NORMAL;
7621 else if (decl_context == MEMFUNCDEF)
7622 funcdef_flag = true, decl_context = FIELD;
7623 else if (decl_context == BITFIELD)
7624 bitfield = 1, decl_context = FIELD;
7625 else if (decl_context == TEMPLATE_TYPE_ARG)
7626 template_type_arg = true, decl_context = TYPENAME;
7628 if (initialized > 1)
7629 funcdef_flag = true;
7631 /* Look inside a declarator for the name being declared
7632 and get it as a string, for an error message. */
7633 for (id_declarator = declarator;
7635 id_declarator = id_declarator->declarator)
7637 if (id_declarator->kind != cdk_id)
7638 innermost_code = id_declarator->kind;
7640 switch (id_declarator->kind)
7643 if (id_declarator->declarator
7644 && id_declarator->declarator->kind == cdk_id)
7646 sfk = id_declarator->declarator->u.id.sfk;
7647 if (sfk == sfk_destructor)
7654 tree qualifying_scope = id_declarator->u.id.qualifying_scope;
7655 tree decl = id_declarator->u.id.unqualified_name;
7658 if (qualifying_scope)
7660 if (at_function_scope_p ())
7664 A declarator-id shall not be qualified except
7667 None of the cases are permitted in block
7669 if (qualifying_scope == global_namespace)
7670 error ("invalid use of qualified-name %<::%D%>",
7672 else if (TYPE_P (qualifying_scope))
7673 error ("invalid use of qualified-name %<%T::%D%>",
7674 qualifying_scope, decl);
7676 error ("invalid use of qualified-name %<%D::%D%>",
7677 qualifying_scope, decl);
7678 return error_mark_node;
7680 else if (TYPE_P (qualifying_scope))
7682 ctype = qualifying_scope;
7683 if (innermost_code != cdk_function
7684 && current_class_type
7685 && !UNIQUELY_DERIVED_FROM_P (ctype,
7686 current_class_type))
7688 error ("type %qT is not derived from type %qT",
7689 ctype, current_class_type);
7690 return error_mark_node;
7693 else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL)
7694 in_namespace = qualifying_scope;
7696 switch (TREE_CODE (decl))
7702 if (innermost_code != cdk_function)
7704 error ("declaration of %qD as non-function", decl);
7705 return error_mark_node;
7707 else if (!qualifying_scope
7708 && !(current_class_type && at_class_scope_p ()))
7710 error ("declaration of %qD as non-member", decl);
7711 return error_mark_node;
7714 type = TREE_OPERAND (decl, 0);
7716 type = constructor_name (type);
7717 name = IDENTIFIER_POINTER (type);
7722 case TEMPLATE_ID_EXPR:
7724 tree fns = TREE_OPERAND (decl, 0);
7727 if (TREE_CODE (dname) != IDENTIFIER_NODE)
7729 gcc_assert (is_overloaded_fn (dname));
7730 dname = DECL_NAME (get_first_fn (dname));
7735 case IDENTIFIER_NODE:
7736 if (TREE_CODE (decl) == IDENTIFIER_NODE)
7739 if (C_IS_RESERVED_WORD (dname))
7741 error ("declarator-id missing; using reserved word %qD",
7743 name = IDENTIFIER_POINTER (dname);
7745 else if (!IDENTIFIER_TYPENAME_P (dname))
7746 name = IDENTIFIER_POINTER (dname);
7749 gcc_assert (flags == NO_SPECIAL);
7750 flags = TYPENAME_FLAG;
7751 ctor_return_type = TREE_TYPE (dname);
7752 sfk = sfk_conversion;
7753 if (is_typename_at_global_scope (dname))
7754 name = IDENTIFIER_POINTER (dname);
7756 name = "<invalid operator>";
7773 return error_mark_node;
7778 if (id_declarator->kind == cdk_id)
7784 The declarator in a function-definition shall have the form
7785 D1 ( parameter-declaration-clause) ... */
7786 if (funcdef_flag && innermost_code != cdk_function)
7788 error ("function definition does not declare parameters");
7789 return error_mark_node;
7792 if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
7793 && innermost_code != cdk_function
7794 && ! (ctype && !declspecs->any_specifiers_p))
7796 error ("declaration of %qD as non-function", dname);
7797 return error_mark_node;
7800 /* Anything declared one level down from the top level
7801 must be one of the parameters of a function
7802 (because the body is at least two levels down). */
7804 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
7805 by not allowing C++ class definitions to specify their parameters
7806 with xdecls (must be spec.d in the parmlist).
7808 Since we now wait to push a class scope until we are sure that
7809 we are in a legitimate method context, we must set oldcname
7810 explicitly (since current_class_name is not yet alive).
7812 We also want to avoid calling this a PARM if it is in a namespace. */
7814 if (decl_context == NORMAL && !toplevel_bindings_p ())
7816 struct cp_binding_level *b = current_binding_level;
7817 current_binding_level = b->level_chain;
7818 if (current_binding_level != 0 && toplevel_bindings_p ())
7819 decl_context = PARM;
7820 current_binding_level = b;
7824 name = decl_context == PARM ? "parameter" : "type name";
7826 /* If there were multiple types specified in the decl-specifier-seq,
7827 issue an error message. */
7828 if (declspecs->multiple_types_p)
7830 error ("two or more data types in declaration of %qs", name);
7831 return error_mark_node;
7834 if (declspecs->conflicting_specifiers_p)
7836 error ("conflicting specifiers in declaration of %qs", name);
7837 return error_mark_node;
7840 /* Extract the basic type from the decl-specifier-seq. */
7841 type = declspecs->type;
7842 if (type == error_mark_node)
7845 type_was_error_mark_node = true;
7847 /* If the entire declaration is itself tagged as deprecated then
7848 suppress reports of deprecated items. */
7849 if (type && TREE_DEPRECATED (type)
7850 && deprecated_state != DEPRECATED_SUPPRESS)
7851 warn_deprecated_use (type);
7852 if (type && TREE_CODE (type) == TYPE_DECL)
7854 typedef_decl = type;
7855 type = TREE_TYPE (typedef_decl);
7856 if (TREE_DEPRECATED (type)
7857 && DECL_ARTIFICIAL (typedef_decl)
7858 && deprecated_state != DEPRECATED_SUPPRESS)
7859 warn_deprecated_use (type);
7861 /* No type at all: default to `int', and set DEFAULTED_INT
7862 because it was not a user-defined typedef. */
7863 if (type == NULL_TREE && (signed_p || unsigned_p || long_p || short_p))
7865 /* These imply 'int'. */
7866 type = integer_type_node;
7870 explicit_int = declspecs->explicit_int_p;
7871 explicit_char = declspecs->explicit_char_p;
7874 /* See the code below that used this. */
7876 decl_attr = DECL_ATTRIBUTES (typedef_decl);
7878 typedef_type = type;
7881 if (sfk != sfk_conversion)
7882 ctor_return_type = ctype;
7884 if (sfk != sfk_none)
7885 type = check_special_function_return_type (sfk, type,
7887 else if (type == NULL_TREE)
7893 /* We handle `main' specially here, because 'main () { }' is so
7894 common. With no options, it is allowed. With -Wreturn-type,
7895 it is a warning. It is only an error with -pedantic-errors. */
7896 is_main = (funcdef_flag
7897 && dname && MAIN_NAME_P (dname)
7898 && ctype == NULL_TREE
7899 && in_namespace == NULL_TREE
7900 && current_namespace == global_namespace);
7902 if (type_was_error_mark_node)
7903 /* We've already issued an error, don't complain more. */;
7904 else if (in_system_header || flag_ms_extensions)
7905 /* Allow it, sigh. */;
7907 permerror (input_location, "ISO C++ forbids declaration of %qs with no type", name);
7909 pedwarn (input_location, OPT_pedantic,
7910 "ISO C++ forbids declaration of %qs with no type", name);
7912 warning (OPT_Wreturn_type,
7913 "ISO C++ forbids declaration of %qs with no type", name);
7915 type = integer_type_node;
7920 /* Now process the modifiers that were specified
7921 and check for invalid combinations. */
7923 /* Long double is a special combination. */
7924 if (long_p && !longlong && TYPE_MAIN_VARIANT (type) == double_type_node)
7927 type = build_qualified_type (long_double_type_node,
7928 cp_type_quals (type));
7931 /* Check all other uses of type modifiers. */
7933 if (unsigned_p || signed_p || long_p || short_p)
7937 if ((signed_p || unsigned_p) && TREE_CODE (type) != INTEGER_TYPE)
7938 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
7939 else if (signed_p && unsigned_p)
7940 error ("%<signed%> and %<unsigned%> specified together for %qs", name);
7941 else if (longlong && TREE_CODE (type) != INTEGER_TYPE)
7942 error ("%<long long%> invalid for %qs", name);
7943 else if (long_p && TREE_CODE (type) == REAL_TYPE)
7944 error ("%<long%> invalid for %qs", name);
7945 else if (short_p && TREE_CODE (type) == REAL_TYPE)
7946 error ("%<short%> invalid for %qs", name);
7947 else if ((long_p || short_p) && TREE_CODE (type) != INTEGER_TYPE)
7948 error ("%<long%> or %<short%> invalid for %qs", name);
7949 else if ((long_p || short_p) && explicit_char)
7950 error ("%<long%> or %<short%> specified with char for %qs", name);
7951 else if (long_p && short_p)
7952 error ("%<long%> and %<short%> specified together for %qs", name);
7953 else if (type == char16_type_node || type == char32_type_node)
7955 if (signed_p || unsigned_p)
7956 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
7957 else if (short_p || long_p)
7958 error ("%<short%> or %<long%> invalid for %qs", name);
7963 if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
7965 pedwarn (input_location, OPT_pedantic,
7966 "long, short, signed or unsigned used invalidly for %qs",
7968 if (flag_pedantic_errors)
7973 /* Discard the type modifiers if they are invalid. */
7984 /* Decide whether an integer type is signed or not.
7985 Optionally treat bitfields as signed by default. */
7989 It is implementation-defined whether a plain (neither
7990 explicitly signed or unsigned) char, short, int, or long
7991 bit-field is signed or unsigned.
7993 Naturally, we extend this to long long as well. Note that
7994 this does not include wchar_t. */
7995 || (bitfield && !flag_signed_bitfields
7997 /* A typedef for plain `int' without `signed' can be
7998 controlled just like plain `int', but a typedef for
7999 `signed int' cannot be so controlled. */
8001 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
8002 && TREE_CODE (type) == INTEGER_TYPE
8003 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
8006 type = long_long_unsigned_type_node;
8008 type = long_unsigned_type_node;
8010 type = short_unsigned_type_node;
8011 else if (type == char_type_node)
8012 type = unsigned_char_type_node;
8013 else if (typedef_decl)
8014 type = unsigned_type_for (type);
8016 type = unsigned_type_node;
8018 else if (signed_p && type == char_type_node)
8019 type = signed_char_type_node;
8021 type = long_long_integer_type_node;
8023 type = long_integer_type_node;
8025 type = short_integer_type_node;
8027 if (declspecs->specs[(int)ds_complex])
8029 if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
8030 error ("complex invalid for %qs", name);
8031 /* If we just have "complex", it is equivalent to
8032 "complex double", but if any modifiers at all are specified it is
8033 the complex form of TYPE. E.g, "complex short" is
8034 "complex short int". */
8036 else if (defaulted_int && ! longlong
8037 && ! (long_p || short_p || signed_p || unsigned_p))
8038 type = complex_double_type_node;
8039 else if (type == integer_type_node)
8040 type = complex_integer_type_node;
8041 else if (type == float_type_node)
8042 type = complex_float_type_node;
8043 else if (type == double_type_node)
8044 type = complex_double_type_node;
8045 else if (type == long_double_type_node)
8046 type = complex_long_double_type_node;
8048 type = build_complex_type (type);
8051 type_quals = TYPE_UNQUALIFIED;
8052 if (declspecs->specs[(int)ds_const])
8053 type_quals |= TYPE_QUAL_CONST;
8054 if (declspecs->specs[(int)ds_volatile])
8055 type_quals |= TYPE_QUAL_VOLATILE;
8056 if (declspecs->specs[(int)ds_restrict])
8057 type_quals |= TYPE_QUAL_RESTRICT;
8058 if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
8059 error ("qualifiers are not allowed on declaration of %<operator %T%>",
8062 if (TREE_CODE (type) == FUNCTION_TYPE
8063 && type_quals != TYPE_UNQUALIFIED)
8065 /* This was an error in C++98 (cv-qualifiers cannot be added to
8066 a function type), but DR 295 makes the code well-formed by
8067 dropping the extra qualifiers. */
8070 tree bad_type = build_qualified_type (type, type_quals);
8071 pedwarn (input_location, OPT_pedantic,
8072 "ignoring %qV qualifiers added to function type %qT",
8075 type_quals = TYPE_UNQUALIFIED;
8077 type_quals |= cp_type_quals (type);
8078 type = cp_build_qualified_type_real
8079 (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
8080 ? tf_ignore_bad_quals : 0) | tf_warning_or_error));
8081 /* We might have ignored or rejected some of the qualifiers. */
8082 type_quals = cp_type_quals (type);
8085 inlinep = !! declspecs->specs[(int)ds_inline];
8086 virtualp = !! declspecs->specs[(int)ds_virtual];
8087 explicitp = !! declspecs->specs[(int)ds_explicit];
8089 storage_class = declspecs->storage_class;
8090 if (storage_class == sc_static)
8091 staticp = 1 + (decl_context == FIELD);
8093 if (virtualp && staticp == 2)
8095 error ("member %qD cannot be declared both virtual and static", dname);
8096 storage_class = sc_none;
8099 friendp = !! declspecs->specs[(int)ds_friend];
8101 if (dependent_name && !friendp)
8103 error ("%<%T::%D%> is not a valid declarator", ctype, dependent_name);
8104 return error_mark_node;
8107 /* Issue errors about use of storage classes for parameters. */
8108 if (decl_context == PARM)
8110 if (declspecs->specs[(int)ds_typedef])
8112 error ("typedef declaration invalid in parameter declaration");
8113 return error_mark_node;
8115 else if (storage_class == sc_static
8116 || storage_class == sc_extern
8118 error ("storage class specifiers invalid in parameter declarations");
8120 if (type_uses_auto (type))
8122 error ("parameter declared %<auto%>");
8123 type = error_mark_node;
8127 /* Give error if `virtual' is used outside of class declaration. */
8129 && (current_class_name == NULL_TREE || decl_context != FIELD))
8131 error ("%<virtual%> outside class declaration");
8135 /* Static anonymous unions are dealt with here. */
8136 if (staticp && decl_context == TYPENAME
8138 && ANON_AGGR_TYPE_P (declspecs->type))
8139 decl_context = FIELD;
8141 /* Warn about storage classes that are invalid for certain
8142 kinds of declarations (parameters, typenames, etc.). */
8145 && storage_class != sc_extern
8146 && storage_class != sc_static)
8147 || declspecs->specs[(int)ds_typedef]))
8149 error ("multiple storage classes in declaration of %qs", name);
8152 if (decl_context != NORMAL
8153 && ((storage_class != sc_none
8154 && storage_class != sc_mutable)
8157 if ((decl_context == PARM || decl_context == CATCHPARM)
8158 && (storage_class == sc_register
8159 || storage_class == sc_auto))
8161 else if (declspecs->specs[(int)ds_typedef])
8163 else if (decl_context == FIELD
8164 /* C++ allows static class elements. */
8165 && storage_class == sc_static)
8166 /* C++ also allows inlines and signed and unsigned elements,
8167 but in those cases we don't come in here. */
8171 if (decl_context == FIELD)
8172 error ("storage class specified for %qs", name);
8175 if (decl_context == PARM || decl_context == CATCHPARM)
8176 error ("storage class specified for parameter %qs", name);
8178 error ("storage class specified for typename");
8180 if (storage_class == sc_register
8181 || storage_class == sc_auto
8182 || storage_class == sc_extern
8184 storage_class = sc_none;
8187 else if (storage_class == sc_extern && funcdef_flag
8188 && ! toplevel_bindings_p ())
8189 error ("nested function %qs declared %<extern%>", name);
8190 else if (toplevel_bindings_p ())
8192 if (storage_class == sc_auto)
8193 error ("top-level declaration of %qs specifies %<auto%>", name);
8196 && storage_class != sc_extern
8197 && storage_class != sc_static)
8199 error ("function-scope %qs implicitly auto and declared %<__thread%>",
8204 if (storage_class && friendp)
8206 error ("storage class specifiers invalid in friend function declarations");
8207 storage_class = sc_none;
8212 unqualified_id = NULL_TREE;
8215 unqualified_id = id_declarator->u.id.unqualified_name;
8216 switch (TREE_CODE (unqualified_id))
8219 unqualified_id = TREE_OPERAND (unqualified_id, 0);
8220 if (TYPE_P (unqualified_id))
8221 unqualified_id = constructor_name (unqualified_id);
8224 case IDENTIFIER_NODE:
8225 case TEMPLATE_ID_EXPR:
8233 /* Determine the type of the entity declared by recurring on the
8235 for (; declarator; declarator = declarator->declarator)
8237 const cp_declarator *inner_declarator;
8240 if (type == error_mark_node)
8241 return error_mark_node;
8243 attrs = declarator->attributes;
8249 if (declarator == NULL || declarator->kind == cdk_id)
8250 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
8251 if (declarator->kind == cdk_function)
8252 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
8253 if (declarator->kind == cdk_array)
8254 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
8255 returned_attrs = decl_attributes (&type,
8256 chainon (returned_attrs, attrs),
8260 if (declarator->kind == cdk_id)
8263 inner_declarator = declarator->declarator;
8265 switch (declarator->kind)
8268 type = create_array_type_for_decl (dname, type,
8269 declarator->u.array.bounds);
8277 /* Declaring a function type.
8278 Make sure we have a valid type for the function to return. */
8280 if (type_quals != TYPE_UNQUALIFIED)
8282 if (SCALAR_TYPE_P (type) || VOID_TYPE_P (type))
8283 warning (OPT_Wignored_qualifiers,
8284 "type qualifiers ignored on function return type");
8285 /* We now know that the TYPE_QUALS don't apply to the
8286 decl, but to its return type. */
8287 type_quals = TYPE_UNQUALIFIED;
8288 set_no_warning = true;
8291 /* Error about some types functions can't return. */
8293 if (TREE_CODE (type) == FUNCTION_TYPE)
8295 error ("%qs declared as function returning a function", name);
8296 return error_mark_node;
8298 if (TREE_CODE (type) == ARRAY_TYPE)
8300 error ("%qs declared as function returning an array", name);
8301 return error_mark_node;
8304 /* Pick up type qualifiers which should be applied to `this'. */
8305 memfn_quals = declarator->u.function.qualifiers;
8307 /* Pick up the exception specifications. */
8308 raises = declarator->u.function.exception_specification;
8310 /* Say it's a definition only for the CALL_EXPR
8311 closest to the identifier. */
8312 funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id;
8314 /* Handle a late-specified return type. */
8317 if (type_uses_auto (type))
8319 if (!declarator->u.function.late_return_type)
8321 error ("%qs function uses %<auto%> type specifier without"
8322 " late return type", name);
8323 return error_mark_node;
8325 else if (!is_auto (type))
8327 error ("%qs function with late return type has"
8328 " %qT as its type rather than plain %<auto%>",
8330 return error_mark_node;
8333 else if (declarator->u.function.late_return_type)
8335 error ("%qs function with late return type not declared"
8336 " with %<auto%> type specifier", name);
8337 return error_mark_node;
8340 type = splice_late_return_type
8341 (type, declarator->u.function.late_return_type);
8342 if (type == error_mark_node)
8343 return error_mark_node;
8345 if (ctype == NULL_TREE
8346 && decl_context == FIELD
8348 && (friendp == 0 || dname == current_class_name))
8349 ctype = current_class_type;
8351 if (ctype && (sfk == sfk_constructor
8352 || sfk == sfk_destructor))
8354 /* We are within a class's scope. If our declarator name
8355 is the same as the class name, and we are defining
8356 a function, then it is a constructor/destructor, and
8357 therefore returns a void type. */
8359 /* ISO C++ 12.4/2. A destructor may not be declared
8360 const or volatile. A destructor may not be
8363 ISO C++ 12.1. A constructor may not be declared
8364 const or volatile. A constructor may not be
8365 virtual. A constructor may not be static. */
8367 error ((flags == DTOR_FLAG)
8368 ? "destructor cannot be static member function"
8369 : "constructor cannot be static member function");
8372 error ((flags == DTOR_FLAG)
8373 ? "destructors may not be cv-qualified"
8374 : "constructors may not be cv-qualified");
8375 memfn_quals = TYPE_UNQUALIFIED;
8378 if (decl_context == FIELD
8379 && !member_function_or_else (ctype,
8382 return error_mark_node;
8384 if (flags != DTOR_FLAG)
8386 /* It's a constructor. */
8391 permerror (input_location, "constructors cannot be declared virtual");
8394 if (decl_context == FIELD
8395 && sfk != sfk_constructor)
8396 return error_mark_node;
8398 if (decl_context == FIELD)
8404 error ("can't initialize friend function %qs", name);
8407 /* Cannot be both friend and virtual. */
8408 error ("virtual functions cannot be friends");
8411 if (decl_context == NORMAL)
8412 error ("friend declaration not in class definition");
8413 if (current_function_decl && funcdef_flag)
8414 error ("can't define friend function %qs in a local "
8419 arg_types = grokparms (declarator->u.function.parameters,
8422 if (inner_declarator
8423 && inner_declarator->kind == cdk_id
8424 && inner_declarator->u.id.sfk == sfk_destructor
8425 && arg_types != void_list_node)
8427 error ("destructors may not have parameters");
8428 arg_types = void_list_node;
8432 type = build_function_type (type, arg_types);
8439 /* Filter out pointers-to-references and references-to-references.
8440 We can get these if a TYPE_DECL is used. */
8442 if (TREE_CODE (type) == REFERENCE_TYPE)
8444 if (declarator->kind != cdk_reference)
8446 error ("cannot declare pointer to %q#T", type);
8447 type = TREE_TYPE (type);
8450 /* In C++0x, we allow reference to reference declarations
8451 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
8452 and template type arguments [14.3.1/4 temp.arg.type]. The
8453 check for direct reference to reference declarations, which
8454 are still forbidden, occurs below. Reasoning behind the change
8455 can be found in DR106, DR540, and the rvalue reference
8457 else if (cxx_dialect == cxx98)
8459 error ("cannot declare reference to %q#T", type);
8460 type = TREE_TYPE (type);
8463 else if (VOID_TYPE_P (type))
8465 if (declarator->kind == cdk_reference)
8466 error ("cannot declare reference to %q#T", type);
8467 else if (declarator->kind == cdk_ptrmem)
8468 error ("cannot declare pointer to %q#T member", type);
8471 /* We now know that the TYPE_QUALS don't apply to the decl,
8472 but to the target of the pointer. */
8473 type_quals = TYPE_UNQUALIFIED;
8475 if (declarator->kind == cdk_ptrmem
8476 && (TREE_CODE (type) == FUNCTION_TYPE
8477 || (memfn_quals && TREE_CODE (type) == METHOD_TYPE)))
8479 memfn_quals |= cp_type_quals (type);
8480 type = build_memfn_type (type,
8481 declarator->u.pointer.class_type,
8483 memfn_quals = TYPE_UNQUALIFIED;
8486 if (TREE_CODE (type) == FUNCTION_TYPE
8487 && cp_type_quals (type) != TYPE_UNQUALIFIED)
8488 error ("cannot declare %s to qualified function type %qT",
8489 declarator->kind == cdk_reference ? "reference" : "pointer",
8492 if (declarator->kind == cdk_reference)
8494 /* In C++0x, the type we are creating a reference to might be
8495 a typedef which is itself a reference type. In that case,
8496 we follow the reference collapsing rules in
8497 [7.1.3/8 dcl.typedef] to create the final reference type:
8499 "If a typedef TD names a type that is a reference to a type
8500 T, an attempt to create the type 'lvalue reference to cv TD'
8501 creates the type 'lvalue reference to T,' while an attempt
8502 to create the type "rvalue reference to cv TD' creates the
8505 if (!VOID_TYPE_P (type))
8506 type = cp_build_reference_type
8507 ((TREE_CODE (type) == REFERENCE_TYPE
8508 ? TREE_TYPE (type) : type),
8509 (declarator->u.reference.rvalue_ref
8510 && (TREE_CODE(type) != REFERENCE_TYPE
8511 || TYPE_REF_IS_RVALUE (type))));
8513 /* In C++0x, we need this check for direct reference to
8514 reference declarations, which are forbidden by
8515 [8.3.2/5 dcl.ref]. Reference to reference declarations
8516 are only allowed indirectly through typedefs and template
8517 type arguments. Example:
8519 void foo(int & &); // invalid ref-to-ref decl
8521 typedef int & int_ref;
8522 void foo(int_ref &); // valid ref-to-ref decl
8524 if (inner_declarator && inner_declarator->kind == cdk_reference)
8525 error ("cannot declare reference to %q#T, which is not "
8526 "a typedef or a template type argument", type);
8528 else if (TREE_CODE (type) == METHOD_TYPE)
8529 type = build_ptrmemfunc_type (build_pointer_type (type));
8530 else if (declarator->kind == cdk_ptrmem)
8532 gcc_assert (TREE_CODE (declarator->u.pointer.class_type)
8534 if (declarator->u.pointer.class_type == error_mark_node)
8535 /* We will already have complained. */
8536 type = error_mark_node;
8538 type = build_ptrmem_type (declarator->u.pointer.class_type,
8542 type = build_pointer_type (type);
8544 /* Process a list of type modifier keywords (such as
8545 const or volatile) that were given inside the `*' or `&'. */
8547 if (declarator->u.pointer.qualifiers)
8550 = cp_build_qualified_type (type,
8551 declarator->u.pointer.qualifiers);
8552 type_quals = cp_type_quals (type);
8565 if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR
8566 && TREE_CODE (type) != FUNCTION_TYPE
8567 && TREE_CODE (type) != METHOD_TYPE)
8569 error ("template-id %qD used as a declarator",
8571 unqualified_id = dname;
8574 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
8575 qualified with a class-name, turn it into a METHOD_TYPE, unless
8576 we know that the function is static. We take advantage of this
8577 opportunity to do other processing that pertains to entities
8578 explicitly declared to be class members. Note that if DECLARATOR
8579 is non-NULL, we know it is a cdk_id declarator; otherwise, we
8580 would not have exited the loop above. */
8582 && declarator->u.id.qualifying_scope
8583 && TYPE_P (declarator->u.id.qualifying_scope))
8587 ctype = declarator->u.id.qualifying_scope;
8588 ctype = TYPE_MAIN_VARIANT (ctype);
8590 while (t != NULL_TREE && CLASS_TYPE_P (t))
8592 /* You're supposed to have one `template <...>' for every
8593 template class, but you don't need one for a full
8594 specialization. For example:
8596 template <class T> struct S{};
8597 template <> struct S<int> { void f(); };
8598 void S<int>::f () {}
8600 is correct; there shouldn't be a `template <>' for the
8601 definition of `S<int>::f'. */
8602 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t)
8603 && !any_dependent_template_arguments_p (CLASSTYPE_TI_ARGS (t)))
8604 /* T is an explicit (not partial) specialization. All
8605 containing classes must therefore also be explicitly
8608 if ((CLASSTYPE_USE_TEMPLATE (t) || CLASSTYPE_IS_TEMPLATE (t))
8609 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
8610 template_count += 1;
8612 t = TYPE_MAIN_DECL (t);
8613 t = DECL_CONTEXT (t);
8616 if (ctype == current_class_type)
8620 permerror (input_location, "member functions are implicitly friends of their class");
8624 permerror (declarator->id_loc,
8625 "extra qualification %<%T::%> on member %qs",
8628 else if (/* If the qualifying type is already complete, then we
8629 can skip the following checks. */
8630 !COMPLETE_TYPE_P (ctype)
8631 && (/* If the function is being defined, then
8632 qualifying type must certainly be complete. */
8634 /* A friend declaration of "T::f" is OK, even if
8635 "T" is a template parameter. But, if this
8636 function is not a friend, the qualifying type
8638 || (!friendp && !CLASS_TYPE_P (ctype))
8639 /* For a declaration, the type need not be
8640 complete, if either it is dependent (since there
8641 is no meaningful definition of complete in that
8642 case) or the qualifying class is currently being
8644 || !(dependent_type_p (ctype)
8645 || currently_open_class (ctype)))
8646 /* Check that the qualifying type is complete. */
8647 && !complete_type_or_else (ctype, NULL_TREE))
8648 return error_mark_node;
8649 else if (TREE_CODE (type) == FUNCTION_TYPE)
8651 tree sname = declarator->u.id.unqualified_name;
8653 if (current_class_type
8654 && (!friendp || funcdef_flag))
8657 ? "cannot define member function %<%T::%s%> within %<%T%>"
8658 : "cannot declare member function %<%T::%s%> within %<%T%>",
8659 ctype, name, current_class_type);
8660 return error_mark_node;
8663 if (TREE_CODE (sname) == IDENTIFIER_NODE
8664 && NEW_DELETE_OPNAME_P (sname))
8665 /* Overloaded operator new and operator delete
8666 are always static functions. */
8669 type = build_memfn_type (type, ctype, memfn_quals);
8671 else if (declspecs->specs[(int)ds_typedef]
8672 && current_class_type)
8674 error ("cannot declare member %<%T::%s%> within %qT",
8675 ctype, name, current_class_type);
8676 return error_mark_node;
8680 /* Now TYPE has the actual type. */
8685 *attrlist = chainon (returned_attrs, *attrlist);
8687 attrlist = &returned_attrs;
8690 /* Handle parameter packs. */
8691 if (parameter_pack_p)
8693 if (decl_context == PARM)
8694 /* Turn the type into a pack expansion.*/
8695 type = make_pack_expansion (type);
8697 error ("non-parameter %qs cannot be a parameter pack", name);
8700 /* Did array size calculations overflow? */
8702 if (TREE_CODE (type) == ARRAY_TYPE
8703 && COMPLETE_TYPE_P (type)
8704 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
8705 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
8707 error ("size of array %qs is too large", name);
8708 /* If we proceed with the array type as it is, we'll eventually
8709 crash in tree_low_cst(). */
8710 type = error_mark_node;
8713 if ((decl_context == FIELD || decl_context == PARM)
8714 && !processing_template_decl
8715 && variably_modified_type_p (type, NULL_TREE))
8717 if (decl_context == FIELD)
8718 error ("data member may not have variably modified type %qT", type);
8720 error ("parameter may not have variably modified type %qT", type);
8721 type = error_mark_node;
8724 if (explicitp == 1 || (explicitp && friendp))
8726 /* [dcl.fct.spec] The explicit specifier shall only be used in
8727 declarations of constructors within a class definition. */
8728 error ("only declarations of constructors can be %<explicit%>");
8732 if (storage_class == sc_mutable)
8734 if (decl_context != FIELD || friendp)
8736 error ("non-member %qs cannot be declared %<mutable%>", name);
8737 storage_class = sc_none;
8739 else if (decl_context == TYPENAME || declspecs->specs[(int)ds_typedef])
8741 error ("non-object member %qs cannot be declared %<mutable%>", name);
8742 storage_class = sc_none;
8744 else if (TREE_CODE (type) == FUNCTION_TYPE
8745 || TREE_CODE (type) == METHOD_TYPE)
8747 error ("function %qs cannot be declared %<mutable%>", name);
8748 storage_class = sc_none;
8752 error ("static %qs cannot be declared %<mutable%>", name);
8753 storage_class = sc_none;
8755 else if (type_quals & TYPE_QUAL_CONST)
8757 error ("const %qs cannot be declared %<mutable%>", name);
8758 storage_class = sc_none;
8762 /* If this is declaring a typedef name, return a TYPE_DECL. */
8763 if (declspecs->specs[(int)ds_typedef] && decl_context != TYPENAME)
8767 /* Note that the grammar rejects storage classes
8768 in typenames, fields or parameters. */
8769 if (current_lang_name == lang_name_java)
8770 TYPE_FOR_JAVA (type) = 1;
8772 /* This declaration:
8774 typedef void f(int) const;
8776 declares a function type which is not a member of any
8777 particular class, but which is cv-qualified; for
8778 example "f S::*" declares a pointer to a const-qualified
8779 member function of S. We record the cv-qualification in the
8781 if (memfn_quals && TREE_CODE (type) == FUNCTION_TYPE)
8783 type = cp_build_qualified_type (type, memfn_quals);
8785 /* We have now dealt with these qualifiers. */
8786 memfn_quals = TYPE_UNQUALIFIED;
8789 if (decl_context == FIELD)
8790 decl = build_lang_decl (TYPE_DECL, unqualified_id, type);
8792 decl = build_decl (TYPE_DECL, unqualified_id, type);
8793 if (id_declarator && declarator->u.id.qualifying_scope) {
8794 error ("%Jtypedef name may not be a nested-name-specifier", decl);
8795 TREE_TYPE (decl) = error_mark_node;
8798 if (decl_context != FIELD)
8800 if (!current_function_decl)
8801 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8802 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl)
8803 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
8804 (current_function_decl)))
8805 /* The TYPE_DECL is "abstract" because there will be
8806 clones of this constructor/destructor, and there will
8807 be copies of this TYPE_DECL generated in those
8809 DECL_ABSTRACT (decl) = 1;
8811 else if (constructor_name_p (unqualified_id, current_class_type))
8812 permerror (input_location, "ISO C++ forbids nested type %qD with same name "
8813 "as enclosing class",
8816 /* If the user declares "typedef struct {...} foo" then the
8817 struct will have an anonymous name. Fill that name in now.
8818 Nothing can refer to it, so nothing needs know about the name
8820 if (type != error_mark_node
8823 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
8824 && TYPE_ANONYMOUS_P (type)
8825 && cp_type_quals (type) == TYPE_UNQUALIFIED)
8829 /* Replace the anonymous name with the real name everywhere. */
8830 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
8832 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8834 debug_hooks->set_name (t, decl);
8835 TYPE_NAME (t) = decl;
8839 if (TYPE_LANG_SPECIFIC (type))
8840 TYPE_WAS_ANONYMOUS (type) = 1;
8842 /* If this is a typedef within a template class, the nested
8843 type is a (non-primary) template. The name for the
8844 template needs updating as well. */
8845 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
8846 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
8847 = TYPE_IDENTIFIER (type);
8849 /* FIXME remangle member functions; member functions of a
8850 type with external linkage have external linkage. */
8854 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
8855 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
8857 bad_specifiers (decl, "type", virtualp,
8858 memfn_quals != TYPE_UNQUALIFIED,
8859 inlinep, friendp, raises != NULL_TREE);
8864 /* Detect the case of an array type of unspecified size
8865 which came, as such, direct from a typedef name.
8866 We must copy the type, so that the array's domain can be
8867 individually set by the object's initializer. */
8869 if (type && typedef_type
8870 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
8871 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
8872 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
8874 /* Detect where we're using a typedef of function type to declare a
8875 function. PARMS will not be set, so we must create it now. */
8877 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
8879 tree decls = NULL_TREE;
8882 for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
8884 tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
8886 TREE_CHAIN (decl) = decls;
8890 parms = nreverse (decls);
8892 if (decl_context != TYPENAME)
8894 /* A cv-qualifier-seq shall only be part of the function type
8895 for a non-static member function. [8.3.5/4 dcl.fct] */
8896 if (cp_type_quals (type) != TYPE_UNQUALIFIED
8897 && (current_class_type == NULL_TREE || staticp) )
8900 ? G_("qualified function types cannot be used to "
8901 "declare static member functions")
8902 : G_("qualified function types cannot be used to "
8903 "declare free functions"));
8904 type = TYPE_MAIN_VARIANT (type);
8907 /* The qualifiers on the function type become the qualifiers on
8908 the non-static member function. */
8909 memfn_quals |= cp_type_quals (type);
8913 /* If this is a type name (such as, in a cast or sizeof),
8914 compute the type and return it now. */
8916 if (decl_context == TYPENAME)
8918 /* Note that the grammar rejects storage classes
8919 in typenames, fields or parameters. */
8920 if (type_quals != TYPE_UNQUALIFIED)
8921 type_quals = TYPE_UNQUALIFIED;
8923 /* Special case: "friend class foo" looks like a TYPENAME context. */
8926 if (type_quals != TYPE_UNQUALIFIED)
8928 error ("type qualifiers specified for friend class declaration");
8929 type_quals = TYPE_UNQUALIFIED;
8933 error ("%<inline%> specified for friend class declaration");
8939 /* Don't allow friend declaration without a class-key. */
8940 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
8941 permerror (input_location, "template parameters cannot be friends");
8942 else if (TREE_CODE (type) == TYPENAME_TYPE)
8943 permerror (input_location, "friend declaration requires class-key, "
8944 "i.e. %<friend class %T::%D%>",
8945 TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
8947 permerror (input_location, "friend declaration requires class-key, "
8948 "i.e. %<friend %#T%>",
8952 /* Only try to do this stuff if we didn't already give up. */
8953 if (type != integer_type_node)
8955 /* A friendly class? */
8956 if (current_class_type)
8957 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
8960 error ("trying to make class %qT a friend of global scope",
8963 type = void_type_node;
8966 else if (memfn_quals)
8968 if (ctype == NULL_TREE
8969 && TREE_CODE (type) == METHOD_TYPE)
8970 ctype = TYPE_METHOD_BASETYPE (type);
8973 type = build_memfn_type (type, ctype, memfn_quals);
8974 /* Core issue #547: need to allow this in template type args. */
8975 else if (template_type_arg && TREE_CODE (type) == FUNCTION_TYPE)
8976 type = cp_build_qualified_type (type, memfn_quals);
8978 error ("invalid qualifiers on non-member function type");
8983 else if (unqualified_id == NULL_TREE && decl_context != PARM
8984 && decl_context != CATCHPARM
8985 && TREE_CODE (type) != UNION_TYPE
8988 error ("abstract declarator %qT used as declaration", type);
8989 return error_mark_node;
8992 /* Only functions may be declared using an operator-function-id. */
8994 && IDENTIFIER_OPNAME_P (unqualified_id)
8995 && TREE_CODE (type) != FUNCTION_TYPE
8996 && TREE_CODE (type) != METHOD_TYPE)
8998 error ("declaration of %qD as non-function", unqualified_id);
8999 return error_mark_node;
9002 /* We don't check parameter types here because we can emit a better
9003 error message later. */
9004 if (decl_context != PARM)
9006 type = check_var_type (unqualified_id, type);
9007 if (type == error_mark_node)
9008 return error_mark_node;
9011 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
9012 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
9014 if (decl_context == PARM || decl_context == CATCHPARM)
9016 if (ctype || in_namespace)
9017 error ("cannot use %<::%> in parameter declaration");
9019 /* A parameter declared as an array of T is really a pointer to T.
9020 One declared as a function is really a pointer to a function.
9021 One declared as a member is really a pointer to member. */
9023 if (TREE_CODE (type) == ARRAY_TYPE)
9025 /* Transfer const-ness of array into that of type pointed to. */
9026 type = build_pointer_type (TREE_TYPE (type));
9027 type_quals = TYPE_UNQUALIFIED;
9029 else if (TREE_CODE (type) == FUNCTION_TYPE)
9030 type = build_pointer_type (type);
9036 if (decl_context == PARM)
9038 decl = cp_build_parm_decl (unqualified_id, type);
9040 bad_specifiers (decl, "parameter", virtualp,
9041 memfn_quals != TYPE_UNQUALIFIED,
9042 inlinep, friendp, raises != NULL_TREE);
9044 else if (decl_context == FIELD)
9046 /* The C99 flexible array extension. */
9047 if (!staticp && TREE_CODE (type) == ARRAY_TYPE
9048 && TYPE_DOMAIN (type) == NULL_TREE)
9050 tree itype = compute_array_index_type (dname, integer_zero_node);
9051 type = build_cplus_array_type (TREE_TYPE (type), itype);
9054 if (type == error_mark_node)
9056 /* Happens when declaring arrays of sizes which
9057 are error_mark_node, for example. */
9060 else if (in_namespace && !friendp)
9062 /* Something like struct S { int N::j; }; */
9063 error ("invalid use of %<::%>");
9064 return error_mark_node;
9066 else if (TREE_CODE (type) == FUNCTION_TYPE)
9069 tree function_context;
9073 if (ctype == NULL_TREE)
9074 ctype = current_class_type;
9076 if (ctype == NULL_TREE)
9078 error ("can't make %qD into a method -- not in a class",
9080 return error_mark_node;
9083 /* ``A union may [ ... ] not [ have ] virtual functions.''
9085 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
9087 error ("function %qD declared virtual inside a union",
9089 return error_mark_node;
9092 if (NEW_DELETE_OPNAME_P (unqualified_id))
9096 error ("%qD cannot be declared virtual, since it "
9102 else if (staticp < 2)
9103 type = build_memfn_type (type, ctype, memfn_quals);
9106 /* Check that the name used for a destructor makes sense. */
9107 if (sfk == sfk_destructor)
9109 tree uqname = id_declarator->u.id.unqualified_name;
9113 gcc_assert (friendp);
9114 error ("expected qualified name in friend declaration "
9115 "for destructor %qD", uqname);
9116 return error_mark_node;
9119 if (!check_dtor_name (ctype, TREE_OPERAND (uqname, 0)))
9121 error ("declaration of %qD as member of %qT",
9123 return error_mark_node;
9126 else if (sfk == sfk_constructor && friendp)
9128 error ("expected qualified name in friend declaration "
9129 "for constructor %qD",
9130 id_declarator->u.id.unqualified_name);
9131 return error_mark_node;
9134 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
9135 function_context = (ctype != NULL_TREE) ?
9136 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
9137 publicp = (! friendp || ! staticp)
9138 && function_context == NULL_TREE;
9139 decl = grokfndecl (ctype, type,
9140 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
9141 ? unqualified_id : dname,
9144 virtualp, flags, memfn_quals, raises,
9145 friendp ? -1 : 0, friendp, publicp, inlinep,
9147 funcdef_flag, template_count, in_namespace,
9148 attrlist, declarator->id_loc);
9149 if (decl == NULL_TREE)
9150 return error_mark_node;
9152 /* This clobbers the attrs stored in `decl' from `attrlist'. */
9153 /* The decl and setting of decl_attr is also turned off. */
9154 decl = build_decl_attribute_variant (decl, decl_attr);
9157 /* [class.conv.ctor]
9159 A constructor declared without the function-specifier
9160 explicit that can be called with a single parameter
9161 specifies a conversion from the type of its first
9162 parameter to the type of its class. Such a constructor
9163 is called a converting constructor. */
9165 DECL_NONCONVERTING_P (decl) = 1;
9167 else if (TREE_CODE (type) == METHOD_TYPE)
9169 /* We only get here for friend declarations of
9170 members of other classes. */
9171 /* All method decls are public, so tell grokfndecl to set
9172 TREE_PUBLIC, also. */
9173 decl = grokfndecl (ctype, type,
9174 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
9175 ? unqualified_id : dname,
9178 virtualp, flags, memfn_quals, raises,
9179 friendp ? -1 : 0, friendp, 1, 0, sfk,
9180 funcdef_flag, template_count, in_namespace,
9182 declarator->id_loc);
9183 if (decl == NULL_TREE)
9184 return error_mark_node;
9186 else if (!staticp && !dependent_type_p (type)
9187 && !COMPLETE_TYPE_P (complete_type (type))
9188 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
9191 error ("field %qD has incomplete type", unqualified_id);
9193 error ("name %qT has incomplete type", type);
9195 /* If we're instantiating a template, tell them which
9196 instantiation made the field's type be incomplete. */
9197 if (current_class_type
9198 && TYPE_NAME (current_class_type)
9199 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
9201 && declspecs->type == type)
9202 error (" in instantiation of template %qT",
9203 current_class_type);
9205 return error_mark_node;
9211 error ("%qE is neither function nor member function; "
9212 "cannot be declared friend", unqualified_id);
9220 /* Friends are treated specially. */
9221 if (ctype == current_class_type)
9222 ; /* We already issued a permerror. */
9223 else if (decl && DECL_NAME (decl))
9225 if (template_class_depth (current_class_type) == 0)
9227 decl = check_explicit_specialization
9228 (unqualified_id, decl, template_count,
9229 2 * funcdef_flag + 4);
9230 if (decl == error_mark_node)
9231 return error_mark_node;
9234 decl = do_friend (ctype, unqualified_id, decl,
9240 return error_mark_node;
9243 /* Structure field. It may not be a function, except for C++. */
9245 if (decl == NULL_TREE)
9251 /* An attempt is being made to initialize a non-static
9252 member. But, from [class.mem]:
9254 4 A member-declarator can contain a
9255 constant-initializer only if it declares a static
9256 member (_class.static_) of integral or enumeration
9257 type, see _class.static.data_.
9259 This used to be relatively common practice, but
9260 the rest of the compiler does not correctly
9261 handle the initialization unless the member is
9262 static so we make it static below. */
9263 permerror (input_location, "ISO C++ forbids initialization of member %qD",
9265 permerror (input_location, "making %qD static", unqualified_id);
9269 if (uses_template_parms (type))
9270 /* We'll check at instantiation time. */
9272 else if (check_static_variable_definition (unqualified_id,
9274 /* If we just return the declaration, crashes
9275 will sometimes occur. We therefore return
9276 void_type_node, as if this was a friend
9277 declaration, to cause callers to completely
9278 ignore this declaration. */
9279 return error_mark_node;
9284 /* C++ allows static class members. All other work
9285 for this is done by grokfield. */
9286 decl = build_lang_decl (VAR_DECL, unqualified_id, type);
9287 set_linkage_for_static_data_member (decl);
9288 /* Even if there is an in-class initialization, DECL
9289 is considered undefined until an out-of-class
9290 definition is provided. */
9291 DECL_EXTERNAL (decl) = 1;
9294 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
9298 decl = build_decl (FIELD_DECL, unqualified_id, type);
9299 DECL_NONADDRESSABLE_P (decl) = bitfield;
9300 if (bitfield && !unqualified_id)
9301 TREE_NO_WARNING (decl) = 1;
9303 if (storage_class == sc_mutable)
9305 DECL_MUTABLE_P (decl) = 1;
9306 storage_class = sc_none;
9310 bad_specifiers (decl, "field", virtualp,
9311 memfn_quals != TYPE_UNQUALIFIED,
9312 inlinep, friendp, raises != NULL_TREE);
9315 else if (TREE_CODE (type) == FUNCTION_TYPE
9316 || TREE_CODE (type) == METHOD_TYPE)
9321 if (!unqualified_id)
9322 return error_mark_node;
9324 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
9325 original_name = dname;
9327 original_name = unqualified_id;
9329 if (storage_class == sc_auto)
9330 error ("storage class %<auto%> invalid for function %qs", name);
9331 else if (storage_class == sc_register)
9332 error ("storage class %<register%> invalid for function %qs", name);
9334 error ("storage class %<__thread%> invalid for function %qs", name);
9336 /* Function declaration not at top level.
9337 Storage classes other than `extern' are not allowed
9338 and `extern' makes no difference. */
9339 if (! toplevel_bindings_p ()
9340 && (storage_class == sc_static
9341 || declspecs->specs[(int)ds_inline])
9344 if (storage_class == sc_static)
9345 pedwarn (input_location, OPT_pedantic,
9346 "%<static%> specified invalid for function %qs "
9347 "declared out of global scope", name);
9349 pedwarn (input_location, OPT_pedantic,
9350 "%<inline%> specifier invalid for function %qs "
9351 "declared out of global scope", name);
9354 if (ctype != NULL_TREE
9355 && TREE_CODE (ctype) != NAMESPACE_DECL && !MAYBE_CLASS_TYPE_P (ctype))
9357 error ("%q#T is not a class or a namespace", ctype);
9361 if (ctype == NULL_TREE)
9365 error ("virtual non-class function %qs", name);
9368 else if (sfk == sfk_constructor
9369 || sfk == sfk_destructor)
9372 ? "%qs defined in a non-class scope"
9373 : "%qs declared in a non-class scope", name);
9377 else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2
9378 && !NEW_DELETE_OPNAME_P (original_name))
9379 type = build_method_type_directly (ctype,
9381 TYPE_ARG_TYPES (type));
9383 /* Record presence of `static'. */
9384 publicp = (ctype != NULL_TREE
9385 || storage_class == sc_extern
9386 || storage_class != sc_static);
9388 decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
9389 virtualp, flags, memfn_quals, raises,
9391 publicp, inlinep, sfk, funcdef_flag,
9392 template_count, in_namespace, attrlist,
9393 declarator->id_loc);
9394 if (decl == NULL_TREE)
9395 return error_mark_node;
9399 int invalid_static = 0;
9401 /* Don't allow a static member function in a class, and forbid
9402 declaring main to be static. */
9403 if (TREE_CODE (type) == METHOD_TYPE)
9405 permerror (input_location, "cannot declare member function %qD to have "
9406 "static linkage", decl);
9409 else if (current_function_decl)
9411 /* FIXME need arm citation */
9412 error ("cannot declare static function inside another function");
9419 storage_class = sc_none;
9425 /* It's a variable. */
9427 /* An uninitialized decl with `extern' is a reference. */
9428 decl = grokvardecl (type, unqualified_id,
9431 (type_quals & TYPE_QUAL_CONST) != 0,
9432 ctype ? ctype : in_namespace);
9433 bad_specifiers (decl, "variable", virtualp,
9434 memfn_quals != TYPE_UNQUALIFIED,
9435 inlinep, friendp, raises != NULL_TREE);
9439 DECL_CONTEXT (decl) = ctype;
9442 permerror (input_location, "%<static%> may not be used when defining "
9443 "(as opposed to declaring) a static data member");
9445 storage_class = sc_none;
9447 if (storage_class == sc_register && TREE_STATIC (decl))
9449 error ("static member %qD declared %<register%>", decl);
9450 storage_class = sc_none;
9452 if (storage_class == sc_extern && pedantic)
9454 pedwarn (input_location, OPT_pedantic,
9455 "cannot explicitly declare member %q#D to have "
9456 "extern linkage", decl);
9457 storage_class = sc_none;
9462 if (storage_class == sc_extern && initialized && !funcdef_flag)
9464 if (toplevel_bindings_p ())
9466 /* It's common practice (and completely valid) to have a const
9467 be initialized and declared extern. */
9468 if (!(type_quals & TYPE_QUAL_CONST))
9469 warning (0, "%qs initialized and declared %<extern%>", name);
9473 error ("%qs has both %<extern%> and initializer", name);
9474 return error_mark_node;
9478 /* Record `register' declaration for warnings on &
9479 and in case doing stupid register allocation. */
9481 if (storage_class == sc_register)
9482 DECL_REGISTER (decl) = 1;
9483 else if (storage_class == sc_extern)
9484 DECL_THIS_EXTERN (decl) = 1;
9485 else if (storage_class == sc_static)
9486 DECL_THIS_STATIC (decl) = 1;
9488 /* Record constancy and volatility on the DECL itself . There's
9489 no need to do this when processing a template; we'll do this
9490 for the instantiated declaration based on the type of DECL. */
9491 if (!processing_template_decl)
9492 cp_apply_type_quals_to_decl (type_quals, decl);
9495 TREE_NO_WARNING (decl) = 1;
9501 /* Subroutine of start_function. Ensure that each of the parameter
9502 types (as listed in PARMS) is complete, as is required for a
9503 function definition. */
9506 require_complete_types_for_parms (tree parms)
9508 for (; parms; parms = TREE_CHAIN (parms))
9510 if (dependent_type_p (TREE_TYPE (parms)))
9512 if (!VOID_TYPE_P (TREE_TYPE (parms))
9513 && complete_type_or_else (TREE_TYPE (parms), parms))
9515 relayout_decl (parms);
9516 DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
9519 /* grokparms or complete_type_or_else will have already issued
9521 TREE_TYPE (parms) = error_mark_node;
9525 /* Returns nonzero if T is a local variable. */
9528 local_variable_p (const_tree t)
9530 if ((TREE_CODE (t) == VAR_DECL
9531 /* A VAR_DECL with a context that is a _TYPE is a static data
9533 && !TYPE_P (CP_DECL_CONTEXT (t))
9534 /* Any other non-local variable must be at namespace scope. */
9535 && !DECL_NAMESPACE_SCOPE_P (t))
9536 || (TREE_CODE (t) == PARM_DECL))
9542 /* Like local_variable_p, but suitable for use as a tree-walking
9546 local_variable_p_walkfn (tree *tp, int *walk_subtrees,
9547 void *data ATTRIBUTE_UNUSED)
9549 if (local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
9551 else if (TYPE_P (*tp))
9558 /* Check that ARG, which is a default-argument expression for a
9559 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
9560 something goes wrong. DECL may also be a _TYPE node, rather than a
9561 DECL, if there is no DECL available. */
9564 check_default_argument (tree decl, tree arg)
9569 if (TREE_CODE (arg) == DEFAULT_ARG)
9570 /* We get a DEFAULT_ARG when looking at an in-class declaration
9571 with a default argument. Ignore the argument for now; we'll
9572 deal with it after the class is complete. */
9581 decl_type = TREE_TYPE (decl);
9583 if (arg == error_mark_node
9584 || decl == error_mark_node
9585 || TREE_TYPE (arg) == error_mark_node
9586 || decl_type == error_mark_node)
9587 /* Something already went wrong. There's no need to check
9589 return error_mark_node;
9591 /* [dcl.fct.default]
9593 A default argument expression is implicitly converted to the
9595 if (!TREE_TYPE (arg)
9596 || !can_convert_arg (decl_type, TREE_TYPE (arg), arg, LOOKUP_NORMAL))
9599 error ("default argument for %q#D has type %qT",
9600 decl, TREE_TYPE (arg));
9602 error ("default argument for parameter of type %qT has type %qT",
9603 decl_type, TREE_TYPE (arg));
9605 return error_mark_node;
9608 /* [dcl.fct.default]
9610 Local variables shall not be used in default argument
9613 The keyword `this' shall not be used in a default argument of a
9615 var = cp_walk_tree_without_duplicates (&arg, local_variable_p_walkfn, NULL);
9618 error ("default argument %qE uses local variable %qD", arg, var);
9619 return error_mark_node;
9626 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
9629 type_is_deprecated (tree type)
9631 enum tree_code code;
9632 if (TREE_DEPRECATED (type))
9634 if (TYPE_NAME (type)
9635 && TREE_DEPRECATED (TYPE_NAME (type)))
9638 code = TREE_CODE (type);
9640 if (code == POINTER_TYPE || code == REFERENCE_TYPE
9641 || code == OFFSET_TYPE || code == FUNCTION_TYPE
9642 || code == METHOD_TYPE || code == ARRAY_TYPE)
9643 return type_is_deprecated (TREE_TYPE (type));
9645 if (TYPE_PTRMEMFUNC_P (type))
9646 return type_is_deprecated
9647 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type))));
9652 /* Decode the list of parameter types for a function type.
9653 Given the list of things declared inside the parens,
9654 return a list of types.
9656 If this parameter does not end with an ellipsis, we append
9659 *PARMS is set to the chain of PARM_DECLs created. */
9662 grokparms (tree parmlist, tree *parms)
9664 tree result = NULL_TREE;
9665 tree decls = NULL_TREE;
9669 for (parm = parmlist; parm != NULL_TREE; parm = TREE_CHAIN (parm))
9671 tree type = NULL_TREE;
9672 tree init = TREE_PURPOSE (parm);
9673 tree decl = TREE_VALUE (parm);
9675 if (parm == void_list_node)
9678 if (! decl || TREE_TYPE (decl) == error_mark_node)
9681 type = TREE_TYPE (decl);
9682 if (VOID_TYPE_P (type))
9684 if (same_type_p (type, void_type_node)
9685 && DECL_SELF_REFERENCE_P (type)
9686 && !DECL_NAME (decl) && !result && TREE_CHAIN (parm) == void_list_node)
9687 /* this is a parmlist of `(void)', which is ok. */
9689 cxx_incomplete_type_error (decl, type);
9690 /* It's not a good idea to actually create parameters of
9691 type `void'; other parts of the compiler assume that a
9692 void type terminates the parameter list. */
9693 type = error_mark_node;
9694 TREE_TYPE (decl) = error_mark_node;
9697 if (type != error_mark_node
9698 && TYPE_FOR_JAVA (type)
9699 && MAYBE_CLASS_TYPE_P (type))
9701 error ("parameter %qD has Java class type", decl);
9702 type = error_mark_node;
9703 TREE_TYPE (decl) = error_mark_node;
9707 if (type != error_mark_node)
9709 if (deprecated_state != DEPRECATED_SUPPRESS)
9711 tree deptype = type_is_deprecated (type);
9713 warn_deprecated_use (deptype);
9716 /* Top-level qualifiers on the parameters are
9717 ignored for function types. */
9718 type = cp_build_qualified_type (type, 0);
9719 if (TREE_CODE (type) == METHOD_TYPE)
9721 error ("parameter %qD invalidly declared method type", decl);
9722 type = build_pointer_type (type);
9723 TREE_TYPE (decl) = type;
9725 else if (abstract_virtuals_error (decl, type))
9726 any_error = 1; /* Seems like a good idea. */
9727 else if (POINTER_TYPE_P (type))
9729 /* [dcl.fct]/6, parameter types cannot contain pointers
9730 (references) to arrays of unknown bound. */
9731 tree t = TREE_TYPE (type);
9732 int ptr = TYPE_PTR_P (type);
9738 else if (TREE_CODE (t) != ARRAY_TYPE)
9740 else if (!TYPE_DOMAIN (t))
9744 if (TREE_CODE (t) == ARRAY_TYPE)
9745 error ("parameter %qD includes %s to array of unknown "
9747 decl, ptr ? "pointer" : "reference", t);
9752 else if (init && !processing_template_decl)
9753 init = check_default_argument (decl, init);
9756 if (TREE_CODE (decl) == PARM_DECL
9757 && FUNCTION_PARAMETER_PACK_P (decl)
9758 && TREE_CHAIN (parm)
9759 && TREE_CHAIN (parm) != void_list_node)
9760 error ("parameter packs must be at the end of the parameter list");
9762 TREE_CHAIN (decl) = decls;
9764 result = tree_cons (init, type, result);
9766 decls = nreverse (decls);
9767 result = nreverse (result);
9769 result = chainon (result, void_list_node);
9776 /* D is a constructor or overloaded `operator='.
9778 Let T be the class in which D is declared. Then, this function
9781 -1 if D's is an ill-formed constructor or copy assignment operator
9782 whose first parameter is of type `T'.
9783 0 if D is not a copy constructor or copy assignment
9785 1 if D is a copy constructor or copy assignment operator whose
9786 first parameter is a reference to const qualified T.
9787 2 if D is a copy constructor or copy assignment operator whose
9788 first parameter is a reference to non-const qualified T.
9790 This function can be used as a predicate. Positive values indicate
9791 a copy constructor and nonzero values indicate a copy assignment
9795 copy_fn_p (const_tree d)
9801 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
9803 if (TREE_CODE (d) == TEMPLATE_DECL
9804 || (DECL_TEMPLATE_INFO (d)
9805 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
9806 /* Instantiations of template member functions are never copy
9807 functions. Note that member functions of templated classes are
9808 represented as template functions internally, and we must
9809 accept those as copy functions. */
9812 args = FUNCTION_FIRST_USER_PARMTYPE (d);
9816 arg_type = TREE_VALUE (args);
9817 if (arg_type == error_mark_node)
9820 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
9822 /* Pass by value copy assignment operator. */
9825 else if (TREE_CODE (arg_type) == REFERENCE_TYPE
9826 && !TYPE_REF_IS_RVALUE (arg_type)
9827 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
9829 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
9835 args = TREE_CHAIN (args);
9837 if (args && args != void_list_node && !TREE_PURPOSE (args))
9838 /* There are more non-optional args. */
9844 /* D is a constructor or overloaded `operator='.
9846 Let T be the class in which D is declared. Then, this function
9847 returns true when D is a move constructor or move assignment
9848 operator, false otherwise. */
9851 move_fn_p (const_tree d)
9855 bool result = false;
9857 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
9859 if (cxx_dialect == cxx98)
9860 /* There are no move constructors if we are in C++98 mode. */
9863 if (TREE_CODE (d) == TEMPLATE_DECL
9864 || (DECL_TEMPLATE_INFO (d)
9865 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
9866 /* Instantiations of template member functions are never copy
9867 functions. Note that member functions of templated classes are
9868 represented as template functions internally, and we must
9869 accept those as copy functions. */
9872 args = FUNCTION_FIRST_USER_PARMTYPE (d);
9876 arg_type = TREE_VALUE (args);
9877 if (arg_type == error_mark_node)
9880 if (TREE_CODE (arg_type) == REFERENCE_TYPE
9881 && TYPE_REF_IS_RVALUE (arg_type)
9882 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)),
9886 args = TREE_CHAIN (args);
9888 if (args && args != void_list_node && !TREE_PURPOSE (args))
9889 /* There are more non-optional args. */
9895 /* Remember any special properties of member function DECL. */
9898 grok_special_member_properties (tree decl)
9902 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
9905 class_type = DECL_CONTEXT (decl);
9906 if (DECL_CONSTRUCTOR_P (decl))
9908 int ctor = copy_fn_p (decl);
9910 if (!DECL_ARTIFICIAL (decl))
9911 TYPE_HAS_USER_CONSTRUCTOR (class_type) = 1;
9917 A non-template constructor for class X is a copy
9918 constructor if its first parameter is of type X&, const
9919 X&, volatile X& or const volatile X&, and either there
9920 are no other parameters or else all other parameters have
9921 default arguments. */
9922 TYPE_HAS_INIT_REF (class_type) = 1;
9923 if (!DECL_DEFAULTED_FN (decl))
9924 TYPE_HAS_COMPLEX_INIT_REF (class_type) = 1;
9926 TYPE_HAS_CONST_INIT_REF (class_type) = 1;
9928 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
9930 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type) = 1;
9931 if (TREE_CODE (decl) == TEMPLATE_DECL || !DECL_DEFAULTED_FN (decl))
9932 TYPE_HAS_COMPLEX_DFLT (class_type) = 1;
9934 else if (is_list_ctor (decl))
9935 TYPE_HAS_LIST_CTOR (class_type) = 1;
9937 else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
9941 A non-template assignment operator for class X is a copy
9942 assignment operator if its parameter is of type X, X&, const
9943 X&, volatile X& or const volatile X&. */
9945 int assop = copy_fn_p (decl);
9949 TYPE_HAS_ASSIGN_REF (class_type) = 1;
9950 if (!DECL_DEFAULTED_FN (decl))
9951 TYPE_HAS_COMPLEX_ASSIGN_REF (class_type) = 1;
9953 TYPE_HAS_CONST_ASSIGN_REF (class_type) = 1;
9958 /* Check a constructor DECL has the correct form. Complains
9959 if the class has a constructor of the form X(X). */
9962 grok_ctor_properties (const_tree ctype, const_tree decl)
9964 int ctor_parm = copy_fn_p (decl);
9970 A declaration of a constructor for a class X is ill-formed if
9971 its first parameter is of type (optionally cv-qualified) X
9972 and either there are no other parameters or else all other
9973 parameters have default arguments.
9975 We *don't* complain about member template instantiations that
9976 have this form, though; they can occur as we try to decide
9977 what constructor to use during overload resolution. Since
9978 overload resolution will never prefer such a constructor to
9979 the non-template copy constructor (which is either explicitly
9980 or implicitly defined), there's no need to worry about their
9981 existence. Theoretically, they should never even be
9982 instantiated, but that's hard to forestall. */
9983 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
9991 /* An operator with this code is unary, but can also be binary. */
9994 ambi_op_p (enum tree_code code)
9996 return (code == INDIRECT_REF
9997 || code == ADDR_EXPR
9998 || code == UNARY_PLUS_EXPR
9999 || code == NEGATE_EXPR
10000 || code == PREINCREMENT_EXPR
10001 || code == PREDECREMENT_EXPR);
10004 /* An operator with this name can only be unary. */
10007 unary_op_p (enum tree_code code)
10009 return (code == TRUTH_NOT_EXPR
10010 || code == BIT_NOT_EXPR
10011 || code == COMPONENT_REF
10012 || code == TYPE_EXPR);
10015 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
10016 errors are issued for invalid declarations. */
10019 grok_op_properties (tree decl, bool complain)
10021 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
10023 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
10024 tree name = DECL_NAME (decl);
10025 enum tree_code operator_code;
10030 /* Count the number of arguments and check for ellipsis. */
10031 for (argtype = argtypes, arity = 0;
10032 argtype && argtype != void_list_node;
10033 argtype = TREE_CHAIN (argtype))
10035 ellipsis_p = !argtype;
10037 class_type = DECL_CONTEXT (decl);
10038 if (class_type && !CLASS_TYPE_P (class_type))
10039 class_type = NULL_TREE;
10041 if (DECL_CONV_FN_P (decl))
10042 operator_code = TYPE_EXPR;
10046 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
10047 if (ansi_opname (CODE) == name) \
10049 operator_code = (CODE); \
10052 else if (ansi_assopname (CODE) == name) \
10054 operator_code = (CODE); \
10055 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
10059 #include "operators.def"
10060 #undef DEF_OPERATOR
10062 gcc_unreachable ();
10065 gcc_assert (operator_code != MAX_TREE_CODES);
10066 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
10069 switch (operator_code)
10072 TYPE_HAS_NEW_OPERATOR (class_type) = 1;
10076 TYPE_GETS_DELETE (class_type) |= 1;
10080 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type) = 1;
10083 case VEC_DELETE_EXPR:
10084 TYPE_GETS_DELETE (class_type) |= 2;
10091 /* [basic.std.dynamic.allocation]/1:
10093 A program is ill-formed if an allocation function is declared
10094 in a namespace scope other than global scope or declared static
10097 The same also holds true for deallocation functions. */
10098 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR
10099 || operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
10101 if (DECL_NAMESPACE_SCOPE_P (decl))
10103 if (CP_DECL_CONTEXT (decl) != global_namespace)
10105 error ("%qD may not be declared within a namespace", decl);
10108 else if (!TREE_PUBLIC (decl))
10110 error ("%qD may not be declared as static", decl);
10116 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
10118 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
10119 DECL_IS_OPERATOR_NEW (decl) = 1;
10121 else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
10122 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
10125 /* An operator function must either be a non-static member function
10126 or have at least one parameter of a class, a reference to a class,
10127 an enumeration, or a reference to an enumeration. 13.4.0.6 */
10128 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
10130 if (operator_code == TYPE_EXPR
10131 || operator_code == CALL_EXPR
10132 || operator_code == COMPONENT_REF
10133 || operator_code == ARRAY_REF
10134 || operator_code == NOP_EXPR)
10136 error ("%qD must be a nonstatic member function", decl);
10143 if (DECL_STATIC_FUNCTION_P (decl))
10145 error ("%qD must be either a non-static member "
10146 "function or a non-member function", decl);
10150 for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
10152 tree arg = non_reference (TREE_VALUE (p));
10153 if (arg == error_mark_node)
10156 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
10157 because these checks are performed even on
10158 template functions. */
10159 if (MAYBE_CLASS_TYPE_P (arg)
10160 || TREE_CODE (arg) == ENUMERAL_TYPE)
10164 if (!p || p == void_list_node)
10167 error ("%qD must have an argument of class or "
10168 "enumerated type", decl);
10174 /* There are no restrictions on the arguments to an overloaded
10176 if (operator_code == CALL_EXPR)
10179 /* Warn about conversion operators that will never be used. */
10180 if (IDENTIFIER_TYPENAME_P (name)
10181 && ! DECL_TEMPLATE_INFO (decl)
10183 /* Warn only declaring the function; there is no need to
10184 warn again about out-of-class definitions. */
10185 && class_type == current_class_type)
10187 tree t = TREE_TYPE (name);
10188 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
10189 const char *what = 0;
10192 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
10194 if (TREE_CODE (t) == VOID_TYPE)
10196 else if (class_type)
10198 if (t == class_type)
10199 what = "the same type";
10200 /* Don't force t to be complete here. */
10201 else if (MAYBE_CLASS_TYPE_P (t)
10202 && COMPLETE_TYPE_P (t)
10203 && DERIVED_FROM_P (t, class_type))
10204 what = "a base class";
10208 warning (OPT_Wconversion, "conversion to %s%s will never use a type "
10209 "conversion operator",
10210 ref ? "a reference to " : "", what);
10213 if (operator_code == COND_EXPR)
10216 error ("ISO C++ prohibits overloading operator ?:");
10219 else if (ellipsis_p)
10221 error ("%qD must not have variable number of arguments", decl);
10224 else if (ambi_op_p (operator_code))
10227 /* We pick the one-argument operator codes by default, so
10228 we don't have to change anything. */
10230 else if (arity == 2)
10232 /* If we thought this was a unary operator, we now know
10233 it to be a binary operator. */
10234 switch (operator_code)
10237 operator_code = MULT_EXPR;
10241 operator_code = BIT_AND_EXPR;
10244 case UNARY_PLUS_EXPR:
10245 operator_code = PLUS_EXPR;
10249 operator_code = MINUS_EXPR;
10252 case PREINCREMENT_EXPR:
10253 operator_code = POSTINCREMENT_EXPR;
10256 case PREDECREMENT_EXPR:
10257 operator_code = POSTDECREMENT_EXPR;
10261 gcc_unreachable ();
10264 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
10266 if ((operator_code == POSTINCREMENT_EXPR
10267 || operator_code == POSTDECREMENT_EXPR)
10268 && ! processing_template_decl
10269 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
10272 error ("postfix %qD must take %<int%> as its argument",
10275 error ("postfix %qD must take %<int%> as its second "
10283 error ("%qD must take either zero or one argument", decl);
10285 error ("%qD must take either one or two arguments", decl);
10289 /* More Effective C++ rule 6. */
10291 && (operator_code == POSTINCREMENT_EXPR
10292 || operator_code == POSTDECREMENT_EXPR
10293 || operator_code == PREINCREMENT_EXPR
10294 || operator_code == PREDECREMENT_EXPR))
10296 tree arg = TREE_VALUE (argtypes);
10297 tree ret = TREE_TYPE (TREE_TYPE (decl));
10298 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
10299 arg = TREE_TYPE (arg);
10300 arg = TYPE_MAIN_VARIANT (arg);
10301 if (operator_code == PREINCREMENT_EXPR
10302 || operator_code == PREDECREMENT_EXPR)
10304 if (TREE_CODE (ret) != REFERENCE_TYPE
10305 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
10307 warning (OPT_Weffc__, "prefix %qD should return %qT", decl,
10308 build_reference_type (arg));
10312 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
10313 warning (OPT_Weffc__, "postfix %qD should return %qT", decl, arg);
10317 else if (unary_op_p (operator_code))
10322 error ("%qD must take %<void%>", decl);
10324 error ("%qD must take exactly one argument", decl);
10328 else /* if (binary_op_p (operator_code)) */
10333 error ("%qD must take exactly one argument", decl);
10335 error ("%qD must take exactly two arguments", decl);
10339 /* More Effective C++ rule 7. */
10341 && (operator_code == TRUTH_ANDIF_EXPR
10342 || operator_code == TRUTH_ORIF_EXPR
10343 || operator_code == COMPOUND_EXPR))
10344 warning (OPT_Weffc__, "user-defined %qD always evaluates both arguments",
10348 /* Effective C++ rule 23. */
10351 && !DECL_ASSIGNMENT_OPERATOR_P (decl)
10352 && (operator_code == PLUS_EXPR
10353 || operator_code == MINUS_EXPR
10354 || operator_code == TRUNC_DIV_EXPR
10355 || operator_code == MULT_EXPR
10356 || operator_code == TRUNC_MOD_EXPR)
10357 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
10358 warning (OPT_Weffc__, "%qD should return by value", decl);
10360 /* [over.oper]/8 */
10361 for (; argtypes && argtypes != void_list_node;
10362 argtypes = TREE_CHAIN (argtypes))
10363 if (TREE_PURPOSE (argtypes))
10365 TREE_PURPOSE (argtypes) = NULL_TREE;
10366 if (operator_code == POSTINCREMENT_EXPR
10367 || operator_code == POSTDECREMENT_EXPR)
10369 pedwarn (input_location, OPT_pedantic, "%qD cannot have default arguments",
10374 error ("%qD cannot have default arguments", decl);
10382 /* Return a string giving the keyword associate with CODE. */
10384 static const char *
10385 tag_name (enum tag_types code)
10397 case typename_type:
10400 gcc_unreachable ();
10404 /* Name lookup in an elaborated-type-specifier (after the keyword
10405 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
10406 elaborated-type-specifier is invalid, issue a diagnostic and return
10407 error_mark_node; otherwise, return the *_TYPE to which it referred.
10408 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
10411 check_elaborated_type_specifier (enum tag_types tag_code,
10413 bool allow_template_p)
10419 struct S { struct S *p; };
10421 name lookup will find the TYPE_DECL for the implicit "S::S"
10422 typedef. Adjust for that here. */
10423 if (DECL_SELF_REFERENCE_P (decl))
10424 decl = TYPE_NAME (TREE_TYPE (decl));
10426 type = TREE_TYPE (decl);
10428 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
10429 is false for this case as well. */
10430 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
10432 error ("using template type parameter %qT after %qs",
10433 type, tag_name (tag_code));
10434 return error_mark_node;
10438 If the identifier resolves to a typedef-name or a template
10439 type-parameter, the elaborated-type-specifier is ill-formed.
10441 In other words, the only legitimate declaration to use in the
10442 elaborated type specifier is the implicit typedef created when
10443 the type is declared. */
10444 else if (!DECL_IMPLICIT_TYPEDEF_P (decl)
10445 && tag_code != typename_type)
10447 error ("using typedef-name %qD after %qs", decl, tag_name (tag_code));
10448 error ("%q+D has a previous declaration here", decl);
10449 return error_mark_node;
10451 else if (TREE_CODE (type) != RECORD_TYPE
10452 && TREE_CODE (type) != UNION_TYPE
10453 && tag_code != enum_type
10454 && tag_code != typename_type)
10456 error ("%qT referred to as %qs", type, tag_name (tag_code));
10457 error ("%q+T has a previous declaration here", type);
10458 return error_mark_node;
10460 else if (TREE_CODE (type) != ENUMERAL_TYPE
10461 && tag_code == enum_type)
10463 error ("%qT referred to as enum", type);
10464 error ("%q+T has a previous declaration here", type);
10465 return error_mark_node;
10467 else if (!allow_template_p
10468 && TREE_CODE (type) == RECORD_TYPE
10469 && CLASSTYPE_IS_TEMPLATE (type))
10471 /* If a class template appears as elaborated type specifier
10472 without a template header such as:
10474 template <class T> class C {};
10475 void f(class C); // No template header here
10477 then the required template argument is missing. */
10478 error ("template argument required for %<%s %T%>",
10479 tag_name (tag_code),
10480 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
10481 return error_mark_node;
10487 /* Lookup NAME in elaborate type specifier in scope according to
10488 SCOPE and issue diagnostics if necessary.
10489 Return *_TYPE node upon success, NULL_TREE when the NAME is not
10490 found, and ERROR_MARK_NODE for type error. */
10493 lookup_and_check_tag (enum tag_types tag_code, tree name,
10494 tag_scope scope, bool template_header_p)
10498 if (scope == ts_global)
10500 /* First try ordinary name lookup, ignoring hidden class name
10501 injected via friend declaration. */
10502 decl = lookup_name_prefer_type (name, 2);
10503 /* If that fails, the name will be placed in the smallest
10504 non-class, non-function-prototype scope according to 3.3.1/5.
10505 We may already have a hidden name declared as friend in this
10506 scope. So lookup again but not ignoring hidden names.
10507 If we find one, that name will be made visible rather than
10508 creating a new tag. */
10510 decl = lookup_type_scope (name, ts_within_enclosing_non_class);
10513 decl = lookup_type_scope (name, scope);
10515 if (decl && DECL_CLASS_TEMPLATE_P (decl))
10516 decl = DECL_TEMPLATE_RESULT (decl);
10518 if (decl && TREE_CODE (decl) == TYPE_DECL)
10520 /* Look for invalid nested type:
10524 if (scope == ts_current && DECL_SELF_REFERENCE_P (decl))
10526 error ("%qD has the same name as the class in which it is "
10529 return error_mark_node;
10532 /* Two cases we need to consider when deciding if a class
10533 template is allowed as an elaborated type specifier:
10534 1. It is a self reference to its own class.
10535 2. It comes with a template header.
10539 template <class T> class C {
10540 class C *c1; // DECL_SELF_REFERENCE_P is true
10543 template <class U> class C; // template_header_p is true
10544 template <class T> class C<T>::D {
10545 class C *c2; // DECL_SELF_REFERENCE_P is true
10548 t = check_elaborated_type_specifier (tag_code,
10551 | DECL_SELF_REFERENCE_P (decl));
10554 else if (decl && TREE_CODE (decl) == TREE_LIST)
10556 error ("reference to %qD is ambiguous", name);
10557 print_candidates (decl);
10558 return error_mark_node;
10564 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
10565 Define the tag as a forward-reference if it is not defined.
10567 If a declaration is given, process it here, and report an error if
10568 multiple declarations are not identical.
10570 SCOPE is TS_CURRENT when this is also a definition. Only look in
10571 the current frame for the name (since C++ allows new names in any
10572 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
10573 declaration. Only look beginning from the current scope outward up
10574 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
10576 TEMPLATE_HEADER_P is true when this declaration is preceded by
10577 a set of template parameters. */
10580 xref_tag (enum tag_types tag_code, tree name,
10581 tag_scope scope, bool template_header_p)
10583 enum tree_code code;
10585 tree context = NULL_TREE;
10587 timevar_push (TV_NAME_LOOKUP);
10589 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
10595 code = RECORD_TYPE;
10601 code = ENUMERAL_TYPE;
10604 gcc_unreachable ();
10607 /* In case of anonymous name, xref_tag is only called to
10608 make type node and push name. Name lookup is not required. */
10609 if (ANON_AGGRNAME_P (name))
10612 t = lookup_and_check_tag (tag_code, name,
10613 scope, template_header_p);
10615 if (t == error_mark_node)
10616 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10618 if (scope != ts_current && t && current_class_type
10619 && template_class_depth (current_class_type)
10620 && template_header_p)
10622 /* Since SCOPE is not TS_CURRENT, we are not looking at a
10623 definition of this tag. Since, in addition, we are currently
10624 processing a (member) template declaration of a template
10625 class, we must be very careful; consider:
10632 { template <class V>
10633 friend struct S1; };
10635 Here, the S2::S1 declaration should not be confused with the
10636 outer declaration. In particular, the inner version should
10637 have a template parameter of level 2, not level 1. This
10638 would be particularly important if the member declaration
10641 template <class V = U> friend struct S1;
10643 say, when we should tsubst into `U' when instantiating
10644 S2. On the other hand, when presented with:
10654 we must find the inner binding eventually. We
10655 accomplish this by making sure that the new type we
10656 create to represent this declaration has the right
10658 context = TYPE_CONTEXT (t);
10664 /* If no such tag is yet defined, create a forward-reference node
10665 and record it as the "definition".
10666 When a real declaration of this type is found,
10667 the forward-reference will be altered into a real type. */
10668 if (code == ENUMERAL_TYPE)
10670 error ("use of enum %q#D without previous declaration", name);
10671 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10675 t = make_class_type (code);
10676 TYPE_CONTEXT (t) = context;
10677 t = pushtag (name, t, scope);
10682 if (template_header_p && MAYBE_CLASS_TYPE_P (t))
10684 if (!redeclare_class_template (t, current_template_parms))
10685 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10687 else if (!processing_template_decl
10688 && CLASS_TYPE_P (t)
10689 && CLASSTYPE_IS_TEMPLATE (t))
10691 error ("redeclaration of %qT as a non-template", t);
10692 error ("previous declaration %q+D", t);
10693 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10696 /* Make injected friend class visible. */
10697 if (scope != ts_within_enclosing_non_class
10698 && hidden_name_p (TYPE_NAME (t)))
10700 DECL_ANTICIPATED (TYPE_NAME (t)) = 0;
10701 DECL_FRIEND_P (TYPE_NAME (t)) = 0;
10703 if (TYPE_TEMPLATE_INFO (t))
10705 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t)) = 0;
10706 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t)) = 0;
10711 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
10715 xref_tag_from_type (tree old, tree id, tag_scope scope)
10717 enum tag_types tag_kind;
10719 if (TREE_CODE (old) == RECORD_TYPE)
10720 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
10722 tag_kind = union_type;
10724 if (id == NULL_TREE)
10725 id = TYPE_IDENTIFIER (old);
10727 return xref_tag (tag_kind, id, scope, false);
10730 /* Create the binfo hierarchy for REF with (possibly NULL) base list
10731 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
10732 access_* node, and the TREE_VALUE is the type of the base-class.
10733 Non-NULL TREE_TYPE indicates virtual inheritance.
10735 Returns true if the binfo hierarchy was successfully created,
10736 false if an error was detected. */
10739 xref_basetypes (tree ref, tree base_list)
10742 tree binfo, base_binfo;
10743 unsigned max_vbases = 0; /* Maximum direct & indirect virtual bases. */
10744 unsigned max_bases = 0; /* Maximum direct bases. */
10746 tree default_access;
10747 tree igo_prev; /* Track Inheritance Graph Order. */
10749 if (ref == error_mark_node)
10752 /* The base of a derived class is private by default, all others are
10754 default_access = (TREE_CODE (ref) == RECORD_TYPE
10755 && CLASSTYPE_DECLARED_CLASS (ref)
10756 ? access_private_node : access_public_node);
10758 /* First, make sure that any templates in base-classes are
10759 instantiated. This ensures that if we call ourselves recursively
10760 we do not get confused about which classes are marked and which
10762 basep = &base_list;
10765 tree basetype = TREE_VALUE (*basep);
10767 if (!(processing_template_decl && uses_template_parms (basetype))
10768 && !complete_type_or_else (basetype, NULL))
10769 /* An incomplete type. Remove it from the list. */
10770 *basep = TREE_CHAIN (*basep);
10774 if (TREE_TYPE (*basep))
10776 if (CLASS_TYPE_P (basetype))
10777 max_vbases += VEC_length (tree, CLASSTYPE_VBASECLASSES (basetype));
10778 basep = &TREE_CHAIN (*basep);
10782 TYPE_MARKED_P (ref) = 1;
10784 /* The binfo slot should be empty, unless this is an (ill-formed)
10786 gcc_assert (!TYPE_BINFO (ref) || TYPE_SIZE (ref));
10787 gcc_assert (TYPE_MAIN_VARIANT (ref) == ref);
10789 binfo = make_tree_binfo (max_bases);
10791 TYPE_BINFO (ref) = binfo;
10792 BINFO_OFFSET (binfo) = size_zero_node;
10793 BINFO_TYPE (binfo) = ref;
10795 /* Apply base-class info set up to the variants of this type. */
10796 fixup_type_variants (ref);
10800 BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, gc, max_bases);
10801 /* An aggregate cannot have baseclasses. */
10802 CLASSTYPE_NON_AGGREGATE (ref) = 1;
10804 if (TREE_CODE (ref) == UNION_TYPE)
10806 error ("derived union %qT invalid", ref);
10813 if (TYPE_FOR_JAVA (ref))
10815 error ("Java class %qT cannot have multiple bases", ref);
10822 CLASSTYPE_VBASECLASSES (ref) = VEC_alloc (tree, gc, max_vbases);
10824 if (TYPE_FOR_JAVA (ref))
10826 error ("Java class %qT cannot have virtual bases", ref);
10831 for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list))
10833 tree access = TREE_PURPOSE (base_list);
10834 int via_virtual = TREE_TYPE (base_list) != NULL_TREE;
10835 tree basetype = TREE_VALUE (base_list);
10837 if (access == access_default_node)
10838 access = default_access;
10840 if (PACK_EXPANSION_P (basetype))
10841 basetype = PACK_EXPANSION_PATTERN (basetype);
10842 if (TREE_CODE (basetype) == TYPE_DECL)
10843 basetype = TREE_TYPE (basetype);
10844 if (!MAYBE_CLASS_TYPE_P (basetype) || TREE_CODE (basetype) == UNION_TYPE)
10846 error ("base type %qT fails to be a struct or class type",
10851 if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0))
10852 TYPE_FOR_JAVA (ref) = 1;
10854 base_binfo = NULL_TREE;
10855 if (CLASS_TYPE_P (basetype) && !dependent_type_p (basetype))
10857 base_binfo = TYPE_BINFO (basetype);
10858 /* The original basetype could have been a typedef'd type. */
10859 basetype = BINFO_TYPE (base_binfo);
10861 /* Inherit flags from the base. */
10862 TYPE_HAS_NEW_OPERATOR (ref)
10863 |= TYPE_HAS_NEW_OPERATOR (basetype);
10864 TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
10865 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
10866 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
10867 TYPE_HAS_CONVERSION (ref) |= TYPE_HAS_CONVERSION (basetype);
10868 CLASSTYPE_DIAMOND_SHAPED_P (ref)
10869 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype);
10870 CLASSTYPE_REPEATED_BASE_P (ref)
10871 |= CLASSTYPE_REPEATED_BASE_P (basetype);
10874 /* We must do this test after we've seen through a typedef
10876 if (TYPE_MARKED_P (basetype))
10878 if (basetype == ref)
10879 error ("recursive type %qT undefined", basetype);
10881 error ("duplicate base type %qT invalid", basetype);
10885 if (PACK_EXPANSION_P (TREE_VALUE (base_list)))
10886 /* Regenerate the pack expansion for the bases. */
10887 basetype = make_pack_expansion (basetype);
10889 TYPE_MARKED_P (basetype) = 1;
10891 base_binfo = copy_binfo (base_binfo, basetype, ref,
10892 &igo_prev, via_virtual);
10893 if (!BINFO_INHERITANCE_CHAIN (base_binfo))
10894 BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
10896 BINFO_BASE_APPEND (binfo, base_binfo);
10897 BINFO_BASE_ACCESS_APPEND (binfo, access);
10900 if (VEC_space (tree, CLASSTYPE_VBASECLASSES (ref), 1))
10901 /* If we have space in the vbase vector, we must have shared at
10902 least one of them, and are therefore diamond shaped. */
10903 CLASSTYPE_DIAMOND_SHAPED_P (ref) = 1;
10905 /* Unmark all the types. */
10906 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
10907 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
10908 TYPE_MARKED_P (ref) = 0;
10910 /* Now see if we have a repeated base type. */
10911 if (!CLASSTYPE_REPEATED_BASE_P (ref))
10913 for (base_binfo = binfo; base_binfo;
10914 base_binfo = TREE_CHAIN (base_binfo))
10916 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
10918 CLASSTYPE_REPEATED_BASE_P (ref) = 1;
10921 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 1;
10923 for (base_binfo = binfo; base_binfo;
10924 base_binfo = TREE_CHAIN (base_binfo))
10925 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
10926 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
10935 /* Begin compiling the definition of an enumeration type.
10938 UNDERLYING_TYPE is the type that will be used as the storage for
10939 the enumeration type. This should be NULL_TREE if no storage type
10942 SCOPED_ENUM_P is true if this is a scoped enumeration type.
10944 Returns the type object, as yet incomplete.
10945 Also records info about it so that build_enumerator
10946 may be used to declare the individual values as they are read. */
10949 start_enum (tree name, tree underlying_type, bool scoped_enum_p)
10953 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
10955 /* If this is the real definition for a previous forward reference,
10956 fill in the contents in the same object that used to be the
10957 forward reference. */
10959 enumtype = lookup_and_check_tag (enum_type, name,
10960 /*tag_scope=*/ts_current,
10961 /*template_header_p=*/false);
10963 if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
10965 error ("multiple definition of %q#T", enumtype);
10966 error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype));
10967 /* Clear out TYPE_VALUES, and start again. */
10968 TYPE_VALUES (enumtype) = NULL_TREE;
10972 /* In case of error, make a dummy enum to allow parsing to
10974 if (enumtype == error_mark_node)
10975 name = make_anon_name ();
10977 enumtype = make_node (ENUMERAL_TYPE);
10978 enumtype = pushtag (name, enumtype, /*tag_scope=*/ts_current);
10981 if (enumtype == error_mark_node)
10986 SET_SCOPED_ENUM_P (enumtype, 1);
10987 begin_scope (sk_scoped_enum, enumtype);
10989 /* [C++0x dcl.enum]p5:
10991 If not explicitly specified, the underlying type of a scoped
10992 enumeration type is int. */
10993 if (!underlying_type)
10994 underlying_type = integer_type_node;
10997 if (underlying_type)
10999 if (CP_INTEGRAL_TYPE_P (underlying_type))
11001 TYPE_MIN_VALUE (enumtype) = TYPE_MIN_VALUE (underlying_type);
11002 TYPE_MAX_VALUE (enumtype) = TYPE_MAX_VALUE (underlying_type);
11003 TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
11004 TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
11005 SET_TYPE_MODE (enumtype, TYPE_MODE (underlying_type));
11006 TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type);
11007 TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
11008 TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
11009 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);
11010 ENUM_UNDERLYING_TYPE (enumtype) = underlying_type;
11013 error ("underlying type %<%T%> of %<%T%> must be an integral type",
11014 underlying_type, enumtype);
11020 /* After processing and defining all the values of an enumeration type,
11021 install their decls in the enumeration type and finish it off.
11022 ENUMTYPE is the type object and VALUES a list of name-value pairs. */
11025 finish_enum (tree enumtype)
11034 bool use_short_enum;
11038 integer_type_kind itk;
11039 tree underlying_type = NULL_TREE;
11040 bool fixed_underlying_type_p
11041 = ENUM_UNDERLYING_TYPE (enumtype) != NULL_TREE;
11043 /* We built up the VALUES in reverse order. */
11044 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
11046 /* For an enum defined in a template, just set the type of the values;
11047 all further processing is postponed until the template is
11048 instantiated. We need to set the type so that tsubst of a CONST_DECL
11050 if (processing_template_decl)
11052 for (values = TYPE_VALUES (enumtype);
11054 values = TREE_CHAIN (values))
11055 TREE_TYPE (TREE_VALUE (values)) = enumtype;
11056 if (at_function_scope_p ())
11057 add_stmt (build_min (TAG_DEFN, enumtype));
11061 /* Determine the minimum and maximum values of the enumerators. */
11062 if (TYPE_VALUES (enumtype))
11064 minnode = maxnode = NULL_TREE;
11066 for (values = TYPE_VALUES (enumtype);
11068 values = TREE_CHAIN (values))
11070 decl = TREE_VALUE (values);
11072 /* [dcl.enum]: Following the closing brace of an enum-specifier,
11073 each enumerator has the type of its enumeration. Prior to the
11074 closing brace, the type of each enumerator is the type of its
11075 initializing value. */
11076 TREE_TYPE (decl) = enumtype;
11078 /* Update the minimum and maximum values, if appropriate. */
11079 value = DECL_INITIAL (decl);
11080 if (value == error_mark_node)
11081 value = integer_zero_node;
11082 /* Figure out what the minimum and maximum values of the
11083 enumerators are. */
11085 minnode = maxnode = value;
11086 else if (tree_int_cst_lt (maxnode, value))
11088 else if (tree_int_cst_lt (value, minnode))
11095 If the enumerator-list is empty, the underlying type is as if
11096 the enumeration had a single enumerator with value 0. */
11097 minnode = maxnode = integer_zero_node;
11099 /* Compute the number of bits require to represent all values of the
11100 enumeration. We must do this before the type of MINNODE and
11101 MAXNODE are transformed, since tree_int_cst_min_precision relies
11102 on the TREE_TYPE of the value it is passed. */
11103 unsignedp = tree_int_cst_sgn (minnode) >= 0;
11104 lowprec = tree_int_cst_min_precision (minnode, unsignedp);
11105 highprec = tree_int_cst_min_precision (maxnode, unsignedp);
11106 precision = MAX (lowprec, highprec);
11108 if (!fixed_underlying_type_p)
11110 /* Determine the underlying type of the enumeration.
11114 The underlying type of an enumeration is an integral type that
11115 can represent all the enumerator values defined in the
11116 enumeration. It is implementation-defined which integral type is
11117 used as the underlying type for an enumeration except that the
11118 underlying type shall not be larger than int unless the value of
11119 an enumerator cannot fit in an int or unsigned int.
11121 We use "int" or an "unsigned int" as the underlying type, even if
11122 a smaller integral type would work, unless the user has
11123 explicitly requested that we use the smallest possible type. The
11124 user can request that for all enumerations with a command line
11125 flag, or for just one enumeration with an attribute. */
11127 use_short_enum = flag_short_enums
11128 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype));
11130 for (itk = (use_short_enum ? itk_char : itk_int);
11134 underlying_type = integer_types[itk];
11135 if (TYPE_PRECISION (underlying_type) >= precision
11136 && TYPE_UNSIGNED (underlying_type) == unsignedp)
11139 if (itk == itk_none)
11143 IF no integral type can represent all the enumerator values, the
11144 enumeration is ill-formed. */
11145 error ("no integral type can represent all of the enumerator values "
11146 "for %qT", enumtype);
11147 precision = TYPE_PRECISION (long_long_integer_type_node);
11148 underlying_type = integer_types[itk_unsigned_long_long];
11153 The value of sizeof() applied to an enumeration type, an object
11154 of an enumeration type, or an enumerator, is the value of sizeof()
11155 applied to the underlying type. */
11156 TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
11157 TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
11158 SET_TYPE_MODE (enumtype, TYPE_MODE (underlying_type));
11159 TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
11160 TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
11161 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);
11163 /* Set the underlying type of the enumeration type to the
11164 computed enumeration type, restricted to the enumerator
11166 ENUM_UNDERLYING_TYPE (enumtype) = copy_node (underlying_type);
11167 set_min_and_max_values_for_integral_type
11168 (ENUM_UNDERLYING_TYPE (enumtype), precision, unsignedp);
11171 underlying_type = ENUM_UNDERLYING_TYPE (enumtype);
11173 /* Compute the minimum and maximum values for the type.
11177 For an enumeration where emin is the smallest enumerator and emax
11178 is the largest, the values of the enumeration are the values of the
11179 underlying type in the range bmin to bmax, where bmin and bmax are,
11180 respectively, the smallest and largest values of the smallest bit-
11181 field that can store emin and emax. */
11183 /* The middle-end currently assumes that types with TYPE_PRECISION
11184 narrower than their underlying type are suitably zero or sign
11185 extended to fill their mode. g++ doesn't make these guarantees.
11186 Until the middle-end can represent such paradoxical types, we
11187 set the TYPE_PRECISION to the width of the underlying type. */
11188 TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type);
11190 set_min_and_max_values_for_integral_type (enumtype, precision, unsignedp);
11192 /* Convert each of the enumerators to the type of the underlying
11193 type of the enumeration. */
11194 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
11196 location_t saved_location;
11198 decl = TREE_VALUE (values);
11199 saved_location = input_location;
11200 input_location = DECL_SOURCE_LOCATION (decl);
11201 if (fixed_underlying_type_p)
11202 /* If the enumeration type has a fixed underlying type, we
11203 already checked all of the enumerator values. */
11204 value = DECL_INITIAL (decl);
11206 value = perform_implicit_conversion (underlying_type,
11207 DECL_INITIAL (decl),
11208 tf_warning_or_error);
11209 input_location = saved_location;
11211 /* Do not clobber shared ints. */
11212 value = copy_node (value);
11214 TREE_TYPE (value) = enumtype;
11215 DECL_INITIAL (decl) = value;
11218 /* Fix up all variant types of this enum type. */
11219 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
11221 TYPE_VALUES (t) = TYPE_VALUES (enumtype);
11222 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
11223 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
11224 TYPE_SIZE (t) = TYPE_SIZE (enumtype);
11225 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
11226 SET_TYPE_MODE (t, TYPE_MODE (enumtype));
11227 TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
11228 TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
11229 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
11230 TYPE_UNSIGNED (t) = TYPE_UNSIGNED (enumtype);
11231 ENUM_UNDERLYING_TYPE (t) = ENUM_UNDERLYING_TYPE (enumtype);
11234 /* Finish up the scope of a scoped enumeration. */
11235 if (SCOPED_ENUM_P (enumtype))
11238 /* Finish debugging output for this type. */
11239 rest_of_type_compilation (enumtype, namespace_bindings_p ());
11242 /* Build and install a CONST_DECL for an enumeration constant of the
11243 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
11244 Assignment of sequential values by default is handled here. */
11247 build_enumerator (tree name, tree value, tree enumtype)
11253 /* If the VALUE was erroneous, pretend it wasn't there; that will
11254 result in the enum being assigned the next value in sequence. */
11255 if (value == error_mark_node)
11258 /* Remove no-op casts from the value. */
11260 STRIP_TYPE_NOPS (value);
11262 if (! processing_template_decl)
11264 /* Validate and default VALUE. */
11265 if (value != NULL_TREE)
11267 value = integral_constant_value (value);
11269 if (TREE_CODE (value) == INTEGER_CST)
11271 value = perform_integral_promotions (value);
11272 constant_expression_warning (value);
11276 error ("enumerator value for %qD is not an integer constant", name);
11281 /* Default based on previous value. */
11282 if (value == NULL_TREE)
11284 if (TYPE_VALUES (enumtype))
11287 unsigned HOST_WIDE_INT lo;
11291 /* The next value is the previous value plus one.
11292 add_double doesn't know the type of the target expression,
11293 so we must check with int_fits_type_p as well. */
11294 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
11295 if (error_operand_p (prev_value))
11296 value = error_mark_node;
11299 overflowed = add_double (TREE_INT_CST_LOW (prev_value),
11300 TREE_INT_CST_HIGH (prev_value),
11302 value = build_int_cst_wide (TREE_TYPE (prev_value), lo, hi);
11304 |= !int_fits_type_p (value, TREE_TYPE (prev_value));
11308 error ("overflow in enumeration values at %qD", name);
11309 value = error_mark_node;
11314 value = integer_zero_node;
11317 /* Remove no-op casts from the value. */
11318 STRIP_TYPE_NOPS (value);
11320 /* If the underlying type of the enum is fixed, check whether
11321 the enumerator values fits in the underlying type. If it
11322 does not fit, the program is ill-formed [C++0x dcl.enum]. */
11323 if (ENUM_UNDERLYING_TYPE (enumtype)
11325 && TREE_CODE (value) == INTEGER_CST
11326 && !int_fits_type_p (value, ENUM_UNDERLYING_TYPE (enumtype)))
11328 error ("enumerator value %E is too large for underlying type %<%T%>",
11329 value, ENUM_UNDERLYING_TYPE (enumtype));
11331 /* Silently convert the value so that we can continue. */
11332 value = perform_implicit_conversion (ENUM_UNDERLYING_TYPE (enumtype),
11337 /* C++ associates enums with global, function, or class declarations. */
11338 context = current_scope ();
11340 /* Build the actual enumeration constant. Note that the enumeration
11341 constants have the underlying type of the enum (if it is fixed)
11342 or the type of their initializer (if the underlying type of the
11343 enum is not fixed):
11347 If the underlying type is fixed, the type of each enumerator
11348 prior to the closing brace is the underlying type; if the
11349 initializing value of an enumerator cannot be represented by
11350 the underlying type, the program is ill-formed. If the
11351 underlying type is not fixed, the type of each enumerator is
11352 the type of its initializing value.
11354 If the underlying type is not fixed, it will be computed by
11355 finish_enum and we will reset the type of this enumerator. Of
11356 course, if we're processing a template, there may be no value. */
11357 type = value ? TREE_TYPE (value) : NULL_TREE;
11359 if (context && context == current_class_type)
11360 /* This enum declaration is local to the class. We need the full
11361 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
11362 decl = build_lang_decl (CONST_DECL, name, type);
11364 /* It's a global enum, or it's local to a function. (Note local to
11365 a function could mean local to a class method. */
11366 decl = build_decl (CONST_DECL, name, type);
11368 DECL_CONTEXT (decl) = FROB_CONTEXT (context);
11369 TREE_CONSTANT (decl) = 1;
11370 TREE_READONLY (decl) = 1;
11371 DECL_INITIAL (decl) = value;
11373 if (context && context == current_class_type)
11374 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
11375 on the TYPE_FIELDS list for `S'. (That's so that you can say
11376 things like `S::i' later.) */
11377 finish_member_declaration (decl);
11381 /* Add this enumeration constant to the list for this type. */
11382 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
11385 /* Look for an enumerator with the given NAME within the enumeration
11386 type ENUMTYPE. This routine is used primarily for qualified name
11387 lookup into an enumerator in C++0x, e.g.,
11389 enum class Color { Red, Green, Blue };
11391 Color color = Color::Red;
11393 Returns the value corresponding to the enumerator, or
11394 NULL_TREE if no such enumerator was found. */
11396 lookup_enumerator (tree enumtype, tree name)
11399 gcc_assert (enumtype && TREE_CODE (enumtype) == ENUMERAL_TYPE);
11401 e = purpose_member (name, TYPE_VALUES (enumtype));
11402 return e? TREE_VALUE (e) : NULL_TREE;
11406 /* We're defining DECL. Make sure that it's type is OK. */
11409 check_function_type (tree decl, tree current_function_parms)
11411 tree fntype = TREE_TYPE (decl);
11412 tree return_type = complete_type (TREE_TYPE (fntype));
11414 /* In a function definition, arg types must be complete. */
11415 require_complete_types_for_parms (current_function_parms);
11417 if (dependent_type_p (return_type))
11419 if (!COMPLETE_OR_VOID_TYPE_P (return_type)
11420 || (TYPE_FOR_JAVA (return_type) && MAYBE_CLASS_TYPE_P (return_type)))
11422 tree args = TYPE_ARG_TYPES (fntype);
11424 if (!COMPLETE_OR_VOID_TYPE_P (return_type))
11425 error ("return type %q#T is incomplete", return_type);
11427 error ("return type has Java class type %q#T", return_type);
11429 /* Make it return void instead. */
11430 if (TREE_CODE (fntype) == METHOD_TYPE)
11431 fntype = build_method_type_directly (TREE_TYPE (TREE_VALUE (args)),
11433 TREE_CHAIN (args));
11435 fntype = build_function_type (void_type_node, args);
11437 = build_exception_variant (fntype,
11438 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)));
11441 abstract_virtuals_error (decl, TREE_TYPE (fntype));
11444 /* Create the FUNCTION_DECL for a function definition.
11445 DECLSPECS and DECLARATOR are the parts of the declaration;
11446 they describe the function's name and the type it returns,
11447 but twisted together in a fashion that parallels the syntax of C.
11449 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
11450 DECLARATOR is really the DECL for the function we are about to
11451 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
11452 indicating that the function is an inline defined in-class.
11454 This function creates a binding context for the function body
11455 as well as setting up the FUNCTION_DECL in current_function_decl.
11457 For C++, we must first check whether that datum makes any sense.
11458 For example, "class A local_a(1,2);" means that variable local_a
11459 is an aggregate of type A, which should have a constructor
11460 applied to it with the argument list [1, 2].
11462 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
11463 or may be a BLOCK if the function has been defined previously
11464 in this translation unit. On exit, DECL_INITIAL (decl1) will be
11465 error_mark_node if the function has never been defined, or
11466 a BLOCK if the function has been defined somewhere. */
11469 start_preparsed_function (tree decl1, tree attrs, int flags)
11471 tree ctype = NULL_TREE;
11474 int doing_friend = 0;
11475 struct cp_binding_level *bl;
11476 tree current_function_parms;
11477 struct c_fileinfo *finfo
11478 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1)));
11479 bool honor_interface;
11481 /* Sanity check. */
11482 gcc_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE);
11483 gcc_assert (TREE_CHAIN (void_list_node) == NULL_TREE);
11485 fntype = TREE_TYPE (decl1);
11486 if (TREE_CODE (fntype) == METHOD_TYPE)
11487 ctype = TYPE_METHOD_BASETYPE (fntype);
11489 /* ISO C++ 11.4/5. A friend function defined in a class is in
11490 the (lexical) scope of the class in which it is defined. */
11491 if (!ctype && DECL_FRIEND_P (decl1))
11493 ctype = DECL_FRIEND_CONTEXT (decl1);
11495 /* CTYPE could be null here if we're dealing with a template;
11496 for example, `inline friend float foo()' inside a template
11497 will have no CTYPE set. */
11498 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
11504 if (DECL_DECLARED_INLINE_P (decl1)
11505 && lookup_attribute ("noinline", attrs))
11506 warning (0, "inline function %q+D given attribute noinline", decl1);
11508 /* Handle gnu_inline attribute. */
11509 if (GNU_INLINE_P (decl1))
11511 DECL_EXTERNAL (decl1) = 1;
11512 DECL_NOT_REALLY_EXTERN (decl1) = 0;
11513 DECL_INTERFACE_KNOWN (decl1) = 1;
11514 DECL_DISREGARD_INLINE_LIMITS (decl1) = 1;
11517 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
11518 /* This is a constructor, we must ensure that any default args
11519 introduced by this definition are propagated to the clones
11520 now. The clones are used directly in overload resolution. */
11521 adjust_clone_args (decl1);
11523 /* Sometimes we don't notice that a function is a static member, and
11524 build a METHOD_TYPE for it. Fix that up now. */
11525 if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
11526 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
11528 revert_static_member_fn (decl1);
11532 /* Set up current_class_type, and enter the scope of the class, if
11535 push_nested_class (ctype);
11536 else if (DECL_STATIC_FUNCTION_P (decl1))
11537 push_nested_class (DECL_CONTEXT (decl1));
11539 /* Now that we have entered the scope of the class, we must restore
11540 the bindings for any template parameters surrounding DECL1, if it
11541 is an inline member template. (Order is important; consider the
11542 case where a template parameter has the same name as a field of
11543 the class.) It is not until after this point that
11544 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
11545 if (flags & SF_INCLASS_INLINE)
11546 maybe_begin_member_template_processing (decl1);
11548 /* Effective C++ rule 15. */
11550 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
11551 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
11552 warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");
11554 /* Make the init_value nonzero so pushdecl knows this is not tentative.
11555 error_mark_node is replaced below (in poplevel) with the BLOCK. */
11556 if (!DECL_INITIAL (decl1))
11557 DECL_INITIAL (decl1) = error_mark_node;
11559 /* This function exists in static storage.
11560 (This does not mean `static' in the C sense!) */
11561 TREE_STATIC (decl1) = 1;
11563 /* We must call push_template_decl after current_class_type is set
11564 up. (If we are processing inline definitions after exiting a
11565 class scope, current_class_type will be NULL_TREE until set above
11566 by push_nested_class.) */
11567 if (processing_template_decl)
11569 /* FIXME: Handle error_mark_node more gracefully. */
11570 tree newdecl1 = push_template_decl (decl1);
11571 if (newdecl1 != error_mark_node)
11575 /* We are now in the scope of the function being defined. */
11576 current_function_decl = decl1;
11578 /* Save the parm names or decls from this function's declarator
11579 where store_parm_decls will find them. */
11580 current_function_parms = DECL_ARGUMENTS (decl1);
11582 /* Make sure the parameter and return types are reasonable. When
11583 you declare a function, these types can be incomplete, but they
11584 must be complete when you define the function. */
11585 check_function_type (decl1, current_function_parms);
11587 /* Build the return declaration for the function. */
11588 restype = TREE_TYPE (fntype);
11589 if (DECL_RESULT (decl1) == NULL_TREE)
11593 resdecl = build_decl (RESULT_DECL, 0, restype);
11594 DECL_ARTIFICIAL (resdecl) = 1;
11595 DECL_IGNORED_P (resdecl) = 1;
11596 DECL_RESULT (decl1) = resdecl;
11598 cp_apply_type_quals_to_decl (cp_type_quals (restype), resdecl);
11601 /* Let the user know we're compiling this function. */
11602 announce_function (decl1);
11604 /* Record the decl so that the function name is defined.
11605 If we already have a decl for this name, and it is a FUNCTION_DECL,
11606 use the old decl. */
11607 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
11609 /* A specialization is not used to guide overload resolution. */
11610 if (!DECL_FUNCTION_MEMBER_P (decl1)
11611 && !(DECL_USE_TEMPLATE (decl1) &&
11612 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1))))
11614 tree olddecl = pushdecl (decl1);
11616 if (olddecl == error_mark_node)
11617 /* If something went wrong when registering the declaration,
11618 use DECL1; we have to have a FUNCTION_DECL to use when
11619 parsing the body of the function. */
11623 /* Otherwise, OLDDECL is either a previous declaration
11624 of the same function or DECL1 itself. */
11626 if (warn_missing_declarations
11627 && olddecl == decl1
11628 && !DECL_MAIN_P (decl1)
11629 && TREE_PUBLIC (decl1)
11630 && !DECL_DECLARED_INLINE_P (decl1))
11634 /* Check whether DECL1 is in an anonymous
11636 for (context = DECL_CONTEXT (decl1);
11638 context = DECL_CONTEXT (context))
11640 if (TREE_CODE (context) == NAMESPACE_DECL
11641 && DECL_NAME (context) == NULL_TREE)
11645 if (context == NULL)
11646 warning (OPT_Wmissing_declarations,
11647 "no previous declaration for %q+D", decl1);
11655 /* We need to set the DECL_CONTEXT. */
11656 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
11657 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
11659 fntype = TREE_TYPE (decl1);
11661 /* If #pragma weak applies, mark the decl appropriately now.
11662 The pragma only applies to global functions. Because
11663 determining whether or not the #pragma applies involves
11664 computing the mangled name for the declaration, we cannot
11665 apply the pragma until after we have merged this declaration
11666 with any previous declarations; if the original declaration
11667 has a linkage specification, that specification applies to
11668 the definition as well, and may affect the mangled name. */
11669 if (!DECL_CONTEXT (decl1))
11670 maybe_apply_pragma_weak (decl1);
11673 /* Reset this in case the call to pushdecl changed it. */
11674 current_function_decl = decl1;
11676 gcc_assert (DECL_INITIAL (decl1));
11678 /* This function may already have been parsed, in which case just
11679 return; our caller will skip over the body without parsing. */
11680 if (DECL_INITIAL (decl1) != error_mark_node)
11683 /* Initialize RTL machinery. We cannot do this until
11684 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
11685 even when processing a template; this is how we get
11686 CFUN set up, and our per-function variables initialized.
11687 FIXME factor out the non-RTL stuff. */
11688 bl = current_binding_level;
11689 allocate_struct_function (decl1, processing_template_decl);
11691 /* Initialize the language data structures. Whenever we start
11692 a new function, we destroy temporaries in the usual way. */
11693 cfun->language = GGC_CNEW (struct language_function);
11694 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
11695 current_binding_level = bl;
11697 /* Even though we're inside a function body, we still don't want to
11698 call expand_expr to calculate the size of a variable-sized array.
11699 We haven't necessarily assigned RTL to all variables yet, so it's
11700 not safe to try to expand expressions involving them. */
11701 cfun->dont_save_pending_sizes_p = 1;
11703 /* Start the statement-tree, start the tree now. */
11704 DECL_SAVED_TREE (decl1) = push_stmt_list ();
11706 /* If we are (erroneously) defining a function that we have already
11707 defined before, wipe out what we knew before. */
11708 if (!DECL_PENDING_INLINE_P (decl1))
11709 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
11711 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
11713 /* We know that this was set up by `grokclassfn'. We do not
11714 wait until `store_parm_decls', since evil parse errors may
11715 never get us to that point. Here we keep the consistency
11716 between `current_class_type' and `current_class_ptr'. */
11717 tree t = DECL_ARGUMENTS (decl1);
11719 gcc_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL);
11720 gcc_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE);
11722 cp_function_chain->x_current_class_ref
11723 = cp_build_indirect_ref (t, NULL, tf_warning_or_error);
11724 cp_function_chain->x_current_class_ptr = t;
11726 /* Constructors and destructors need to know whether they're "in
11727 charge" of initializing virtual base classes. */
11728 t = TREE_CHAIN (t);
11729 if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
11731 current_in_charge_parm = t;
11732 t = TREE_CHAIN (t);
11734 if (DECL_HAS_VTT_PARM_P (decl1))
11736 gcc_assert (DECL_NAME (t) == vtt_parm_identifier);
11737 current_vtt_parm = t;
11741 honor_interface = (!DECL_TEMPLATE_INSTANTIATION (decl1)
11742 /* Implicitly-defined methods (like the
11743 destructor for a class in which no destructor
11744 is explicitly declared) must not be defined
11745 until their definition is needed. So, we
11746 ignore interface specifications for
11747 compiler-generated functions. */
11748 && !DECL_ARTIFICIAL (decl1));
11750 if (DECL_INTERFACE_KNOWN (decl1))
11752 tree ctx = decl_function_context (decl1);
11754 if (DECL_NOT_REALLY_EXTERN (decl1))
11755 DECL_EXTERNAL (decl1) = 0;
11757 if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
11758 && TREE_PUBLIC (ctx))
11759 /* This is a function in a local class in an extern inline
11761 comdat_linkage (decl1);
11763 /* If this function belongs to an interface, it is public.
11764 If it belongs to someone else's interface, it is also external.
11765 This only affects inlines and template instantiations. */
11766 else if (!finfo->interface_unknown && honor_interface)
11768 if (DECL_DECLARED_INLINE_P (decl1)
11769 || DECL_TEMPLATE_INSTANTIATION (decl1)
11770 || processing_template_decl)
11772 DECL_EXTERNAL (decl1)
11773 = (finfo->interface_only
11774 || (DECL_DECLARED_INLINE_P (decl1)
11775 && ! flag_implement_inlines
11776 && !DECL_VINDEX (decl1)));
11778 /* For WIN32 we also want to put these in linkonce sections. */
11779 maybe_make_one_only (decl1);
11782 DECL_EXTERNAL (decl1) = 0;
11783 DECL_INTERFACE_KNOWN (decl1) = 1;
11784 /* If this function is in an interface implemented in this file,
11785 make sure that the back end knows to emit this function
11787 if (!DECL_EXTERNAL (decl1))
11788 mark_needed (decl1);
11790 else if (finfo->interface_unknown && finfo->interface_only
11791 && honor_interface)
11793 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
11794 interface, we will have both finfo->interface_unknown and
11795 finfo->interface_only set. In that case, we don't want to
11796 use the normal heuristics because someone will supply a
11797 #pragma implementation elsewhere, and deducing it here would
11798 produce a conflict. */
11799 comdat_linkage (decl1);
11800 DECL_EXTERNAL (decl1) = 0;
11801 DECL_INTERFACE_KNOWN (decl1) = 1;
11802 DECL_DEFER_OUTPUT (decl1) = 1;
11806 /* This is a definition, not a reference.
11807 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
11808 if (!GNU_INLINE_P (decl1))
11809 DECL_EXTERNAL (decl1) = 0;
11811 if ((DECL_DECLARED_INLINE_P (decl1)
11812 || DECL_TEMPLATE_INSTANTIATION (decl1))
11813 && ! DECL_INTERFACE_KNOWN (decl1)
11814 /* Don't try to defer nested functions for now. */
11815 && ! decl_function_context (decl1))
11816 DECL_DEFER_OUTPUT (decl1) = 1;
11818 DECL_INTERFACE_KNOWN (decl1) = 1;
11821 /* Determine the ELF visibility attribute for the function. We must not
11822 do this before calling "pushdecl", as we must allow "duplicate_decls"
11823 to merge any attributes appropriately. We also need to wait until
11825 if (!DECL_CLONED_FUNCTION_P (decl1))
11826 determine_visibility (decl1);
11828 begin_scope (sk_function_parms, decl1);
11832 if (DECL_DESTRUCTOR_P (decl1)
11833 || (DECL_CONSTRUCTOR_P (decl1)
11834 && targetm.cxx.cdtor_returns_this ()))
11836 cdtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
11837 DECL_CONTEXT (cdtor_label) = current_function_decl;
11840 start_fname_decls ();
11842 store_parm_decls (current_function_parms);
11846 /* Like start_preparsed_function, except that instead of a
11847 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
11849 Returns 1 on success. If the DECLARATOR is not suitable for a function
11850 (it defines a datum instead), we return 0, which tells
11851 yyparse to report a parse error. */
11854 start_function (cp_decl_specifier_seq *declspecs,
11855 const cp_declarator *declarator,
11860 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
11861 if (decl1 == error_mark_node)
11863 /* If the declarator is not suitable for a function definition,
11864 cause a syntax error. */
11865 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
11867 error ("invalid function declaration");
11871 if (DECL_MAIN_P (decl1))
11872 /* main must return int. grokfndecl should have corrected it
11873 (and issued a diagnostic) if the user got it wrong. */
11874 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1)),
11875 integer_type_node));
11877 start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT);
11882 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
11886 use_eh_spec_block (tree fn)
11888 return (flag_exceptions && flag_enforce_eh_specs
11889 && !processing_template_decl
11890 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn))
11891 /* We insert the EH_SPEC_BLOCK only in the original
11892 function; then, it is copied automatically to the
11894 && !DECL_CLONED_FUNCTION_P (fn)
11895 /* Implicitly-generated constructors and destructors have
11896 exception specifications. However, those specifications
11897 are the union of the possible exceptions specified by the
11898 constructors/destructors for bases and members, so no
11899 unallowed exception will ever reach this function. By
11900 not creating the EH_SPEC_BLOCK we save a little memory,
11901 and we avoid spurious warnings about unreachable
11903 && !DECL_ARTIFICIAL (fn));
11906 /* Store the parameter declarations into the current function declaration.
11907 This is called after parsing the parameter declarations, before
11908 digesting the body of the function.
11910 Also install to binding contour return value identifier, if any. */
11913 store_parm_decls (tree current_function_parms)
11915 tree fndecl = current_function_decl;
11918 /* This is a chain of any other decls that came in among the parm
11919 declarations. If a parm is declared with enum {foo, bar} x;
11920 then CONST_DECLs for foo and bar are put here. */
11921 tree nonparms = NULL_TREE;
11923 if (current_function_parms)
11925 /* This case is when the function was defined with an ANSI prototype.
11926 The parms already have decls, so we need not do anything here
11927 except record them as in effect
11928 and complain if any redundant old-style parm decls were written. */
11930 tree specparms = current_function_parms;
11933 /* Must clear this because it might contain TYPE_DECLs declared
11935 current_binding_level->names = NULL;
11937 /* If we're doing semantic analysis, then we'll call pushdecl
11938 for each of these. We must do them in reverse order so that
11939 they end in the correct forward order. */
11940 specparms = nreverse (specparms);
11942 for (parm = specparms; parm; parm = next)
11944 next = TREE_CHAIN (parm);
11945 if (TREE_CODE (parm) == PARM_DECL)
11947 if (DECL_NAME (parm) == NULL_TREE
11948 || TREE_CODE (parm) != VOID_TYPE)
11951 error ("parameter %qD declared void", parm);
11955 /* If we find an enum constant or a type tag,
11956 put it aside for the moment. */
11957 TREE_CHAIN (parm) = NULL_TREE;
11958 nonparms = chainon (nonparms, parm);
11962 /* Get the decls in their original chain order and record in the
11963 function. This is all and only the PARM_DECLs that were
11964 pushed into scope by the loop above. */
11965 DECL_ARGUMENTS (fndecl) = getdecls ();
11968 DECL_ARGUMENTS (fndecl) = NULL_TREE;
11970 /* Now store the final chain of decls for the arguments
11971 as the decl-chain of the current lexical scope.
11972 Put the enumerators in as well, at the front so that
11973 DECL_ARGUMENTS is not modified. */
11974 current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));
11976 if (use_eh_spec_block (current_function_decl))
11977 current_eh_spec_block = begin_eh_spec_block ();
11981 /* We have finished doing semantic analysis on DECL, but have not yet
11982 generated RTL for its body. Save away our current state, so that
11983 when we want to generate RTL later we know what to do. */
11986 save_function_data (tree decl)
11988 struct language_function *f;
11990 /* Save the language-specific per-function data so that we can
11991 get it back when we really expand this function. */
11992 gcc_assert (!DECL_PENDING_INLINE_P (decl));
11995 f = GGC_NEW (struct language_function);
11996 memcpy (f, cp_function_chain, sizeof (struct language_function));
11997 DECL_SAVED_FUNCTION_DATA (decl) = f;
11999 /* Clear out the bits we don't need. */
12000 f->base.x_stmt_tree.x_cur_stmt_list = NULL_TREE;
12001 f->bindings = NULL;
12002 f->x_local_names = NULL;
12006 /* Set the return value of the constructor (if present). */
12009 finish_constructor_body (void)
12014 if (targetm.cxx.cdtor_returns_this ()
12015 && (! TYPE_FOR_JAVA (current_class_type)))
12017 /* Any return from a constructor will end up here. */
12018 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
12020 val = DECL_ARGUMENTS (current_function_decl);
12021 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
12022 DECL_RESULT (current_function_decl), val);
12023 /* Return the address of the object. */
12024 exprstmt = build_stmt (RETURN_EXPR, val);
12025 add_stmt (exprstmt);
12029 /* Do all the processing for the beginning of a destructor; set up the
12030 vtable pointers and cleanups for bases and members. */
12033 begin_destructor_body (void)
12035 tree compound_stmt;
12037 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
12038 issued an error message. We still want to try to process the
12039 body of the function, but initialize_vtbl_ptrs will crash if
12040 TYPE_BINFO is NULL. */
12041 if (COMPLETE_TYPE_P (current_class_type))
12043 compound_stmt = begin_compound_stmt (0);
12044 /* Make all virtual function table pointers in non-virtual base
12045 classes point to CURRENT_CLASS_TYPE's virtual function
12047 initialize_vtbl_ptrs (current_class_ptr);
12048 finish_compound_stmt (compound_stmt);
12050 /* And insert cleanups for our bases and members so that they
12051 will be properly destroyed if we throw. */
12052 push_base_cleanups ();
12056 /* At the end of every destructor we generate code to delete the object if
12057 necessary. Do that now. */
12060 finish_destructor_body (void)
12064 /* Any return from a destructor will end up here; that way all base
12065 and member cleanups will be run when the function returns. */
12066 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
12068 /* In a virtual destructor, we must call delete. */
12069 if (DECL_VIRTUAL_P (current_function_decl))
12072 tree virtual_size = cxx_sizeof (current_class_type);
12076 At the point of definition of a virtual destructor (including
12077 an implicit definition), non-placement operator delete shall
12078 be looked up in the scope of the destructor's class and if
12079 found shall be accessible and unambiguous. */
12080 exprstmt = build_op_delete_call(DELETE_EXPR, current_class_ptr,
12082 /*global_p=*/false,
12083 /*placement=*/NULL_TREE,
12084 /*alloc_fn=*/NULL_TREE);
12086 if_stmt = begin_if_stmt ();
12087 finish_if_stmt_cond (build2 (BIT_AND_EXPR, integer_type_node,
12088 current_in_charge_parm,
12091 finish_expr_stmt (exprstmt);
12092 finish_then_clause (if_stmt);
12093 finish_if_stmt (if_stmt);
12096 if (targetm.cxx.cdtor_returns_this ())
12100 val = DECL_ARGUMENTS (current_function_decl);
12101 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
12102 DECL_RESULT (current_function_decl), val);
12103 /* Return the address of the object. */
12104 exprstmt = build_stmt (RETURN_EXPR, val);
12105 add_stmt (exprstmt);
12109 /* Do the necessary processing for the beginning of a function body, which
12110 in this case includes member-initializers, but not the catch clauses of
12111 a function-try-block. Currently, this means opening a binding level
12112 for the member-initializers (in a ctor) and member cleanups (in a dtor). */
12115 begin_function_body (void)
12119 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
12122 if (processing_template_decl)
12123 /* Do nothing now. */;
12125 /* Always keep the BLOCK node associated with the outermost pair of
12126 curly braces of a function. These are needed for correct
12127 operation of dwarfout.c. */
12128 keep_next_level (true);
12130 stmt = begin_compound_stmt (BCS_FN_BODY);
12132 if (processing_template_decl)
12133 /* Do nothing now. */;
12134 else if (DECL_DESTRUCTOR_P (current_function_decl))
12135 begin_destructor_body ();
12140 /* Do the processing for the end of a function body. Currently, this means
12141 closing out the cleanups for fully-constructed bases and members, and in
12142 the case of the destructor, deleting the object if desired. Again, this
12143 is only meaningful for [cd]tors, since they are the only functions where
12144 there is a significant distinction between the main body and any
12145 function catch clauses. Handling, say, main() return semantics here
12146 would be wrong, as flowing off the end of a function catch clause for
12147 main() would also need to return 0. */
12150 finish_function_body (tree compstmt)
12152 if (compstmt == NULL_TREE)
12155 /* Close the block. */
12156 finish_compound_stmt (compstmt);
12158 if (processing_template_decl)
12159 /* Do nothing now. */;
12160 else if (DECL_CONSTRUCTOR_P (current_function_decl))
12161 finish_constructor_body ();
12162 else if (DECL_DESTRUCTOR_P (current_function_decl))
12163 finish_destructor_body ();
12166 /* Given a function, returns the BLOCK corresponding to the outermost level
12167 of curly braces, skipping the artificial block created for constructor
12171 outer_curly_brace_block (tree fndecl)
12173 tree block = BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl));
12174 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
12175 /* Skip the artificial function body block. */
12176 block = BLOCK_SUBBLOCKS (block);
12180 /* Finish up a function declaration and compile that function
12181 all the way to assembler language output. The free the storage
12182 for the function definition.
12184 FLAGS is a bitwise or of the following values:
12186 We just finished processing the body of an in-class inline
12187 function definition. (This processing will have taken place
12188 after the class definition is complete.) */
12191 finish_function (int flags)
12193 tree fndecl = current_function_decl;
12194 tree fntype, ctype = NULL_TREE;
12195 int inclass_inline = (flags & 2) != 0;
12198 /* When we get some parse errors, we can end up without a
12199 current_function_decl, so cope. */
12200 if (fndecl == NULL_TREE)
12201 return error_mark_node;
12203 gcc_assert (!defer_mark_used_calls);
12204 defer_mark_used_calls = true;
12206 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
12207 && DECL_VIRTUAL_P (fndecl)
12208 && !processing_template_decl)
12210 tree fnclass = DECL_CONTEXT (fndecl);
12211 if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
12212 keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
12215 nested = function_depth > 1;
12216 fntype = TREE_TYPE (fndecl);
12218 /* TREE_READONLY (fndecl) = 1;
12219 This caused &foo to be of type ptr-to-const-function
12220 which then got a warning when stored in a ptr-to-function variable. */
12222 gcc_assert (building_stmt_tree ());
12223 /* The current function is being defined, so its DECL_INITIAL should
12224 be set, and unless there's a multiple definition, it should be
12225 error_mark_node. */
12226 gcc_assert (DECL_INITIAL (fndecl) == error_mark_node);
12228 /* For a cloned function, we've already got all the code we need;
12229 there's no need to add any extra bits. */
12230 if (!DECL_CLONED_FUNCTION_P (fndecl))
12232 if (DECL_MAIN_P (current_function_decl))
12236 /* Make it so that `main' always returns 0 by default (or
12239 stmt = finish_return_stmt (integer_one_node);
12241 stmt = finish_return_stmt (integer_zero_node);
12243 /* Hack. We don't want the middle-end to warn that this
12244 return is unreachable, so put the statement on the
12247 location_t linezero = linemap_line_start (line_table, 0, 1);
12248 SET_EXPR_LOCATION (stmt, linezero);
12252 if (use_eh_spec_block (current_function_decl))
12253 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
12254 (TREE_TYPE (current_function_decl)),
12255 current_eh_spec_block);
12258 /* If we're saving up tree structure, tie off the function now. */
12259 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
12261 finish_fname_decls ();
12263 /* If this function can't throw any exceptions, remember that. */
12264 if (!processing_template_decl
12265 && !cp_function_chain->can_throw
12266 && !flag_non_call_exceptions
12267 && !DECL_REPLACEABLE_P (fndecl))
12268 TREE_NOTHROW (fndecl) = 1;
12270 /* This must come after expand_function_end because cleanups might
12271 have declarations (from inline functions) that need to go into
12272 this function's blocks. */
12274 /* If the current binding level isn't the outermost binding level
12275 for this function, either there is a bug, or we have experienced
12276 syntax errors and the statement tree is malformed. */
12277 if (current_binding_level->kind != sk_function_parms)
12279 /* Make sure we have already experienced errors. */
12280 gcc_assert (errorcount);
12282 /* Throw away the broken statement tree and extra binding
12284 DECL_SAVED_TREE (fndecl) = alloc_stmt_list ();
12286 while (current_binding_level->kind != sk_function_parms)
12288 if (current_binding_level->kind == sk_class)
12289 pop_nested_class ();
12291 poplevel (0, 0, 0);
12294 poplevel (1, 0, 1);
12296 /* Statements should always be full-expressions at the outermost set
12297 of curly braces for a function. */
12298 gcc_assert (stmts_are_full_exprs_p ());
12300 /* Set up the named return value optimization, if we can. Candidate
12301 variables are selected in check_return_expr. */
12302 if (current_function_return_value)
12304 tree r = current_function_return_value;
12307 if (r != error_mark_node
12308 /* This is only worth doing for fns that return in memory--and
12309 simpler, since we don't have to worry about promoted modes. */
12310 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
12311 /* Only allow this for variables declared in the outer scope of
12312 the function so we know that their lifetime always ends with a
12313 return; see g++.dg/opt/nrv6.C. We could be more flexible if
12314 we were to do this optimization in tree-ssa. */
12315 && (outer = outer_curly_brace_block (fndecl))
12316 && chain_member (r, BLOCK_VARS (outer)))
12317 finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));
12319 current_function_return_value = NULL_TREE;
12322 /* Remember that we were in class scope. */
12323 if (current_class_name)
12324 ctype = current_class_type;
12326 /* Must mark the RESULT_DECL as being in this function. */
12327 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
12329 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
12330 to the FUNCTION_DECL node itself. */
12331 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
12333 /* Save away current state, if appropriate. */
12334 if (!processing_template_decl)
12335 save_function_data (fndecl);
12337 /* Complain if there's just no return statement. */
12338 if (warn_return_type
12339 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
12340 && !dependent_type_p (TREE_TYPE (fntype))
12341 && !current_function_returns_value && !current_function_returns_null
12342 /* Don't complain if we abort or throw. */
12343 && !current_function_returns_abnormally
12344 && !DECL_NAME (DECL_RESULT (fndecl))
12345 && !TREE_NO_WARNING (fndecl)
12346 /* Structor return values (if any) are set by the compiler. */
12347 && !DECL_CONSTRUCTOR_P (fndecl)
12348 && !DECL_DESTRUCTOR_P (fndecl))
12350 warning (OPT_Wreturn_type,
12351 "no return statement in function returning non-void");
12352 TREE_NO_WARNING (fndecl) = 1;
12355 /* Store the end of the function, so that we get good line number
12356 info for the epilogue. */
12357 cfun->function_end_locus = input_location;
12359 /* Genericize before inlining. */
12360 if (!processing_template_decl)
12362 struct language_function *f = DECL_SAVED_FUNCTION_DATA (fndecl);
12363 invoke_plugin_callbacks (PLUGIN_CXX_CP_PRE_GENERICIZE, fndecl);
12364 cp_genericize (fndecl);
12365 /* Clear out the bits we don't need. */
12366 f->x_current_class_ptr = NULL;
12367 f->x_current_class_ref = NULL;
12368 f->x_eh_spec_block = NULL;
12369 f->x_in_charge_parm = NULL;
12370 f->x_vtt_parm = NULL;
12371 f->x_return_value = NULL;
12372 f->bindings = NULL;
12373 f->extern_decl_map = NULL;
12375 /* Handle attribute((warn_unused_result)). Relies on gimple input. */
12376 c_warn_unused_result (gimple_body (fndecl));
12378 /* Clear out the bits we don't need. */
12379 local_names = NULL;
12381 /* We're leaving the context of this function, so zap cfun. It's still in
12382 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
12384 current_function_decl = NULL;
12386 /* If this is an in-class inline definition, we may have to pop the
12387 bindings for the template parameters that we added in
12388 maybe_begin_member_template_processing when start_function was
12390 if (inclass_inline)
12391 maybe_end_member_template_processing ();
12393 /* Leave the scope of the class. */
12395 pop_nested_class ();
12401 /* Let the error reporting routines know that we're outside a
12402 function. For a nested function, this value is used in
12403 cxx_pop_function_context and then reset via pop_function_context. */
12404 current_function_decl = NULL_TREE;
12406 defer_mark_used_calls = false;
12407 if (deferred_mark_used_calls)
12412 for (i = 0; VEC_iterate (tree, deferred_mark_used_calls, i, decl); i++)
12414 VEC_free (tree, gc, deferred_mark_used_calls);
12420 /* Create the FUNCTION_DECL for a function definition.
12421 DECLSPECS and DECLARATOR are the parts of the declaration;
12422 they describe the return type and the name of the function,
12423 but twisted together in a fashion that parallels the syntax of C.
12425 This function creates a binding context for the function body
12426 as well as setting up the FUNCTION_DECL in current_function_decl.
12428 Returns a FUNCTION_DECL on success.
12430 If the DECLARATOR is not suitable for a function (it defines a datum
12431 instead), we return 0, which tells yyparse to report a parse error.
12433 May return void_type_node indicating that this method is actually
12434 a friend. See grokfield for more details.
12436 Came here with a `.pushlevel' .
12438 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
12439 CHANGES TO CODE IN `grokfield'. */
12442 start_method (cp_decl_specifier_seq *declspecs,
12443 const cp_declarator *declarator, tree attrlist)
12445 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
12448 if (fndecl == error_mark_node)
12449 return error_mark_node;
12451 if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
12453 error ("invalid member function declaration");
12454 return error_mark_node;
12458 cplus_decl_attributes (&fndecl, attrlist, 0);
12460 /* Pass friends other than inline friend functions back. */
12461 if (fndecl == void_type_node)
12464 if (DECL_IN_AGGR_P (fndecl))
12466 if (DECL_CONTEXT (fndecl)
12467 && TREE_CODE (DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
12468 error ("%qD is already defined in class %qT", fndecl,
12469 DECL_CONTEXT (fndecl));
12470 return error_mark_node;
12473 check_template_shadow (fndecl);
12475 DECL_DECLARED_INLINE_P (fndecl) = 1;
12476 DECL_NO_INLINE_WARNING_P (fndecl) = 1;
12478 /* We process method specializations in finish_struct_1. */
12479 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
12481 fndecl = push_template_decl (fndecl);
12482 if (fndecl == error_mark_node)
12486 if (! DECL_FRIEND_P (fndecl))
12488 if (TREE_CHAIN (fndecl))
12490 fndecl = copy_node (fndecl);
12491 TREE_CHAIN (fndecl) = NULL_TREE;
12495 finish_decl (fndecl, NULL_TREE, NULL_TREE);
12497 /* Make a place for the parms. */
12498 begin_scope (sk_function_parms, fndecl);
12500 DECL_IN_AGGR_P (fndecl) = 1;
12504 /* Go through the motions of finishing a function definition.
12505 We don't compile this method until after the whole class has
12508 FINISH_METHOD must return something that looks as though it
12509 came from GROKFIELD (since we are defining a method, after all).
12511 This is called after parsing the body of the function definition.
12512 STMTS is the chain of statements that makes up the function body.
12514 DECL is the ..._DECL that `start_method' provided. */
12517 finish_method (tree decl)
12519 tree fndecl = decl;
12524 if (decl == void_type_node)
12527 old_initial = DECL_INITIAL (fndecl);
12529 /* Undo the level for the parms (from start_method).
12530 This is like poplevel, but it causes nothing to be
12531 saved. Saving information here confuses symbol-table
12532 output routines. Besides, this information will
12533 be correctly output when this method is actually
12536 /* Clear out the meanings of the local variables of this level;
12537 also record in each decl which block it belongs to. */
12539 for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
12541 if (DECL_NAME (link) != NULL_TREE)
12542 pop_binding (DECL_NAME (link), link);
12543 gcc_assert (TREE_CODE (link) != FUNCTION_DECL);
12544 DECL_CONTEXT (link) = NULL_TREE;
12547 poplevel (0, 0, 0);
12549 DECL_INITIAL (fndecl) = old_initial;
12551 /* We used to check if the context of FNDECL was different from
12552 current_class_type as another way to get inside here. This didn't work
12553 for String.cc in libg++. */
12554 if (DECL_FRIEND_P (fndecl))
12556 VEC_safe_push (tree, gc, CLASSTYPE_INLINE_FRIENDS (current_class_type),
12558 decl = void_type_node;
12565 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
12566 we can lay it out later, when and if its type becomes complete. */
12569 maybe_register_incomplete_var (tree var)
12571 gcc_assert (TREE_CODE (var) == VAR_DECL);
12573 /* Keep track of variables with incomplete types. */
12574 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
12575 && DECL_EXTERNAL (var))
12577 tree inner_type = TREE_TYPE (var);
12579 while (TREE_CODE (inner_type) == ARRAY_TYPE)
12580 inner_type = TREE_TYPE (inner_type);
12581 inner_type = TYPE_MAIN_VARIANT (inner_type);
12583 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
12584 /* RTTI TD entries are created while defining the type_info. */
12585 || (TYPE_LANG_SPECIFIC (inner_type)
12586 && TYPE_BEING_DEFINED (inner_type)))
12587 incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
12591 /* Called when a class type (given by TYPE) is defined. If there are
12592 any existing VAR_DECLs whose type has been completed by this
12593 declaration, update them now. */
12596 complete_vars (tree type)
12598 tree *list = &incomplete_vars;
12600 gcc_assert (CLASS_TYPE_P (type));
12603 if (same_type_p (type, TREE_PURPOSE (*list)))
12605 tree var = TREE_VALUE (*list);
12606 tree type = TREE_TYPE (var);
12607 /* Complete the type of the variable. The VAR_DECL itself
12608 will be laid out in expand_expr. */
12609 complete_type (type);
12610 cp_apply_type_quals_to_decl (cp_type_quals (type), var);
12611 /* Remove this entry from the list. */
12612 *list = TREE_CHAIN (*list);
12615 list = &TREE_CHAIN (*list);
12618 /* Check for pending declarations which may have abstract type. */
12619 complete_type_check_abstract (type);
12622 /* If DECL is of a type which needs a cleanup, build and return an
12623 expression to perform that cleanup here. Return NULL_TREE if no
12624 cleanup need be done. */
12627 cxx_maybe_build_cleanup (tree decl)
12633 /* Assume no cleanup is required. */
12634 cleanup = NULL_TREE;
12636 if (error_operand_p (decl))
12639 /* Handle "__attribute__((cleanup))". We run the cleanup function
12640 before the destructor since the destructor is what actually
12641 terminates the lifetime of the object. */
12642 attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
12649 /* Get the name specified by the user for the cleanup function. */
12650 id = TREE_VALUE (TREE_VALUE (attr));
12651 /* Look up the name to find the cleanup function to call. It is
12652 important to use lookup_name here because that is what is
12653 used in c-common.c:handle_cleanup_attribute when performing
12654 initial checks on the attribute. Note that those checks
12655 include ensuring that the function found is not an overloaded
12656 function, or an object with an overloaded call operator,
12657 etc.; we can rely on the fact that the function found is an
12658 ordinary FUNCTION_DECL. */
12659 fn = lookup_name (id);
12660 arg = build_address (decl);
12662 cleanup = cp_build_function_call (fn, build_tree_list (NULL_TREE,
12664 tf_warning_or_error);
12666 /* Handle ordinary C++ destructors. */
12667 type = TREE_TYPE (decl);
12668 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
12670 int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
12671 bool has_vbases = (TREE_CODE (type) == RECORD_TYPE
12672 && CLASSTYPE_VBASECLASSES (type));
12676 if (TREE_CODE (type) == ARRAY_TYPE)
12679 addr = build_address (decl);
12681 /* Optimize for space over speed here. */
12682 if (!has_vbases || flag_expensive_optimizations)
12683 flags |= LOOKUP_NONVIRTUAL;
12685 call = build_delete (TREE_TYPE (addr), addr,
12686 sfk_complete_destructor, flags, 0);
12688 cleanup = build_compound_expr (cleanup, call);
12696 /* When a stmt has been parsed, this function is called. */
12703 /* DECL was originally constructed as a non-static member function,
12704 but turned out to be static. Update it accordingly. */
12707 revert_static_member_fn (tree decl)
12710 tree function = TREE_TYPE (decl);
12711 tree args = TYPE_ARG_TYPES (function);
12713 if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
12714 != TYPE_UNQUALIFIED)
12715 error ("static member function %q#D declared with type qualifiers", decl);
12717 args = TREE_CHAIN (args);
12718 tmp = build_function_type (TREE_TYPE (function), args);
12719 tmp = build_qualified_type (tmp, cp_type_quals (function));
12720 tmp = build_exception_variant (tmp,
12721 TYPE_RAISES_EXCEPTIONS (function));
12722 TREE_TYPE (decl) = tmp;
12723 if (DECL_ARGUMENTS (decl))
12724 DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
12725 DECL_STATIC_FUNCTION_P (decl) = 1;
12728 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
12729 one of the language-independent trees. */
12731 enum cp_tree_node_structure_enum
12732 cp_tree_node_structure (union lang_tree_node * t)
12734 switch (TREE_CODE (&t->generic))
12736 case DEFAULT_ARG: return TS_CP_DEFAULT_ARG;
12737 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER;
12738 case OVERLOAD: return TS_CP_OVERLOAD;
12739 case TEMPLATE_PARM_INDEX: return TS_CP_TPI;
12740 case PTRMEM_CST: return TS_CP_PTRMEM;
12741 case BASELINK: return TS_CP_BASELINK;
12742 case STATIC_ASSERT: return TS_CP_STATIC_ASSERT;
12743 case ARGUMENT_PACK_SELECT: return TS_CP_ARGUMENT_PACK_SELECT;
12744 case TRAIT_EXPR: return TS_CP_TRAIT_EXPR;
12745 default: return TS_CP_GENERIC;
12749 /* Build the void_list_node (void_type_node having been created). */
12751 build_void_list_node (void)
12753 tree t = build_tree_list (NULL_TREE, void_type_node);
12758 cp_missing_noreturn_ok_p (tree decl)
12760 /* A missing noreturn is ok for the `main' function. */
12761 return DECL_MAIN_P (decl);
12764 /* Return the COMDAT group into which DECL should be placed. */
12767 cxx_comdat_group (tree decl)
12771 /* Virtual tables, construction virtual tables, and virtual table
12772 tables all go in a single COMDAT group, named after the primary
12774 if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
12775 name = DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl)));
12776 /* For all other DECLs, the COMDAT group is the mangled name of the
12777 declaration itself. */
12780 while (DECL_THUNK_P (decl))
12782 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
12783 into the same section as the target function. In that case
12784 we must return target's name. */
12785 tree target = THUNK_TARGET (decl);
12786 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target)
12787 && DECL_SECTION_NAME (target) != NULL
12788 && DECL_ONE_ONLY (target))
12793 name = DECL_ASSEMBLER_NAME (decl);
12796 return IDENTIFIER_POINTER (name);
12799 #include "gt-cp-decl.h"