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
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"
57 static tree grokparms (cp_parameter_declarator *, tree *);
58 static const char *redeclaration_error_message (tree, tree);
60 static int decl_jump_unsafe (tree);
61 static void require_complete_types_for_parms (tree);
62 static int ambi_op_p (enum tree_code);
63 static int unary_op_p (enum tree_code);
64 static void push_local_name (tree);
65 static tree grok_reference_init (tree, tree, tree, tree *);
66 static tree grokvardecl (tree, tree, const cp_decl_specifier_seq *,
68 static void record_unknown_type (tree, const char *);
69 static tree builtin_function_1 (tree, tree);
70 static tree build_library_fn_1 (tree, enum tree_code, tree);
71 static int member_function_or_else (tree, tree, enum overload_flags);
72 static void bad_specifiers (tree, const char *, int, int, int, int,
74 static void check_for_uninitialized_const_var (tree);
75 static hashval_t typename_hash (const void *);
76 static int typename_compare (const void *, const void *);
77 static tree local_variable_p_walkfn (tree *, int *, void *);
78 static tree record_builtin_java_type (const char *, int);
79 static const char *tag_name (enum tag_types);
80 static tree lookup_and_check_tag (enum tag_types, tree, tag_scope, bool);
81 static int walk_namespaces_r (tree, walk_namespaces_fn, void *);
82 static void maybe_deduce_size_from_array_init (tree, tree);
83 static void layout_var_decl (tree);
84 static void maybe_commonize_var (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 /* States indicating how grokdeclarator() should handle declspecs marked
231 with __attribute__((deprecated)). An object declared as
232 __attribute__((deprecated)) suppresses warnings of uses of other
235 enum deprecated_states {
240 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
243 /* A TREE_LIST of VAR_DECLs. The TREE_PURPOSE is a RECORD_TYPE or
244 UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type. At the
245 time the VAR_DECL was declared, the type was incomplete. */
247 static GTY(()) tree incomplete_vars;
249 /* Returns the kind of template specialization we are currently
250 processing, given that it's declaration contained N_CLASS_SCOPES
251 explicit scope qualifications. */
254 current_tmpl_spec_kind (int n_class_scopes)
256 int n_template_parm_scopes = 0;
257 int seen_specialization_p = 0;
258 int innermost_specialization_p = 0;
259 struct cp_binding_level *b;
261 /* Scan through the template parameter scopes. */
262 for (b = current_binding_level;
263 b->kind == sk_template_parms;
266 /* If we see a specialization scope inside a parameter scope,
267 then something is wrong. That corresponds to a declaration
270 template <class T> template <> ...
272 which is always invalid since [temp.expl.spec] forbids the
273 specialization of a class member template if the enclosing
274 class templates are not explicitly specialized as well. */
275 if (b->explicit_spec_p)
277 if (n_template_parm_scopes == 0)
278 innermost_specialization_p = 1;
280 seen_specialization_p = 1;
282 else if (seen_specialization_p == 1)
283 return tsk_invalid_member_spec;
285 ++n_template_parm_scopes;
288 /* Handle explicit instantiations. */
289 if (processing_explicit_instantiation)
291 if (n_template_parm_scopes != 0)
292 /* We've seen a template parameter list during an explicit
293 instantiation. For example:
295 template <class T> template void f(int);
297 This is erroneous. */
298 return tsk_invalid_expl_inst;
300 return tsk_expl_inst;
303 if (n_template_parm_scopes < n_class_scopes)
304 /* We've not seen enough template headers to match all the
305 specialized classes present. For example:
307 template <class T> void R<T>::S<T>::f(int);
309 This is invalid; there needs to be one set of template
310 parameters for each class. */
311 return tsk_insufficient_parms;
312 else if (n_template_parm_scopes == n_class_scopes)
313 /* We're processing a non-template declaration (even though it may
314 be a member of a template class.) For example:
316 template <class T> void S<T>::f(int);
318 The `class T' maches the `S<T>', leaving no template headers
319 corresponding to the `f'. */
321 else if (n_template_parm_scopes > n_class_scopes + 1)
322 /* We've got too many template headers. For example:
324 template <> template <class T> void f (T);
326 There need to be more enclosing classes. */
327 return tsk_excessive_parms;
329 /* This must be a template. It's of the form:
331 template <class T> template <class U> void S<T>::f(U);
333 This is a specialization if the innermost level was a
334 specialization; otherwise it's just a definition of the
336 return innermost_specialization_p ? tsk_expl_spec : tsk_template;
339 /* Exit the current scope. */
347 /* When a label goes out of scope, check to see if that label was used
348 in a valid manner, and issue any appropriate warnings or errors. */
351 pop_label (tree label, tree old_value)
353 if (!processing_template_decl)
355 if (DECL_INITIAL (label) == NULL_TREE)
359 error ("label %q+D used but not defined", label);
360 #ifdef USE_MAPPED_LOCATION
361 location = input_location; /* FIXME want (input_filename, (line)0) */
363 location.file = input_filename;
366 /* Avoid crashing later. */
367 define_label (location, DECL_NAME (label));
370 warn_for_unused_label (label);
373 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
376 /* At the end of a function, all labels declared within the function
377 go out of scope. BLOCK is the top-level block for the
381 pop_labels_1 (void **slot, void *data)
383 struct named_label_entry *ent = (struct named_label_entry *) *slot;
384 tree block = (tree) data;
386 pop_label (ent->label_decl, NULL_TREE);
388 /* Put the labels into the "variables" of the top-level block,
389 so debugger can see them. */
390 TREE_CHAIN (ent->label_decl) = BLOCK_VARS (block);
391 BLOCK_VARS (block) = ent->label_decl;
393 htab_clear_slot (named_labels, slot);
399 pop_labels (tree block)
403 htab_traverse (named_labels, pop_labels_1, block);
408 /* At the end of a block with local labels, restore the outer definition. */
411 pop_local_label (tree label, tree old_value)
413 struct named_label_entry dummy;
416 pop_label (label, old_value);
418 dummy.label_decl = label;
419 slot = htab_find_slot (named_labels, &dummy, NO_INSERT);
420 htab_clear_slot (named_labels, slot);
423 /* The following two routines are used to interface to Objective-C++.
424 The binding level is purposely treated as an opaque type. */
427 objc_get_current_scope (void)
429 return current_binding_level;
432 /* The following routine is used by the NeXT-style SJLJ exceptions;
433 variables get marked 'volatile' so as to not be clobbered by
434 _setjmp()/_longjmp() calls. All variables in the current scope,
435 as well as parent scopes up to (but not including) ENCLOSING_BLK
436 shall be thusly marked. */
439 objc_mark_locals_volatile (void *enclosing_blk)
441 struct cp_binding_level *scope;
443 for (scope = current_binding_level;
444 scope && scope != enclosing_blk;
445 scope = scope->level_chain)
449 for (decl = scope->names; decl; decl = TREE_CHAIN (decl))
450 objc_volatilize_decl (decl);
452 /* Do not climb up past the current function. */
453 if (scope->kind == sk_function_parms)
458 /* Update data for defined and undefined labels when leaving a scope. */
461 poplevel_named_label_1 (void **slot, void *data)
463 struct named_label_entry *ent = (struct named_label_entry *) *slot;
464 struct cp_binding_level *bl = (struct cp_binding_level *) data;
465 struct cp_binding_level *obl = bl->level_chain;
467 if (ent->binding_level == bl)
471 for (decl = ent->names_in_scope; decl; decl = TREE_CHAIN (decl))
472 if (decl_jump_unsafe (decl))
473 ent->bad_decls = tree_cons (NULL, decl, ent->bad_decls);
475 ent->binding_level = obl;
476 ent->names_in_scope = obl->names;
480 ent->in_try_scope = true;
483 ent->in_catch_scope = true;
486 ent->in_omp_scope = true;
494 struct named_label_use_entry *use;
496 for (use = ent->uses; use ; use = use->next)
497 if (use->binding_level == bl)
499 use->binding_level = obl;
500 use->names_in_scope = obl->names;
501 if (bl->kind == sk_omp)
502 use->in_omp_scope = true;
509 /* Exit a binding level.
510 Pop the level off, and restore the state of the identifier-decl mappings
511 that were in effect when this level was entered.
513 If KEEP == 1, this level had explicit declarations, so
514 and create a "block" (a BLOCK node) for the level
515 to record its declarations and subblocks for symbol table output.
517 If FUNCTIONBODY is nonzero, this level is the body of a function,
518 so create a block as if KEEP were set and also clear out all
521 If REVERSE is nonzero, reverse the order of decls before putting
522 them into the BLOCK. */
525 poplevel (int keep, int reverse, int functionbody)
528 /* The chain of decls was accumulated in reverse order.
529 Put it into forward order, just for cleanliness. */
531 int tmp = functionbody;
532 int real_functionbody;
536 int leaving_for_scope;
539 timevar_push (TV_NAME_LOOKUP);
544 gcc_assert (current_binding_level->kind != sk_class);
546 real_functionbody = (current_binding_level->kind == sk_cleanup
547 ? ((functionbody = 0), tmp) : functionbody);
548 subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
550 gcc_assert (!VEC_length(cp_class_binding,
551 current_binding_level->class_shadowed));
553 /* We used to use KEEP == 2 to indicate that the new block should go
554 at the beginning of the list of blocks at this binding level,
555 rather than the end. This hack is no longer used. */
556 gcc_assert (keep == 0 || keep == 1);
558 if (current_binding_level->keep)
561 /* Any uses of undefined labels, and any defined labels, now operate
562 under constraints of next binding contour. */
563 if (cfun && !functionbody && named_labels)
564 htab_traverse (named_labels, poplevel_named_label_1,
565 current_binding_level);
567 /* Get the decls in the order they were written.
568 Usually current_binding_level->names is in reverse order.
569 But parameter decls were previously put in forward order. */
572 current_binding_level->names
573 = decls = nreverse (current_binding_level->names);
575 decls = current_binding_level->names;
577 /* If there were any declarations or structure tags in that level,
578 or if this level is a function body,
579 create a BLOCK to record them for the life of this function. */
581 if (keep == 1 || functionbody)
582 block = make_node (BLOCK);
583 if (block != NULL_TREE)
585 BLOCK_VARS (block) = decls;
586 BLOCK_SUBBLOCKS (block) = subblocks;
589 /* In each subblock, record that this is its superior. */
591 for (link = subblocks; link; link = BLOCK_CHAIN (link))
592 BLOCK_SUPERCONTEXT (link) = block;
594 /* We still support the old for-scope rules, whereby the variables
595 in a for-init statement were in scope after the for-statement
596 ended. We only use the new rules if flag_new_for_scope is
599 = current_binding_level->kind == sk_for && flag_new_for_scope == 1;
601 /* Before we remove the declarations first check for unused variables. */
602 if (warn_unused_variable
603 && !processing_template_decl)
604 for (decl = getdecls (); decl; decl = TREE_CHAIN (decl))
605 if (TREE_CODE (decl) == VAR_DECL
606 && ! TREE_USED (decl)
607 && ! DECL_IN_SYSTEM_HEADER (decl)
608 && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl))
609 warning (OPT_Wunused_variable, "unused variable %q+D", decl);
611 /* Remove declarations for all the DECLs in this level. */
612 for (link = decls; link; link = TREE_CHAIN (link))
614 if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
617 tree name = DECL_NAME (link);
621 ob = outer_binding (name,
622 IDENTIFIER_BINDING (name),
625 ns_binding = IDENTIFIER_NAMESPACE_VALUE (name);
627 ns_binding = NULL_TREE;
629 if (ob && ob->scope == current_binding_level->level_chain)
630 /* We have something like:
635 and we are leaving the `for' scope. There's no reason to
636 keep the binding of the inner `i' in this case. */
637 pop_binding (name, link);
638 else if ((ob && (TREE_CODE (ob->value) == TYPE_DECL))
639 || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL))
640 /* Here, we have something like:
648 We must pop the for-scope binding so we know what's a
649 type and what isn't. */
650 pop_binding (name, link);
653 /* Mark this VAR_DECL as dead so that we can tell we left it
654 there only for backward compatibility. */
655 DECL_DEAD_FOR_LOCAL (link) = 1;
657 /* Keep track of what should have happened when we
658 popped the binding. */
661 SET_DECL_SHADOWED_FOR_VAR (link, ob->value);
662 DECL_HAS_SHADOWED_FOR_VAR_P (link) = 1;
665 /* Add it to the list of dead variables in the next
666 outermost binding to that we can remove these when we
667 leave that binding. */
668 current_binding_level->level_chain->dead_vars_from_for
669 = tree_cons (NULL_TREE, link,
670 current_binding_level->level_chain->
673 /* Although we don't pop the cxx_binding, we do clear
674 its SCOPE since the scope is going away now. */
675 IDENTIFIER_BINDING (name)->scope
676 = current_binding_level->level_chain;
683 /* Remove the binding. */
686 if (TREE_CODE (decl) == TREE_LIST)
687 decl = TREE_VALUE (decl);
690 if (TREE_CODE (name) == OVERLOAD)
691 name = OVL_FUNCTION (name);
693 gcc_assert (DECL_P (name));
694 pop_binding (DECL_NAME (name), decl);
698 /* Remove declarations for any `for' variables from inner scopes
699 that we kept around. */
700 for (link = current_binding_level->dead_vars_from_for;
701 link; link = TREE_CHAIN (link))
702 pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
704 /* Restore the IDENTIFIER_TYPE_VALUEs. */
705 for (link = current_binding_level->type_shadowed;
706 link; link = TREE_CHAIN (link))
707 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
709 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
710 for (link = current_binding_level->shadowed_labels;
712 link = TREE_CHAIN (link))
713 pop_local_label (TREE_VALUE (link), TREE_PURPOSE (link));
715 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
716 list if a `using' declaration put them there. The debugging
717 back ends won't understand OVERLOAD, so we remove them here.
718 Because the BLOCK_VARS are (temporarily) shared with
719 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
720 popped all the bindings. */
725 for (d = &BLOCK_VARS (block); *d; )
727 if (TREE_CODE (*d) == TREE_LIST)
728 *d = TREE_CHAIN (*d);
730 d = &TREE_CHAIN (*d);
734 /* If the level being exited is the top level of a function,
735 check over all the labels. */
738 /* Since this is the top level block of a function, the vars are
739 the function's parameters. Don't leave them in the BLOCK
740 because they are found in the FUNCTION_DECL instead. */
741 BLOCK_VARS (block) = 0;
745 kind = current_binding_level->kind;
746 if (kind == sk_cleanup)
750 /* If this is a temporary binding created for a cleanup, then we'll
751 have pushed a statement list level. Pop that, create a new
752 BIND_EXPR for the block, and insert it into the stream. */
753 stmt = pop_stmt_list (current_binding_level->statement_list);
754 stmt = c_build_bind_expr (block, stmt);
761 /* The current function is being defined, so its DECL_INITIAL
762 should be error_mark_node. */
763 gcc_assert (DECL_INITIAL (current_function_decl) == error_mark_node);
764 DECL_INITIAL (current_function_decl) = block;
767 current_binding_level->blocks
768 = chainon (current_binding_level->blocks, block);
770 /* If we did not make a block for the level just exited,
771 any blocks made for inner levels
772 (since they cannot be recorded as subblocks in that level)
773 must be carried forward so they will later become subblocks
774 of something else. */
776 current_binding_level->blocks
777 = chainon (current_binding_level->blocks, subblocks);
779 /* Each and every BLOCK node created here in `poplevel' is important
780 (e.g. for proper debugging information) so if we created one
781 earlier, mark it as "used". */
783 TREE_USED (block) = 1;
785 /* All temporary bindings created for cleanups are popped silently. */
786 if (kind == sk_cleanup)
789 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, block);
792 /* Insert BLOCK at the end of the list of subblocks of the
793 current binding level. This is used when a BIND_EXPR is expanded,
794 to handle the BLOCK node inside the BIND_EXPR. */
797 insert_block (tree block)
799 TREE_USED (block) = 1;
800 current_binding_level->blocks
801 = chainon (current_binding_level->blocks, block);
804 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
805 itself, calling F for each. The DATA is passed to F as well. */
808 walk_namespaces_r (tree namespace, walk_namespaces_fn f, void* data)
811 tree current = NAMESPACE_LEVEL (namespace)->namespaces;
813 result |= (*f) (namespace, data);
815 for (; current; current = TREE_CHAIN (current))
816 result |= walk_namespaces_r (current, f, data);
821 /* Walk all the namespaces, calling F for each. The DATA is passed to
825 walk_namespaces (walk_namespaces_fn f, void* data)
827 return walk_namespaces_r (global_namespace, f, data);
830 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
831 DATA is non-NULL, this is the last time we will call
832 wrapup_global_declarations for this NAMESPACE. */
835 wrapup_globals_for_namespace (tree namespace, void* data)
837 struct cp_binding_level *level = NAMESPACE_LEVEL (namespace);
838 VEC(tree,gc) *statics = level->static_decls;
839 tree *vec = VEC_address (tree, statics);
840 int len = VEC_length (tree, statics);
841 int last_time = (data != 0);
845 check_global_declarations (vec, len);
846 emit_debug_global_declarations (vec, len);
850 /* Write out any globals that need to be output. */
851 return wrapup_global_declarations (vec, len);
855 /* In C++, you don't have to write `struct S' to refer to `S'; you
856 can just use `S'. We accomplish this by creating a TYPE_DECL as
857 if the user had written `typedef struct S S'. Create and return
858 the TYPE_DECL for TYPE. */
861 create_implicit_typedef (tree name, tree type)
865 decl = build_decl (TYPE_DECL, name, type);
866 DECL_ARTIFICIAL (decl) = 1;
867 /* There are other implicit type declarations, like the one *within*
868 a class that allows you to write `S::S'. We must distinguish
870 SET_DECL_IMPLICIT_TYPEDEF_P (decl);
871 TYPE_NAME (type) = decl;
876 /* Remember a local name for name-mangling purposes. */
879 push_local_name (tree decl)
884 timevar_push (TV_NAME_LOOKUP);
886 name = DECL_NAME (decl);
888 nelts = VEC_length (tree, local_names);
889 for (i = 0; i < nelts; i++)
891 t = VEC_index (tree, local_names, i);
892 if (DECL_NAME (t) == name)
894 if (!DECL_LANG_SPECIFIC (decl))
895 retrofit_lang_decl (decl);
896 DECL_LANG_SPECIFIC (decl)->decl_flags.u2sel = 1;
897 if (DECL_LANG_SPECIFIC (t))
898 DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
900 DECL_DISCRIMINATOR (decl) = 1;
902 VEC_replace (tree, local_names, i, decl);
903 timevar_pop (TV_NAME_LOOKUP);
908 VEC_safe_push (tree, gc, local_names, decl);
909 timevar_pop (TV_NAME_LOOKUP);
912 /* Subroutine of duplicate_decls: return truthvalue of whether
913 or not types of these decls match.
915 For C++, we must compare the parameter list so that `int' can match
916 `int&' in a parameter position, but `int&' is not confused with
920 decls_match (tree newdecl, tree olddecl)
924 if (newdecl == olddecl)
927 if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
928 /* If the two DECLs are not even the same kind of thing, we're not
929 interested in their types. */
932 if (TREE_CODE (newdecl) == FUNCTION_DECL)
934 tree f1 = TREE_TYPE (newdecl);
935 tree f2 = TREE_TYPE (olddecl);
936 tree p1 = TYPE_ARG_TYPES (f1);
937 tree p2 = TYPE_ARG_TYPES (f2);
939 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
940 && ! (DECL_EXTERN_C_P (newdecl)
941 && DECL_EXTERN_C_P (olddecl)))
944 if (TREE_CODE (f1) != TREE_CODE (f2))
947 if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
949 if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
950 && (DECL_BUILT_IN (olddecl)
951 #ifndef NO_IMPLICIT_EXTERN_C
952 || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
953 || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
957 types_match = self_promoting_args_p (p1);
958 if (p1 == void_list_node)
959 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
961 #ifndef NO_IMPLICIT_EXTERN_C
962 else if (p1 == NULL_TREE
963 && (DECL_EXTERN_C_P (olddecl)
964 && DECL_IN_SYSTEM_HEADER (olddecl)
965 && !DECL_CLASS_SCOPE_P (olddecl))
966 && (DECL_EXTERN_C_P (newdecl)
967 && DECL_IN_SYSTEM_HEADER (newdecl)
968 && !DECL_CLASS_SCOPE_P (newdecl)))
970 types_match = self_promoting_args_p (p2);
971 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
975 types_match = compparms (p1, p2);
980 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
982 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
983 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
986 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
987 DECL_TEMPLATE_PARMS (olddecl)))
990 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
991 types_match = same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)),
992 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl)));
994 types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
995 DECL_TEMPLATE_RESULT (newdecl));
999 /* Need to check scope for variable declaration (VAR_DECL).
1000 For typedef (TYPE_DECL), scope is ignored. */
1001 if (TREE_CODE (newdecl) == VAR_DECL
1002 && CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
1004 Two declarations for an object with C language linkage
1005 with the same name (ignoring the namespace that qualify
1006 it) that appear in different namespace scopes refer to
1008 && !(DECL_EXTERN_C_P (olddecl) && DECL_EXTERN_C_P (newdecl)))
1011 if (TREE_TYPE (newdecl) == error_mark_node)
1012 types_match = TREE_TYPE (olddecl) == error_mark_node;
1013 else if (TREE_TYPE (olddecl) == NULL_TREE)
1014 types_match = TREE_TYPE (newdecl) == NULL_TREE;
1015 else if (TREE_TYPE (newdecl) == NULL_TREE)
1018 types_match = comptypes (TREE_TYPE (newdecl),
1019 TREE_TYPE (olddecl),
1020 COMPARE_REDECLARATION);
1026 /* If NEWDECL is `static' and an `extern' was seen previously,
1027 warn about it. OLDDECL is the previous declaration.
1029 Note that this does not apply to the C++ case of declaring
1030 a variable `extern const' and then later `const'.
1032 Don't complain about built-in functions, since they are beyond
1033 the user's control. */
1036 warn_extern_redeclared_static (tree newdecl, tree olddecl)
1040 if (TREE_CODE (newdecl) == TYPE_DECL
1041 || TREE_CODE (newdecl) == TEMPLATE_DECL
1042 || TREE_CODE (newdecl) == CONST_DECL
1043 || TREE_CODE (newdecl) == NAMESPACE_DECL)
1046 /* Don't get confused by static member functions; that's a different
1048 if (TREE_CODE (newdecl) == FUNCTION_DECL
1049 && DECL_STATIC_FUNCTION_P (newdecl))
1052 /* If the old declaration was `static', or the new one isn't, then
1053 then everything is OK. */
1054 if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
1057 /* It's OK to declare a builtin function as `static'. */
1058 if (TREE_CODE (olddecl) == FUNCTION_DECL
1059 && DECL_ARTIFICIAL (olddecl))
1062 name = DECL_ASSEMBLER_NAME (newdecl);
1063 pedwarn ("%qD was declared %<extern%> and later %<static%>", newdecl);
1064 pedwarn ("previous declaration of %q+D", olddecl);
1067 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1068 function templates. If their exception specifications do not
1069 match, issue a diagnostic. */
1072 check_redeclaration_exception_specification (tree new_decl,
1077 tree new_exceptions;
1078 tree old_exceptions;
1080 new_type = TREE_TYPE (new_decl);
1081 new_exceptions = TYPE_RAISES_EXCEPTIONS (new_type);
1082 old_type = TREE_TYPE (old_decl);
1083 old_exceptions = TYPE_RAISES_EXCEPTIONS (old_type);
1087 If any declaration of a function has an exception-specification,
1088 all declarations, including the definition and an explicit
1089 specialization, of that function shall have an
1090 exception-specification with the same set of type-ids. */
1091 if ((pedantic || ! DECL_IN_SYSTEM_HEADER (old_decl))
1092 && ! DECL_IS_BUILTIN (old_decl)
1094 && !comp_except_specs (new_exceptions, old_exceptions,
1097 error ("declaration of %qF throws different exceptions", new_decl);
1098 error ("from previous declaration %q+F", old_decl);
1102 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1103 && lookup_attribute ("gnu_inline", \
1104 DECL_ATTRIBUTES (fn)))
1106 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1107 If the redeclaration is invalid, a diagnostic is issued, and the
1108 error_mark_node is returned. Otherwise, OLDDECL is returned.
1110 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1113 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1116 duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend)
1118 unsigned olddecl_uid = DECL_UID (olddecl);
1119 int olddecl_friend = 0, types_match = 0, hidden_friend = 0;
1120 int new_defines_function = 0;
1123 if (newdecl == olddecl)
1126 types_match = decls_match (newdecl, olddecl);
1128 /* If either the type of the new decl or the type of the old decl is an
1129 error_mark_node, then that implies that we have already issued an
1130 error (earlier) for some bogus type specification, and in that case,
1131 it is rather pointless to harass the user with yet more error message
1132 about the same declaration, so just pretend the types match here. */
1133 if (TREE_TYPE (newdecl) == error_mark_node
1134 || TREE_TYPE (olddecl) == error_mark_node)
1135 return error_mark_node;
1137 if (DECL_P (olddecl)
1138 && TREE_CODE (newdecl) == FUNCTION_DECL
1139 && TREE_CODE (olddecl) == FUNCTION_DECL
1140 && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
1142 if (DECL_DECLARED_INLINE_P (newdecl)
1143 && DECL_UNINLINABLE (newdecl)
1144 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1145 /* Already warned elsewhere. */;
1146 else if (DECL_DECLARED_INLINE_P (olddecl)
1147 && DECL_UNINLINABLE (olddecl)
1148 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1149 /* Already warned. */;
1150 else if (DECL_DECLARED_INLINE_P (newdecl)
1151 && DECL_UNINLINABLE (olddecl)
1152 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1154 warning (OPT_Wattributes, "function %q+D redeclared as inline",
1156 warning (OPT_Wattributes, "previous declaration of %q+D "
1157 "with attribute noinline", olddecl);
1159 else if (DECL_DECLARED_INLINE_P (olddecl)
1160 && DECL_UNINLINABLE (newdecl)
1161 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1163 warning (OPT_Wattributes, "function %q+D redeclared with "
1164 "attribute noinline", newdecl);
1165 warning (OPT_Wattributes, "previous declaration of %q+D was inline",
1170 /* Check for redeclaration and other discrepancies. */
1171 if (TREE_CODE (olddecl) == FUNCTION_DECL
1172 && DECL_ARTIFICIAL (olddecl))
1174 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl));
1175 if (TREE_CODE (newdecl) != FUNCTION_DECL)
1177 /* Avoid warnings redeclaring built-ins which have not been
1178 explicitly declared. */
1179 if (DECL_ANTICIPATED (olddecl))
1182 /* If you declare a built-in or predefined function name as static,
1183 the old definition is overridden, but optionally warn this was a
1184 bad choice of name. */
1185 if (! TREE_PUBLIC (newdecl))
1187 warning (OPT_Wshadow, "shadowing %s function %q#D",
1188 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
1190 /* Discard the old built-in function. */
1193 /* If the built-in is not ansi, then programs can override
1194 it even globally without an error. */
1195 else if (! DECL_BUILT_IN (olddecl))
1196 warning (0, "library function %q#D redeclared as non-function %q#D",
1200 error ("declaration of %q#D", newdecl);
1201 error ("conflicts with built-in declaration %q#D",
1206 else if (!types_match)
1208 /* Avoid warnings redeclaring built-ins which have not been
1209 explicitly declared. */
1210 if (DECL_ANTICIPATED (olddecl))
1212 /* Deal with fileptr_type_node. FILE type is not known
1213 at the time we create the builtins. */
1216 for (t1 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1217 t2 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1219 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1222 else if (TREE_VALUE (t2) == fileptr_type_node)
1224 tree t = TREE_VALUE (t1);
1226 if (TREE_CODE (t) == POINTER_TYPE
1227 && TYPE_NAME (TREE_TYPE (t))
1228 && DECL_NAME (TYPE_NAME (TREE_TYPE (t)))
1229 == get_identifier ("FILE")
1230 && compparms (TREE_CHAIN (t1), TREE_CHAIN (t2)))
1232 tree oldargs = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1234 TYPE_ARG_TYPES (TREE_TYPE (olddecl))
1235 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1236 types_match = decls_match (newdecl, olddecl);
1238 return duplicate_decls (newdecl, olddecl,
1240 TYPE_ARG_TYPES (TREE_TYPE (olddecl)) = oldargs;
1243 else if (! same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1246 else if ((DECL_EXTERN_C_P (newdecl)
1247 && DECL_EXTERN_C_P (olddecl))
1248 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1249 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1251 /* A near match; override the builtin. */
1253 if (TREE_PUBLIC (newdecl))
1255 warning (0, "new declaration %q#D", newdecl);
1256 warning (0, "ambiguates built-in declaration %q#D",
1260 warning (OPT_Wshadow, "shadowing %s function %q#D",
1261 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
1265 /* Discard the old built-in function. */
1268 /* Replace the old RTL to avoid problems with inlining. */
1269 COPY_DECL_RTL (newdecl, olddecl);
1271 /* Even if the types match, prefer the new declarations type for
1272 built-ins which have not been explicitly declared, for
1273 exception lists, etc... */
1274 else if (DECL_ANTICIPATED (olddecl))
1276 tree type = TREE_TYPE (newdecl);
1277 tree attribs = (*targetm.merge_type_attributes)
1278 (TREE_TYPE (olddecl), type);
1280 type = cp_build_type_attribute_variant (type, attribs);
1281 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = type;
1284 /* If a function is explicitly declared "throw ()", propagate that to
1285 the corresponding builtin. */
1286 if (DECL_BUILT_IN_CLASS (olddecl) == BUILT_IN_NORMAL
1287 && DECL_ANTICIPATED (olddecl)
1288 && TREE_NOTHROW (newdecl)
1289 && !TREE_NOTHROW (olddecl)
1290 && built_in_decls [DECL_FUNCTION_CODE (olddecl)] != NULL_TREE
1291 && built_in_decls [DECL_FUNCTION_CODE (olddecl)] != olddecl
1293 TREE_NOTHROW (built_in_decls [DECL_FUNCTION_CODE (olddecl)]) = 1;
1295 /* Whether or not the builtin can throw exceptions has no
1296 bearing on this declarator. */
1297 TREE_NOTHROW (olddecl) = 0;
1299 if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
1301 /* If a builtin function is redeclared as `static', merge
1302 the declarations, but make the original one static. */
1303 DECL_THIS_STATIC (olddecl) = 1;
1304 TREE_PUBLIC (olddecl) = 0;
1306 /* Make the old declaration consistent with the new one so
1307 that all remnants of the builtin-ness of this function
1308 will be banished. */
1309 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1310 COPY_DECL_RTL (newdecl, olddecl);
1313 else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1315 /* C++ Standard, 3.3, clause 4:
1316 "[Note: a namespace name or a class template name must be unique
1317 in its declarative region (7.3.2, clause 14). ]" */
1318 if (TREE_CODE (olddecl) != NAMESPACE_DECL
1319 && TREE_CODE (newdecl) != NAMESPACE_DECL
1320 && (TREE_CODE (olddecl) != TEMPLATE_DECL
1321 || TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) != TYPE_DECL)
1322 && (TREE_CODE (newdecl) != TEMPLATE_DECL
1323 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != TYPE_DECL))
1325 if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
1326 && TREE_CODE (newdecl) != TYPE_DECL)
1327 || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
1328 && TREE_CODE (olddecl) != TYPE_DECL))
1330 /* We do nothing special here, because C++ does such nasty
1331 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1332 get shadowed, and know that if we need to find a TYPE_DECL
1333 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1334 slot of the identifier. */
1338 if ((TREE_CODE (newdecl) == FUNCTION_DECL
1339 && DECL_FUNCTION_TEMPLATE_P (olddecl))
1340 || (TREE_CODE (olddecl) == FUNCTION_DECL
1341 && DECL_FUNCTION_TEMPLATE_P (newdecl)))
1345 error ("%q#D redeclared as different kind of symbol", newdecl);
1346 if (TREE_CODE (olddecl) == TREE_LIST)
1347 olddecl = TREE_VALUE (olddecl);
1348 error ("previous declaration of %q+#D", olddecl);
1350 return error_mark_node;
1352 else if (!types_match)
1354 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
1355 /* These are certainly not duplicate declarations; they're
1356 from different scopes. */
1359 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1361 /* The name of a class template may not be declared to refer to
1362 any other template, class, function, object, namespace, value,
1363 or type in the same scope. */
1364 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
1365 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1367 error ("declaration of template %q#D", newdecl);
1368 error ("conflicts with previous declaration %q+#D", olddecl);
1370 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
1371 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
1372 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
1373 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
1374 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1375 DECL_TEMPLATE_PARMS (olddecl))
1376 /* Template functions can be disambiguated by
1378 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
1379 TREE_TYPE (TREE_TYPE (olddecl))))
1381 error ("new declaration %q#D", newdecl);
1382 error ("ambiguates old declaration %q+#D", olddecl);
1386 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1388 if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
1390 error ("declaration of C function %q#D conflicts with",
1392 error ("previous declaration %q+#D here", olddecl);
1394 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1395 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1397 error ("new declaration %q#D", newdecl);
1398 error ("ambiguates old declaration %q+#D", olddecl);
1399 return error_mark_node;
1406 error ("conflicting declaration %q#D", newdecl);
1407 error ("%q+D has a previous declaration as %q#D", olddecl, olddecl);
1408 return error_mark_node;
1411 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1412 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
1413 && (!DECL_TEMPLATE_INFO (newdecl)
1414 || (DECL_TI_TEMPLATE (newdecl)
1415 != DECL_TI_TEMPLATE (olddecl))))
1416 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
1417 && (!DECL_TEMPLATE_INFO (olddecl)
1418 || (DECL_TI_TEMPLATE (olddecl)
1419 != DECL_TI_TEMPLATE (newdecl))))))
1420 /* It's OK to have a template specialization and a non-template
1421 with the same type, or to have specializations of two
1422 different templates with the same type. Note that if one is a
1423 specialization, and the other is an instantiation of the same
1424 template, that we do not exit at this point. That situation
1425 can occur if we instantiate a template class, and then
1426 specialize one of its methods. This situation is valid, but
1427 the declarations must be merged in the usual way. */
1429 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1430 && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
1431 && !DECL_USE_TEMPLATE (newdecl))
1432 || (DECL_TEMPLATE_INSTANTIATION (newdecl)
1433 && !DECL_USE_TEMPLATE (olddecl))))
1434 /* One of the declarations is a template instantiation, and the
1435 other is not a template at all. That's OK. */
1437 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1439 /* In [namespace.alias] we have:
1441 In a declarative region, a namespace-alias-definition can be
1442 used to redefine a namespace-alias declared in that declarative
1443 region to refer only to the namespace to which it already
1446 Therefore, if we encounter a second alias directive for the same
1447 alias, we can just ignore the second directive. */
1448 if (DECL_NAMESPACE_ALIAS (newdecl)
1449 && (DECL_NAMESPACE_ALIAS (newdecl)
1450 == DECL_NAMESPACE_ALIAS (olddecl)))
1452 /* [namespace.alias]
1454 A namespace-name or namespace-alias shall not be declared as
1455 the name of any other entity in the same declarative region.
1456 A namespace-name defined at global scope shall not be
1457 declared as the name of any other entity in any global scope
1459 error ("declaration of namespace %qD conflicts with", newdecl);
1460 error ("previous declaration of namespace %q+D here", olddecl);
1461 return error_mark_node;
1465 const char *errmsg = redeclaration_error_message (newdecl, olddecl);
1468 error (errmsg, newdecl);
1469 if (DECL_NAME (olddecl) != NULL_TREE)
1470 error ((DECL_INITIAL (olddecl) && namespace_bindings_p ())
1471 ? "%q+#D previously defined here"
1472 : "%q+#D previously declared here", olddecl);
1473 return error_mark_node;
1475 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1476 && DECL_INITIAL (olddecl) != NULL_TREE
1477 && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
1478 && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
1480 /* Prototype decl follows defn w/o prototype. */
1481 warning (0, "prototype for %q+#D", newdecl);
1482 warning (0, "%Jfollows non-prototype definition here", olddecl);
1484 else if ((TREE_CODE (olddecl) == FUNCTION_DECL
1485 || TREE_CODE (olddecl) == VAR_DECL)
1486 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
1489 If two declarations of the same function or object
1490 specify different linkage-specifications ..., the program
1491 is ill-formed.... Except for functions with C++ linkage,
1492 a function declaration without a linkage specification
1493 shall not precede the first linkage specification for
1494 that function. A function can be declared without a
1495 linkage specification after an explicit linkage
1496 specification has been seen; the linkage explicitly
1497 specified in the earlier declaration is not affected by
1498 such a function declaration.
1500 DR 563 raises the question why the restrictions on
1501 functions should not also apply to objects. Older
1502 versions of G++ silently ignore the linkage-specification
1510 which is clearly wrong. Therefore, we now treat objects
1512 if (current_lang_depth () == 0)
1514 /* There is no explicit linkage-specification, so we use
1515 the linkage from the previous declaration. */
1516 if (!DECL_LANG_SPECIFIC (newdecl))
1517 retrofit_lang_decl (newdecl);
1518 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1522 error ("previous declaration of %q+#D with %qL linkage",
1523 olddecl, DECL_LANGUAGE (olddecl));
1524 error ("conflicts with new declaration with %qL linkage",
1525 DECL_LANGUAGE (newdecl));
1529 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
1531 else if (TREE_CODE (olddecl) == FUNCTION_DECL)
1533 tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1534 tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1537 if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
1538 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
1540 for (; t1 && t1 != void_list_node;
1541 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
1542 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
1544 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
1547 pedwarn ("default argument given for parameter %d of %q#D",
1549 pedwarn ("after previous specification in %q+#D", olddecl);
1553 error ("default argument given for parameter %d of %q#D",
1555 error ("after previous specification in %q+#D",
1560 if (DECL_DECLARED_INLINE_P (newdecl)
1561 && ! DECL_DECLARED_INLINE_P (olddecl)
1562 && TREE_ADDRESSABLE (olddecl) && warn_inline)
1564 warning (0, "%q#D was used before it was declared inline", newdecl);
1565 warning (0, "%Jprevious non-inline declaration here", olddecl);
1570 /* Do not merge an implicit typedef with an explicit one. In:
1574 typedef class A A __attribute__ ((foo));
1576 the attribute should apply only to the typedef. */
1577 if (TREE_CODE (olddecl) == TYPE_DECL
1578 && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
1579 || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
1582 /* If new decl is `static' and an `extern' was seen previously,
1584 warn_extern_redeclared_static (newdecl, olddecl);
1586 /* We have committed to returning 1 at this point. */
1587 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1589 /* Now that functions must hold information normally held
1590 by field decls, there is extra work to do so that
1591 declaration information does not get destroyed during
1593 if (DECL_VINDEX (olddecl))
1594 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
1595 if (DECL_CONTEXT (olddecl))
1596 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1597 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
1598 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1599 DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
1600 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
1601 DECL_INVALID_OVERRIDER_P (newdecl) |= DECL_INVALID_OVERRIDER_P (olddecl);
1602 DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
1603 if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
1604 SET_OVERLOADED_OPERATOR_CODE
1605 (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
1606 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
1608 /* Optionally warn about more than one declaration for the same
1609 name, but don't warn about a function declaration followed by a
1611 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
1612 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
1613 /* Don't warn about extern decl followed by definition. */
1614 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
1615 /* Don't warn about friends, let add_friend take care of it. */
1616 && ! (newdecl_is_friend || DECL_FRIEND_P (olddecl)))
1618 warning (OPT_Wredundant_decls, "redundant redeclaration of %qD in same scope", newdecl);
1619 warning (OPT_Wredundant_decls, "previous declaration of %q+D", olddecl);
1623 /* Deal with C++: must preserve virtual function table size. */
1624 if (TREE_CODE (olddecl) == TYPE_DECL)
1626 tree newtype = TREE_TYPE (newdecl);
1627 tree oldtype = TREE_TYPE (olddecl);
1629 if (newtype != error_mark_node && oldtype != error_mark_node
1630 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
1631 CLASSTYPE_FRIEND_CLASSES (newtype)
1632 = CLASSTYPE_FRIEND_CLASSES (oldtype);
1634 DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
1637 /* Copy all the DECL_... slots specified in the new decl
1638 except for any that we copy here from the old type. */
1639 DECL_ATTRIBUTES (newdecl)
1640 = (*targetm.merge_decl_attributes) (olddecl, newdecl);
1642 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1646 old_result = DECL_TEMPLATE_RESULT (olddecl);
1647 new_result = DECL_TEMPLATE_RESULT (newdecl);
1648 TREE_TYPE (olddecl) = TREE_TYPE (old_result);
1649 DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
1650 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
1651 DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
1653 DECL_ATTRIBUTES (old_result)
1654 = (*targetm.merge_decl_attributes) (old_result, new_result);
1656 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1658 if (GNU_INLINE_P (old_result) != GNU_INLINE_P (new_result)
1659 && DECL_INITIAL (new_result))
1661 if (DECL_INITIAL (old_result))
1663 DECL_INLINE (old_result) = 0;
1664 DECL_UNINLINABLE (old_result) = 1;
1668 DECL_INLINE (old_result) = DECL_INLINE (new_result);
1669 DECL_UNINLINABLE (old_result) = DECL_UNINLINABLE (new_result);
1671 DECL_EXTERNAL (old_result) = DECL_EXTERNAL (new_result);
1672 DECL_NOT_REALLY_EXTERN (old_result)
1673 = DECL_NOT_REALLY_EXTERN (new_result);
1674 DECL_INTERFACE_KNOWN (old_result)
1675 = DECL_INTERFACE_KNOWN (new_result);
1676 DECL_DECLARED_INLINE_P (old_result)
1677 = DECL_DECLARED_INLINE_P (new_result);
1681 DECL_INLINE (old_result)
1682 |= DECL_INLINE (new_result);
1683 DECL_DECLARED_INLINE_P (old_result)
1684 |= DECL_DECLARED_INLINE_P (new_result);
1685 check_redeclaration_exception_specification (newdecl, olddecl);
1689 /* If the new declaration is a definition, update the file and
1690 line information on the declaration, and also make
1691 the old declaration the same definition. */
1692 if (DECL_INITIAL (new_result) != NULL_TREE)
1694 DECL_SOURCE_LOCATION (olddecl)
1695 = DECL_SOURCE_LOCATION (old_result)
1696 = DECL_SOURCE_LOCATION (newdecl);
1697 DECL_INITIAL (old_result) = DECL_INITIAL (new_result);
1698 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1699 DECL_ARGUMENTS (old_result)
1700 = DECL_ARGUMENTS (new_result);
1708 /* Automatically handles default parameters. */
1709 tree oldtype = TREE_TYPE (olddecl);
1712 /* Merge the data types specified in the two decls. */
1713 newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1715 /* If merge_types produces a non-typedef type, just use the old type. */
1716 if (TREE_CODE (newdecl) == TYPE_DECL
1717 && newtype == DECL_ORIGINAL_TYPE (newdecl))
1720 if (TREE_CODE (newdecl) == VAR_DECL)
1722 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
1723 DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
1724 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl)
1725 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl);
1726 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl)
1727 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl);
1729 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
1730 if (DECL_LANG_SPECIFIC (olddecl)
1731 && CP_DECL_THREADPRIVATE_P (olddecl))
1733 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
1734 if (!DECL_LANG_SPECIFIC (newdecl))
1735 retrofit_lang_decl (newdecl);
1737 DECL_TLS_MODEL (newdecl) = DECL_TLS_MODEL (olddecl);
1738 CP_DECL_THREADPRIVATE_P (newdecl) = 1;
1742 /* Do this after calling `merge_types' so that default
1743 parameters don't confuse us. */
1744 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1745 check_redeclaration_exception_specification (newdecl, olddecl);
1746 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
1748 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1749 check_default_args (newdecl);
1751 /* Lay the type out, unless already done. */
1752 if (! same_type_p (newtype, oldtype)
1753 && TREE_TYPE (newdecl) != error_mark_node
1754 && !(processing_template_decl && uses_template_parms (newdecl)))
1755 layout_type (TREE_TYPE (newdecl));
1757 if ((TREE_CODE (newdecl) == VAR_DECL
1758 || TREE_CODE (newdecl) == PARM_DECL
1759 || TREE_CODE (newdecl) == RESULT_DECL
1760 || TREE_CODE (newdecl) == FIELD_DECL
1761 || TREE_CODE (newdecl) == TYPE_DECL)
1762 && !(processing_template_decl && uses_template_parms (newdecl)))
1763 layout_decl (newdecl, 0);
1765 /* Merge the type qualifiers. */
1766 if (TREE_READONLY (newdecl))
1767 TREE_READONLY (olddecl) = 1;
1768 if (TREE_THIS_VOLATILE (newdecl))
1769 TREE_THIS_VOLATILE (olddecl) = 1;
1770 if (TREE_NOTHROW (newdecl))
1771 TREE_NOTHROW (olddecl) = 1;
1773 /* Merge deprecatedness. */
1774 if (TREE_DEPRECATED (newdecl))
1775 TREE_DEPRECATED (olddecl) = 1;
1777 /* Merge the initialization information. */
1778 if (DECL_INITIAL (newdecl) == NULL_TREE
1779 && DECL_INITIAL (olddecl) != NULL_TREE)
1781 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1782 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
1783 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
1784 && DECL_LANG_SPECIFIC (newdecl)
1785 && DECL_LANG_SPECIFIC (olddecl))
1787 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1788 DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
1792 /* Merge the section attribute.
1793 We want to issue an error if the sections conflict but that must be
1794 done later in decl_attributes since we are called before attributes
1796 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1797 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1799 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1801 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1802 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1803 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1804 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1805 TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
1806 TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl);
1807 DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
1808 DECL_IS_OPERATOR_NEW (newdecl) |= DECL_IS_OPERATOR_NEW (olddecl);
1809 DECL_IS_PURE (newdecl) |= DECL_IS_PURE (olddecl);
1810 /* Keep the old RTL. */
1811 COPY_DECL_RTL (olddecl, newdecl);
1813 else if (TREE_CODE (newdecl) == VAR_DECL
1814 && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
1816 /* Keep the old RTL. We cannot keep the old RTL if the old
1817 declaration was for an incomplete object and the new
1818 declaration is not since many attributes of the RTL will
1820 COPY_DECL_RTL (olddecl, newdecl);
1823 /* If cannot merge, then use the new type and qualifiers,
1824 and don't preserve the old rtl. */
1827 /* Clean out any memory we had of the old declaration. */
1828 tree oldstatic = value_member (olddecl, static_aggregates);
1830 TREE_VALUE (oldstatic) = error_mark_node;
1832 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1833 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1834 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1835 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1838 /* Merge the storage class information. */
1839 merge_weak (newdecl, olddecl);
1841 DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
1842 DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
1843 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1844 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
1845 if (! DECL_EXTERNAL (olddecl))
1846 DECL_EXTERNAL (newdecl) = 0;
1848 new_template = NULL_TREE;
1849 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
1851 bool new_redefines_gnu_inline = false;
1853 if (new_defines_function
1854 && ((DECL_INTERFACE_KNOWN (olddecl)
1855 && TREE_CODE (olddecl) == FUNCTION_DECL)
1856 || (TREE_CODE (olddecl) == TEMPLATE_DECL
1857 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
1858 == FUNCTION_DECL))))
1862 if (TREE_CODE (fn) == TEMPLATE_DECL)
1863 fn = DECL_TEMPLATE_RESULT (olddecl);
1865 new_redefines_gnu_inline = GNU_INLINE_P (fn) && DECL_INITIAL (fn);
1868 if (!new_redefines_gnu_inline)
1870 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
1871 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
1872 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
1874 DECL_TEMPLATE_INSTANTIATED (newdecl)
1875 |= DECL_TEMPLATE_INSTANTIATED (olddecl);
1877 /* If the OLDDECL is an instantiation and/or specialization,
1878 then the NEWDECL must be too. But, it may not yet be marked
1879 as such if the caller has created NEWDECL, but has not yet
1880 figured out that it is a redeclaration. */
1881 if (!DECL_USE_TEMPLATE (newdecl))
1882 DECL_USE_TEMPLATE (newdecl) = DECL_USE_TEMPLATE (olddecl);
1884 /* Don't really know how much of the language-specific
1885 values we should copy from old to new. */
1886 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
1887 DECL_LANG_SPECIFIC (newdecl)->decl_flags.u2 =
1888 DECL_LANG_SPECIFIC (olddecl)->decl_flags.u2;
1889 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
1890 DECL_REPO_AVAILABLE_P (newdecl) = DECL_REPO_AVAILABLE_P (olddecl);
1891 if (DECL_TEMPLATE_INFO (newdecl))
1892 new_template = DECL_TI_TEMPLATE (newdecl);
1893 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
1894 DECL_INITIALIZED_IN_CLASS_P (newdecl)
1895 |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
1896 olddecl_friend = DECL_FRIEND_P (olddecl);
1897 hidden_friend = (DECL_ANTICIPATED (olddecl)
1898 && DECL_HIDDEN_FRIEND_P (olddecl)
1899 && newdecl_is_friend);
1901 /* Only functions have DECL_BEFRIENDING_CLASSES. */
1902 if (TREE_CODE (newdecl) == FUNCTION_DECL
1903 || DECL_FUNCTION_TEMPLATE_P (newdecl))
1905 DECL_BEFRIENDING_CLASSES (newdecl)
1906 = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
1907 DECL_BEFRIENDING_CLASSES (olddecl));
1908 /* DECL_THUNKS is only valid for virtual functions,
1909 otherwise it is a DECL_FRIEND_CONTEXT. */
1910 if (DECL_VIRTUAL_P (newdecl))
1911 DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl);
1915 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1917 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
1918 && !DECL_TEMPLATE_INSTANTIATION (newdecl))
1920 /* If newdecl is not a specialization, then it is not a
1921 template-related function at all. And that means that we
1922 should have exited above, returning 0. */
1923 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl));
1925 if (TREE_USED (olddecl))
1926 /* From [temp.expl.spec]:
1928 If a template, a member template or the member of a class
1929 template is explicitly specialized then that
1930 specialization shall be declared before the first use of
1931 that specialization that would cause an implicit
1932 instantiation to take place, in every translation unit in
1933 which such a use occurs. */
1934 error ("explicit specialization of %qD after first use",
1937 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
1939 /* Don't propagate visibility from the template to the
1940 specialization here. We'll do that in determine_visibility if
1942 DECL_VISIBILITY_SPECIFIED (olddecl) = 0;
1944 /* [temp.expl.spec/14] We don't inline explicit specialization
1945 just because the primary template says so. */
1947 else if (new_defines_function && DECL_INITIAL (olddecl))
1949 /* C++ is always in in unit-at-a-time mode, so we never
1950 inline re-defined extern inline functions. */
1951 DECL_INLINE (newdecl) = 0;
1952 DECL_UNINLINABLE (newdecl) = 1;
1956 if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
1957 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
1959 DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
1961 /* If either decl says `inline', this fn is inline, unless
1962 its definition was passed already. */
1963 if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
1964 DECL_INLINE (olddecl) = 1;
1965 DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
1967 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
1968 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
1970 DECL_DISREGARD_INLINE_LIMITS (newdecl)
1971 = DECL_DISREGARD_INLINE_LIMITS (olddecl)
1972 = (DECL_DISREGARD_INLINE_LIMITS (newdecl)
1973 || DECL_DISREGARD_INLINE_LIMITS (olddecl));
1976 /* Preserve abstractness on cloned [cd]tors. */
1977 DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
1981 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1982 COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
1983 COPY_DECL_RTL (newdecl, olddecl);
1985 if (! types_match || new_defines_function)
1987 /* These need to be copied so that the names are available.
1988 Note that if the types do match, we'll preserve inline
1989 info and other bits, but if not, we won't. */
1990 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
1991 DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
1993 if (new_defines_function)
1994 /* If defining a function declared with other language
1995 linkage, use the previously declared language linkage. */
1996 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1997 else if (types_match)
1999 /* If redeclaring a builtin function, and not a definition,
2000 it stays built in. */
2001 if (DECL_BUILT_IN (olddecl))
2003 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
2004 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
2005 /* If we're keeping the built-in definition, keep the rtl,
2006 regardless of declaration matches. */
2007 COPY_DECL_RTL (olddecl, newdecl);
2010 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
2011 /* Don't clear out the arguments if we're redefining a function. */
2012 if (DECL_ARGUMENTS (olddecl))
2013 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
2016 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
2017 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
2019 /* Now preserve various other info from the definition. */
2020 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
2021 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
2022 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
2023 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
2025 /* Warn about conflicting visibility specifications. */
2026 if (DECL_VISIBILITY_SPECIFIED (olddecl)
2027 && DECL_VISIBILITY_SPECIFIED (newdecl)
2028 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
2030 warning (OPT_Wattributes, "%q+D: visibility attribute ignored "
2031 "because it", newdecl);
2032 warning (OPT_Wattributes, "%Jconflicts with previous "
2033 "declaration here", olddecl);
2035 /* Choose the declaration which specified visibility. */
2036 if (DECL_VISIBILITY_SPECIFIED (olddecl))
2038 DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
2039 DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
2041 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2042 so keep this behavior. */
2043 if (TREE_CODE (newdecl) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (newdecl))
2045 SET_DECL_INIT_PRIORITY (olddecl, DECL_INIT_PRIORITY (newdecl));
2046 DECL_HAS_INIT_PRIORITY_P (olddecl) = 1;
2049 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2050 with that from NEWDECL below. */
2051 if (DECL_LANG_SPECIFIC (olddecl))
2053 gcc_assert (DECL_LANG_SPECIFIC (olddecl)
2054 != DECL_LANG_SPECIFIC (newdecl));
2055 ggc_free (DECL_LANG_SPECIFIC (olddecl));
2058 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2062 function_size = sizeof (struct tree_decl_common);
2064 memcpy ((char *) olddecl + sizeof (struct tree_common),
2065 (char *) newdecl + sizeof (struct tree_common),
2066 function_size - sizeof (struct tree_common));
2068 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2069 (char *) newdecl + sizeof (struct tree_decl_common),
2070 sizeof (struct tree_function_decl) - sizeof (struct tree_decl_common));
2072 /* If newdecl is a template instantiation, it is possible that
2073 the following sequence of events has occurred:
2075 o A friend function was declared in a class template. The
2076 class template was instantiated.
2078 o The instantiation of the friend declaration was
2079 recorded on the instantiation list, and is newdecl.
2081 o Later, however, instantiate_class_template called pushdecl
2082 on the newdecl to perform name injection. But, pushdecl in
2083 turn called duplicate_decls when it discovered that another
2084 declaration of a global function with the same name already
2087 o Here, in duplicate_decls, we decided to clobber newdecl.
2089 If we're going to do that, we'd better make sure that
2090 olddecl, and not newdecl, is on the list of
2091 instantiations so that if we try to do the instantiation
2092 again we won't get the clobbered declaration. */
2093 reregister_specialization (newdecl,
2099 size_t size = tree_code_size (TREE_CODE (olddecl));
2100 memcpy ((char *) olddecl + sizeof (struct tree_common),
2101 (char *) newdecl + sizeof (struct tree_common),
2102 sizeof (struct tree_decl_common) - sizeof (struct tree_common));
2103 switch (TREE_CODE (olddecl))
2113 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2114 (char *) newdecl + sizeof (struct tree_decl_common),
2115 size - sizeof (struct tree_decl_common)
2116 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2120 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2121 (char *) newdecl + sizeof (struct tree_decl_common),
2122 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common)
2123 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2127 DECL_UID (olddecl) = olddecl_uid;
2129 DECL_FRIEND_P (olddecl) = 1;
2132 DECL_ANTICIPATED (olddecl) = 1;
2133 DECL_HIDDEN_FRIEND_P (olddecl) = 1;
2136 /* NEWDECL contains the merged attribute lists.
2137 Update OLDDECL to be the same. */
2138 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
2140 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2141 so that encode_section_info has a chance to look at the new decl
2142 flags and attributes. */
2143 if (DECL_RTL_SET_P (olddecl)
2144 && (TREE_CODE (olddecl) == FUNCTION_DECL
2145 || (TREE_CODE (olddecl) == VAR_DECL
2146 && TREE_STATIC (olddecl))))
2147 make_decl_rtl (olddecl);
2149 /* The NEWDECL will no longer be needed. Because every out-of-class
2150 declaration of a member results in a call to duplicate_decls,
2151 freeing these nodes represents in a significant savings. */
2157 /* Return zero if the declaration NEWDECL is valid
2158 when the declaration OLDDECL (assumed to be for the same name)
2159 has already been seen.
2160 Otherwise return an error message format string with a %s
2161 where the identifier should go. */
2164 redeclaration_error_message (tree newdecl, tree olddecl)
2166 if (TREE_CODE (newdecl) == TYPE_DECL)
2168 /* Because C++ can put things into name space for free,
2169 constructs like "typedef struct foo { ... } foo"
2170 would look like an erroneous redeclaration. */
2171 if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
2174 return "redefinition of %q#D";
2176 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
2178 /* If this is a pure function, its olddecl will actually be
2179 the original initialization to `0' (which we force to call
2180 abort()). Don't complain about redefinition in this case. */
2181 if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl)
2182 && DECL_INITIAL (olddecl) == NULL_TREE)
2185 /* If both functions come from different namespaces, this is not
2186 a redeclaration - this is a conflict with a used function. */
2187 if (DECL_NAMESPACE_SCOPE_P (olddecl)
2188 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl)
2189 && ! decls_match (olddecl, newdecl))
2190 return "%qD conflicts with used function";
2192 /* We'll complain about linkage mismatches in
2193 warn_extern_redeclared_static. */
2195 /* Defining the same name twice is no good. */
2196 if (DECL_INITIAL (olddecl) != NULL_TREE
2197 && DECL_INITIAL (newdecl) != NULL_TREE)
2199 if (DECL_NAME (olddecl) == NULL_TREE)
2200 return "%q#D not declared in class";
2201 else if (!GNU_INLINE_P (olddecl)
2202 || GNU_INLINE_P (newdecl))
2203 return "redefinition of %q#D";
2206 if (DECL_DECLARED_INLINE_P (olddecl) && DECL_DECLARED_INLINE_P (newdecl))
2208 bool olda = GNU_INLINE_P (olddecl);
2209 bool newa = GNU_INLINE_P (newdecl);
2214 return "%q+D redeclared inline with %<gnu_inline%> attribute";
2216 return "%q+D redeclared inline without %<gnu_inline%> attribute";
2222 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2226 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2228 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl))
2229 && COMPLETE_TYPE_P (TREE_TYPE (olddecl)))
2230 return "redefinition of %q#D";
2234 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL
2235 || (DECL_TEMPLATE_RESULT (newdecl)
2236 == DECL_TEMPLATE_RESULT (olddecl)))
2239 nt = DECL_TEMPLATE_RESULT (newdecl);
2240 if (DECL_TEMPLATE_INFO (nt))
2241 nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt));
2242 ot = DECL_TEMPLATE_RESULT (olddecl);
2243 if (DECL_TEMPLATE_INFO (ot))
2244 ot = DECL_TEMPLATE_RESULT (template_for_substitution (ot));
2245 if (DECL_INITIAL (nt) && DECL_INITIAL (ot)
2246 && (!GNU_INLINE_P (ot) || GNU_INLINE_P (nt)))
2247 return "redefinition of %q#D";
2249 if (DECL_DECLARED_INLINE_P (ot) && DECL_DECLARED_INLINE_P (nt))
2251 bool olda = GNU_INLINE_P (ot);
2252 bool newa = GNU_INLINE_P (nt);
2257 return "%q+D redeclared inline with %<gnu_inline%> attribute";
2259 return "%q+D redeclared inline without %<gnu_inline%> attribute";
2263 /* Core issue #226 (C++0x):
2265 If a friend function template declaration specifies a
2266 default template-argument, that declaration shall be a
2267 definition and shall be the only declaration of the
2268 function template in the translation unit. */
2269 if ((cxx_dialect != cxx98)
2270 && TREE_CODE (ot) == FUNCTION_DECL && DECL_FRIEND_P (ot)
2271 && !check_default_tmpl_args (nt, DECL_TEMPLATE_PARMS (newdecl),
2272 /*is_primary=*/1, /*is_partial=*/0,
2273 /*is_friend_decl=*/2))
2274 return "redeclaration of friend %q#D may not have default template arguments";
2278 else if (TREE_CODE (newdecl) == VAR_DECL
2279 && DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl)
2280 && (! DECL_LANG_SPECIFIC (olddecl)
2281 || ! CP_DECL_THREADPRIVATE_P (olddecl)
2282 || DECL_THREAD_LOCAL_P (newdecl)))
2284 /* Only variables can be thread-local, and all declarations must
2285 agree on this property. */
2286 if (DECL_THREAD_LOCAL_P (newdecl))
2287 return "thread-local declaration of %q#D follows "
2288 "non-thread-local declaration";
2290 return "non-thread-local declaration of %q#D follows "
2291 "thread-local declaration";
2293 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
2295 /* The objects have been declared at namespace scope. If either
2296 is a member of an anonymous union, then this is an invalid
2297 redeclaration. For example:
2303 if ((TREE_CODE (newdecl) == VAR_DECL && DECL_ANON_UNION_VAR_P (newdecl))
2304 || (TREE_CODE (olddecl) == VAR_DECL && DECL_ANON_UNION_VAR_P (olddecl)))
2305 return "redeclaration of %q#D";
2306 /* If at least one declaration is a reference, there is no
2307 conflict. For example:
2313 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2315 /* Reject two definitions. */
2316 return "redefinition of %q#D";
2320 /* Objects declared with block scope: */
2321 /* Reject two definitions, and reject a definition
2322 together with an external reference. */
2323 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
2324 return "redeclaration of %q#D";
2329 /* Hash and equality functions for the named_label table. */
2332 named_label_entry_hash (const void *data)
2334 const struct named_label_entry *ent = (const struct named_label_entry *) data;
2335 return DECL_UID (ent->label_decl);
2339 named_label_entry_eq (const void *a, const void *b)
2341 const struct named_label_entry *ent_a = (const struct named_label_entry *) a;
2342 const struct named_label_entry *ent_b = (const struct named_label_entry *) b;
2343 return ent_a->label_decl == ent_b->label_decl;
2346 /* Create a new label, named ID. */
2349 make_label_decl (tree id, int local_p)
2351 struct named_label_entry *ent;
2355 decl = build_decl (LABEL_DECL, id, void_type_node);
2357 DECL_CONTEXT (decl) = current_function_decl;
2358 DECL_MODE (decl) = VOIDmode;
2359 C_DECLARED_LABEL_FLAG (decl) = local_p;
2361 /* Say where one reference is to the label, for the sake of the
2362 error if it is not defined. */
2363 DECL_SOURCE_LOCATION (decl) = input_location;
2365 /* Record the fact that this identifier is bound to this label. */
2366 SET_IDENTIFIER_LABEL_VALUE (id, decl);
2368 /* Create the label htab for the function on demand. */
2370 named_labels = htab_create_ggc (13, named_label_entry_hash,
2371 named_label_entry_eq, NULL);
2373 /* Record this label on the list of labels used in this function.
2374 We do this before calling make_label_decl so that we get the
2375 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2376 ent = GGC_CNEW (struct named_label_entry);
2377 ent->label_decl = decl;
2379 slot = htab_find_slot (named_labels, ent, INSERT);
2380 gcc_assert (*slot == NULL);
2386 /* Look for a label named ID in the current function. If one cannot
2387 be found, create one. (We keep track of used, but undefined,
2388 labels, and complain about them at the end of a function.) */
2391 lookup_label (tree id)
2395 timevar_push (TV_NAME_LOOKUP);
2396 /* You can't use labels at global scope. */
2397 if (current_function_decl == NULL_TREE)
2399 error ("label %qE referenced outside of any function", id);
2400 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2403 /* See if we've already got this label. */
2404 decl = IDENTIFIER_LABEL_VALUE (id);
2405 if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
2406 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2408 decl = make_label_decl (id, /*local_p=*/0);
2409 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2412 /* Declare a local label named ID. */
2415 declare_local_label (tree id)
2419 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2420 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2421 shadow = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
2422 current_binding_level->shadowed_labels);
2423 current_binding_level->shadowed_labels = shadow;
2425 decl = make_label_decl (id, /*local_p=*/1);
2426 TREE_VALUE (shadow) = decl;
2431 /* Returns nonzero if it is ill-formed to jump past the declaration of
2432 DECL. Returns 2 if it's also a real problem. */
2435 decl_jump_unsafe (tree decl)
2437 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl)
2438 || TREE_TYPE (decl) == error_mark_node)
2441 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
2442 || DECL_NONTRIVIALLY_INITIALIZED_P (decl))
2445 if (pod_type_p (TREE_TYPE (decl)))
2448 /* The POD stuff is just pedantry; why should it matter if the class
2449 contains a field of pointer to member type? */
2453 /* A subroutine of check_previous_goto_1 to identify a branch to the user. */
2456 identify_goto (tree decl, const location_t *locus)
2459 pedwarn ("jump to label %qD", decl);
2461 pedwarn ("jump to case label");
2463 pedwarn ("%H from here", locus);
2466 /* Check that a single previously seen jump to a newly defined label
2467 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2468 the jump context; NAMES are the names in scope in LEVEL at the jump
2469 context; LOCUS is the source position of the jump or 0. Returns
2470 true if all is well. */
2473 check_previous_goto_1 (tree decl, struct cp_binding_level* level, tree names,
2474 bool exited_omp, const location_t *locus)
2476 struct cp_binding_level *b;
2477 bool identified = false, saw_eh = false, saw_omp = false;
2481 identify_goto (decl, locus);
2482 error (" exits OpenMP structured block");
2483 identified = saw_omp = true;
2486 for (b = current_binding_level; b ; b = b->level_chain)
2488 tree new_decls, old_decls = (b == level ? names : NULL_TREE);
2490 for (new_decls = b->names; new_decls != old_decls;
2491 new_decls = TREE_CHAIN (new_decls))
2493 int problem = decl_jump_unsafe (new_decls);
2499 identify_goto (decl, locus);
2503 error (" crosses initialization of %q+#D", new_decls);
2505 pedwarn (" enters scope of non-POD %q+#D", new_decls);
2510 if ((b->kind == sk_try || b->kind == sk_catch) && !saw_eh)
2514 identify_goto (decl, locus);
2517 if (b->kind == sk_try)
2518 error (" enters try block");
2520 error (" enters catch block");
2523 if (b->kind == sk_omp && !saw_omp)
2527 identify_goto (decl, locus);
2530 error (" enters OpenMP structured block");
2539 check_previous_goto (tree decl, struct named_label_use_entry *use)
2541 check_previous_goto_1 (decl, use->binding_level,
2542 use->names_in_scope, use->in_omp_scope,
2543 &use->o_goto_locus);
2547 check_switch_goto (struct cp_binding_level* level)
2549 return check_previous_goto_1 (NULL_TREE, level, level->names, false, NULL);
2552 /* Check that a new jump to a label DECL is OK. Called by
2553 finish_goto_stmt. */
2556 check_goto (tree decl)
2558 struct named_label_entry *ent, dummy;
2559 bool saw_catch = false, identified = false;
2562 /* We can't know where a computed goto is jumping.
2563 So we assume that it's OK. */
2564 if (TREE_CODE (decl) != LABEL_DECL)
2567 /* We didn't record any information about this label when we created it,
2568 and there's not much point since it's trivial to analyze as a return. */
2569 if (decl == cdtor_label)
2572 dummy.label_decl = decl;
2573 ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2574 gcc_assert (ent != NULL);
2576 /* If the label hasn't been defined yet, defer checking. */
2577 if (! DECL_INITIAL (decl))
2579 struct named_label_use_entry *new_use;
2581 /* Don't bother creating another use if the last goto had the
2582 same data, and will therefore create the same set of errors. */
2584 && ent->uses->names_in_scope == current_binding_level->names)
2587 new_use = GGC_NEW (struct named_label_use_entry);
2588 new_use->binding_level = current_binding_level;
2589 new_use->names_in_scope = current_binding_level->names;
2590 new_use->o_goto_locus = input_location;
2591 new_use->in_omp_scope = false;
2593 new_use->next = ent->uses;
2594 ent->uses = new_use;
2598 if (ent->in_try_scope || ent->in_catch_scope
2599 || ent->in_omp_scope || ent->bad_decls)
2601 pedwarn ("jump to label %q+D", decl);
2602 pedwarn (" from here");
2606 for (bad = ent->bad_decls; bad; bad = TREE_CHAIN (bad))
2608 tree b = TREE_VALUE (bad);
2609 int u = decl_jump_unsafe (b);
2611 if (u > 1 && DECL_ARTIFICIAL (b))
2613 /* Can't skip init of __exception_info. */
2614 error ("%J enters catch block", b);
2618 error (" skips initialization of %q+#D", b);
2620 pedwarn (" enters scope of non-POD %q+#D", b);
2623 if (ent->in_try_scope)
2624 error (" enters try block");
2625 else if (ent->in_catch_scope && !saw_catch)
2626 error (" enters catch block");
2628 if (ent->in_omp_scope)
2629 error (" enters OpenMP structured block");
2630 else if (flag_openmp)
2632 struct cp_binding_level *b;
2633 for (b = current_binding_level; b ; b = b->level_chain)
2635 if (b == ent->binding_level)
2637 if (b->kind == sk_omp)
2641 pedwarn ("jump to label %q+D", decl);
2642 pedwarn (" from here");
2645 error (" exits OpenMP structured block");
2652 /* Check that a return is ok wrt OpenMP structured blocks.
2653 Called by finish_return_stmt. Returns true if all is well. */
2656 check_omp_return (void)
2658 struct cp_binding_level *b;
2659 for (b = current_binding_level; b ; b = b->level_chain)
2660 if (b->kind == sk_omp)
2662 error ("invalid exit from OpenMP structured block");
2668 /* Define a label, specifying the location in the source file.
2669 Return the LABEL_DECL node for the label. */
2672 define_label (location_t location, tree name)
2674 struct named_label_entry *ent, dummy;
2675 struct cp_binding_level *p;
2678 timevar_push (TV_NAME_LOOKUP);
2680 decl = lookup_label (name);
2682 dummy.label_decl = decl;
2683 ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2684 gcc_assert (ent != NULL);
2686 /* After labels, make any new cleanups in the function go into their
2687 own new (temporary) binding contour. */
2688 for (p = current_binding_level;
2689 p->kind != sk_function_parms;
2691 p->more_cleanups_ok = 0;
2693 if (name == get_identifier ("wchar_t"))
2694 pedwarn ("label named wchar_t");
2696 if (DECL_INITIAL (decl) != NULL_TREE)
2698 error ("duplicate label %qD", decl);
2699 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
2703 struct named_label_use_entry *use;
2705 /* Mark label as having been defined. */
2706 DECL_INITIAL (decl) = error_mark_node;
2707 /* Say where in the source. */
2708 DECL_SOURCE_LOCATION (decl) = location;
2710 ent->binding_level = current_binding_level;
2711 ent->names_in_scope = current_binding_level->names;
2713 for (use = ent->uses; use ; use = use->next)
2714 check_previous_goto (decl, use);
2718 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2723 struct cp_binding_level *level;
2724 struct cp_switch *next;
2725 /* The SWITCH_STMT being built. */
2727 /* A splay-tree mapping the low element of a case range to the high
2728 element, or NULL_TREE if there is no high element. Used to
2729 determine whether or not a new case label duplicates an old case
2730 label. We need a tree, rather than simply a hash table, because
2731 of the GNU case range extension. */
2735 /* A stack of the currently active switch statements. The innermost
2736 switch statement is on the top of the stack. There is no need to
2737 mark the stack for garbage collection because it is only active
2738 during the processing of the body of a function, and we never
2739 collect at that point. */
2741 static struct cp_switch *switch_stack;
2743 /* Called right after a switch-statement condition is parsed.
2744 SWITCH_STMT is the switch statement being parsed. */
2747 push_switch (tree switch_stmt)
2749 struct cp_switch *p = XNEW (struct cp_switch);
2750 p->level = current_binding_level;
2751 p->next = switch_stack;
2752 p->switch_stmt = switch_stmt;
2753 p->cases = splay_tree_new (case_compare, NULL, NULL);
2760 struct cp_switch *cs = switch_stack;
2761 location_t switch_location;
2763 /* Emit warnings as needed. */
2764 if (EXPR_HAS_LOCATION (cs->switch_stmt))
2765 switch_location = EXPR_LOCATION (cs->switch_stmt);
2767 switch_location = input_location;
2768 if (!processing_template_decl)
2769 c_do_switch_warnings (cs->cases, switch_location,
2770 SWITCH_STMT_TYPE (cs->switch_stmt),
2771 SWITCH_STMT_COND (cs->switch_stmt));
2773 splay_tree_delete (cs->cases);
2774 switch_stack = switch_stack->next;
2778 /* Note that we've seen a definition of a case label, and complain if this
2779 is a bad place for one. */
2782 finish_case_label (tree low_value, tree high_value)
2785 struct cp_binding_level *p;
2787 if (processing_template_decl)
2791 /* For templates, just add the case label; we'll do semantic
2792 analysis at instantiation-time. */
2793 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
2794 return add_stmt (build_case_label (low_value, high_value, label));
2797 /* Find the condition on which this switch statement depends. */
2798 cond = SWITCH_STMT_COND (switch_stack->switch_stmt);
2799 if (cond && TREE_CODE (cond) == TREE_LIST)
2800 cond = TREE_VALUE (cond);
2802 if (!check_switch_goto (switch_stack->level))
2803 return error_mark_node;
2805 r = c_add_case_label (switch_stack->cases, cond, TREE_TYPE (cond),
2806 low_value, high_value);
2808 /* After labels, make any new cleanups in the function go into their
2809 own new (temporary) binding contour. */
2810 for (p = current_binding_level;
2811 p->kind != sk_function_parms;
2813 p->more_cleanups_ok = 0;
2818 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
2821 typename_hash (const void* k)
2824 const_tree const t = (const_tree) k;
2826 hash = (htab_hash_pointer (TYPE_CONTEXT (t))
2827 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));
2832 typedef struct typename_info {
2840 /* Compare two TYPENAME_TYPEs. K1 is really of type `tree', K2 is
2841 really of type `typename_info*' */
2844 typename_compare (const void * k1, const void * k2)
2846 const_tree const t1 = (const_tree) k1;
2847 const typename_info *const t2 = (const typename_info *) k2;
2849 return (DECL_NAME (TYPE_NAME (t1)) == t2->name
2850 && TYPE_CONTEXT (t1) == t2->scope
2851 && TYPENAME_TYPE_FULLNAME (t1) == t2->template_id
2852 && TYPENAME_IS_ENUM_P (t1) == t2->enum_p
2853 && TYPENAME_IS_CLASS_P (t1) == t2->class_p);
2856 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
2857 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
2859 Returns the new TYPENAME_TYPE. */
2861 static GTY ((param_is (union tree_node))) htab_t typename_htab;
2864 build_typename_type (tree context, tree name, tree fullname,
2865 enum tag_types tag_type)
2873 if (typename_htab == NULL)
2874 typename_htab = htab_create_ggc (61, &typename_hash,
2875 &typename_compare, NULL);
2877 ti.scope = FROB_CONTEXT (context);
2879 ti.template_id = fullname;
2880 ti.enum_p = tag_type == enum_type;
2881 ti.class_p = (tag_type == class_type
2882 || tag_type == record_type
2883 || tag_type == union_type);
2884 hash = (htab_hash_pointer (ti.scope)
2885 ^ htab_hash_pointer (ti.name));
2887 /* See if we already have this type. */
2888 e = htab_find_slot_with_hash (typename_htab, &ti, hash, INSERT);
2893 /* Build the TYPENAME_TYPE. */
2894 t = make_aggr_type (TYPENAME_TYPE);
2895 TYPE_CONTEXT (t) = ti.scope;
2896 TYPENAME_TYPE_FULLNAME (t) = ti.template_id;
2897 TYPENAME_IS_ENUM_P (t) = ti.enum_p;
2898 TYPENAME_IS_CLASS_P (t) = ti.class_p;
2900 /* Build the corresponding TYPE_DECL. */
2901 d = build_decl (TYPE_DECL, name, t);
2902 TYPE_NAME (TREE_TYPE (d)) = d;
2903 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2904 DECL_CONTEXT (d) = FROB_CONTEXT (context);
2905 DECL_ARTIFICIAL (d) = 1;
2907 /* Store it in the hash table. */
2910 /* TYPENAME_TYPEs must always be compared structurally, because
2911 they may or may not resolve down to another type depending on
2912 the currently open classes. */
2913 SET_TYPE_STRUCTURAL_EQUALITY (t);
2919 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
2920 provided to name the type. Returns an appropriate type, unless an
2921 error occurs, in which case error_mark_node is returned. If we
2922 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
2923 return that, rather than the _TYPE it corresponds to, in other
2924 cases we look through the type decl. If TF_ERROR is set, complain
2925 about errors, otherwise be quiet. */
2928 make_typename_type (tree context, tree name, enum tag_types tag_type,
2929 tsubst_flags_t complain)
2935 if (name == error_mark_node
2936 || context == NULL_TREE
2937 || context == error_mark_node)
2938 return error_mark_node;
2942 if (!(TYPE_LANG_SPECIFIC (name)
2943 && (CLASSTYPE_IS_TEMPLATE (name)
2944 || CLASSTYPE_USE_TEMPLATE (name))))
2945 name = TYPE_IDENTIFIER (name);
2947 /* Create a TEMPLATE_ID_EXPR for the type. */
2948 name = build_nt (TEMPLATE_ID_EXPR,
2949 CLASSTYPE_TI_TEMPLATE (name),
2950 CLASSTYPE_TI_ARGS (name));
2952 else if (TREE_CODE (name) == TYPE_DECL)
2953 name = DECL_NAME (name);
2957 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
2959 name = TREE_OPERAND (name, 0);
2960 if (TREE_CODE (name) == TEMPLATE_DECL)
2961 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
2962 else if (TREE_CODE (name) == OVERLOAD)
2964 error ("%qD is not a type", name);
2965 return error_mark_node;
2968 if (TREE_CODE (name) == TEMPLATE_DECL)
2970 error ("%qD used without template parameters", name);
2971 return error_mark_node;
2973 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
2974 gcc_assert (TYPE_P (context));
2976 /* When the CONTEXT is a dependent type, NAME could refer to a
2977 dependent base class of CONTEXT. So we cannot peek inside it,
2978 even if CONTEXT is a currently open scope. */
2979 if (dependent_type_p (context))
2980 return build_typename_type (context, name, fullname, tag_type);
2982 if (!IS_AGGR_TYPE (context))
2984 if (complain & tf_error)
2985 error ("%q#T is not a class", context);
2986 return error_mark_node;
2989 want_template = TREE_CODE (fullname) == TEMPLATE_ID_EXPR;
2991 /* We should only set WANT_TYPE when we're a nested typename type.
2992 Then we can give better diagnostics if we find a non-type. */
2993 t = lookup_field (context, name, 0, /*want_type=*/true);
2996 if (complain & tf_error)
2997 error (want_template ? "no class template named %q#T in %q#T"
2998 : "no type named %q#T in %q#T", name, context);
2999 return error_mark_node;
3002 if (want_template && !DECL_CLASS_TEMPLATE_P (t))
3004 if (complain & tf_error)
3005 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3007 return error_mark_node;
3009 if (!want_template && TREE_CODE (t) != TYPE_DECL)
3011 if (complain & tf_error)
3012 error ("%<typename %T::%D%> names %q#T, which is not a type",
3014 return error_mark_node;
3017 if (complain & tf_error)
3018 perform_or_defer_access_check (TYPE_BINFO (context), t, t);
3021 return lookup_template_class (t, TREE_OPERAND (fullname, 1),
3023 /*entering_scope=*/0,
3024 tf_warning_or_error | tf_user);
3026 if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
3032 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3033 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3034 in which case error_mark_node is returned.
3036 If PARM_LIST is non-NULL, also make sure that the template parameter
3037 list of TEMPLATE_DECL matches.
3039 If COMPLAIN zero, don't complain about any errors that occur. */
3042 make_unbound_class_template (tree context, tree name, tree parm_list,
3043 tsubst_flags_t complain)
3049 name = TYPE_IDENTIFIER (name);
3050 else if (DECL_P (name))
3051 name = DECL_NAME (name);
3052 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
3054 if (!dependent_type_p (context)
3055 || currently_open_class (context))
3057 tree tmpl = NULL_TREE;
3059 if (IS_AGGR_TYPE (context))
3060 tmpl = lookup_field (context, name, 0, false);
3062 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
3064 if (complain & tf_error)
3065 error ("no class template named %q#T in %q#T", name, context);
3066 return error_mark_node;
3070 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl), parm_list))
3072 if (complain & tf_error)
3074 error ("template parameters do not match template");
3075 error ("%q+D declared here", tmpl);
3077 return error_mark_node;
3080 if (complain & tf_error)
3081 perform_or_defer_access_check (TYPE_BINFO (context), tmpl, tmpl);
3086 /* Build the UNBOUND_CLASS_TEMPLATE. */
3087 t = make_aggr_type (UNBOUND_CLASS_TEMPLATE);
3088 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
3089 TREE_TYPE (t) = NULL_TREE;
3090 SET_TYPE_STRUCTURAL_EQUALITY (t);
3092 /* Build the corresponding TEMPLATE_DECL. */
3093 d = build_decl (TEMPLATE_DECL, name, t);
3094 TYPE_NAME (TREE_TYPE (d)) = d;
3095 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
3096 DECL_CONTEXT (d) = FROB_CONTEXT (context);
3097 DECL_ARTIFICIAL (d) = 1;
3098 DECL_TEMPLATE_PARMS (d) = parm_list;
3105 /* Push the declarations of builtin types into the namespace.
3106 RID_INDEX is the index of the builtin type in the array
3107 RID_POINTERS. NAME is the name used when looking up the builtin
3108 type. TYPE is the _TYPE node for the builtin type. */
3111 record_builtin_type (enum rid rid_index,
3115 tree rname = NULL_TREE, tname = NULL_TREE;
3116 tree tdecl = NULL_TREE;
3118 if ((int) rid_index < (int) RID_MAX)
3119 rname = ridpointers[(int) rid_index];
3121 tname = get_identifier (name);
3123 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
3124 eliminated. Built-in types should not be looked up name; their
3125 names are keywords that the parser can recognize. However, there
3126 is code in c-common.c that uses identifier_global_value to look
3127 up built-in types by name. */
3130 tdecl = build_decl (TYPE_DECL, tname, type);
3131 DECL_ARTIFICIAL (tdecl) = 1;
3132 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
3138 tdecl = build_decl (TYPE_DECL, rname, type);
3139 DECL_ARTIFICIAL (tdecl) = 1;
3141 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
3144 if (!TYPE_NAME (type))
3145 TYPE_NAME (type) = tdecl;
3148 debug_hooks->type_decl (tdecl, 0);
3151 /* Record one of the standard Java types.
3152 * Declare it as having the given NAME.
3153 * If SIZE > 0, it is the size of one of the integral types;
3154 * otherwise it is the negative of the size of one of the other types. */
3157 record_builtin_java_type (const char* name, int size)
3161 type = make_signed_type (size);
3162 else if (size == -1)
3163 { /* "__java_boolean". */
3164 type = build_variant_type_copy (boolean_type_node);
3166 else if (size > -32)
3167 { /* "__java_char". */
3168 type = make_unsigned_type (-size);
3171 { /* "__java_float" or ""__java_double". */
3172 type = make_node (REAL_TYPE);
3173 TYPE_PRECISION (type) = - size;
3176 record_builtin_type (RID_MAX, name, type);
3177 decl = TYPE_NAME (type);
3179 /* Suppress generate debug symbol entries for these types,
3180 since for normal C++ they are just clutter.
3181 However, push_lang_context undoes this if extern "Java" is seen. */
3182 DECL_IGNORED_P (decl) = 1;
3184 TYPE_FOR_JAVA (type) = 1;
3188 /* Push a type into the namespace so that the back ends ignore it. */
3191 record_unknown_type (tree type, const char* name)
3193 tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
3194 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3195 DECL_IGNORED_P (decl) = 1;
3196 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
3197 TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
3198 TYPE_ALIGN (type) = 1;
3199 TYPE_USER_ALIGN (type) = 0;
3200 TYPE_MODE (type) = TYPE_MODE (void_type_node);
3203 /* A string for which we should create an IDENTIFIER_NODE at
3206 typedef struct predefined_identifier
3208 /* The name of the identifier. */
3209 const char *const name;
3210 /* The place where the IDENTIFIER_NODE should be stored. */
3212 /* Nonzero if this is the name of a constructor or destructor. */
3213 const int ctor_or_dtor_p;
3214 } predefined_identifier;
3216 /* Create all the predefined identifiers. */
3219 initialize_predefined_identifiers (void)
3221 const predefined_identifier *pid;
3223 /* A table of identifiers to create at startup. */
3224 static const predefined_identifier predefined_identifiers[] = {
3225 { "C++", &lang_name_cplusplus, 0 },
3226 { "C", &lang_name_c, 0 },
3227 { "Java", &lang_name_java, 0 },
3228 /* Some of these names have a trailing space so that it is
3229 impossible for them to conflict with names written by users. */
3230 { "__ct ", &ctor_identifier, 1 },
3231 { "__base_ctor ", &base_ctor_identifier, 1 },
3232 { "__comp_ctor ", &complete_ctor_identifier, 1 },
3233 { "__dt ", &dtor_identifier, 1 },
3234 { "__comp_dtor ", &complete_dtor_identifier, 1 },
3235 { "__base_dtor ", &base_dtor_identifier, 1 },
3236 { "__deleting_dtor ", &deleting_dtor_identifier, 1 },
3237 { IN_CHARGE_NAME, &in_charge_identifier, 0 },
3238 { "nelts", &nelts_identifier, 0 },
3239 { THIS_NAME, &this_identifier, 0 },
3240 { VTABLE_DELTA_NAME, &delta_identifier, 0 },
3241 { VTABLE_PFN_NAME, &pfn_identifier, 0 },
3242 { "_vptr", &vptr_identifier, 0 },
3243 { "__vtt_parm", &vtt_parm_identifier, 0 },
3244 { "::", &global_scope_name, 0 },
3245 { "std", &std_identifier, 0 },
3249 for (pid = predefined_identifiers; pid->name; ++pid)
3251 *pid->node = get_identifier (pid->name);
3252 if (pid->ctor_or_dtor_p)
3253 IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
3257 /* Create the predefined scalar types of C,
3258 and some nodes representing standard constants (0, 1, (void *)0).
3259 Initialize the global binding level.
3260 Make definitions for built-in primitive functions. */
3263 cxx_init_decl_processing (void)
3266 tree void_ftype_ptr;
3268 build_common_tree_nodes (flag_signed_char, false);
3270 /* Create all the identifiers we need. */
3271 initialize_predefined_identifiers ();
3273 /* Create the global variables. */
3274 push_to_top_level ();
3276 current_function_decl = NULL_TREE;
3277 current_binding_level = NULL;
3278 /* Enter the global namespace. */
3279 gcc_assert (global_namespace == NULL_TREE);
3280 global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name,
3282 TREE_PUBLIC (global_namespace) = 1;
3283 begin_scope (sk_namespace, global_namespace);
3285 current_lang_name = NULL_TREE;
3287 if (flag_visibility_ms_compat)
3288 default_visibility = VISIBILITY_HIDDEN;
3291 current_lang_name = lang_name_c;
3293 /* Create the `std' namespace. */
3294 push_namespace (std_identifier);
3295 std_node = current_namespace;
3298 c_common_nodes_and_builtins ();
3300 java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
3301 java_short_type_node = record_builtin_java_type ("__java_short", 16);
3302 java_int_type_node = record_builtin_java_type ("__java_int", 32);
3303 java_long_type_node = record_builtin_java_type ("__java_long", 64);
3304 java_float_type_node = record_builtin_java_type ("__java_float", -32);
3305 java_double_type_node = record_builtin_java_type ("__java_double", -64);
3306 java_char_type_node = record_builtin_java_type ("__java_char", -16);
3307 java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
3309 integer_two_node = build_int_cst (NULL_TREE, 2);
3310 integer_three_node = build_int_cst (NULL_TREE, 3);
3312 record_builtin_type (RID_BOOL, "bool", boolean_type_node);
3313 truthvalue_type_node = boolean_type_node;
3314 truthvalue_false_node = boolean_false_node;
3315 truthvalue_true_node = boolean_true_node;
3317 empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
3320 record_builtin_type (RID_MAX, NULL, string_type_node);
3323 delta_type_node = ptrdiff_type_node;
3324 vtable_index_type = ptrdiff_type_node;
3326 vtt_parm_type = build_pointer_type (const_ptr_type_node);
3327 void_ftype = build_function_type (void_type_node, void_list_node);
3328 void_ftype_ptr = build_function_type (void_type_node,
3329 tree_cons (NULL_TREE,
3333 = build_exception_variant (void_ftype_ptr, empty_except_spec);
3335 /* C++ extensions */
3337 unknown_type_node = make_node (UNKNOWN_TYPE);
3338 record_unknown_type (unknown_type_node, "unknown type");
3340 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3341 TREE_TYPE (unknown_type_node) = unknown_type_node;
3343 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3345 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
3346 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
3349 /* Make sure we get a unique function type, so we can give
3350 its pointer type a name. (This wins for gdb.) */
3351 tree vfunc_type = make_node (FUNCTION_TYPE);
3352 TREE_TYPE (vfunc_type) = integer_type_node;
3353 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
3354 layout_type (vfunc_type);
3356 vtable_entry_type = build_pointer_type (vfunc_type);
3358 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
3361 = build_cplus_array_type (vtable_entry_type, NULL_TREE);
3362 layout_type (vtbl_type_node);
3363 vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
3364 record_builtin_type (RID_MAX, NULL, vtbl_type_node);
3365 vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
3366 layout_type (vtbl_ptr_type_node);
3367 record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
3369 push_namespace (get_identifier ("__cxxabiv1"));
3370 abi_node = current_namespace;
3373 global_type_node = make_node (LANG_TYPE);
3374 record_unknown_type (global_type_node, "global type");
3377 current_lang_name = lang_name_cplusplus;
3381 tree bad_alloc_type_node;
3382 tree bad_alloc_decl;
3383 tree newtype, deltype;
3384 tree ptr_ftype_sizetype;
3386 push_namespace (std_identifier);
3387 bad_alloc_id = get_identifier ("bad_alloc");
3388 bad_alloc_type_node = make_aggr_type (RECORD_TYPE);
3389 TYPE_CONTEXT (bad_alloc_type_node) = current_namespace;
3391 = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node);
3392 DECL_CONTEXT (bad_alloc_decl) = current_namespace;
3393 TYPE_STUB_DECL (bad_alloc_type_node) = bad_alloc_decl;
3397 = build_function_type (ptr_type_node,
3398 tree_cons (NULL_TREE,
3401 newtype = build_exception_variant
3402 (ptr_ftype_sizetype, add_exception_specifier
3403 (NULL_TREE, bad_alloc_type_node, -1));
3404 deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
3405 push_cp_library_fn (NEW_EXPR, newtype);
3406 push_cp_library_fn (VEC_NEW_EXPR, newtype);
3407 global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
3408 push_cp_library_fn (VEC_DELETE_EXPR, deltype);
3412 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
3414 /* Perform other language dependent initializations. */
3415 init_class_processing ();
3416 init_rtti_processing ();
3418 if (flag_exceptions)
3419 init_exception_processing ();
3421 if (! supports_one_only ())
3424 make_fname_decl = cp_make_fname_decl;
3425 start_fname_decls ();
3427 /* Show we use EH for cleanups. */
3428 if (flag_exceptions)
3429 using_eh_for_cleanups ();
3432 /* Generate an initializer for a function naming variable from
3433 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3434 filled in with the type of the init. */
3437 cp_fname_init (const char* name, tree *type_p)
3439 tree domain = NULL_TREE;
3441 tree init = NULL_TREE;
3446 length = strlen (name);
3447 domain = build_index_type (size_int (length));
3448 init = build_string (length + 1, name);
3451 type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
3452 type = build_cplus_array_type (type, domain);
3457 TREE_TYPE (init) = type;
3459 init = error_mark_node;
3464 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
3465 decl, NAME is the initialization string and TYPE_DEP indicates whether
3466 NAME depended on the type of the function. We make use of that to detect
3467 __PRETTY_FUNCTION__ inside a template fn. This is being done
3468 lazily at the point of first use, so we mustn't push the decl now. */
3471 cp_make_fname_decl (tree id, int type_dep)
3473 const char *const name = (type_dep && processing_template_decl
3474 ? NULL : fname_as_string (type_dep));
3476 tree init = cp_fname_init (name, &type);
3477 tree decl = build_decl (VAR_DECL, id, type);
3480 free (CONST_CAST (char *, name));
3482 /* As we're using pushdecl_with_scope, we must set the context. */
3483 DECL_CONTEXT (decl) = current_function_decl;
3484 DECL_PRETTY_FUNCTION_P (decl) = type_dep;
3486 TREE_STATIC (decl) = 1;
3487 TREE_READONLY (decl) = 1;
3488 DECL_ARTIFICIAL (decl) = 1;
3490 TREE_USED (decl) = 1;
3492 if (current_function_decl)
3494 struct cp_binding_level *b = current_binding_level;
3495 while (b->level_chain->kind != sk_function_parms)
3497 pushdecl_with_scope (decl, b, /*is_friend=*/false);
3498 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE,
3499 LOOKUP_ONLYCONVERTING);
3502 pushdecl_top_level_and_finish (decl, init);
3508 builtin_function_1 (tree decl, tree context)
3510 tree id = DECL_NAME (decl);
3511 const char *name = IDENTIFIER_POINTER (id);
3513 retrofit_lang_decl (decl);
3515 /* All nesting of C++ functions is lexical; there is never a "static
3516 chain" in the sense of GNU C nested functions. */
3517 DECL_NO_STATIC_CHAIN (decl) = 1;
3519 DECL_ARTIFICIAL (decl) = 1;
3520 SET_OVERLOADED_OPERATOR_CODE (decl, ERROR_MARK);
3521 SET_DECL_LANGUAGE (decl, lang_c);
3522 /* Runtime library routines are, by definition, available in an
3523 external shared object. */
3524 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
3525 DECL_VISIBILITY_SPECIFIED (decl) = 1;
3527 DECL_CONTEXT (decl) = context;
3531 /* A function in the user's namespace should have an explicit
3532 declaration before it is used. Mark the built-in function as
3533 anticipated but not actually declared. */
3534 if (name[0] != '_' || name[1] != '_')
3535 DECL_ANTICIPATED (decl) = 1;
3536 else if (strncmp (name + 2, "builtin_", strlen ("builtin_")) != 0)
3538 size_t len = strlen (name);
3540 /* Treat __*_chk fortification functions as anticipated as well,
3541 unless they are __builtin_*. */
3542 if (len > strlen ("___chk")
3543 && memcmp (name + len - strlen ("_chk"),
3544 "_chk", strlen ("_chk") + 1) == 0)
3545 DECL_ANTICIPATED (decl) = 1;
3552 cxx_builtin_function (tree decl)
3554 tree id = DECL_NAME (decl);
3555 const char *name = IDENTIFIER_POINTER (id);
3556 /* All builtins that don't begin with an '_' should additionally
3557 go in the 'std' namespace. */
3560 tree decl2 = copy_node(decl);
3561 push_namespace (std_identifier);
3562 builtin_function_1 (decl2, std_node);
3566 return builtin_function_1 (decl, NULL_TREE);
3569 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
3570 function. Not called directly. */
3573 build_library_fn_1 (tree name, enum tree_code operator_code, tree type)
3575 tree fn = build_lang_decl (FUNCTION_DECL, name, type);
3576 DECL_EXTERNAL (fn) = 1;
3577 TREE_PUBLIC (fn) = 1;
3578 DECL_ARTIFICIAL (fn) = 1;
3579 SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
3580 SET_DECL_LANGUAGE (fn, lang_c);
3581 /* Runtime library routines are, by definition, available in an
3582 external shared object. */
3583 DECL_VISIBILITY (fn) = VISIBILITY_DEFAULT;
3584 DECL_VISIBILITY_SPECIFIED (fn) = 1;
3588 /* Returns the _DECL for a library function with C linkage.
3589 We assume that such functions never throw; if this is incorrect,
3590 callers should unset TREE_NOTHROW. */
3593 build_library_fn (tree name, tree type)
3595 tree fn = build_library_fn_1 (name, ERROR_MARK, type);
3596 TREE_NOTHROW (fn) = 1;
3600 /* Returns the _DECL for a library function with C++ linkage. */
3603 build_cp_library_fn (tree name, enum tree_code operator_code, tree type)
3605 tree fn = build_library_fn_1 (name, operator_code, type);
3606 TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
3607 DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
3608 SET_DECL_LANGUAGE (fn, lang_cplusplus);
3612 /* Like build_library_fn, but takes a C string instead of an
3616 build_library_fn_ptr (const char* name, tree type)
3618 return build_library_fn (get_identifier (name), type);
3621 /* Like build_cp_library_fn, but takes a C string instead of an
3625 build_cp_library_fn_ptr (const char* name, tree type)
3627 return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
3630 /* Like build_library_fn, but also pushes the function so that we will
3631 be able to find it via IDENTIFIER_GLOBAL_VALUE. */
3634 push_library_fn (tree name, tree type)
3636 tree fn = build_library_fn (name, type);
3637 pushdecl_top_level (fn);
3641 /* Like build_cp_library_fn, but also pushes the function so that it
3642 will be found by normal lookup. */
3645 push_cp_library_fn (enum tree_code operator_code, tree type)
3647 tree fn = build_cp_library_fn (ansi_opname (operator_code),
3654 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
3658 push_void_library_fn (tree name, tree parmtypes)
3660 tree type = build_function_type (void_type_node, parmtypes);
3661 return push_library_fn (name, type);
3664 /* Like push_library_fn, but also note that this function throws
3665 and does not return. Used for __throw_foo and the like. */
3668 push_throw_library_fn (tree name, tree type)
3670 tree fn = push_library_fn (name, type);
3671 TREE_THIS_VOLATILE (fn) = 1;
3672 TREE_NOTHROW (fn) = 0;
3676 /* When we call finish_struct for an anonymous union, we create
3677 default copy constructors and such. But, an anonymous union
3678 shouldn't have such things; this function undoes the damage to the
3679 anonymous union type T.
3681 (The reason that we create the synthesized methods is that we don't
3682 distinguish `union { int i; }' from `typedef union { int i; } U'.
3683 The first is an anonymous union; the second is just an ordinary
3687 fixup_anonymous_aggr (tree t)
3691 /* Wipe out memory of synthesized methods. */
3692 TYPE_HAS_USER_CONSTRUCTOR (t) = 0;
3693 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
3694 TYPE_HAS_INIT_REF (t) = 0;
3695 TYPE_HAS_CONST_INIT_REF (t) = 0;
3696 TYPE_HAS_ASSIGN_REF (t) = 0;
3697 TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
3699 /* Splice the implicitly generated functions out of the TYPE_METHODS
3701 q = &TYPE_METHODS (t);
3704 if (DECL_ARTIFICIAL (*q))
3705 *q = TREE_CHAIN (*q);
3707 q = &TREE_CHAIN (*q);
3710 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
3711 if (TYPE_METHODS (t))
3713 tree decl = TYPE_MAIN_DECL (t);
3715 if (TREE_CODE (t) != UNION_TYPE)
3716 error ("%Jan anonymous struct cannot have function members", decl);
3718 error ("%Jan anonymous union cannot have function members", decl);
3721 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
3722 assignment operators (because they cannot have these methods themselves).
3723 For anonymous unions this is already checked because they are not allowed
3724 in any union, otherwise we have to check it. */
3725 if (TREE_CODE (t) != UNION_TYPE)
3729 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
3730 if (TREE_CODE (field) == FIELD_DECL)
3732 type = TREE_TYPE (field);
3733 if (CLASS_TYPE_P (type))
3735 if (TYPE_NEEDS_CONSTRUCTING (type))
3736 error ("member %q+#D with constructor not allowed "
3737 "in anonymous aggregate", field);
3738 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
3739 error ("member %q+#D with destructor not allowed "
3740 "in anonymous aggregate", field);
3741 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
3742 error ("member %q+#D with copy assignment operator "
3743 "not allowed in anonymous aggregate", field);
3749 /* Make sure that a declaration with no declarator is well-formed, i.e.
3750 just declares a tagged type or anonymous union.
3752 Returns the type declared; or NULL_TREE if none. */
3755 check_tag_decl (cp_decl_specifier_seq *declspecs)
3757 int saw_friend = declspecs->specs[(int)ds_friend] != 0;
3758 int saw_typedef = declspecs->specs[(int)ds_typedef] != 0;
3759 /* If a class, struct, or enum type is declared by the DECLSPECS
3760 (i.e, if a class-specifier, enum-specifier, or non-typename
3761 elaborated-type-specifier appears in the DECLSPECS),
3762 DECLARED_TYPE is set to the corresponding type. */
3763 tree declared_type = NULL_TREE;
3764 bool error_p = false;
3766 if (declspecs->multiple_types_p)
3767 error ("multiple types in one declaration");
3768 else if (declspecs->redefined_builtin_type)
3770 if (!in_system_header)
3771 pedwarn ("redeclaration of C++ built-in type %qT",
3772 declspecs->redefined_builtin_type);
3777 && TYPE_P (declspecs->type)
3778 && ((TREE_CODE (declspecs->type) != TYPENAME_TYPE
3779 && IS_AGGR_TYPE (declspecs->type))
3780 || TREE_CODE (declspecs->type) == ENUMERAL_TYPE))
3781 declared_type = declspecs->type;
3782 else if (declspecs->type == error_mark_node)
3784 if (declared_type == NULL_TREE && ! saw_friend && !error_p)
3785 pedwarn ("declaration does not declare anything");
3786 /* Check for an anonymous union. */
3787 else if (declared_type && IS_AGGR_TYPE_CODE (TREE_CODE (declared_type))
3788 && TYPE_ANONYMOUS_P (declared_type))
3790 /* 7/3 In a simple-declaration, the optional init-declarator-list
3791 can be omitted only when declaring a class (clause 9) or
3792 enumeration (7.2), that is, when the decl-specifier-seq contains
3793 either a class-specifier, an elaborated-type-specifier with
3794 a class-key (9.1), or an enum-specifier. In these cases and
3795 whenever a class-specifier or enum-specifier is present in the
3796 decl-specifier-seq, the identifiers in these specifiers are among
3797 the names being declared by the declaration (as class-name,
3798 enum-names, or enumerators, depending on the syntax). In such
3799 cases, and except for the declaration of an unnamed bit-field (9.6),
3800 the decl-specifier-seq shall introduce one or more names into the
3801 program, or shall redeclare a name introduced by a previous
3802 declaration. [Example:
3803 enum { }; // ill-formed
3804 typedef class { }; // ill-formed
3808 error ("missing type-name in typedef-declaration");
3811 /* Anonymous unions are objects, so they can have specifiers. */;
3812 SET_ANON_AGGR_TYPE_P (declared_type);
3814 if (TREE_CODE (declared_type) != UNION_TYPE && pedantic
3815 && !in_system_header)
3816 pedwarn ("ISO C++ prohibits anonymous structs");
3821 if (declspecs->specs[(int)ds_inline]
3822 || declspecs->specs[(int)ds_virtual])
3823 error ("%qs can only be specified for functions",
3824 declspecs->specs[(int)ds_inline]
3825 ? "inline" : "virtual");
3827 && (!current_class_type
3828 || current_scope () != current_class_type))
3829 error ("%<friend%> can only be specified inside a class");
3830 else if (declspecs->specs[(int)ds_explicit])
3831 error ("%<explicit%> can only be specified for constructors");
3832 else if (declspecs->storage_class)
3833 error ("a storage class can only be specified for objects "
3835 else if (declspecs->specs[(int)ds_const]
3836 || declspecs->specs[(int)ds_volatile]
3837 || declspecs->specs[(int)ds_restrict]
3838 || declspecs->specs[(int)ds_thread])
3839 error ("qualifiers can only be specified for objects "
3841 else if (saw_typedef)
3842 warning (0, "%<typedef%> was ignored in this declaration");
3845 return declared_type;
3848 /* Called when a declaration is seen that contains no names to declare.
3849 If its type is a reference to a structure, union or enum inherited
3850 from a containing scope, shadow that tag name for the current scope
3851 with a forward reference.
3852 If its type defines a new named structure or union
3853 or defines an enum, it is valid but we need not do anything here.
3854 Otherwise, it is an error.
3856 C++: may have to grok the declspecs to learn about static,
3857 complain for anonymous unions.
3859 Returns the TYPE declared -- or NULL_TREE if none. */
3862 shadow_tag (cp_decl_specifier_seq *declspecs)
3864 tree t = check_tag_decl (declspecs);
3869 if (declspecs->attributes)
3871 warning (0, "attribute ignored in declaration of %q+#T", t);
3872 warning (0, "attribute for %q+#T must follow the %qs keyword",
3873 t, class_key_or_enum_as_string (t));
3877 if (maybe_process_partial_specialization (t) == error_mark_node)
3880 /* This is where the variables in an anonymous union are
3881 declared. An anonymous union declaration looks like:
3883 because there is no declarator after the union, the parser
3884 sends that declaration here. */
3885 if (ANON_AGGR_TYPE_P (t))
3887 fixup_anonymous_aggr (t);
3889 if (TYPE_FIELDS (t))
3891 tree decl = grokdeclarator (/*declarator=*/NULL,
3892 declspecs, NORMAL, 0, NULL);
3893 finish_anon_union (decl);
3900 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
3903 groktypename (cp_decl_specifier_seq *type_specifiers,
3904 const cp_declarator *declarator)
3908 attrs = type_specifiers->attributes;
3909 type_specifiers->attributes = NULL_TREE;
3910 type = grokdeclarator (declarator, type_specifiers, TYPENAME, 0, &attrs);
3913 if (CLASS_TYPE_P (type))
3914 warning (OPT_Wattributes, "ignoring attributes applied to class type %qT "
3915 "outside of definition", type);
3916 else if (IS_AGGR_TYPE (type))
3917 /* A template type parameter or other dependent type. */
3918 warning (OPT_Wattributes, "ignoring attributes applied to dependent "
3919 "type %qT without an associated declaration", type);
3921 cplus_decl_attributes (&type, attrs, 0);
3926 /* Process a DECLARATOR for a function-scope variable declaration,
3927 namespace-scope variable declaration, or function declaration.
3928 (Function definitions go through start_function; class member
3929 declarations appearing in the body of the class go through
3930 grokfield.) The DECL corresponding to the DECLARATOR is returned.
3931 If an error occurs, the error_mark_node is returned instead.
3933 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED
3934 is true if an explicit initializer is present, but false if this is
3935 a variable implicitly initialized via a default constructor.
3936 ATTRIBUTES and PREFIX_ATTRIBUTES are GNU attributes associated with
3937 this declaration. *PUSHED_SCOPE_P is set to the scope entered in
3938 this function, if any; if set, the caller is responsible for
3939 calling pop_scope. */
3942 start_decl (const cp_declarator *declarator,
3943 cp_decl_specifier_seq *declspecs,
3946 tree prefix_attributes,
3947 tree *pushed_scope_p)
3954 *pushed_scope_p = NULL_TREE;
3956 /* An object declared as __attribute__((deprecated)) suppresses
3957 warnings of uses of other deprecated items. */
3958 if (lookup_attribute ("deprecated", attributes))
3959 deprecated_state = DEPRECATED_SUPPRESS;
3961 attributes = chainon (attributes, prefix_attributes);
3963 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
3966 deprecated_state = DEPRECATED_NORMAL;
3968 if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE
3969 || decl == error_mark_node)
3970 return error_mark_node;
3972 type = TREE_TYPE (decl);
3974 context = DECL_CONTEXT (decl);
3978 *pushed_scope_p = push_scope (context);
3980 /* We are only interested in class contexts, later. */
3981 if (TREE_CODE (context) == NAMESPACE_DECL)
3982 context = NULL_TREE;
3986 /* Is it valid for this decl to have an initializer at all?
3987 If not, set INITIALIZED to zero, which will indirectly
3988 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
3989 switch (TREE_CODE (decl))
3992 error ("typedef %qD is initialized (use __typeof__ instead)", decl);
3993 return error_mark_node;
3996 error ("function %q#D is initialized like a variable", decl);
3997 return error_mark_node;
4005 if (! toplevel_bindings_p ()
4006 && DECL_EXTERNAL (decl))
4007 warning (0, "declaration of %q#D has %<extern%> and is initialized",
4009 DECL_EXTERNAL (decl) = 0;
4010 if (toplevel_bindings_p ())
4011 TREE_STATIC (decl) = 1;
4014 /* Set attributes here so if duplicate decl, will have proper attributes. */
4015 cplus_decl_attributes (&decl, attributes, 0);
4017 /* Dllimported symbols cannot be defined. Static data members (which
4018 can be initialized in-class and dllimported) go through grokfield,
4019 not here, so we don't need to exclude those decls when checking for
4021 if (initialized && DECL_DLLIMPORT_P (decl))
4023 error ("definition of %q#D is marked %<dllimport%>", decl);
4024 DECL_DLLIMPORT_P (decl) = 0;
4027 /* If #pragma weak was used, mark the decl weak now. */
4028 maybe_apply_pragma_weak (decl);
4030 if (TREE_CODE (decl) == FUNCTION_DECL
4031 && DECL_DECLARED_INLINE_P (decl)
4032 && DECL_UNINLINABLE (decl)
4033 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
4034 warning (0, "inline function %q+D given attribute noinline", decl);
4036 if (context && COMPLETE_TYPE_P (complete_type (context)))
4038 if (TREE_CODE (decl) == VAR_DECL)
4040 tree field = lookup_field (context, DECL_NAME (decl), 0, false);
4041 if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
4042 error ("%q#D is not a static member of %q#T", decl, context);
4045 if (DECL_CONTEXT (field) != context)
4047 if (!same_type_p (DECL_CONTEXT (field), context))
4048 pedwarn ("ISO C++ does not permit %<%T::%D%> "
4049 "to be defined as %<%T::%D%>",
4050 DECL_CONTEXT (field), DECL_NAME (decl),
4051 context, DECL_NAME (decl));
4052 DECL_CONTEXT (decl) = DECL_CONTEXT (field);
4054 if (processing_specialization
4055 && template_class_depth (context) == 0
4056 && CLASSTYPE_TEMPLATE_SPECIALIZATION (context))
4057 error ("template header not allowed in member definition "
4058 "of explicitly specialized class");
4059 /* Static data member are tricky; an in-class initialization
4060 still doesn't provide a definition, so the in-class
4061 declaration will have DECL_EXTERNAL set, but will have an
4062 initialization. Thus, duplicate_decls won't warn
4063 about this situation, and so we check here. */
4064 if (initialized && DECL_INITIALIZED_IN_CLASS_P (field))
4065 error ("duplicate initialization of %qD", decl);
4066 if (duplicate_decls (decl, field, /*newdecl_is_friend=*/false))
4072 tree field = check_classfn (context, decl,
4073 (processing_template_decl
4074 > template_class_depth (context))
4075 ? current_template_parms
4077 if (field && field != error_mark_node
4078 && duplicate_decls (decl, field,
4079 /*newdecl_is_friend=*/false))
4083 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
4084 DECL_IN_AGGR_P (decl) = 0;
4085 /* Do not mark DECL as an explicit specialization if it was not
4086 already marked as an instantiation; a declaration should
4087 never be marked as a specialization unless we know what
4088 template is being specialized. */
4089 if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
4091 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
4093 /* [temp.expl.spec] An explicit specialization of a static data
4094 member of a template is a definition if the declaration
4095 includes an initializer; otherwise, it is a declaration.
4097 We check for processing_specialization so this only applies
4098 to the new specialization syntax. */
4099 if (!initialized && processing_specialization)
4100 DECL_EXTERNAL (decl) = 1;
4103 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
4104 pedwarn ("declaration of %q#D outside of class is not definition",
4108 was_public = TREE_PUBLIC (decl);
4110 /* Enter this declaration into the symbol table. */
4111 decl = maybe_push_decl (decl);
4113 if (processing_template_decl)
4114 decl = push_template_decl (decl);
4115 if (decl == error_mark_node)
4116 return error_mark_node;
4118 /* Tell the back end to use or not use .common as appropriate. If we say
4119 -fconserve-space, we want this to save .data space, at the expense of
4120 wrong semantics. If we say -fno-conserve-space, we want this to
4121 produce errors about redefs; to do this we force variables into the
4123 if (flag_conserve_space
4124 && TREE_CODE (decl) == VAR_DECL
4125 && TREE_PUBLIC (decl)
4126 && !DECL_THREAD_LOCAL_P (decl)
4127 && !have_global_bss_p ())
4128 DECL_COMMON (decl) = 1;
4130 if (TREE_CODE (decl) == VAR_DECL
4131 && DECL_NAMESPACE_SCOPE_P (decl) && !TREE_PUBLIC (decl) && !was_public
4132 && !DECL_THIS_STATIC (decl) && !DECL_ARTIFICIAL (decl))
4134 /* This is a const variable with implicit 'static'. Set
4135 DECL_THIS_STATIC so we can tell it from variables that are
4136 !TREE_PUBLIC because of the anonymous namespace. */
4137 gcc_assert (cp_type_readonly (TREE_TYPE (decl)));
4138 DECL_THIS_STATIC (decl) = 1;
4141 if (!processing_template_decl && TREE_CODE (decl) == VAR_DECL)
4142 start_decl_1 (decl, initialized);
4147 /* Process the declaration of a variable DECL. INITIALIZED is true
4148 iff DECL is explicitly initialized. (INITIALIZED is false if the
4149 variable is initialized via an implicitly-called constructor.)
4150 This function must be called for ordinary variables (including, for
4151 example, implicit instantiations of templates), but must not be
4152 called for template declarations. */
4155 start_decl_1 (tree decl, bool initialized)
4159 bool aggregate_definition_p;
4161 gcc_assert (!processing_template_decl);
4163 if (error_operand_p (decl))
4166 gcc_assert (TREE_CODE (decl) == VAR_DECL);
4168 type = TREE_TYPE (decl);
4169 complete_p = COMPLETE_TYPE_P (type);
4170 aggregate_definition_p = IS_AGGR_TYPE (type) && !DECL_EXTERNAL (decl);
4172 /* If an explicit initializer is present, or if this is a definition
4173 of an aggregate, then we need a complete type at this point.
4174 (Scalars are always complete types, so there is nothing to
4175 check.) This code just sets COMPLETE_P; errors (if necessary)
4176 are issued below. */
4177 if ((initialized || aggregate_definition_p)
4179 && COMPLETE_TYPE_P (complete_type (type)))
4182 /* We will not yet have set TREE_READONLY on DECL if the type
4183 was "const", but incomplete, before this point. But, now, we
4184 have a complete type, so we can try again. */
4185 cp_apply_type_quals_to_decl (cp_type_quals (type), decl);
4189 /* Is it valid for this decl to have an initializer at all? */
4191 /* Don't allow initializations for incomplete types except for
4192 arrays which might be completed by the initialization. */
4194 ; /* A complete type is ok. */
4195 else if (TREE_CODE (type) != ARRAY_TYPE)
4197 error ("variable %q#D has initializer but incomplete type", decl);
4198 type = TREE_TYPE (decl) = error_mark_node;
4200 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
4202 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
4203 error ("elements of array %q#D have incomplete type", decl);
4204 /* else we already gave an error in start_decl. */
4207 else if (aggregate_definition_p && !complete_p)
4209 error ("aggregate %q#D has incomplete type and cannot be defined",
4211 /* Change the type so that assemble_variable will give
4212 DECL an rtl we can live with: (mem (const_int 0)). */
4213 type = TREE_TYPE (decl) = error_mark_node;
4216 /* Create a new scope to hold this declaration if necessary.
4217 Whether or not a new scope is necessary cannot be determined
4218 until after the type has been completed; if the type is a
4219 specialization of a class template it is not until after
4220 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4221 will be set correctly. */
4222 maybe_push_cleanup_level (type);
4225 /* Handle initialization of references. DECL, TYPE, and INIT have the
4226 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
4227 but will be set to a new CLEANUP_STMT if a temporary is created
4228 that must be destroyed subsequently.
4230 Returns an initializer expression to use to initialize DECL, or
4231 NULL if the initialization can be performed statically.
4233 Quotes on semantics can be found in ARM 8.4.3. */
4236 grok_reference_init (tree decl, tree type, tree init, tree *cleanup)
4240 if (init == NULL_TREE)
4242 if ((DECL_LANG_SPECIFIC (decl) == 0
4243 || DECL_IN_AGGR_P (decl) == 0)
4244 && ! DECL_THIS_EXTERN (decl))
4245 error ("%qD declared as reference but not initialized", decl);
4249 if (TREE_CODE (init) == CONSTRUCTOR)
4251 error ("ISO C++ forbids use of initializer list to "
4252 "initialize reference %qD", decl);
4256 if (TREE_CODE (init) == TREE_LIST)
4257 init = build_x_compound_expr_from_list (init, "initializer");
4259 if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
4260 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
4261 /* Note: default conversion is only called in very special cases. */
4262 init = decay_conversion (init);
4264 /* Convert INIT to the reference type TYPE. This may involve the
4265 creation of a temporary, whose lifetime must be the same as that
4266 of the reference. If so, a DECL_EXPR for the temporary will be
4267 added just after the DECL_EXPR for DECL. That's why we don't set
4268 DECL_INITIAL for local references (instead assigning to them
4269 explicitly); we need to allow the temporary to be initialized
4271 tmp = initialize_reference (type, init, decl, cleanup);
4273 if (tmp == error_mark_node)
4275 else if (tmp == NULL_TREE)
4277 error ("cannot initialize %qT from %qT", type, TREE_TYPE (init));
4281 if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
4284 DECL_INITIAL (decl) = tmp;
4289 /* Designated initializers in arrays are not supported in GNU C++.
4290 The parser cannot detect this error since it does not know whether
4291 a given brace-enclosed initializer is for a class type or for an
4292 array. This function checks that CE does not use a designated
4293 initializer. If it does, an error is issued. Returns true if CE
4294 is valid, i.e., does not have a designated initializer. */
4297 check_array_designated_initializer (const constructor_elt *ce)
4299 /* Designated initializers for array elements are not supported. */
4302 /* The parser only allows identifiers as designated
4304 gcc_assert (TREE_CODE (ce->index) == IDENTIFIER_NODE);
4305 error ("name %qD used in a GNU-style designated "
4306 "initializer for an array", ce->index);
4313 /* When parsing `int a[] = {1, 2};' we don't know the size of the
4314 array until we finish parsing the initializer. If that's the
4315 situation we're in, update DECL accordingly. */
4318 maybe_deduce_size_from_array_init (tree decl, tree init)
4320 tree type = TREE_TYPE (decl);
4322 if (TREE_CODE (type) == ARRAY_TYPE
4323 && TYPE_DOMAIN (type) == NULL_TREE
4324 && TREE_CODE (decl) != TYPE_DECL)
4326 /* do_default is really a C-ism to deal with tentative definitions.
4327 But let's leave it here to ease the eventual merge. */
4328 int do_default = !DECL_EXTERNAL (decl);
4329 tree initializer = init ? init : DECL_INITIAL (decl);
4332 /* Check that there are no designated initializers in INIT, as
4333 those are not supported in GNU C++, and as the middle-end
4334 will crash if presented with a non-numeric designated
4336 if (initializer && TREE_CODE (initializer) == CONSTRUCTOR)
4338 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initializer);
4339 constructor_elt *ce;
4342 VEC_iterate (constructor_elt, v, i, ce);
4344 if (!check_array_designated_initializer (ce))
4350 failure = cp_complete_array_type (&TREE_TYPE (decl), initializer,
4354 error ("initializer fails to determine size of %qD", decl);
4355 TREE_TYPE (decl) = error_mark_node;
4357 else if (failure == 2)
4361 error ("array size missing in %qD", decl);
4362 TREE_TYPE (decl) = error_mark_node;
4364 /* If a `static' var's size isn't known, make it extern as
4365 well as static, so it does not get allocated. If it's not
4366 `static', then don't mark it extern; finish_incomplete_decl
4367 will give it a default size and it will get allocated. */
4368 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
4369 DECL_EXTERNAL (decl) = 1;
4371 else if (failure == 3)
4373 error ("zero-size array %qD", decl);
4374 TREE_TYPE (decl) = error_mark_node;
4378 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl)), decl);
4380 layout_decl (decl, 0);
4384 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
4385 any appropriate error messages regarding the layout. */
4388 layout_var_decl (tree decl)
4392 type = TREE_TYPE (decl);
4393 if (type == error_mark_node)
4396 /* If we haven't already layed out this declaration, do so now.
4397 Note that we must not call complete type for an external object
4398 because it's type might involve templates that we are not
4399 supposed to instantiate yet. (And it's perfectly valid to say
4400 `extern X x' for some incomplete type `X'.) */
4401 if (!DECL_EXTERNAL (decl))
4402 complete_type (type);
4403 if (!DECL_SIZE (decl)
4404 && TREE_TYPE (decl) != error_mark_node
4405 && (COMPLETE_TYPE_P (type)
4406 || (TREE_CODE (type) == ARRAY_TYPE
4407 && !TYPE_DOMAIN (type)
4408 && COMPLETE_TYPE_P (TREE_TYPE (type)))))
4409 layout_decl (decl, 0);
4411 if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
4413 /* An automatic variable with an incomplete type: that is an error.
4414 Don't talk about array types here, since we took care of that
4415 message in grokdeclarator. */
4416 error ("storage size of %qD isn't known", decl);
4417 TREE_TYPE (decl) = error_mark_node;
4420 /* Keep this code around in case we later want to control debug info
4421 based on whether a type is "used". (jason 1999-11-11) */
4423 else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
4424 /* Let debugger know it should output info for this type. */
4425 note_debug_info_needed (ttype);
4427 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
4428 note_debug_info_needed (DECL_CONTEXT (decl));
4431 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
4432 && DECL_SIZE (decl) != NULL_TREE
4433 && ! TREE_CONSTANT (DECL_SIZE (decl)))
4435 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
4436 constant_expression_warning (DECL_SIZE (decl));
4438 error ("storage size of %qD isn't constant", decl);
4442 /* If a local static variable is declared in an inline function, or if
4443 we have a weak definition, we must endeavor to create only one
4444 instance of the variable at link-time. */
4447 maybe_commonize_var (tree decl)
4449 /* Static data in a function with comdat linkage also has comdat
4451 if (TREE_STATIC (decl)
4452 /* Don't mess with __FUNCTION__. */
4453 && ! DECL_ARTIFICIAL (decl)
4454 && DECL_FUNCTION_SCOPE_P (decl)
4455 /* Unfortunately, import_export_decl has not always been called
4456 before the function is processed, so we cannot simply check
4458 && (DECL_COMDAT (DECL_CONTEXT (decl))
4459 || ((DECL_DECLARED_INLINE_P (DECL_CONTEXT (decl))
4460 || DECL_TEMPLATE_INSTANTIATION (DECL_CONTEXT (decl)))
4461 && TREE_PUBLIC (DECL_CONTEXT (decl)))))
4465 /* With weak symbols, we simply make the variable COMDAT;
4466 that will cause copies in multiple translations units to
4468 comdat_linkage (decl);
4472 if (DECL_INITIAL (decl) == NULL_TREE
4473 || DECL_INITIAL (decl) == error_mark_node)
4475 /* Without weak symbols, we can use COMMON to merge
4476 uninitialized variables. */
4477 TREE_PUBLIC (decl) = 1;
4478 DECL_COMMON (decl) = 1;
4482 /* While for initialized variables, we must use internal
4483 linkage -- which means that multiple copies will not
4485 TREE_PUBLIC (decl) = 0;
4486 DECL_COMMON (decl) = 0;
4487 warning (0, "sorry: semantics of inline function static "
4488 "data %q+#D are wrong (you'll wind up "
4489 "with multiple copies)", decl);
4490 warning (0, "%J you can work around this by removing "
4496 else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
4497 /* Set it up again; we might have set DECL_INITIAL since the last
4499 comdat_linkage (decl);
4502 /* Issue an error message if DECL is an uninitialized const variable. */
4505 check_for_uninitialized_const_var (tree decl)
4507 tree type = TREE_TYPE (decl);
4509 /* ``Unless explicitly declared extern, a const object does not have
4510 external linkage and must be initialized. ($8.4; $12.1)'' ARM
4512 if (TREE_CODE (decl) == VAR_DECL
4513 && TREE_CODE (type) != REFERENCE_TYPE
4514 && CP_TYPE_CONST_P (type)
4515 && !TYPE_NEEDS_CONSTRUCTING (type)
4516 && !DECL_INITIAL (decl))
4517 error ("uninitialized const %qD", decl);
4521 /* Structure holding the current initializer being processed by reshape_init.
4522 CUR is a pointer to the current element being processed, END is a pointer
4523 after the last element present in the initializer. */
4524 typedef struct reshape_iterator_t
4526 constructor_elt *cur;
4527 constructor_elt *end;
4530 static tree reshape_init_r (tree, reshape_iter *, bool);
4532 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
4533 returned is the next FIELD_DECL (possibly FIELD itself) that can be
4534 initialized. If there are no more such fields, the return value
4538 next_initializable_field (tree field)
4541 && (TREE_CODE (field) != FIELD_DECL
4542 || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
4543 || DECL_ARTIFICIAL (field)))
4544 field = TREE_CHAIN (field);
4549 /* Subroutine of reshape_init_array and reshape_init_vector, which does
4550 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
4551 INTEGER_CST representing the size of the array minus one (the maximum index),
4552 or NULL_TREE if the array was declared without specifying the size. D is
4553 the iterator within the constructor. */
4556 reshape_init_array_1 (tree elt_type, tree max_index, reshape_iter *d)
4559 bool sized_array_p = (max_index != NULL_TREE);
4560 unsigned HOST_WIDE_INT max_index_cst = 0;
4561 unsigned HOST_WIDE_INT index;
4563 /* The initializer for an array is always a CONSTRUCTOR. */
4564 new_init = build_constructor (NULL_TREE, NULL);
4568 /* Minus 1 is used for zero sized arrays. */
4569 if (integer_all_onesp (max_index))
4572 if (host_integerp (max_index, 1))
4573 max_index_cst = tree_low_cst (max_index, 1);
4574 /* sizetype is sign extended, not zero extended. */
4576 max_index_cst = tree_low_cst (fold_convert (size_type_node, max_index),
4580 /* Loop until there are no more initializers. */
4582 d->cur != d->end && (!sized_array_p || index <= max_index_cst);
4587 check_array_designated_initializer (d->cur);
4588 elt_init = reshape_init_r (elt_type, d, /*first_initializer_p=*/false);
4589 if (elt_init == error_mark_node)
4590 return error_mark_node;
4591 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), NULL_TREE, elt_init);
4597 /* Subroutine of reshape_init_r, processes the initializers for arrays.
4598 Parameters are the same of reshape_init_r. */
4601 reshape_init_array (tree type, reshape_iter *d)
4603 tree max_index = NULL_TREE;
4605 gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
4607 if (TYPE_DOMAIN (type))
4608 max_index = array_type_nelts (type);
4610 return reshape_init_array_1 (TREE_TYPE (type), max_index, d);
4613 /* Subroutine of reshape_init_r, processes the initializers for vectors.
4614 Parameters are the same of reshape_init_r. */
4617 reshape_init_vector (tree type, reshape_iter *d)
4619 tree max_index = NULL_TREE;
4622 gcc_assert (TREE_CODE (type) == VECTOR_TYPE);
4624 if (COMPOUND_LITERAL_P (d->cur->value))
4626 tree value = d->cur->value;
4627 if (!same_type_p (TREE_TYPE (value), type))
4629 error ("invalid type %qT as initializer for a vector of type %qT",
4630 TREE_TYPE (d->cur->value), type);
4631 value = error_mark_node;
4637 /* For a vector, the representation type is a struct
4638 containing a single member which is an array of the
4639 appropriate size. */
4640 rtype = TYPE_DEBUG_REPRESENTATION_TYPE (type);
4641 if (rtype && TYPE_DOMAIN (TREE_TYPE (TYPE_FIELDS (rtype))))
4642 max_index = array_type_nelts (TREE_TYPE (TYPE_FIELDS (rtype)));
4644 return reshape_init_array_1 (TREE_TYPE (type), max_index, d);
4647 /* Subroutine of reshape_init_r, processes the initializers for classes
4648 or union. Parameters are the same of reshape_init_r. */
4651 reshape_init_class (tree type, reshape_iter *d, bool first_initializer_p)
4656 gcc_assert (CLASS_TYPE_P (type));
4658 /* The initializer for a class is always a CONSTRUCTOR. */
4659 new_init = build_constructor (NULL_TREE, NULL);
4660 field = next_initializable_field (TYPE_FIELDS (type));
4666 An initializer for an aggregate member that is an
4667 empty class shall have the form of an empty
4668 initializer-list {}. */
4669 if (!first_initializer_p)
4671 error ("initializer for %qT must be brace-enclosed", type);
4672 return error_mark_node;
4677 /* Loop through the initializable fields, gathering initializers. */
4678 while (d->cur != d->end)
4682 /* Handle designated initializers, as an extension. */
4685 field = lookup_field_1 (type, d->cur->index, /*want_type=*/false);
4687 if (!field || TREE_CODE (field) != FIELD_DECL)
4689 error ("%qT has no non-static data member named %qD", type,
4691 return error_mark_node;
4695 /* If we processed all the member of the class, we are done. */
4699 field_init = reshape_init_r (TREE_TYPE (field), d,
4700 /*first_initializer_p=*/false);
4701 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), field, field_init);
4705 When a union is initialized with a brace-enclosed
4706 initializer, the braces shall only contain an
4707 initializer for the first member of the union. */
4708 if (TREE_CODE (type) == UNION_TYPE)
4711 field = next_initializable_field (TREE_CHAIN (field));
4717 /* Subroutine of reshape_init, which processes a single initializer (part of
4718 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
4719 iterator within the CONSTRUCTOR which points to the initializer to process.
4720 FIRST_INITIALIZER_P is true if this is the first initializer of the
4721 CONSTRUCTOR node. */
4724 reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p)
4726 tree init = d->cur->value;
4728 /* A non-aggregate type is always initialized with a single
4730 if (!CP_AGGREGATE_TYPE_P (type))
4732 /* It is invalid to initialize a non-aggregate type with a
4733 brace-enclosed initializer.
4734 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
4735 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
4736 a CONSTRUCTOR (with a record type). */
4737 if (TREE_CODE (init) == CONSTRUCTOR
4738 && BRACE_ENCLOSED_INITIALIZER_P (init)) /* p7626.C */
4740 error ("braces around scalar initializer for type %qT", type);
4741 init = error_mark_node;
4750 All implicit type conversions (clause _conv_) are considered when
4751 initializing the aggregate member with an initializer from an
4752 initializer-list. If the initializer can initialize a member,
4753 the member is initialized. Otherwise, if the member is itself a
4754 non-empty subaggregate, brace elision is assumed and the
4755 initializer is considered for the initialization of the first
4756 member of the subaggregate. */
4757 if (TREE_CODE (init) != CONSTRUCTOR
4758 && can_convert_arg (type, TREE_TYPE (init), init, LOOKUP_NORMAL))
4764 /* [dcl.init.string]
4766 A char array (whether plain char, signed char, or unsigned char)
4767 can be initialized by a string-literal (optionally enclosed in
4768 braces); a wchar_t array can be initialized by a wide
4769 string-literal (optionally enclosed in braces). */
4770 if (TREE_CODE (type) == ARRAY_TYPE
4771 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
4773 tree str_init = init;
4775 /* Strip one level of braces if and only if they enclose a single
4776 element (as allowed by [dcl.init.string]). */
4777 if (!first_initializer_p
4778 && TREE_CODE (str_init) == CONSTRUCTOR
4779 && VEC_length (constructor_elt, CONSTRUCTOR_ELTS (str_init)) == 1)
4781 str_init = VEC_index (constructor_elt,
4782 CONSTRUCTOR_ELTS (str_init), 0)->value;
4785 /* If it's a string literal, then it's the initializer for the array
4786 as a whole. Otherwise, continue with normal initialization for
4787 array types (one value per array element). */
4788 if (TREE_CODE (str_init) == STRING_CST)
4795 /* The following cases are about aggregates. If we are not within a full
4796 initializer already, and there is not a CONSTRUCTOR, it means that there
4797 is a missing set of braces (that is, we are processing the case for
4798 which reshape_init exists). */
4799 if (!first_initializer_p)
4801 if (TREE_CODE (init) == CONSTRUCTOR)
4803 if (TREE_TYPE (init) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init)))
4804 /* There is no need to reshape pointer-to-member function
4805 initializers, as they are always constructed correctly
4806 by the front end. */
4808 else if (COMPOUND_LITERAL_P (init))
4809 /* For a nested compound literal, there is no need to reshape since
4810 brace elision is not allowed. Even if we decided to allow it,
4811 we should add a call to reshape_init in finish_compound_literal,
4812 before calling digest_init, so changing this code would still
4813 not be necessary. */
4814 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init));
4818 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
4819 return reshape_init (type, init);
4823 warning (OPT_Wmissing_braces, "missing braces around initializer for %qT",
4827 /* Dispatch to specialized routines. */
4828 if (CLASS_TYPE_P (type))
4829 return reshape_init_class (type, d, first_initializer_p);
4830 else if (TREE_CODE (type) == ARRAY_TYPE)
4831 return reshape_init_array (type, d);
4832 else if (TREE_CODE (type) == VECTOR_TYPE)
4833 return reshape_init_vector (type, d);
4838 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
4839 brace-enclosed aggregate initializer.
4841 INIT is the CONSTRUCTOR containing the list of initializers describing
4842 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
4843 It may not presently match the shape of the TYPE; for example:
4845 struct S { int a; int b; };
4846 struct S a[] = { 1, 2, 3, 4 };
4848 Here INIT will hold a VEC of four elements, rather than a
4849 VEC of two elements, each itself a VEC of two elements. This
4850 routine transforms INIT from the former form into the latter. The
4851 revised CONSTRUCTOR node is returned. */
4854 reshape_init (tree type, tree init)
4856 VEC(constructor_elt, gc) *v;
4860 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
4862 v = CONSTRUCTOR_ELTS (init);
4864 /* An empty constructor does not need reshaping, and it is always a valid
4866 if (VEC_empty (constructor_elt, v))
4869 /* Recurse on this CONSTRUCTOR. */
4870 d.cur = VEC_index (constructor_elt, v, 0);
4871 d.end = d.cur + VEC_length (constructor_elt, v);
4873 new_init = reshape_init_r (type, &d, true);
4874 if (new_init == error_mark_node)
4875 return error_mark_node;
4877 /* Make sure all the element of the constructor were used. Otherwise,
4878 issue an error about exceeding initializers. */
4880 error ("too many initializers for %qT", type);
4885 /* Verify INIT (the initializer for DECL), and record the
4886 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
4887 grok_reference_init.
4889 If the return value is non-NULL, it is an expression that must be
4890 evaluated dynamically to initialize DECL. */
4893 check_initializer (tree decl, tree init, int flags, tree *cleanup)
4895 tree type = TREE_TYPE (decl);
4896 tree init_code = NULL;
4898 /* Things that are going to be initialized need to have complete
4900 TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
4902 if (type == error_mark_node)
4903 /* We will have already complained. */
4906 if (TREE_CODE (type) == ARRAY_TYPE)
4908 tree element_type = TREE_TYPE (type);
4910 /* The array type itself need not be complete, because the
4911 initializer may tell us how many elements are in the array.
4912 But, the elements of the array must be complete. */
4913 if (!COMPLETE_TYPE_P (complete_type (element_type)))
4915 error ("elements of array %q#D have incomplete type", decl);
4918 /* It is not valid to initialize a VLA. */
4920 && ((COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
4921 || !TREE_CONSTANT (TYPE_SIZE (element_type))))
4923 error ("variable-sized object %qD may not be initialized", decl);
4927 else if (!COMPLETE_TYPE_P (type))
4929 error ("%qD has incomplete type", decl);
4930 TREE_TYPE (decl) = error_mark_node;
4934 /* There is no way to make a variable-sized class type in GNU C++. */
4935 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type)));
4937 if (init && BRACE_ENCLOSED_INITIALIZER_P (init))
4939 int init_len = VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init));
4940 if (SCALAR_TYPE_P (type))
4944 error ("scalar object %qD requires one element in initializer",
4946 TREE_TYPE (decl) = error_mark_node;
4950 else if ((cxx_dialect == cxx98) && !CP_AGGREGATE_TYPE_P (type))
4952 /* A non-aggregate that is not a scalar cannot be initialized
4953 via an initializer-list in C++98. */
4954 error ("braces around initializer for non-aggregate type %qT",
4956 TREE_TYPE (decl) = error_mark_node;
4961 if (TREE_CODE (decl) == CONST_DECL)
4963 gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);
4965 DECL_INITIAL (decl) = init;
4967 gcc_assert (init != NULL_TREE);
4970 else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
4971 init = grok_reference_init (decl, type, init, cleanup);
4974 /* Do not reshape constructors of vectors (they don't need to be
4976 if (TREE_CODE (init) == CONSTRUCTOR
4977 && !COMPOUND_LITERAL_P (init)
4978 && !TREE_TYPE (init)) /* ptrmemfunc */
4980 init = reshape_init (type, init);
4982 if ((*targetm.vector_opaque_p) (type))
4984 error ("opaque vector types cannot be initialized");
4985 init = error_mark_node;
4989 /* If DECL has an array type without a specific bound, deduce the
4990 array size from the initializer. */
4991 maybe_deduce_size_from_array_init (decl, init);
4992 type = TREE_TYPE (decl);
4993 if (type == error_mark_node)
4996 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_NEEDS_CONSTRUCTING (type))
4997 goto initialize_aggr;
4998 else if (CLASS_TYPE_P (type))
5000 if (TREE_CODE (init) == CONSTRUCTOR)
5002 if (TYPE_NON_AGGREGATE_CLASS (type))
5004 error ("%qD must be initialized by constructor, "
5007 init = error_mark_node;
5010 goto dont_use_constructor;
5014 int saved_stmts_are_full_exprs_p;
5017 saved_stmts_are_full_exprs_p = 0;
5018 if (building_stmt_tree ())
5020 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
5021 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
5023 init = build_aggr_init (decl, init, flags);
5024 if (building_stmt_tree ())
5025 current_stmt_tree ()->stmts_are_full_exprs_p =
5026 saved_stmts_are_full_exprs_p;
5032 dont_use_constructor:
5033 if (TREE_CODE (init) != TREE_VEC)
5035 init_code = store_init_value (decl, init);
5036 if (pedantic && TREE_CODE (type) == ARRAY_TYPE
5037 && DECL_INITIAL (decl)
5038 && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST
5039 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl)))
5040 warning (0, "array %qD initialized by parenthesized string literal %qE",
5041 decl, DECL_INITIAL (decl));
5046 else if (DECL_EXTERNAL (decl))
5048 else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
5049 goto initialize_aggr;
5050 else if (IS_AGGR_TYPE (type))
5052 tree core_type = strip_array_types (type);
5054 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
5055 error ("structure %qD with uninitialized const members", decl);
5056 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
5057 error ("structure %qD with uninitialized reference members", decl);
5059 check_for_uninitialized_const_var (decl);
5062 check_for_uninitialized_const_var (decl);
5064 if (init && init != error_mark_node)
5065 init_code = build2 (INIT_EXPR, type, decl, init);
5070 /* If DECL is not a local variable, give it RTL. */
5073 make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
5075 int toplev = toplevel_bindings_p ();
5077 const char *filename;
5079 /* Set the DECL_ASSEMBLER_NAME for the object. */
5082 /* The `register' keyword, when used together with an
5083 asm-specification, indicates that the variable should be
5084 placed in a particular register. */
5085 if (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
5087 set_user_assembler_name (decl, asmspec);
5088 DECL_HARD_REGISTER (decl) = 1;
5092 if (TREE_CODE (decl) == FUNCTION_DECL
5093 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
5094 set_builtin_user_assembler_name (decl, asmspec);
5095 set_user_assembler_name (decl, asmspec);
5099 /* Handle non-variables up front. */
5100 if (TREE_CODE (decl) != VAR_DECL)
5102 rest_of_decl_compilation (decl, toplev, at_eof);
5106 /* If we see a class member here, it should be a static data
5108 if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
5110 gcc_assert (TREE_STATIC (decl));
5111 /* An in-class declaration of a static data member should be
5112 external; it is only a declaration, and not a definition. */
5113 if (init == NULL_TREE)
5114 gcc_assert (DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl));
5117 /* We don't create any RTL for local variables. */
5118 if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
5121 /* We defer emission of local statics until the corresponding
5122 DECL_EXPR is expanded. */
5123 defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
5125 /* We try to defer namespace-scope static constants so that they are
5126 not emitted into the object file unnecessarily. */
5127 filename = input_filename;
5128 if (!DECL_VIRTUAL_P (decl)
5129 && TREE_READONLY (decl)
5130 && DECL_INITIAL (decl) != NULL_TREE
5131 && DECL_INITIAL (decl) != error_mark_node
5133 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
5135 && !TREE_PUBLIC (decl))
5137 /* Fool with the linkage of static consts according to #pragma
5139 struct c_fileinfo *finfo = get_fileinfo (filename);
5140 if (!finfo->interface_unknown && !TREE_PUBLIC (decl))
5142 TREE_PUBLIC (decl) = 1;
5143 DECL_EXTERNAL (decl) = finfo->interface_only;
5148 /* Likewise for template instantiations. */
5149 else if (DECL_LANG_SPECIFIC (decl)
5150 && DECL_IMPLICIT_INSTANTIATION (decl))
5153 /* If we're not deferring, go ahead and assemble the variable. */
5155 rest_of_decl_compilation (decl, toplev, at_eof);
5158 /* walk_tree helper for wrap_temporary_cleanups, below. */
5161 wrap_cleanups_r (tree *stmt_p, int *walk_subtrees, void *data)
5163 if (TYPE_P (*stmt_p))
5169 if (TREE_CODE (*stmt_p) == TARGET_EXPR)
5171 tree guard = (tree)data;
5172 tree tcleanup = TARGET_EXPR_CLEANUP (*stmt_p);
5174 tcleanup = build2 (TRY_CATCH_EXPR, void_type_node, tcleanup, guard);
5175 /* Tell honor_protect_cleanup_actions to handle this as a separate
5177 TRY_CATCH_IS_CLEANUP (tcleanup) = 1;
5179 TARGET_EXPR_CLEANUP (*stmt_p) = tcleanup;
5185 /* We're initializing a local variable which has a cleanup GUARD. If there
5186 are any temporaries used in the initializer INIT of this variable, we
5187 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
5188 variable will be cleaned up properly if one of them throws.
5190 Unfortunately, there's no way to express this properly in terms of
5191 nesting, as the regions for the temporaries overlap the region for the
5192 variable itself; if there are two temporaries, the variable needs to be
5193 the first thing destroyed if either of them throws. However, we only
5194 want to run the variable's cleanup if it actually got constructed. So
5195 we need to guard the temporary cleanups with the variable's cleanup if
5196 they are run on the normal path, but not if they are run on the
5197 exceptional path. We implement this by telling
5198 honor_protect_cleanup_actions to strip the variable cleanup from the
5199 exceptional path. */
5202 wrap_temporary_cleanups (tree init, tree guard)
5204 cp_walk_tree_without_duplicates (&init, wrap_cleanups_r, (void *)guard);
5207 /* Generate code to initialize DECL (a local variable). */
5210 initialize_local_var (tree decl, tree init)
5212 tree type = TREE_TYPE (decl);
5216 gcc_assert (TREE_CODE (decl) == VAR_DECL
5217 || TREE_CODE (decl) == RESULT_DECL);
5218 gcc_assert (!TREE_STATIC (decl));
5220 if (DECL_SIZE (decl) == NULL_TREE)
5222 /* If we used it already as memory, it must stay in memory. */
5223 DECL_INITIAL (decl) = NULL_TREE;
5224 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
5228 if (type == error_mark_node)
5231 /* Compute and store the initial value. */
5232 already_used = TREE_USED (decl) || TREE_USED (type);
5234 /* Generate a cleanup, if necessary. */
5235 cleanup = cxx_maybe_build_cleanup (decl);
5237 /* Perform the initialization. */
5240 int saved_stmts_are_full_exprs_p;
5242 /* If we're only initializing a single object, guard the destructors
5243 of any temporaries used in its initializer with its destructor.
5244 This isn't right for arrays because each element initialization is
5245 a full-expression. */
5246 if (cleanup && TREE_CODE (type) != ARRAY_TYPE)
5247 wrap_temporary_cleanups (init, cleanup);
5249 gcc_assert (building_stmt_tree ());
5250 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
5251 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
5252 finish_expr_stmt (init);
5253 current_stmt_tree ()->stmts_are_full_exprs_p =
5254 saved_stmts_are_full_exprs_p;
5257 /* Set this to 0 so we can tell whether an aggregate which was
5258 initialized was ever used. Don't do this if it has a
5259 destructor, so we don't complain about the 'resource
5260 allocation is initialization' idiom. Now set
5261 attribute((unused)) on types so decls of that type will be
5262 marked used. (see TREE_USED, above.) */
5263 if (TYPE_NEEDS_CONSTRUCTING (type)
5265 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
5266 && DECL_NAME (decl))
5267 TREE_USED (decl) = 0;
5268 else if (already_used)
5269 TREE_USED (decl) = 1;
5272 finish_decl_cleanup (decl, cleanup);
5275 /* DECL is a VAR_DECL for a compiler-generated variable with static
5276 storage duration (like a virtual table) whose initializer is a
5277 compile-time constant. INIT must be either a TREE_LIST of values,
5278 or a CONSTRUCTOR. Initialize the variable and provide it to the
5282 initialize_artificial_var (tree decl, tree init)
5284 gcc_assert (DECL_ARTIFICIAL (decl));
5285 if (TREE_CODE (init) == TREE_LIST)
5286 init = build_constructor_from_list (NULL_TREE, init);
5287 gcc_assert (TREE_CODE (init) == CONSTRUCTOR);
5288 DECL_INITIAL (decl) = init;
5289 DECL_INITIALIZED_P (decl) = 1;
5290 determine_visibility (decl);
5291 layout_var_decl (decl);
5292 maybe_commonize_var (decl);
5293 make_rtl_for_nonlocal_decl (decl, init, /*asmspec=*/NULL);
5296 /* INIT is the initializer for a variable, as represented by the
5297 parser. Returns true iff INIT is value-dependent. */
5300 value_dependent_init_p (tree init)
5302 if (TREE_CODE (init) == TREE_LIST)
5303 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
5304 return any_value_dependent_elements_p (init);
5305 else if (TREE_CODE (init) == CONSTRUCTOR)
5306 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
5308 VEC(constructor_elt, gc) *elts;
5312 elts = CONSTRUCTOR_ELTS (init);
5313 nelts = VEC_length (constructor_elt, elts);
5314 for (i = 0; i < nelts; ++i)
5315 if (value_dependent_init_p (VEC_index (constructor_elt,
5320 /* It must be a simple expression, e.g., int i = 3; */
5321 return value_dependent_expression_p (init);
5326 /* Finish processing of a declaration;
5327 install its line number and initial value.
5328 If the length of an array type is not known before,
5329 it must be determined now, from the initial value, or it is an error.
5331 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
5332 true, then INIT is an integral constant expression.
5334 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
5335 if the (init) syntax was used. */
5338 cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
5339 tree asmspec_tree, int flags)
5343 const char *asmspec = NULL;
5344 int was_readonly = 0;
5345 bool var_definition_p = false;
5346 int saved_processing_template_decl;
5348 if (decl == error_mark_node)
5353 error ("assignment (not initialization) in declaration");
5357 gcc_assert (TREE_CODE (decl) != RESULT_DECL);
5358 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
5359 gcc_assert (TREE_CODE (decl) != PARM_DECL);
5361 type = TREE_TYPE (decl);
5362 if (type == error_mark_node)
5365 /* Assume no cleanup is required. */
5366 cleanup = NULL_TREE;
5367 saved_processing_template_decl = processing_template_decl;
5369 /* If a name was specified, get the string. */
5370 if (global_scope_p (current_binding_level))
5371 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
5372 if (asmspec_tree && asmspec_tree != error_mark_node)
5373 asmspec = TREE_STRING_POINTER (asmspec_tree);
5375 if (current_class_type
5376 && CP_DECL_CONTEXT (decl) == current_class_type
5377 && TYPE_BEING_DEFINED (current_class_type)
5378 && (DECL_INITIAL (decl) || init))
5379 DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
5381 if (processing_template_decl)
5383 bool type_dependent_p;
5385 /* Add this declaration to the statement-tree. */
5386 if (at_function_scope_p ())
5387 add_decl_expr (decl);
5389 type_dependent_p = dependent_type_p (type);
5391 if (check_for_bare_parameter_packs (init))
5394 DECL_INITIAL (decl) = NULL_TREE;
5397 if (init && init_const_expr_p)
5399 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
5400 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl))
5401 TREE_CONSTANT (decl) = 1;
5404 /* Generally, initializers in templates are expanded when the
5405 template is instantiated. But, if DECL is an integral
5406 constant static data member, then it can be used in future
5407 integral constant expressions, and its value must be
5410 && DECL_CLASS_SCOPE_P (decl)
5411 && DECL_INTEGRAL_CONSTANT_VAR_P (decl)
5412 && !type_dependent_p
5413 && !value_dependent_init_p (init)))
5416 DECL_INITIAL (decl) = init;
5417 if (TREE_CODE (decl) == VAR_DECL
5418 && !DECL_PRETTY_FUNCTION_P (decl)
5419 && !type_dependent_p)
5420 maybe_deduce_size_from_array_init (decl, init);
5424 if (TREE_CODE (init) == TREE_LIST)
5426 /* If the parenthesized-initializer form was used (e.g.,
5427 "int A<N>::i(X)"), then INIT will be a TREE_LIST of initializer
5428 arguments. (There is generally only one.) We convert them
5431 for (; list; list = TREE_CHAIN (list))
5433 tree elt = TREE_VALUE (list);
5434 TREE_VALUE (list) = fold_non_dependent_expr (elt);
5438 init = fold_non_dependent_expr (init);
5439 processing_template_decl = 0;
5442 /* Take care of TYPE_DECLs up front. */
5443 if (TREE_CODE (decl) == TYPE_DECL)
5445 if (type != error_mark_node
5446 && IS_AGGR_TYPE (type) && DECL_NAME (decl))
5448 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
5449 warning (0, "shadowing previous type declaration of %q#D", decl);
5450 set_identifier_type_value (DECL_NAME (decl), decl);
5453 /* If we have installed this as the canonical typedef for this
5454 type, and that type has not been defined yet, delay emitting
5455 the debug information for it, as we will emit it later. */
5456 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
5457 && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
5458 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
5460 rest_of_decl_compilation (decl, DECL_CONTEXT (decl) == NULL_TREE,
5465 /* A reference will be modified here, as it is initialized. */
5466 if (! DECL_EXTERNAL (decl)
5467 && TREE_READONLY (decl)
5468 && TREE_CODE (type) == REFERENCE_TYPE)
5471 TREE_READONLY (decl) = 0;
5474 if (TREE_CODE (decl) == VAR_DECL)
5476 /* Only PODs can have thread-local storage. Other types may require
5477 various kinds of non-trivial initialization. */
5478 if (DECL_THREAD_LOCAL_P (decl) && !pod_type_p (TREE_TYPE (decl)))
5479 error ("%qD cannot be thread-local because it has non-POD type %qT",
5480 decl, TREE_TYPE (decl));
5481 /* If this is a local variable that will need a mangled name,
5482 register it now. We must do this before processing the
5483 initializer for the variable, since the initialization might
5484 require a guard variable, and since the mangled name of the
5485 guard variable will depend on the mangled name of this
5487 if (DECL_FUNCTION_SCOPE_P (decl)
5488 && TREE_STATIC (decl)
5489 && !DECL_ARTIFICIAL (decl))
5490 push_local_name (decl);
5491 /* Convert the initializer to the type of DECL, if we have not
5492 already initialized DECL. */
5493 if (!DECL_INITIALIZED_P (decl)
5494 /* If !DECL_EXTERNAL then DECL is being defined. In the
5495 case of a static data member initialized inside the
5496 class-specifier, there can be an initializer even if DECL
5497 is *not* defined. */
5498 && (!DECL_EXTERNAL (decl) || init))
5500 if (TYPE_FOR_JAVA (type) && IS_AGGR_TYPE (type))
5503 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
5504 /* Allow libjava/prims.cc define primitive classes. */
5505 if (init != NULL_TREE
5506 || jclass == NULL_TREE
5507 || TREE_CODE (jclass) != TYPE_DECL
5508 || !POINTER_TYPE_P (TREE_TYPE (jclass))
5509 || !same_type_ignoring_top_level_qualifiers_p
5510 (type, TREE_TYPE (TREE_TYPE (jclass))))
5511 error ("Java object %qD not allocated with %<new%>", decl);
5516 DECL_NONTRIVIALLY_INITIALIZED_P (decl) = 1;
5517 if (init_const_expr_p)
5519 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
5520 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl))
5521 TREE_CONSTANT (decl) = 1;
5524 init = check_initializer (decl, init, flags, &cleanup);
5525 /* Thread-local storage cannot be dynamically initialized. */
5526 if (DECL_THREAD_LOCAL_P (decl) && init)
5528 error ("%qD is thread-local and so cannot be dynamically "
5529 "initialized", decl);
5533 /* Check that the initializer for a static data member was a
5534 constant. Although we check in the parser that the
5535 initializer is an integral constant expression, we do not
5536 simplify division-by-zero at the point at which it
5537 occurs. Therefore, in:
5539 struct S { static const int i = 7 / 0; };
5541 we issue an error at this point. It would
5542 probably be better to forbid division by zero in
5543 integral constant expressions. */
5544 if (DECL_EXTERNAL (decl) && init)
5546 error ("%qD cannot be initialized by a non-constant expression"
5547 " when being declared", decl);
5548 DECL_INITIALIZED_IN_CLASS_P (decl) = 0;
5556 The memory occupied by any object of static storage
5557 duration is zero-initialized at program startup before
5558 any other initialization takes place.
5560 We cannot create an appropriate initializer until after
5561 the type of DECL is finalized. If DECL_INITIAL is set,
5562 then the DECL is statically initialized, and any
5563 necessary zero-initialization has already been performed. */
5564 if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
5565 DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
5566 /*nelts=*/NULL_TREE,
5567 /*static_storage_p=*/true);
5568 /* Remember that the initialization for this variable has
5570 DECL_INITIALIZED_P (decl) = 1;
5571 /* This declaration is the definition of this variable,
5572 unless we are initializing a static data member within
5573 the class specifier. */
5574 if (!DECL_EXTERNAL (decl))
5575 var_definition_p = true;
5577 /* If the variable has an array type, lay out the type, even if
5578 there is no initializer. It is valid to index through the
5579 array, and we must get TYPE_ALIGN set correctly on the array
5581 else if (TREE_CODE (type) == ARRAY_TYPE)
5584 else if (TREE_CODE (decl) == FIELD_DECL
5585 && TYPE_FOR_JAVA (type) && IS_AGGR_TYPE (type))
5586 error ("non-static data member %qD has Java class type", decl);
5588 /* Add this declaration to the statement-tree. This needs to happen
5589 after the call to check_initializer so that the DECL_EXPR for a
5590 reference temp is added before the DECL_EXPR for the reference itself. */
5591 if (at_function_scope_p ())
5592 add_decl_expr (decl);
5594 /* Let the middle end know about variables and functions -- but not
5595 static data members in uninstantiated class templates. */
5596 if (!saved_processing_template_decl
5597 && (TREE_CODE (decl) == VAR_DECL
5598 || TREE_CODE (decl) == FUNCTION_DECL))
5600 if (TREE_CODE (decl) == VAR_DECL)
5602 layout_var_decl (decl);
5603 maybe_commonize_var (decl);
5606 /* This needs to happen after the linkage is set. */
5607 determine_visibility (decl);
5609 if (var_definition_p && TREE_STATIC (decl))
5611 /* If a TREE_READONLY variable needs initialization
5612 at runtime, it is no longer readonly and we need to
5613 avoid MEM_READONLY_P being set on RTL created for it. */
5616 if (TREE_READONLY (decl))
5617 TREE_READONLY (decl) = 0;
5620 else if (was_readonly)
5621 TREE_READONLY (decl) = 1;
5624 make_rtl_for_nonlocal_decl (decl, init, asmspec);
5626 /* Check for abstractness of the type. Notice that there is no
5627 need to strip array types here since the check for those types
5628 is already done within create_array_type_for_decl. */
5629 if (TREE_CODE (type) == FUNCTION_TYPE
5630 || TREE_CODE (type) == METHOD_TYPE)
5631 abstract_virtuals_error (decl, TREE_TYPE (type));
5633 abstract_virtuals_error (decl, type);
5635 if (TREE_CODE (decl) == FUNCTION_DECL
5636 || TREE_TYPE (decl) == error_mark_node)
5637 /* No initialization required. */
5639 else if (DECL_EXTERNAL (decl)
5640 && ! (DECL_LANG_SPECIFIC (decl)
5641 && DECL_NOT_REALLY_EXTERN (decl)))
5644 DECL_INITIAL (decl) = init;
5646 /* A variable definition. */
5647 else if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
5648 /* Initialize the local variable. */
5649 initialize_local_var (decl, init);
5651 /* If a variable is defined, and then a subsequent
5652 definition with external linkage is encountered, we will
5653 get here twice for the same variable. We want to avoid
5654 calling expand_static_init more than once. For variables
5655 that are not static data members, we can call
5656 expand_static_init only when we actually process the
5657 initializer. It is not legal to redeclare a static data
5658 member, so this issue does not arise in that case. */
5659 else if (var_definition_p && TREE_STATIC (decl))
5660 expand_static_init (decl, init);
5663 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
5664 reference, insert it in the statement-tree now. */
5666 push_cleanup (decl, cleanup, false);
5669 processing_template_decl = saved_processing_template_decl;
5672 TREE_READONLY (decl) = 1;
5674 /* If this was marked 'used', be sure it will be output. */
5675 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
5676 mark_decl_referenced (decl);
5679 /* This is here for a midend callback from c-common.c. */
5682 finish_decl (tree decl, tree init, tree asmspec_tree)
5684 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, asmspec_tree, 0);
5687 /* Returns a declaration for a VAR_DECL as if:
5689 extern "C" TYPE NAME;
5691 had been seen. Used to create compiler-generated global
5695 declare_global_var (tree name, tree type)
5699 push_to_top_level ();
5700 decl = build_decl (VAR_DECL, name, type);
5701 TREE_PUBLIC (decl) = 1;
5702 DECL_EXTERNAL (decl) = 1;
5703 DECL_ARTIFICIAL (decl) = 1;
5704 /* If the user has explicitly declared this variable (perhaps
5705 because the code we are compiling is part of a low-level runtime
5706 library), then it is possible that our declaration will be merged
5707 with theirs by pushdecl. */
5708 decl = pushdecl (decl);
5709 finish_decl (decl, NULL_TREE, NULL_TREE);
5710 pop_from_top_level ();
5715 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
5716 if "__cxa_atexit" is not being used) corresponding to the function
5717 to be called when the program exits. */
5720 get_atexit_fn_ptr_type (void)
5725 if (!atexit_fn_ptr_type_node)
5727 if (flag_use_cxa_atexit
5728 && !targetm.cxx.use_atexit_for_cxa_atexit ())
5729 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
5730 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5732 /* The parameter to "atexit" is "void (*)(void)". */
5733 arg_types = void_list_node;
5735 fn_type = build_function_type (void_type_node, arg_types);
5736 atexit_fn_ptr_type_node = build_pointer_type (fn_type);
5739 return atexit_fn_ptr_type_node;
5742 /* Returns a pointer to the `atexit' function. Note that if
5743 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
5744 `__cxa_atexit' function specified in the IA64 C++ ABI. */
5747 get_atexit_node (void)
5754 bool use_aeabi_atexit;
5759 if (flag_use_cxa_atexit && !targetm.cxx.use_atexit_for_cxa_atexit ())
5761 /* The declaration for `__cxa_atexit' is:
5763 int __cxa_atexit (void (*)(void *), void *, void *)
5765 We build up the argument types and then then function type
5768 use_aeabi_atexit = targetm.cxx.use_aeabi_atexit ();
5769 /* First, build the pointer-to-function type for the first
5771 fn_ptr_type = get_atexit_fn_ptr_type ();
5772 /* Then, build the rest of the argument types. */
5773 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5774 if (use_aeabi_atexit)
5776 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
5777 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
5781 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
5782 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
5784 /* And the final __cxa_atexit type. */
5785 fn_type = build_function_type (integer_type_node, arg_types);
5786 fn_ptr_type = build_pointer_type (fn_type);
5787 if (use_aeabi_atexit)
5788 name = "__aeabi_atexit";
5790 name = "__cxa_atexit";
5794 /* The declaration for `atexit' is:
5796 int atexit (void (*)());
5798 We build up the argument types and then then function type
5800 fn_ptr_type = get_atexit_fn_ptr_type ();
5801 arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
5802 /* Build the final atexit type. */
5803 fn_type = build_function_type (integer_type_node, arg_types);
5807 /* Now, build the function declaration. */
5808 push_lang_context (lang_name_c);
5809 atexit_fndecl = build_library_fn_ptr (name, fn_type);
5810 mark_used (atexit_fndecl);
5811 pop_lang_context ();
5812 atexit_node = decay_conversion (atexit_fndecl);
5817 /* Returns the __dso_handle VAR_DECL. */
5820 get_dso_handle_node (void)
5822 if (dso_handle_node)
5823 return dso_handle_node;
5825 /* Declare the variable. */
5826 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
5829 return dso_handle_node;
5832 /* Begin a new function with internal linkage whose job will be simply
5833 to destroy some particular variable. */
5835 static GTY(()) int start_cleanup_cnt;
5838 start_cleanup_fn (void)
5843 bool use_cxa_atexit = flag_use_cxa_atexit
5844 && !targetm.cxx.use_atexit_for_cxa_atexit ();
5846 push_to_top_level ();
5848 /* No need to mangle this. */
5849 push_lang_context (lang_name_c);
5851 /* Build the name of the function. */
5852 sprintf (name, "__tcf_%d", start_cleanup_cnt++);
5853 /* Build the function declaration. */
5854 fntype = TREE_TYPE (get_atexit_fn_ptr_type ());
5855 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
5856 /* It's a function with internal linkage, generated by the
5858 TREE_PUBLIC (fndecl) = 0;
5859 DECL_ARTIFICIAL (fndecl) = 1;
5860 /* Make the function `inline' so that it is only emitted if it is
5861 actually needed. It is unlikely that it will be inlined, since
5862 it is only called via a function pointer, but we avoid unnecessary
5863 emissions this way. */
5864 DECL_INLINE (fndecl) = 1;
5865 DECL_DECLARED_INLINE_P (fndecl) = 1;
5866 DECL_INTERFACE_KNOWN (fndecl) = 1;
5867 /* Build the parameter. */
5872 parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
5873 DECL_CONTEXT (parmdecl) = fndecl;
5874 TREE_USED (parmdecl) = 1;
5875 DECL_ARGUMENTS (fndecl) = parmdecl;
5879 start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED);
5881 pop_lang_context ();
5883 return current_function_decl;
5886 /* Finish the cleanup function begun by start_cleanup_fn. */
5889 end_cleanup_fn (void)
5891 expand_or_defer_fn (finish_function (0));
5893 pop_from_top_level ();
5896 /* Generate code to handle the destruction of DECL, an object with
5897 static storage duration. */
5900 register_dtor_fn (tree decl)
5909 type = TREE_TYPE (decl);
5910 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
5911 return void_zero_node;
5913 /* If we're using "__cxa_atexit" (or "__aeabi_atexit"), and DECL is
5914 a class object, we can just pass the destructor to
5915 "__cxa_atexit"; we don't have to build a temporary function to do
5917 use_dtor = (flag_use_cxa_atexit
5918 && !targetm.cxx.use_atexit_for_cxa_atexit ()
5919 && CLASS_TYPE_P (type));
5924 /* Find the destructor. */
5925 idx = lookup_fnfields_1 (type, complete_dtor_identifier);
5926 gcc_assert (idx >= 0);
5927 cleanup = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), idx);
5928 /* Make sure it is accessible. */
5929 perform_or_defer_access_check (TYPE_BINFO (type), cleanup, cleanup);
5933 /* Call build_cleanup before we enter the anonymous function so
5934 that any access checks will be done relative to the current
5935 scope, rather than the scope of the anonymous function. */
5936 build_cleanup (decl);
5938 /* Now start the function. */
5939 cleanup = start_cleanup_fn ();
5941 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
5942 to the original function, rather than the anonymous one. That
5943 will make the back end think that nested functions are in use,
5944 which causes confusion. */
5945 push_deferring_access_checks (dk_no_check);
5946 fcall = build_cleanup (decl);
5947 pop_deferring_access_checks ();
5949 /* Create the body of the anonymous function. */
5950 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
5951 finish_expr_stmt (fcall);
5952 finish_compound_stmt (compound_stmt);
5956 /* Call atexit with the cleanup function. */
5957 mark_used (cleanup);
5958 cleanup = build_address (cleanup);
5959 if (flag_use_cxa_atexit && !targetm.cxx.use_atexit_for_cxa_atexit ())
5965 /* We must convert CLEANUP to the type that "__cxa_atexit"
5967 cleanup = build_nop (get_atexit_fn_ptr_type (), cleanup);
5968 /* "__cxa_atexit" will pass the address of DECL to the
5969 cleanup function. */
5971 addr = build_address (decl);
5972 /* The declared type of the parameter to "__cxa_atexit" is
5973 "void *". For plain "T*", we could just let the
5974 machinery in build_function_call convert it -- but if the
5975 type is "cv-qualified T *", then we need to convert it
5976 before passing it in, to avoid spurious errors. */
5977 addr = build_nop (ptr_type_node, addr);
5980 /* Since the cleanup functions we build ignore the address
5981 they're given, there's no reason to pass the actual address
5982 in, and, in general, it's cheaper to pass NULL than any
5984 addr = null_pointer_node;
5985 args = tree_cons (NULL_TREE,
5986 build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0),
5988 if (targetm.cxx.use_aeabi_atexit ())
5990 args = tree_cons (NULL_TREE, cleanup, args);
5991 args = tree_cons (NULL_TREE, addr, args);
5995 args = tree_cons (NULL_TREE, addr, args);
5996 args = tree_cons (NULL_TREE, cleanup, args);
6000 args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
6001 return build_function_call (get_atexit_node (), args);
6004 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
6005 is its initializer. Generate code to handle the construction
6006 and destruction of DECL. */
6009 expand_static_init (tree decl, tree init)
6011 gcc_assert (TREE_CODE (decl) == VAR_DECL);
6012 gcc_assert (TREE_STATIC (decl));
6014 /* Some variables require no initialization. */
6016 && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
6017 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
6020 if (DECL_FUNCTION_SCOPE_P (decl))
6022 /* Emit code to perform this initialization but once. */
6023 tree if_stmt = NULL_TREE, inner_if_stmt = NULL_TREE;
6024 tree then_clause = NULL_TREE, inner_then_clause = NULL_TREE;
6025 tree guard, guard_addr;
6026 tree acquire_fn, release_fn, abort_fn;
6029 /* Emit code to perform this initialization but once. This code
6032 static <type> guard;
6033 if (!guard.first_byte) {
6034 if (__cxa_guard_acquire (&guard)) {
6037 // Do initialization.
6038 flag = true; __cxa_guard_release (&guard);
6039 // Register variable for destruction at end of program.
6041 if (!flag) __cxa_guard_abort (&guard);
6045 Note that the `flag' variable is only set to 1 *after* the
6046 initialization is complete. This ensures that an exception,
6047 thrown during the construction, will cause the variable to
6048 reinitialized when we pass through this code again, as per:
6052 If the initialization exits by throwing an exception, the
6053 initialization is not complete, so it will be tried again
6054 the next time control enters the declaration.
6056 This process should be thread-safe, too; multiple threads
6057 should not be able to initialize the variable more than
6060 /* Create the guard variable. */
6061 guard = get_guard (decl);
6063 /* This optimization isn't safe on targets with relaxed memory
6064 consistency. On such targets we force synchronization in
6065 __cxa_guard_acquire. */
6066 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
6068 /* Begin the conditional initialization. */
6069 if_stmt = begin_if_stmt ();
6070 finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
6071 then_clause = begin_compound_stmt (BCS_NO_SCOPE);
6074 if (flag_threadsafe_statics)
6076 guard_addr = build_address (guard);
6078 acquire_fn = get_identifier ("__cxa_guard_acquire");
6079 release_fn = get_identifier ("__cxa_guard_release");
6080 abort_fn = get_identifier ("__cxa_guard_abort");
6081 if (!get_global_value_if_present (acquire_fn, &acquire_fn))
6083 tree argtypes = tree_cons (NULL_TREE, TREE_TYPE (guard_addr),
6085 tree vfntype = build_function_type (void_type_node, argtypes);
6086 acquire_fn = push_library_fn
6087 (acquire_fn, build_function_type (integer_type_node, argtypes));
6088 release_fn = push_library_fn (release_fn, vfntype);
6089 abort_fn = push_library_fn (abort_fn, vfntype);
6093 release_fn = identifier_global_value (release_fn);
6094 abort_fn = identifier_global_value (abort_fn);
6097 inner_if_stmt = begin_if_stmt ();
6098 finish_if_stmt_cond (build_call_n (acquire_fn, 1, guard_addr),
6101 inner_then_clause = begin_compound_stmt (BCS_NO_SCOPE);
6102 begin = get_target_expr (boolean_false_node);
6103 flag = TARGET_EXPR_SLOT (begin);
6105 TARGET_EXPR_CLEANUP (begin)
6106 = build3 (COND_EXPR, void_type_node, flag,
6108 build_call_n (abort_fn, 1, guard_addr));
6109 CLEANUP_EH_ONLY (begin) = 1;
6111 /* Do the initialization itself. */
6112 init = add_stmt_to_compound (begin, init);
6113 init = add_stmt_to_compound
6114 (init, build2 (MODIFY_EXPR, void_type_node, flag, boolean_true_node));
6115 init = add_stmt_to_compound
6116 (init, build_call_n (release_fn, 1, guard_addr));
6119 init = add_stmt_to_compound (init, set_guard (guard));
6121 /* Use atexit to register a function for destroying this static
6123 init = add_stmt_to_compound (init, register_dtor_fn (decl));
6125 finish_expr_stmt (init);
6127 if (flag_threadsafe_statics)
6129 finish_compound_stmt (inner_then_clause);
6130 finish_then_clause (inner_if_stmt);
6131 finish_if_stmt (inner_if_stmt);
6134 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
6136 finish_compound_stmt (then_clause);
6137 finish_then_clause (if_stmt);
6138 finish_if_stmt (if_stmt);
6142 static_aggregates = tree_cons (init, decl, static_aggregates);
6146 /* Make TYPE a complete type based on INITIAL_VALUE.
6147 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6148 2 if there was no information (in which case assume 0 if DO_DEFAULT),
6149 3 if the initializer list is empty (in pedantic mode). */
6152 cp_complete_array_type (tree *ptype, tree initial_value, bool do_default)
6155 tree type, elt_type;
6159 unsigned HOST_WIDE_INT i;
6162 /* An array of character type can be initialized from a
6163 brace-enclosed string constant.
6165 FIXME: this code is duplicated from reshape_init. Probably
6166 we should just call reshape_init here? */
6167 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype)))
6168 && TREE_CODE (initial_value) == CONSTRUCTOR
6169 && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (initial_value)))
6171 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
6172 tree value = VEC_index (constructor_elt, v, 0)->value;
6174 if (TREE_CODE (value) == STRING_CST
6175 && VEC_length (constructor_elt, v) == 1)
6176 initial_value = value;
6179 /* If any of the elements are parameter packs, we can't actually
6180 complete this type now because the array size is dependent. */
6181 if (TREE_CODE (initial_value) == CONSTRUCTOR)
6183 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value),
6186 if (PACK_EXPANSION_P (value))
6192 failure = complete_array_type (ptype, initial_value, do_default);
6194 /* We can create the array before the element type is complete, which
6195 means that we didn't have these two bits set in the original type
6196 either. In completing the type, we are expected to propagate these
6197 bits. See also complete_type which does the same thing for arrays
6200 if (TYPE_DOMAIN (type))
6202 elt_type = TREE_TYPE (type);
6203 TYPE_NEEDS_CONSTRUCTING (type) = TYPE_NEEDS_CONSTRUCTING (elt_type);
6204 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
6205 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type);
6211 /* Return zero if something is declared to be a member of type
6212 CTYPE when in the context of CUR_TYPE. STRING is the error
6213 message to print in that case. Otherwise, quietly return 1. */
6216 member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
6218 if (ctype && ctype != cur_type)
6220 if (flags == DTOR_FLAG)
6221 error ("destructor for alien class %qT cannot be a member", ctype);
6223 error ("constructor for alien class %qT cannot be a member", ctype);
6229 /* Subroutine of `grokdeclarator'. */
6231 /* Generate errors possibly applicable for a given set of specifiers.
6232 This is for ARM $7.1.2. */
6235 bad_specifiers (tree object,
6244 error ("%qD declared as a %<virtual%> %s", object, type);
6246 error ("%qD declared as an %<inline%> %s", object, type);
6248 error ("%<const%> and %<volatile%> function specifiers on "
6249 "%qD invalid in %s declaration",
6252 error ("%q+D declared as a friend", object);
6254 && (TREE_CODE (object) == TYPE_DECL
6255 || (!TYPE_PTRFN_P (TREE_TYPE (object))
6256 && !TYPE_REFFN_P (TREE_TYPE (object))
6257 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
6258 error ("%q+D declared with an exception specification", object);
6261 /* DECL is a member function or static data member and is presently
6262 being defined. Check that the definition is taking place in a
6266 check_class_member_definition_namespace (tree decl)
6268 /* These checks only apply to member functions and static data
6270 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
6271 || TREE_CODE (decl) == VAR_DECL);
6272 /* We check for problems with specializations in pt.c in
6273 check_specialization_namespace, where we can issue better
6275 if (processing_specialization)
6277 /* There are no restrictions on the placement of
6278 explicit instantiations. */
6279 if (processing_explicit_instantiation)
6283 A member function definition that appears outside of the
6284 class definition shall appear in a namespace scope enclosing
6285 the class definition.
6289 The definition for a static data member shall appear in a
6290 namespace scope enclosing the member's class definition. */
6291 if (!is_ancestor (current_namespace, DECL_CONTEXT (decl)))
6292 pedwarn ("definition of %qD is not in namespace enclosing %qT",
6293 decl, DECL_CONTEXT (decl));
6296 /* Build a PARM_DECL for the "this" parameter. TYPE is the
6297 METHOD_TYPE for a non-static member function; QUALS are the
6298 cv-qualifiers that apply to the function. */
6301 build_this_parm (tree type, cp_cv_quals quals)
6306 cp_cv_quals this_quals;
6308 this_type = TREE_VALUE (TYPE_ARG_TYPES (type));
6309 /* The `this' parameter is implicitly `const'; it cannot be
6311 this_quals = (quals & TYPE_QUAL_RESTRICT) | TYPE_QUAL_CONST;
6312 qual_type = cp_build_qualified_type (this_type, this_quals);
6313 parm = build_artificial_parm (this_identifier, qual_type);
6314 cp_apply_type_quals_to_decl (this_quals, parm);
6318 /* CTYPE is class type, or null if non-class.
6319 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
6321 DECLARATOR is the function's name.
6322 PARMS is a chain of PARM_DECLs for the function.
6323 VIRTUALP is truthvalue of whether the function is virtual or not.
6324 FLAGS are to be passed through to `grokclassfn'.
6325 QUALS are qualifiers indicating whether the function is `const'
6327 RAISES is a list of exceptions that this function can raise.
6328 CHECK is 1 if we must find this method in CTYPE, 0 if we should
6329 not look, and -1 if we should not call `grokclassfn' at all.
6331 SFK is the kind of special function (if any) for the new function.
6333 Returns `NULL_TREE' if something goes wrong, after issuing
6334 applicable error messages. */
6337 grokfndecl (tree ctype,
6341 tree orig_declarator,
6343 enum overload_flags flags,
6350 special_function_kind sfk,
6357 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
6361 type = build_exception_variant (type, raises);
6363 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
6364 if (TREE_CODE (type) == METHOD_TYPE)
6367 parm = build_this_parm (type, quals);
6368 TREE_CHAIN (parm) = parms;
6371 DECL_ARGUMENTS (decl) = parms;
6372 /* Propagate volatile out from type to decl. */
6373 if (TYPE_VOLATILE (type))
6374 TREE_THIS_VOLATILE (decl) = 1;
6376 /* Setup decl according to sfk. */
6379 case sfk_constructor:
6380 case sfk_copy_constructor:
6381 DECL_CONSTRUCTOR_P (decl) = 1;
6383 case sfk_destructor:
6384 DECL_DESTRUCTOR_P (decl) = 1;
6390 /* If pointers to member functions use the least significant bit to
6391 indicate whether a function is virtual, ensure a pointer
6392 to this function will have that bit clear. */
6393 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
6394 && TREE_CODE (type) == METHOD_TYPE
6395 && DECL_ALIGN (decl) < 2 * BITS_PER_UNIT)
6396 DECL_ALIGN (decl) = 2 * BITS_PER_UNIT;
6399 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
6403 ("defining explicit specialization %qD in friend declaration",
6407 tree fns = TREE_OPERAND (orig_declarator, 0);
6408 tree args = TREE_OPERAND (orig_declarator, 1);
6410 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
6412 /* Something like `template <class T> friend void f<T>()'. */
6413 error ("invalid use of template-id %qD in declaration "
6414 "of primary template",
6420 /* A friend declaration of the form friend void f<>(). Record
6421 the information in the TEMPLATE_ID_EXPR. */
6422 SET_DECL_IMPLICIT_INSTANTIATION (decl);
6424 if (TREE_CODE (fns) == COMPONENT_REF)
6426 /* Due to bison parser ickiness, we will have already looked
6427 up an operator_name or PFUNCNAME within the current class
6428 (see template_id in parse.y). If the current class contains
6429 such a name, we'll get a COMPONENT_REF here. Undo that. */
6431 gcc_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
6432 == current_class_type);
6433 fns = TREE_OPERAND (fns, 1);
6435 gcc_assert (TREE_CODE (fns) == IDENTIFIER_NODE
6436 || TREE_CODE (fns) == OVERLOAD);
6437 DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
6439 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
6440 if (TREE_PURPOSE (t)
6441 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
6443 error ("default arguments are not allowed in declaration "
6444 "of friend template specialization %qD",
6451 error ("%<inline%> is not allowed in declaration of friend "
6452 "template specialization %qD",
6459 /* If this decl has namespace scope, set that up. */
6461 set_decl_namespace (decl, in_namespace, friendp);
6463 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
6465 /* `main' and builtins have implicit 'C' linkage. */
6466 if ((MAIN_NAME_P (declarator)
6467 || (IDENTIFIER_LENGTH (declarator) > 10
6468 && IDENTIFIER_POINTER (declarator)[0] == '_'
6469 && IDENTIFIER_POINTER (declarator)[1] == '_'
6470 && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
6471 && current_lang_name == lang_name_cplusplus
6472 && ctype == NULL_TREE
6473 /* NULL_TREE means global namespace. */
6474 && DECL_CONTEXT (decl) == NULL_TREE)
6475 SET_DECL_LANGUAGE (decl, lang_c);
6477 /* Should probably propagate const out from type to decl I bet (mrs). */
6480 DECL_STATIC_FUNCTION_P (decl) = 1;
6481 DECL_CONTEXT (decl) = ctype;
6486 DECL_CONTEXT (decl) = ctype;
6488 check_class_member_definition_namespace (decl);
6491 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
6493 if (processing_template_decl)
6494 error ("cannot declare %<::main%> to be a template");
6496 error ("cannot declare %<::main%> to be inline");
6498 error ("cannot declare %<::main%> to be static");
6503 /* Members of anonymous types and local classes have no linkage; make
6504 them internal. If a typedef is made later, this will be changed. */
6505 if (ctype && (TYPE_ANONYMOUS_P (ctype)
6506 || decl_function_context (TYPE_MAIN_DECL (ctype))))
6511 /* [basic.link]: A name with no linkage (notably, the name of a class
6512 or enumeration declared in a local scope) shall not be used to
6513 declare an entity with linkage.
6515 Only check this for public decls for now. See core 319, 389. */
6516 t = no_linkage_check (TREE_TYPE (decl),
6517 /*relaxed_p=*/false);
6520 if (TYPE_ANONYMOUS_P (t))
6522 if (DECL_EXTERN_C_P (decl))
6523 /* Allow this; it's pretty common in C. */;
6526 pedwarn ("non-local function %q#D uses anonymous type",
6528 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
6529 pedwarn ("%q+#D does not refer to the unqualified "
6530 "type, so it is not used for linkage",
6535 pedwarn ("non-local function %q#D uses local type %qT", decl, t);
6539 TREE_PUBLIC (decl) = publicp;
6542 DECL_INTERFACE_KNOWN (decl) = 1;
6543 DECL_NOT_REALLY_EXTERN (decl) = 1;
6546 /* If the declaration was declared inline, mark it as such. */
6548 DECL_DECLARED_INLINE_P (decl) = 1;
6549 /* We inline functions that are explicitly declared inline, or, when
6550 the user explicitly asks us to, all functions. */
6551 if (DECL_DECLARED_INLINE_P (decl)
6552 || (flag_inline_trees == 2 && !DECL_INLINE (decl) && funcdef_flag))
6553 DECL_INLINE (decl) = 1;
6555 DECL_EXTERNAL (decl) = 1;
6556 if (quals && TREE_CODE (type) == FUNCTION_TYPE)
6559 ? G_("static member function %qD cannot have cv-qualifier")
6560 : G_("non-member function %qD cannot have cv-qualifier"),
6562 quals = TYPE_UNQUALIFIED;
6565 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl))
6566 && !grok_op_properties (decl, /*complain=*/true))
6569 if (ctype && decl_function_context (decl))
6570 DECL_NO_STATIC_CHAIN (decl) = 1;
6573 /* Make the init_value nonzero so pushdecl knows this is not
6574 tentative. error_mark_node is replaced later with the BLOCK. */
6575 DECL_INITIAL (decl) = error_mark_node;
6577 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
6578 TREE_NOTHROW (decl) = 1;
6580 /* Caller will do the rest of this. */
6584 if (ctype != NULL_TREE)
6585 grokclassfn (ctype, decl, flags);
6587 decl = check_explicit_specialization (orig_declarator, decl,
6590 4 * (friendp != 0));
6591 if (decl == error_mark_node)
6596 cplus_decl_attributes (&decl, *attrlist, 0);
6597 *attrlist = NULL_TREE;
6600 /* Check main's type after attributes have been applied. */
6601 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
6603 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
6606 tree oldtypeargs = TYPE_ARG_TYPES (TREE_TYPE (decl));
6608 error ("%<::main%> must return %<int%>");
6609 newtype = build_function_type (integer_type_node, oldtypeargs);
6610 TREE_TYPE (decl) = newtype;
6612 check_main_parameter_types (decl);
6615 if (ctype != NULL_TREE
6616 && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
6619 tree old_decl = check_classfn (ctype, decl,
6620 (processing_template_decl
6621 > template_class_depth (ctype))
6622 ? current_template_parms
6625 if (old_decl == error_mark_node)
6633 if (TREE_CODE (old_decl) == TEMPLATE_DECL)
6634 /* Because grokfndecl is always supposed to return a
6635 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
6636 here. We depend on our callers to figure out that its
6637 really a template that's being returned. */
6638 old_decl = DECL_TEMPLATE_RESULT (old_decl);
6640 if (DECL_STATIC_FUNCTION_P (old_decl)
6641 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
6642 /* Remove the `this' parm added by grokclassfn.
6643 XXX Isn't this done in start_function, too? */
6644 revert_static_member_fn (decl);
6645 if (DECL_ARTIFICIAL (old_decl))
6647 error ("definition of implicitly-declared %qD", old_decl);
6651 /* Since we've smashed OLD_DECL to its
6652 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
6653 if (TREE_CODE (decl) == TEMPLATE_DECL)
6654 decl = DECL_TEMPLATE_RESULT (decl);
6656 /* Attempt to merge the declarations. This can fail, in
6657 the case of some invalid specialization declarations. */
6658 pushed_scope = push_scope (ctype);
6659 ok = duplicate_decls (decl, old_decl, friendp);
6661 pop_scope (pushed_scope);
6664 error ("no %q#D member function declared in class %qT",
6672 if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
6675 if (ctype == NULL_TREE || check)
6679 DECL_VIRTUAL_P (decl) = 1;
6684 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
6685 the linkage that DECL will receive in the object file. */
6688 set_linkage_for_static_data_member (tree decl)
6690 /* A static data member always has static storage duration and
6691 external linkage. Note that static data members are forbidden in
6692 local classes -- the only situation in which a class has
6693 non-external linkage. */
6694 TREE_PUBLIC (decl) = 1;
6695 TREE_STATIC (decl) = 1;
6696 /* For non-template classes, static data members are always put
6697 out in exactly those files where they are defined, just as
6698 with ordinary namespace-scope variables. */
6699 if (!processing_template_decl)
6700 DECL_INTERFACE_KNOWN (decl) = 1;
6703 /* Create a VAR_DECL named NAME with the indicated TYPE.
6705 If SCOPE is non-NULL, it is the class type or namespace containing
6706 the variable. If SCOPE is NULL, the variable should is created in
6707 the innermost enclosings scope. */
6710 grokvardecl (tree type,
6712 const cp_decl_specifier_seq *declspecs,
6718 tree explicit_scope;
6720 gcc_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE);
6722 /* Compute the scope in which to place the variable, but remember
6723 whether or not that scope was explicitly specified by the user. */
6724 explicit_scope = scope;
6727 /* An explicit "extern" specifier indicates a namespace-scope
6729 if (declspecs->storage_class == sc_extern)
6730 scope = current_namespace;
6731 else if (!at_function_scope_p ())
6732 scope = current_scope ();
6736 && (/* If the variable is a namespace-scope variable declared in a
6737 template, we need DECL_LANG_SPECIFIC. */
6738 (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
6739 /* Similarly for namespace-scope variables with language linkage
6741 || (TREE_CODE (scope) == NAMESPACE_DECL
6742 && current_lang_name != lang_name_cplusplus)
6743 /* Similarly for static data members. */
6745 decl = build_lang_decl (VAR_DECL, name, type);
6747 decl = build_decl (VAR_DECL, name, type);
6749 if (explicit_scope && TREE_CODE (explicit_scope) == NAMESPACE_DECL)
6750 set_decl_namespace (decl, explicit_scope, 0);
6752 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
6754 if (declspecs->storage_class == sc_extern)
6756 DECL_THIS_EXTERN (decl) = 1;
6757 DECL_EXTERNAL (decl) = !initialized;
6760 if (DECL_CLASS_SCOPE_P (decl))
6762 set_linkage_for_static_data_member (decl);
6763 /* This function is only called with out-of-class definitions. */
6764 DECL_EXTERNAL (decl) = 0;
6765 check_class_member_definition_namespace (decl);
6767 /* At top level, either `static' or no s.c. makes a definition
6768 (perhaps tentative), and absence of `static' makes it public. */
6769 else if (toplevel_bindings_p ())
6771 TREE_PUBLIC (decl) = (declspecs->storage_class != sc_static
6772 && (DECL_THIS_EXTERN (decl) || ! constp));
6773 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
6775 /* Not at top level, only `static' makes a static definition. */
6778 TREE_STATIC (decl) = declspecs->storage_class == sc_static;
6779 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
6782 if (declspecs->specs[(int)ds_thread])
6783 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
6785 if (TREE_PUBLIC (decl))
6787 /* [basic.link]: A name with no linkage (notably, the name of a class
6788 or enumeration declared in a local scope) shall not be used to
6789 declare an entity with linkage.
6791 Only check this for public decls for now. */
6792 tree t = no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false);
6795 if (TYPE_ANONYMOUS_P (t))
6797 if (DECL_EXTERN_C_P (decl))
6798 /* Allow this; it's pretty common in C. */
6802 /* DRs 132, 319 and 389 seem to indicate types with
6803 no linkage can only be used to declare extern "C"
6804 entities. Since it's not always an error in the
6805 ISO C++ 90 Standard, we only issue a warning. */
6806 warning (0, "non-local variable %q#D uses anonymous type",
6808 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
6809 warning (0, "%q+#D does not refer to the unqualified "
6810 "type, so it is not used for linkage",
6815 warning (0, "non-local variable %q#D uses local type %qT", decl, t);
6819 DECL_INTERFACE_KNOWN (decl) = 1;
6824 /* Create and return a canonical pointer to member function type, for
6825 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
6828 build_ptrmemfunc_type (tree type)
6832 tree unqualified_variant = NULL_TREE;
6834 if (type == error_mark_node)
6837 /* If a canonical type already exists for this type, use it. We use
6838 this method instead of type_hash_canon, because it only does a
6839 simple equality check on the list of field members. */
6841 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
6844 /* Make sure that we always have the unqualified pointer-to-member
6846 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
6848 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
6850 t = make_aggr_type (RECORD_TYPE);
6851 xref_basetypes (t, NULL_TREE);
6853 /* Let the front end know this is a pointer to member function... */
6854 TYPE_PTRMEMFUNC_FLAG (t) = 1;
6855 /* ... and not really an aggregate. */
6856 SET_IS_AGGR_TYPE (t, 0);
6858 field = build_decl (FIELD_DECL, pfn_identifier, type);
6861 field = build_decl (FIELD_DECL, delta_identifier, delta_type_node);
6862 TREE_CHAIN (field) = fields;
6865 finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
6867 /* Zap out the name so that the back end will give us the debugging
6868 information for this anonymous RECORD_TYPE. */
6869 TYPE_NAME (t) = NULL_TREE;
6871 /* If this is not the unqualified form of this pointer-to-member
6872 type, set the TYPE_MAIN_VARIANT for this type to be the
6873 unqualified type. Since they are actually RECORD_TYPEs that are
6874 not variants of each other, we must do this manually. */
6875 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
6877 t = build_qualified_type (t, cp_type_quals (type));
6878 TYPE_MAIN_VARIANT (t) = unqualified_variant;
6879 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
6880 TYPE_NEXT_VARIANT (unqualified_variant) = t;
6883 /* Cache this pointer-to-member type so that we can find it again
6885 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
6887 /* Managing canonical types for the RECORD_TYPE behind a
6888 pointer-to-member function is a nightmare, so use structural
6889 equality for now. */
6890 SET_TYPE_STRUCTURAL_EQUALITY (t);
6895 /* Create and return a pointer to data member type. */
6898 build_ptrmem_type (tree class_type, tree member_type)
6900 if (TREE_CODE (member_type) == METHOD_TYPE)
6904 arg_types = TYPE_ARG_TYPES (member_type);
6905 class_type = (cp_build_qualified_type
6907 cp_type_quals (TREE_TYPE (TREE_VALUE (arg_types)))));
6909 = build_method_type_directly (class_type,
6910 TREE_TYPE (member_type),
6911 TREE_CHAIN (arg_types));
6912 return build_ptrmemfunc_type (build_pointer_type (member_type));
6916 gcc_assert (TREE_CODE (member_type) != FUNCTION_TYPE);
6917 return build_offset_type (class_type, member_type);
6921 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
6922 Check to see that the definition is valid. Issue appropriate error
6923 messages. Return 1 if the definition is particularly bad, or 0
6927 check_static_variable_definition (tree decl, tree type)
6929 /* Motion 10 at San Diego: If a static const integral data member is
6930 initialized with an integral constant expression, the initializer
6931 may appear either in the declaration (within the class), or in
6932 the definition, but not both. If it appears in the class, the
6933 member is a member constant. The file-scope definition is always
6935 if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
6937 error ("invalid in-class initialization of static data member "
6938 "of non-integral type %qT",
6940 /* If we just return the declaration, crashes will sometimes
6941 occur. We therefore return void_type_node, as if this were a
6942 friend declaration, to cause callers to completely ignore
6943 this declaration. */
6946 else if (!CP_TYPE_CONST_P (type))
6947 error ("ISO C++ forbids in-class initialization of non-const "
6948 "static member %qD",
6950 else if (pedantic && !INTEGRAL_TYPE_P (type))
6951 pedwarn ("ISO C++ forbids initialization of member constant "
6952 "%qD of non-integral type %qT", decl, type);
6957 /* Given the SIZE (i.e., number of elements) in an array, compute an
6958 appropriate index type for the array. If non-NULL, NAME is the
6959 name of the thing being declared. */
6962 compute_array_index_type (tree name, tree size)
6966 tree abi_1_itype = NULL_TREE;
6968 if (error_operand_p (size))
6969 return error_mark_node;
6971 type = TREE_TYPE (size);
6972 /* The array bound must be an integer type. */
6973 if (!dependent_type_p (type) && !INTEGRAL_TYPE_P (type))
6976 error ("size of array %qD has non-integral type %qT", name, type);
6978 error ("size of array has non-integral type %qT", type);
6979 size = integer_one_node;
6980 type = TREE_TYPE (size);
6983 if (value_dependent_expression_p (size))
6985 /* We cannot do any checking for a value-dependent SIZE. Just
6986 build the index type and mark that it requires structural
6988 itype = build_index_type (build_min (MINUS_EXPR, sizetype,
6989 size, integer_one_node));
6990 SET_TYPE_STRUCTURAL_EQUALITY (itype);
6994 if (!abi_version_at_least (2) && processing_template_decl)
6995 /* For abi-1, we handled all instances in templates the same way,
6996 even when they were non-dependent. This effects the manglings
6997 produced. So, we do the normal checking for non-dependent
6998 sizes, but at the end we'll return the same type that abi-1
6999 would have, but with TYPE_CANONICAL set to the "right"
7000 value that the current ABI would provide. */
7001 abi_1_itype = build_index_type (build_min (MINUS_EXPR, sizetype,
7002 size, integer_one_node));
7004 /* The size might be the result of a cast. */
7005 STRIP_TYPE_NOPS (size);
7007 /* It might be a const variable or enumeration constant. */
7008 size = integral_constant_value (size);
7010 /* Normally, the array-bound will be a constant. */
7011 if (TREE_CODE (size) == INTEGER_CST)
7013 /* Check to see if the array bound overflowed. Make that an
7014 error, no matter how generous we're being. */
7015 int old_flag_pedantic_errors = flag_pedantic_errors;
7016 int old_pedantic = pedantic;
7017 pedantic = flag_pedantic_errors = 1;
7018 constant_expression_warning (size);
7019 pedantic = old_pedantic;
7020 flag_pedantic_errors = old_flag_pedantic_errors;
7022 /* An array must have a positive number of elements. */
7023 if (INT_CST_LT (size, integer_zero_node))
7026 error ("size of array %qD is negative", name);
7028 error ("size of array is negative");
7029 size = integer_one_node;
7031 /* As an extension we allow zero-sized arrays. We always allow
7032 them in system headers because glibc uses them. */
7033 else if (integer_zerop (size) && pedantic && !in_system_header)
7036 pedwarn ("ISO C++ forbids zero-size array %qD", name);
7038 pedwarn ("ISO C++ forbids zero-size array");
7041 else if (TREE_CONSTANT (size))
7043 /* `(int) &fn' is not a valid array bound. */
7045 error ("size of array %qD is not an integral constant-expression",
7048 error ("size of array is not an integral constant-expression");
7049 size = integer_one_node;
7051 else if (pedantic && warn_vla != 0)
7054 pedwarn ("ISO C++ forbids variable length array %qD", name);
7056 pedwarn ("ISO C++ forbids variable length array");
7058 else if (warn_vla > 0)
7062 "variable length array %qD is used", name);
7065 "variable length array is used");
7068 if (processing_template_decl && !TREE_CONSTANT (size))
7069 /* A variable sized array. */
7070 itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node);
7073 HOST_WIDE_INT saved_processing_template_decl;
7075 /* Compute the index of the largest element in the array. It is
7076 one less than the number of elements in the array. We save
7077 and restore PROCESSING_TEMPLATE_DECL so that computations in
7078 cp_build_binary_op will be appropriately folded. */
7079 saved_processing_template_decl = processing_template_decl;
7080 processing_template_decl = 0;
7081 itype = cp_build_binary_op (MINUS_EXPR,
7082 cp_convert (ssizetype, size),
7083 cp_convert (ssizetype, integer_one_node));
7084 itype = fold (itype);
7085 processing_template_decl = saved_processing_template_decl;
7087 if (!TREE_CONSTANT (itype))
7088 /* A variable sized array. */
7089 itype = variable_size (itype);
7090 /* Make sure that there was no overflow when creating to a signed
7091 index type. (For example, on a 32-bit machine, an array with
7092 size 2^32 - 1 is too big.) */
7093 else if (TREE_CODE (itype) == INTEGER_CST
7094 && TREE_OVERFLOW (itype))
7096 error ("overflow in array dimension");
7097 TREE_OVERFLOW (itype) = 0;
7101 /* Create and return the appropriate index type. */
7104 tree t = build_index_type (itype);
7105 TYPE_CANONICAL (abi_1_itype) = TYPE_CANONICAL (t);
7109 return build_index_type (itype);
7112 /* Returns the scope (if any) in which the entity declared by
7113 DECLARATOR will be located. If the entity was declared with an
7114 unqualified name, NULL_TREE is returned. */
7117 get_scope_of_declarator (const cp_declarator *declarator)
7119 while (declarator && declarator->kind != cdk_id)
7120 declarator = declarator->declarator;
7122 /* If the declarator-id is a SCOPE_REF, the scope in which the
7123 declaration occurs is the first operand. */
7125 && declarator->u.id.qualifying_scope)
7126 return declarator->u.id.qualifying_scope;
7128 /* Otherwise, the declarator is not a qualified name; the entity will
7129 be declared in the current scope. */
7133 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
7134 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
7138 create_array_type_for_decl (tree name, tree type, tree size)
7140 tree itype = NULL_TREE;
7141 const char* error_msg;
7143 /* If things have already gone awry, bail now. */
7144 if (type == error_mark_node || size == error_mark_node)
7145 return error_mark_node;
7147 /* Assume that everything will go OK. */
7150 /* There are some types which cannot be array elements. */
7151 switch (TREE_CODE (type))
7154 error_msg = "array of void";
7158 error_msg = "array of functions";
7161 case REFERENCE_TYPE:
7162 error_msg = "array of references";
7166 error_msg = "array of function members";
7173 /* If something went wrong, issue an error-message and return. */
7177 error ("declaration of %qD as %s", name, error_msg);
7179 error ("creating %s", error_msg);
7181 return error_mark_node;
7186 The constant expressions that specify the bounds of the arrays
7187 can be omitted only for the first member of the sequence. */
7188 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
7191 error ("declaration of %qD as multidimensional array must "
7192 "have bounds for all dimensions except the first",
7195 error ("multidimensional array must have bounds for all "
7196 "dimensions except the first");
7198 return error_mark_node;
7201 /* Figure out the index type for the array. */
7203 itype = compute_array_index_type (name, size);
7206 T is called the array element type; this type shall not be [...] an
7207 abstract class type. */
7208 abstract_virtuals_error (name, type);
7210 return build_cplus_array_type (type, itype);
7213 /* Check that it's OK to declare a function with the indicated TYPE.
7214 SFK indicates the kind of special function (if any) that this
7215 function is. OPTYPE is the type given in a conversion operator
7216 declaration, or the class type for a constructor/destructor.
7217 Returns the actual return type of the function; that
7218 may be different than TYPE if an error occurs, or for certain
7219 special functions. */
7222 check_special_function_return_type (special_function_kind sfk,
7228 case sfk_constructor:
7230 error ("return type specification for constructor invalid");
7232 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
7233 type = build_pointer_type (optype);
7235 type = void_type_node;
7238 case sfk_destructor:
7240 error ("return type specification for destructor invalid");
7241 /* We can't use the proper return type here because we run into
7242 problems with ambiguous bases and covariant returns.
7243 Java classes are left unchanged because (void *) isn't a valid
7244 Java type, and we don't want to change the Java ABI. */
7245 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
7246 type = build_pointer_type (void_type_node);
7248 type = void_type_node;
7251 case sfk_conversion:
7253 error ("return type specified for %<operator %T%>", optype);
7264 /* A variable or data member (whose unqualified name is IDENTIFIER)
7265 has been declared with the indicated TYPE. If the TYPE is not
7266 acceptable, issue an error message and return a type to use for
7267 error-recovery purposes. */
7270 check_var_type (tree identifier, tree type)
7272 if (VOID_TYPE_P (type))
7275 error ("unnamed variable or field declared void");
7276 else if (TREE_CODE (identifier) == IDENTIFIER_NODE)
7278 gcc_assert (!IDENTIFIER_OPNAME_P (identifier));
7279 error ("variable or field %qE declared void", identifier);
7282 error ("variable or field declared void");
7283 type = error_mark_node;
7289 /* Given declspecs and a declarator (abstract or otherwise), determine
7290 the name and type of the object declared and construct a DECL node
7293 DECLSPECS points to the representation of declaration-specifier
7294 sequence that precedes declarator.
7296 DECL_CONTEXT says which syntactic context this declaration is in:
7297 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
7298 FUNCDEF for a function definition. Like NORMAL but a few different
7299 error messages in each case. Return value may be zero meaning
7300 this definition is too screwy to try to parse.
7301 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
7302 handle member functions (which have FIELD context).
7303 Return value may be zero meaning this definition is too screwy to
7305 PARM for a parameter declaration (either within a function prototype
7306 or before a function body). Make a PARM_DECL, or return void_type_node.
7307 CATCHPARM for a parameter declaration before a catch clause.
7308 TYPENAME if for a typename (in a cast or sizeof).
7309 Don't make a DECL node; just return the ..._TYPE node.
7310 FIELD for a struct or union field; make a FIELD_DECL.
7311 BITFIELD for a field with specified width.
7312 INITIALIZED is 1 if the decl has an initializer.
7314 ATTRLIST is a pointer to the list of attributes, which may be NULL
7315 if there are none; *ATTRLIST may be modified if attributes from inside
7316 the declarator should be applied to the declaration.
7318 When this function is called, scoping variables (such as
7319 CURRENT_CLASS_TYPE) should reflect the scope in which the
7320 declaration occurs, not the scope in which the new declaration will
7321 be placed. For example, on:
7325 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
7328 Returns a DECL (if a declarator is present), a TYPE (if there is no
7329 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
7333 grokdeclarator (const cp_declarator *declarator,
7334 const cp_decl_specifier_seq *declspecs,
7335 enum decl_context decl_context,
7339 tree type = NULL_TREE;
7341 int virtualp, explicitp, friendp, inlinep, staticp;
7342 int explicit_int = 0;
7343 int explicit_char = 0;
7344 int defaulted_int = 0;
7345 tree dependent_name = NULL_TREE;
7347 tree typedef_decl = NULL_TREE;
7348 const char *name = NULL;
7349 tree typedef_type = NULL_TREE;
7350 /* True if this declarator is a function definition. */
7351 bool funcdef_flag = false;
7352 cp_declarator_kind innermost_code = cdk_error;
7355 /* See the code below that used this. */
7356 tree decl_attr = NULL_TREE;
7359 /* Keep track of what sort of function is being processed
7360 so that we can warn about default return values, or explicit
7361 return values which do not match prescribed defaults. */
7362 special_function_kind sfk = sfk_none;
7364 tree dname = NULL_TREE;
7365 tree ctor_return_type = NULL_TREE;
7366 enum overload_flags flags = NO_SPECIAL;
7367 /* cv-qualifiers that apply to the declarator, for a declaration of
7368 a member function. */
7369 cp_cv_quals memfn_quals = TYPE_UNQUALIFIED;
7370 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
7372 tree raises = NULL_TREE;
7373 int template_count = 0;
7374 tree returned_attrs = NULL_TREE;
7375 tree parms = NULL_TREE;
7376 const cp_declarator *id_declarator;
7377 /* The unqualified name of the declarator; either an
7378 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
7379 tree unqualified_id;
7380 /* The class type, if any, in which this entity is located,
7381 or NULL_TREE if none. Note that this value may be different from
7382 the current class type; for example if an attempt is made to declare
7383 "A::f" inside "B", this value will be "A". */
7384 tree ctype = current_class_type;
7385 /* The NAMESPACE_DECL for the namespace in which this entity is
7386 located. If an unqualified name is used to declare the entity,
7387 this value will be NULL_TREE, even if the entity is located at
7389 tree in_namespace = NULL_TREE;
7390 cp_storage_class storage_class;
7391 bool unsigned_p, signed_p, short_p, long_p, thread_p;
7392 bool type_was_error_mark_node = false;
7393 bool parameter_pack_p = declarator? declarator->parameter_pack_p : false;
7394 bool set_no_warning = false;
7396 signed_p = declspecs->specs[(int)ds_signed];
7397 unsigned_p = declspecs->specs[(int)ds_unsigned];
7398 short_p = declspecs->specs[(int)ds_short];
7399 long_p = declspecs->specs[(int)ds_long];
7400 longlong = declspecs->specs[(int)ds_long] >= 2;
7401 thread_p = declspecs->specs[(int)ds_thread];
7403 if (decl_context == FUNCDEF)
7404 funcdef_flag = true, decl_context = NORMAL;
7405 else if (decl_context == MEMFUNCDEF)
7406 funcdef_flag = true, decl_context = FIELD;
7407 else if (decl_context == BITFIELD)
7408 bitfield = 1, decl_context = FIELD;
7410 /* Look inside a declarator for the name being declared
7411 and get it as a string, for an error message. */
7412 for (id_declarator = declarator;
7414 id_declarator = id_declarator->declarator)
7416 if (id_declarator->kind != cdk_id)
7417 innermost_code = id_declarator->kind;
7419 switch (id_declarator->kind)
7422 if (id_declarator->declarator
7423 && id_declarator->declarator->kind == cdk_id)
7425 sfk = id_declarator->declarator->u.id.sfk;
7426 if (sfk == sfk_destructor)
7433 tree qualifying_scope = id_declarator->u.id.qualifying_scope;
7434 tree decl = id_declarator->u.id.unqualified_name;
7437 if (qualifying_scope)
7439 if (at_function_scope_p ())
7443 A declarator-id shall not be qualified except
7446 None of the cases are permitted in block
7448 if (qualifying_scope == global_namespace)
7449 error ("invalid use of qualified-name %<::%D%>",
7451 else if (TYPE_P (qualifying_scope))
7452 error ("invalid use of qualified-name %<%T::%D%>",
7453 qualifying_scope, decl);
7455 error ("invalid use of qualified-name %<%D::%D%>",
7456 qualifying_scope, decl);
7457 return error_mark_node;
7459 else if (TYPE_P (qualifying_scope))
7461 ctype = qualifying_scope;
7462 if (innermost_code != cdk_function
7463 && current_class_type
7464 && !UNIQUELY_DERIVED_FROM_P (ctype,
7465 current_class_type))
7467 error ("type %qT is not derived from type %qT",
7468 ctype, current_class_type);
7469 return error_mark_node;
7472 else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL)
7473 in_namespace = qualifying_scope;
7475 switch (TREE_CODE (decl))
7481 if (innermost_code != cdk_function)
7483 error ("declaration of %qD as non-function", decl);
7484 return error_mark_node;
7486 else if (!qualifying_scope
7487 && !(current_class_type && at_class_scope_p ()))
7489 error ("declaration of %qD as non-member", decl);
7490 return error_mark_node;
7493 type = TREE_OPERAND (decl, 0);
7494 name = IDENTIFIER_POINTER (constructor_name (type));
7499 case TEMPLATE_ID_EXPR:
7501 tree fns = TREE_OPERAND (decl, 0);
7504 if (TREE_CODE (dname) != IDENTIFIER_NODE)
7506 gcc_assert (is_overloaded_fn (dname));
7507 dname = DECL_NAME (get_first_fn (dname));
7512 case IDENTIFIER_NODE:
7513 if (TREE_CODE (decl) == IDENTIFIER_NODE)
7516 if (C_IS_RESERVED_WORD (dname))
7518 error ("declarator-id missing; using reserved word %qD",
7520 name = IDENTIFIER_POINTER (dname);
7522 else if (!IDENTIFIER_TYPENAME_P (dname))
7523 name = IDENTIFIER_POINTER (dname);
7526 gcc_assert (flags == NO_SPECIAL);
7527 flags = TYPENAME_FLAG;
7528 ctor_return_type = TREE_TYPE (dname);
7529 sfk = sfk_conversion;
7530 if (is_typename_at_global_scope (dname))
7531 name = IDENTIFIER_POINTER (dname);
7533 name = "<invalid operator>";
7550 return error_mark_node;
7555 if (id_declarator->kind == cdk_id)
7561 The declarator in a function-definition shall have the form
7562 D1 ( parameter-declaration-clause) ... */
7563 if (funcdef_flag && innermost_code != cdk_function)
7565 error ("function definition does not declare parameters");
7566 return error_mark_node;
7569 if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
7570 && innermost_code != cdk_function
7571 && ! (ctype && !declspecs->any_specifiers_p))
7573 error ("declaration of %qD as non-function", dname);
7574 return error_mark_node;
7577 /* Anything declared one level down from the top level
7578 must be one of the parameters of a function
7579 (because the body is at least two levels down). */
7581 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
7582 by not allowing C++ class definitions to specify their parameters
7583 with xdecls (must be spec.d in the parmlist).
7585 Since we now wait to push a class scope until we are sure that
7586 we are in a legitimate method context, we must set oldcname
7587 explicitly (since current_class_name is not yet alive).
7589 We also want to avoid calling this a PARM if it is in a namespace. */
7591 if (decl_context == NORMAL && !toplevel_bindings_p ())
7593 struct cp_binding_level *b = current_binding_level;
7594 current_binding_level = b->level_chain;
7595 if (current_binding_level != 0 && toplevel_bindings_p ())
7596 decl_context = PARM;
7597 current_binding_level = b;
7601 name = decl_context == PARM ? "parameter" : "type name";
7603 /* If there were multiple types specified in the decl-specifier-seq,
7604 issue an error message. */
7605 if (declspecs->multiple_types_p)
7607 error ("two or more data types in declaration of %qs", name);
7608 return error_mark_node;
7611 if (declspecs->conflicting_specifiers_p)
7613 error ("conflicting specifiers in declaration of %qs", name);
7614 return error_mark_node;
7617 /* Extract the basic type from the decl-specifier-seq. */
7618 type = declspecs->type;
7619 if (type == error_mark_node)
7622 type_was_error_mark_node = true;
7624 /* If the entire declaration is itself tagged as deprecated then
7625 suppress reports of deprecated items. */
7626 if (type && TREE_DEPRECATED (type)
7627 && deprecated_state != DEPRECATED_SUPPRESS)
7628 warn_deprecated_use (type);
7629 if (type && TREE_CODE (type) == TYPE_DECL)
7631 typedef_decl = type;
7632 type = TREE_TYPE (typedef_decl);
7633 if (TREE_DEPRECATED (type)
7634 && DECL_ARTIFICIAL (typedef_decl)
7635 && deprecated_state != DEPRECATED_SUPPRESS)
7636 warn_deprecated_use (type);
7638 /* No type at all: default to `int', and set DEFAULTED_INT
7639 because it was not a user-defined typedef. */
7640 if (type == NULL_TREE && (signed_p || unsigned_p || long_p || short_p))
7642 /* These imply 'int'. */
7643 type = integer_type_node;
7647 explicit_int = declspecs->explicit_int_p;
7648 explicit_char = declspecs->explicit_char_p;
7651 /* See the code below that used this. */
7653 decl_attr = DECL_ATTRIBUTES (typedef_decl);
7655 typedef_type = type;
7658 if (sfk != sfk_conversion)
7659 ctor_return_type = ctype;
7661 if (sfk != sfk_none)
7662 type = check_special_function_return_type (sfk, type,
7664 else if (type == NULL_TREE)
7670 /* We handle `main' specially here, because 'main () { }' is so
7671 common. With no options, it is allowed. With -Wreturn-type,
7672 it is a warning. It is only an error with -pedantic-errors. */
7673 is_main = (funcdef_flag
7674 && dname && MAIN_NAME_P (dname)
7675 && ctype == NULL_TREE
7676 && in_namespace == NULL_TREE
7677 && current_namespace == global_namespace);
7679 if (type_was_error_mark_node)
7680 /* We've already issued an error, don't complain more. */;
7681 else if (in_system_header || flag_ms_extensions)
7682 /* Allow it, sigh. */;
7683 else if (pedantic || ! is_main)
7684 pedwarn ("ISO C++ forbids declaration of %qs with no type", name);
7686 warning (OPT_Wreturn_type,
7687 "ISO C++ forbids declaration of %qs with no type", name);
7689 type = integer_type_node;
7694 /* Now process the modifiers that were specified
7695 and check for invalid combinations. */
7697 /* Long double is a special combination. */
7698 if (long_p && !longlong && TYPE_MAIN_VARIANT (type) == double_type_node)
7701 type = build_qualified_type (long_double_type_node,
7702 cp_type_quals (type));
7705 /* Check all other uses of type modifiers. */
7707 if (unsigned_p || signed_p || long_p || short_p)
7711 if ((signed_p || unsigned_p) && TREE_CODE (type) != INTEGER_TYPE)
7712 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
7713 else if (signed_p && unsigned_p)
7714 error ("%<signed%> and %<unsigned%> specified together for %qs", name);
7715 else if (longlong && TREE_CODE (type) != INTEGER_TYPE)
7716 error ("%<long long%> invalid for %qs", name);
7717 else if (long_p && TREE_CODE (type) == REAL_TYPE)
7718 error ("%<long%> invalid for %qs", name);
7719 else if (short_p && TREE_CODE (type) == REAL_TYPE)
7720 error ("%<short%> invalid for %qs", name);
7721 else if ((long_p || short_p) && TREE_CODE (type) != INTEGER_TYPE)
7722 error ("%<long%> or %<short%> invalid for %qs", name);
7723 else if ((long_p || short_p) && explicit_char)
7724 error ("%<long%> or %<short%> specified with char for %qs", name);
7725 else if (long_p && short_p)
7726 error ("%<long%> and %<short%> specified together for %qs", name);
7730 if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
7732 pedwarn ("long, short, signed or unsigned used invalidly for %qs",
7734 if (flag_pedantic_errors)
7739 /* Discard the type modifiers if they are invalid. */
7750 /* Decide whether an integer type is signed or not.
7751 Optionally treat bitfields as signed by default. */
7755 It is implementation-defined whether a plain (neither
7756 explicitly signed or unsigned) char, short, int, or long
7757 bit-field is signed or unsigned.
7759 Naturally, we extend this to long long as well. Note that
7760 this does not include wchar_t. */
7761 || (bitfield && !flag_signed_bitfields
7763 /* A typedef for plain `int' without `signed' can be
7764 controlled just like plain `int', but a typedef for
7765 `signed int' cannot be so controlled. */
7767 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
7768 && TREE_CODE (type) == INTEGER_TYPE
7769 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
7772 type = long_long_unsigned_type_node;
7774 type = long_unsigned_type_node;
7776 type = short_unsigned_type_node;
7777 else if (type == char_type_node)
7778 type = unsigned_char_type_node;
7779 else if (typedef_decl)
7780 type = unsigned_type_for (type);
7782 type = unsigned_type_node;
7784 else if (signed_p && type == char_type_node)
7785 type = signed_char_type_node;
7787 type = long_long_integer_type_node;
7789 type = long_integer_type_node;
7791 type = short_integer_type_node;
7793 if (declspecs->specs[(int)ds_complex])
7795 if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
7796 error ("complex invalid for %qs", name);
7797 /* If we just have "complex", it is equivalent to
7798 "complex double", but if any modifiers at all are specified it is
7799 the complex form of TYPE. E.g, "complex short" is
7800 "complex short int". */
7802 else if (defaulted_int && ! longlong
7803 && ! (long_p || short_p || signed_p || unsigned_p))
7804 type = complex_double_type_node;
7805 else if (type == integer_type_node)
7806 type = complex_integer_type_node;
7807 else if (type == float_type_node)
7808 type = complex_float_type_node;
7809 else if (type == double_type_node)
7810 type = complex_double_type_node;
7811 else if (type == long_double_type_node)
7812 type = complex_long_double_type_node;
7814 type = build_complex_type (type);
7817 type_quals = TYPE_UNQUALIFIED;
7818 if (declspecs->specs[(int)ds_const])
7819 type_quals |= TYPE_QUAL_CONST;
7820 if (declspecs->specs[(int)ds_volatile])
7821 type_quals |= TYPE_QUAL_VOLATILE;
7822 if (declspecs->specs[(int)ds_restrict])
7823 type_quals |= TYPE_QUAL_RESTRICT;
7824 if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
7825 error ("qualifiers are not allowed on declaration of %<operator %T%>",
7828 if (TREE_CODE (type) == FUNCTION_TYPE
7829 && type_quals != TYPE_UNQUALIFIED)
7831 /* This was an error in C++98 (cv-qualifiers cannot be added to
7832 a function type), but DR 295 makes the code well-formed by
7833 dropping the extra qualifiers. */
7836 tree bad_type = build_qualified_type (type, type_quals);
7837 pedwarn ("ignoring %qV qualifiers added to function type %qT",
7840 type_quals = TYPE_UNQUALIFIED;
7842 type_quals |= cp_type_quals (type);
7843 type = cp_build_qualified_type_real
7844 (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
7845 ? tf_ignore_bad_quals : 0) | tf_warning_or_error));
7846 /* We might have ignored or rejected some of the qualifiers. */
7847 type_quals = cp_type_quals (type);
7850 inlinep = !! declspecs->specs[(int)ds_inline];
7851 virtualp = !! declspecs->specs[(int)ds_virtual];
7852 explicitp = !! declspecs->specs[(int)ds_explicit];
7854 storage_class = declspecs->storage_class;
7855 if (storage_class == sc_static)
7856 staticp = 1 + (decl_context == FIELD);
7858 if (virtualp && staticp == 2)
7860 error ("member %qD cannot be declared both virtual and static", dname);
7861 storage_class = sc_none;
7864 friendp = !! declspecs->specs[(int)ds_friend];
7866 if (dependent_name && !friendp)
7868 error ("%<%T::%D%> is not a valid declarator", ctype, dependent_name);
7869 return error_mark_node;
7872 /* Issue errors about use of storage classes for parameters. */
7873 if (decl_context == PARM)
7875 if (declspecs->specs[(int)ds_typedef])
7877 error ("typedef declaration invalid in parameter declaration");
7878 return error_mark_node;
7880 else if (storage_class == sc_static
7881 || storage_class == sc_extern
7883 error ("storage class specifiers invalid in parameter declarations");
7886 /* Give error if `virtual' is used outside of class declaration. */
7888 && (current_class_name == NULL_TREE || decl_context != FIELD))
7890 error ("virtual outside class declaration");
7894 /* Static anonymous unions are dealt with here. */
7895 if (staticp && decl_context == TYPENAME
7897 && ANON_AGGR_TYPE_P (declspecs->type))
7898 decl_context = FIELD;
7900 /* Warn about storage classes that are invalid for certain
7901 kinds of declarations (parameters, typenames, etc.). */
7904 && storage_class != sc_extern
7905 && storage_class != sc_static)
7906 || declspecs->specs[(int)ds_typedef]))
7908 error ("multiple storage classes in declaration of %qs", name);
7911 if (decl_context != NORMAL
7912 && ((storage_class != sc_none
7913 && storage_class != sc_mutable)
7916 if ((decl_context == PARM || decl_context == CATCHPARM)
7917 && (storage_class == sc_register
7918 || storage_class == sc_auto))
7920 else if (declspecs->specs[(int)ds_typedef])
7922 else if (decl_context == FIELD
7923 /* C++ allows static class elements. */
7924 && storage_class == sc_static)
7925 /* C++ also allows inlines and signed and unsigned elements,
7926 but in those cases we don't come in here. */
7930 if (decl_context == FIELD)
7931 error ("storage class specified for %qs", name);
7934 if (decl_context == PARM || decl_context == CATCHPARM)
7935 error ("storage class specified for parameter %qs", name);
7937 error ("storage class specified for typename");
7939 if (storage_class == sc_register
7940 || storage_class == sc_auto
7941 || storage_class == sc_extern
7943 storage_class = sc_none;
7946 else if (storage_class == sc_extern && initialized
7949 if (toplevel_bindings_p ())
7951 /* It's common practice (and completely valid) to have a const
7952 be initialized and declared extern. */
7953 if (!(type_quals & TYPE_QUAL_CONST))
7954 warning (0, "%qs initialized and declared %<extern%>", name);
7957 error ("%qs has both %<extern%> and initializer", name);
7959 else if (storage_class == sc_extern && funcdef_flag
7960 && ! toplevel_bindings_p ())
7961 error ("nested function %qs declared %<extern%>", name);
7962 else if (toplevel_bindings_p ())
7964 if (storage_class == sc_auto)
7965 error ("top-level declaration of %qs specifies %<auto%>", name);
7968 && storage_class != sc_extern
7969 && storage_class != sc_static)
7971 error ("function-scope %qs implicitly auto and declared %<__thread%>",
7976 if (storage_class && friendp)
7977 error ("storage class specifiers invalid in friend function declarations");
7980 unqualified_id = NULL_TREE;
7983 unqualified_id = id_declarator->u.id.unqualified_name;
7984 switch (TREE_CODE (unqualified_id))
7988 = constructor_name (TREE_OPERAND (unqualified_id, 0));
7991 case IDENTIFIER_NODE:
7992 case TEMPLATE_ID_EXPR:
8000 /* Determine the type of the entity declared by recurring on the
8002 for (; declarator; declarator = declarator->declarator)
8004 const cp_declarator *inner_declarator;
8007 if (type == error_mark_node)
8008 return error_mark_node;
8010 attrs = declarator->attributes;
8016 if (declarator == NULL || declarator->kind == cdk_id)
8017 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
8018 if (declarator->kind == cdk_function)
8019 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
8020 if (declarator->kind == cdk_array)
8021 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
8022 returned_attrs = decl_attributes (&type,
8023 chainon (returned_attrs, attrs),
8027 if (declarator->kind == cdk_id)
8030 inner_declarator = declarator->declarator;
8032 switch (declarator->kind)
8035 type = create_array_type_for_decl (dname, type,
8036 declarator->u.array.bounds);
8044 /* Declaring a function type.
8045 Make sure we have a valid type for the function to return. */
8047 if (type_quals != TYPE_UNQUALIFIED)
8049 if (SCALAR_TYPE_P (type) || VOID_TYPE_P (type))
8050 warning (OPT_Wignored_qualifiers,
8051 "type qualifiers ignored on function return type");
8052 /* We now know that the TYPE_QUALS don't apply to the
8053 decl, but to its return type. */
8054 type_quals = TYPE_UNQUALIFIED;
8055 set_no_warning = true;
8058 /* Warn about some types functions can't return. */
8060 if (TREE_CODE (type) == FUNCTION_TYPE)
8062 error ("%qs declared as function returning a function", name);
8063 type = integer_type_node;
8065 if (TREE_CODE (type) == ARRAY_TYPE)
8067 error ("%qs declared as function returning an array", name);
8068 type = integer_type_node;
8071 /* Pick up type qualifiers which should be applied to `this'. */
8072 memfn_quals = declarator->u.function.qualifiers;
8074 /* Pick up the exception specifications. */
8075 raises = declarator->u.function.exception_specification;
8077 /* Say it's a definition only for the CALL_EXPR
8078 closest to the identifier. */
8079 funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id;
8081 if (ctype == NULL_TREE
8082 && decl_context == FIELD
8084 && (friendp == 0 || dname == current_class_name))
8085 ctype = current_class_type;
8087 if (ctype && (sfk == sfk_constructor
8088 || sfk == sfk_destructor))
8090 /* We are within a class's scope. If our declarator name
8091 is the same as the class name, and we are defining
8092 a function, then it is a constructor/destructor, and
8093 therefore returns a void type. */
8095 /* ISO C++ 12.4/2. A destructor may not be declared
8096 const or volatile. A destructor may not be
8099 ISO C++ 12.1. A constructor may not be declared
8100 const or volatile. A constructor may not be
8101 virtual. A constructor may not be static. */
8103 error ((flags == DTOR_FLAG)
8104 ? "destructor cannot be static member function"
8105 : "constructor cannot be static member function");
8108 error ((flags == DTOR_FLAG)
8109 ? "destructors may not be cv-qualified"
8110 : "constructors may not be cv-qualified");
8111 memfn_quals = TYPE_UNQUALIFIED;
8114 if (decl_context == FIELD
8115 && !member_function_or_else (ctype,
8118 return error_mark_node;
8120 if (flags != DTOR_FLAG)
8122 /* It's a constructor. */
8127 pedwarn ("constructors cannot be declared virtual");
8130 if (decl_context == FIELD
8131 && sfk != sfk_constructor)
8132 return error_mark_node;
8134 if (decl_context == FIELD)
8140 error ("can't initialize friend function %qs", name);
8143 /* Cannot be both friend and virtual. */
8144 error ("virtual functions cannot be friends");
8147 if (decl_context == NORMAL)
8148 error ("friend declaration not in class definition");
8149 if (current_function_decl && funcdef_flag)
8150 error ("can't define friend function %qs in a local "
8155 arg_types = grokparms (declarator->u.function.parameters,
8158 if (inner_declarator
8159 && inner_declarator->kind == cdk_id
8160 && inner_declarator->u.id.sfk == sfk_destructor
8161 && arg_types != void_list_node)
8163 error ("destructors may not have parameters");
8164 arg_types = void_list_node;
8168 type = build_function_type (type, arg_types);
8175 /* Filter out pointers-to-references and references-to-references.
8176 We can get these if a TYPE_DECL is used. */
8178 if (TREE_CODE (type) == REFERENCE_TYPE)
8180 if (declarator->kind != cdk_reference)
8182 error ("cannot declare pointer to %q#T", type);
8183 type = TREE_TYPE (type);
8186 /* In C++0x, we allow reference to reference declarations
8187 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
8188 and template type arguments [14.3.1/4 temp.arg.type]. The
8189 check for direct reference to reference declarations, which
8190 are still forbidden, occurs below. Reasoning behind the change
8191 can be found in DR106, DR540, and the rvalue reference
8193 else if (cxx_dialect == cxx98)
8195 error ("cannot declare reference to %q#T", type);
8196 type = TREE_TYPE (type);
8199 else if (VOID_TYPE_P (type))
8201 if (declarator->kind == cdk_reference)
8202 error ("cannot declare reference to %q#T", type);
8203 else if (declarator->kind == cdk_ptrmem)
8204 error ("cannot declare pointer to %q#T member", type);
8207 /* We now know that the TYPE_QUALS don't apply to the decl,
8208 but to the target of the pointer. */
8209 type_quals = TYPE_UNQUALIFIED;
8211 if (declarator->kind == cdk_ptrmem
8212 && (TREE_CODE (type) == FUNCTION_TYPE
8213 || (memfn_quals && TREE_CODE (type) == METHOD_TYPE)))
8215 memfn_quals |= cp_type_quals (type);
8216 type = build_memfn_type (type,
8217 declarator->u.pointer.class_type,
8219 memfn_quals = TYPE_UNQUALIFIED;
8222 if (declarator->kind == cdk_reference)
8224 /* In C++0x, the type we are creating a reference to might be
8225 a typedef which is itself a reference type. In that case,
8226 we follow the reference collapsing rules in
8227 [7.1.3/8 dcl.typedef] to create the final reference type:
8229 "If a typedef TD names a type that is a reference to a type
8230 T, an attempt to create the type 'lvalue reference to cv TD'
8231 creates the type 'lvalue reference to T,' while an attempt
8232 to create the type "rvalue reference to cv TD' creates the
8235 if (!VOID_TYPE_P (type))
8236 type = cp_build_reference_type
8237 ((TREE_CODE (type) == REFERENCE_TYPE
8238 ? TREE_TYPE (type) : type),
8239 (declarator->u.reference.rvalue_ref
8240 && (TREE_CODE(type) != REFERENCE_TYPE
8241 || TYPE_REF_IS_RVALUE (type))));
8243 /* In C++0x, we need this check for direct reference to
8244 reference declarations, which are forbidden by
8245 [8.3.2/5 dcl.ref]. Reference to reference declarations
8246 are only allowed indirectly through typedefs and template
8247 type arguments. Example:
8249 void foo(int & &); // invalid ref-to-ref decl
8251 typedef int & int_ref;
8252 void foo(int_ref &); // valid ref-to-ref decl
8254 if (inner_declarator && inner_declarator->kind == cdk_reference)
8255 error ("cannot declare reference to %q#T, which is not "
8256 "a typedef or a template type argument", type);
8258 else if (TREE_CODE (type) == METHOD_TYPE)
8259 type = build_ptrmemfunc_type (build_pointer_type (type));
8260 else if (declarator->kind == cdk_ptrmem)
8262 gcc_assert (TREE_CODE (declarator->u.pointer.class_type)
8264 if (declarator->u.pointer.class_type == error_mark_node)
8265 /* We will already have complained. */
8266 type = error_mark_node;
8268 type = build_ptrmem_type (declarator->u.pointer.class_type,
8272 type = build_pointer_type (type);
8274 /* Process a list of type modifier keywords (such as
8275 const or volatile) that were given inside the `*' or `&'. */
8277 if (declarator->u.pointer.qualifiers)
8280 = cp_build_qualified_type (type,
8281 declarator->u.pointer.qualifiers);
8282 type_quals = cp_type_quals (type);
8295 if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR
8296 && TREE_CODE (type) != FUNCTION_TYPE
8297 && TREE_CODE (type) != METHOD_TYPE)
8299 error ("template-id %qD used as a declarator",
8301 unqualified_id = dname;
8304 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
8305 qualified with a class-name, turn it into a METHOD_TYPE, unless
8306 we know that the function is static. We take advantage of this
8307 opportunity to do other processing that pertains to entities
8308 explicitly declared to be class members. Note that if DECLARATOR
8309 is non-NULL, we know it is a cdk_id declarator; otherwise, we
8310 would not have exited the loop above. */
8312 && declarator->u.id.qualifying_scope
8313 && TYPE_P (declarator->u.id.qualifying_scope))
8317 ctype = declarator->u.id.qualifying_scope;
8318 ctype = TYPE_MAIN_VARIANT (ctype);
8320 while (t != NULL_TREE && CLASS_TYPE_P (t))
8322 /* You're supposed to have one `template <...>' for every
8323 template class, but you don't need one for a full
8324 specialization. For example:
8326 template <class T> struct S{};
8327 template <> struct S<int> { void f(); };
8328 void S<int>::f () {}
8330 is correct; there shouldn't be a `template <>' for the
8331 definition of `S<int>::f'. */
8332 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t)
8333 && !any_dependent_template_arguments_p (CLASSTYPE_TI_ARGS (t)))
8334 /* T is an explicit (not partial) specialization. All
8335 containing classes must therefore also be explicitly
8338 if ((CLASSTYPE_USE_TEMPLATE (t) || CLASSTYPE_IS_TEMPLATE (t))
8339 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
8340 template_count += 1;
8342 t = TYPE_MAIN_DECL (t);
8343 t = DECL_CONTEXT (t);
8346 if (ctype == current_class_type)
8350 pedwarn ("member functions are implicitly friends of their class");
8354 pedwarn ("extra qualification %<%T::%> on member %qs",
8357 else if (/* If the qualifying type is already complete, then we
8358 can skip the following checks. */
8359 !COMPLETE_TYPE_P (ctype)
8360 && (/* If the function is being defined, then
8361 qualifying type must certainly be complete. */
8363 /* A friend declaration of "T::f" is OK, even if
8364 "T" is a template parameter. But, if this
8365 function is not a friend, the qualifying type
8367 || (!friendp && !CLASS_TYPE_P (ctype))
8368 /* For a declaration, the type need not be
8369 complete, if either it is dependent (since there
8370 is no meaningful definition of complete in that
8371 case) or the qualifying class is currently being
8373 || !(dependent_type_p (ctype)
8374 || currently_open_class (ctype)))
8375 /* Check that the qualifying type is complete. */
8376 && !complete_type_or_else (ctype, NULL_TREE))
8377 return error_mark_node;
8378 else if (TREE_CODE (type) == FUNCTION_TYPE)
8380 tree sname = declarator->u.id.unqualified_name;
8382 if (current_class_type
8383 && (!friendp || funcdef_flag))
8386 ? "cannot define member function %<%T::%s%> within %<%T%>"
8387 : "cannot declare member function %<%T::%s%> within %<%T%>",
8388 ctype, name, current_class_type);
8389 return error_mark_node;
8392 if (TREE_CODE (sname) == IDENTIFIER_NODE
8393 && NEW_DELETE_OPNAME_P (sname))
8394 /* Overloaded operator new and operator delete
8395 are always static functions. */
8398 type = build_memfn_type (type, ctype, memfn_quals);
8400 else if (declspecs->specs[(int)ds_typedef]
8401 && current_class_type)
8403 error ("cannot declare member %<%T::%s%> within %qT",
8404 ctype, name, current_class_type);
8405 return error_mark_node;
8409 /* Now TYPE has the actual type. */
8414 *attrlist = chainon (returned_attrs, *attrlist);
8416 attrlist = &returned_attrs;
8419 /* Handle parameter packs. */
8420 if (parameter_pack_p)
8422 if (decl_context == PARM)
8423 /* Turn the type into a pack expansion.*/
8424 type = make_pack_expansion (type);
8426 error ("non-parameter %qs cannot be a parameter pack", name);
8429 /* Did array size calculations overflow? */
8431 if (TREE_CODE (type) == ARRAY_TYPE
8432 && COMPLETE_TYPE_P (type)
8433 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
8434 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
8436 error ("size of array %qs is too large", name);
8437 /* If we proceed with the array type as it is, we'll eventually
8438 crash in tree_low_cst(). */
8439 type = error_mark_node;
8442 if ((decl_context == FIELD || decl_context == PARM)
8443 && !processing_template_decl
8444 && variably_modified_type_p (type, NULL_TREE))
8446 if (decl_context == FIELD)
8447 error ("data member may not have variably modified type %qT", type);
8449 error ("parameter may not have variably modified type %qT", type);
8450 type = error_mark_node;
8453 if (explicitp == 1 || (explicitp && friendp))
8455 /* [dcl.fct.spec] The explicit specifier shall only be used in
8456 declarations of constructors within a class definition. */
8457 error ("only declarations of constructors can be %<explicit%>");
8461 if (storage_class == sc_mutable)
8463 if (decl_context != FIELD || friendp)
8465 error ("non-member %qs cannot be declared %<mutable%>", name);
8466 storage_class = sc_none;
8468 else if (decl_context == TYPENAME || declspecs->specs[(int)ds_typedef])
8470 error ("non-object member %qs cannot be declared %<mutable%>", name);
8471 storage_class = sc_none;
8473 else if (TREE_CODE (type) == FUNCTION_TYPE
8474 || TREE_CODE (type) == METHOD_TYPE)
8476 error ("function %qs cannot be declared %<mutable%>", name);
8477 storage_class = sc_none;
8481 error ("static %qs cannot be declared %<mutable%>", name);
8482 storage_class = sc_none;
8484 else if (type_quals & TYPE_QUAL_CONST)
8486 error ("const %qs cannot be declared %<mutable%>", name);
8487 storage_class = sc_none;
8491 /* If this is declaring a typedef name, return a TYPE_DECL. */
8492 if (declspecs->specs[(int)ds_typedef] && decl_context != TYPENAME)
8496 /* Note that the grammar rejects storage classes
8497 in typenames, fields or parameters. */
8498 if (current_lang_name == lang_name_java)
8499 TYPE_FOR_JAVA (type) = 1;
8501 /* This declaration:
8503 typedef void f(int) const;
8505 declares a function type which is not a member of any
8506 particular class, but which is cv-qualified; for
8507 example "f S::*" declares a pointer to a const-qualified
8508 member function of S. We record the cv-qualification in the
8510 if (memfn_quals && TREE_CODE (type) == FUNCTION_TYPE)
8512 type = cp_build_qualified_type (type, memfn_quals);
8514 /* We have now dealt with these qualifiers. */
8515 memfn_quals = TYPE_UNQUALIFIED;
8518 if (decl_context == FIELD)
8519 decl = build_lang_decl (TYPE_DECL, unqualified_id, type);
8521 decl = build_decl (TYPE_DECL, unqualified_id, type);
8522 if (id_declarator && declarator->u.id.qualifying_scope)
8523 error ("%Jtypedef name may not be a nested-name-specifier", decl);
8525 if (decl_context != FIELD)
8527 if (!current_function_decl)
8528 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8529 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl)
8530 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
8531 (current_function_decl)))
8532 /* The TYPE_DECL is "abstract" because there will be
8533 clones of this constructor/destructor, and there will
8534 be copies of this TYPE_DECL generated in those
8536 DECL_ABSTRACT (decl) = 1;
8538 else if (constructor_name_p (unqualified_id, current_class_type))
8539 pedwarn ("ISO C++ forbids nested type %qD with same name "
8540 "as enclosing class",
8543 /* If the user declares "typedef struct {...} foo" then the
8544 struct will have an anonymous name. Fill that name in now.
8545 Nothing can refer to it, so nothing needs know about the name
8547 if (type != error_mark_node
8550 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
8551 && TYPE_ANONYMOUS_P (type)
8552 /* Don't do this if there are attributes. */
8553 && (!attrlist || !*attrlist)
8554 && cp_type_quals (type) == TYPE_UNQUALIFIED)
8556 tree oldname = TYPE_NAME (type);
8559 /* Replace the anonymous name with the real name everywhere. */
8560 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
8561 if (TYPE_NAME (t) == oldname)
8562 TYPE_NAME (t) = decl;
8564 if (TYPE_LANG_SPECIFIC (type))
8565 TYPE_WAS_ANONYMOUS (type) = 1;
8567 /* If this is a typedef within a template class, the nested
8568 type is a (non-primary) template. The name for the
8569 template needs updating as well. */
8570 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
8571 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
8572 = TYPE_IDENTIFIER (type);
8574 /* FIXME remangle member functions; member functions of a
8575 type with external linkage have external linkage. */
8579 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
8580 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
8582 bad_specifiers (decl, "type", virtualp,
8583 memfn_quals != TYPE_UNQUALIFIED,
8584 inlinep, friendp, raises != NULL_TREE);
8589 /* Detect the case of an array type of unspecified size
8590 which came, as such, direct from a typedef name.
8591 We must copy the type, so that the array's domain can be
8592 individually set by the object's initializer. */
8594 if (type && typedef_type
8595 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
8596 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
8597 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
8599 /* Detect where we're using a typedef of function type to declare a
8600 function. PARMS will not be set, so we must create it now. */
8602 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
8604 tree decls = NULL_TREE;
8607 for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
8609 tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
8611 TREE_CHAIN (decl) = decls;
8615 parms = nreverse (decls);
8617 if (decl_context != TYPENAME)
8619 /* A cv-qualifier-seq shall only be part of the function type
8620 for a non-static member function. [8.3.5/4 dcl.fct] */
8621 if (cp_type_quals (type) != TYPE_UNQUALIFIED
8622 && (current_class_type == NULL_TREE || staticp) )
8625 ? G_("qualified function types cannot be used to "
8626 "declare static member functions")
8627 : G_("qualified function types cannot be used to "
8628 "declare free functions"));
8629 type = TYPE_MAIN_VARIANT (type);
8632 /* The qualifiers on the function type become the qualifiers on
8633 the non-static member function. */
8634 memfn_quals |= cp_type_quals (type);
8638 /* If this is a type name (such as, in a cast or sizeof),
8639 compute the type and return it now. */
8641 if (decl_context == TYPENAME)
8643 /* Note that the grammar rejects storage classes
8644 in typenames, fields or parameters. */
8645 if (type_quals != TYPE_UNQUALIFIED)
8646 type_quals = TYPE_UNQUALIFIED;
8648 /* Special case: "friend class foo" looks like a TYPENAME context. */
8651 if (type_quals != TYPE_UNQUALIFIED)
8653 error ("type qualifiers specified for friend class declaration");
8654 type_quals = TYPE_UNQUALIFIED;
8658 error ("%<inline%> specified for friend class declaration");
8664 /* Don't allow friend declaration without a class-key. */
8665 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
8666 pedwarn ("template parameters cannot be friends");
8667 else if (TREE_CODE (type) == TYPENAME_TYPE)
8668 pedwarn ("friend declaration requires class-key, "
8669 "i.e. %<friend class %T::%D%>",
8670 TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
8672 pedwarn ("friend declaration requires class-key, "
8673 "i.e. %<friend %#T%>",
8677 /* Only try to do this stuff if we didn't already give up. */
8678 if (type != integer_type_node)
8680 /* A friendly class? */
8681 if (current_class_type)
8682 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
8685 error ("trying to make class %qT a friend of global scope",
8688 type = void_type_node;
8691 else if (memfn_quals)
8693 if (ctype == NULL_TREE)
8695 if (TREE_CODE (type) != METHOD_TYPE)
8696 error ("invalid qualifiers on non-member function type");
8698 ctype = TYPE_METHOD_BASETYPE (type);
8701 type = build_memfn_type (type, ctype, memfn_quals);
8706 else if (unqualified_id == NULL_TREE && decl_context != PARM
8707 && decl_context != CATCHPARM
8708 && TREE_CODE (type) != UNION_TYPE
8711 error ("abstract declarator %qT used as declaration", type);
8712 return error_mark_node;
8715 /* Only functions may be declared using an operator-function-id. */
8717 && IDENTIFIER_OPNAME_P (unqualified_id)
8718 && TREE_CODE (type) != FUNCTION_TYPE
8719 && TREE_CODE (type) != METHOD_TYPE)
8721 error ("declaration of %qD as non-function", unqualified_id);
8722 return error_mark_node;
8725 /* We don't check parameter types here because we can emit a better
8726 error message later. */
8727 if (decl_context != PARM)
8729 type = check_var_type (unqualified_id, type);
8730 if (type == error_mark_node)
8731 return error_mark_node;
8734 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
8735 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
8737 if (decl_context == PARM || decl_context == CATCHPARM)
8739 if (ctype || in_namespace)
8740 error ("cannot use %<::%> in parameter declaration");
8742 /* A parameter declared as an array of T is really a pointer to T.
8743 One declared as a function is really a pointer to a function.
8744 One declared as a member is really a pointer to member. */
8746 if (TREE_CODE (type) == ARRAY_TYPE)
8748 /* Transfer const-ness of array into that of type pointed to. */
8749 type = build_pointer_type (TREE_TYPE (type));
8750 type_quals = TYPE_UNQUALIFIED;
8752 else if (TREE_CODE (type) == FUNCTION_TYPE)
8753 type = build_pointer_type (type);
8759 if (decl_context == PARM)
8761 decl = cp_build_parm_decl (unqualified_id, type);
8763 bad_specifiers (decl, "parameter", virtualp,
8764 memfn_quals != TYPE_UNQUALIFIED,
8765 inlinep, friendp, raises != NULL_TREE);
8767 else if (decl_context == FIELD)
8769 /* The C99 flexible array extension. */
8770 if (!staticp && TREE_CODE (type) == ARRAY_TYPE
8771 && TYPE_DOMAIN (type) == NULL_TREE)
8773 tree itype = compute_array_index_type (dname, integer_zero_node);
8774 type = build_cplus_array_type (TREE_TYPE (type), itype);
8777 if (type == error_mark_node)
8779 /* Happens when declaring arrays of sizes which
8780 are error_mark_node, for example. */
8783 else if (in_namespace && !friendp)
8785 /* Something like struct S { int N::j; }; */
8786 error ("invalid use of %<::%>");
8787 return error_mark_node;
8789 else if (TREE_CODE (type) == FUNCTION_TYPE)
8792 tree function_context;
8796 if (ctype == NULL_TREE)
8797 ctype = current_class_type;
8799 if (ctype == NULL_TREE)
8801 error ("can't make %qD into a method -- not in a class",
8803 return error_mark_node;
8806 /* ``A union may [ ... ] not [ have ] virtual functions.''
8808 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
8810 error ("function %qD declared virtual inside a union",
8812 return error_mark_node;
8815 if (NEW_DELETE_OPNAME_P (unqualified_id))
8819 error ("%qD cannot be declared virtual, since it "
8825 else if (staticp < 2)
8826 type = build_memfn_type (type, ctype, memfn_quals);
8829 /* Check that the name used for a destructor makes sense. */
8830 if (sfk == sfk_destructor)
8834 gcc_assert (friendp);
8835 error ("expected qualified name in friend declaration "
8836 "for destructor %qD",
8837 id_declarator->u.id.unqualified_name);
8838 return error_mark_node;
8841 if (!same_type_p (TREE_OPERAND
8842 (id_declarator->u.id.unqualified_name, 0),
8845 error ("declaration of %qD as member of %qT",
8846 id_declarator->u.id.unqualified_name, ctype);
8847 return error_mark_node;
8850 else if (sfk == sfk_constructor && friendp)
8852 error ("expected qualified name in friend declaration "
8853 "for constructor %qD",
8854 id_declarator->u.id.unqualified_name);
8855 return error_mark_node;
8858 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
8859 function_context = (ctype != NULL_TREE) ?
8860 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
8861 publicp = (! friendp || ! staticp)
8862 && function_context == NULL_TREE;
8863 decl = grokfndecl (ctype, type,
8864 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
8865 ? unqualified_id : dname,
8868 virtualp, flags, memfn_quals, raises,
8869 friendp ? -1 : 0, friendp, publicp, inlinep,
8871 funcdef_flag, template_count, in_namespace, attrlist);
8872 if (decl == NULL_TREE)
8873 return error_mark_node;
8875 /* This clobbers the attrs stored in `decl' from `attrlist'. */
8876 /* The decl and setting of decl_attr is also turned off. */
8877 decl = build_decl_attribute_variant (decl, decl_attr);
8880 /* [class.conv.ctor]
8882 A constructor declared without the function-specifier
8883 explicit that can be called with a single parameter
8884 specifies a conversion from the type of its first
8885 parameter to the type of its class. Such a constructor
8886 is called a converting constructor. */
8888 DECL_NONCONVERTING_P (decl) = 1;
8889 else if (DECL_CONSTRUCTOR_P (decl))
8891 /* The constructor can be called with exactly one
8892 parameter if there is at least one parameter, and
8893 any subsequent parameters have default arguments.
8894 Ignore any compiler-added parms. */
8895 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
8897 if (arg_types == void_list_node
8899 && TREE_CHAIN (arg_types)
8900 && TREE_CHAIN (arg_types) != void_list_node
8901 && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
8902 DECL_NONCONVERTING_P (decl) = 1;
8905 else if (TREE_CODE (type) == METHOD_TYPE)
8907 /* We only get here for friend declarations of
8908 members of other classes. */
8909 /* All method decls are public, so tell grokfndecl to set
8910 TREE_PUBLIC, also. */
8911 decl = grokfndecl (ctype, type,
8912 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
8913 ? unqualified_id : dname,
8916 virtualp, flags, memfn_quals, raises,
8917 friendp ? -1 : 0, friendp, 1, 0, sfk,
8918 funcdef_flag, template_count, in_namespace,
8920 if (decl == NULL_TREE)
8921 return error_mark_node;
8923 else if (!staticp && !dependent_type_p (type)
8924 && !COMPLETE_TYPE_P (complete_type (type))
8925 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
8928 error ("field %qD has incomplete type", unqualified_id);
8930 error ("name %qT has incomplete type", type);
8932 /* If we're instantiating a template, tell them which
8933 instantiation made the field's type be incomplete. */
8934 if (current_class_type
8935 && TYPE_NAME (current_class_type)
8936 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
8938 && declspecs->type == type)
8939 error (" in instantiation of template %qT",
8940 current_class_type);
8942 return error_mark_node;
8948 error ("%qE is neither function nor member function; "
8949 "cannot be declared friend", unqualified_id);
8957 /* Friends are treated specially. */
8958 if (ctype == current_class_type)
8959 ; /* We already issued a pedwarn. */
8960 else if (decl && DECL_NAME (decl))
8962 if (template_class_depth (current_class_type) == 0)
8964 decl = check_explicit_specialization
8965 (unqualified_id, decl, template_count,
8966 2 * funcdef_flag + 4);
8967 if (decl == error_mark_node)
8968 return error_mark_node;
8971 decl = do_friend (ctype, unqualified_id, decl,
8977 return error_mark_node;
8980 /* Structure field. It may not be a function, except for C++. */
8982 if (decl == NULL_TREE)
8988 /* An attempt is being made to initialize a non-static
8989 member. But, from [class.mem]:
8991 4 A member-declarator can contain a
8992 constant-initializer only if it declares a static
8993 member (_class.static_) of integral or enumeration
8994 type, see _class.static.data_.
8996 This used to be relatively common practice, but
8997 the rest of the compiler does not correctly
8998 handle the initialization unless the member is
8999 static so we make it static below. */
9000 pedwarn ("ISO C++ forbids initialization of member %qD",
9002 pedwarn ("making %qD static", unqualified_id);
9006 if (uses_template_parms (type))
9007 /* We'll check at instantiation time. */
9009 else if (check_static_variable_definition (unqualified_id,
9011 /* If we just return the declaration, crashes
9012 will sometimes occur. We therefore return
9013 void_type_node, as if this was a friend
9014 declaration, to cause callers to completely
9015 ignore this declaration. */
9016 return error_mark_node;
9021 /* C++ allows static class members. All other work
9022 for this is done by grokfield. */
9023 decl = build_lang_decl (VAR_DECL, unqualified_id, type);
9024 set_linkage_for_static_data_member (decl);
9025 /* Even if there is an in-class initialization, DECL
9026 is considered undefined until an out-of-class
9027 definition is provided. */
9028 DECL_EXTERNAL (decl) = 1;
9031 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
9035 decl = build_decl (FIELD_DECL, unqualified_id, type);
9036 DECL_NONADDRESSABLE_P (decl) = bitfield;
9037 if (bitfield && !unqualified_id)
9038 TREE_NO_WARNING (decl) = 1;
9040 if (storage_class == sc_mutable)
9042 DECL_MUTABLE_P (decl) = 1;
9043 storage_class = sc_none;
9047 bad_specifiers (decl, "field", virtualp,
9048 memfn_quals != TYPE_UNQUALIFIED,
9049 inlinep, friendp, raises != NULL_TREE);
9052 else if (TREE_CODE (type) == FUNCTION_TYPE
9053 || TREE_CODE (type) == METHOD_TYPE)
9058 if (!unqualified_id)
9059 return error_mark_node;
9061 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
9062 original_name = dname;
9064 original_name = unqualified_id;
9066 if (storage_class == sc_auto)
9067 error ("storage class %<auto%> invalid for function %qs", name);
9068 else if (storage_class == sc_register)
9069 error ("storage class %<register%> invalid for function %qs", name);
9071 error ("storage class %<__thread%> invalid for function %qs", name);
9073 /* Function declaration not at top level.
9074 Storage classes other than `extern' are not allowed
9075 and `extern' makes no difference. */
9076 if (! toplevel_bindings_p ()
9077 && (storage_class == sc_static
9078 || declspecs->specs[(int)ds_inline])
9081 if (storage_class == sc_static)
9082 pedwarn ("%<static%> specified invalid for function %qs "
9083 "declared out of global scope", name);
9085 pedwarn ("%<inline%> specifier invalid for function %qs "
9086 "declared out of global scope", name);
9089 if (ctype == NULL_TREE)
9093 error ("virtual non-class function %qs", name);
9097 else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2
9098 && !NEW_DELETE_OPNAME_P (original_name))
9099 type = build_method_type_directly (ctype,
9101 TYPE_ARG_TYPES (type));
9103 /* Record presence of `static'. */
9104 publicp = (ctype != NULL_TREE
9105 || storage_class == sc_extern
9106 || storage_class != sc_static);
9108 decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
9109 virtualp, flags, memfn_quals, raises,
9111 publicp, inlinep, sfk, funcdef_flag,
9112 template_count, in_namespace, attrlist);
9113 if (decl == NULL_TREE)
9114 return error_mark_node;
9118 int invalid_static = 0;
9120 /* Don't allow a static member function in a class, and forbid
9121 declaring main to be static. */
9122 if (TREE_CODE (type) == METHOD_TYPE)
9124 pedwarn ("cannot declare member function %qD to have "
9125 "static linkage", decl);
9128 else if (current_function_decl)
9130 /* FIXME need arm citation */
9131 error ("cannot declare static function inside another function");
9138 storage_class = sc_none;
9144 /* It's a variable. */
9146 /* An uninitialized decl with `extern' is a reference. */
9147 decl = grokvardecl (type, unqualified_id,
9150 (type_quals & TYPE_QUAL_CONST) != 0,
9151 ctype ? ctype : in_namespace);
9152 bad_specifiers (decl, "variable", virtualp,
9153 memfn_quals != TYPE_UNQUALIFIED,
9154 inlinep, friendp, raises != NULL_TREE);
9158 DECL_CONTEXT (decl) = ctype;
9161 pedwarn ("%<static%> may not be used when defining "
9162 "(as opposed to declaring) a static data member");
9164 storage_class = sc_none;
9166 if (storage_class == sc_register && TREE_STATIC (decl))
9168 error ("static member %qD declared %<register%>", decl);
9169 storage_class = sc_none;
9171 if (storage_class == sc_extern && pedantic)
9173 pedwarn ("cannot explicitly declare member %q#D to have "
9176 storage_class = sc_none;
9181 /* Record `register' declaration for warnings on &
9182 and in case doing stupid register allocation. */
9184 if (storage_class == sc_register)
9185 DECL_REGISTER (decl) = 1;
9186 else if (storage_class == sc_extern)
9187 DECL_THIS_EXTERN (decl) = 1;
9188 else if (storage_class == sc_static)
9189 DECL_THIS_STATIC (decl) = 1;
9191 /* Record constancy and volatility on the DECL itself . There's
9192 no need to do this when processing a template; we'll do this
9193 for the instantiated declaration based on the type of DECL. */
9194 if (!processing_template_decl)
9195 cp_apply_type_quals_to_decl (type_quals, decl);
9198 TREE_NO_WARNING (decl) = 1;
9204 /* Subroutine of start_function. Ensure that each of the parameter
9205 types (as listed in PARMS) is complete, as is required for a
9206 function definition. */
9209 require_complete_types_for_parms (tree parms)
9211 for (; parms; parms = TREE_CHAIN (parms))
9213 if (dependent_type_p (TREE_TYPE (parms)))
9215 if (!VOID_TYPE_P (TREE_TYPE (parms))
9216 && complete_type_or_else (TREE_TYPE (parms), parms))
9218 relayout_decl (parms);
9219 DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
9222 /* grokparms or complete_type_or_else will have already issued
9224 TREE_TYPE (parms) = error_mark_node;
9228 /* Returns nonzero if T is a local variable. */
9231 local_variable_p (const_tree t)
9233 if ((TREE_CODE (t) == VAR_DECL
9234 /* A VAR_DECL with a context that is a _TYPE is a static data
9236 && !TYPE_P (CP_DECL_CONTEXT (t))
9237 /* Any other non-local variable must be at namespace scope. */
9238 && !DECL_NAMESPACE_SCOPE_P (t))
9239 || (TREE_CODE (t) == PARM_DECL))
9245 /* Like local_variable_p, but suitable for use as a tree-walking
9249 local_variable_p_walkfn (tree *tp, int *walk_subtrees,
9250 void *data ATTRIBUTE_UNUSED)
9252 if (local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
9254 else if (TYPE_P (*tp))
9261 /* Check that ARG, which is a default-argument expression for a
9262 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
9263 something goes wrong. DECL may also be a _TYPE node, rather than a
9264 DECL, if there is no DECL available. */
9267 check_default_argument (tree decl, tree arg)
9272 if (TREE_CODE (arg) == DEFAULT_ARG)
9273 /* We get a DEFAULT_ARG when looking at an in-class declaration
9274 with a default argument. Ignore the argument for now; we'll
9275 deal with it after the class is complete. */
9284 decl_type = TREE_TYPE (decl);
9286 if (arg == error_mark_node
9287 || decl == error_mark_node
9288 || TREE_TYPE (arg) == error_mark_node
9289 || decl_type == error_mark_node)
9290 /* Something already went wrong. There's no need to check
9292 return error_mark_node;
9294 /* [dcl.fct.default]
9296 A default argument expression is implicitly converted to the
9298 if (!TREE_TYPE (arg)
9299 || !can_convert_arg (decl_type, TREE_TYPE (arg), arg, LOOKUP_NORMAL))
9302 error ("default argument for %q#D has type %qT",
9303 decl, TREE_TYPE (arg));
9305 error ("default argument for parameter of type %qT has type %qT",
9306 decl_type, TREE_TYPE (arg));
9308 return error_mark_node;
9311 /* [dcl.fct.default]
9313 Local variables shall not be used in default argument
9316 The keyword `this' shall not be used in a default argument of a
9318 var = cp_walk_tree_without_duplicates (&arg, local_variable_p_walkfn, NULL);
9321 error ("default argument %qE uses local variable %qD", arg, var);
9322 return error_mark_node;
9329 /* Decode the list of parameter types for a function type.
9330 Given the list of things declared inside the parens,
9331 return a list of types.
9333 If this parameter does not end with an ellipsis, we append
9336 *PARMS is set to the chain of PARM_DECLs created. */
9339 grokparms (cp_parameter_declarator *first_parm, tree *parms)
9341 tree result = NULL_TREE;
9342 tree decls = NULL_TREE;
9343 int ellipsis = !first_parm || first_parm->ellipsis_p;
9344 cp_parameter_declarator *parm;
9346 struct pointer_set_t *unique_decls = pointer_set_create ();
9348 for (parm = first_parm; parm != NULL; parm = parm->next)
9350 tree type = NULL_TREE;
9351 tree init = parm->default_argument;
9355 if (parm == no_parameters)
9358 attrs = parm->decl_specifiers.attributes;
9359 parm->decl_specifiers.attributes = NULL_TREE;
9360 decl = grokdeclarator (parm->declarator, &parm->decl_specifiers,
9361 PARM, init != NULL_TREE, &attrs);
9362 if (! decl || TREE_TYPE (decl) == error_mark_node)
9366 cplus_decl_attributes (&decl, attrs, 0);
9368 type = TREE_TYPE (decl);
9369 if (VOID_TYPE_P (type))
9371 if (same_type_p (type, void_type_node)
9372 && DECL_SELF_REFERENCE_P (type)
9373 && !DECL_NAME (decl) && !result && !parm->next && !ellipsis)
9374 /* this is a parmlist of `(void)', which is ok. */
9376 cxx_incomplete_type_error (decl, type);
9377 /* It's not a good idea to actually create parameters of
9378 type `void'; other parts of the compiler assume that a
9379 void type terminates the parameter list. */
9380 type = error_mark_node;
9381 TREE_TYPE (decl) = error_mark_node;
9384 if (type != error_mark_node
9385 && TYPE_FOR_JAVA (type)
9386 && IS_AGGR_TYPE (type))
9388 error ("parameter %qD has Java class type", decl);
9389 type = error_mark_node;
9390 TREE_TYPE (decl) = error_mark_node;
9394 if (type != error_mark_node)
9396 /* Top-level qualifiers on the parameters are
9397 ignored for function types. */
9398 type = cp_build_qualified_type (type, 0);
9399 if (TREE_CODE (type) == METHOD_TYPE)
9401 error ("parameter %qD invalidly declared method type", decl);
9402 type = build_pointer_type (type);
9403 TREE_TYPE (decl) = type;
9405 else if (abstract_virtuals_error (decl, type))
9406 any_error = 1; /* Seems like a good idea. */
9407 else if (POINTER_TYPE_P (type))
9409 /* [dcl.fct]/6, parameter types cannot contain pointers
9410 (references) to arrays of unknown bound. */
9411 tree t = TREE_TYPE (type);
9412 int ptr = TYPE_PTR_P (type);
9418 else if (TREE_CODE (t) != ARRAY_TYPE)
9420 else if (!TYPE_DOMAIN (t))
9424 if (TREE_CODE (t) == ARRAY_TYPE)
9425 error ("parameter %qD includes %s to array of unknown "
9427 decl, ptr ? "pointer" : "reference", t);
9432 else if (init && !processing_template_decl)
9433 init = check_default_argument (decl, init);
9436 if (TREE_CODE (decl) == PARM_DECL
9437 && FUNCTION_PARAMETER_PACK_P (decl)
9439 error ("parameter packs must be at the end of the parameter list");
9441 if (DECL_NAME (decl))
9443 if (pointer_set_contains (unique_decls, DECL_NAME (decl)))
9444 error ("multiple parameters named %qE", DECL_NAME (decl));
9446 pointer_set_insert (unique_decls, DECL_NAME (decl));
9449 TREE_CHAIN (decl) = decls;
9451 result = tree_cons (init, type, result);
9453 decls = nreverse (decls);
9454 result = nreverse (result);
9456 result = chainon (result, void_list_node);
9459 pointer_set_destroy (unique_decls);
9464 /* D is a constructor or overloaded `operator='.
9466 Let T be the class in which D is declared. Then, this function
9469 -1 if D's is an ill-formed constructor or copy assignment operator
9470 whose first parameter is of type `T'.
9471 0 if D is not a copy constructor or copy assignment
9473 1 if D is a copy constructor or copy assignment operator whose
9474 first parameter is a reference to const qualified T.
9475 2 if D is a copy constructor or copy assignment operator whose
9476 first parameter is a reference to non-const qualified T.
9478 This function can be used as a predicate. Positive values indicate
9479 a copy constructor and nonzero values indicate a copy assignment
9483 copy_fn_p (const_tree d)
9489 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
9491 if (TREE_CODE (d) == TEMPLATE_DECL
9492 || (DECL_TEMPLATE_INFO (d)
9493 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
9494 /* Instantiations of template member functions are never copy
9495 functions. Note that member functions of templated classes are
9496 represented as template functions internally, and we must
9497 accept those as copy functions. */
9500 args = FUNCTION_FIRST_USER_PARMTYPE (d);
9504 arg_type = TREE_VALUE (args);
9505 if (arg_type == error_mark_node)
9508 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
9510 /* Pass by value copy assignment operator. */
9513 else if (TREE_CODE (arg_type) == REFERENCE_TYPE
9514 && !TYPE_REF_IS_RVALUE (arg_type)
9515 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
9517 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
9523 args = TREE_CHAIN (args);
9525 if (args && args != void_list_node && !TREE_PURPOSE (args))
9526 /* There are more non-optional args. */
9532 /* D is a constructor or overloaded `operator='.
9534 Let T be the class in which D is declared. Then, this function
9535 returns true when D is a move constructor or move assignment
9536 operator, false otherwise. */
9539 move_fn_p (const_tree d)
9543 bool result = false;
9545 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
9547 if (cxx_dialect == cxx98)
9548 /* There are no move constructors if we are in C++98 mode. */
9551 if (TREE_CODE (d) == TEMPLATE_DECL
9552 || (DECL_TEMPLATE_INFO (d)
9553 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
9554 /* Instantiations of template member functions are never copy
9555 functions. Note that member functions of templated classes are
9556 represented as template functions internally, and we must
9557 accept those as copy functions. */
9560 args = FUNCTION_FIRST_USER_PARMTYPE (d);
9564 arg_type = TREE_VALUE (args);
9565 if (arg_type == error_mark_node)
9568 if (TREE_CODE (arg_type) == REFERENCE_TYPE
9569 && TYPE_REF_IS_RVALUE (arg_type)
9570 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)),
9574 args = TREE_CHAIN (args);
9576 if (args && args != void_list_node && !TREE_PURPOSE (args))
9577 /* There are more non-optional args. */
9583 /* Remember any special properties of member function DECL. */
9586 grok_special_member_properties (tree decl)
9590 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
9593 class_type = DECL_CONTEXT (decl);
9594 if (DECL_CONSTRUCTOR_P (decl))
9596 int ctor = copy_fn_p (decl);
9598 if (!DECL_ARTIFICIAL (decl))
9599 TYPE_HAS_USER_CONSTRUCTOR (class_type) = 1;
9605 A non-template constructor for class X is a copy
9606 constructor if its first parameter is of type X&, const
9607 X&, volatile X& or const volatile X&, and either there
9608 are no other parameters or else all other parameters have
9609 default arguments. */
9610 TYPE_HAS_INIT_REF (class_type) = 1;
9612 TYPE_HAS_CONST_INIT_REF (class_type) = 1;
9614 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
9615 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type) = 1;
9617 else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
9621 A non-template assignment operator for class X is a copy
9622 assignment operator if its parameter is of type X, X&, const
9623 X&, volatile X& or const volatile X&. */
9625 int assop = copy_fn_p (decl);
9629 TYPE_HAS_ASSIGN_REF (class_type) = 1;
9631 TYPE_HAS_CONST_ASSIGN_REF (class_type) = 1;
9636 /* Check a constructor DECL has the correct form. Complains
9637 if the class has a constructor of the form X(X). */
9640 grok_ctor_properties (const_tree ctype, const_tree decl)
9642 int ctor_parm = copy_fn_p (decl);
9648 A declaration of a constructor for a class X is ill-formed if
9649 its first parameter is of type (optionally cv-qualified) X
9650 and either there are no other parameters or else all other
9651 parameters have default arguments.
9653 We *don't* complain about member template instantiations that
9654 have this form, though; they can occur as we try to decide
9655 what constructor to use during overload resolution. Since
9656 overload resolution will never prefer such a constructor to
9657 the non-template copy constructor (which is either explicitly
9658 or implicitly defined), there's no need to worry about their
9659 existence. Theoretically, they should never even be
9660 instantiated, but that's hard to forestall. */
9661 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
9669 /* An operator with this code is unary, but can also be binary. */
9672 ambi_op_p (enum tree_code code)
9674 return (code == INDIRECT_REF
9675 || code == ADDR_EXPR
9676 || code == UNARY_PLUS_EXPR
9677 || code == NEGATE_EXPR
9678 || code == PREINCREMENT_EXPR
9679 || code == PREDECREMENT_EXPR);
9682 /* An operator with this name can only be unary. */
9685 unary_op_p (enum tree_code code)
9687 return (code == TRUTH_NOT_EXPR
9688 || code == BIT_NOT_EXPR
9689 || code == COMPONENT_REF
9690 || code == TYPE_EXPR);
9693 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
9694 errors are issued for invalid declarations. */
9697 grok_op_properties (tree decl, bool complain)
9699 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
9701 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
9702 tree name = DECL_NAME (decl);
9703 enum tree_code operator_code;
9708 /* Count the number of arguments and check for ellipsis. */
9709 for (argtype = argtypes, arity = 0;
9710 argtype && argtype != void_list_node;
9711 argtype = TREE_CHAIN (argtype))
9713 ellipsis_p = !argtype;
9715 class_type = DECL_CONTEXT (decl);
9716 if (class_type && !CLASS_TYPE_P (class_type))
9717 class_type = NULL_TREE;
9719 if (DECL_CONV_FN_P (decl))
9720 operator_code = TYPE_EXPR;
9724 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
9725 if (ansi_opname (CODE) == name) \
9727 operator_code = (CODE); \
9730 else if (ansi_assopname (CODE) == name) \
9732 operator_code = (CODE); \
9733 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
9737 #include "operators.def"
9743 gcc_assert (operator_code != LAST_CPLUS_TREE_CODE);
9744 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
9747 switch (operator_code)
9750 TYPE_HAS_NEW_OPERATOR (class_type) = 1;
9754 TYPE_GETS_DELETE (class_type) |= 1;
9758 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type) = 1;
9761 case VEC_DELETE_EXPR:
9762 TYPE_GETS_DELETE (class_type) |= 2;
9769 /* [basic.std.dynamic.allocation]/1:
9771 A program is ill-formed if an allocation function is declared
9772 in a namespace scope other than global scope or declared static
9775 The same also holds true for deallocation functions. */
9776 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR
9777 || operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
9779 if (DECL_NAMESPACE_SCOPE_P (decl))
9781 if (CP_DECL_CONTEXT (decl) != global_namespace)
9783 error ("%qD may not be declared within a namespace", decl);
9786 else if (!TREE_PUBLIC (decl))
9788 error ("%qD may not be declared as static", decl);
9794 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
9796 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
9797 DECL_IS_OPERATOR_NEW (decl) = 1;
9799 else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
9800 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
9803 /* An operator function must either be a non-static member function
9804 or have at least one parameter of a class, a reference to a class,
9805 an enumeration, or a reference to an enumeration. 13.4.0.6 */
9806 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
9808 if (operator_code == TYPE_EXPR
9809 || operator_code == CALL_EXPR
9810 || operator_code == COMPONENT_REF
9811 || operator_code == ARRAY_REF
9812 || operator_code == NOP_EXPR)
9814 error ("%qD must be a nonstatic member function", decl);
9821 if (DECL_STATIC_FUNCTION_P (decl))
9823 error ("%qD must be either a non-static member "
9824 "function or a non-member function", decl);
9828 for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
9830 tree arg = non_reference (TREE_VALUE (p));
9831 if (arg == error_mark_node)
9834 /* IS_AGGR_TYPE, rather than CLASS_TYPE_P, is used
9835 because these checks are performed even on
9836 template functions. */
9837 if (IS_AGGR_TYPE (arg) || TREE_CODE (arg) == ENUMERAL_TYPE)
9841 if (!p || p == void_list_node)
9844 error ("%qD must have an argument of class or "
9845 "enumerated type", decl);
9851 /* There are no restrictions on the arguments to an overloaded
9853 if (operator_code == CALL_EXPR)
9856 /* Warn about conversion operators that will never be used. */
9857 if (IDENTIFIER_TYPENAME_P (name)
9858 && ! DECL_TEMPLATE_INFO (decl)
9860 /* Warn only declaring the function; there is no need to
9861 warn again about out-of-class definitions. */
9862 && class_type == current_class_type)
9864 tree t = TREE_TYPE (name);
9865 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
9866 const char *what = 0;
9869 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
9871 if (TREE_CODE (t) == VOID_TYPE)
9873 else if (class_type)
9875 if (t == class_type)
9876 what = "the same type";
9877 /* Don't force t to be complete here. */
9878 else if (IS_AGGR_TYPE (t)
9879 && COMPLETE_TYPE_P (t)
9880 && DERIVED_FROM_P (t, class_type))
9881 what = "a base class";
9885 warning (OPT_Wconversion, "conversion to %s%s will never use a type "
9886 "conversion operator",
9887 ref ? "a reference to " : "", what);
9890 if (operator_code == COND_EXPR)
9893 error ("ISO C++ prohibits overloading operator ?:");
9896 else if (ellipsis_p)
9898 error ("%qD must not have variable number of arguments", decl);
9901 else if (ambi_op_p (operator_code))
9904 /* We pick the one-argument operator codes by default, so
9905 we don't have to change anything. */
9907 else if (arity == 2)
9909 /* If we thought this was a unary operator, we now know
9910 it to be a binary operator. */
9911 switch (operator_code)
9914 operator_code = MULT_EXPR;
9918 operator_code = BIT_AND_EXPR;
9921 case UNARY_PLUS_EXPR:
9922 operator_code = PLUS_EXPR;
9926 operator_code = MINUS_EXPR;
9929 case PREINCREMENT_EXPR:
9930 operator_code = POSTINCREMENT_EXPR;
9933 case PREDECREMENT_EXPR:
9934 operator_code = POSTDECREMENT_EXPR;
9941 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
9943 if ((operator_code == POSTINCREMENT_EXPR
9944 || operator_code == POSTDECREMENT_EXPR)
9945 && ! processing_template_decl
9946 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
9949 error ("postfix %qD must take %<int%> as its argument",
9952 error ("postfix %qD must take %<int%> as its second "
9960 error ("%qD must take either zero or one argument", decl);
9962 error ("%qD must take either one or two arguments", decl);
9966 /* More Effective C++ rule 6. */
9968 && (operator_code == POSTINCREMENT_EXPR
9969 || operator_code == POSTDECREMENT_EXPR
9970 || operator_code == PREINCREMENT_EXPR
9971 || operator_code == PREDECREMENT_EXPR))
9973 tree arg = TREE_VALUE (argtypes);
9974 tree ret = TREE_TYPE (TREE_TYPE (decl));
9975 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
9976 arg = TREE_TYPE (arg);
9977 arg = TYPE_MAIN_VARIANT (arg);
9978 if (operator_code == PREINCREMENT_EXPR
9979 || operator_code == PREDECREMENT_EXPR)
9981 if (TREE_CODE (ret) != REFERENCE_TYPE
9982 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
9984 warning (OPT_Weffc__, "prefix %qD should return %qT", decl,
9985 build_reference_type (arg));
9989 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
9990 warning (OPT_Weffc__, "postfix %qD should return %qT", decl, arg);
9994 else if (unary_op_p (operator_code))
9999 error ("%qD must take %<void%>", decl);
10001 error ("%qD must take exactly one argument", decl);
10005 else /* if (binary_op_p (operator_code)) */
10010 error ("%qD must take exactly one argument", decl);
10012 error ("%qD must take exactly two arguments", decl);
10016 /* More Effective C++ rule 7. */
10018 && (operator_code == TRUTH_ANDIF_EXPR
10019 || operator_code == TRUTH_ORIF_EXPR
10020 || operator_code == COMPOUND_EXPR))
10021 warning (OPT_Weffc__, "user-defined %qD always evaluates both arguments",
10025 /* Effective C++ rule 23. */
10028 && !DECL_ASSIGNMENT_OPERATOR_P (decl)
10029 && (operator_code == PLUS_EXPR
10030 || operator_code == MINUS_EXPR
10031 || operator_code == TRUNC_DIV_EXPR
10032 || operator_code == MULT_EXPR
10033 || operator_code == TRUNC_MOD_EXPR)
10034 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
10035 warning (OPT_Weffc__, "%qD should return by value", decl);
10037 /* [over.oper]/8 */
10038 for (; argtypes && argtypes != void_list_node;
10039 argtypes = TREE_CHAIN (argtypes))
10040 if (TREE_PURPOSE (argtypes))
10042 TREE_PURPOSE (argtypes) = NULL_TREE;
10043 if (operator_code == POSTINCREMENT_EXPR
10044 || operator_code == POSTDECREMENT_EXPR)
10047 pedwarn ("%qD cannot have default arguments", decl);
10051 error ("%qD cannot have default arguments", decl);
10059 /* Return a string giving the keyword associate with CODE. */
10061 static const char *
10062 tag_name (enum tag_types code)
10074 case typename_type:
10077 gcc_unreachable ();
10081 /* Name lookup in an elaborated-type-specifier (after the keyword
10082 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
10083 elaborated-type-specifier is invalid, issue a diagnostic and return
10084 error_mark_node; otherwise, return the *_TYPE to which it referred.
10085 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
10088 check_elaborated_type_specifier (enum tag_types tag_code,
10090 bool allow_template_p)
10096 struct S { struct S *p; };
10098 name lookup will find the TYPE_DECL for the implicit "S::S"
10099 typedef. Adjust for that here. */
10100 if (DECL_SELF_REFERENCE_P (decl))
10101 decl = TYPE_NAME (TREE_TYPE (decl));
10103 type = TREE_TYPE (decl);
10105 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
10106 is false for this case as well. */
10107 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
10109 error ("using template type parameter %qT after %qs",
10110 type, tag_name (tag_code));
10111 return error_mark_node;
10115 If the identifier resolves to a typedef-name or a template
10116 type-parameter, the elaborated-type-specifier is ill-formed.
10118 In other words, the only legitimate declaration to use in the
10119 elaborated type specifier is the implicit typedef created when
10120 the type is declared. */
10121 else if (!DECL_IMPLICIT_TYPEDEF_P (decl)
10122 && tag_code != typename_type)
10124 error ("using typedef-name %qD after %qs", decl, tag_name (tag_code));
10125 error ("%q+D has a previous declaration here", decl);
10126 return error_mark_node;
10128 else if (TREE_CODE (type) != RECORD_TYPE
10129 && TREE_CODE (type) != UNION_TYPE
10130 && tag_code != enum_type
10131 && tag_code != typename_type)
10133 error ("%qT referred to as %qs", type, tag_name (tag_code));
10134 error ("%q+T has a previous declaration here", type);
10135 return error_mark_node;
10137 else if (TREE_CODE (type) != ENUMERAL_TYPE
10138 && tag_code == enum_type)
10140 error ("%qT referred to as enum", type);
10141 error ("%q+T has a previous declaration here", type);
10142 return error_mark_node;
10144 else if (!allow_template_p
10145 && TREE_CODE (type) == RECORD_TYPE
10146 && CLASSTYPE_IS_TEMPLATE (type))
10148 /* If a class template appears as elaborated type specifier
10149 without a template header such as:
10151 template <class T> class C {};
10152 void f(class C); // No template header here
10154 then the required template argument is missing. */
10155 error ("template argument required for %<%s %T%>",
10156 tag_name (tag_code),
10157 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
10158 return error_mark_node;
10164 /* Lookup NAME in elaborate type specifier in scope according to
10165 SCOPE and issue diagnostics if necessary.
10166 Return *_TYPE node upon success, NULL_TREE when the NAME is not
10167 found, and ERROR_MARK_NODE for type error. */
10170 lookup_and_check_tag (enum tag_types tag_code, tree name,
10171 tag_scope scope, bool template_header_p)
10175 if (scope == ts_global)
10177 /* First try ordinary name lookup, ignoring hidden class name
10178 injected via friend declaration. */
10179 decl = lookup_name_prefer_type (name, 2);
10180 /* If that fails, the name will be placed in the smallest
10181 non-class, non-function-prototype scope according to 3.3.1/5.
10182 We may already have a hidden name declared as friend in this
10183 scope. So lookup again but not ignoring hidden names.
10184 If we find one, that name will be made visible rather than
10185 creating a new tag. */
10187 decl = lookup_type_scope (name, ts_within_enclosing_non_class);
10190 decl = lookup_type_scope (name, scope);
10192 if (decl && DECL_CLASS_TEMPLATE_P (decl))
10193 decl = DECL_TEMPLATE_RESULT (decl);
10195 if (decl && TREE_CODE (decl) == TYPE_DECL)
10197 /* Look for invalid nested type:
10201 if (scope == ts_current && DECL_SELF_REFERENCE_P (decl))
10203 error ("%qD has the same name as the class in which it is "
10206 return error_mark_node;
10209 /* Two cases we need to consider when deciding if a class
10210 template is allowed as an elaborated type specifier:
10211 1. It is a self reference to its own class.
10212 2. It comes with a template header.
10216 template <class T> class C {
10217 class C *c1; // DECL_SELF_REFERENCE_P is true
10220 template <class U> class C; // template_header_p is true
10221 template <class T> class C<T>::D {
10222 class C *c2; // DECL_SELF_REFERENCE_P is true
10225 t = check_elaborated_type_specifier (tag_code,
10228 | DECL_SELF_REFERENCE_P (decl));
10231 else if (decl && TREE_CODE (decl) == TREE_LIST)
10233 error ("reference to %qD is ambiguous", name);
10234 print_candidates (decl);
10235 return error_mark_node;
10241 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
10242 Define the tag as a forward-reference if it is not defined.
10244 If a declaration is given, process it here, and report an error if
10245 multiple declarations are not identical.
10247 SCOPE is TS_CURRENT when this is also a definition. Only look in
10248 the current frame for the name (since C++ allows new names in any
10249 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
10250 declaration. Only look beginning from the current scope outward up
10251 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
10253 TEMPLATE_HEADER_P is true when this declaration is preceded by
10254 a set of template parameters. */
10257 xref_tag (enum tag_types tag_code, tree name,
10258 tag_scope scope, bool template_header_p)
10260 enum tree_code code;
10262 tree context = NULL_TREE;
10264 timevar_push (TV_NAME_LOOKUP);
10266 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
10272 code = RECORD_TYPE;
10278 code = ENUMERAL_TYPE;
10281 gcc_unreachable ();
10284 /* In case of anonymous name, xref_tag is only called to
10285 make type node and push name. Name lookup is not required. */
10286 if (ANON_AGGRNAME_P (name))
10289 t = lookup_and_check_tag (tag_code, name,
10290 scope, template_header_p);
10292 if (t == error_mark_node)
10293 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10295 if (scope != ts_current && t && current_class_type
10296 && template_class_depth (current_class_type)
10297 && template_header_p)
10299 /* Since SCOPE is not TS_CURRENT, we are not looking at a
10300 definition of this tag. Since, in addition, we are currently
10301 processing a (member) template declaration of a template
10302 class, we must be very careful; consider:
10309 { template <class V>
10310 friend struct S1; };
10312 Here, the S2::S1 declaration should not be confused with the
10313 outer declaration. In particular, the inner version should
10314 have a template parameter of level 2, not level 1. This
10315 would be particularly important if the member declaration
10318 template <class V = U> friend struct S1;
10320 say, when we should tsubst into `U' when instantiating
10321 S2. On the other hand, when presented with:
10331 we must find the inner binding eventually. We
10332 accomplish this by making sure that the new type we
10333 create to represent this declaration has the right
10335 context = TYPE_CONTEXT (t);
10341 /* If no such tag is yet defined, create a forward-reference node
10342 and record it as the "definition".
10343 When a real declaration of this type is found,
10344 the forward-reference will be altered into a real type. */
10345 if (code == ENUMERAL_TYPE)
10347 error ("use of enum %q#D without previous declaration", name);
10348 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10352 t = make_aggr_type (code);
10353 TYPE_CONTEXT (t) = context;
10354 t = pushtag (name, t, scope);
10359 if (template_header_p && IS_AGGR_TYPE (t))
10361 if (!redeclare_class_template (t, current_template_parms))
10362 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10364 else if (!processing_template_decl
10365 && CLASS_TYPE_P (t)
10366 && CLASSTYPE_IS_TEMPLATE (t))
10368 error ("redeclaration of %qT as a non-template", t);
10369 error ("previous declaration %q+D", t);
10370 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10373 /* Make injected friend class visible. */
10374 if (scope != ts_within_enclosing_non_class
10375 && hidden_name_p (TYPE_NAME (t)))
10377 DECL_ANTICIPATED (TYPE_NAME (t)) = 0;
10378 DECL_FRIEND_P (TYPE_NAME (t)) = 0;
10380 if (TYPE_TEMPLATE_INFO (t))
10382 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t)) = 0;
10383 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t)) = 0;
10388 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
10392 xref_tag_from_type (tree old, tree id, tag_scope scope)
10394 enum tag_types tag_kind;
10396 if (TREE_CODE (old) == RECORD_TYPE)
10397 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
10399 tag_kind = union_type;
10401 if (id == NULL_TREE)
10402 id = TYPE_IDENTIFIER (old);
10404 return xref_tag (tag_kind, id, scope, false);
10407 /* Create the binfo hierarchy for REF with (possibly NULL) base list
10408 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
10409 access_* node, and the TREE_VALUE is the type of the base-class.
10410 Non-NULL TREE_TYPE indicates virtual inheritance.
10412 Returns true if the binfo hierarchy was successfully created,
10413 false if an error was detected. */
10416 xref_basetypes (tree ref, tree base_list)
10419 tree binfo, base_binfo;
10420 unsigned max_vbases = 0; /* Maximum direct & indirect virtual bases. */
10421 unsigned max_bases = 0; /* Maximum direct bases. */
10423 tree default_access;
10424 tree igo_prev; /* Track Inheritance Graph Order. */
10426 if (ref == error_mark_node)
10429 /* The base of a derived class is private by default, all others are
10431 default_access = (TREE_CODE (ref) == RECORD_TYPE
10432 && CLASSTYPE_DECLARED_CLASS (ref)
10433 ? access_private_node : access_public_node);
10435 /* First, make sure that any templates in base-classes are
10436 instantiated. This ensures that if we call ourselves recursively
10437 we do not get confused about which classes are marked and which
10439 basep = &base_list;
10442 tree basetype = TREE_VALUE (*basep);
10444 if (!(processing_template_decl && uses_template_parms (basetype))
10445 && !complete_type_or_else (basetype, NULL))
10446 /* An incomplete type. Remove it from the list. */
10447 *basep = TREE_CHAIN (*basep);
10451 if (TREE_TYPE (*basep))
10453 if (CLASS_TYPE_P (basetype))
10454 max_vbases += VEC_length (tree, CLASSTYPE_VBASECLASSES (basetype));
10455 basep = &TREE_CHAIN (*basep);
10459 TYPE_MARKED_P (ref) = 1;
10461 /* The binfo slot should be empty, unless this is an (ill-formed)
10463 gcc_assert (!TYPE_BINFO (ref) || TYPE_SIZE (ref));
10464 gcc_assert (TYPE_MAIN_VARIANT (ref) == ref);
10466 binfo = make_tree_binfo (max_bases);
10468 TYPE_BINFO (ref) = binfo;
10469 BINFO_OFFSET (binfo) = size_zero_node;
10470 BINFO_TYPE (binfo) = ref;
10474 BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, gc, max_bases);
10475 /* An aggregate cannot have baseclasses. */
10476 CLASSTYPE_NON_AGGREGATE (ref) = 1;
10478 if (TREE_CODE (ref) == UNION_TYPE)
10480 error ("derived union %qT invalid", ref);
10487 if (TYPE_FOR_JAVA (ref))
10489 error ("Java class %qT cannot have multiple bases", ref);
10496 CLASSTYPE_VBASECLASSES (ref) = VEC_alloc (tree, gc, max_vbases);
10498 if (TYPE_FOR_JAVA (ref))
10500 error ("Java class %qT cannot have virtual bases", ref);
10505 for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list))
10507 tree access = TREE_PURPOSE (base_list);
10508 int via_virtual = TREE_TYPE (base_list) != NULL_TREE;
10509 tree basetype = TREE_VALUE (base_list);
10511 if (access == access_default_node)
10512 access = default_access;
10514 if (PACK_EXPANSION_P (basetype))
10515 basetype = PACK_EXPANSION_PATTERN (basetype);
10516 if (TREE_CODE (basetype) == TYPE_DECL)
10517 basetype = TREE_TYPE (basetype);
10518 if (TREE_CODE (basetype) != RECORD_TYPE
10519 && TREE_CODE (basetype) != TYPENAME_TYPE
10520 && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
10521 && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM)
10523 error ("base type %qT fails to be a struct or class type",
10528 if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0))
10529 TYPE_FOR_JAVA (ref) = 1;
10531 base_binfo = NULL_TREE;
10532 if (CLASS_TYPE_P (basetype) && !dependent_type_p (basetype))
10534 base_binfo = TYPE_BINFO (basetype);
10535 /* The original basetype could have been a typedef'd type. */
10536 basetype = BINFO_TYPE (base_binfo);
10538 /* Inherit flags from the base. */
10539 TYPE_HAS_NEW_OPERATOR (ref)
10540 |= TYPE_HAS_NEW_OPERATOR (basetype);
10541 TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
10542 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
10543 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
10544 TYPE_HAS_CONVERSION (ref) |= TYPE_HAS_CONVERSION (basetype);
10545 CLASSTYPE_DIAMOND_SHAPED_P (ref)
10546 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype);
10547 CLASSTYPE_REPEATED_BASE_P (ref)
10548 |= CLASSTYPE_REPEATED_BASE_P (basetype);
10551 /* We must do this test after we've seen through a typedef
10553 if (TYPE_MARKED_P (basetype))
10555 if (basetype == ref)
10556 error ("recursive type %qT undefined", basetype);
10558 error ("duplicate base type %qT invalid", basetype);
10562 if (PACK_EXPANSION_P (TREE_VALUE (base_list)))
10563 /* Regenerate the pack expansion for the bases. */
10564 basetype = make_pack_expansion (basetype);
10566 TYPE_MARKED_P (basetype) = 1;
10568 base_binfo = copy_binfo (base_binfo, basetype, ref,
10569 &igo_prev, via_virtual);
10570 if (!BINFO_INHERITANCE_CHAIN (base_binfo))
10571 BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
10573 BINFO_BASE_APPEND (binfo, base_binfo);
10574 BINFO_BASE_ACCESS_APPEND (binfo, access);
10577 if (VEC_space (tree, CLASSTYPE_VBASECLASSES (ref), 1))
10578 /* If we have space in the vbase vector, we must have shared at
10579 least one of them, and are therefore diamond shaped. */
10580 CLASSTYPE_DIAMOND_SHAPED_P (ref) = 1;
10582 /* Unmark all the types. */
10583 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
10584 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
10585 TYPE_MARKED_P (ref) = 0;
10587 /* Now see if we have a repeated base type. */
10588 if (!CLASSTYPE_REPEATED_BASE_P (ref))
10590 for (base_binfo = binfo; base_binfo;
10591 base_binfo = TREE_CHAIN (base_binfo))
10593 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
10595 CLASSTYPE_REPEATED_BASE_P (ref) = 1;
10598 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 1;
10600 for (base_binfo = binfo; base_binfo;
10601 base_binfo = TREE_CHAIN (base_binfo))
10602 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
10603 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
10612 /* Begin compiling the definition of an enumeration type.
10614 Returns the type object, as yet incomplete.
10615 Also records info about it so that build_enumerator
10616 may be used to declare the individual values as they are read. */
10619 start_enum (tree name)
10623 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
10625 /* If this is the real definition for a previous forward reference,
10626 fill in the contents in the same object that used to be the
10627 forward reference. */
10629 enumtype = lookup_and_check_tag (enum_type, name,
10630 /*tag_scope=*/ts_current,
10631 /*template_header_p=*/false);
10633 if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
10635 error ("multiple definition of %q#T", enumtype);
10636 error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype));
10637 /* Clear out TYPE_VALUES, and start again. */
10638 TYPE_VALUES (enumtype) = NULL_TREE;
10642 /* In case of error, make a dummy enum to allow parsing to
10644 if (enumtype == error_mark_node)
10645 name = make_anon_name ();
10647 enumtype = make_node (ENUMERAL_TYPE);
10648 enumtype = pushtag (name, enumtype, /*tag_scope=*/ts_current);
10654 /* After processing and defining all the values of an enumeration type,
10655 install their decls in the enumeration type and finish it off.
10656 ENUMTYPE is the type object and VALUES a list of name-value pairs. */
10659 finish_enum (tree enumtype)
10668 bool use_short_enum;
10672 integer_type_kind itk;
10673 tree underlying_type = NULL_TREE;
10675 /* We built up the VALUES in reverse order. */
10676 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
10678 /* For an enum defined in a template, just set the type of the values;
10679 all further processing is postponed until the template is
10680 instantiated. We need to set the type so that tsubst of a CONST_DECL
10682 if (processing_template_decl)
10684 for (values = TYPE_VALUES (enumtype);
10686 values = TREE_CHAIN (values))
10687 TREE_TYPE (TREE_VALUE (values)) = enumtype;
10688 if (at_function_scope_p ())
10689 add_stmt (build_min (TAG_DEFN, enumtype));
10693 /* Determine the minimum and maximum values of the enumerators. */
10694 if (TYPE_VALUES (enumtype))
10696 minnode = maxnode = NULL_TREE;
10698 for (values = TYPE_VALUES (enumtype);
10700 values = TREE_CHAIN (values))
10702 decl = TREE_VALUE (values);
10704 /* [dcl.enum]: Following the closing brace of an enum-specifier,
10705 each enumerator has the type of its enumeration. Prior to the
10706 closing brace, the type of each enumerator is the type of its
10707 initializing value. */
10708 TREE_TYPE (decl) = enumtype;
10710 /* Update the minimum and maximum values, if appropriate. */
10711 value = DECL_INITIAL (decl);
10712 if (value == error_mark_node)
10713 value = integer_zero_node;
10714 /* Figure out what the minimum and maximum values of the
10715 enumerators are. */
10717 minnode = maxnode = value;
10718 else if (tree_int_cst_lt (maxnode, value))
10720 else if (tree_int_cst_lt (value, minnode))
10727 If the enumerator-list is empty, the underlying type is as if
10728 the enumeration had a single enumerator with value 0. */
10729 minnode = maxnode = integer_zero_node;
10731 /* Compute the number of bits require to represent all values of the
10732 enumeration. We must do this before the type of MINNODE and
10733 MAXNODE are transformed, since min_precision relies on the
10734 TREE_TYPE of the value it is passed. */
10735 unsignedp = tree_int_cst_sgn (minnode) >= 0;
10736 lowprec = min_precision (minnode, unsignedp);
10737 highprec = min_precision (maxnode, unsignedp);
10738 precision = MAX (lowprec, highprec);
10740 /* Determine the underlying type of the enumeration.
10744 The underlying type of an enumeration is an integral type that
10745 can represent all the enumerator values defined in the
10746 enumeration. It is implementation-defined which integral type is
10747 used as the underlying type for an enumeration except that the
10748 underlying type shall not be larger than int unless the value of
10749 an enumerator cannot fit in an int or unsigned int.
10751 We use "int" or an "unsigned int" as the underlying type, even if
10752 a smaller integral type would work, unless the user has
10753 explicitly requested that we use the smallest possible type. The
10754 user can request that for all enumerations with a command line
10755 flag, or for just one enumeration with an attribute. */
10757 use_short_enum = flag_short_enums
10758 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype));
10760 for (itk = (use_short_enum ? itk_char : itk_int);
10764 underlying_type = integer_types[itk];
10765 if (TYPE_PRECISION (underlying_type) >= precision
10766 && TYPE_UNSIGNED (underlying_type) == unsignedp)
10769 if (itk == itk_none)
10773 IF no integral type can represent all the enumerator values, the
10774 enumeration is ill-formed. */
10775 error ("no integral type can represent all of the enumerator values "
10776 "for %qT", enumtype);
10777 precision = TYPE_PRECISION (long_long_integer_type_node);
10778 underlying_type = integer_types[itk_unsigned_long_long];
10781 /* Compute the minium and maximum values for the type.
10785 For an enumeration where emin is the smallest enumerator and emax
10786 is the largest, the values of the enumeration are the values of the
10787 underlying type in the range bmin to bmax, where bmin and bmax are,
10788 respectively, the smallest and largest values of the smallest bit-
10789 field that can store emin and emax. */
10791 /* The middle-end currently assumes that types with TYPE_PRECISION
10792 narrower than their underlying type are suitably zero or sign
10793 extended to fill their mode. g++ doesn't make these guarantees.
10794 Until the middle-end can represent such paradoxical types, we
10795 set the TYPE_PRECISION to the width of the underlying type. */
10796 TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type);
10798 set_min_and_max_values_for_integral_type (enumtype, precision, unsignedp);
10802 The value of sizeof() applied to an enumeration type, an object
10803 of an enumeration type, or an enumerator, is the value of sizeof()
10804 applied to the underlying type. */
10805 TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
10806 TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
10807 TYPE_MODE (enumtype) = TYPE_MODE (underlying_type);
10808 TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
10809 TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
10810 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);
10812 /* Convert each of the enumerators to the type of the underlying
10813 type of the enumeration. */
10814 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
10816 location_t saved_location;
10818 decl = TREE_VALUE (values);
10819 saved_location = input_location;
10820 input_location = DECL_SOURCE_LOCATION (decl);
10821 value = perform_implicit_conversion (underlying_type,
10822 DECL_INITIAL (decl));
10823 input_location = saved_location;
10825 /* Do not clobber shared ints. */
10826 value = copy_node (value);
10828 TREE_TYPE (value) = enumtype;
10829 DECL_INITIAL (decl) = value;
10830 TREE_VALUE (values) = value;
10833 /* Fix up all variant types of this enum type. */
10834 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
10836 TYPE_VALUES (t) = TYPE_VALUES (enumtype);
10837 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
10838 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
10839 TYPE_SIZE (t) = TYPE_SIZE (enumtype);
10840 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
10841 TYPE_MODE (t) = TYPE_MODE (enumtype);
10842 TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
10843 TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
10844 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
10845 TYPE_UNSIGNED (t) = TYPE_UNSIGNED (enumtype);
10848 /* Finish debugging output for this type. */
10849 rest_of_type_compilation (enumtype, namespace_bindings_p ());
10852 /* Build and install a CONST_DECL for an enumeration constant of the
10853 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
10854 Assignment of sequential values by default is handled here. */
10857 build_enumerator (tree name, tree value, tree enumtype)
10863 /* If the VALUE was erroneous, pretend it wasn't there; that will
10864 result in the enum being assigned the next value in sequence. */
10865 if (value == error_mark_node)
10868 /* Remove no-op casts from the value. */
10870 STRIP_TYPE_NOPS (value);
10872 if (! processing_template_decl)
10874 /* Validate and default VALUE. */
10875 if (value != NULL_TREE)
10877 value = integral_constant_value (value);
10879 if (TREE_CODE (value) == INTEGER_CST)
10881 value = perform_integral_promotions (value);
10882 constant_expression_warning (value);
10886 error ("enumerator value for %qD is not an integer constant", name);
10891 /* Default based on previous value. */
10892 if (value == NULL_TREE)
10894 if (TYPE_VALUES (enumtype))
10897 unsigned HOST_WIDE_INT lo;
10901 /* The next value is the previous value plus one. We can
10902 safely assume that the previous value is an INTEGER_CST.
10903 add_double doesn't know the type of the target expression,
10904 so we must check with int_fits_type_p as well. */
10905 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
10906 overflowed = add_double (TREE_INT_CST_LOW (prev_value),
10907 TREE_INT_CST_HIGH (prev_value),
10909 value = build_int_cst_wide (TREE_TYPE (prev_value), lo, hi);
10910 overflowed |= !int_fits_type_p (value, TREE_TYPE (prev_value));
10914 error ("overflow in enumeration values at %qD", name);
10915 value = error_mark_node;
10919 value = integer_zero_node;
10922 /* Remove no-op casts from the value. */
10923 STRIP_TYPE_NOPS (value);
10926 /* C++ associates enums with global, function, or class declarations. */
10927 context = current_scope ();
10929 /* Build the actual enumeration constant. Note that the enumeration
10930 constants have the type of their initializers until the
10931 enumeration is complete:
10935 Following the closing brace of an enum-specifier, each enumer-
10936 ator has the type of its enumeration. Prior to the closing
10937 brace, the type of each enumerator is the type of its
10938 initializing value.
10940 In finish_enum we will reset the type. Of course, if we're
10941 processing a template, there may be no value. */
10942 type = value ? TREE_TYPE (value) : NULL_TREE;
10944 if (context && context == current_class_type)
10945 /* This enum declaration is local to the class. We need the full
10946 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
10947 decl = build_lang_decl (CONST_DECL, name, type);
10949 /* It's a global enum, or it's local to a function. (Note local to
10950 a function could mean local to a class method. */
10951 decl = build_decl (CONST_DECL, name, type);
10953 DECL_CONTEXT (decl) = FROB_CONTEXT (context);
10954 TREE_CONSTANT (decl) = 1;
10955 TREE_INVARIANT (decl) = 1;
10956 TREE_READONLY (decl) = 1;
10957 DECL_INITIAL (decl) = value;
10959 if (context && context == current_class_type)
10960 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
10961 on the TYPE_FIELDS list for `S'. (That's so that you can say
10962 things like `S::i' later.) */
10963 finish_member_declaration (decl);
10967 /* Add this enumeration constant to the list for this type. */
10968 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
10972 /* We're defining DECL. Make sure that it's type is OK. */
10975 check_function_type (tree decl, tree current_function_parms)
10977 tree fntype = TREE_TYPE (decl);
10978 tree return_type = complete_type (TREE_TYPE (fntype));
10980 /* In a function definition, arg types must be complete. */
10981 require_complete_types_for_parms (current_function_parms);
10983 if (dependent_type_p (return_type))
10985 if (!COMPLETE_OR_VOID_TYPE_P (return_type)
10986 || (TYPE_FOR_JAVA (return_type) && IS_AGGR_TYPE (return_type)))
10988 tree args = TYPE_ARG_TYPES (fntype);
10990 if (!COMPLETE_OR_VOID_TYPE_P (return_type))
10991 error ("return type %q#T is incomplete", return_type);
10993 error ("return type has Java class type %q#T", return_type);
10995 /* Make it return void instead. */
10996 if (TREE_CODE (fntype) == METHOD_TYPE)
10997 fntype = build_method_type_directly (TREE_TYPE (TREE_VALUE (args)),
10999 TREE_CHAIN (args));
11001 fntype = build_function_type (void_type_node, args);
11003 = build_exception_variant (fntype,
11004 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)));
11007 abstract_virtuals_error (decl, TREE_TYPE (fntype));
11010 /* Create the FUNCTION_DECL for a function definition.
11011 DECLSPECS and DECLARATOR are the parts of the declaration;
11012 they describe the function's name and the type it returns,
11013 but twisted together in a fashion that parallels the syntax of C.
11015 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
11016 DECLARATOR is really the DECL for the function we are about to
11017 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
11018 indicating that the function is an inline defined in-class.
11020 This function creates a binding context for the function body
11021 as well as setting up the FUNCTION_DECL in current_function_decl.
11023 For C++, we must first check whether that datum makes any sense.
11024 For example, "class A local_a(1,2);" means that variable local_a
11025 is an aggregate of type A, which should have a constructor
11026 applied to it with the argument list [1, 2].
11028 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
11029 or may be a BLOCK if the function has been defined previously
11030 in this translation unit. On exit, DECL_INITIAL (decl1) will be
11031 error_mark_node if the function has never been defined, or
11032 a BLOCK if the function has been defined somewhere. */
11035 start_preparsed_function (tree decl1, tree attrs, int flags)
11037 tree ctype = NULL_TREE;
11040 int doing_friend = 0;
11041 struct cp_binding_level *bl;
11042 tree current_function_parms;
11043 struct c_fileinfo *finfo
11044 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1)));
11045 bool honor_interface;
11047 /* Sanity check. */
11048 gcc_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE);
11049 gcc_assert (TREE_CHAIN (void_list_node) == NULL_TREE);
11051 fntype = TREE_TYPE (decl1);
11052 if (TREE_CODE (fntype) == METHOD_TYPE)
11053 ctype = TYPE_METHOD_BASETYPE (fntype);
11055 /* ISO C++ 11.4/5. A friend function defined in a class is in
11056 the (lexical) scope of the class in which it is defined. */
11057 if (!ctype && DECL_FRIEND_P (decl1))
11059 ctype = DECL_FRIEND_CONTEXT (decl1);
11061 /* CTYPE could be null here if we're dealing with a template;
11062 for example, `inline friend float foo()' inside a template
11063 will have no CTYPE set. */
11064 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
11070 if (DECL_DECLARED_INLINE_P (decl1)
11071 && lookup_attribute ("noinline", attrs))
11072 warning (0, "inline function %q+D given attribute noinline", decl1);
11074 /* Handle gnu_inline attribute. */
11075 if (GNU_INLINE_P (decl1))
11077 DECL_EXTERNAL (decl1) = 1;
11078 DECL_NOT_REALLY_EXTERN (decl1) = 0;
11079 DECL_INTERFACE_KNOWN (decl1) = 1;
11080 DECL_DISREGARD_INLINE_LIMITS (decl1) = 1;
11083 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
11084 /* This is a constructor, we must ensure that any default args
11085 introduced by this definition are propagated to the clones
11086 now. The clones are used directly in overload resolution. */
11087 adjust_clone_args (decl1);
11089 /* Sometimes we don't notice that a function is a static member, and
11090 build a METHOD_TYPE for it. Fix that up now. */
11091 if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
11092 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
11094 revert_static_member_fn (decl1);
11098 /* Set up current_class_type, and enter the scope of the class, if
11101 push_nested_class (ctype);
11102 else if (DECL_STATIC_FUNCTION_P (decl1))
11103 push_nested_class (DECL_CONTEXT (decl1));
11105 /* Now that we have entered the scope of the class, we must restore
11106 the bindings for any template parameters surrounding DECL1, if it
11107 is an inline member template. (Order is important; consider the
11108 case where a template parameter has the same name as a field of
11109 the class.) It is not until after this point that
11110 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
11111 if (flags & SF_INCLASS_INLINE)
11112 maybe_begin_member_template_processing (decl1);
11114 /* Effective C++ rule 15. */
11116 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
11117 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
11118 warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");
11120 /* Make the init_value nonzero so pushdecl knows this is not tentative.
11121 error_mark_node is replaced below (in poplevel) with the BLOCK. */
11122 if (!DECL_INITIAL (decl1))
11123 DECL_INITIAL (decl1) = error_mark_node;
11125 /* This function exists in static storage.
11126 (This does not mean `static' in the C sense!) */
11127 TREE_STATIC (decl1) = 1;
11129 /* We must call push_template_decl after current_class_type is set
11130 up. (If we are processing inline definitions after exiting a
11131 class scope, current_class_type will be NULL_TREE until set above
11132 by push_nested_class.) */
11133 if (processing_template_decl)
11135 /* FIXME: Handle error_mark_node more gracefully. */
11136 tree newdecl1 = push_template_decl (decl1);
11137 if (newdecl1 != error_mark_node)
11141 /* We are now in the scope of the function being defined. */
11142 current_function_decl = decl1;
11144 /* Save the parm names or decls from this function's declarator
11145 where store_parm_decls will find them. */
11146 current_function_parms = DECL_ARGUMENTS (decl1);
11148 /* Make sure the parameter and return types are reasonable. When
11149 you declare a function, these types can be incomplete, but they
11150 must be complete when you define the function. */
11151 check_function_type (decl1, current_function_parms);
11153 /* Build the return declaration for the function. */
11154 restype = TREE_TYPE (fntype);
11155 if (DECL_RESULT (decl1) == NULL_TREE)
11159 resdecl = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
11160 DECL_ARTIFICIAL (resdecl) = 1;
11161 DECL_IGNORED_P (resdecl) = 1;
11162 DECL_RESULT (decl1) = resdecl;
11164 cp_apply_type_quals_to_decl (cp_type_quals (restype), resdecl);
11167 /* Let the user know we're compiling this function. */
11168 announce_function (decl1);
11170 /* Record the decl so that the function name is defined.
11171 If we already have a decl for this name, and it is a FUNCTION_DECL,
11172 use the old decl. */
11173 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
11175 /* A specialization is not used to guide overload resolution. */
11176 if (!DECL_FUNCTION_MEMBER_P (decl1)
11177 && !(DECL_USE_TEMPLATE (decl1) &&
11178 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1))))
11180 tree olddecl = pushdecl (decl1);
11182 if (olddecl == error_mark_node)
11183 /* If something went wrong when registering the declaration,
11184 use DECL1; we have to have a FUNCTION_DECL to use when
11185 parsing the body of the function. */
11189 /* Otherwise, OLDDECL is either a previous declaration
11190 of the same function or DECL1 itself. */
11192 if (warn_missing_declarations
11193 && olddecl == decl1
11194 && !DECL_MAIN_P (decl1)
11195 && TREE_PUBLIC (decl1)
11196 && !DECL_DECLARED_INLINE_P (decl1))
11200 /* Check whether DECL1 is in an anonymous
11202 for (context = DECL_CONTEXT (decl1);
11204 context = DECL_CONTEXT (context))
11206 if (TREE_CODE (context) == NAMESPACE_DECL
11207 && DECL_NAME (context) == NULL_TREE)
11211 if (context == NULL)
11212 warning (OPT_Wmissing_declarations,
11213 "no previous declaration for %q+D", decl1);
11221 /* We need to set the DECL_CONTEXT. */
11222 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
11223 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
11225 fntype = TREE_TYPE (decl1);
11227 /* If #pragma weak applies, mark the decl appropriately now.
11228 The pragma only applies to global functions. Because
11229 determining whether or not the #pragma applies involves
11230 computing the mangled name for the declaration, we cannot
11231 apply the pragma until after we have merged this declaration
11232 with any previous declarations; if the original declaration
11233 has a linkage specification, that specification applies to
11234 the definition as well, and may affect the mangled name. */
11235 if (!DECL_CONTEXT (decl1))
11236 maybe_apply_pragma_weak (decl1);
11239 /* Reset this in case the call to pushdecl changed it. */
11240 current_function_decl = decl1;
11242 gcc_assert (DECL_INITIAL (decl1));
11244 /* This function may already have been parsed, in which case just
11245 return; our caller will skip over the body without parsing. */
11246 if (DECL_INITIAL (decl1) != error_mark_node)
11249 /* Initialize RTL machinery. We cannot do this until
11250 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
11251 even when processing a template; this is how we get
11252 CFUN set up, and our per-function variables initialized.
11253 FIXME factor out the non-RTL stuff. */
11254 bl = current_binding_level;
11255 allocate_struct_function (decl1, processing_template_decl);
11256 current_binding_level = bl;
11258 /* Even though we're inside a function body, we still don't want to
11259 call expand_expr to calculate the size of a variable-sized array.
11260 We haven't necessarily assigned RTL to all variables yet, so it's
11261 not safe to try to expand expressions involving them. */
11262 cfun->x_dont_save_pending_sizes_p = 1;
11264 /* Start the statement-tree, start the tree now. */
11265 DECL_SAVED_TREE (decl1) = push_stmt_list ();
11267 /* If we are (erroneously) defining a function that we have already
11268 defined before, wipe out what we knew before. */
11269 if (!DECL_PENDING_INLINE_P (decl1))
11270 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
11272 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
11274 /* We know that this was set up by `grokclassfn'. We do not
11275 wait until `store_parm_decls', since evil parse errors may
11276 never get us to that point. Here we keep the consistency
11277 between `current_class_type' and `current_class_ptr'. */
11278 tree t = DECL_ARGUMENTS (decl1);
11280 gcc_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL);
11281 gcc_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE);
11283 cp_function_chain->x_current_class_ref
11284 = build_indirect_ref (t, NULL);
11285 cp_function_chain->x_current_class_ptr = t;
11287 /* Constructors and destructors need to know whether they're "in
11288 charge" of initializing virtual base classes. */
11289 t = TREE_CHAIN (t);
11290 if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
11292 current_in_charge_parm = t;
11293 t = TREE_CHAIN (t);
11295 if (DECL_HAS_VTT_PARM_P (decl1))
11297 gcc_assert (DECL_NAME (t) == vtt_parm_identifier);
11298 current_vtt_parm = t;
11302 honor_interface = (!DECL_TEMPLATE_INSTANTIATION (decl1)
11303 /* Implicitly-defined methods (like the
11304 destructor for a class in which no destructor
11305 is explicitly declared) must not be defined
11306 until their definition is needed. So, we
11307 ignore interface specifications for
11308 compiler-generated functions. */
11309 && !DECL_ARTIFICIAL (decl1));
11311 if (DECL_INTERFACE_KNOWN (decl1))
11313 tree ctx = decl_function_context (decl1);
11315 if (DECL_NOT_REALLY_EXTERN (decl1))
11316 DECL_EXTERNAL (decl1) = 0;
11318 if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
11319 && TREE_PUBLIC (ctx))
11320 /* This is a function in a local class in an extern inline
11322 comdat_linkage (decl1);
11324 /* If this function belongs to an interface, it is public.
11325 If it belongs to someone else's interface, it is also external.
11326 This only affects inlines and template instantiations. */
11327 else if (!finfo->interface_unknown && honor_interface)
11329 if (DECL_DECLARED_INLINE_P (decl1)
11330 || DECL_TEMPLATE_INSTANTIATION (decl1)
11331 || processing_template_decl)
11333 DECL_EXTERNAL (decl1)
11334 = (finfo->interface_only
11335 || (DECL_DECLARED_INLINE_P (decl1)
11336 && ! flag_implement_inlines
11337 && !DECL_VINDEX (decl1)));
11339 /* For WIN32 we also want to put these in linkonce sections. */
11340 maybe_make_one_only (decl1);
11343 DECL_EXTERNAL (decl1) = 0;
11344 DECL_INTERFACE_KNOWN (decl1) = 1;
11345 /* If this function is in an interface implemented in this file,
11346 make sure that the back end knows to emit this function
11348 if (!DECL_EXTERNAL (decl1))
11349 mark_needed (decl1);
11351 else if (finfo->interface_unknown && finfo->interface_only
11352 && honor_interface)
11354 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
11355 interface, we will have both finfo->interface_unknown and
11356 finfo->interface_only set. In that case, we don't want to
11357 use the normal heuristics because someone will supply a
11358 #pragma implementation elsewhere, and deducing it here would
11359 produce a conflict. */
11360 comdat_linkage (decl1);
11361 DECL_EXTERNAL (decl1) = 0;
11362 DECL_INTERFACE_KNOWN (decl1) = 1;
11363 DECL_DEFER_OUTPUT (decl1) = 1;
11367 /* This is a definition, not a reference.
11368 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
11369 if (!GNU_INLINE_P (decl1))
11370 DECL_EXTERNAL (decl1) = 0;
11372 if ((DECL_DECLARED_INLINE_P (decl1)
11373 || DECL_TEMPLATE_INSTANTIATION (decl1))
11374 && ! DECL_INTERFACE_KNOWN (decl1)
11375 /* Don't try to defer nested functions for now. */
11376 && ! decl_function_context (decl1))
11377 DECL_DEFER_OUTPUT (decl1) = 1;
11379 DECL_INTERFACE_KNOWN (decl1) = 1;
11382 /* Determine the ELF visibility attribute for the function. We must not
11383 do this before calling "pushdecl", as we must allow "duplicate_decls"
11384 to merge any attributes appropriately. We also need to wait until
11386 if (!DECL_CLONED_FUNCTION_P (decl1))
11387 determine_visibility (decl1);
11389 begin_scope (sk_function_parms, decl1);
11393 if (DECL_DESTRUCTOR_P (decl1)
11394 || (DECL_CONSTRUCTOR_P (decl1)
11395 && targetm.cxx.cdtor_returns_this ()))
11397 cdtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
11398 DECL_CONTEXT (cdtor_label) = current_function_decl;
11401 start_fname_decls ();
11403 store_parm_decls (current_function_parms);
11407 /* Like start_preparsed_function, except that instead of a
11408 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
11410 Returns 1 on success. If the DECLARATOR is not suitable for a function
11411 (it defines a datum instead), we return 0, which tells
11412 yyparse to report a parse error. */
11415 start_function (cp_decl_specifier_seq *declspecs,
11416 const cp_declarator *declarator,
11421 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
11422 /* If the declarator is not suitable for a function definition,
11423 cause a syntax error. */
11424 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
11427 if (DECL_MAIN_P (decl1))
11428 /* main must return int. grokfndecl should have corrected it
11429 (and issued a diagnostic) if the user got it wrong. */
11430 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1)),
11431 integer_type_node));
11433 start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT);
11438 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
11442 use_eh_spec_block (tree fn)
11444 return (flag_exceptions && flag_enforce_eh_specs
11445 && !processing_template_decl
11446 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn))
11447 /* We insert the EH_SPEC_BLOCK only in the original
11448 function; then, it is copied automatically to the
11450 && !DECL_CLONED_FUNCTION_P (fn)
11451 /* Implicitly-generated constructors and destructors have
11452 exception specifications. However, those specifications
11453 are the union of the possible exceptions specified by the
11454 constructors/destructors for bases and members, so no
11455 unallowed exception will ever reach this function. By
11456 not creating the EH_SPEC_BLOCK we save a little memory,
11457 and we avoid spurious warnings about unreachable
11459 && !DECL_ARTIFICIAL (fn));
11462 /* Store the parameter declarations into the current function declaration.
11463 This is called after parsing the parameter declarations, before
11464 digesting the body of the function.
11466 Also install to binding contour return value identifier, if any. */
11469 store_parm_decls (tree current_function_parms)
11471 tree fndecl = current_function_decl;
11474 /* This is a chain of any other decls that came in among the parm
11475 declarations. If a parm is declared with enum {foo, bar} x;
11476 then CONST_DECLs for foo and bar are put here. */
11477 tree nonparms = NULL_TREE;
11479 if (current_function_parms)
11481 /* This case is when the function was defined with an ANSI prototype.
11482 The parms already have decls, so we need not do anything here
11483 except record them as in effect
11484 and complain if any redundant old-style parm decls were written. */
11486 tree specparms = current_function_parms;
11489 /* Must clear this because it might contain TYPE_DECLs declared
11491 current_binding_level->names = NULL;
11493 /* If we're doing semantic analysis, then we'll call pushdecl
11494 for each of these. We must do them in reverse order so that
11495 they end in the correct forward order. */
11496 specparms = nreverse (specparms);
11498 for (parm = specparms; parm; parm = next)
11500 next = TREE_CHAIN (parm);
11501 if (TREE_CODE (parm) == PARM_DECL)
11503 if (DECL_NAME (parm) == NULL_TREE
11504 || TREE_CODE (parm) != VOID_TYPE)
11507 error ("parameter %qD declared void", parm);
11511 /* If we find an enum constant or a type tag,
11512 put it aside for the moment. */
11513 TREE_CHAIN (parm) = NULL_TREE;
11514 nonparms = chainon (nonparms, parm);
11518 /* Get the decls in their original chain order and record in the
11519 function. This is all and only the PARM_DECLs that were
11520 pushed into scope by the loop above. */
11521 DECL_ARGUMENTS (fndecl) = getdecls ();
11524 DECL_ARGUMENTS (fndecl) = NULL_TREE;
11526 /* Now store the final chain of decls for the arguments
11527 as the decl-chain of the current lexical scope.
11528 Put the enumerators in as well, at the front so that
11529 DECL_ARGUMENTS is not modified. */
11530 current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));
11532 if (use_eh_spec_block (current_function_decl))
11533 current_eh_spec_block = begin_eh_spec_block ();
11537 /* We have finished doing semantic analysis on DECL, but have not yet
11538 generated RTL for its body. Save away our current state, so that
11539 when we want to generate RTL later we know what to do. */
11542 save_function_data (tree decl)
11544 struct language_function *f;
11546 /* Save the language-specific per-function data so that we can
11547 get it back when we really expand this function. */
11548 gcc_assert (!DECL_PENDING_INLINE_P (decl));
11551 f = GGC_NEW (struct language_function);
11552 memcpy (f, cp_function_chain, sizeof (struct language_function));
11553 DECL_SAVED_FUNCTION_DATA (decl) = f;
11555 /* Clear out the bits we don't need. */
11556 f->base.x_stmt_tree.x_cur_stmt_list = NULL_TREE;
11557 f->bindings = NULL;
11558 f->x_local_names = NULL;
11562 /* Set the return value of the constructor (if present). */
11565 finish_constructor_body (void)
11570 if (targetm.cxx.cdtor_returns_this ())
11572 /* Any return from a constructor will end up here. */
11573 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
11575 val = DECL_ARGUMENTS (current_function_decl);
11576 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
11577 DECL_RESULT (current_function_decl), val);
11578 /* Return the address of the object. */
11579 exprstmt = build_stmt (RETURN_EXPR, val);
11580 add_stmt (exprstmt);
11584 /* Do all the processing for the beginning of a destructor; set up the
11585 vtable pointers and cleanups for bases and members. */
11588 begin_destructor_body (void)
11590 tree compound_stmt;
11592 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
11593 issued an error message. We still want to try to process the
11594 body of the function, but initialize_vtbl_ptrs will crash if
11595 TYPE_BINFO is NULL. */
11596 if (COMPLETE_TYPE_P (current_class_type))
11598 compound_stmt = begin_compound_stmt (0);
11599 /* Make all virtual function table pointers in non-virtual base
11600 classes point to CURRENT_CLASS_TYPE's virtual function
11602 initialize_vtbl_ptrs (current_class_ptr);
11603 finish_compound_stmt (compound_stmt);
11605 /* And insert cleanups for our bases and members so that they
11606 will be properly destroyed if we throw. */
11607 push_base_cleanups ();
11611 /* At the end of every destructor we generate code to delete the object if
11612 necessary. Do that now. */
11615 finish_destructor_body (void)
11619 /* Any return from a destructor will end up here; that way all base
11620 and member cleanups will be run when the function returns. */
11621 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
11623 /* In a virtual destructor, we must call delete. */
11624 if (DECL_VIRTUAL_P (current_function_decl))
11627 tree virtual_size = cxx_sizeof (current_class_type);
11631 At the point of definition of a virtual destructor (including
11632 an implicit definition), non-placement operator delete shall
11633 be looked up in the scope of the destructor's class and if
11634 found shall be accessible and unambiguous. */
11635 exprstmt = build_op_delete_call(DELETE_EXPR, current_class_ptr,
11637 /*global_p=*/false,
11638 /*placement=*/NULL_TREE,
11639 /*alloc_fn=*/NULL_TREE);
11641 if_stmt = begin_if_stmt ();
11642 finish_if_stmt_cond (build2 (BIT_AND_EXPR, integer_type_node,
11643 current_in_charge_parm,
11646 finish_expr_stmt (exprstmt);
11647 finish_then_clause (if_stmt);
11648 finish_if_stmt (if_stmt);
11651 if (targetm.cxx.cdtor_returns_this ())
11655 val = DECL_ARGUMENTS (current_function_decl);
11656 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
11657 DECL_RESULT (current_function_decl), val);
11658 /* Return the address of the object. */
11659 exprstmt = build_stmt (RETURN_EXPR, val);
11660 add_stmt (exprstmt);
11664 /* Do the necessary processing for the beginning of a function body, which
11665 in this case includes member-initializers, but not the catch clauses of
11666 a function-try-block. Currently, this means opening a binding level
11667 for the member-initializers (in a ctor) and member cleanups (in a dtor). */
11670 begin_function_body (void)
11674 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
11677 if (processing_template_decl)
11678 /* Do nothing now. */;
11680 /* Always keep the BLOCK node associated with the outermost pair of
11681 curly braces of a function. These are needed for correct
11682 operation of dwarfout.c. */
11683 keep_next_level (true);
11685 stmt = begin_compound_stmt (BCS_FN_BODY);
11687 if (processing_template_decl)
11688 /* Do nothing now. */;
11689 else if (DECL_DESTRUCTOR_P (current_function_decl))
11690 begin_destructor_body ();
11695 /* Do the processing for the end of a function body. Currently, this means
11696 closing out the cleanups for fully-constructed bases and members, and in
11697 the case of the destructor, deleting the object if desired. Again, this
11698 is only meaningful for [cd]tors, since they are the only functions where
11699 there is a significant distinction between the main body and any
11700 function catch clauses. Handling, say, main() return semantics here
11701 would be wrong, as flowing off the end of a function catch clause for
11702 main() would also need to return 0. */
11705 finish_function_body (tree compstmt)
11707 if (compstmt == NULL_TREE)
11710 /* Close the block. */
11711 finish_compound_stmt (compstmt);
11713 if (processing_template_decl)
11714 /* Do nothing now. */;
11715 else if (DECL_CONSTRUCTOR_P (current_function_decl))
11716 finish_constructor_body ();
11717 else if (DECL_DESTRUCTOR_P (current_function_decl))
11718 finish_destructor_body ();
11721 /* Given a function, returns the BLOCK corresponding to the outermost level
11722 of curly braces, skipping the artificial block created for constructor
11726 outer_curly_brace_block (tree fndecl)
11728 tree block = BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl));
11729 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
11730 /* Skip the artificial function body block. */
11731 block = BLOCK_SUBBLOCKS (block);
11735 /* Finish up a function declaration and compile that function
11736 all the way to assembler language output. The free the storage
11737 for the function definition.
11739 FLAGS is a bitwise or of the following values:
11741 We just finished processing the body of an in-class inline
11742 function definition. (This processing will have taken place
11743 after the class definition is complete.) */
11746 finish_function (int flags)
11748 tree fndecl = current_function_decl;
11749 tree fntype, ctype = NULL_TREE;
11750 int inclass_inline = (flags & 2) != 0;
11753 /* When we get some parse errors, we can end up without a
11754 current_function_decl, so cope. */
11755 if (fndecl == NULL_TREE)
11756 return error_mark_node;
11758 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
11759 && DECL_VIRTUAL_P (fndecl)
11760 && !processing_template_decl)
11762 tree fnclass = DECL_CONTEXT (fndecl);
11763 if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
11764 keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
11767 nested = function_depth > 1;
11768 fntype = TREE_TYPE (fndecl);
11770 /* TREE_READONLY (fndecl) = 1;
11771 This caused &foo to be of type ptr-to-const-function
11772 which then got a warning when stored in a ptr-to-function variable. */
11774 gcc_assert (building_stmt_tree ());
11775 /* The current function is being defined, so its DECL_INITIAL should
11776 be set, and unless there's a multiple definition, it should be
11777 error_mark_node. */
11778 gcc_assert (DECL_INITIAL (fndecl) == error_mark_node);
11780 /* For a cloned function, we've already got all the code we need;
11781 there's no need to add any extra bits. */
11782 if (!DECL_CLONED_FUNCTION_P (fndecl))
11784 if (DECL_MAIN_P (current_function_decl))
11788 /* Make it so that `main' always returns 0 by default (or
11791 stmt = finish_return_stmt (integer_one_node);
11793 stmt = finish_return_stmt (integer_zero_node);
11795 /* Hack. We don't want the middle-end to warn that this
11796 return is unreachable, so put the statement on the
11798 #ifdef USE_MAPPED_LOCATION
11800 location_t linezero = linemap_line_start (line_table, 0, 1);
11801 SET_EXPR_LOCATION (stmt, linezero);
11804 annotate_with_file_line (stmt, input_filename, 0);
11808 if (use_eh_spec_block (current_function_decl))
11809 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
11810 (TREE_TYPE (current_function_decl)),
11811 current_eh_spec_block);
11814 /* If we're saving up tree structure, tie off the function now. */
11815 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
11817 finish_fname_decls ();
11819 /* If this function can't throw any exceptions, remember that. */
11820 if (!processing_template_decl
11821 && !cp_function_chain->can_throw
11822 && !flag_non_call_exceptions
11823 && !DECL_REPLACEABLE_P (fndecl))
11824 TREE_NOTHROW (fndecl) = 1;
11826 /* This must come after expand_function_end because cleanups might
11827 have declarations (from inline functions) that need to go into
11828 this function's blocks. */
11830 /* If the current binding level isn't the outermost binding level
11831 for this function, either there is a bug, or we have experienced
11832 syntax errors and the statement tree is malformed. */
11833 if (current_binding_level->kind != sk_function_parms)
11835 /* Make sure we have already experienced errors. */
11836 gcc_assert (errorcount);
11838 /* Throw away the broken statement tree and extra binding
11840 DECL_SAVED_TREE (fndecl) = alloc_stmt_list ();
11842 while (current_binding_level->kind != sk_function_parms)
11844 if (current_binding_level->kind == sk_class)
11845 pop_nested_class ();
11847 poplevel (0, 0, 0);
11850 poplevel (1, 0, 1);
11852 /* Statements should always be full-expressions at the outermost set
11853 of curly braces for a function. */
11854 gcc_assert (stmts_are_full_exprs_p ());
11856 /* Set up the named return value optimization, if we can. Candidate
11857 variables are selected in check_return_expr. */
11858 if (current_function_return_value)
11860 tree r = current_function_return_value;
11863 if (r != error_mark_node
11864 /* This is only worth doing for fns that return in memory--and
11865 simpler, since we don't have to worry about promoted modes. */
11866 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
11867 /* Only allow this for variables declared in the outer scope of
11868 the function so we know that their lifetime always ends with a
11869 return; see g++.dg/opt/nrv6.C. We could be more flexible if
11870 we were to do this optimization in tree-ssa. */
11871 && (outer = outer_curly_brace_block (fndecl))
11872 && chain_member (r, BLOCK_VARS (outer)))
11873 finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));
11875 current_function_return_value = NULL_TREE;
11878 /* Remember that we were in class scope. */
11879 if (current_class_name)
11880 ctype = current_class_type;
11882 /* Must mark the RESULT_DECL as being in this function. */
11883 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
11885 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
11886 to the FUNCTION_DECL node itself. */
11887 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
11889 /* Save away current state, if appropriate. */
11890 if (!processing_template_decl)
11891 save_function_data (fndecl);
11893 /* Complain if there's just no return statement. */
11894 if (warn_return_type
11895 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
11896 && !dependent_type_p (TREE_TYPE (fntype))
11897 && !current_function_returns_value && !current_function_returns_null
11898 /* Don't complain if we abort or throw. */
11899 && !current_function_returns_abnormally
11900 && !DECL_NAME (DECL_RESULT (fndecl))
11901 /* Normally, with -Wreturn-type, flow will complain. Unless we're an
11902 inline function, as we might never be compiled separately. */
11903 && (DECL_INLINE (fndecl) || processing_template_decl)
11904 /* Structor return values (if any) are set by the compiler. */
11905 && !DECL_CONSTRUCTOR_P (fndecl)
11906 && !DECL_DESTRUCTOR_P (fndecl))
11907 warning (OPT_Wreturn_type, "no return statement in function returning non-void");
11909 /* Store the end of the function, so that we get good line number
11910 info for the epilogue. */
11911 cfun->function_end_locus = input_location;
11913 /* Genericize before inlining. */
11914 if (!processing_template_decl)
11916 struct language_function *f = DECL_SAVED_FUNCTION_DATA (fndecl);
11917 cp_genericize (fndecl);
11918 /* Clear out the bits we don't need. */
11919 f->x_current_class_ptr = NULL;
11920 f->x_current_class_ref = NULL;
11921 f->x_eh_spec_block = NULL;
11922 f->x_in_charge_parm = NULL;
11923 f->x_vtt_parm = NULL;
11924 f->x_return_value = NULL;
11925 f->bindings = NULL;
11926 f->extern_decl_map = NULL;
11928 /* Handle attribute((warn_unused_result)). Relies on gimple input. */
11929 c_warn_unused_result (&DECL_SAVED_TREE (fndecl));
11931 /* Clear out the bits we don't need. */
11932 local_names = NULL;
11934 /* We're leaving the context of this function, so zap cfun. It's still in
11935 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
11937 current_function_decl = NULL;
11939 /* If this is an in-class inline definition, we may have to pop the
11940 bindings for the template parameters that we added in
11941 maybe_begin_member_template_processing when start_function was
11943 if (inclass_inline)
11944 maybe_end_member_template_processing ();
11946 /* Leave the scope of the class. */
11948 pop_nested_class ();
11954 /* Let the error reporting routines know that we're outside a
11955 function. For a nested function, this value is used in
11956 cxx_pop_function_context and then reset via pop_function_context. */
11957 current_function_decl = NULL_TREE;
11962 /* Create the FUNCTION_DECL for a function definition.
11963 DECLSPECS and DECLARATOR are the parts of the declaration;
11964 they describe the return type and the name of the function,
11965 but twisted together in a fashion that parallels the syntax of C.
11967 This function creates a binding context for the function body
11968 as well as setting up the FUNCTION_DECL in current_function_decl.
11970 Returns a FUNCTION_DECL on success.
11972 If the DECLARATOR is not suitable for a function (it defines a datum
11973 instead), we return 0, which tells yyparse to report a parse error.
11975 May return void_type_node indicating that this method is actually
11976 a friend. See grokfield for more details.
11978 Came here with a `.pushlevel' .
11980 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
11981 CHANGES TO CODE IN `grokfield'. */
11984 start_method (cp_decl_specifier_seq *declspecs,
11985 const cp_declarator *declarator, tree attrlist)
11987 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
11990 if (fndecl == error_mark_node)
11991 return error_mark_node;
11993 if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
11995 error ("invalid member function declaration");
11996 return error_mark_node;
12000 cplus_decl_attributes (&fndecl, attrlist, 0);
12002 /* Pass friends other than inline friend functions back. */
12003 if (fndecl == void_type_node)
12006 if (DECL_IN_AGGR_P (fndecl))
12008 if (DECL_CONTEXT (fndecl)
12009 && TREE_CODE (DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
12010 error ("%qD is already defined in class %qT", fndecl,
12011 DECL_CONTEXT (fndecl));
12012 return error_mark_node;
12015 check_template_shadow (fndecl);
12017 DECL_DECLARED_INLINE_P (fndecl) = 1;
12018 if (flag_default_inline)
12019 DECL_INLINE (fndecl) = 1;
12021 /* We process method specializations in finish_struct_1. */
12022 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
12024 fndecl = push_template_decl (fndecl);
12025 if (fndecl == error_mark_node)
12029 if (! DECL_FRIEND_P (fndecl))
12031 if (TREE_CHAIN (fndecl))
12033 fndecl = copy_node (fndecl);
12034 TREE_CHAIN (fndecl) = NULL_TREE;
12038 finish_decl (fndecl, NULL_TREE, NULL_TREE);
12040 /* Make a place for the parms. */
12041 begin_scope (sk_function_parms, fndecl);
12043 DECL_IN_AGGR_P (fndecl) = 1;
12047 /* Go through the motions of finishing a function definition.
12048 We don't compile this method until after the whole class has
12051 FINISH_METHOD must return something that looks as though it
12052 came from GROKFIELD (since we are defining a method, after all).
12054 This is called after parsing the body of the function definition.
12055 STMTS is the chain of statements that makes up the function body.
12057 DECL is the ..._DECL that `start_method' provided. */
12060 finish_method (tree decl)
12062 tree fndecl = decl;
12067 if (decl == void_type_node)
12070 old_initial = DECL_INITIAL (fndecl);
12072 /* Undo the level for the parms (from start_method).
12073 This is like poplevel, but it causes nothing to be
12074 saved. Saving information here confuses symbol-table
12075 output routines. Besides, this information will
12076 be correctly output when this method is actually
12079 /* Clear out the meanings of the local variables of this level;
12080 also record in each decl which block it belongs to. */
12082 for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
12084 if (DECL_NAME (link) != NULL_TREE)
12085 pop_binding (DECL_NAME (link), link);
12086 gcc_assert (TREE_CODE (link) != FUNCTION_DECL);
12087 DECL_CONTEXT (link) = NULL_TREE;
12090 poplevel (0, 0, 0);
12092 DECL_INITIAL (fndecl) = old_initial;
12094 /* We used to check if the context of FNDECL was different from
12095 current_class_type as another way to get inside here. This didn't work
12096 for String.cc in libg++. */
12097 if (DECL_FRIEND_P (fndecl))
12099 VEC_safe_push (tree, gc, CLASSTYPE_INLINE_FRIENDS (current_class_type),
12101 decl = void_type_node;
12108 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
12109 we can lay it out later, when and if its type becomes complete. */
12112 maybe_register_incomplete_var (tree var)
12114 gcc_assert (TREE_CODE (var) == VAR_DECL);
12116 /* Keep track of variables with incomplete types. */
12117 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
12118 && DECL_EXTERNAL (var))
12120 tree inner_type = TREE_TYPE (var);
12122 while (TREE_CODE (inner_type) == ARRAY_TYPE)
12123 inner_type = TREE_TYPE (inner_type);
12124 inner_type = TYPE_MAIN_VARIANT (inner_type);
12126 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
12127 /* RTTI TD entries are created while defining the type_info. */
12128 || (TYPE_LANG_SPECIFIC (inner_type)
12129 && TYPE_BEING_DEFINED (inner_type)))
12130 incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
12134 /* Called when a class type (given by TYPE) is defined. If there are
12135 any existing VAR_DECLs whose type hsa been completed by this
12136 declaration, update them now. */
12139 complete_vars (tree type)
12141 tree *list = &incomplete_vars;
12143 gcc_assert (CLASS_TYPE_P (type));
12146 if (same_type_p (type, TREE_PURPOSE (*list)))
12148 tree var = TREE_VALUE (*list);
12149 tree type = TREE_TYPE (var);
12150 /* Complete the type of the variable. The VAR_DECL itself
12151 will be laid out in expand_expr. */
12152 complete_type (type);
12153 cp_apply_type_quals_to_decl (cp_type_quals (type), var);
12154 /* Remove this entry from the list. */
12155 *list = TREE_CHAIN (*list);
12158 list = &TREE_CHAIN (*list);
12161 /* Check for pending declarations which may have abstract type. */
12162 complete_type_check_abstract (type);
12165 /* If DECL is of a type which needs a cleanup, build and return an
12166 expression to perform that cleanup here. Return NULL_TREE if no
12167 cleanup need be done. */
12170 cxx_maybe_build_cleanup (tree decl)
12176 /* Assume no cleanup is required. */
12177 cleanup = NULL_TREE;
12179 if (error_operand_p (decl))
12182 /* Handle "__attribute__((cleanup))". We run the cleanup function
12183 before the destructor since the destructor is what actually
12184 terminates the lifetime of the object. */
12185 attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
12192 /* Get the name specified by the user for the cleanup function. */
12193 id = TREE_VALUE (TREE_VALUE (attr));
12194 /* Look up the name to find the cleanup function to call. It is
12195 important to use lookup_name here because that is what is
12196 used in c-common.c:handle_cleanup_attribute when performing
12197 initial checks on the attribute. Note that those checks
12198 include ensuring that the function found is not an overloaded
12199 function, or an object with an overloaded call operator,
12200 etc.; we can rely on the fact that the functionfound is an
12201 ordinary FUNCTION_DECL. */
12202 fn = lookup_name (id);
12203 arg = build_address (decl);
12205 cleanup = build_function_call (fn, build_tree_list (NULL_TREE,
12208 /* Handle ordinary C++ destructors. */
12209 type = TREE_TYPE (decl);
12210 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
12212 int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
12213 bool has_vbases = (TREE_CODE (type) == RECORD_TYPE
12214 && CLASSTYPE_VBASECLASSES (type));
12218 if (TREE_CODE (type) == ARRAY_TYPE)
12221 addr = build_address (decl);
12223 /* Optimize for space over speed here. */
12224 if (!has_vbases || flag_expensive_optimizations)
12225 flags |= LOOKUP_NONVIRTUAL;
12227 call = build_delete (TREE_TYPE (addr), addr,
12228 sfk_complete_destructor, flags, 0);
12230 cleanup = build_compound_expr (cleanup, call);
12238 /* When a stmt has been parsed, this function is called. */
12245 /* DECL was originally constructed as a non-static member function,
12246 but turned out to be static. Update it accordingly. */
12249 revert_static_member_fn (tree decl)
12252 tree function = TREE_TYPE (decl);
12253 tree args = TYPE_ARG_TYPES (function);
12255 if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
12256 != TYPE_UNQUALIFIED)
12257 error ("static member function %q#D declared with type qualifiers", decl);
12259 args = TREE_CHAIN (args);
12260 tmp = build_function_type (TREE_TYPE (function), args);
12261 tmp = build_qualified_type (tmp, cp_type_quals (function));
12262 tmp = build_exception_variant (tmp,
12263 TYPE_RAISES_EXCEPTIONS (function));
12264 TREE_TYPE (decl) = tmp;
12265 if (DECL_ARGUMENTS (decl))
12266 DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
12267 DECL_STATIC_FUNCTION_P (decl) = 1;
12270 /* Initialize the variables used during compilation of a C++
12274 cxx_push_function_context (struct function * f)
12276 struct language_function *p = GGC_CNEW (struct language_function);
12279 /* Whenever we start a new function, we destroy temporaries in the
12281 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
12287 if (DECL_SAVED_FUNCTION_DATA (fn))
12289 /* If we already parsed this function, and we're just expanding it
12290 now, restore saved state. */
12291 *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (fn);
12293 /* We don't need the saved data anymore. Unless this is an inline
12294 function; we need the named return value info for
12295 declare_return_variable. */
12296 if (! DECL_INLINE (fn))
12297 DECL_SAVED_FUNCTION_DATA (fn) = NULL;
12302 /* Free the language-specific parts of F, now that we've finished
12303 compiling the function. */
12306 cxx_pop_function_context (struct function * f)
12311 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
12312 one of the language-independent trees. */
12314 enum cp_tree_node_structure_enum
12315 cp_tree_node_structure (union lang_tree_node * t)
12317 switch (TREE_CODE (&t->generic))
12319 case DEFAULT_ARG: return TS_CP_DEFAULT_ARG;
12320 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER;
12321 case OVERLOAD: return TS_CP_OVERLOAD;
12322 case TEMPLATE_PARM_INDEX: return TS_CP_TPI;
12323 case PTRMEM_CST: return TS_CP_PTRMEM;
12324 case BASELINK: return TS_CP_BASELINK;
12325 case STATIC_ASSERT: return TS_CP_STATIC_ASSERT;
12326 case ARGUMENT_PACK_SELECT: return TS_CP_ARGUMENT_PACK_SELECT;
12327 case TRAIT_EXPR: return TS_CP_TRAIT_EXPR;
12328 default: return TS_CP_GENERIC;
12332 /* Build the void_list_node (void_type_node having been created). */
12334 build_void_list_node (void)
12336 tree t = build_tree_list (NULL_TREE, void_type_node);
12341 cp_missing_noreturn_ok_p (tree decl)
12343 /* A missing noreturn is ok for the `main' function. */
12344 return DECL_MAIN_P (decl);
12347 /* Return the COMDAT group into which DECL should be placed. */
12350 cxx_comdat_group (tree decl)
12354 /* Virtual tables, construction virtual tables, and virtual table
12355 tables all go in a single COMDAT group, named after the primary
12357 if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
12358 name = DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl)));
12359 /* For all other DECLs, the COMDAT group is the mangled name of the
12360 declaration itself. */
12363 while (DECL_THUNK_P (decl))
12365 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
12366 into the same section as the target function. In that case
12367 we must return target's name. */
12368 tree target = THUNK_TARGET (decl);
12369 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target)
12370 && DECL_SECTION_NAME (target) != NULL
12371 && DECL_ONE_ONLY (target))
12376 name = DECL_ASSEMBLER_NAME (decl);
12379 return IDENTIFIER_POINTER (name);
12382 #include "gt-cp-decl.h"