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 ((*targetm.vector_opaque_p) (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))
8831 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)))
8832 TYPE_NAME (t) = decl;
8834 if (TYPE_LANG_SPECIFIC (type))
8835 TYPE_WAS_ANONYMOUS (type) = 1;
8837 /* If this is a typedef within a template class, the nested
8838 type is a (non-primary) template. The name for the
8839 template needs updating as well. */
8840 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
8841 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
8842 = TYPE_IDENTIFIER (type);
8844 /* FIXME remangle member functions; member functions of a
8845 type with external linkage have external linkage. */
8849 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
8850 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
8852 bad_specifiers (decl, "type", virtualp,
8853 memfn_quals != TYPE_UNQUALIFIED,
8854 inlinep, friendp, raises != NULL_TREE);
8859 /* Detect the case of an array type of unspecified size
8860 which came, as such, direct from a typedef name.
8861 We must copy the type, so that the array's domain can be
8862 individually set by the object's initializer. */
8864 if (type && typedef_type
8865 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
8866 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
8867 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
8869 /* Detect where we're using a typedef of function type to declare a
8870 function. PARMS will not be set, so we must create it now. */
8872 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
8874 tree decls = NULL_TREE;
8877 for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
8879 tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
8881 TREE_CHAIN (decl) = decls;
8885 parms = nreverse (decls);
8887 if (decl_context != TYPENAME)
8889 /* A cv-qualifier-seq shall only be part of the function type
8890 for a non-static member function. [8.3.5/4 dcl.fct] */
8891 if (cp_type_quals (type) != TYPE_UNQUALIFIED
8892 && (current_class_type == NULL_TREE || staticp) )
8895 ? G_("qualified function types cannot be used to "
8896 "declare static member functions")
8897 : G_("qualified function types cannot be used to "
8898 "declare free functions"));
8899 type = TYPE_MAIN_VARIANT (type);
8902 /* The qualifiers on the function type become the qualifiers on
8903 the non-static member function. */
8904 memfn_quals |= cp_type_quals (type);
8908 /* If this is a type name (such as, in a cast or sizeof),
8909 compute the type and return it now. */
8911 if (decl_context == TYPENAME)
8913 /* Note that the grammar rejects storage classes
8914 in typenames, fields or parameters. */
8915 if (type_quals != TYPE_UNQUALIFIED)
8916 type_quals = TYPE_UNQUALIFIED;
8918 /* Special case: "friend class foo" looks like a TYPENAME context. */
8921 if (type_quals != TYPE_UNQUALIFIED)
8923 error ("type qualifiers specified for friend class declaration");
8924 type_quals = TYPE_UNQUALIFIED;
8928 error ("%<inline%> specified for friend class declaration");
8934 /* Don't allow friend declaration without a class-key. */
8935 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
8936 permerror (input_location, "template parameters cannot be friends");
8937 else if (TREE_CODE (type) == TYPENAME_TYPE)
8938 permerror (input_location, "friend declaration requires class-key, "
8939 "i.e. %<friend class %T::%D%>",
8940 TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
8942 permerror (input_location, "friend declaration requires class-key, "
8943 "i.e. %<friend %#T%>",
8947 /* Only try to do this stuff if we didn't already give up. */
8948 if (type != integer_type_node)
8950 /* A friendly class? */
8951 if (current_class_type)
8952 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
8955 error ("trying to make class %qT a friend of global scope",
8958 type = void_type_node;
8961 else if (memfn_quals)
8963 if (ctype == NULL_TREE
8964 && TREE_CODE (type) == METHOD_TYPE)
8965 ctype = TYPE_METHOD_BASETYPE (type);
8968 type = build_memfn_type (type, ctype, memfn_quals);
8969 /* Core issue #547: need to allow this in template type args. */
8970 else if (template_type_arg && TREE_CODE (type) == FUNCTION_TYPE)
8971 type = cp_build_qualified_type (type, memfn_quals);
8973 error ("invalid qualifiers on non-member function type");
8978 else if (unqualified_id == NULL_TREE && decl_context != PARM
8979 && decl_context != CATCHPARM
8980 && TREE_CODE (type) != UNION_TYPE
8983 error ("abstract declarator %qT used as declaration", type);
8984 return error_mark_node;
8987 /* Only functions may be declared using an operator-function-id. */
8989 && IDENTIFIER_OPNAME_P (unqualified_id)
8990 && TREE_CODE (type) != FUNCTION_TYPE
8991 && TREE_CODE (type) != METHOD_TYPE)
8993 error ("declaration of %qD as non-function", unqualified_id);
8994 return error_mark_node;
8997 /* We don't check parameter types here because we can emit a better
8998 error message later. */
8999 if (decl_context != PARM)
9001 type = check_var_type (unqualified_id, type);
9002 if (type == error_mark_node)
9003 return error_mark_node;
9006 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
9007 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
9009 if (decl_context == PARM || decl_context == CATCHPARM)
9011 if (ctype || in_namespace)
9012 error ("cannot use %<::%> in parameter declaration");
9014 /* A parameter declared as an array of T is really a pointer to T.
9015 One declared as a function is really a pointer to a function.
9016 One declared as a member is really a pointer to member. */
9018 if (TREE_CODE (type) == ARRAY_TYPE)
9020 /* Transfer const-ness of array into that of type pointed to. */
9021 type = build_pointer_type (TREE_TYPE (type));
9022 type_quals = TYPE_UNQUALIFIED;
9024 else if (TREE_CODE (type) == FUNCTION_TYPE)
9025 type = build_pointer_type (type);
9031 if (decl_context == PARM)
9033 decl = cp_build_parm_decl (unqualified_id, type);
9035 bad_specifiers (decl, "parameter", virtualp,
9036 memfn_quals != TYPE_UNQUALIFIED,
9037 inlinep, friendp, raises != NULL_TREE);
9039 else if (decl_context == FIELD)
9041 /* The C99 flexible array extension. */
9042 if (!staticp && TREE_CODE (type) == ARRAY_TYPE
9043 && TYPE_DOMAIN (type) == NULL_TREE)
9045 tree itype = compute_array_index_type (dname, integer_zero_node);
9046 type = build_cplus_array_type (TREE_TYPE (type), itype);
9049 if (type == error_mark_node)
9051 /* Happens when declaring arrays of sizes which
9052 are error_mark_node, for example. */
9055 else if (in_namespace && !friendp)
9057 /* Something like struct S { int N::j; }; */
9058 error ("invalid use of %<::%>");
9059 return error_mark_node;
9061 else if (TREE_CODE (type) == FUNCTION_TYPE)
9064 tree function_context;
9068 if (ctype == NULL_TREE)
9069 ctype = current_class_type;
9071 if (ctype == NULL_TREE)
9073 error ("can't make %qD into a method -- not in a class",
9075 return error_mark_node;
9078 /* ``A union may [ ... ] not [ have ] virtual functions.''
9080 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
9082 error ("function %qD declared virtual inside a union",
9084 return error_mark_node;
9087 if (NEW_DELETE_OPNAME_P (unqualified_id))
9091 error ("%qD cannot be declared virtual, since it "
9097 else if (staticp < 2)
9098 type = build_memfn_type (type, ctype, memfn_quals);
9101 /* Check that the name used for a destructor makes sense. */
9102 if (sfk == sfk_destructor)
9104 tree uqname = id_declarator->u.id.unqualified_name;
9108 gcc_assert (friendp);
9109 error ("expected qualified name in friend declaration "
9110 "for destructor %qD", uqname);
9111 return error_mark_node;
9114 if (!check_dtor_name (ctype, TREE_OPERAND (uqname, 0)))
9116 error ("declaration of %qD as member of %qT",
9118 return error_mark_node;
9121 else if (sfk == sfk_constructor && friendp)
9123 error ("expected qualified name in friend declaration "
9124 "for constructor %qD",
9125 id_declarator->u.id.unqualified_name);
9126 return error_mark_node;
9129 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
9130 function_context = (ctype != NULL_TREE) ?
9131 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
9132 publicp = (! friendp || ! staticp)
9133 && function_context == NULL_TREE;
9134 decl = grokfndecl (ctype, type,
9135 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
9136 ? unqualified_id : dname,
9139 virtualp, flags, memfn_quals, raises,
9140 friendp ? -1 : 0, friendp, publicp, inlinep,
9142 funcdef_flag, template_count, in_namespace,
9143 attrlist, declarator->id_loc);
9144 if (decl == NULL_TREE)
9145 return error_mark_node;
9147 /* This clobbers the attrs stored in `decl' from `attrlist'. */
9148 /* The decl and setting of decl_attr is also turned off. */
9149 decl = build_decl_attribute_variant (decl, decl_attr);
9152 /* [class.conv.ctor]
9154 A constructor declared without the function-specifier
9155 explicit that can be called with a single parameter
9156 specifies a conversion from the type of its first
9157 parameter to the type of its class. Such a constructor
9158 is called a converting constructor. */
9160 DECL_NONCONVERTING_P (decl) = 1;
9162 else if (TREE_CODE (type) == METHOD_TYPE)
9164 /* We only get here for friend declarations of
9165 members of other classes. */
9166 /* All method decls are public, so tell grokfndecl to set
9167 TREE_PUBLIC, also. */
9168 decl = grokfndecl (ctype, type,
9169 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
9170 ? unqualified_id : dname,
9173 virtualp, flags, memfn_quals, raises,
9174 friendp ? -1 : 0, friendp, 1, 0, sfk,
9175 funcdef_flag, template_count, in_namespace,
9177 declarator->id_loc);
9178 if (decl == NULL_TREE)
9179 return error_mark_node;
9181 else if (!staticp && !dependent_type_p (type)
9182 && !COMPLETE_TYPE_P (complete_type (type))
9183 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
9186 error ("field %qD has incomplete type", unqualified_id);
9188 error ("name %qT has incomplete type", type);
9190 /* If we're instantiating a template, tell them which
9191 instantiation made the field's type be incomplete. */
9192 if (current_class_type
9193 && TYPE_NAME (current_class_type)
9194 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
9196 && declspecs->type == type)
9197 error (" in instantiation of template %qT",
9198 current_class_type);
9200 return error_mark_node;
9206 error ("%qE is neither function nor member function; "
9207 "cannot be declared friend", unqualified_id);
9215 /* Friends are treated specially. */
9216 if (ctype == current_class_type)
9217 ; /* We already issued a permerror. */
9218 else if (decl && DECL_NAME (decl))
9220 if (template_class_depth (current_class_type) == 0)
9222 decl = check_explicit_specialization
9223 (unqualified_id, decl, template_count,
9224 2 * funcdef_flag + 4);
9225 if (decl == error_mark_node)
9226 return error_mark_node;
9229 decl = do_friend (ctype, unqualified_id, decl,
9235 return error_mark_node;
9238 /* Structure field. It may not be a function, except for C++. */
9240 if (decl == NULL_TREE)
9246 /* An attempt is being made to initialize a non-static
9247 member. But, from [class.mem]:
9249 4 A member-declarator can contain a
9250 constant-initializer only if it declares a static
9251 member (_class.static_) of integral or enumeration
9252 type, see _class.static.data_.
9254 This used to be relatively common practice, but
9255 the rest of the compiler does not correctly
9256 handle the initialization unless the member is
9257 static so we make it static below. */
9258 permerror (input_location, "ISO C++ forbids initialization of member %qD",
9260 permerror (input_location, "making %qD static", unqualified_id);
9264 if (uses_template_parms (type))
9265 /* We'll check at instantiation time. */
9267 else if (check_static_variable_definition (unqualified_id,
9269 /* If we just return the declaration, crashes
9270 will sometimes occur. We therefore return
9271 void_type_node, as if this was a friend
9272 declaration, to cause callers to completely
9273 ignore this declaration. */
9274 return error_mark_node;
9279 /* C++ allows static class members. All other work
9280 for this is done by grokfield. */
9281 decl = build_lang_decl (VAR_DECL, unqualified_id, type);
9282 set_linkage_for_static_data_member (decl);
9283 /* Even if there is an in-class initialization, DECL
9284 is considered undefined until an out-of-class
9285 definition is provided. */
9286 DECL_EXTERNAL (decl) = 1;
9289 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
9293 decl = build_decl (FIELD_DECL, unqualified_id, type);
9294 DECL_NONADDRESSABLE_P (decl) = bitfield;
9295 if (bitfield && !unqualified_id)
9296 TREE_NO_WARNING (decl) = 1;
9298 if (storage_class == sc_mutable)
9300 DECL_MUTABLE_P (decl) = 1;
9301 storage_class = sc_none;
9305 bad_specifiers (decl, "field", virtualp,
9306 memfn_quals != TYPE_UNQUALIFIED,
9307 inlinep, friendp, raises != NULL_TREE);
9310 else if (TREE_CODE (type) == FUNCTION_TYPE
9311 || TREE_CODE (type) == METHOD_TYPE)
9316 if (!unqualified_id)
9317 return error_mark_node;
9319 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
9320 original_name = dname;
9322 original_name = unqualified_id;
9324 if (storage_class == sc_auto)
9325 error ("storage class %<auto%> invalid for function %qs", name);
9326 else if (storage_class == sc_register)
9327 error ("storage class %<register%> invalid for function %qs", name);
9329 error ("storage class %<__thread%> invalid for function %qs", name);
9331 /* Function declaration not at top level.
9332 Storage classes other than `extern' are not allowed
9333 and `extern' makes no difference. */
9334 if (! toplevel_bindings_p ()
9335 && (storage_class == sc_static
9336 || declspecs->specs[(int)ds_inline])
9339 if (storage_class == sc_static)
9340 pedwarn (input_location, OPT_pedantic,
9341 "%<static%> specified invalid for function %qs "
9342 "declared out of global scope", name);
9344 pedwarn (input_location, OPT_pedantic,
9345 "%<inline%> specifier invalid for function %qs "
9346 "declared out of global scope", name);
9349 if (ctype != NULL_TREE
9350 && TREE_CODE (ctype) != NAMESPACE_DECL && !MAYBE_CLASS_TYPE_P (ctype))
9352 error ("%q#T is not a class or a namespace", ctype);
9356 if (ctype == NULL_TREE)
9360 error ("virtual non-class function %qs", name);
9363 else if (sfk == sfk_constructor
9364 || sfk == sfk_destructor)
9367 ? "%qs defined in a non-class scope"
9368 : "%qs declared in a non-class scope", name);
9372 else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2
9373 && !NEW_DELETE_OPNAME_P (original_name))
9374 type = build_method_type_directly (ctype,
9376 TYPE_ARG_TYPES (type));
9378 /* Record presence of `static'. */
9379 publicp = (ctype != NULL_TREE
9380 || storage_class == sc_extern
9381 || storage_class != sc_static);
9383 decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
9384 virtualp, flags, memfn_quals, raises,
9386 publicp, inlinep, sfk, funcdef_flag,
9387 template_count, in_namespace, attrlist,
9388 declarator->id_loc);
9389 if (decl == NULL_TREE)
9390 return error_mark_node;
9394 int invalid_static = 0;
9396 /* Don't allow a static member function in a class, and forbid
9397 declaring main to be static. */
9398 if (TREE_CODE (type) == METHOD_TYPE)
9400 permerror (input_location, "cannot declare member function %qD to have "
9401 "static linkage", decl);
9404 else if (current_function_decl)
9406 /* FIXME need arm citation */
9407 error ("cannot declare static function inside another function");
9414 storage_class = sc_none;
9420 /* It's a variable. */
9422 /* An uninitialized decl with `extern' is a reference. */
9423 decl = grokvardecl (type, unqualified_id,
9426 (type_quals & TYPE_QUAL_CONST) != 0,
9427 ctype ? ctype : in_namespace);
9428 bad_specifiers (decl, "variable", virtualp,
9429 memfn_quals != TYPE_UNQUALIFIED,
9430 inlinep, friendp, raises != NULL_TREE);
9434 DECL_CONTEXT (decl) = ctype;
9437 permerror (input_location, "%<static%> may not be used when defining "
9438 "(as opposed to declaring) a static data member");
9440 storage_class = sc_none;
9442 if (storage_class == sc_register && TREE_STATIC (decl))
9444 error ("static member %qD declared %<register%>", decl);
9445 storage_class = sc_none;
9447 if (storage_class == sc_extern && pedantic)
9449 pedwarn (input_location, OPT_pedantic,
9450 "cannot explicitly declare member %q#D to have "
9451 "extern linkage", decl);
9452 storage_class = sc_none;
9457 if (storage_class == sc_extern && initialized && !funcdef_flag)
9459 if (toplevel_bindings_p ())
9461 /* It's common practice (and completely valid) to have a const
9462 be initialized and declared extern. */
9463 if (!(type_quals & TYPE_QUAL_CONST))
9464 warning (0, "%qs initialized and declared %<extern%>", name);
9468 error ("%qs has both %<extern%> and initializer", name);
9469 return error_mark_node;
9473 /* Record `register' declaration for warnings on &
9474 and in case doing stupid register allocation. */
9476 if (storage_class == sc_register)
9477 DECL_REGISTER (decl) = 1;
9478 else if (storage_class == sc_extern)
9479 DECL_THIS_EXTERN (decl) = 1;
9480 else if (storage_class == sc_static)
9481 DECL_THIS_STATIC (decl) = 1;
9483 /* Record constancy and volatility on the DECL itself . There's
9484 no need to do this when processing a template; we'll do this
9485 for the instantiated declaration based on the type of DECL. */
9486 if (!processing_template_decl)
9487 cp_apply_type_quals_to_decl (type_quals, decl);
9490 TREE_NO_WARNING (decl) = 1;
9496 /* Subroutine of start_function. Ensure that each of the parameter
9497 types (as listed in PARMS) is complete, as is required for a
9498 function definition. */
9501 require_complete_types_for_parms (tree parms)
9503 for (; parms; parms = TREE_CHAIN (parms))
9505 if (dependent_type_p (TREE_TYPE (parms)))
9507 if (!VOID_TYPE_P (TREE_TYPE (parms))
9508 && complete_type_or_else (TREE_TYPE (parms), parms))
9510 relayout_decl (parms);
9511 DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
9514 /* grokparms or complete_type_or_else will have already issued
9516 TREE_TYPE (parms) = error_mark_node;
9520 /* Returns nonzero if T is a local variable. */
9523 local_variable_p (const_tree t)
9525 if ((TREE_CODE (t) == VAR_DECL
9526 /* A VAR_DECL with a context that is a _TYPE is a static data
9528 && !TYPE_P (CP_DECL_CONTEXT (t))
9529 /* Any other non-local variable must be at namespace scope. */
9530 && !DECL_NAMESPACE_SCOPE_P (t))
9531 || (TREE_CODE (t) == PARM_DECL))
9537 /* Like local_variable_p, but suitable for use as a tree-walking
9541 local_variable_p_walkfn (tree *tp, int *walk_subtrees,
9542 void *data ATTRIBUTE_UNUSED)
9544 if (local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
9546 else if (TYPE_P (*tp))
9553 /* Check that ARG, which is a default-argument expression for a
9554 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
9555 something goes wrong. DECL may also be a _TYPE node, rather than a
9556 DECL, if there is no DECL available. */
9559 check_default_argument (tree decl, tree arg)
9564 if (TREE_CODE (arg) == DEFAULT_ARG)
9565 /* We get a DEFAULT_ARG when looking at an in-class declaration
9566 with a default argument. Ignore the argument for now; we'll
9567 deal with it after the class is complete. */
9576 decl_type = TREE_TYPE (decl);
9578 if (arg == error_mark_node
9579 || decl == error_mark_node
9580 || TREE_TYPE (arg) == error_mark_node
9581 || decl_type == error_mark_node)
9582 /* Something already went wrong. There's no need to check
9584 return error_mark_node;
9586 /* [dcl.fct.default]
9588 A default argument expression is implicitly converted to the
9590 if (!TREE_TYPE (arg)
9591 || !can_convert_arg (decl_type, TREE_TYPE (arg), arg, LOOKUP_NORMAL))
9594 error ("default argument for %q#D has type %qT",
9595 decl, TREE_TYPE (arg));
9597 error ("default argument for parameter of type %qT has type %qT",
9598 decl_type, TREE_TYPE (arg));
9600 return error_mark_node;
9603 /* [dcl.fct.default]
9605 Local variables shall not be used in default argument
9608 The keyword `this' shall not be used in a default argument of a
9610 var = cp_walk_tree_without_duplicates (&arg, local_variable_p_walkfn, NULL);
9613 error ("default argument %qE uses local variable %qD", arg, var);
9614 return error_mark_node;
9621 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
9624 type_is_deprecated (tree type)
9626 enum tree_code code;
9627 if (TREE_DEPRECATED (type))
9629 if (TYPE_NAME (type)
9630 && TREE_DEPRECATED (TYPE_NAME (type)))
9633 code = TREE_CODE (type);
9635 if (code == POINTER_TYPE || code == REFERENCE_TYPE
9636 || code == OFFSET_TYPE || code == FUNCTION_TYPE
9637 || code == METHOD_TYPE || code == ARRAY_TYPE)
9638 return type_is_deprecated (TREE_TYPE (type));
9640 if (TYPE_PTRMEMFUNC_P (type))
9641 return type_is_deprecated
9642 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type))));
9647 /* Decode the list of parameter types for a function type.
9648 Given the list of things declared inside the parens,
9649 return a list of types.
9651 If this parameter does not end with an ellipsis, we append
9654 *PARMS is set to the chain of PARM_DECLs created. */
9657 grokparms (tree parmlist, tree *parms)
9659 tree result = NULL_TREE;
9660 tree decls = NULL_TREE;
9664 for (parm = parmlist; parm != NULL_TREE; parm = TREE_CHAIN (parm))
9666 tree type = NULL_TREE;
9667 tree init = TREE_PURPOSE (parm);
9668 tree decl = TREE_VALUE (parm);
9670 if (parm == void_list_node)
9673 if (! decl || TREE_TYPE (decl) == error_mark_node)
9676 type = TREE_TYPE (decl);
9677 if (VOID_TYPE_P (type))
9679 if (same_type_p (type, void_type_node)
9680 && DECL_SELF_REFERENCE_P (type)
9681 && !DECL_NAME (decl) && !result && TREE_CHAIN (parm) == void_list_node)
9682 /* this is a parmlist of `(void)', which is ok. */
9684 cxx_incomplete_type_error (decl, type);
9685 /* It's not a good idea to actually create parameters of
9686 type `void'; other parts of the compiler assume that a
9687 void type terminates the parameter list. */
9688 type = error_mark_node;
9689 TREE_TYPE (decl) = error_mark_node;
9692 if (type != error_mark_node
9693 && TYPE_FOR_JAVA (type)
9694 && MAYBE_CLASS_TYPE_P (type))
9696 error ("parameter %qD has Java class type", decl);
9697 type = error_mark_node;
9698 TREE_TYPE (decl) = error_mark_node;
9702 if (type != error_mark_node)
9704 if (deprecated_state != DEPRECATED_SUPPRESS)
9706 tree deptype = type_is_deprecated (type);
9708 warn_deprecated_use (deptype);
9711 /* Top-level qualifiers on the parameters are
9712 ignored for function types. */
9713 type = cp_build_qualified_type (type, 0);
9714 if (TREE_CODE (type) == METHOD_TYPE)
9716 error ("parameter %qD invalidly declared method type", decl);
9717 type = build_pointer_type (type);
9718 TREE_TYPE (decl) = type;
9720 else if (abstract_virtuals_error (decl, type))
9721 any_error = 1; /* Seems like a good idea. */
9722 else if (POINTER_TYPE_P (type))
9724 /* [dcl.fct]/6, parameter types cannot contain pointers
9725 (references) to arrays of unknown bound. */
9726 tree t = TREE_TYPE (type);
9727 int ptr = TYPE_PTR_P (type);
9733 else if (TREE_CODE (t) != ARRAY_TYPE)
9735 else if (!TYPE_DOMAIN (t))
9739 if (TREE_CODE (t) == ARRAY_TYPE)
9740 error ("parameter %qD includes %s to array of unknown "
9742 decl, ptr ? "pointer" : "reference", t);
9747 else if (init && !processing_template_decl)
9748 init = check_default_argument (decl, init);
9751 if (TREE_CODE (decl) == PARM_DECL
9752 && FUNCTION_PARAMETER_PACK_P (decl)
9753 && TREE_CHAIN (parm)
9754 && TREE_CHAIN (parm) != void_list_node)
9755 error ("parameter packs must be at the end of the parameter list");
9757 TREE_CHAIN (decl) = decls;
9759 result = tree_cons (init, type, result);
9761 decls = nreverse (decls);
9762 result = nreverse (result);
9764 result = chainon (result, void_list_node);
9771 /* D is a constructor or overloaded `operator='.
9773 Let T be the class in which D is declared. Then, this function
9776 -1 if D's is an ill-formed constructor or copy assignment operator
9777 whose first parameter is of type `T'.
9778 0 if D is not a copy constructor or copy assignment
9780 1 if D is a copy constructor or copy assignment operator whose
9781 first parameter is a reference to const qualified T.
9782 2 if D is a copy constructor or copy assignment operator whose
9783 first parameter is a reference to non-const qualified T.
9785 This function can be used as a predicate. Positive values indicate
9786 a copy constructor and nonzero values indicate a copy assignment
9790 copy_fn_p (const_tree d)
9796 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
9798 if (TREE_CODE (d) == TEMPLATE_DECL
9799 || (DECL_TEMPLATE_INFO (d)
9800 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
9801 /* Instantiations of template member functions are never copy
9802 functions. Note that member functions of templated classes are
9803 represented as template functions internally, and we must
9804 accept those as copy functions. */
9807 args = FUNCTION_FIRST_USER_PARMTYPE (d);
9811 arg_type = TREE_VALUE (args);
9812 if (arg_type == error_mark_node)
9815 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
9817 /* Pass by value copy assignment operator. */
9820 else if (TREE_CODE (arg_type) == REFERENCE_TYPE
9821 && !TYPE_REF_IS_RVALUE (arg_type)
9822 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
9824 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
9830 args = TREE_CHAIN (args);
9832 if (args && args != void_list_node && !TREE_PURPOSE (args))
9833 /* There are more non-optional args. */
9839 /* D is a constructor or overloaded `operator='.
9841 Let T be the class in which D is declared. Then, this function
9842 returns true when D is a move constructor or move assignment
9843 operator, false otherwise. */
9846 move_fn_p (const_tree d)
9850 bool result = false;
9852 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
9854 if (cxx_dialect == cxx98)
9855 /* There are no move constructors if we are in C++98 mode. */
9858 if (TREE_CODE (d) == TEMPLATE_DECL
9859 || (DECL_TEMPLATE_INFO (d)
9860 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
9861 /* Instantiations of template member functions are never copy
9862 functions. Note that member functions of templated classes are
9863 represented as template functions internally, and we must
9864 accept those as copy functions. */
9867 args = FUNCTION_FIRST_USER_PARMTYPE (d);
9871 arg_type = TREE_VALUE (args);
9872 if (arg_type == error_mark_node)
9875 if (TREE_CODE (arg_type) == REFERENCE_TYPE
9876 && TYPE_REF_IS_RVALUE (arg_type)
9877 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)),
9881 args = TREE_CHAIN (args);
9883 if (args && args != void_list_node && !TREE_PURPOSE (args))
9884 /* There are more non-optional args. */
9890 /* Remember any special properties of member function DECL. */
9893 grok_special_member_properties (tree decl)
9897 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
9900 class_type = DECL_CONTEXT (decl);
9901 if (DECL_CONSTRUCTOR_P (decl))
9903 int ctor = copy_fn_p (decl);
9905 if (!DECL_ARTIFICIAL (decl))
9906 TYPE_HAS_USER_CONSTRUCTOR (class_type) = 1;
9912 A non-template constructor for class X is a copy
9913 constructor if its first parameter is of type X&, const
9914 X&, volatile X& or const volatile X&, and either there
9915 are no other parameters or else all other parameters have
9916 default arguments. */
9917 TYPE_HAS_INIT_REF (class_type) = 1;
9918 if (!DECL_DEFAULTED_FN (decl))
9919 TYPE_HAS_COMPLEX_INIT_REF (class_type) = 1;
9921 TYPE_HAS_CONST_INIT_REF (class_type) = 1;
9923 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
9925 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type) = 1;
9926 if (TREE_CODE (decl) == TEMPLATE_DECL || !DECL_DEFAULTED_FN (decl))
9927 TYPE_HAS_COMPLEX_DFLT (class_type) = 1;
9929 else if (is_list_ctor (decl))
9930 TYPE_HAS_LIST_CTOR (class_type) = 1;
9932 else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
9936 A non-template assignment operator for class X is a copy
9937 assignment operator if its parameter is of type X, X&, const
9938 X&, volatile X& or const volatile X&. */
9940 int assop = copy_fn_p (decl);
9944 TYPE_HAS_ASSIGN_REF (class_type) = 1;
9945 if (!DECL_DEFAULTED_FN (decl))
9946 TYPE_HAS_COMPLEX_ASSIGN_REF (class_type) = 1;
9948 TYPE_HAS_CONST_ASSIGN_REF (class_type) = 1;
9953 /* Check a constructor DECL has the correct form. Complains
9954 if the class has a constructor of the form X(X). */
9957 grok_ctor_properties (const_tree ctype, const_tree decl)
9959 int ctor_parm = copy_fn_p (decl);
9965 A declaration of a constructor for a class X is ill-formed if
9966 its first parameter is of type (optionally cv-qualified) X
9967 and either there are no other parameters or else all other
9968 parameters have default arguments.
9970 We *don't* complain about member template instantiations that
9971 have this form, though; they can occur as we try to decide
9972 what constructor to use during overload resolution. Since
9973 overload resolution will never prefer such a constructor to
9974 the non-template copy constructor (which is either explicitly
9975 or implicitly defined), there's no need to worry about their
9976 existence. Theoretically, they should never even be
9977 instantiated, but that's hard to forestall. */
9978 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
9986 /* An operator with this code is unary, but can also be binary. */
9989 ambi_op_p (enum tree_code code)
9991 return (code == INDIRECT_REF
9992 || code == ADDR_EXPR
9993 || code == UNARY_PLUS_EXPR
9994 || code == NEGATE_EXPR
9995 || code == PREINCREMENT_EXPR
9996 || code == PREDECREMENT_EXPR);
9999 /* An operator with this name can only be unary. */
10002 unary_op_p (enum tree_code code)
10004 return (code == TRUTH_NOT_EXPR
10005 || code == BIT_NOT_EXPR
10006 || code == COMPONENT_REF
10007 || code == TYPE_EXPR);
10010 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
10011 errors are issued for invalid declarations. */
10014 grok_op_properties (tree decl, bool complain)
10016 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
10018 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
10019 tree name = DECL_NAME (decl);
10020 enum tree_code operator_code;
10025 /* Count the number of arguments and check for ellipsis. */
10026 for (argtype = argtypes, arity = 0;
10027 argtype && argtype != void_list_node;
10028 argtype = TREE_CHAIN (argtype))
10030 ellipsis_p = !argtype;
10032 class_type = DECL_CONTEXT (decl);
10033 if (class_type && !CLASS_TYPE_P (class_type))
10034 class_type = NULL_TREE;
10036 if (DECL_CONV_FN_P (decl))
10037 operator_code = TYPE_EXPR;
10041 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
10042 if (ansi_opname (CODE) == name) \
10044 operator_code = (CODE); \
10047 else if (ansi_assopname (CODE) == name) \
10049 operator_code = (CODE); \
10050 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
10054 #include "operators.def"
10055 #undef DEF_OPERATOR
10057 gcc_unreachable ();
10060 gcc_assert (operator_code != MAX_TREE_CODES);
10061 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
10064 switch (operator_code)
10067 TYPE_HAS_NEW_OPERATOR (class_type) = 1;
10071 TYPE_GETS_DELETE (class_type) |= 1;
10075 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type) = 1;
10078 case VEC_DELETE_EXPR:
10079 TYPE_GETS_DELETE (class_type) |= 2;
10086 /* [basic.std.dynamic.allocation]/1:
10088 A program is ill-formed if an allocation function is declared
10089 in a namespace scope other than global scope or declared static
10092 The same also holds true for deallocation functions. */
10093 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR
10094 || operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
10096 if (DECL_NAMESPACE_SCOPE_P (decl))
10098 if (CP_DECL_CONTEXT (decl) != global_namespace)
10100 error ("%qD may not be declared within a namespace", decl);
10103 else if (!TREE_PUBLIC (decl))
10105 error ("%qD may not be declared as static", decl);
10111 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
10113 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
10114 DECL_IS_OPERATOR_NEW (decl) = 1;
10116 else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
10117 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
10120 /* An operator function must either be a non-static member function
10121 or have at least one parameter of a class, a reference to a class,
10122 an enumeration, or a reference to an enumeration. 13.4.0.6 */
10123 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
10125 if (operator_code == TYPE_EXPR
10126 || operator_code == CALL_EXPR
10127 || operator_code == COMPONENT_REF
10128 || operator_code == ARRAY_REF
10129 || operator_code == NOP_EXPR)
10131 error ("%qD must be a nonstatic member function", decl);
10138 if (DECL_STATIC_FUNCTION_P (decl))
10140 error ("%qD must be either a non-static member "
10141 "function or a non-member function", decl);
10145 for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
10147 tree arg = non_reference (TREE_VALUE (p));
10148 if (arg == error_mark_node)
10151 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
10152 because these checks are performed even on
10153 template functions. */
10154 if (MAYBE_CLASS_TYPE_P (arg)
10155 || TREE_CODE (arg) == ENUMERAL_TYPE)
10159 if (!p || p == void_list_node)
10162 error ("%qD must have an argument of class or "
10163 "enumerated type", decl);
10169 /* There are no restrictions on the arguments to an overloaded
10171 if (operator_code == CALL_EXPR)
10174 /* Warn about conversion operators that will never be used. */
10175 if (IDENTIFIER_TYPENAME_P (name)
10176 && ! DECL_TEMPLATE_INFO (decl)
10178 /* Warn only declaring the function; there is no need to
10179 warn again about out-of-class definitions. */
10180 && class_type == current_class_type)
10182 tree t = TREE_TYPE (name);
10183 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
10184 const char *what = 0;
10187 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
10189 if (TREE_CODE (t) == VOID_TYPE)
10191 else if (class_type)
10193 if (t == class_type)
10194 what = "the same type";
10195 /* Don't force t to be complete here. */
10196 else if (MAYBE_CLASS_TYPE_P (t)
10197 && COMPLETE_TYPE_P (t)
10198 && DERIVED_FROM_P (t, class_type))
10199 what = "a base class";
10203 warning (OPT_Wconversion, "conversion to %s%s will never use a type "
10204 "conversion operator",
10205 ref ? "a reference to " : "", what);
10208 if (operator_code == COND_EXPR)
10211 error ("ISO C++ prohibits overloading operator ?:");
10214 else if (ellipsis_p)
10216 error ("%qD must not have variable number of arguments", decl);
10219 else if (ambi_op_p (operator_code))
10222 /* We pick the one-argument operator codes by default, so
10223 we don't have to change anything. */
10225 else if (arity == 2)
10227 /* If we thought this was a unary operator, we now know
10228 it to be a binary operator. */
10229 switch (operator_code)
10232 operator_code = MULT_EXPR;
10236 operator_code = BIT_AND_EXPR;
10239 case UNARY_PLUS_EXPR:
10240 operator_code = PLUS_EXPR;
10244 operator_code = MINUS_EXPR;
10247 case PREINCREMENT_EXPR:
10248 operator_code = POSTINCREMENT_EXPR;
10251 case PREDECREMENT_EXPR:
10252 operator_code = POSTDECREMENT_EXPR;
10256 gcc_unreachable ();
10259 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
10261 if ((operator_code == POSTINCREMENT_EXPR
10262 || operator_code == POSTDECREMENT_EXPR)
10263 && ! processing_template_decl
10264 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
10267 error ("postfix %qD must take %<int%> as its argument",
10270 error ("postfix %qD must take %<int%> as its second "
10278 error ("%qD must take either zero or one argument", decl);
10280 error ("%qD must take either one or two arguments", decl);
10284 /* More Effective C++ rule 6. */
10286 && (operator_code == POSTINCREMENT_EXPR
10287 || operator_code == POSTDECREMENT_EXPR
10288 || operator_code == PREINCREMENT_EXPR
10289 || operator_code == PREDECREMENT_EXPR))
10291 tree arg = TREE_VALUE (argtypes);
10292 tree ret = TREE_TYPE (TREE_TYPE (decl));
10293 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
10294 arg = TREE_TYPE (arg);
10295 arg = TYPE_MAIN_VARIANT (arg);
10296 if (operator_code == PREINCREMENT_EXPR
10297 || operator_code == PREDECREMENT_EXPR)
10299 if (TREE_CODE (ret) != REFERENCE_TYPE
10300 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
10302 warning (OPT_Weffc__, "prefix %qD should return %qT", decl,
10303 build_reference_type (arg));
10307 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
10308 warning (OPT_Weffc__, "postfix %qD should return %qT", decl, arg);
10312 else if (unary_op_p (operator_code))
10317 error ("%qD must take %<void%>", decl);
10319 error ("%qD must take exactly one argument", decl);
10323 else /* if (binary_op_p (operator_code)) */
10328 error ("%qD must take exactly one argument", decl);
10330 error ("%qD must take exactly two arguments", decl);
10334 /* More Effective C++ rule 7. */
10336 && (operator_code == TRUTH_ANDIF_EXPR
10337 || operator_code == TRUTH_ORIF_EXPR
10338 || operator_code == COMPOUND_EXPR))
10339 warning (OPT_Weffc__, "user-defined %qD always evaluates both arguments",
10343 /* Effective C++ rule 23. */
10346 && !DECL_ASSIGNMENT_OPERATOR_P (decl)
10347 && (operator_code == PLUS_EXPR
10348 || operator_code == MINUS_EXPR
10349 || operator_code == TRUNC_DIV_EXPR
10350 || operator_code == MULT_EXPR
10351 || operator_code == TRUNC_MOD_EXPR)
10352 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
10353 warning (OPT_Weffc__, "%qD should return by value", decl);
10355 /* [over.oper]/8 */
10356 for (; argtypes && argtypes != void_list_node;
10357 argtypes = TREE_CHAIN (argtypes))
10358 if (TREE_PURPOSE (argtypes))
10360 TREE_PURPOSE (argtypes) = NULL_TREE;
10361 if (operator_code == POSTINCREMENT_EXPR
10362 || operator_code == POSTDECREMENT_EXPR)
10364 pedwarn (input_location, OPT_pedantic, "%qD cannot have default arguments",
10369 error ("%qD cannot have default arguments", decl);
10377 /* Return a string giving the keyword associate with CODE. */
10379 static const char *
10380 tag_name (enum tag_types code)
10392 case typename_type:
10395 gcc_unreachable ();
10399 /* Name lookup in an elaborated-type-specifier (after the keyword
10400 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
10401 elaborated-type-specifier is invalid, issue a diagnostic and return
10402 error_mark_node; otherwise, return the *_TYPE to which it referred.
10403 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
10406 check_elaborated_type_specifier (enum tag_types tag_code,
10408 bool allow_template_p)
10414 struct S { struct S *p; };
10416 name lookup will find the TYPE_DECL for the implicit "S::S"
10417 typedef. Adjust for that here. */
10418 if (DECL_SELF_REFERENCE_P (decl))
10419 decl = TYPE_NAME (TREE_TYPE (decl));
10421 type = TREE_TYPE (decl);
10423 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
10424 is false for this case as well. */
10425 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
10427 error ("using template type parameter %qT after %qs",
10428 type, tag_name (tag_code));
10429 return error_mark_node;
10433 If the identifier resolves to a typedef-name or a template
10434 type-parameter, the elaborated-type-specifier is ill-formed.
10436 In other words, the only legitimate declaration to use in the
10437 elaborated type specifier is the implicit typedef created when
10438 the type is declared. */
10439 else if (!DECL_IMPLICIT_TYPEDEF_P (decl)
10440 && tag_code != typename_type)
10442 error ("using typedef-name %qD after %qs", decl, tag_name (tag_code));
10443 error ("%q+D has a previous declaration here", decl);
10444 return error_mark_node;
10446 else if (TREE_CODE (type) != RECORD_TYPE
10447 && TREE_CODE (type) != UNION_TYPE
10448 && tag_code != enum_type
10449 && tag_code != typename_type)
10451 error ("%qT referred to as %qs", type, tag_name (tag_code));
10452 error ("%q+T has a previous declaration here", type);
10453 return error_mark_node;
10455 else if (TREE_CODE (type) != ENUMERAL_TYPE
10456 && tag_code == enum_type)
10458 error ("%qT referred to as enum", type);
10459 error ("%q+T has a previous declaration here", type);
10460 return error_mark_node;
10462 else if (!allow_template_p
10463 && TREE_CODE (type) == RECORD_TYPE
10464 && CLASSTYPE_IS_TEMPLATE (type))
10466 /* If a class template appears as elaborated type specifier
10467 without a template header such as:
10469 template <class T> class C {};
10470 void f(class C); // No template header here
10472 then the required template argument is missing. */
10473 error ("template argument required for %<%s %T%>",
10474 tag_name (tag_code),
10475 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
10476 return error_mark_node;
10482 /* Lookup NAME in elaborate type specifier in scope according to
10483 SCOPE and issue diagnostics if necessary.
10484 Return *_TYPE node upon success, NULL_TREE when the NAME is not
10485 found, and ERROR_MARK_NODE for type error. */
10488 lookup_and_check_tag (enum tag_types tag_code, tree name,
10489 tag_scope scope, bool template_header_p)
10493 if (scope == ts_global)
10495 /* First try ordinary name lookup, ignoring hidden class name
10496 injected via friend declaration. */
10497 decl = lookup_name_prefer_type (name, 2);
10498 /* If that fails, the name will be placed in the smallest
10499 non-class, non-function-prototype scope according to 3.3.1/5.
10500 We may already have a hidden name declared as friend in this
10501 scope. So lookup again but not ignoring hidden names.
10502 If we find one, that name will be made visible rather than
10503 creating a new tag. */
10505 decl = lookup_type_scope (name, ts_within_enclosing_non_class);
10508 decl = lookup_type_scope (name, scope);
10510 if (decl && DECL_CLASS_TEMPLATE_P (decl))
10511 decl = DECL_TEMPLATE_RESULT (decl);
10513 if (decl && TREE_CODE (decl) == TYPE_DECL)
10515 /* Look for invalid nested type:
10519 if (scope == ts_current && DECL_SELF_REFERENCE_P (decl))
10521 error ("%qD has the same name as the class in which it is "
10524 return error_mark_node;
10527 /* Two cases we need to consider when deciding if a class
10528 template is allowed as an elaborated type specifier:
10529 1. It is a self reference to its own class.
10530 2. It comes with a template header.
10534 template <class T> class C {
10535 class C *c1; // DECL_SELF_REFERENCE_P is true
10538 template <class U> class C; // template_header_p is true
10539 template <class T> class C<T>::D {
10540 class C *c2; // DECL_SELF_REFERENCE_P is true
10543 t = check_elaborated_type_specifier (tag_code,
10546 | DECL_SELF_REFERENCE_P (decl));
10549 else if (decl && TREE_CODE (decl) == TREE_LIST)
10551 error ("reference to %qD is ambiguous", name);
10552 print_candidates (decl);
10553 return error_mark_node;
10559 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
10560 Define the tag as a forward-reference if it is not defined.
10562 If a declaration is given, process it here, and report an error if
10563 multiple declarations are not identical.
10565 SCOPE is TS_CURRENT when this is also a definition. Only look in
10566 the current frame for the name (since C++ allows new names in any
10567 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
10568 declaration. Only look beginning from the current scope outward up
10569 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
10571 TEMPLATE_HEADER_P is true when this declaration is preceded by
10572 a set of template parameters. */
10575 xref_tag (enum tag_types tag_code, tree name,
10576 tag_scope scope, bool template_header_p)
10578 enum tree_code code;
10580 tree context = NULL_TREE;
10582 timevar_push (TV_NAME_LOOKUP);
10584 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
10590 code = RECORD_TYPE;
10596 code = ENUMERAL_TYPE;
10599 gcc_unreachable ();
10602 /* In case of anonymous name, xref_tag is only called to
10603 make type node and push name. Name lookup is not required. */
10604 if (ANON_AGGRNAME_P (name))
10607 t = lookup_and_check_tag (tag_code, name,
10608 scope, template_header_p);
10610 if (t == error_mark_node)
10611 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10613 if (scope != ts_current && t && current_class_type
10614 && template_class_depth (current_class_type)
10615 && template_header_p)
10617 /* Since SCOPE is not TS_CURRENT, we are not looking at a
10618 definition of this tag. Since, in addition, we are currently
10619 processing a (member) template declaration of a template
10620 class, we must be very careful; consider:
10627 { template <class V>
10628 friend struct S1; };
10630 Here, the S2::S1 declaration should not be confused with the
10631 outer declaration. In particular, the inner version should
10632 have a template parameter of level 2, not level 1. This
10633 would be particularly important if the member declaration
10636 template <class V = U> friend struct S1;
10638 say, when we should tsubst into `U' when instantiating
10639 S2. On the other hand, when presented with:
10649 we must find the inner binding eventually. We
10650 accomplish this by making sure that the new type we
10651 create to represent this declaration has the right
10653 context = TYPE_CONTEXT (t);
10659 /* If no such tag is yet defined, create a forward-reference node
10660 and record it as the "definition".
10661 When a real declaration of this type is found,
10662 the forward-reference will be altered into a real type. */
10663 if (code == ENUMERAL_TYPE)
10665 error ("use of enum %q#D without previous declaration", name);
10666 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10670 t = make_class_type (code);
10671 TYPE_CONTEXT (t) = context;
10672 t = pushtag (name, t, scope);
10677 if (template_header_p && MAYBE_CLASS_TYPE_P (t))
10679 if (!redeclare_class_template (t, current_template_parms))
10680 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10682 else if (!processing_template_decl
10683 && CLASS_TYPE_P (t)
10684 && CLASSTYPE_IS_TEMPLATE (t))
10686 error ("redeclaration of %qT as a non-template", t);
10687 error ("previous declaration %q+D", t);
10688 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10691 /* Make injected friend class visible. */
10692 if (scope != ts_within_enclosing_non_class
10693 && hidden_name_p (TYPE_NAME (t)))
10695 DECL_ANTICIPATED (TYPE_NAME (t)) = 0;
10696 DECL_FRIEND_P (TYPE_NAME (t)) = 0;
10698 if (TYPE_TEMPLATE_INFO (t))
10700 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t)) = 0;
10701 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t)) = 0;
10706 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
10710 xref_tag_from_type (tree old, tree id, tag_scope scope)
10712 enum tag_types tag_kind;
10714 if (TREE_CODE (old) == RECORD_TYPE)
10715 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
10717 tag_kind = union_type;
10719 if (id == NULL_TREE)
10720 id = TYPE_IDENTIFIER (old);
10722 return xref_tag (tag_kind, id, scope, false);
10725 /* Create the binfo hierarchy for REF with (possibly NULL) base list
10726 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
10727 access_* node, and the TREE_VALUE is the type of the base-class.
10728 Non-NULL TREE_TYPE indicates virtual inheritance.
10730 Returns true if the binfo hierarchy was successfully created,
10731 false if an error was detected. */
10734 xref_basetypes (tree ref, tree base_list)
10737 tree binfo, base_binfo;
10738 unsigned max_vbases = 0; /* Maximum direct & indirect virtual bases. */
10739 unsigned max_bases = 0; /* Maximum direct bases. */
10741 tree default_access;
10742 tree igo_prev; /* Track Inheritance Graph Order. */
10744 if (ref == error_mark_node)
10747 /* The base of a derived class is private by default, all others are
10749 default_access = (TREE_CODE (ref) == RECORD_TYPE
10750 && CLASSTYPE_DECLARED_CLASS (ref)
10751 ? access_private_node : access_public_node);
10753 /* First, make sure that any templates in base-classes are
10754 instantiated. This ensures that if we call ourselves recursively
10755 we do not get confused about which classes are marked and which
10757 basep = &base_list;
10760 tree basetype = TREE_VALUE (*basep);
10762 if (!(processing_template_decl && uses_template_parms (basetype))
10763 && !complete_type_or_else (basetype, NULL))
10764 /* An incomplete type. Remove it from the list. */
10765 *basep = TREE_CHAIN (*basep);
10769 if (TREE_TYPE (*basep))
10771 if (CLASS_TYPE_P (basetype))
10772 max_vbases += VEC_length (tree, CLASSTYPE_VBASECLASSES (basetype));
10773 basep = &TREE_CHAIN (*basep);
10777 TYPE_MARKED_P (ref) = 1;
10779 /* The binfo slot should be empty, unless this is an (ill-formed)
10781 gcc_assert (!TYPE_BINFO (ref) || TYPE_SIZE (ref));
10782 gcc_assert (TYPE_MAIN_VARIANT (ref) == ref);
10784 binfo = make_tree_binfo (max_bases);
10786 TYPE_BINFO (ref) = binfo;
10787 BINFO_OFFSET (binfo) = size_zero_node;
10788 BINFO_TYPE (binfo) = ref;
10790 /* Apply base-class info set up to the variants of this type. */
10791 fixup_type_variants (ref);
10795 BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, gc, max_bases);
10796 /* An aggregate cannot have baseclasses. */
10797 CLASSTYPE_NON_AGGREGATE (ref) = 1;
10799 if (TREE_CODE (ref) == UNION_TYPE)
10801 error ("derived union %qT invalid", ref);
10808 if (TYPE_FOR_JAVA (ref))
10810 error ("Java class %qT cannot have multiple bases", ref);
10817 CLASSTYPE_VBASECLASSES (ref) = VEC_alloc (tree, gc, max_vbases);
10819 if (TYPE_FOR_JAVA (ref))
10821 error ("Java class %qT cannot have virtual bases", ref);
10826 for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list))
10828 tree access = TREE_PURPOSE (base_list);
10829 int via_virtual = TREE_TYPE (base_list) != NULL_TREE;
10830 tree basetype = TREE_VALUE (base_list);
10832 if (access == access_default_node)
10833 access = default_access;
10835 if (PACK_EXPANSION_P (basetype))
10836 basetype = PACK_EXPANSION_PATTERN (basetype);
10837 if (TREE_CODE (basetype) == TYPE_DECL)
10838 basetype = TREE_TYPE (basetype);
10839 if (!MAYBE_CLASS_TYPE_P (basetype) || TREE_CODE (basetype) == UNION_TYPE)
10841 error ("base type %qT fails to be a struct or class type",
10846 if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0))
10847 TYPE_FOR_JAVA (ref) = 1;
10849 base_binfo = NULL_TREE;
10850 if (CLASS_TYPE_P (basetype) && !dependent_type_p (basetype))
10852 base_binfo = TYPE_BINFO (basetype);
10853 /* The original basetype could have been a typedef'd type. */
10854 basetype = BINFO_TYPE (base_binfo);
10856 /* Inherit flags from the base. */
10857 TYPE_HAS_NEW_OPERATOR (ref)
10858 |= TYPE_HAS_NEW_OPERATOR (basetype);
10859 TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
10860 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
10861 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
10862 TYPE_HAS_CONVERSION (ref) |= TYPE_HAS_CONVERSION (basetype);
10863 CLASSTYPE_DIAMOND_SHAPED_P (ref)
10864 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype);
10865 CLASSTYPE_REPEATED_BASE_P (ref)
10866 |= CLASSTYPE_REPEATED_BASE_P (basetype);
10869 /* We must do this test after we've seen through a typedef
10871 if (TYPE_MARKED_P (basetype))
10873 if (basetype == ref)
10874 error ("recursive type %qT undefined", basetype);
10876 error ("duplicate base type %qT invalid", basetype);
10880 if (PACK_EXPANSION_P (TREE_VALUE (base_list)))
10881 /* Regenerate the pack expansion for the bases. */
10882 basetype = make_pack_expansion (basetype);
10884 TYPE_MARKED_P (basetype) = 1;
10886 base_binfo = copy_binfo (base_binfo, basetype, ref,
10887 &igo_prev, via_virtual);
10888 if (!BINFO_INHERITANCE_CHAIN (base_binfo))
10889 BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
10891 BINFO_BASE_APPEND (binfo, base_binfo);
10892 BINFO_BASE_ACCESS_APPEND (binfo, access);
10895 if (VEC_space (tree, CLASSTYPE_VBASECLASSES (ref), 1))
10896 /* If we have space in the vbase vector, we must have shared at
10897 least one of them, and are therefore diamond shaped. */
10898 CLASSTYPE_DIAMOND_SHAPED_P (ref) = 1;
10900 /* Unmark all the types. */
10901 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
10902 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
10903 TYPE_MARKED_P (ref) = 0;
10905 /* Now see if we have a repeated base type. */
10906 if (!CLASSTYPE_REPEATED_BASE_P (ref))
10908 for (base_binfo = binfo; base_binfo;
10909 base_binfo = TREE_CHAIN (base_binfo))
10911 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
10913 CLASSTYPE_REPEATED_BASE_P (ref) = 1;
10916 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 1;
10918 for (base_binfo = binfo; base_binfo;
10919 base_binfo = TREE_CHAIN (base_binfo))
10920 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
10921 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
10930 /* Begin compiling the definition of an enumeration type.
10933 UNDERLYING_TYPE is the type that will be used as the storage for
10934 the enumeration type. This should be NULL_TREE if no storage type
10937 SCOPED_ENUM_P is true if this is a scoped enumeration type.
10939 Returns the type object, as yet incomplete.
10940 Also records info about it so that build_enumerator
10941 may be used to declare the individual values as they are read. */
10944 start_enum (tree name, tree underlying_type, bool scoped_enum_p)
10948 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
10950 /* If this is the real definition for a previous forward reference,
10951 fill in the contents in the same object that used to be the
10952 forward reference. */
10954 enumtype = lookup_and_check_tag (enum_type, name,
10955 /*tag_scope=*/ts_current,
10956 /*template_header_p=*/false);
10958 if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
10960 error ("multiple definition of %q#T", enumtype);
10961 error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype));
10962 /* Clear out TYPE_VALUES, and start again. */
10963 TYPE_VALUES (enumtype) = NULL_TREE;
10967 /* In case of error, make a dummy enum to allow parsing to
10969 if (enumtype == error_mark_node)
10970 name = make_anon_name ();
10972 enumtype = make_node (ENUMERAL_TYPE);
10973 enumtype = pushtag (name, enumtype, /*tag_scope=*/ts_current);
10976 if (enumtype == error_mark_node)
10981 SET_SCOPED_ENUM_P (enumtype, 1);
10982 begin_scope (sk_scoped_enum, enumtype);
10984 /* [C++0x dcl.enum]p5:
10986 If not explicitly specified, the underlying type of a scoped
10987 enumeration type is int. */
10988 if (!underlying_type)
10989 underlying_type = integer_type_node;
10992 if (underlying_type)
10994 if (CP_INTEGRAL_TYPE_P (underlying_type))
10996 TYPE_MIN_VALUE (enumtype) = TYPE_MIN_VALUE (underlying_type);
10997 TYPE_MAX_VALUE (enumtype) = TYPE_MAX_VALUE (underlying_type);
10998 TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
10999 TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
11000 SET_TYPE_MODE (enumtype, TYPE_MODE (underlying_type));
11001 TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type);
11002 TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
11003 TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
11004 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);
11005 ENUM_UNDERLYING_TYPE (enumtype) = underlying_type;
11008 error ("underlying type %<%T%> of %<%T%> must be an integral type",
11009 underlying_type, enumtype);
11015 /* After processing and defining all the values of an enumeration type,
11016 install their decls in the enumeration type and finish it off.
11017 ENUMTYPE is the type object and VALUES a list of name-value pairs. */
11020 finish_enum (tree enumtype)
11029 bool use_short_enum;
11033 integer_type_kind itk;
11034 tree underlying_type = NULL_TREE;
11035 bool fixed_underlying_type_p
11036 = ENUM_UNDERLYING_TYPE (enumtype) != NULL_TREE;
11038 /* We built up the VALUES in reverse order. */
11039 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
11041 /* For an enum defined in a template, just set the type of the values;
11042 all further processing is postponed until the template is
11043 instantiated. We need to set the type so that tsubst of a CONST_DECL
11045 if (processing_template_decl)
11047 for (values = TYPE_VALUES (enumtype);
11049 values = TREE_CHAIN (values))
11050 TREE_TYPE (TREE_VALUE (values)) = enumtype;
11051 if (at_function_scope_p ())
11052 add_stmt (build_min (TAG_DEFN, enumtype));
11056 /* Determine the minimum and maximum values of the enumerators. */
11057 if (TYPE_VALUES (enumtype))
11059 minnode = maxnode = NULL_TREE;
11061 for (values = TYPE_VALUES (enumtype);
11063 values = TREE_CHAIN (values))
11065 decl = TREE_VALUE (values);
11067 /* [dcl.enum]: Following the closing brace of an enum-specifier,
11068 each enumerator has the type of its enumeration. Prior to the
11069 closing brace, the type of each enumerator is the type of its
11070 initializing value. */
11071 TREE_TYPE (decl) = enumtype;
11073 /* Update the minimum and maximum values, if appropriate. */
11074 value = DECL_INITIAL (decl);
11075 if (value == error_mark_node)
11076 value = integer_zero_node;
11077 /* Figure out what the minimum and maximum values of the
11078 enumerators are. */
11080 minnode = maxnode = value;
11081 else if (tree_int_cst_lt (maxnode, value))
11083 else if (tree_int_cst_lt (value, minnode))
11090 If the enumerator-list is empty, the underlying type is as if
11091 the enumeration had a single enumerator with value 0. */
11092 minnode = maxnode = integer_zero_node;
11094 /* Compute the number of bits require to represent all values of the
11095 enumeration. We must do this before the type of MINNODE and
11096 MAXNODE are transformed, since tree_int_cst_min_precision relies
11097 on the TREE_TYPE of the value it is passed. */
11098 unsignedp = tree_int_cst_sgn (minnode) >= 0;
11099 lowprec = tree_int_cst_min_precision (minnode, unsignedp);
11100 highprec = tree_int_cst_min_precision (maxnode, unsignedp);
11101 precision = MAX (lowprec, highprec);
11103 if (!fixed_underlying_type_p)
11105 /* Determine the underlying type of the enumeration.
11109 The underlying type of an enumeration is an integral type that
11110 can represent all the enumerator values defined in the
11111 enumeration. It is implementation-defined which integral type is
11112 used as the underlying type for an enumeration except that the
11113 underlying type shall not be larger than int unless the value of
11114 an enumerator cannot fit in an int or unsigned int.
11116 We use "int" or an "unsigned int" as the underlying type, even if
11117 a smaller integral type would work, unless the user has
11118 explicitly requested that we use the smallest possible type. The
11119 user can request that for all enumerations with a command line
11120 flag, or for just one enumeration with an attribute. */
11122 use_short_enum = flag_short_enums
11123 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype));
11125 for (itk = (use_short_enum ? itk_char : itk_int);
11129 underlying_type = integer_types[itk];
11130 if (TYPE_PRECISION (underlying_type) >= precision
11131 && TYPE_UNSIGNED (underlying_type) == unsignedp)
11134 if (itk == itk_none)
11138 IF no integral type can represent all the enumerator values, the
11139 enumeration is ill-formed. */
11140 error ("no integral type can represent all of the enumerator values "
11141 "for %qT", enumtype);
11142 precision = TYPE_PRECISION (long_long_integer_type_node);
11143 underlying_type = integer_types[itk_unsigned_long_long];
11148 The value of sizeof() applied to an enumeration type, an object
11149 of an enumeration type, or an enumerator, is the value of sizeof()
11150 applied to the underlying type. */
11151 TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
11152 TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
11153 SET_TYPE_MODE (enumtype, TYPE_MODE (underlying_type));
11154 TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
11155 TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
11156 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);
11158 /* Set the underlying type of the enumeration type to the
11159 computed enumeration type, restricted to the enumerator
11161 ENUM_UNDERLYING_TYPE (enumtype) = copy_node (underlying_type);
11162 set_min_and_max_values_for_integral_type
11163 (ENUM_UNDERLYING_TYPE (enumtype), precision, unsignedp);
11166 underlying_type = ENUM_UNDERLYING_TYPE (enumtype);
11168 /* Compute the minimum and maximum values for the type.
11172 For an enumeration where emin is the smallest enumerator and emax
11173 is the largest, the values of the enumeration are the values of the
11174 underlying type in the range bmin to bmax, where bmin and bmax are,
11175 respectively, the smallest and largest values of the smallest bit-
11176 field that can store emin and emax. */
11178 /* The middle-end currently assumes that types with TYPE_PRECISION
11179 narrower than their underlying type are suitably zero or sign
11180 extended to fill their mode. g++ doesn't make these guarantees.
11181 Until the middle-end can represent such paradoxical types, we
11182 set the TYPE_PRECISION to the width of the underlying type. */
11183 TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type);
11185 set_min_and_max_values_for_integral_type (enumtype, precision, unsignedp);
11187 /* Convert each of the enumerators to the type of the underlying
11188 type of the enumeration. */
11189 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
11191 location_t saved_location;
11193 decl = TREE_VALUE (values);
11194 saved_location = input_location;
11195 input_location = DECL_SOURCE_LOCATION (decl);
11196 if (fixed_underlying_type_p)
11197 /* If the enumeration type has a fixed underlying type, we
11198 already checked all of the enumerator values. */
11199 value = DECL_INITIAL (decl);
11201 value = perform_implicit_conversion (underlying_type,
11202 DECL_INITIAL (decl),
11203 tf_warning_or_error);
11204 input_location = saved_location;
11206 /* Do not clobber shared ints. */
11207 value = copy_node (value);
11209 TREE_TYPE (value) = enumtype;
11210 DECL_INITIAL (decl) = value;
11213 /* Fix up all variant types of this enum type. */
11214 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
11216 TYPE_VALUES (t) = TYPE_VALUES (enumtype);
11217 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
11218 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
11219 TYPE_SIZE (t) = TYPE_SIZE (enumtype);
11220 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
11221 SET_TYPE_MODE (t, TYPE_MODE (enumtype));
11222 TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
11223 TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
11224 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
11225 TYPE_UNSIGNED (t) = TYPE_UNSIGNED (enumtype);
11226 ENUM_UNDERLYING_TYPE (t) = ENUM_UNDERLYING_TYPE (enumtype);
11229 /* Finish up the scope of a scoped enumeration. */
11230 if (SCOPED_ENUM_P (enumtype))
11233 /* Finish debugging output for this type. */
11234 rest_of_type_compilation (enumtype, namespace_bindings_p ());
11237 /* Build and install a CONST_DECL for an enumeration constant of the
11238 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
11239 Assignment of sequential values by default is handled here. */
11242 build_enumerator (tree name, tree value, tree enumtype)
11248 /* If the VALUE was erroneous, pretend it wasn't there; that will
11249 result in the enum being assigned the next value in sequence. */
11250 if (value == error_mark_node)
11253 /* Remove no-op casts from the value. */
11255 STRIP_TYPE_NOPS (value);
11257 if (! processing_template_decl)
11259 /* Validate and default VALUE. */
11260 if (value != NULL_TREE)
11262 value = integral_constant_value (value);
11264 if (TREE_CODE (value) == INTEGER_CST)
11266 value = perform_integral_promotions (value);
11267 constant_expression_warning (value);
11271 error ("enumerator value for %qD is not an integer constant", name);
11276 /* Default based on previous value. */
11277 if (value == NULL_TREE)
11279 if (TYPE_VALUES (enumtype))
11282 unsigned HOST_WIDE_INT lo;
11286 /* The next value is the previous value plus one.
11287 add_double doesn't know the type of the target expression,
11288 so we must check with int_fits_type_p as well. */
11289 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
11290 if (error_operand_p (prev_value))
11291 value = error_mark_node;
11294 overflowed = add_double (TREE_INT_CST_LOW (prev_value),
11295 TREE_INT_CST_HIGH (prev_value),
11297 value = build_int_cst_wide (TREE_TYPE (prev_value), lo, hi);
11299 |= !int_fits_type_p (value, TREE_TYPE (prev_value));
11303 error ("overflow in enumeration values at %qD", name);
11304 value = error_mark_node;
11309 value = integer_zero_node;
11312 /* Remove no-op casts from the value. */
11313 STRIP_TYPE_NOPS (value);
11315 /* If the underlying type of the enum is fixed, check whether
11316 the enumerator values fits in the underlying type. If it
11317 does not fit, the program is ill-formed [C++0x dcl.enum]. */
11318 if (ENUM_UNDERLYING_TYPE (enumtype)
11320 && TREE_CODE (value) == INTEGER_CST
11321 && !int_fits_type_p (value, ENUM_UNDERLYING_TYPE (enumtype)))
11323 error ("enumerator value %E is too large for underlying type %<%T%>",
11324 value, ENUM_UNDERLYING_TYPE (enumtype));
11326 /* Silently convert the value so that we can continue. */
11327 value = perform_implicit_conversion (ENUM_UNDERLYING_TYPE (enumtype),
11332 /* C++ associates enums with global, function, or class declarations. */
11333 context = current_scope ();
11335 /* Build the actual enumeration constant. Note that the enumeration
11336 constants have the underlying type of the enum (if it is fixed)
11337 or the type of their initializer (if the underlying type of the
11338 enum is not fixed):
11342 If the underlying type is fixed, the type of each enumerator
11343 prior to the closing brace is the underlying type; if the
11344 initializing value of an enumerator cannot be represented by
11345 the underlying type, the program is ill-formed. If the
11346 underlying type is not fixed, the type of each enumerator is
11347 the type of its initializing value.
11349 If the underlying type is not fixed, it will be computed by
11350 finish_enum and we will reset the type of this enumerator. Of
11351 course, if we're processing a template, there may be no value. */
11352 type = value ? TREE_TYPE (value) : NULL_TREE;
11354 if (context && context == current_class_type)
11355 /* This enum declaration is local to the class. We need the full
11356 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
11357 decl = build_lang_decl (CONST_DECL, name, type);
11359 /* It's a global enum, or it's local to a function. (Note local to
11360 a function could mean local to a class method. */
11361 decl = build_decl (CONST_DECL, name, type);
11363 DECL_CONTEXT (decl) = FROB_CONTEXT (context);
11364 TREE_CONSTANT (decl) = 1;
11365 TREE_READONLY (decl) = 1;
11366 DECL_INITIAL (decl) = value;
11368 if (context && context == current_class_type)
11369 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
11370 on the TYPE_FIELDS list for `S'. (That's so that you can say
11371 things like `S::i' later.) */
11372 finish_member_declaration (decl);
11376 /* Add this enumeration constant to the list for this type. */
11377 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
11380 /* Look for an enumerator with the given NAME within the enumeration
11381 type ENUMTYPE. This routine is used primarily for qualified name
11382 lookup into an enumerator in C++0x, e.g.,
11384 enum class Color { Red, Green, Blue };
11386 Color color = Color::Red;
11388 Returns the value corresponding to the enumerator, or
11389 NULL_TREE if no such enumerator was found. */
11391 lookup_enumerator (tree enumtype, tree name)
11394 gcc_assert (enumtype && TREE_CODE (enumtype) == ENUMERAL_TYPE);
11396 e = purpose_member (name, TYPE_VALUES (enumtype));
11397 return e? TREE_VALUE (e) : NULL_TREE;
11401 /* We're defining DECL. Make sure that it's type is OK. */
11404 check_function_type (tree decl, tree current_function_parms)
11406 tree fntype = TREE_TYPE (decl);
11407 tree return_type = complete_type (TREE_TYPE (fntype));
11409 /* In a function definition, arg types must be complete. */
11410 require_complete_types_for_parms (current_function_parms);
11412 if (dependent_type_p (return_type))
11414 if (!COMPLETE_OR_VOID_TYPE_P (return_type)
11415 || (TYPE_FOR_JAVA (return_type) && MAYBE_CLASS_TYPE_P (return_type)))
11417 tree args = TYPE_ARG_TYPES (fntype);
11419 if (!COMPLETE_OR_VOID_TYPE_P (return_type))
11420 error ("return type %q#T is incomplete", return_type);
11422 error ("return type has Java class type %q#T", return_type);
11424 /* Make it return void instead. */
11425 if (TREE_CODE (fntype) == METHOD_TYPE)
11426 fntype = build_method_type_directly (TREE_TYPE (TREE_VALUE (args)),
11428 TREE_CHAIN (args));
11430 fntype = build_function_type (void_type_node, args);
11432 = build_exception_variant (fntype,
11433 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)));
11436 abstract_virtuals_error (decl, TREE_TYPE (fntype));
11439 /* Create the FUNCTION_DECL for a function definition.
11440 DECLSPECS and DECLARATOR are the parts of the declaration;
11441 they describe the function's name and the type it returns,
11442 but twisted together in a fashion that parallels the syntax of C.
11444 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
11445 DECLARATOR is really the DECL for the function we are about to
11446 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
11447 indicating that the function is an inline defined in-class.
11449 This function creates a binding context for the function body
11450 as well as setting up the FUNCTION_DECL in current_function_decl.
11452 For C++, we must first check whether that datum makes any sense.
11453 For example, "class A local_a(1,2);" means that variable local_a
11454 is an aggregate of type A, which should have a constructor
11455 applied to it with the argument list [1, 2].
11457 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
11458 or may be a BLOCK if the function has been defined previously
11459 in this translation unit. On exit, DECL_INITIAL (decl1) will be
11460 error_mark_node if the function has never been defined, or
11461 a BLOCK if the function has been defined somewhere. */
11464 start_preparsed_function (tree decl1, tree attrs, int flags)
11466 tree ctype = NULL_TREE;
11469 int doing_friend = 0;
11470 struct cp_binding_level *bl;
11471 tree current_function_parms;
11472 struct c_fileinfo *finfo
11473 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1)));
11474 bool honor_interface;
11476 /* Sanity check. */
11477 gcc_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE);
11478 gcc_assert (TREE_CHAIN (void_list_node) == NULL_TREE);
11480 fntype = TREE_TYPE (decl1);
11481 if (TREE_CODE (fntype) == METHOD_TYPE)
11482 ctype = TYPE_METHOD_BASETYPE (fntype);
11484 /* ISO C++ 11.4/5. A friend function defined in a class is in
11485 the (lexical) scope of the class in which it is defined. */
11486 if (!ctype && DECL_FRIEND_P (decl1))
11488 ctype = DECL_FRIEND_CONTEXT (decl1);
11490 /* CTYPE could be null here if we're dealing with a template;
11491 for example, `inline friend float foo()' inside a template
11492 will have no CTYPE set. */
11493 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
11499 if (DECL_DECLARED_INLINE_P (decl1)
11500 && lookup_attribute ("noinline", attrs))
11501 warning (0, "inline function %q+D given attribute noinline", decl1);
11503 /* Handle gnu_inline attribute. */
11504 if (GNU_INLINE_P (decl1))
11506 DECL_EXTERNAL (decl1) = 1;
11507 DECL_NOT_REALLY_EXTERN (decl1) = 0;
11508 DECL_INTERFACE_KNOWN (decl1) = 1;
11509 DECL_DISREGARD_INLINE_LIMITS (decl1) = 1;
11512 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
11513 /* This is a constructor, we must ensure that any default args
11514 introduced by this definition are propagated to the clones
11515 now. The clones are used directly in overload resolution. */
11516 adjust_clone_args (decl1);
11518 /* Sometimes we don't notice that a function is a static member, and
11519 build a METHOD_TYPE for it. Fix that up now. */
11520 if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
11521 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
11523 revert_static_member_fn (decl1);
11527 /* Set up current_class_type, and enter the scope of the class, if
11530 push_nested_class (ctype);
11531 else if (DECL_STATIC_FUNCTION_P (decl1))
11532 push_nested_class (DECL_CONTEXT (decl1));
11534 /* Now that we have entered the scope of the class, we must restore
11535 the bindings for any template parameters surrounding DECL1, if it
11536 is an inline member template. (Order is important; consider the
11537 case where a template parameter has the same name as a field of
11538 the class.) It is not until after this point that
11539 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
11540 if (flags & SF_INCLASS_INLINE)
11541 maybe_begin_member_template_processing (decl1);
11543 /* Effective C++ rule 15. */
11545 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
11546 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
11547 warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");
11549 /* Make the init_value nonzero so pushdecl knows this is not tentative.
11550 error_mark_node is replaced below (in poplevel) with the BLOCK. */
11551 if (!DECL_INITIAL (decl1))
11552 DECL_INITIAL (decl1) = error_mark_node;
11554 /* This function exists in static storage.
11555 (This does not mean `static' in the C sense!) */
11556 TREE_STATIC (decl1) = 1;
11558 /* We must call push_template_decl after current_class_type is set
11559 up. (If we are processing inline definitions after exiting a
11560 class scope, current_class_type will be NULL_TREE until set above
11561 by push_nested_class.) */
11562 if (processing_template_decl)
11564 /* FIXME: Handle error_mark_node more gracefully. */
11565 tree newdecl1 = push_template_decl (decl1);
11566 if (newdecl1 != error_mark_node)
11570 /* We are now in the scope of the function being defined. */
11571 current_function_decl = decl1;
11573 /* Save the parm names or decls from this function's declarator
11574 where store_parm_decls will find them. */
11575 current_function_parms = DECL_ARGUMENTS (decl1);
11577 /* Make sure the parameter and return types are reasonable. When
11578 you declare a function, these types can be incomplete, but they
11579 must be complete when you define the function. */
11580 check_function_type (decl1, current_function_parms);
11582 /* Build the return declaration for the function. */
11583 restype = TREE_TYPE (fntype);
11584 if (DECL_RESULT (decl1) == NULL_TREE)
11588 resdecl = build_decl (RESULT_DECL, 0, restype);
11589 DECL_ARTIFICIAL (resdecl) = 1;
11590 DECL_IGNORED_P (resdecl) = 1;
11591 DECL_RESULT (decl1) = resdecl;
11593 cp_apply_type_quals_to_decl (cp_type_quals (restype), resdecl);
11596 /* Let the user know we're compiling this function. */
11597 announce_function (decl1);
11599 /* Record the decl so that the function name is defined.
11600 If we already have a decl for this name, and it is a FUNCTION_DECL,
11601 use the old decl. */
11602 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
11604 /* A specialization is not used to guide overload resolution. */
11605 if (!DECL_FUNCTION_MEMBER_P (decl1)
11606 && !(DECL_USE_TEMPLATE (decl1) &&
11607 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1))))
11609 tree olddecl = pushdecl (decl1);
11611 if (olddecl == error_mark_node)
11612 /* If something went wrong when registering the declaration,
11613 use DECL1; we have to have a FUNCTION_DECL to use when
11614 parsing the body of the function. */
11618 /* Otherwise, OLDDECL is either a previous declaration
11619 of the same function or DECL1 itself. */
11621 if (warn_missing_declarations
11622 && olddecl == decl1
11623 && !DECL_MAIN_P (decl1)
11624 && TREE_PUBLIC (decl1)
11625 && !DECL_DECLARED_INLINE_P (decl1))
11629 /* Check whether DECL1 is in an anonymous
11631 for (context = DECL_CONTEXT (decl1);
11633 context = DECL_CONTEXT (context))
11635 if (TREE_CODE (context) == NAMESPACE_DECL
11636 && DECL_NAME (context) == NULL_TREE)
11640 if (context == NULL)
11641 warning (OPT_Wmissing_declarations,
11642 "no previous declaration for %q+D", decl1);
11650 /* We need to set the DECL_CONTEXT. */
11651 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
11652 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
11654 fntype = TREE_TYPE (decl1);
11656 /* If #pragma weak applies, mark the decl appropriately now.
11657 The pragma only applies to global functions. Because
11658 determining whether or not the #pragma applies involves
11659 computing the mangled name for the declaration, we cannot
11660 apply the pragma until after we have merged this declaration
11661 with any previous declarations; if the original declaration
11662 has a linkage specification, that specification applies to
11663 the definition as well, and may affect the mangled name. */
11664 if (!DECL_CONTEXT (decl1))
11665 maybe_apply_pragma_weak (decl1);
11668 /* Reset this in case the call to pushdecl changed it. */
11669 current_function_decl = decl1;
11671 gcc_assert (DECL_INITIAL (decl1));
11673 /* This function may already have been parsed, in which case just
11674 return; our caller will skip over the body without parsing. */
11675 if (DECL_INITIAL (decl1) != error_mark_node)
11678 /* Initialize RTL machinery. We cannot do this until
11679 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
11680 even when processing a template; this is how we get
11681 CFUN set up, and our per-function variables initialized.
11682 FIXME factor out the non-RTL stuff. */
11683 bl = current_binding_level;
11684 allocate_struct_function (decl1, processing_template_decl);
11686 /* Initialize the language data structures. Whenever we start
11687 a new function, we destroy temporaries in the usual way. */
11688 cfun->language = GGC_CNEW (struct language_function);
11689 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
11690 current_binding_level = bl;
11692 /* Even though we're inside a function body, we still don't want to
11693 call expand_expr to calculate the size of a variable-sized array.
11694 We haven't necessarily assigned RTL to all variables yet, so it's
11695 not safe to try to expand expressions involving them. */
11696 cfun->dont_save_pending_sizes_p = 1;
11698 /* Start the statement-tree, start the tree now. */
11699 DECL_SAVED_TREE (decl1) = push_stmt_list ();
11701 /* If we are (erroneously) defining a function that we have already
11702 defined before, wipe out what we knew before. */
11703 if (!DECL_PENDING_INLINE_P (decl1))
11704 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
11706 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
11708 /* We know that this was set up by `grokclassfn'. We do not
11709 wait until `store_parm_decls', since evil parse errors may
11710 never get us to that point. Here we keep the consistency
11711 between `current_class_type' and `current_class_ptr'. */
11712 tree t = DECL_ARGUMENTS (decl1);
11714 gcc_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL);
11715 gcc_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE);
11717 cp_function_chain->x_current_class_ref
11718 = cp_build_indirect_ref (t, NULL, tf_warning_or_error);
11719 cp_function_chain->x_current_class_ptr = t;
11721 /* Constructors and destructors need to know whether they're "in
11722 charge" of initializing virtual base classes. */
11723 t = TREE_CHAIN (t);
11724 if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
11726 current_in_charge_parm = t;
11727 t = TREE_CHAIN (t);
11729 if (DECL_HAS_VTT_PARM_P (decl1))
11731 gcc_assert (DECL_NAME (t) == vtt_parm_identifier);
11732 current_vtt_parm = t;
11736 honor_interface = (!DECL_TEMPLATE_INSTANTIATION (decl1)
11737 /* Implicitly-defined methods (like the
11738 destructor for a class in which no destructor
11739 is explicitly declared) must not be defined
11740 until their definition is needed. So, we
11741 ignore interface specifications for
11742 compiler-generated functions. */
11743 && !DECL_ARTIFICIAL (decl1));
11745 if (DECL_INTERFACE_KNOWN (decl1))
11747 tree ctx = decl_function_context (decl1);
11749 if (DECL_NOT_REALLY_EXTERN (decl1))
11750 DECL_EXTERNAL (decl1) = 0;
11752 if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
11753 && TREE_PUBLIC (ctx))
11754 /* This is a function in a local class in an extern inline
11756 comdat_linkage (decl1);
11758 /* If this function belongs to an interface, it is public.
11759 If it belongs to someone else's interface, it is also external.
11760 This only affects inlines and template instantiations. */
11761 else if (!finfo->interface_unknown && honor_interface)
11763 if (DECL_DECLARED_INLINE_P (decl1)
11764 || DECL_TEMPLATE_INSTANTIATION (decl1)
11765 || processing_template_decl)
11767 DECL_EXTERNAL (decl1)
11768 = (finfo->interface_only
11769 || (DECL_DECLARED_INLINE_P (decl1)
11770 && ! flag_implement_inlines
11771 && !DECL_VINDEX (decl1)));
11773 /* For WIN32 we also want to put these in linkonce sections. */
11774 maybe_make_one_only (decl1);
11777 DECL_EXTERNAL (decl1) = 0;
11778 DECL_INTERFACE_KNOWN (decl1) = 1;
11779 /* If this function is in an interface implemented in this file,
11780 make sure that the back end knows to emit this function
11782 if (!DECL_EXTERNAL (decl1))
11783 mark_needed (decl1);
11785 else if (finfo->interface_unknown && finfo->interface_only
11786 && honor_interface)
11788 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
11789 interface, we will have both finfo->interface_unknown and
11790 finfo->interface_only set. In that case, we don't want to
11791 use the normal heuristics because someone will supply a
11792 #pragma implementation elsewhere, and deducing it here would
11793 produce a conflict. */
11794 comdat_linkage (decl1);
11795 DECL_EXTERNAL (decl1) = 0;
11796 DECL_INTERFACE_KNOWN (decl1) = 1;
11797 DECL_DEFER_OUTPUT (decl1) = 1;
11801 /* This is a definition, not a reference.
11802 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
11803 if (!GNU_INLINE_P (decl1))
11804 DECL_EXTERNAL (decl1) = 0;
11806 if ((DECL_DECLARED_INLINE_P (decl1)
11807 || DECL_TEMPLATE_INSTANTIATION (decl1))
11808 && ! DECL_INTERFACE_KNOWN (decl1)
11809 /* Don't try to defer nested functions for now. */
11810 && ! decl_function_context (decl1))
11811 DECL_DEFER_OUTPUT (decl1) = 1;
11813 DECL_INTERFACE_KNOWN (decl1) = 1;
11816 /* Determine the ELF visibility attribute for the function. We must not
11817 do this before calling "pushdecl", as we must allow "duplicate_decls"
11818 to merge any attributes appropriately. We also need to wait until
11820 if (!DECL_CLONED_FUNCTION_P (decl1))
11821 determine_visibility (decl1);
11823 begin_scope (sk_function_parms, decl1);
11827 if (DECL_DESTRUCTOR_P (decl1)
11828 || (DECL_CONSTRUCTOR_P (decl1)
11829 && targetm.cxx.cdtor_returns_this ()))
11831 cdtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
11832 DECL_CONTEXT (cdtor_label) = current_function_decl;
11835 start_fname_decls ();
11837 store_parm_decls (current_function_parms);
11841 /* Like start_preparsed_function, except that instead of a
11842 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
11844 Returns 1 on success. If the DECLARATOR is not suitable for a function
11845 (it defines a datum instead), we return 0, which tells
11846 yyparse to report a parse error. */
11849 start_function (cp_decl_specifier_seq *declspecs,
11850 const cp_declarator *declarator,
11855 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
11856 if (decl1 == error_mark_node)
11858 /* If the declarator is not suitable for a function definition,
11859 cause a syntax error. */
11860 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
11862 error ("invalid function declaration");
11866 if (DECL_MAIN_P (decl1))
11867 /* main must return int. grokfndecl should have corrected it
11868 (and issued a diagnostic) if the user got it wrong. */
11869 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1)),
11870 integer_type_node));
11872 start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT);
11877 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
11881 use_eh_spec_block (tree fn)
11883 return (flag_exceptions && flag_enforce_eh_specs
11884 && !processing_template_decl
11885 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn))
11886 /* We insert the EH_SPEC_BLOCK only in the original
11887 function; then, it is copied automatically to the
11889 && !DECL_CLONED_FUNCTION_P (fn)
11890 /* Implicitly-generated constructors and destructors have
11891 exception specifications. However, those specifications
11892 are the union of the possible exceptions specified by the
11893 constructors/destructors for bases and members, so no
11894 unallowed exception will ever reach this function. By
11895 not creating the EH_SPEC_BLOCK we save a little memory,
11896 and we avoid spurious warnings about unreachable
11898 && !DECL_ARTIFICIAL (fn));
11901 /* Store the parameter declarations into the current function declaration.
11902 This is called after parsing the parameter declarations, before
11903 digesting the body of the function.
11905 Also install to binding contour return value identifier, if any. */
11908 store_parm_decls (tree current_function_parms)
11910 tree fndecl = current_function_decl;
11913 /* This is a chain of any other decls that came in among the parm
11914 declarations. If a parm is declared with enum {foo, bar} x;
11915 then CONST_DECLs for foo and bar are put here. */
11916 tree nonparms = NULL_TREE;
11918 if (current_function_parms)
11920 /* This case is when the function was defined with an ANSI prototype.
11921 The parms already have decls, so we need not do anything here
11922 except record them as in effect
11923 and complain if any redundant old-style parm decls were written. */
11925 tree specparms = current_function_parms;
11928 /* Must clear this because it might contain TYPE_DECLs declared
11930 current_binding_level->names = NULL;
11932 /* If we're doing semantic analysis, then we'll call pushdecl
11933 for each of these. We must do them in reverse order so that
11934 they end in the correct forward order. */
11935 specparms = nreverse (specparms);
11937 for (parm = specparms; parm; parm = next)
11939 next = TREE_CHAIN (parm);
11940 if (TREE_CODE (parm) == PARM_DECL)
11942 if (DECL_NAME (parm) == NULL_TREE
11943 || TREE_CODE (parm) != VOID_TYPE)
11946 error ("parameter %qD declared void", parm);
11950 /* If we find an enum constant or a type tag,
11951 put it aside for the moment. */
11952 TREE_CHAIN (parm) = NULL_TREE;
11953 nonparms = chainon (nonparms, parm);
11957 /* Get the decls in their original chain order and record in the
11958 function. This is all and only the PARM_DECLs that were
11959 pushed into scope by the loop above. */
11960 DECL_ARGUMENTS (fndecl) = getdecls ();
11963 DECL_ARGUMENTS (fndecl) = NULL_TREE;
11965 /* Now store the final chain of decls for the arguments
11966 as the decl-chain of the current lexical scope.
11967 Put the enumerators in as well, at the front so that
11968 DECL_ARGUMENTS is not modified. */
11969 current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));
11971 if (use_eh_spec_block (current_function_decl))
11972 current_eh_spec_block = begin_eh_spec_block ();
11976 /* We have finished doing semantic analysis on DECL, but have not yet
11977 generated RTL for its body. Save away our current state, so that
11978 when we want to generate RTL later we know what to do. */
11981 save_function_data (tree decl)
11983 struct language_function *f;
11985 /* Save the language-specific per-function data so that we can
11986 get it back when we really expand this function. */
11987 gcc_assert (!DECL_PENDING_INLINE_P (decl));
11990 f = GGC_NEW (struct language_function);
11991 memcpy (f, cp_function_chain, sizeof (struct language_function));
11992 DECL_SAVED_FUNCTION_DATA (decl) = f;
11994 /* Clear out the bits we don't need. */
11995 f->base.x_stmt_tree.x_cur_stmt_list = NULL_TREE;
11996 f->bindings = NULL;
11997 f->x_local_names = NULL;
12001 /* Set the return value of the constructor (if present). */
12004 finish_constructor_body (void)
12009 if (targetm.cxx.cdtor_returns_this ()
12010 && (! TYPE_FOR_JAVA (current_class_type)))
12012 /* Any return from a constructor will end up here. */
12013 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
12015 val = DECL_ARGUMENTS (current_function_decl);
12016 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
12017 DECL_RESULT (current_function_decl), val);
12018 /* Return the address of the object. */
12019 exprstmt = build_stmt (RETURN_EXPR, val);
12020 add_stmt (exprstmt);
12024 /* Do all the processing for the beginning of a destructor; set up the
12025 vtable pointers and cleanups for bases and members. */
12028 begin_destructor_body (void)
12030 tree compound_stmt;
12032 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
12033 issued an error message. We still want to try to process the
12034 body of the function, but initialize_vtbl_ptrs will crash if
12035 TYPE_BINFO is NULL. */
12036 if (COMPLETE_TYPE_P (current_class_type))
12038 compound_stmt = begin_compound_stmt (0);
12039 /* Make all virtual function table pointers in non-virtual base
12040 classes point to CURRENT_CLASS_TYPE's virtual function
12042 initialize_vtbl_ptrs (current_class_ptr);
12043 finish_compound_stmt (compound_stmt);
12045 /* And insert cleanups for our bases and members so that they
12046 will be properly destroyed if we throw. */
12047 push_base_cleanups ();
12051 /* At the end of every destructor we generate code to delete the object if
12052 necessary. Do that now. */
12055 finish_destructor_body (void)
12059 /* Any return from a destructor will end up here; that way all base
12060 and member cleanups will be run when the function returns. */
12061 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
12063 /* In a virtual destructor, we must call delete. */
12064 if (DECL_VIRTUAL_P (current_function_decl))
12067 tree virtual_size = cxx_sizeof (current_class_type);
12071 At the point of definition of a virtual destructor (including
12072 an implicit definition), non-placement operator delete shall
12073 be looked up in the scope of the destructor's class and if
12074 found shall be accessible and unambiguous. */
12075 exprstmt = build_op_delete_call(DELETE_EXPR, current_class_ptr,
12077 /*global_p=*/false,
12078 /*placement=*/NULL_TREE,
12079 /*alloc_fn=*/NULL_TREE);
12081 if_stmt = begin_if_stmt ();
12082 finish_if_stmt_cond (build2 (BIT_AND_EXPR, integer_type_node,
12083 current_in_charge_parm,
12086 finish_expr_stmt (exprstmt);
12087 finish_then_clause (if_stmt);
12088 finish_if_stmt (if_stmt);
12091 if (targetm.cxx.cdtor_returns_this ())
12095 val = DECL_ARGUMENTS (current_function_decl);
12096 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
12097 DECL_RESULT (current_function_decl), val);
12098 /* Return the address of the object. */
12099 exprstmt = build_stmt (RETURN_EXPR, val);
12100 add_stmt (exprstmt);
12104 /* Do the necessary processing for the beginning of a function body, which
12105 in this case includes member-initializers, but not the catch clauses of
12106 a function-try-block. Currently, this means opening a binding level
12107 for the member-initializers (in a ctor) and member cleanups (in a dtor). */
12110 begin_function_body (void)
12114 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
12117 if (processing_template_decl)
12118 /* Do nothing now. */;
12120 /* Always keep the BLOCK node associated with the outermost pair of
12121 curly braces of a function. These are needed for correct
12122 operation of dwarfout.c. */
12123 keep_next_level (true);
12125 stmt = begin_compound_stmt (BCS_FN_BODY);
12127 if (processing_template_decl)
12128 /* Do nothing now. */;
12129 else if (DECL_DESTRUCTOR_P (current_function_decl))
12130 begin_destructor_body ();
12135 /* Do the processing for the end of a function body. Currently, this means
12136 closing out the cleanups for fully-constructed bases and members, and in
12137 the case of the destructor, deleting the object if desired. Again, this
12138 is only meaningful for [cd]tors, since they are the only functions where
12139 there is a significant distinction between the main body and any
12140 function catch clauses. Handling, say, main() return semantics here
12141 would be wrong, as flowing off the end of a function catch clause for
12142 main() would also need to return 0. */
12145 finish_function_body (tree compstmt)
12147 if (compstmt == NULL_TREE)
12150 /* Close the block. */
12151 finish_compound_stmt (compstmt);
12153 if (processing_template_decl)
12154 /* Do nothing now. */;
12155 else if (DECL_CONSTRUCTOR_P (current_function_decl))
12156 finish_constructor_body ();
12157 else if (DECL_DESTRUCTOR_P (current_function_decl))
12158 finish_destructor_body ();
12161 /* Given a function, returns the BLOCK corresponding to the outermost level
12162 of curly braces, skipping the artificial block created for constructor
12166 outer_curly_brace_block (tree fndecl)
12168 tree block = BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl));
12169 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
12170 /* Skip the artificial function body block. */
12171 block = BLOCK_SUBBLOCKS (block);
12175 /* Finish up a function declaration and compile that function
12176 all the way to assembler language output. The free the storage
12177 for the function definition.
12179 FLAGS is a bitwise or of the following values:
12181 We just finished processing the body of an in-class inline
12182 function definition. (This processing will have taken place
12183 after the class definition is complete.) */
12186 finish_function (int flags)
12188 tree fndecl = current_function_decl;
12189 tree fntype, ctype = NULL_TREE;
12190 int inclass_inline = (flags & 2) != 0;
12193 /* When we get some parse errors, we can end up without a
12194 current_function_decl, so cope. */
12195 if (fndecl == NULL_TREE)
12196 return error_mark_node;
12198 gcc_assert (!defer_mark_used_calls);
12199 defer_mark_used_calls = true;
12201 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
12202 && DECL_VIRTUAL_P (fndecl)
12203 && !processing_template_decl)
12205 tree fnclass = DECL_CONTEXT (fndecl);
12206 if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
12207 keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
12210 nested = function_depth > 1;
12211 fntype = TREE_TYPE (fndecl);
12213 /* TREE_READONLY (fndecl) = 1;
12214 This caused &foo to be of type ptr-to-const-function
12215 which then got a warning when stored in a ptr-to-function variable. */
12217 gcc_assert (building_stmt_tree ());
12218 /* The current function is being defined, so its DECL_INITIAL should
12219 be set, and unless there's a multiple definition, it should be
12220 error_mark_node. */
12221 gcc_assert (DECL_INITIAL (fndecl) == error_mark_node);
12223 /* For a cloned function, we've already got all the code we need;
12224 there's no need to add any extra bits. */
12225 if (!DECL_CLONED_FUNCTION_P (fndecl))
12227 if (DECL_MAIN_P (current_function_decl))
12231 /* Make it so that `main' always returns 0 by default (or
12234 stmt = finish_return_stmt (integer_one_node);
12236 stmt = finish_return_stmt (integer_zero_node);
12238 /* Hack. We don't want the middle-end to warn that this
12239 return is unreachable, so put the statement on the
12242 location_t linezero = linemap_line_start (line_table, 0, 1);
12243 SET_EXPR_LOCATION (stmt, linezero);
12247 if (use_eh_spec_block (current_function_decl))
12248 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
12249 (TREE_TYPE (current_function_decl)),
12250 current_eh_spec_block);
12253 /* If we're saving up tree structure, tie off the function now. */
12254 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
12256 finish_fname_decls ();
12258 /* If this function can't throw any exceptions, remember that. */
12259 if (!processing_template_decl
12260 && !cp_function_chain->can_throw
12261 && !flag_non_call_exceptions
12262 && !DECL_REPLACEABLE_P (fndecl))
12263 TREE_NOTHROW (fndecl) = 1;
12265 /* This must come after expand_function_end because cleanups might
12266 have declarations (from inline functions) that need to go into
12267 this function's blocks. */
12269 /* If the current binding level isn't the outermost binding level
12270 for this function, either there is a bug, or we have experienced
12271 syntax errors and the statement tree is malformed. */
12272 if (current_binding_level->kind != sk_function_parms)
12274 /* Make sure we have already experienced errors. */
12275 gcc_assert (errorcount);
12277 /* Throw away the broken statement tree and extra binding
12279 DECL_SAVED_TREE (fndecl) = alloc_stmt_list ();
12281 while (current_binding_level->kind != sk_function_parms)
12283 if (current_binding_level->kind == sk_class)
12284 pop_nested_class ();
12286 poplevel (0, 0, 0);
12289 poplevel (1, 0, 1);
12291 /* Statements should always be full-expressions at the outermost set
12292 of curly braces for a function. */
12293 gcc_assert (stmts_are_full_exprs_p ());
12295 /* Set up the named return value optimization, if we can. Candidate
12296 variables are selected in check_return_expr. */
12297 if (current_function_return_value)
12299 tree r = current_function_return_value;
12302 if (r != error_mark_node
12303 /* This is only worth doing for fns that return in memory--and
12304 simpler, since we don't have to worry about promoted modes. */
12305 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
12306 /* Only allow this for variables declared in the outer scope of
12307 the function so we know that their lifetime always ends with a
12308 return; see g++.dg/opt/nrv6.C. We could be more flexible if
12309 we were to do this optimization in tree-ssa. */
12310 && (outer = outer_curly_brace_block (fndecl))
12311 && chain_member (r, BLOCK_VARS (outer)))
12312 finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));
12314 current_function_return_value = NULL_TREE;
12317 /* Remember that we were in class scope. */
12318 if (current_class_name)
12319 ctype = current_class_type;
12321 /* Must mark the RESULT_DECL as being in this function. */
12322 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
12324 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
12325 to the FUNCTION_DECL node itself. */
12326 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
12328 /* Save away current state, if appropriate. */
12329 if (!processing_template_decl)
12330 save_function_data (fndecl);
12332 /* Complain if there's just no return statement. */
12333 if (warn_return_type
12334 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
12335 && !dependent_type_p (TREE_TYPE (fntype))
12336 && !current_function_returns_value && !current_function_returns_null
12337 /* Don't complain if we abort or throw. */
12338 && !current_function_returns_abnormally
12339 && !DECL_NAME (DECL_RESULT (fndecl))
12340 && !TREE_NO_WARNING (fndecl)
12341 /* Structor return values (if any) are set by the compiler. */
12342 && !DECL_CONSTRUCTOR_P (fndecl)
12343 && !DECL_DESTRUCTOR_P (fndecl))
12345 warning (OPT_Wreturn_type,
12346 "no return statement in function returning non-void");
12347 TREE_NO_WARNING (fndecl) = 1;
12350 /* Store the end of the function, so that we get good line number
12351 info for the epilogue. */
12352 cfun->function_end_locus = input_location;
12354 /* Genericize before inlining. */
12355 if (!processing_template_decl)
12357 struct language_function *f = DECL_SAVED_FUNCTION_DATA (fndecl);
12358 invoke_plugin_callbacks (PLUGIN_CXX_CP_PRE_GENERICIZE, fndecl);
12359 cp_genericize (fndecl);
12360 /* Clear out the bits we don't need. */
12361 f->x_current_class_ptr = NULL;
12362 f->x_current_class_ref = NULL;
12363 f->x_eh_spec_block = NULL;
12364 f->x_in_charge_parm = NULL;
12365 f->x_vtt_parm = NULL;
12366 f->x_return_value = NULL;
12367 f->bindings = NULL;
12368 f->extern_decl_map = NULL;
12370 /* Handle attribute((warn_unused_result)). Relies on gimple input. */
12371 c_warn_unused_result (gimple_body (fndecl));
12373 /* Clear out the bits we don't need. */
12374 local_names = NULL;
12376 /* We're leaving the context of this function, so zap cfun. It's still in
12377 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
12379 current_function_decl = NULL;
12381 /* If this is an in-class inline definition, we may have to pop the
12382 bindings for the template parameters that we added in
12383 maybe_begin_member_template_processing when start_function was
12385 if (inclass_inline)
12386 maybe_end_member_template_processing ();
12388 /* Leave the scope of the class. */
12390 pop_nested_class ();
12396 /* Let the error reporting routines know that we're outside a
12397 function. For a nested function, this value is used in
12398 cxx_pop_function_context and then reset via pop_function_context. */
12399 current_function_decl = NULL_TREE;
12401 defer_mark_used_calls = false;
12402 if (deferred_mark_used_calls)
12407 for (i = 0; VEC_iterate (tree, deferred_mark_used_calls, i, decl); i++)
12409 VEC_free (tree, gc, deferred_mark_used_calls);
12415 /* Create the FUNCTION_DECL for a function definition.
12416 DECLSPECS and DECLARATOR are the parts of the declaration;
12417 they describe the return type and the name of the function,
12418 but twisted together in a fashion that parallels the syntax of C.
12420 This function creates a binding context for the function body
12421 as well as setting up the FUNCTION_DECL in current_function_decl.
12423 Returns a FUNCTION_DECL on success.
12425 If the DECLARATOR is not suitable for a function (it defines a datum
12426 instead), we return 0, which tells yyparse to report a parse error.
12428 May return void_type_node indicating that this method is actually
12429 a friend. See grokfield for more details.
12431 Came here with a `.pushlevel' .
12433 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
12434 CHANGES TO CODE IN `grokfield'. */
12437 start_method (cp_decl_specifier_seq *declspecs,
12438 const cp_declarator *declarator, tree attrlist)
12440 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
12443 if (fndecl == error_mark_node)
12444 return error_mark_node;
12446 if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
12448 error ("invalid member function declaration");
12449 return error_mark_node;
12453 cplus_decl_attributes (&fndecl, attrlist, 0);
12455 /* Pass friends other than inline friend functions back. */
12456 if (fndecl == void_type_node)
12459 if (DECL_IN_AGGR_P (fndecl))
12461 if (DECL_CONTEXT (fndecl)
12462 && TREE_CODE (DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
12463 error ("%qD is already defined in class %qT", fndecl,
12464 DECL_CONTEXT (fndecl));
12465 return error_mark_node;
12468 check_template_shadow (fndecl);
12470 DECL_DECLARED_INLINE_P (fndecl) = 1;
12471 DECL_NO_INLINE_WARNING_P (fndecl) = 1;
12473 /* We process method specializations in finish_struct_1. */
12474 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
12476 fndecl = push_template_decl (fndecl);
12477 if (fndecl == error_mark_node)
12481 if (! DECL_FRIEND_P (fndecl))
12483 if (TREE_CHAIN (fndecl))
12485 fndecl = copy_node (fndecl);
12486 TREE_CHAIN (fndecl) = NULL_TREE;
12490 finish_decl (fndecl, NULL_TREE, NULL_TREE);
12492 /* Make a place for the parms. */
12493 begin_scope (sk_function_parms, fndecl);
12495 DECL_IN_AGGR_P (fndecl) = 1;
12499 /* Go through the motions of finishing a function definition.
12500 We don't compile this method until after the whole class has
12503 FINISH_METHOD must return something that looks as though it
12504 came from GROKFIELD (since we are defining a method, after all).
12506 This is called after parsing the body of the function definition.
12507 STMTS is the chain of statements that makes up the function body.
12509 DECL is the ..._DECL that `start_method' provided. */
12512 finish_method (tree decl)
12514 tree fndecl = decl;
12519 if (decl == void_type_node)
12522 old_initial = DECL_INITIAL (fndecl);
12524 /* Undo the level for the parms (from start_method).
12525 This is like poplevel, but it causes nothing to be
12526 saved. Saving information here confuses symbol-table
12527 output routines. Besides, this information will
12528 be correctly output when this method is actually
12531 /* Clear out the meanings of the local variables of this level;
12532 also record in each decl which block it belongs to. */
12534 for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
12536 if (DECL_NAME (link) != NULL_TREE)
12537 pop_binding (DECL_NAME (link), link);
12538 gcc_assert (TREE_CODE (link) != FUNCTION_DECL);
12539 DECL_CONTEXT (link) = NULL_TREE;
12542 poplevel (0, 0, 0);
12544 DECL_INITIAL (fndecl) = old_initial;
12546 /* We used to check if the context of FNDECL was different from
12547 current_class_type as another way to get inside here. This didn't work
12548 for String.cc in libg++. */
12549 if (DECL_FRIEND_P (fndecl))
12551 VEC_safe_push (tree, gc, CLASSTYPE_INLINE_FRIENDS (current_class_type),
12553 decl = void_type_node;
12560 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
12561 we can lay it out later, when and if its type becomes complete. */
12564 maybe_register_incomplete_var (tree var)
12566 gcc_assert (TREE_CODE (var) == VAR_DECL);
12568 /* Keep track of variables with incomplete types. */
12569 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
12570 && DECL_EXTERNAL (var))
12572 tree inner_type = TREE_TYPE (var);
12574 while (TREE_CODE (inner_type) == ARRAY_TYPE)
12575 inner_type = TREE_TYPE (inner_type);
12576 inner_type = TYPE_MAIN_VARIANT (inner_type);
12578 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
12579 /* RTTI TD entries are created while defining the type_info. */
12580 || (TYPE_LANG_SPECIFIC (inner_type)
12581 && TYPE_BEING_DEFINED (inner_type)))
12582 incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
12586 /* Called when a class type (given by TYPE) is defined. If there are
12587 any existing VAR_DECLs whose type has been completed by this
12588 declaration, update them now. */
12591 complete_vars (tree type)
12593 tree *list = &incomplete_vars;
12595 gcc_assert (CLASS_TYPE_P (type));
12598 if (same_type_p (type, TREE_PURPOSE (*list)))
12600 tree var = TREE_VALUE (*list);
12601 tree type = TREE_TYPE (var);
12602 /* Complete the type of the variable. The VAR_DECL itself
12603 will be laid out in expand_expr. */
12604 complete_type (type);
12605 cp_apply_type_quals_to_decl (cp_type_quals (type), var);
12606 /* Remove this entry from the list. */
12607 *list = TREE_CHAIN (*list);
12610 list = &TREE_CHAIN (*list);
12613 /* Check for pending declarations which may have abstract type. */
12614 complete_type_check_abstract (type);
12617 /* If DECL is of a type which needs a cleanup, build and return an
12618 expression to perform that cleanup here. Return NULL_TREE if no
12619 cleanup need be done. */
12622 cxx_maybe_build_cleanup (tree decl)
12628 /* Assume no cleanup is required. */
12629 cleanup = NULL_TREE;
12631 if (error_operand_p (decl))
12634 /* Handle "__attribute__((cleanup))". We run the cleanup function
12635 before the destructor since the destructor is what actually
12636 terminates the lifetime of the object. */
12637 attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
12644 /* Get the name specified by the user for the cleanup function. */
12645 id = TREE_VALUE (TREE_VALUE (attr));
12646 /* Look up the name to find the cleanup function to call. It is
12647 important to use lookup_name here because that is what is
12648 used in c-common.c:handle_cleanup_attribute when performing
12649 initial checks on the attribute. Note that those checks
12650 include ensuring that the function found is not an overloaded
12651 function, or an object with an overloaded call operator,
12652 etc.; we can rely on the fact that the function found is an
12653 ordinary FUNCTION_DECL. */
12654 fn = lookup_name (id);
12655 arg = build_address (decl);
12657 cleanup = cp_build_function_call (fn, build_tree_list (NULL_TREE,
12659 tf_warning_or_error);
12661 /* Handle ordinary C++ destructors. */
12662 type = TREE_TYPE (decl);
12663 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
12665 int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
12666 bool has_vbases = (TREE_CODE (type) == RECORD_TYPE
12667 && CLASSTYPE_VBASECLASSES (type));
12671 if (TREE_CODE (type) == ARRAY_TYPE)
12674 addr = build_address (decl);
12676 /* Optimize for space over speed here. */
12677 if (!has_vbases || flag_expensive_optimizations)
12678 flags |= LOOKUP_NONVIRTUAL;
12680 call = build_delete (TREE_TYPE (addr), addr,
12681 sfk_complete_destructor, flags, 0);
12683 cleanup = build_compound_expr (cleanup, call);
12691 /* When a stmt has been parsed, this function is called. */
12698 /* DECL was originally constructed as a non-static member function,
12699 but turned out to be static. Update it accordingly. */
12702 revert_static_member_fn (tree decl)
12705 tree function = TREE_TYPE (decl);
12706 tree args = TYPE_ARG_TYPES (function);
12708 if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
12709 != TYPE_UNQUALIFIED)
12710 error ("static member function %q#D declared with type qualifiers", decl);
12712 args = TREE_CHAIN (args);
12713 tmp = build_function_type (TREE_TYPE (function), args);
12714 tmp = build_qualified_type (tmp, cp_type_quals (function));
12715 tmp = build_exception_variant (tmp,
12716 TYPE_RAISES_EXCEPTIONS (function));
12717 TREE_TYPE (decl) = tmp;
12718 if (DECL_ARGUMENTS (decl))
12719 DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
12720 DECL_STATIC_FUNCTION_P (decl) = 1;
12723 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
12724 one of the language-independent trees. */
12726 enum cp_tree_node_structure_enum
12727 cp_tree_node_structure (union lang_tree_node * t)
12729 switch (TREE_CODE (&t->generic))
12731 case DEFAULT_ARG: return TS_CP_DEFAULT_ARG;
12732 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER;
12733 case OVERLOAD: return TS_CP_OVERLOAD;
12734 case TEMPLATE_PARM_INDEX: return TS_CP_TPI;
12735 case PTRMEM_CST: return TS_CP_PTRMEM;
12736 case BASELINK: return TS_CP_BASELINK;
12737 case STATIC_ASSERT: return TS_CP_STATIC_ASSERT;
12738 case ARGUMENT_PACK_SELECT: return TS_CP_ARGUMENT_PACK_SELECT;
12739 case TRAIT_EXPR: return TS_CP_TRAIT_EXPR;
12740 default: return TS_CP_GENERIC;
12744 /* Build the void_list_node (void_type_node having been created). */
12746 build_void_list_node (void)
12748 tree t = build_tree_list (NULL_TREE, void_type_node);
12753 cp_missing_noreturn_ok_p (tree decl)
12755 /* A missing noreturn is ok for the `main' function. */
12756 return DECL_MAIN_P (decl);
12759 /* Return the COMDAT group into which DECL should be placed. */
12762 cxx_comdat_group (tree decl)
12766 /* Virtual tables, construction virtual tables, and virtual table
12767 tables all go in a single COMDAT group, named after the primary
12769 if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
12770 name = DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl)));
12771 /* For all other DECLs, the COMDAT group is the mangled name of the
12772 declaration itself. */
12775 while (DECL_THUNK_P (decl))
12777 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
12778 into the same section as the target function. In that case
12779 we must return target's name. */
12780 tree target = THUNK_TARGET (decl);
12781 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target)
12782 && DECL_SECTION_NAME (target) != NULL
12783 && DECL_ONE_ONLY (target))
12788 name = DECL_ASSEMBLER_NAME (decl);
12791 return IDENTIFIER_POINTER (name);
12794 #include "gt-cp-decl.h"