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 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to
20 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
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"
53 #include "tree-flow.h"
55 /* APPLE LOCAL blocks 6040305 (ce) */
56 tree grokparms (cp_parameter_declarator *, tree *);
57 static const char *redeclaration_error_message (tree, tree);
59 static int decl_jump_unsafe (tree);
60 static void require_complete_types_for_parms (tree);
61 static int ambi_op_p (enum tree_code);
62 static int unary_op_p (enum tree_code);
63 static void push_local_name (tree);
64 static tree grok_reference_init (tree, tree, tree, tree *);
65 static tree grokvardecl (tree, tree, const cp_decl_specifier_seq *,
67 static void record_unknown_type (tree, const char *);
68 static tree builtin_function_1 (const char *, tree, tree,
69 enum built_in_function code,
70 enum built_in_class cl, const char *,
72 static tree build_library_fn_1 (tree, enum tree_code, tree);
73 static int member_function_or_else (tree, tree, enum overload_flags);
74 static void bad_specifiers (tree, const char *, int, int, int, int,
76 static void check_for_uninitialized_const_var (tree);
77 static hashval_t typename_hash (const void *);
78 static int typename_compare (const void *, const void *);
79 static tree local_variable_p_walkfn (tree *, int *, void *);
80 static tree record_builtin_java_type (const char *, int);
81 static const char *tag_name (enum tag_types);
82 static tree lookup_and_check_tag (enum tag_types, tree, tag_scope, bool);
83 static int walk_namespaces_r (tree, walk_namespaces_fn, void *);
84 static void maybe_deduce_size_from_array_init (tree, tree);
85 static void layout_var_decl (tree);
86 static void maybe_commonize_var (tree);
87 static tree check_initializer (tree, tree, int, tree *);
88 static void make_rtl_for_nonlocal_decl (tree, tree, const char *);
89 static void save_function_data (tree);
90 static void check_function_type (tree, tree);
91 static void finish_constructor_body (void);
92 static void begin_destructor_body (void);
93 static void finish_destructor_body (void);
94 static tree create_array_type_for_decl (tree, tree, tree);
95 static tree get_atexit_node (void);
96 static tree get_dso_handle_node (void);
97 static tree start_cleanup_fn (void);
98 static void end_cleanup_fn (void);
99 static tree cp_make_fname_decl (tree, int);
100 static void initialize_predefined_identifiers (void);
101 static tree check_special_function_return_type
102 (special_function_kind, tree, tree);
103 static tree push_cp_library_fn (enum tree_code, tree);
104 static tree build_cp_library_fn (tree, enum tree_code, tree);
105 static void store_parm_decls (tree);
106 static void initialize_local_var (tree, tree);
107 static void expand_static_init (tree, tree);
108 static tree next_initializable_field (tree);
110 /* The following symbols are subsumed in the cp_global_trees array, and
111 listed here individually for documentation purposes.
114 tree wchar_decl_node;
116 tree vtable_entry_type;
117 tree delta_type_node;
118 tree __t_desc_type_node;
120 tree class_type_node;
121 tree unknown_type_node;
123 Array type `vtable_entry_type[]'
126 tree vtbl_ptr_type_node;
133 A FUNCTION_DECL which can call `abort'. Not necessarily the
134 one that the user will declare, but sufficient to be called
135 by routines that want to abort the program.
139 The FUNCTION_DECL for the default `::operator delete'.
141 tree global_delete_fndecl;
144 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
145 tree tinfo_var_id; */
147 tree cp_global_trees[CPTI_MAX];
149 /* Indicates that there is a type value in some namespace, although
150 that is not necessarily in scope at the moment. */
152 tree global_type_node;
154 /* The node that holds the "name" of the global scope. */
155 tree global_scope_name;
157 #define local_names cp_function_chain->x_local_names
159 /* A list of objects which have constructors or destructors
160 which reside in the global scope. The decl is stored in
161 the TREE_VALUE slot and the initializer is stored
162 in the TREE_PURPOSE slot. */
163 tree static_aggregates;
167 /* A node for the integer constants 2, and 3. */
169 tree integer_two_node, integer_three_node;
171 /* Used only for jumps to as-yet undefined labels, since jumps to
172 defined labels can have their validity checked immediately. */
174 struct named_label_use_entry GTY(())
176 struct named_label_use_entry *next;
177 /* The binding level to which this entry is *currently* attached.
178 This is initially the binding level in which the goto appeared,
179 but is modified as scopes are closed. */
180 struct cp_binding_level *binding_level;
181 /* The head of the names list that was current when the goto appeared,
182 or the inner scope popped. These are the decls that will *not* be
183 skipped when jumping to the label. */
185 /* The location of the goto, for error reporting. */
186 location_t o_goto_locus;
187 /* True if an OpenMP structured block scope has been closed since
188 the goto appeared. This means that the branch from the label will
189 illegally exit an OpenMP scope. */
193 /* A list of all LABEL_DECLs in the function that have names. Here so
194 we can clear out their names' definitions at the end of the
195 function, and so we can check the validity of jumps to these labels. */
197 struct named_label_entry GTY(())
199 /* The decl itself. */
202 /* The binding level to which the label is *currently* attached.
203 This is initially set to the binding level in which the label
204 is defined, but is modified as scopes are closed. */
205 struct cp_binding_level *binding_level;
206 /* The head of the names list that was current when the label was
207 defined, or the inner scope popped. These are the decls that will
208 be skipped when jumping to the label. */
210 /* A tree list of all decls from all binding levels that would be
211 crossed by a backward branch to the label. */
214 /* A list of uses of the label, before the label is defined. */
215 struct named_label_use_entry *uses;
217 /* The following bits are set after the label is defined, and are
218 updated as scopes are popped. They indicate that a backward jump
219 to the label will illegally enter a scope of the given flavor. */
225 #define named_labels cp_function_chain->x_named_labels
227 /* The number of function bodies which we are currently processing.
228 (Zero if we are at namespace scope, one inside the body of a
229 function, two inside the body of a function in a local class, etc.) */
232 /* States indicating how grokdeclarator() should handle declspecs marked
233 with __attribute__((deprecated)). An object declared as
234 __attribute__((deprecated)) suppresses warnings of uses of other
236 /* APPLE LOCAL begin "unavailable" attribute (radar 2809697) */
237 /* An object declared as __attribute__((unavailable)) suppresses
238 any reports of being declared with unavailable or deprecated
240 /* APPLE LOCAL end "unavailable" attribute (radar 2809697) */
242 enum deprecated_states {
245 /* APPLE LOCAL "unavailable" attribute (radar 2809697) */
246 , DEPRECATED_UNAVAILABLE_SUPPRESS
249 static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
252 /* A TREE_LIST of VAR_DECLs. The TREE_PURPOSE is a RECORD_TYPE or
253 UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type. At the
254 time the VAR_DECL was declared, the type was incomplete. */
256 static GTY(()) tree incomplete_vars;
258 /* Returns the kind of template specialization we are currently
259 processing, given that it's declaration contained N_CLASS_SCOPES
260 explicit scope qualifications. */
263 current_tmpl_spec_kind (int n_class_scopes)
265 int n_template_parm_scopes = 0;
266 int seen_specialization_p = 0;
267 int innermost_specialization_p = 0;
268 struct cp_binding_level *b;
270 /* Scan through the template parameter scopes. */
271 for (b = current_binding_level;
272 b->kind == sk_template_parms;
275 /* If we see a specialization scope inside a parameter scope,
276 then something is wrong. That corresponds to a declaration
279 template <class T> template <> ...
281 which is always invalid since [temp.expl.spec] forbids the
282 specialization of a class member template if the enclosing
283 class templates are not explicitly specialized as well. */
284 if (b->explicit_spec_p)
286 if (n_template_parm_scopes == 0)
287 innermost_specialization_p = 1;
289 seen_specialization_p = 1;
291 else if (seen_specialization_p == 1)
292 return tsk_invalid_member_spec;
294 ++n_template_parm_scopes;
297 /* Handle explicit instantiations. */
298 if (processing_explicit_instantiation)
300 if (n_template_parm_scopes != 0)
301 /* We've seen a template parameter list during an explicit
302 instantiation. For example:
304 template <class T> template void f(int);
306 This is erroneous. */
307 return tsk_invalid_expl_inst;
309 return tsk_expl_inst;
312 if (n_template_parm_scopes < n_class_scopes)
313 /* We've not seen enough template headers to match all the
314 specialized classes present. For example:
316 template <class T> void R<T>::S<T>::f(int);
318 This is invalid; there needs to be one set of template
319 parameters for each class. */
320 return tsk_insufficient_parms;
321 else if (n_template_parm_scopes == n_class_scopes)
322 /* We're processing a non-template declaration (even though it may
323 be a member of a template class.) For example:
325 template <class T> void S<T>::f(int);
327 The `class T' maches the `S<T>', leaving no template headers
328 corresponding to the `f'. */
330 else if (n_template_parm_scopes > n_class_scopes + 1)
331 /* We've got too many template headers. For example:
333 template <> template <class T> void f (T);
335 There need to be more enclosing classes. */
336 return tsk_excessive_parms;
338 /* This must be a template. It's of the form:
340 template <class T> template <class U> void S<T>::f(U);
342 This is a specialization if the innermost level was a
343 specialization; otherwise it's just a definition of the
345 return innermost_specialization_p ? tsk_expl_spec : tsk_template;
348 /* Exit the current scope. */
356 /* When a label goes out of scope, check to see if that label was used
357 in a valid manner, and issue any appropriate warnings or errors. */
360 pop_label (tree label, tree old_value)
362 if (!processing_template_decl)
364 if (DECL_INITIAL (label) == NULL_TREE)
368 error ("label %q+D used but not defined", label);
369 #ifdef USE_MAPPED_LOCATION
370 location = input_location; /* FIXME want (input_filename, (line)0) */
372 location.file = input_filename;
375 /* Avoid crashing later. */
376 define_label (location, DECL_NAME (label));
378 else if (!TREE_USED (label))
379 warning (OPT_Wunused_label, "label %q+D defined but not used", label);
382 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
385 /* At the end of a function, all labels declared within the function
386 go out of scope. BLOCK is the top-level block for the
390 pop_labels_1 (void **slot, void *data)
392 struct named_label_entry *ent = (struct named_label_entry *) *slot;
393 tree block = (tree) data;
395 pop_label (ent->label_decl, NULL_TREE);
397 /* Put the labels into the "variables" of the top-level block,
398 so debugger can see them. */
399 TREE_CHAIN (ent->label_decl) = BLOCK_VARS (block);
400 BLOCK_VARS (block) = ent->label_decl;
402 htab_clear_slot (named_labels, slot);
408 pop_labels (tree block)
412 htab_traverse (named_labels, pop_labels_1, block);
417 /* At the end of a block with local labels, restore the outer definition. */
420 pop_local_label (tree label, tree old_value)
422 struct named_label_entry dummy;
425 pop_label (label, old_value);
427 dummy.label_decl = label;
428 slot = htab_find_slot (named_labels, &dummy, NO_INSERT);
429 htab_clear_slot (named_labels, slot);
432 /* The following two routines are used to interface to Objective-C++.
433 The binding level is purposely treated as an opaque type. */
436 objc_get_current_scope (void)
438 return current_binding_level;
441 /* The following routine is used by the NeXT-style SJLJ exceptions;
442 variables get marked 'volatile' so as to not be clobbered by
443 _setjmp()/_longjmp() calls. All variables in the current scope,
444 as well as parent scopes up to (but not including) ENCLOSING_BLK
445 shall be thusly marked. */
448 objc_mark_locals_volatile (void *enclosing_blk)
450 struct cp_binding_level *scope;
452 for (scope = current_binding_level;
453 scope && scope != enclosing_blk;
454 scope = scope->level_chain)
458 for (decl = scope->names; decl; decl = TREE_CHAIN (decl))
459 objc_volatilize_decl (decl);
461 /* Do not climb up past the current function. */
462 if (scope->kind == sk_function_parms)
467 /* Update data for defined and undefined labels when leaving a scope. */
470 poplevel_named_label_1 (void **slot, void *data)
472 struct named_label_entry *ent = (struct named_label_entry *) *slot;
473 struct cp_binding_level *bl = (struct cp_binding_level *) data;
474 struct cp_binding_level *obl = bl->level_chain;
476 if (ent->binding_level == bl)
480 for (decl = ent->names_in_scope; decl; decl = TREE_CHAIN (decl))
481 if (decl_jump_unsafe (decl))
482 ent->bad_decls = tree_cons (NULL, decl, ent->bad_decls);
484 ent->binding_level = obl;
485 ent->names_in_scope = obl->names;
489 ent->in_try_scope = true;
492 ent->in_catch_scope = true;
495 ent->in_omp_scope = true;
503 struct named_label_use_entry *use;
505 for (use = ent->uses; use ; use = use->next)
506 if (use->binding_level == bl)
508 use->binding_level = obl;
509 use->names_in_scope = obl->names;
510 if (bl->kind == sk_omp)
511 use->in_omp_scope = true;
518 /* Exit a binding level.
519 Pop the level off, and restore the state of the identifier-decl mappings
520 that were in effect when this level was entered.
522 If KEEP == 1, this level had explicit declarations, so
523 and create a "block" (a BLOCK node) for the level
524 to record its declarations and subblocks for symbol table output.
526 If FUNCTIONBODY is nonzero, this level is the body of a function,
527 so create a block as if KEEP were set and also clear out all
530 If REVERSE is nonzero, reverse the order of decls before putting
531 them into the BLOCK. */
534 poplevel (int keep, int reverse, int functionbody)
537 /* The chain of decls was accumulated in reverse order.
538 Put it into forward order, just for cleanliness. */
540 int tmp = functionbody;
541 int real_functionbody;
545 int leaving_for_scope;
548 timevar_push (TV_NAME_LOOKUP);
553 gcc_assert (current_binding_level->kind != sk_class);
555 real_functionbody = (current_binding_level->kind == sk_cleanup
556 ? ((functionbody = 0), tmp) : functionbody);
557 subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
559 gcc_assert (!VEC_length(cp_class_binding,
560 current_binding_level->class_shadowed));
562 /* We used to use KEEP == 2 to indicate that the new block should go
563 at the beginning of the list of blocks at this binding level,
564 rather than the end. This hack is no longer used. */
565 gcc_assert (keep == 0 || keep == 1);
567 if (current_binding_level->keep)
570 /* Any uses of undefined labels, and any defined labels, now operate
571 under constraints of next binding contour. */
572 if (cfun && !functionbody && named_labels)
573 htab_traverse (named_labels, poplevel_named_label_1,
574 current_binding_level);
576 /* Get the decls in the order they were written.
577 Usually current_binding_level->names is in reverse order.
578 But parameter decls were previously put in forward order. */
581 current_binding_level->names
582 = decls = nreverse (current_binding_level->names);
584 decls = current_binding_level->names;
586 /* If there were any declarations or structure tags in that level,
587 or if this level is a function body,
588 create a BLOCK to record them for the life of this function. */
590 if (keep == 1 || functionbody)
591 block = make_node (BLOCK);
592 if (block != NULL_TREE)
594 BLOCK_VARS (block) = decls;
595 BLOCK_SUBBLOCKS (block) = subblocks;
598 /* In each subblock, record that this is its superior. */
600 for (link = subblocks; link; link = TREE_CHAIN (link))
601 BLOCK_SUPERCONTEXT (link) = block;
603 /* We still support the old for-scope rules, whereby the variables
604 in a for-init statement were in scope after the for-statement
605 ended. We only use the new rules if flag_new_for_scope is
608 = current_binding_level->kind == sk_for && flag_new_for_scope == 1;
610 /* Before we remove the declarations first check for unused variables. */
611 if (warn_unused_variable
612 && !processing_template_decl)
613 for (decl = getdecls (); decl; decl = TREE_CHAIN (decl))
614 if (TREE_CODE (decl) == VAR_DECL
615 && ! TREE_USED (decl)
616 && ! DECL_IN_SYSTEM_HEADER (decl)
617 && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl))
618 warning (OPT_Wunused_variable, "unused variable %q+D", decl);
620 /* Remove declarations for all the DECLs in this level. */
621 for (link = decls; link; link = TREE_CHAIN (link))
623 if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
626 tree name = DECL_NAME (link);
630 ob = outer_binding (name,
631 IDENTIFIER_BINDING (name),
634 ns_binding = IDENTIFIER_NAMESPACE_VALUE (name);
636 ns_binding = NULL_TREE;
638 if (ob && ob->scope == current_binding_level->level_chain)
639 /* We have something like:
644 and we are leaving the `for' scope. There's no reason to
645 keep the binding of the inner `i' in this case. */
646 pop_binding (name, link);
647 else if ((ob && (TREE_CODE (ob->value) == TYPE_DECL))
648 || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL))
649 /* Here, we have something like:
657 We must pop the for-scope binding so we know what's a
658 type and what isn't. */
659 pop_binding (name, link);
662 /* Mark this VAR_DECL as dead so that we can tell we left it
663 there only for backward compatibility. */
664 DECL_DEAD_FOR_LOCAL (link) = 1;
666 /* Keep track of what should have happened when we
667 popped the binding. */
670 SET_DECL_SHADOWED_FOR_VAR (link, ob->value);
671 DECL_HAS_SHADOWED_FOR_VAR_P (link) = 1;
674 /* Add it to the list of dead variables in the next
675 outermost binding to that we can remove these when we
676 leave that binding. */
677 current_binding_level->level_chain->dead_vars_from_for
678 = tree_cons (NULL_TREE, link,
679 current_binding_level->level_chain->
682 /* Although we don't pop the cxx_binding, we do clear
683 its SCOPE since the scope is going away now. */
684 IDENTIFIER_BINDING (name)->scope
685 = current_binding_level->level_chain;
692 /* Remove the binding. */
695 if (TREE_CODE (decl) == TREE_LIST)
696 decl = TREE_VALUE (decl);
699 if (TREE_CODE (name) == OVERLOAD)
700 name = OVL_FUNCTION (name);
702 gcc_assert (DECL_P (name));
703 pop_binding (DECL_NAME (name), decl);
707 /* Remove declarations for any `for' variables from inner scopes
708 that we kept around. */
709 for (link = current_binding_level->dead_vars_from_for;
710 link; link = TREE_CHAIN (link))
711 pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
713 /* Restore the IDENTIFIER_TYPE_VALUEs. */
714 for (link = current_binding_level->type_shadowed;
715 link; link = TREE_CHAIN (link))
716 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
718 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
719 for (link = current_binding_level->shadowed_labels;
721 link = TREE_CHAIN (link))
722 pop_local_label (TREE_VALUE (link), TREE_PURPOSE (link));
724 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
725 list if a `using' declaration put them there. The debugging
726 back-ends won't understand OVERLOAD, so we remove them here.
727 Because the BLOCK_VARS are (temporarily) shared with
728 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
729 popped all the bindings. */
734 for (d = &BLOCK_VARS (block); *d; )
736 if (TREE_CODE (*d) == TREE_LIST)
737 *d = TREE_CHAIN (*d);
739 d = &TREE_CHAIN (*d);
743 /* If the level being exited is the top level of a function,
744 check over all the labels. */
747 /* Since this is the top level block of a function, the vars are
748 the function's parameters. Don't leave them in the BLOCK
749 because they are found in the FUNCTION_DECL instead. */
750 BLOCK_VARS (block) = 0;
754 kind = current_binding_level->kind;
755 if (kind == sk_cleanup)
759 /* If this is a temporary binding created for a cleanup, then we'll
760 have pushed a statement list level. Pop that, create a new
761 BIND_EXPR for the block, and insert it into the stream. */
762 stmt = pop_stmt_list (current_binding_level->statement_list);
763 stmt = c_build_bind_expr (block, stmt);
770 /* The current function is being defined, so its DECL_INITIAL
771 should be error_mark_node. */
772 gcc_assert (DECL_INITIAL (current_function_decl) == error_mark_node);
773 DECL_INITIAL (current_function_decl) = block;
776 current_binding_level->blocks
777 = chainon (current_binding_level->blocks, block);
779 /* If we did not make a block for the level just exited,
780 any blocks made for inner levels
781 (since they cannot be recorded as subblocks in that level)
782 must be carried forward so they will later become subblocks
783 of something else. */
785 current_binding_level->blocks
786 = chainon (current_binding_level->blocks, subblocks);
788 /* Each and every BLOCK node created here in `poplevel' is important
789 (e.g. for proper debugging information) so if we created one
790 earlier, mark it as "used". */
792 TREE_USED (block) = 1;
794 /* All temporary bindings created for cleanups are popped silently. */
795 if (kind == sk_cleanup)
798 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, block);
801 /* Insert BLOCK at the end of the list of subblocks of the
802 current binding level. This is used when a BIND_EXPR is expanded,
803 to handle the BLOCK node inside the BIND_EXPR. */
806 insert_block (tree block)
808 TREE_USED (block) = 1;
809 current_binding_level->blocks
810 = chainon (current_binding_level->blocks, block);
813 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
814 itself, calling F for each. The DATA is passed to F as well. */
817 walk_namespaces_r (tree namespace, walk_namespaces_fn f, void* data)
820 tree current = NAMESPACE_LEVEL (namespace)->namespaces;
822 result |= (*f) (namespace, data);
824 for (; current; current = TREE_CHAIN (current))
825 result |= walk_namespaces_r (current, f, data);
830 /* Walk all the namespaces, calling F for each. The DATA is passed to
834 walk_namespaces (walk_namespaces_fn f, void* data)
836 return walk_namespaces_r (global_namespace, f, data);
839 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
840 DATA is non-NULL, this is the last time we will call
841 wrapup_global_declarations for this NAMESPACE. */
844 wrapup_globals_for_namespace (tree namespace, void* data)
846 struct cp_binding_level *level = NAMESPACE_LEVEL (namespace);
847 VEC(tree,gc) *statics = level->static_decls;
848 tree *vec = VEC_address (tree, statics);
849 int len = VEC_length (tree, statics);
850 int last_time = (data != 0);
854 check_global_declarations (vec, len);
855 emit_debug_global_declarations (vec, len);
859 /* Write out any globals that need to be output. */
860 return wrapup_global_declarations (vec, len);
864 /* In C++, you don't have to write `struct S' to refer to `S'; you
865 can just use `S'. We accomplish this by creating a TYPE_DECL as
866 if the user had written `typedef struct S S'. Create and return
867 the TYPE_DECL for TYPE. */
870 create_implicit_typedef (tree name, tree type)
874 decl = build_decl (TYPE_DECL, name, type);
875 DECL_ARTIFICIAL (decl) = 1;
876 /* There are other implicit type declarations, like the one *within*
877 a class that allows you to write `S::S'. We must distinguish
879 SET_DECL_IMPLICIT_TYPEDEF_P (decl);
880 TYPE_NAME (type) = decl;
885 /* Remember a local name for name-mangling purposes. */
888 push_local_name (tree decl)
893 timevar_push (TV_NAME_LOOKUP);
895 name = DECL_NAME (decl);
897 nelts = VEC_length (tree, local_names);
898 for (i = 0; i < nelts; i++)
900 t = VEC_index (tree, local_names, i);
901 if (DECL_NAME (t) == name)
903 if (!DECL_LANG_SPECIFIC (decl))
904 retrofit_lang_decl (decl);
905 DECL_LANG_SPECIFIC (decl)->decl_flags.u2sel = 1;
906 if (DECL_LANG_SPECIFIC (t))
907 DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
909 DECL_DISCRIMINATOR (decl) = 1;
911 VEC_replace (tree, local_names, i, decl);
912 timevar_pop (TV_NAME_LOOKUP);
917 VEC_safe_push (tree, gc, local_names, decl);
918 timevar_pop (TV_NAME_LOOKUP);
921 /* Subroutine of duplicate_decls: return truthvalue of whether
922 or not types of these decls match.
924 For C++, we must compare the parameter list so that `int' can match
925 `int&' in a parameter position, but `int&' is not confused with
929 decls_match (tree newdecl, tree olddecl)
933 if (newdecl == olddecl)
936 if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
937 /* If the two DECLs are not even the same kind of thing, we're not
938 interested in their types. */
941 if (TREE_CODE (newdecl) == FUNCTION_DECL)
943 tree f1 = TREE_TYPE (newdecl);
944 tree f2 = TREE_TYPE (olddecl);
945 tree p1 = TYPE_ARG_TYPES (f1);
946 tree p2 = TYPE_ARG_TYPES (f2);
948 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
949 && ! (DECL_EXTERN_C_P (newdecl)
950 && DECL_EXTERN_C_P (olddecl)))
953 if (TREE_CODE (f1) != TREE_CODE (f2))
956 if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
958 if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
959 && (DECL_BUILT_IN (olddecl)
960 #ifndef NO_IMPLICIT_EXTERN_C
961 || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
962 || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
966 types_match = self_promoting_args_p (p1);
967 if (p1 == void_list_node)
968 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
970 #ifndef NO_IMPLICIT_EXTERN_C
971 else if (p1 == NULL_TREE
972 && (DECL_EXTERN_C_P (olddecl)
973 && DECL_IN_SYSTEM_HEADER (olddecl)
974 && !DECL_CLASS_SCOPE_P (olddecl))
975 && (DECL_EXTERN_C_P (newdecl)
976 && DECL_IN_SYSTEM_HEADER (newdecl)
977 && !DECL_CLASS_SCOPE_P (newdecl)))
979 types_match = self_promoting_args_p (p2);
980 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
984 types_match = compparms (p1, p2);
989 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
991 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
992 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
995 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
996 DECL_TEMPLATE_PARMS (olddecl)))
999 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1000 types_match = same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)),
1001 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl)));
1003 types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
1004 DECL_TEMPLATE_RESULT (newdecl));
1008 /* Need to check scope for variable declaration (VAR_DECL).
1009 For typedef (TYPE_DECL), scope is ignored. */
1010 if (TREE_CODE (newdecl) == VAR_DECL
1011 && CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
1013 Two declarations for an object with C language linkage
1014 with the same name (ignoring the namespace that qualify
1015 it) that appear in different namespace scopes refer to
1017 && !(DECL_EXTERN_C_P (olddecl) && DECL_EXTERN_C_P (newdecl)))
1020 if (TREE_TYPE (newdecl) == error_mark_node)
1021 types_match = TREE_TYPE (olddecl) == error_mark_node;
1022 else if (TREE_TYPE (olddecl) == NULL_TREE)
1023 types_match = TREE_TYPE (newdecl) == NULL_TREE;
1024 else if (TREE_TYPE (newdecl) == NULL_TREE)
1027 types_match = comptypes (TREE_TYPE (newdecl),
1028 TREE_TYPE (olddecl),
1029 COMPARE_REDECLARATION);
1035 /* If NEWDECL is `static' and an `extern' was seen previously,
1036 warn about it. OLDDECL is the previous declaration.
1038 Note that this does not apply to the C++ case of declaring
1039 a variable `extern const' and then later `const'.
1041 Don't complain about built-in functions, since they are beyond
1042 the user's control. */
1045 warn_extern_redeclared_static (tree newdecl, tree olddecl)
1049 if (TREE_CODE (newdecl) == TYPE_DECL
1050 || TREE_CODE (newdecl) == TEMPLATE_DECL
1051 || TREE_CODE (newdecl) == CONST_DECL
1052 || TREE_CODE (newdecl) == NAMESPACE_DECL)
1055 /* Don't get confused by static member functions; that's a different
1057 if (TREE_CODE (newdecl) == FUNCTION_DECL
1058 && DECL_STATIC_FUNCTION_P (newdecl))
1061 /* If the old declaration was `static', or the new one isn't, then
1062 then everything is OK. */
1063 if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
1066 /* It's OK to declare a builtin function as `static'. */
1067 if (TREE_CODE (olddecl) == FUNCTION_DECL
1068 && DECL_ARTIFICIAL (olddecl))
1071 name = DECL_ASSEMBLER_NAME (newdecl);
1072 pedwarn ("%qD was declared %<extern%> and later %<static%>", newdecl);
1073 pedwarn ("previous declaration of %q+D", olddecl);
1076 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1077 function templates. If their exception specifications do not
1078 match, issue an a diagnostic. */
1081 check_redeclaration_exception_specification (tree new_decl,
1086 tree new_exceptions;
1087 tree old_exceptions;
1089 new_type = TREE_TYPE (new_decl);
1090 new_exceptions = TYPE_RAISES_EXCEPTIONS (new_type);
1091 old_type = TREE_TYPE (old_decl);
1092 old_exceptions = TYPE_RAISES_EXCEPTIONS (old_type);
1096 If any declaration of a function has an exception-specification,
1097 all declarations, including the definition and an explicit
1098 specialization, of that function shall have an
1099 exception-specification with the same set of type-ids. */
1100 if ((pedantic || ! DECL_IN_SYSTEM_HEADER (old_decl))
1101 && ! DECL_IS_BUILTIN (old_decl)
1103 && !comp_except_specs (new_exceptions, old_exceptions,
1106 error ("declaration of %qF throws different exceptions", new_decl);
1107 error ("from previous declaration %q+F", old_decl);
1111 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1112 If the redeclaration is invalid, a diagnostic is issued, and the
1113 error_mark_node is returned. Otherwise, OLDDECL is returned.
1115 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1118 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1121 duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend)
1123 unsigned olddecl_uid = DECL_UID (olddecl);
1124 int olddecl_friend = 0, types_match = 0, hidden_friend = 0;
1125 int new_defines_function = 0;
1128 if (newdecl == olddecl)
1131 types_match = decls_match (newdecl, olddecl);
1133 /* If either the type of the new decl or the type of the old decl is an
1134 error_mark_node, then that implies that we have already issued an
1135 error (earlier) for some bogus type specification, and in that case,
1136 it is rather pointless to harass the user with yet more error message
1137 about the same declaration, so just pretend the types match here. */
1138 if (TREE_TYPE (newdecl) == error_mark_node
1139 || TREE_TYPE (olddecl) == error_mark_node)
1140 return error_mark_node;
1142 if (DECL_P (olddecl)
1143 && TREE_CODE (newdecl) == FUNCTION_DECL
1144 && TREE_CODE (olddecl) == FUNCTION_DECL
1145 && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
1147 if (DECL_DECLARED_INLINE_P (newdecl)
1148 && DECL_UNINLINABLE (newdecl)
1149 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1150 /* Already warned elsewhere. */;
1151 else if (DECL_DECLARED_INLINE_P (olddecl)
1152 && DECL_UNINLINABLE (olddecl)
1153 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1154 /* Already warned. */;
1155 else if (DECL_DECLARED_INLINE_P (newdecl)
1156 && DECL_UNINLINABLE (olddecl)
1157 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl)))
1159 warning (OPT_Wattributes, "function %q+D redeclared as inline",
1161 warning (OPT_Wattributes, "previous declaration of %q+D "
1162 "with attribute noinline", olddecl);
1164 else if (DECL_DECLARED_INLINE_P (olddecl)
1165 && DECL_UNINLINABLE (newdecl)
1166 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1168 warning (OPT_Wattributes, "function %q+D redeclared with "
1169 "attribute noinline", newdecl);
1170 warning (OPT_Wattributes, "previous declaration of %q+D was inline",
1175 /* Check for redeclaration and other discrepancies. */
1176 if (TREE_CODE (olddecl) == FUNCTION_DECL
1177 && DECL_ARTIFICIAL (olddecl))
1179 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl));
1180 if (TREE_CODE (newdecl) != FUNCTION_DECL)
1182 /* Avoid warnings redeclaring built-ins which have not been
1183 explicitly declared. */
1184 if (DECL_ANTICIPATED (olddecl))
1187 /* If you declare a built-in or predefined function name as static,
1188 the old definition is overridden, but optionally warn this was a
1189 bad choice of name. */
1190 if (! TREE_PUBLIC (newdecl))
1192 warning (OPT_Wshadow, "shadowing %s function %q#D",
1193 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
1195 /* Discard the old built-in function. */
1198 /* If the built-in is not ansi, then programs can override
1199 it even globally without an error. */
1200 else if (! DECL_BUILT_IN (olddecl))
1201 warning (0, "library function %q#D redeclared as non-function %q#D",
1205 error ("declaration of %q#D", newdecl);
1206 error ("conflicts with built-in declaration %q#D",
1211 else if (!types_match)
1213 /* Avoid warnings redeclaring built-ins which have not been
1214 explicitly declared. */
1215 if (DECL_ANTICIPATED (olddecl))
1217 /* Deal with fileptr_type_node. FILE type is not known
1218 at the time we create the builtins. */
1221 for (t1 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1222 t2 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1224 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1227 else if (TREE_VALUE (t2) == fileptr_type_node)
1229 tree t = TREE_VALUE (t1);
1231 if (TREE_CODE (t) == POINTER_TYPE
1232 && TYPE_NAME (TREE_TYPE (t))
1233 && DECL_NAME (TYPE_NAME (TREE_TYPE (t)))
1234 == get_identifier ("FILE")
1235 && compparms (TREE_CHAIN (t1), TREE_CHAIN (t2)))
1237 tree oldargs = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1239 TYPE_ARG_TYPES (TREE_TYPE (olddecl))
1240 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1241 types_match = decls_match (newdecl, olddecl);
1243 return duplicate_decls (newdecl, olddecl,
1245 TYPE_ARG_TYPES (TREE_TYPE (olddecl)) = oldargs;
1248 else if (! same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1251 else if ((DECL_EXTERN_C_P (newdecl)
1252 && DECL_EXTERN_C_P (olddecl))
1253 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1254 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1256 /* A near match; override the builtin. */
1258 if (TREE_PUBLIC (newdecl))
1260 warning (0, "new declaration %q#D", newdecl);
1261 warning (0, "ambiguates built-in declaration %q#D",
1265 warning (OPT_Wshadow, "shadowing %s function %q#D",
1266 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
1270 /* Discard the old built-in function. */
1273 /* Replace the old RTL to avoid problems with inlining. */
1274 COPY_DECL_RTL (newdecl, olddecl);
1276 /* Even if the types match, prefer the new declarations type for
1277 built-ins which have not been explicitly declared, for
1278 exception lists, etc... */
1279 else if (DECL_ANTICIPATED (olddecl))
1281 tree type = TREE_TYPE (newdecl);
1282 tree attribs = (*targetm.merge_type_attributes)
1283 (TREE_TYPE (olddecl), type);
1285 type = cp_build_type_attribute_variant (type, attribs);
1286 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = type;
1289 /* Whether or not the builtin can throw exceptions has no
1290 bearing on this declarator. */
1291 TREE_NOTHROW (olddecl) = 0;
1293 if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
1295 /* If a builtin function is redeclared as `static', merge
1296 the declarations, but make the original one static. */
1297 DECL_THIS_STATIC (olddecl) = 1;
1298 TREE_PUBLIC (olddecl) = 0;
1300 /* Make the old declaration consistent with the new one so
1301 that all remnants of the builtin-ness of this function
1302 will be banished. */
1303 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1304 COPY_DECL_RTL (newdecl, olddecl);
1307 else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1309 if ((TREE_CODE (olddecl) == TYPE_DECL && DECL_ARTIFICIAL (olddecl)
1310 && TREE_CODE (newdecl) != TYPE_DECL
1311 && ! (TREE_CODE (newdecl) == TEMPLATE_DECL
1312 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL))
1313 || (TREE_CODE (newdecl) == TYPE_DECL && DECL_ARTIFICIAL (newdecl)
1314 && TREE_CODE (olddecl) != TYPE_DECL
1315 && ! (TREE_CODE (olddecl) == TEMPLATE_DECL
1316 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
1319 /* We do nothing special here, because C++ does such nasty
1320 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1321 get shadowed, and know that if we need to find a TYPE_DECL
1322 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1323 slot of the identifier. */
1327 if ((TREE_CODE (newdecl) == FUNCTION_DECL
1328 && DECL_FUNCTION_TEMPLATE_P (olddecl))
1329 || (TREE_CODE (olddecl) == FUNCTION_DECL
1330 && DECL_FUNCTION_TEMPLATE_P (newdecl)))
1333 error ("%q#D redeclared as different kind of symbol", newdecl);
1334 if (TREE_CODE (olddecl) == TREE_LIST)
1335 olddecl = TREE_VALUE (olddecl);
1336 error ("previous declaration of %q+#D", olddecl);
1338 return error_mark_node;
1340 else if (!types_match)
1342 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
1343 /* These are certainly not duplicate declarations; they're
1344 from different scopes. */
1347 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1349 /* The name of a class template may not be declared to refer to
1350 any other template, class, function, object, namespace, value,
1351 or type in the same scope. */
1352 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
1353 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1355 error ("declaration of template %q#D", newdecl);
1356 error ("conflicts with previous declaration %q+#D", olddecl);
1358 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
1359 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
1360 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
1361 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
1362 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1363 DECL_TEMPLATE_PARMS (olddecl))
1364 /* Template functions can be disambiguated by
1366 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
1367 TREE_TYPE (TREE_TYPE (olddecl))))
1369 error ("new declaration %q#D", newdecl);
1370 error ("ambiguates old declaration %q+#D", olddecl);
1374 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1376 if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
1378 error ("declaration of C function %q#D conflicts with",
1380 error ("previous declaration %q+#D here", olddecl);
1382 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1383 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1385 error ("new declaration %q#D", newdecl);
1386 error ("ambiguates old declaration %q+#D", olddecl);
1387 return error_mark_node;
1394 error ("conflicting declaration %q#D", newdecl);
1395 error ("%q+D has a previous declaration as %q#D", olddecl, olddecl);
1396 return error_mark_node;
1399 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1400 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
1401 && (!DECL_TEMPLATE_INFO (newdecl)
1402 || (DECL_TI_TEMPLATE (newdecl)
1403 != DECL_TI_TEMPLATE (olddecl))))
1404 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
1405 && (!DECL_TEMPLATE_INFO (olddecl)
1406 || (DECL_TI_TEMPLATE (olddecl)
1407 != DECL_TI_TEMPLATE (newdecl))))))
1408 /* It's OK to have a template specialization and a non-template
1409 with the same type, or to have specializations of two
1410 different templates with the same type. Note that if one is a
1411 specialization, and the other is an instantiation of the same
1412 template, that we do not exit at this point. That situation
1413 can occur if we instantiate a template class, and then
1414 specialize one of its methods. This situation is valid, but
1415 the declarations must be merged in the usual way. */
1417 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1418 && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
1419 && !DECL_USE_TEMPLATE (newdecl))
1420 || (DECL_TEMPLATE_INSTANTIATION (newdecl)
1421 && !DECL_USE_TEMPLATE (olddecl))))
1422 /* One of the declarations is a template instantiation, and the
1423 other is not a template at all. That's OK. */
1425 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1427 /* In [namespace.alias] we have:
1429 In a declarative region, a namespace-alias-definition can be
1430 used to redefine a namespace-alias declared in that declarative
1431 region to refer only to the namespace to which it already
1434 Therefore, if we encounter a second alias directive for the same
1435 alias, we can just ignore the second directive. */
1436 if (DECL_NAMESPACE_ALIAS (newdecl)
1437 && (DECL_NAMESPACE_ALIAS (newdecl)
1438 == DECL_NAMESPACE_ALIAS (olddecl)))
1440 /* [namespace.alias]
1442 A namespace-name or namespace-alias shall not be declared as
1443 the name of any other entity in the same declarative region.
1444 A namespace-name defined at global scope shall not be
1445 declared as the name of any other entity in any global scope
1447 error ("declaration of namespace %qD conflicts with", newdecl);
1448 error ("previous declaration of namespace %q+D here", olddecl);
1449 return error_mark_node;
1453 const char *errmsg = redeclaration_error_message (newdecl, olddecl);
1456 error (errmsg, newdecl);
1457 if (DECL_NAME (olddecl) != NULL_TREE)
1458 error ((DECL_INITIAL (olddecl) && namespace_bindings_p ())
1459 ? "%q+#D previously defined here"
1460 : "%q+#D previously declared here", olddecl);
1461 return error_mark_node;
1463 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1464 && DECL_INITIAL (olddecl) != NULL_TREE
1465 && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) == NULL_TREE
1466 && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != NULL_TREE)
1468 /* Prototype decl follows defn w/o prototype. */
1469 warning (0, "prototype for %q+#D", newdecl);
1470 warning (0, "%Jfollows non-prototype definition here", olddecl);
1472 else if ((TREE_CODE (olddecl) == FUNCTION_DECL
1473 || TREE_CODE (olddecl) == VAR_DECL)
1474 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
1477 If two declarations of the same function or object
1478 specify different linkage-specifications ..., the program
1479 is ill-formed.... Except for functions with C++ linkage,
1480 a function declaration without a linkage specification
1481 shall not precede the first linkage specification for
1482 that function. A function can be declared without a
1483 linkage specification after an explicit linkage
1484 specification has been seen; the linkage explicitly
1485 specified in the earlier declaration is not affected by
1486 such a function declaration.
1488 DR 563 raises the question why the restrictions on
1489 functions should not also apply to objects. Older
1490 versions of G++ silently ignore the linkage-specification
1498 which is clearly wrong. Therefore, we now treat objects
1500 if (current_lang_depth () == 0)
1502 /* There is no explicit linkage-specification, so we use
1503 the linkage from the previous declaration. */
1504 if (!DECL_LANG_SPECIFIC (newdecl))
1505 retrofit_lang_decl (newdecl);
1506 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1510 error ("previous declaration of %q+#D with %qL linkage",
1511 olddecl, DECL_LANGUAGE (olddecl));
1512 error ("conflicts with new declaration with %qL linkage",
1513 DECL_LANGUAGE (newdecl));
1517 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
1519 else if (TREE_CODE (olddecl) == FUNCTION_DECL)
1521 tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1522 tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1525 if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
1526 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
1528 for (; t1 && t1 != void_list_node;
1529 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
1530 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
1532 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
1535 pedwarn ("default argument given for parameter %d of %q#D",
1537 pedwarn ("after previous specification in %q+#D", olddecl);
1541 error ("default argument given for parameter %d of %q#D",
1543 error ("after previous specification in %q+#D",
1548 if (DECL_DECLARED_INLINE_P (newdecl)
1549 && ! DECL_DECLARED_INLINE_P (olddecl)
1550 && TREE_ADDRESSABLE (olddecl) && warn_inline)
1552 warning (0, "%q#D was used before it was declared inline", newdecl);
1553 warning (0, "%Jprevious non-inline declaration here", olddecl);
1558 /* Do not merge an implicit typedef with an explicit one. In:
1562 typedef class A A __attribute__ ((foo));
1564 the attribute should apply only to the typedef. */
1565 if (TREE_CODE (olddecl) == TYPE_DECL
1566 && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
1567 || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
1570 /* If new decl is `static' and an `extern' was seen previously,
1572 warn_extern_redeclared_static (newdecl, olddecl);
1574 /* We have committed to returning 1 at this point. */
1575 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1577 /* Now that functions must hold information normally held
1578 by field decls, there is extra work to do so that
1579 declaration information does not get destroyed during
1581 if (DECL_VINDEX (olddecl))
1582 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
1583 if (DECL_CONTEXT (olddecl))
1584 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1585 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
1586 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1587 DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
1588 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
1589 DECL_INVALID_OVERRIDER_P (newdecl) |= DECL_INVALID_OVERRIDER_P (olddecl);
1590 DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
1591 if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
1592 SET_OVERLOADED_OPERATOR_CODE
1593 (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
1594 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
1596 /* Optionally warn about more than one declaration for the same
1597 name, but don't warn about a function declaration followed by a
1599 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
1600 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
1601 /* Don't warn about extern decl followed by definition. */
1602 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
1603 /* Don't warn about friends, let add_friend take care of it. */
1604 && ! (newdecl_is_friend || DECL_FRIEND_P (olddecl)))
1606 warning (OPT_Wredundant_decls, "redundant redeclaration of %qD in same scope", newdecl);
1607 warning (OPT_Wredundant_decls, "previous declaration of %q+D", olddecl);
1611 /* Deal with C++: must preserve virtual function table size. */
1612 if (TREE_CODE (olddecl) == TYPE_DECL)
1614 tree newtype = TREE_TYPE (newdecl);
1615 tree oldtype = TREE_TYPE (olddecl);
1617 if (newtype != error_mark_node && oldtype != error_mark_node
1618 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
1619 CLASSTYPE_FRIEND_CLASSES (newtype)
1620 = CLASSTYPE_FRIEND_CLASSES (oldtype);
1622 DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
1625 /* Copy all the DECL_... slots specified in the new decl
1626 except for any that we copy here from the old type. */
1627 DECL_ATTRIBUTES (newdecl)
1628 = (*targetm.merge_decl_attributes) (olddecl, newdecl);
1630 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1634 old_result = DECL_TEMPLATE_RESULT (olddecl);
1635 new_result = DECL_TEMPLATE_RESULT (newdecl);
1636 TREE_TYPE (olddecl) = TREE_TYPE (old_result);
1637 DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
1638 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
1639 DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
1641 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1643 DECL_INLINE (old_result)
1644 |= DECL_INLINE (new_result);
1645 DECL_DECLARED_INLINE_P (old_result)
1646 |= DECL_DECLARED_INLINE_P (new_result);
1647 check_redeclaration_exception_specification (newdecl, olddecl);
1650 /* If the new declaration is a definition, update the file and
1651 line information on the declaration, and also make
1652 the old declaration the same definition. */
1653 if (DECL_INITIAL (old_result) == NULL_TREE
1654 && DECL_INITIAL (new_result) != NULL_TREE)
1656 DECL_SOURCE_LOCATION (olddecl)
1657 = DECL_SOURCE_LOCATION (old_result)
1658 = DECL_SOURCE_LOCATION (newdecl);
1659 DECL_INITIAL (old_result) = DECL_INITIAL (new_result);
1660 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1661 DECL_ARGUMENTS (old_result)
1662 = DECL_ARGUMENTS (new_result);
1670 /* Automatically handles default parameters. */
1671 tree oldtype = TREE_TYPE (olddecl);
1674 /* Merge the data types specified in the two decls. */
1675 newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
1677 /* If merge_types produces a non-typedef type, just use the old type. */
1678 if (TREE_CODE (newdecl) == TYPE_DECL
1679 && newtype == DECL_ORIGINAL_TYPE (newdecl))
1682 if (TREE_CODE (newdecl) == VAR_DECL)
1684 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
1685 DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
1686 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl)
1687 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl);
1688 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl)
1689 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl);
1691 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
1692 if (DECL_LANG_SPECIFIC (olddecl)
1693 && CP_DECL_THREADPRIVATE_P (olddecl))
1695 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
1696 if (!DECL_LANG_SPECIFIC (newdecl))
1697 retrofit_lang_decl (newdecl);
1699 DECL_TLS_MODEL (newdecl) = DECL_TLS_MODEL (olddecl);
1700 CP_DECL_THREADPRIVATE_P (newdecl) = 1;
1704 /* Do this after calling `merge_types' so that default
1705 parameters don't confuse us. */
1706 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1707 check_redeclaration_exception_specification (newdecl, olddecl);
1708 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
1710 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1711 check_default_args (newdecl);
1713 /* Lay the type out, unless already done. */
1714 if (! same_type_p (newtype, oldtype)
1715 && TREE_TYPE (newdecl) != error_mark_node
1716 && !(processing_template_decl && uses_template_parms (newdecl)))
1717 layout_type (TREE_TYPE (newdecl));
1719 if ((TREE_CODE (newdecl) == VAR_DECL
1720 || TREE_CODE (newdecl) == PARM_DECL
1721 || TREE_CODE (newdecl) == RESULT_DECL
1722 || TREE_CODE (newdecl) == FIELD_DECL
1723 || TREE_CODE (newdecl) == TYPE_DECL)
1724 && !(processing_template_decl && uses_template_parms (newdecl)))
1725 layout_decl (newdecl, 0);
1727 /* Merge the type qualifiers. */
1728 if (TREE_READONLY (newdecl))
1729 TREE_READONLY (olddecl) = 1;
1730 if (TREE_THIS_VOLATILE (newdecl))
1731 TREE_THIS_VOLATILE (olddecl) = 1;
1732 if (TREE_NOTHROW (newdecl))
1733 TREE_NOTHROW (olddecl) = 1;
1735 /* Merge deprecatedness. */
1736 if (TREE_DEPRECATED (newdecl))
1737 TREE_DEPRECATED (olddecl) = 1;
1739 /* Merge the initialization information. */
1740 if (DECL_INITIAL (newdecl) == NULL_TREE
1741 && DECL_INITIAL (olddecl) != NULL_TREE)
1743 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
1744 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
1745 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
1746 && DECL_LANG_SPECIFIC (newdecl)
1747 && DECL_LANG_SPECIFIC (olddecl))
1749 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1750 DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
1754 /* Merge the section attribute.
1755 We want to issue an error if the sections conflict but that must be
1756 done later in decl_attributes since we are called before attributes
1758 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1759 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1761 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1763 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1764 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1765 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
1766 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1767 TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
1768 TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl);
1769 DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
1770 DECL_IS_PURE (newdecl) |= DECL_IS_PURE (olddecl);
1771 /* Keep the old RTL. */
1772 COPY_DECL_RTL (olddecl, newdecl);
1774 else if (TREE_CODE (newdecl) == VAR_DECL
1775 && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
1777 /* Keep the old RTL. We cannot keep the old RTL if the old
1778 declaration was for an incomplete object and the new
1779 declaration is not since many attributes of the RTL will
1781 COPY_DECL_RTL (olddecl, newdecl);
1784 /* If cannot merge, then use the new type and qualifiers,
1785 and don't preserve the old rtl. */
1788 /* Clean out any memory we had of the old declaration. */
1789 tree oldstatic = value_member (olddecl, static_aggregates);
1791 TREE_VALUE (oldstatic) = error_mark_node;
1793 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1794 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1795 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1796 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1799 /* Merge the storage class information. */
1800 merge_weak (newdecl, olddecl);
1802 DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
1803 DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
1804 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1805 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
1806 if (! DECL_EXTERNAL (olddecl))
1807 DECL_EXTERNAL (newdecl) = 0;
1809 new_template = NULL_TREE;
1810 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
1812 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
1813 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
1814 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
1815 DECL_TEMPLATE_INSTANTIATED (newdecl)
1816 |= DECL_TEMPLATE_INSTANTIATED (olddecl);
1818 /* If the OLDDECL is an instantiation and/or specialization,
1819 then the NEWDECL must be too. But, it may not yet be marked
1820 as such if the caller has created NEWDECL, but has not yet
1821 figured out that it is a redeclaration. */
1822 if (!DECL_USE_TEMPLATE (newdecl))
1823 DECL_USE_TEMPLATE (newdecl) = DECL_USE_TEMPLATE (olddecl);
1825 /* Don't really know how much of the language-specific
1826 values we should copy from old to new. */
1827 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
1828 DECL_LANG_SPECIFIC (newdecl)->decl_flags.u2 =
1829 DECL_LANG_SPECIFIC (olddecl)->decl_flags.u2;
1830 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
1831 DECL_REPO_AVAILABLE_P (newdecl) = DECL_REPO_AVAILABLE_P (olddecl);
1832 if (DECL_TEMPLATE_INFO (newdecl))
1833 new_template = DECL_TI_TEMPLATE (newdecl);
1834 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
1835 DECL_INITIALIZED_IN_CLASS_P (newdecl)
1836 |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
1837 olddecl_friend = DECL_FRIEND_P (olddecl);
1838 hidden_friend = (DECL_ANTICIPATED (olddecl)
1839 && DECL_HIDDEN_FRIEND_P (olddecl)
1840 && newdecl_is_friend);
1842 /* Only functions have DECL_BEFRIENDING_CLASSES. */
1843 if (TREE_CODE (newdecl) == FUNCTION_DECL
1844 || DECL_FUNCTION_TEMPLATE_P (newdecl))
1846 DECL_BEFRIENDING_CLASSES (newdecl)
1847 = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
1848 DECL_BEFRIENDING_CLASSES (olddecl));
1849 /* DECL_THUNKS is only valid for virtual functions,
1850 otherwise it is a DECL_FRIEND_CONTEXT. */
1851 if (DECL_VIRTUAL_P (newdecl))
1852 DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl);
1856 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1858 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
1859 && !DECL_TEMPLATE_INSTANTIATION (newdecl))
1861 /* If newdecl is not a specialization, then it is not a
1862 template-related function at all. And that means that we
1863 should have exited above, returning 0. */
1864 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl));
1866 if (TREE_USED (olddecl))
1867 /* From [temp.expl.spec]:
1869 If a template, a member template or the member of a class
1870 template is explicitly specialized then that
1871 specialization shall be declared before the first use of
1872 that specialization that would cause an implicit
1873 instantiation to take place, in every translation unit in
1874 which such a use occurs. */
1875 error ("explicit specialization of %qD after first use",
1878 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
1880 /* Don't propagate visibility from the template to the
1881 specialization here. We'll do that in determine_visibility if
1883 DECL_VISIBILITY_SPECIFIED (olddecl) = 0;
1885 /* [temp.expl.spec/14] We don't inline explicit specialization
1886 just because the primary template says so. */
1890 if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
1891 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
1893 DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
1895 /* If either decl says `inline', this fn is inline, unless
1896 its definition was passed already. */
1897 if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
1898 DECL_INLINE (olddecl) = 1;
1899 DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
1901 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
1902 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
1905 /* Preserve abstractness on cloned [cd]tors. */
1906 DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
1910 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1911 COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
1912 COPY_DECL_RTL (newdecl, olddecl);
1914 if (! types_match || new_defines_function)
1916 /* These need to be copied so that the names are available.
1917 Note that if the types do match, we'll preserve inline
1918 info and other bits, but if not, we won't. */
1919 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
1920 DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
1922 if (new_defines_function)
1923 /* If defining a function declared with other language
1924 linkage, use the previously declared language linkage. */
1925 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1926 else if (types_match)
1928 /* If redeclaring a builtin function, and not a definition,
1929 it stays built in. */
1930 if (DECL_BUILT_IN (olddecl))
1932 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
1933 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
1934 /* If we're keeping the built-in definition, keep the rtl,
1935 regardless of declaration matches. */
1936 COPY_DECL_RTL (olddecl, newdecl);
1939 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
1940 /* Don't clear out the arguments if we're redefining a function. */
1941 if (DECL_ARGUMENTS (olddecl))
1942 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
1945 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1946 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
1948 /* Now preserve various other info from the definition. */
1949 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
1950 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
1951 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
1952 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
1954 /* Warn about conflicting visibility specifications. */
1955 if (DECL_VISIBILITY_SPECIFIED (olddecl)
1956 && DECL_VISIBILITY_SPECIFIED (newdecl)
1957 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
1959 warning (OPT_Wattributes, "%q+D: visibility attribute ignored "
1960 "because it", newdecl);
1961 warning (OPT_Wattributes, "%Jconflicts with previous "
1962 "declaration here", olddecl);
1964 /* Choose the declaration which specified visibility. */
1965 if (DECL_VISIBILITY_SPECIFIED (olddecl))
1967 DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
1968 DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
1970 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
1971 so keep this behavior. */
1972 if (TREE_CODE (newdecl) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (newdecl))
1974 SET_DECL_INIT_PRIORITY (olddecl, DECL_INIT_PRIORITY (newdecl));
1975 DECL_HAS_INIT_PRIORITY_P (olddecl) = 1;
1978 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
1979 with that from NEWDECL below. */
1980 if (DECL_LANG_SPECIFIC (olddecl))
1982 gcc_assert (DECL_LANG_SPECIFIC (olddecl)
1983 != DECL_LANG_SPECIFIC (newdecl));
1984 ggc_free (DECL_LANG_SPECIFIC (olddecl));
1987 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1991 function_size = sizeof (struct tree_decl_common);
1993 memcpy ((char *) olddecl + sizeof (struct tree_common),
1994 (char *) newdecl + sizeof (struct tree_common),
1995 function_size - sizeof (struct tree_common));
1997 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
1998 (char *) newdecl + sizeof (struct tree_decl_common),
1999 sizeof (struct tree_function_decl) - sizeof (struct tree_decl_common));
2001 /* If newdecl is a template instantiation, it is possible that
2002 the following sequence of events has occurred:
2004 o A friend function was declared in a class template. The
2005 class template was instantiated.
2007 o The instantiation of the friend declaration was
2008 recorded on the instantiation list, and is newdecl.
2010 o Later, however, instantiate_class_template called pushdecl
2011 on the newdecl to perform name injection. But, pushdecl in
2012 turn called duplicate_decls when it discovered that another
2013 declaration of a global function with the same name already
2016 o Here, in duplicate_decls, we decided to clobber newdecl.
2018 If we're going to do that, we'd better make sure that
2019 olddecl, and not newdecl, is on the list of
2020 instantiations so that if we try to do the instantiation
2021 again we won't get the clobbered declaration. */
2022 reregister_specialization (newdecl,
2028 size_t size = tree_code_size (TREE_CODE (olddecl));
2029 memcpy ((char *) olddecl + sizeof (struct tree_common),
2030 (char *) newdecl + sizeof (struct tree_common),
2031 sizeof (struct tree_decl_common) - sizeof (struct tree_common));
2032 switch (TREE_CODE (olddecl))
2042 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2043 (char *) newdecl + sizeof (struct tree_decl_common),
2044 size - sizeof (struct tree_decl_common)
2045 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2049 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2050 (char *) newdecl + sizeof (struct tree_decl_common),
2051 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common)
2052 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2056 DECL_UID (olddecl) = olddecl_uid;
2058 DECL_FRIEND_P (olddecl) = 1;
2061 DECL_ANTICIPATED (olddecl) = 1;
2062 DECL_HIDDEN_FRIEND_P (olddecl) = 1;
2065 /* NEWDECL contains the merged attribute lists.
2066 Update OLDDECL to be the same. */
2067 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
2069 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2070 so that encode_section_info has a chance to look at the new decl
2071 flags and attributes. */
2072 if (DECL_RTL_SET_P (olddecl)
2073 && (TREE_CODE (olddecl) == FUNCTION_DECL
2074 || (TREE_CODE (olddecl) == VAR_DECL
2075 && TREE_STATIC (olddecl))))
2076 make_decl_rtl (olddecl);
2078 /* The NEWDECL will no longer be needed. Because every out-of-class
2079 declaration of a member results in a call to duplicate_decls,
2080 freeing these nodes represents in a significant savings. */
2086 /* Return zero if the declaration NEWDECL is valid
2087 when the declaration OLDDECL (assumed to be for the same name)
2088 has already been seen.
2089 Otherwise return an error message format string with a %s
2090 where the identifier should go. */
2093 redeclaration_error_message (tree newdecl, tree olddecl)
2095 if (TREE_CODE (newdecl) == TYPE_DECL)
2097 /* Because C++ can put things into name space for free,
2098 constructs like "typedef struct foo { ... } foo"
2099 would look like an erroneous redeclaration. */
2100 if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
2103 return "redefinition of %q#D";
2105 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
2107 /* If this is a pure function, its olddecl will actually be
2108 the original initialization to `0' (which we force to call
2109 abort()). Don't complain about redefinition in this case. */
2110 if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl)
2111 && DECL_INITIAL (olddecl) == NULL_TREE)
2114 /* If both functions come from different namespaces, this is not
2115 a redeclaration - this is a conflict with a used function. */
2116 if (DECL_NAMESPACE_SCOPE_P (olddecl)
2117 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl)
2118 && ! decls_match (olddecl, newdecl))
2119 return "%qD conflicts with used function";
2121 /* We'll complain about linkage mismatches in
2122 warn_extern_redeclared_static. */
2124 /* Defining the same name twice is no good. */
2125 if (DECL_INITIAL (olddecl) != NULL_TREE
2126 && DECL_INITIAL (newdecl) != NULL_TREE)
2128 if (DECL_NAME (olddecl) == NULL_TREE)
2129 return "%q#D not declared in class";
2131 return "redefinition of %q#D";
2135 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2139 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2141 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl))
2142 && COMPLETE_TYPE_P (TREE_TYPE (olddecl)))
2143 return "redefinition of %q#D";
2147 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL
2148 || (DECL_TEMPLATE_RESULT (newdecl)
2149 == DECL_TEMPLATE_RESULT (olddecl)))
2152 nt = DECL_TEMPLATE_RESULT (newdecl);
2153 if (DECL_TEMPLATE_INFO (nt))
2154 nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt));
2155 ot = DECL_TEMPLATE_RESULT (olddecl);
2156 if (DECL_TEMPLATE_INFO (ot))
2157 ot = DECL_TEMPLATE_RESULT (template_for_substitution (ot));
2158 if (DECL_INITIAL (nt) && DECL_INITIAL (ot))
2159 return "redefinition of %q#D";
2163 else if (TREE_CODE (newdecl) == VAR_DECL
2164 && DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl)
2165 && (! DECL_LANG_SPECIFIC (olddecl)
2166 || ! CP_DECL_THREADPRIVATE_P (olddecl)
2167 || DECL_THREAD_LOCAL_P (newdecl)))
2169 /* Only variables can be thread-local, and all declarations must
2170 agree on this property. */
2171 if (DECL_THREAD_LOCAL_P (newdecl))
2172 return "thread-local declaration of %q#D follows "
2173 "non-thread-local declaration";
2175 return "non-thread-local declaration of %q#D follows "
2176 "thread-local declaration";
2178 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
2180 /* The objects have been declared at namespace scope. If either
2181 is a member of an anonymous union, then this is an invalid
2182 redeclaration. For example:
2188 if (DECL_ANON_UNION_VAR_P (newdecl)
2189 || DECL_ANON_UNION_VAR_P (olddecl))
2190 return "redeclaration of %q#D";
2191 /* If at least one declaration is a reference, there is no
2192 conflict. For example:
2198 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2200 /* Reject two definitions. */
2201 return "redefinition of %q#D";
2205 /* Objects declared with block scope: */
2206 /* Reject two definitions, and reject a definition
2207 together with an external reference. */
2208 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
2209 return "redeclaration of %q#D";
2214 /* Hash and equality functions for the named_label table. */
2217 named_label_entry_hash (const void *data)
2219 const struct named_label_entry *ent = (const struct named_label_entry *) data;
2220 return DECL_UID (ent->label_decl);
2224 named_label_entry_eq (const void *a, const void *b)
2226 const struct named_label_entry *ent_a = (const struct named_label_entry *) a;
2227 const struct named_label_entry *ent_b = (const struct named_label_entry *) b;
2228 return ent_a->label_decl == ent_b->label_decl;
2231 /* Create a new label, named ID. */
2234 make_label_decl (tree id, int local_p)
2236 struct named_label_entry *ent;
2240 decl = build_decl (LABEL_DECL, id, void_type_node);
2242 DECL_CONTEXT (decl) = current_function_decl;
2243 DECL_MODE (decl) = VOIDmode;
2244 C_DECLARED_LABEL_FLAG (decl) = local_p;
2246 /* Say where one reference is to the label, for the sake of the
2247 error if it is not defined. */
2248 DECL_SOURCE_LOCATION (decl) = input_location;
2250 /* Record the fact that this identifier is bound to this label. */
2251 SET_IDENTIFIER_LABEL_VALUE (id, decl);
2253 /* Create the label htab for the function on demand. */
2255 named_labels = htab_create_ggc (13, named_label_entry_hash,
2256 named_label_entry_eq, NULL);
2258 /* Record this label on the list of labels used in this function.
2259 We do this before calling make_label_decl so that we get the
2260 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2261 ent = GGC_CNEW (struct named_label_entry);
2262 ent->label_decl = decl;
2264 slot = htab_find_slot (named_labels, ent, INSERT);
2265 gcc_assert (*slot == NULL);
2271 /* Look for a label named ID in the current function. If one cannot
2272 be found, create one. (We keep track of used, but undefined,
2273 labels, and complain about them at the end of a function.) */
2276 lookup_label (tree id)
2280 timevar_push (TV_NAME_LOOKUP);
2281 /* You can't use labels at global scope. */
2282 if (current_function_decl == NULL_TREE)
2284 error ("label %qE referenced outside of any function", id);
2285 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
2288 /* See if we've already got this label. */
2289 decl = IDENTIFIER_LABEL_VALUE (id);
2290 if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
2291 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2293 decl = make_label_decl (id, /*local_p=*/0);
2294 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2297 /* Declare a local label named ID. */
2300 declare_local_label (tree id)
2304 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2305 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2306 shadow = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
2307 current_binding_level->shadowed_labels);
2308 current_binding_level->shadowed_labels = shadow;
2310 decl = make_label_decl (id, /*local_p=*/1);
2311 TREE_VALUE (shadow) = decl;
2316 /* Returns nonzero if it is ill-formed to jump past the declaration of
2317 DECL. Returns 2 if it's also a real problem. */
2320 decl_jump_unsafe (tree decl)
2322 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl)
2323 || TREE_TYPE (decl) == error_mark_node)
2326 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
2327 || DECL_NONTRIVIALLY_INITIALIZED_P (decl))
2330 if (pod_type_p (TREE_TYPE (decl)))
2333 /* The POD stuff is just pedantry; why should it matter if the class
2334 contains a field of pointer to member type? */
2338 /* A subroutine of check_previous_goto_1 to identify a branch to the user. */
2341 identify_goto (tree decl, const location_t *locus)
2344 pedwarn ("jump to label %qD", decl);
2346 pedwarn ("jump to case label");
2348 pedwarn ("%H from here", locus);
2351 /* Check that a single previously seen jump to a newly defined label
2352 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2353 the jump context; NAMES are the names in scope in LEVEL at the jump
2354 context; LOCUS is the source position of the jump or 0. Returns
2355 true if all is well. */
2358 check_previous_goto_1 (tree decl, struct cp_binding_level* level, tree names,
2359 bool exited_omp, const location_t *locus)
2361 struct cp_binding_level *b;
2362 bool identified = false, saw_eh = false, saw_omp = false;
2366 identify_goto (decl, locus);
2367 error (" exits OpenMP structured block");
2368 identified = saw_omp = true;
2371 for (b = current_binding_level; b ; b = b->level_chain)
2373 tree new_decls, old_decls = (b == level ? names : NULL_TREE);
2375 for (new_decls = b->names; new_decls != old_decls;
2376 new_decls = TREE_CHAIN (new_decls))
2378 int problem = decl_jump_unsafe (new_decls);
2384 identify_goto (decl, locus);
2388 error (" crosses initialization of %q+#D", new_decls);
2390 pedwarn (" enters scope of non-POD %q+#D", new_decls);
2395 if ((b->kind == sk_try || b->kind == sk_catch) && !saw_eh)
2399 identify_goto (decl, locus);
2402 if (b->kind == sk_try)
2403 error (" enters try block");
2405 error (" enters catch block");
2408 if (b->kind == sk_omp && !saw_omp)
2412 identify_goto (decl, locus);
2415 error (" enters OpenMP structured block");
2424 check_previous_goto (tree decl, struct named_label_use_entry *use)
2426 check_previous_goto_1 (decl, use->binding_level,
2427 use->names_in_scope, use->in_omp_scope,
2428 &use->o_goto_locus);
2432 check_switch_goto (struct cp_binding_level* level)
2434 return check_previous_goto_1 (NULL_TREE, level, level->names, false, NULL);
2437 /* Check that a new jump to a label DECL is OK. Called by
2438 finish_goto_stmt. */
2441 check_goto (tree decl)
2443 struct named_label_entry *ent, dummy;
2444 bool saw_catch = false, identified = false;
2447 /* We can't know where a computed goto is jumping.
2448 So we assume that it's OK. */
2449 if (TREE_CODE (decl) != LABEL_DECL)
2452 /* We didn't record any information about this label when we created it,
2453 and there's not much point since it's trivial to analyze as a return. */
2454 if (decl == cdtor_label)
2457 dummy.label_decl = decl;
2458 ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2459 gcc_assert (ent != NULL);
2461 /* If the label hasn't been defined yet, defer checking. */
2462 if (! DECL_INITIAL (decl))
2464 struct named_label_use_entry *new_use;
2466 /* Don't bother creating another use if the last goto had the
2467 same data, and will therefore create the same set of errors. */
2469 && ent->uses->names_in_scope == current_binding_level->names)
2472 new_use = GGC_NEW (struct named_label_use_entry);
2473 new_use->binding_level = current_binding_level;
2474 new_use->names_in_scope = current_binding_level->names;
2475 new_use->o_goto_locus = input_location;
2476 new_use->in_omp_scope = false;
2478 new_use->next = ent->uses;
2479 ent->uses = new_use;
2483 if (ent->in_try_scope || ent->in_catch_scope
2484 || ent->in_omp_scope || ent->bad_decls)
2486 pedwarn ("jump to label %q+D", decl);
2487 pedwarn (" from here");
2491 for (bad = ent->bad_decls; bad; bad = TREE_CHAIN (bad))
2493 tree b = TREE_VALUE (bad);
2494 int u = decl_jump_unsafe (b);
2496 if (u > 1 && DECL_ARTIFICIAL (b))
2498 /* Can't skip init of __exception_info. */
2499 error ("%J enters catch block", b);
2503 error (" skips initialization of %q+#D", b);
2505 pedwarn (" enters scope of non-POD %q+#D", b);
2508 if (ent->in_try_scope)
2509 error (" enters try block");
2510 else if (ent->in_catch_scope && !saw_catch)
2511 error (" enters catch block");
2513 if (ent->in_omp_scope)
2514 error (" enters OpenMP structured block");
2515 else if (flag_openmp)
2517 struct cp_binding_level *b;
2518 for (b = current_binding_level; b ; b = b->level_chain)
2520 if (b == ent->binding_level)
2522 if (b->kind == sk_omp)
2526 pedwarn ("jump to label %q+D", decl);
2527 pedwarn (" from here");
2530 error (" exits OpenMP structured block");
2537 /* Check that a return is ok wrt OpenMP structured blocks.
2538 Called by finish_return_stmt. Returns true if all is well. */
2541 check_omp_return (void)
2543 struct cp_binding_level *b;
2544 for (b = current_binding_level; b ; b = b->level_chain)
2545 if (b->kind == sk_omp)
2547 error ("invalid exit from OpenMP structured block");
2553 /* Define a label, specifying the location in the source file.
2554 Return the LABEL_DECL node for the label. */
2557 define_label (location_t location, tree name)
2559 struct named_label_entry *ent, dummy;
2560 struct cp_binding_level *p;
2563 timevar_push (TV_NAME_LOOKUP);
2565 decl = lookup_label (name);
2567 dummy.label_decl = decl;
2568 ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2569 gcc_assert (ent != NULL);
2571 /* After labels, make any new cleanups in the function go into their
2572 own new (temporary) binding contour. */
2573 for (p = current_binding_level;
2574 p->kind != sk_function_parms;
2576 p->more_cleanups_ok = 0;
2578 if (name == get_identifier ("wchar_t"))
2579 pedwarn ("label named wchar_t");
2581 if (DECL_INITIAL (decl) != NULL_TREE)
2583 error ("duplicate label %qD", decl);
2584 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
2588 struct named_label_use_entry *use;
2590 /* Mark label as having been defined. */
2591 DECL_INITIAL (decl) = error_mark_node;
2592 /* Say where in the source. */
2593 DECL_SOURCE_LOCATION (decl) = location;
2595 ent->binding_level = current_binding_level;
2596 ent->names_in_scope = current_binding_level->names;
2598 for (use = ent->uses; use ; use = use->next)
2599 check_previous_goto (decl, use);
2603 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2608 struct cp_binding_level *level;
2609 struct cp_switch *next;
2610 /* The SWITCH_STMT being built. */
2612 /* A splay-tree mapping the low element of a case range to the high
2613 element, or NULL_TREE if there is no high element. Used to
2614 determine whether or not a new case label duplicates an old case
2615 label. We need a tree, rather than simply a hash table, because
2616 of the GNU case range extension. */
2620 /* A stack of the currently active switch statements. The innermost
2621 switch statement is on the top of the stack. There is no need to
2622 mark the stack for garbage collection because it is only active
2623 during the processing of the body of a function, and we never
2624 collect at that point. */
2626 static struct cp_switch *switch_stack;
2628 /* Called right after a switch-statement condition is parsed.
2629 SWITCH_STMT is the switch statement being parsed. */
2632 push_switch (tree switch_stmt)
2634 struct cp_switch *p = XNEW (struct cp_switch);
2635 p->level = current_binding_level;
2636 p->next = switch_stack;
2637 p->switch_stmt = switch_stmt;
2638 p->cases = splay_tree_new (case_compare, NULL, NULL);
2645 struct cp_switch *cs = switch_stack;
2646 location_t switch_location;
2648 /* Emit warnings as needed. */
2649 if (EXPR_HAS_LOCATION (cs->switch_stmt))
2650 switch_location = EXPR_LOCATION (cs->switch_stmt);
2652 switch_location = input_location;
2653 if (!processing_template_decl)
2654 c_do_switch_warnings (cs->cases, switch_location,
2655 SWITCH_STMT_TYPE (cs->switch_stmt),
2656 SWITCH_STMT_COND (cs->switch_stmt));
2658 splay_tree_delete (cs->cases);
2659 switch_stack = switch_stack->next;
2663 /* Note that we've seen a definition of a case label, and complain if this
2664 is a bad place for one. */
2667 finish_case_label (tree low_value, tree high_value)
2670 struct cp_binding_level *p;
2672 if (processing_template_decl)
2676 /* For templates, just add the case label; we'll do semantic
2677 analysis at instantiation-time. */
2678 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
2679 return add_stmt (build_case_label (low_value, high_value, label));
2682 /* Find the condition on which this switch statement depends. */
2683 cond = SWITCH_STMT_COND (switch_stack->switch_stmt);
2684 if (cond && TREE_CODE (cond) == TREE_LIST)
2685 cond = TREE_VALUE (cond);
2687 if (!check_switch_goto (switch_stack->level))
2688 return error_mark_node;
2690 r = c_add_case_label (switch_stack->cases, cond, TREE_TYPE (cond),
2691 low_value, high_value);
2693 /* After labels, make any new cleanups in the function go into their
2694 own new (temporary) binding contour. */
2695 for (p = current_binding_level;
2696 p->kind != sk_function_parms;
2698 p->more_cleanups_ok = 0;
2703 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
2706 typename_hash (const void* k)
2711 hash = (htab_hash_pointer (TYPE_CONTEXT (t))
2712 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));
2717 typedef struct typename_info {
2725 /* Compare two TYPENAME_TYPEs. K1 and K2 are really of type `tree'. */
2728 typename_compare (const void * k1, const void * k2)
2731 const typename_info *t2;
2734 t2 = (const typename_info *) k2;
2736 return (DECL_NAME (TYPE_NAME (t1)) == t2->name
2737 && TYPE_CONTEXT (t1) == t2->scope
2738 && TYPENAME_TYPE_FULLNAME (t1) == t2->template_id
2739 && TYPENAME_IS_ENUM_P (t1) == t2->enum_p
2740 && TYPENAME_IS_CLASS_P (t1) == t2->class_p);
2743 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
2744 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
2746 Returns the new TYPENAME_TYPE. */
2748 static GTY ((param_is (union tree_node))) htab_t typename_htab;
2751 build_typename_type (tree context, tree name, tree fullname,
2752 enum tag_types tag_type)
2760 if (typename_htab == NULL)
2761 typename_htab = htab_create_ggc (61, &typename_hash,
2762 &typename_compare, NULL);
2764 ti.scope = FROB_CONTEXT (context);
2766 ti.template_id = fullname;
2767 ti.enum_p = tag_type == enum_type;
2768 ti.class_p = (tag_type == class_type
2769 || tag_type == record_type
2770 || tag_type == union_type);
2771 hash = (htab_hash_pointer (ti.scope)
2772 ^ htab_hash_pointer (ti.name));
2774 /* See if we already have this type. */
2775 e = htab_find_slot_with_hash (typename_htab, &ti, hash, INSERT);
2780 /* Build the TYPENAME_TYPE. */
2781 t = make_aggr_type (TYPENAME_TYPE);
2782 TYPE_CONTEXT (t) = ti.scope;
2783 TYPENAME_TYPE_FULLNAME (t) = ti.template_id;
2784 TYPENAME_IS_ENUM_P (t) = ti.enum_p;
2785 TYPENAME_IS_CLASS_P (t) = ti.class_p;
2787 /* Build the corresponding TYPE_DECL. */
2788 d = build_decl (TYPE_DECL, name, t);
2789 TYPE_NAME (TREE_TYPE (d)) = d;
2790 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2791 DECL_CONTEXT (d) = FROB_CONTEXT (context);
2792 DECL_ARTIFICIAL (d) = 1;
2794 /* Store it in the hash table. */
2801 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
2802 provided to name the type. Returns an appropriate type, unless an
2803 error occurs, in which case error_mark_node is returned. If we
2804 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
2805 return that, rather than the _TYPE it corresponds to, in other
2806 cases we look through the type decl. If TF_ERROR is set, complain
2807 about errors, otherwise be quiet. */
2810 make_typename_type (tree context, tree name, enum tag_types tag_type,
2811 tsubst_flags_t complain)
2817 if (name == error_mark_node
2818 || context == NULL_TREE
2819 || context == error_mark_node)
2820 return error_mark_node;
2824 if (!(TYPE_LANG_SPECIFIC (name)
2825 && (CLASSTYPE_IS_TEMPLATE (name)
2826 || CLASSTYPE_USE_TEMPLATE (name))))
2827 name = TYPE_IDENTIFIER (name);
2829 /* Create a TEMPLATE_ID_EXPR for the type. */
2830 name = build_nt (TEMPLATE_ID_EXPR,
2831 CLASSTYPE_TI_TEMPLATE (name),
2832 CLASSTYPE_TI_ARGS (name));
2834 else if (TREE_CODE (name) == TYPE_DECL)
2835 name = DECL_NAME (name);
2839 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
2841 name = TREE_OPERAND (name, 0);
2842 if (TREE_CODE (name) == TEMPLATE_DECL)
2843 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
2844 else if (TREE_CODE (name) == OVERLOAD)
2846 error ("%qD is not a type", name);
2847 return error_mark_node;
2850 if (TREE_CODE (name) == TEMPLATE_DECL)
2852 error ("%qD used without template parameters", name);
2853 return error_mark_node;
2855 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
2856 gcc_assert (TYPE_P (context));
2858 /* When the CONTEXT is a dependent type, NAME could refer to a
2859 dependent base class of CONTEXT. So we cannot peek inside it,
2860 even if CONTEXT is a currently open scope. */
2861 if (dependent_type_p (context))
2862 return build_typename_type (context, name, fullname, tag_type);
2864 if (!IS_AGGR_TYPE (context))
2866 if (complain & tf_error)
2867 error ("%q#T is not a class", context);
2868 return error_mark_node;
2871 want_template = TREE_CODE (fullname) == TEMPLATE_ID_EXPR;
2873 /* We should only set WANT_TYPE when we're a nested typename type.
2874 Then we can give better diagnostics if we find a non-type. */
2875 t = lookup_field (context, name, 0, /*want_type=*/true);
2878 if (complain & tf_error)
2879 error (want_template ? "no class template named %q#T in %q#T"
2880 : "no type named %q#T in %q#T", name, context);
2881 return error_mark_node;
2884 if (want_template && !DECL_CLASS_TEMPLATE_P (t))
2886 if (complain & tf_error)
2887 error ("%<typename %T::%D%> names %q#T, which is not a class template",
2889 return error_mark_node;
2891 if (!want_template && TREE_CODE (t) != TYPE_DECL)
2893 if (complain & tf_error)
2894 error ("%<typename %T::%D%> names %q#T, which is not a type",
2896 return error_mark_node;
2899 if (complain & tf_error)
2900 perform_or_defer_access_check (TYPE_BINFO (context), t, t);
2903 return lookup_template_class (t, TREE_OPERAND (fullname, 1),
2905 /*entering_scope=*/0,
2906 tf_warning_or_error | tf_user);
2908 if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
2914 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
2915 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
2916 in which case error_mark_node is returned.
2918 If PARM_LIST is non-NULL, also make sure that the template parameter
2919 list of TEMPLATE_DECL matches.
2921 If COMPLAIN zero, don't complain about any errors that occur. */
2924 make_unbound_class_template (tree context, tree name, tree parm_list,
2925 tsubst_flags_t complain)
2931 name = TYPE_IDENTIFIER (name);
2932 else if (DECL_P (name))
2933 name = DECL_NAME (name);
2934 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
2936 if (!dependent_type_p (context)
2937 || currently_open_class (context))
2939 tree tmpl = NULL_TREE;
2941 if (IS_AGGR_TYPE (context))
2942 tmpl = lookup_field (context, name, 0, false);
2944 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
2946 if (complain & tf_error)
2947 error ("no class template named %q#T in %q#T", name, context);
2948 return error_mark_node;
2952 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl), parm_list))
2954 if (complain & tf_error)
2956 error ("template parameters do not match template");
2957 error ("%q+D declared here", tmpl);
2959 return error_mark_node;
2962 if (complain & tf_error)
2963 perform_or_defer_access_check (TYPE_BINFO (context), tmpl, tmpl);
2968 /* Build the UNBOUND_CLASS_TEMPLATE. */
2969 t = make_aggr_type (UNBOUND_CLASS_TEMPLATE);
2970 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
2971 TREE_TYPE (t) = NULL_TREE;
2973 /* Build the corresponding TEMPLATE_DECL. */
2974 d = build_decl (TEMPLATE_DECL, name, t);
2975 TYPE_NAME (TREE_TYPE (d)) = d;
2976 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2977 DECL_CONTEXT (d) = FROB_CONTEXT (context);
2978 DECL_ARTIFICIAL (d) = 1;
2979 DECL_TEMPLATE_PARMS (d) = parm_list;
2986 /* Push the declarations of builtin types into the namespace.
2987 RID_INDEX is the index of the builtin type in the array
2988 RID_POINTERS. NAME is the name used when looking up the builtin
2989 type. TYPE is the _TYPE node for the builtin type. */
2992 record_builtin_type (enum rid rid_index,
2996 tree rname = NULL_TREE, tname = NULL_TREE;
2997 tree tdecl = NULL_TREE;
2999 if ((int) rid_index < (int) RID_MAX)
3000 rname = ridpointers[(int) rid_index];
3002 tname = get_identifier (name);
3004 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
3005 eliminated. Built-in types should not be looked up name; their
3006 names are keywords that the parser can recognize. However, there
3007 is code in c-common.c that uses identifier_global_value to look
3008 up built-in types by name. */
3011 tdecl = build_decl (TYPE_DECL, tname, type);
3012 DECL_ARTIFICIAL (tdecl) = 1;
3013 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
3019 tdecl = build_decl (TYPE_DECL, rname, type);
3020 DECL_ARTIFICIAL (tdecl) = 1;
3022 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
3025 if (!TYPE_NAME (type))
3026 TYPE_NAME (type) = tdecl;
3029 debug_hooks->type_decl (tdecl, 0);
3032 /* Record one of the standard Java types.
3033 * Declare it as having the given NAME.
3034 * If SIZE > 0, it is the size of one of the integral types;
3035 * otherwise it is the negative of the size of one of the other types. */
3038 record_builtin_java_type (const char* name, int size)
3042 type = make_signed_type (size);
3043 else if (size > -32)
3044 { /* "__java_char" or ""__java_boolean". */
3045 type = make_unsigned_type (-size);
3046 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
3049 { /* "__java_float" or ""__java_double". */
3050 type = make_node (REAL_TYPE);
3051 TYPE_PRECISION (type) = - size;
3054 record_builtin_type (RID_MAX, name, type);
3055 decl = TYPE_NAME (type);
3057 /* Suppress generate debug symbol entries for these types,
3058 since for normal C++ they are just clutter.
3059 However, push_lang_context undoes this if extern "Java" is seen. */
3060 DECL_IGNORED_P (decl) = 1;
3062 TYPE_FOR_JAVA (type) = 1;
3066 /* Push a type into the namespace so that the back-ends ignore it. */
3069 record_unknown_type (tree type, const char* name)
3071 tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
3072 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3073 DECL_IGNORED_P (decl) = 1;
3074 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
3075 TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
3076 TYPE_ALIGN (type) = 1;
3077 TYPE_USER_ALIGN (type) = 0;
3078 TYPE_MODE (type) = TYPE_MODE (void_type_node);
3081 /* A string for which we should create an IDENTIFIER_NODE at
3084 typedef struct predefined_identifier
3086 /* The name of the identifier. */
3087 const char *const name;
3088 /* The place where the IDENTIFIER_NODE should be stored. */
3090 /* Nonzero if this is the name of a constructor or destructor. */
3091 const int ctor_or_dtor_p;
3092 } predefined_identifier;
3094 /* Create all the predefined identifiers. */
3097 initialize_predefined_identifiers (void)
3099 const predefined_identifier *pid;
3101 /* A table of identifiers to create at startup. */
3102 static const predefined_identifier predefined_identifiers[] = {
3103 { "C++", &lang_name_cplusplus, 0 },
3104 { "C", &lang_name_c, 0 },
3105 { "Java", &lang_name_java, 0 },
3106 /* Some of these names have a trailing space so that it is
3107 impossible for them to conflict with names written by users. */
3108 { "__ct ", &ctor_identifier, 1 },
3109 { "__base_ctor ", &base_ctor_identifier, 1 },
3110 { "__comp_ctor ", &complete_ctor_identifier, 1 },
3111 { "__dt ", &dtor_identifier, 1 },
3112 { "__comp_dtor ", &complete_dtor_identifier, 1 },
3113 { "__base_dtor ", &base_dtor_identifier, 1 },
3114 { "__deleting_dtor ", &deleting_dtor_identifier, 1 },
3115 { IN_CHARGE_NAME, &in_charge_identifier, 0 },
3116 { "nelts", &nelts_identifier, 0 },
3117 { THIS_NAME, &this_identifier, 0 },
3118 { VTABLE_DELTA_NAME, &delta_identifier, 0 },
3119 { VTABLE_PFN_NAME, &pfn_identifier, 0 },
3120 { "_vptr", &vptr_identifier, 0 },
3121 { "__vtt_parm", &vtt_parm_identifier, 0 },
3122 { "::", &global_scope_name, 0 },
3123 { "std", &std_identifier, 0 },
3127 for (pid = predefined_identifiers; pid->name; ++pid)
3129 *pid->node = get_identifier (pid->name);
3130 if (pid->ctor_or_dtor_p)
3131 IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
3135 /* Create the predefined scalar types of C,
3136 and some nodes representing standard constants (0, 1, (void *)0).
3137 Initialize the global binding level.
3138 Make definitions for built-in primitive functions. */
3141 cxx_init_decl_processing (void)
3144 tree void_ftype_ptr;
3146 build_common_tree_nodes (flag_signed_char, false);
3148 /* Create all the identifiers we need. */
3149 initialize_predefined_identifiers ();
3151 /* Create the global variables. */
3152 push_to_top_level ();
3154 current_function_decl = NULL_TREE;
3155 current_binding_level = NULL;
3156 /* Enter the global namespace. */
3157 gcc_assert (global_namespace == NULL_TREE);
3158 global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name,
3160 TREE_PUBLIC (global_namespace) = 1;
3161 begin_scope (sk_namespace, global_namespace);
3163 current_lang_name = NULL_TREE;
3165 /* Adjust various flags based on command-line settings. */
3166 if (!flag_permissive)
3167 flag_pedantic_errors = 1;
3168 if (!flag_no_inline)
3170 flag_inline_trees = 1;
3173 if (flag_inline_functions)
3174 flag_inline_trees = 2;
3176 if (flag_visibility_ms_compat)
3177 default_visibility = VISIBILITY_HIDDEN;
3180 current_lang_name = lang_name_c;
3182 /* Create the `std' namespace. */
3183 push_namespace (std_identifier);
3184 std_node = current_namespace;
3187 c_common_nodes_and_builtins ();
3189 java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
3190 java_short_type_node = record_builtin_java_type ("__java_short", 16);
3191 java_int_type_node = record_builtin_java_type ("__java_int", 32);
3192 java_long_type_node = record_builtin_java_type ("__java_long", 64);
3193 java_float_type_node = record_builtin_java_type ("__java_float", -32);
3194 java_double_type_node = record_builtin_java_type ("__java_double", -64);
3195 java_char_type_node = record_builtin_java_type ("__java_char", -16);
3196 java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
3198 integer_two_node = build_int_cst (NULL_TREE, 2);
3199 integer_three_node = build_int_cst (NULL_TREE, 3);
3201 record_builtin_type (RID_BOOL, "bool", boolean_type_node);
3202 truthvalue_type_node = boolean_type_node;
3203 truthvalue_false_node = boolean_false_node;
3204 truthvalue_true_node = boolean_true_node;
3206 empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
3209 record_builtin_type (RID_MAX, NULL, string_type_node);
3212 delta_type_node = ptrdiff_type_node;
3213 vtable_index_type = ptrdiff_type_node;
3215 vtt_parm_type = build_pointer_type (const_ptr_type_node);
3216 void_ftype = build_function_type (void_type_node, void_list_node);
3217 void_ftype_ptr = build_function_type (void_type_node,
3218 tree_cons (NULL_TREE,
3222 = build_exception_variant (void_ftype_ptr, empty_except_spec);
3224 /* C++ extensions */
3226 unknown_type_node = make_node (UNKNOWN_TYPE);
3227 record_unknown_type (unknown_type_node, "unknown type");
3229 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3230 TREE_TYPE (unknown_type_node) = unknown_type_node;
3232 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3234 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
3235 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
3238 /* Make sure we get a unique function type, so we can give
3239 its pointer type a name. (This wins for gdb.) */
3240 tree vfunc_type = make_node (FUNCTION_TYPE);
3241 TREE_TYPE (vfunc_type) = integer_type_node;
3242 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
3243 layout_type (vfunc_type);
3245 vtable_entry_type = build_pointer_type (vfunc_type);
3247 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
3250 = build_cplus_array_type (vtable_entry_type, NULL_TREE);
3251 layout_type (vtbl_type_node);
3252 vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
3253 record_builtin_type (RID_MAX, NULL, vtbl_type_node);
3254 vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
3255 layout_type (vtbl_ptr_type_node);
3256 record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
3258 push_namespace (get_identifier ("__cxxabiv1"));
3259 abi_node = current_namespace;
3262 global_type_node = make_node (LANG_TYPE);
3263 record_unknown_type (global_type_node, "global type");
3266 current_lang_name = lang_name_cplusplus;
3270 tree bad_alloc_type_node;
3271 tree bad_alloc_decl;
3272 tree newtype, deltype;
3273 tree ptr_ftype_sizetype;
3275 push_namespace (std_identifier);
3276 bad_alloc_id = get_identifier ("bad_alloc");
3277 bad_alloc_type_node = make_aggr_type (RECORD_TYPE);
3278 TYPE_CONTEXT (bad_alloc_type_node) = current_namespace;
3280 = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node);
3281 DECL_CONTEXT (bad_alloc_decl) = current_namespace;
3282 TYPE_STUB_DECL (bad_alloc_type_node) = bad_alloc_decl;
3286 = build_function_type (ptr_type_node,
3287 tree_cons (NULL_TREE,
3290 newtype = build_exception_variant
3291 (ptr_ftype_sizetype, add_exception_specifier
3292 (NULL_TREE, bad_alloc_type_node, -1));
3293 deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
3294 push_cp_library_fn (NEW_EXPR, newtype);
3295 push_cp_library_fn (VEC_NEW_EXPR, newtype);
3296 global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
3297 push_cp_library_fn (VEC_DELETE_EXPR, deltype);
3301 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
3303 /* Perform other language dependent initializations. */
3304 init_class_processing ();
3305 init_rtti_processing ();
3307 if (flag_exceptions)
3308 init_exception_processing ();
3310 if (! supports_one_only ())
3313 make_fname_decl = cp_make_fname_decl;
3314 start_fname_decls ();
3316 /* Show we use EH for cleanups. */
3317 if (flag_exceptions)
3318 using_eh_for_cleanups ();
3321 /* Generate an initializer for a function naming variable from
3322 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3323 filled in with the type of the init. */
3326 cp_fname_init (const char* name, tree *type_p)
3328 tree domain = NULL_TREE;
3330 tree init = NULL_TREE;
3335 length = strlen (name);
3336 domain = build_index_type (size_int (length));
3337 init = build_string (length + 1, name);
3340 type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
3341 type = build_cplus_array_type (type, domain);
3346 TREE_TYPE (init) = type;
3348 init = error_mark_node;
3353 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
3354 decl, NAME is the initialization string and TYPE_DEP indicates whether
3355 NAME depended on the type of the function. We make use of that to detect
3356 __PRETTY_FUNCTION__ inside a template fn. This is being done
3357 lazily at the point of first use, so we mustn't push the decl now. */
3360 cp_make_fname_decl (tree id, int type_dep)
3362 const char *const name = (type_dep && processing_template_decl
3363 ? NULL : fname_as_string (type_dep));
3365 tree init = cp_fname_init (name, &type);
3366 tree decl = build_decl (VAR_DECL, id, type);
3369 free ((char *) name);
3371 /* As we're using pushdecl_with_scope, we must set the context. */
3372 DECL_CONTEXT (decl) = current_function_decl;
3373 DECL_PRETTY_FUNCTION_P (decl) = type_dep;
3375 TREE_STATIC (decl) = 1;
3376 TREE_READONLY (decl) = 1;
3377 DECL_ARTIFICIAL (decl) = 1;
3379 TREE_USED (decl) = 1;
3381 if (current_function_decl)
3383 struct cp_binding_level *b = current_binding_level;
3384 while (b->level_chain->kind != sk_function_parms)
3386 pushdecl_with_scope (decl, b, /*is_friend=*/false);
3387 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE,
3388 LOOKUP_ONLYCONVERTING);
3391 pushdecl_top_level_and_finish (decl, init);
3396 /* Make a definition for a builtin function named NAME in the current
3397 namespace, whose data type is TYPE and whose context is CONTEXT.
3398 TYPE should be a function type with argument types.
3400 CLASS and CODE tell later passes how to compile calls to this function.
3401 See tree.h for possible values.
3403 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3404 the name to be called if we can't opencode the function.
3405 If ATTRS is nonzero, use that for the function's attribute
3409 builtin_function_1 (const char* name,
3412 enum built_in_function code,
3413 enum built_in_class class,
3414 const char* libname,
3417 tree decl = build_library_fn_1 (get_identifier (name), ERROR_MARK, type);
3418 DECL_BUILT_IN_CLASS (decl) = class;
3419 DECL_FUNCTION_CODE (decl) = code;
3420 DECL_CONTEXT (decl) = context;
3424 /* Since `pushdecl' relies on DECL_ASSEMBLER_NAME instead of DECL_NAME,
3425 we cannot change DECL_ASSEMBLER_NAME until we have installed this
3426 function in the namespace. */
3428 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
3430 /* A function in the user's namespace should have an explicit
3431 declaration before it is used. Mark the built-in function as
3432 anticipated but not actually declared. */
3433 if (name[0] != '_' || name[1] != '_')
3434 DECL_ANTICIPATED (decl) = 1;
3436 /* Possibly apply some default attributes to this built-in function. */
3438 decl_attributes (&decl, attrs, ATTR_FLAG_BUILT_IN);
3440 decl_attributes (&decl, NULL_TREE, 0);
3445 /* Entry point for the benefit of c_common_nodes_and_builtins.
3447 Make a definition for a builtin function named NAME and whose data type
3448 is TYPE. TYPE should be a function type with argument types. This
3449 function places the anticipated declaration in the global namespace
3450 and additionally in the std namespace if appropriate.
3452 CLASS and CODE tell later passes how to compile calls to this function.
3453 See tree.h for possible values.
3455 If LIBNAME is nonzero, use that for DECL_ASSEMBLER_NAME,
3456 the name to be called if we can't opencode the function.
3458 If ATTRS is nonzero, use that for the function's attribute
3462 builtin_function (const char* name,
3465 enum built_in_class cl,
3466 const char* libname,
3469 /* All builtins that don't begin with an '_' should additionally
3470 go in the 'std' namespace. */
3473 push_namespace (std_identifier);
3474 builtin_function_1 (name, type, std_node, code, cl, libname, attrs);
3478 return builtin_function_1 (name, type, NULL_TREE, code,
3479 cl, libname, attrs);
3482 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
3483 function. Not called directly. */
3486 build_library_fn_1 (tree name, enum tree_code operator_code, tree type)
3488 tree fn = build_lang_decl (FUNCTION_DECL, name, type);
3489 DECL_EXTERNAL (fn) = 1;
3490 TREE_PUBLIC (fn) = 1;
3491 DECL_ARTIFICIAL (fn) = 1;
3492 SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
3493 SET_DECL_LANGUAGE (fn, lang_c);
3494 /* Runtime library routines are, by definition, available in an
3495 external shared object. */
3496 DECL_VISIBILITY (fn) = VISIBILITY_DEFAULT;
3497 DECL_VISIBILITY_SPECIFIED (fn) = 1;
3501 /* Returns the _DECL for a library function with C linkage.
3502 We assume that such functions never throw; if this is incorrect,
3503 callers should unset TREE_NOTHROW. */
3506 build_library_fn (tree name, tree type)
3508 tree fn = build_library_fn_1 (name, ERROR_MARK, type);
3509 TREE_NOTHROW (fn) = 1;
3513 /* Returns the _DECL for a library function with C++ linkage. */
3516 build_cp_library_fn (tree name, enum tree_code operator_code, tree type)
3518 tree fn = build_library_fn_1 (name, operator_code, type);
3519 TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
3520 DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
3521 SET_DECL_LANGUAGE (fn, lang_cplusplus);
3525 /* Like build_library_fn, but takes a C string instead of an
3529 build_library_fn_ptr (const char* name, tree type)
3531 return build_library_fn (get_identifier (name), type);
3534 /* Like build_cp_library_fn, but takes a C string instead of an
3538 build_cp_library_fn_ptr (const char* name, tree type)
3540 return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
3543 /* Like build_library_fn, but also pushes the function so that we will
3544 be able to find it via IDENTIFIER_GLOBAL_VALUE. */
3547 push_library_fn (tree name, tree type)
3549 tree fn = build_library_fn (name, type);
3550 pushdecl_top_level (fn);
3554 /* Like build_cp_library_fn, but also pushes the function so that it
3555 will be found by normal lookup. */
3558 push_cp_library_fn (enum tree_code operator_code, tree type)
3560 tree fn = build_cp_library_fn (ansi_opname (operator_code),
3567 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
3571 push_void_library_fn (tree name, tree parmtypes)
3573 tree type = build_function_type (void_type_node, parmtypes);
3574 return push_library_fn (name, type);
3577 /* Like push_library_fn, but also note that this function throws
3578 and does not return. Used for __throw_foo and the like. */
3581 push_throw_library_fn (tree name, tree type)
3583 tree fn = push_library_fn (name, type);
3584 TREE_THIS_VOLATILE (fn) = 1;
3585 TREE_NOTHROW (fn) = 0;
3589 /* When we call finish_struct for an anonymous union, we create
3590 default copy constructors and such. But, an anonymous union
3591 shouldn't have such things; this function undoes the damage to the
3592 anonymous union type T.
3594 (The reason that we create the synthesized methods is that we don't
3595 distinguish `union { int i; }' from `typedef union { int i; } U'.
3596 The first is an anonymous union; the second is just an ordinary
3600 fixup_anonymous_aggr (tree t)
3604 /* Wipe out memory of synthesized methods. */
3605 TYPE_HAS_CONSTRUCTOR (t) = 0;
3606 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
3607 TYPE_HAS_INIT_REF (t) = 0;
3608 TYPE_HAS_CONST_INIT_REF (t) = 0;
3609 TYPE_HAS_ASSIGN_REF (t) = 0;
3610 TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
3612 /* Splice the implicitly generated functions out of the TYPE_METHODS
3614 q = &TYPE_METHODS (t);
3617 if (DECL_ARTIFICIAL (*q))
3618 *q = TREE_CHAIN (*q);
3620 q = &TREE_CHAIN (*q);
3623 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
3624 if (TYPE_METHODS (t))
3625 error ("%Jan anonymous union cannot have function members",
3626 TYPE_MAIN_DECL (t));
3628 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
3629 assignment operators (because they cannot have these methods themselves).
3630 For anonymous unions this is already checked because they are not allowed
3631 in any union, otherwise we have to check it. */
3632 if (TREE_CODE (t) != UNION_TYPE)
3636 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
3637 if (TREE_CODE (field) == FIELD_DECL)
3639 type = TREE_TYPE (field);
3640 if (CLASS_TYPE_P (type))
3642 if (TYPE_NEEDS_CONSTRUCTING (type))
3643 error ("member %q+#D with constructor not allowed "
3644 "in anonymous aggregate", field);
3645 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
3646 error ("member %q+#D with destructor not allowed "
3647 "in anonymous aggregate", field);
3648 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
3649 error ("member %q+#D with copy assignment operator "
3650 "not allowed in anonymous aggregate", field);
3656 /* Make sure that a declaration with no declarator is well-formed, i.e.
3657 just declares a tagged type or anonymous union.
3659 Returns the type declared; or NULL_TREE if none. */
3662 check_tag_decl (cp_decl_specifier_seq *declspecs)
3664 int saw_friend = declspecs->specs[(int)ds_friend] != 0;
3665 int saw_typedef = declspecs->specs[(int)ds_typedef] != 0;
3666 /* If a class, struct, or enum type is declared by the DECLSPECS
3667 (i.e, if a class-specifier, enum-specifier, or non-typename
3668 elaborated-type-specifier appears in the DECLSPECS),
3669 DECLARED_TYPE is set to the corresponding type. */
3670 tree declared_type = NULL_TREE;
3671 bool error_p = false;
3673 if (declspecs->multiple_types_p)
3674 error ("multiple types in one declaration");
3675 else if (declspecs->redefined_builtin_type)
3677 if (!in_system_header)
3678 pedwarn ("redeclaration of C++ built-in type %qT",
3679 declspecs->redefined_builtin_type);
3684 && TYPE_P (declspecs->type)
3685 && ((TREE_CODE (declspecs->type) != TYPENAME_TYPE
3686 && IS_AGGR_TYPE (declspecs->type))
3687 || TREE_CODE (declspecs->type) == ENUMERAL_TYPE))
3688 declared_type = declspecs->type;
3689 else if (declspecs->type == error_mark_node)
3691 if (declared_type == NULL_TREE && ! saw_friend && !error_p)
3692 pedwarn ("declaration does not declare anything");
3693 /* Check for an anonymous union. */
3694 else if (declared_type && IS_AGGR_TYPE_CODE (TREE_CODE (declared_type))
3695 && TYPE_ANONYMOUS_P (declared_type))
3697 /* 7/3 In a simple-declaration, the optional init-declarator-list
3698 can be omitted only when declaring a class (clause 9) or
3699 enumeration (7.2), that is, when the decl-specifier-seq contains
3700 either a class-specifier, an elaborated-type-specifier with
3701 a class-key (9.1), or an enum-specifier. In these cases and
3702 whenever a class-specifier or enum-specifier is present in the
3703 decl-specifier-seq, the identifiers in these specifiers are among
3704 the names being declared by the declaration (as class-name,
3705 enum-names, or enumerators, depending on the syntax). In such
3706 cases, and except for the declaration of an unnamed bit-field (9.6),
3707 the decl-specifier-seq shall introduce one or more names into the
3708 program, or shall redeclare a name introduced by a previous
3709 declaration. [Example:
3710 enum { }; // ill-formed
3711 typedef class { }; // ill-formed
3715 error ("missing type-name in typedef-declaration");
3718 /* Anonymous unions are objects, so they can have specifiers. */;
3719 SET_ANON_AGGR_TYPE_P (declared_type);
3721 if (TREE_CODE (declared_type) != UNION_TYPE && pedantic
3722 && !in_system_header)
3723 pedwarn ("ISO C++ prohibits anonymous structs");
3728 if (declspecs->specs[(int)ds_inline]
3729 || declspecs->specs[(int)ds_virtual])
3730 error ("%qs can only be specified for functions",
3731 declspecs->specs[(int)ds_inline]
3732 ? "inline" : "virtual");
3734 && (!current_class_type
3735 || current_scope () != current_class_type))
3736 error ("%<friend%> can only be specified inside a class");
3737 else if (declspecs->specs[(int)ds_explicit])
3738 error ("%<explicit%> can only be specified for constructors");
3739 else if (declspecs->storage_class)
3740 error ("a storage class can only be specified for objects "
3742 else if (declspecs->specs[(int)ds_const]
3743 || declspecs->specs[(int)ds_volatile]
3744 || declspecs->specs[(int)ds_restrict]
3745 || declspecs->specs[(int)ds_thread])
3746 error ("qualifiers can only be specified for objects "
3750 return declared_type;
3753 /* Called when a declaration is seen that contains no names to declare.
3754 If its type is a reference to a structure, union or enum inherited
3755 from a containing scope, shadow that tag name for the current scope
3756 with a forward reference.
3757 If its type defines a new named structure or union
3758 or defines an enum, it is valid but we need not do anything here.
3759 Otherwise, it is an error.
3761 C++: may have to grok the declspecs to learn about static,
3762 complain for anonymous unions.
3764 Returns the TYPE declared -- or NULL_TREE if none. */
3767 shadow_tag (cp_decl_specifier_seq *declspecs)
3769 tree t = check_tag_decl (declspecs);
3774 if (declspecs->attributes)
3776 warning (0, "attribute ignored in declaration of %q+#T", t);
3777 warning (0, "attribute for %q+#T must follow the %qs keyword",
3778 t, class_key_or_enum_as_string (t));
3782 if (maybe_process_partial_specialization (t) == error_mark_node)
3785 /* This is where the variables in an anonymous union are
3786 declared. An anonymous union declaration looks like:
3788 because there is no declarator after the union, the parser
3789 sends that declaration here. */
3790 if (ANON_AGGR_TYPE_P (t))
3792 fixup_anonymous_aggr (t);
3794 if (TYPE_FIELDS (t))
3796 tree decl = grokdeclarator (/*declarator=*/NULL,
3797 declspecs, NORMAL, 0, NULL);
3798 finish_anon_union (decl);
3805 /* APPLE LOCAL begin blocks 6339747 */
3806 /* Decode a block literal type, such as "int **", returning a ...FUNCTION_DECL node. */
3809 grokblockdecl (cp_decl_specifier_seq *type_specifiers,
3810 const cp_declarator *declarator)
3813 tree attrs = type_specifiers->attributes;
3815 type_specifiers->attributes = NULL_TREE;
3817 decl = grokdeclarator (declarator, type_specifiers, BLOCKDEF, 0, &attrs);
3819 cplus_decl_attributes (&decl, attrs, 0);
3822 /* APPLE LOCAL end blocks 6339747 */
3824 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
3827 groktypename (cp_decl_specifier_seq *type_specifiers,
3828 const cp_declarator *declarator)
3832 attrs = type_specifiers->attributes;
3833 type_specifiers->attributes = NULL_TREE;
3834 type = grokdeclarator (declarator, type_specifiers, TYPENAME, 0, &attrs);
3836 cplus_decl_attributes (&type, attrs, 0);
3840 /* Decode a declarator in an ordinary declaration or data definition.
3841 This is called as soon as the type information and variable name
3842 have been parsed, before parsing the initializer if any.
3843 Here we create the ..._DECL node, fill in its type,
3844 and put it on the list of decls for the current context.
3845 The ..._DECL node is returned as the value.
3847 Exception: for arrays where the length is not specified,
3848 the type is left null, to be filled in by `cp_finish_decl'.
3850 Function definitions do not come here; they go to start_function
3851 instead. However, external and forward declarations of functions
3852 do go through here. Structure field declarations are done by
3853 grokfield and not through here. */
3856 start_decl (const cp_declarator *declarator,
3857 cp_decl_specifier_seq *declspecs,
3860 tree prefix_attributes,
3861 tree *pushed_scope_p)
3866 /* APPLE LOCAL "unavailable" attribute (radar 2809697) */
3870 *pushed_scope_p = NULL_TREE;
3872 /* APPLE LOCAL begin "unavailable" attribute (radar 2809697) */
3873 /* An object declared as __attribute__((unavailable)) suppresses
3874 any reports of being declared with unavailable or deprecated
3875 items. An object declared as __attribute__((deprecated))
3876 suppresses warnings of uses of other deprecated items. */
3877 #ifdef A_LESS_INEFFICENT_WAY /* which I really don't want to do! */
3878 if (lookup_attribute ("deprecated", attributes))
3879 deprecated_state = DEPRECATED_SUPPRESS;
3880 else if (lookup_attribute ("unavailable", attributes))
3881 deprecated_state = DEPRECATED_UNAVAILABLE_SUPPRESS;
3882 #else /* a more efficient way doing what lookup_attribute would do */
3883 for (a = attributes; a; a = TREE_CHAIN (a))
3885 tree name = TREE_PURPOSE (a);
3886 if (TREE_CODE (name) == IDENTIFIER_NODE)
3887 if (is_attribute_p ("deprecated", name))
3889 deprecated_state = DEPRECATED_SUPPRESS;
3892 if (is_attribute_p ("unavailable", name))
3894 deprecated_state = DEPRECATED_UNAVAILABLE_SUPPRESS;
3899 /* APPLE LOCAL end "unavailable" attribute (radar 2809697) */
3901 attributes = chainon (attributes, prefix_attributes);
3903 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
3906 deprecated_state = DEPRECATED_NORMAL;
3908 if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE
3909 || decl == error_mark_node)
3910 return error_mark_node;
3912 type = TREE_TYPE (decl);
3914 context = DECL_CONTEXT (decl);
3918 *pushed_scope_p = push_scope (context);
3920 /* We are only interested in class contexts, later. */
3921 if (TREE_CODE (context) == NAMESPACE_DECL)
3922 context = NULL_TREE;
3926 /* Is it valid for this decl to have an initializer at all?
3927 If not, set INITIALIZED to zero, which will indirectly
3928 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
3929 switch (TREE_CODE (decl))
3932 error ("typedef %qD is initialized (use __typeof__ instead)", decl);
3933 return error_mark_node;
3936 error ("function %q#D is initialized like a variable", decl);
3937 return error_mark_node;
3945 if (! toplevel_bindings_p ()
3946 && DECL_EXTERNAL (decl))
3947 warning (0, "declaration of %q#D has %<extern%> and is initialized",
3949 DECL_EXTERNAL (decl) = 0;
3950 if (toplevel_bindings_p ())
3951 TREE_STATIC (decl) = 1;
3954 /* Set attributes here so if duplicate decl, will have proper attributes. */
3955 cplus_decl_attributes (&decl, attributes, 0);
3957 /* Dllimported symbols cannot be defined. Static data members (which
3958 can be initialized in-class and dllimported) go through grokfield,
3959 not here, so we don't need to exclude those decls when checking for
3961 if (initialized && DECL_DLLIMPORT_P (decl))
3963 error ("definition of %q#D is marked %<dllimport%>", decl);
3964 DECL_DLLIMPORT_P (decl) = 0;
3967 /* If #pragma weak was used, mark the decl weak now. */
3968 maybe_apply_pragma_weak (decl);
3970 if (TREE_CODE (decl) == FUNCTION_DECL
3971 && DECL_DECLARED_INLINE_P (decl)
3972 && DECL_UNINLINABLE (decl)
3973 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
3974 warning (0, "inline function %q+D given attribute noinline", decl);
3976 if (context && COMPLETE_TYPE_P (complete_type (context)))
3978 if (TREE_CODE (decl) == VAR_DECL)
3980 tree field = lookup_field (context, DECL_NAME (decl), 0, false);
3981 if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
3982 error ("%q#D is not a static member of %q#T", decl, context);
3985 if (DECL_CONTEXT (field) != context)
3987 if (!same_type_p (DECL_CONTEXT (field), context))
3988 pedwarn ("ISO C++ does not permit %<%T::%D%> "
3989 "to be defined as %<%T::%D%>",
3990 DECL_CONTEXT (field), DECL_NAME (decl),
3991 context, DECL_NAME (decl));
3992 DECL_CONTEXT (decl) = DECL_CONTEXT (field);
3994 if (processing_specialization
3995 && template_class_depth (context) == 0
3996 && CLASSTYPE_TEMPLATE_SPECIALIZATION (context))
3997 error ("template header not allowed in member definition "
3998 "of explicitly specialized class");
3999 /* Static data member are tricky; an in-class initialization
4000 still doesn't provide a definition, so the in-class
4001 declaration will have DECL_EXTERNAL set, but will have an
4002 initialization. Thus, duplicate_decls won't warn
4003 about this situation, and so we check here. */
4004 if (initialized && DECL_INITIALIZED_IN_CLASS_P (field))
4005 error ("duplicate initialization of %qD", decl);
4006 if (duplicate_decls (decl, field, /*newdecl_is_friend=*/false))
4012 tree field = check_classfn (context, decl,
4013 (processing_template_decl
4014 > template_class_depth (context))
4015 ? current_template_parms
4017 if (field && duplicate_decls (decl, field,
4018 /*newdecl_is_friend=*/false))
4022 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
4023 DECL_IN_AGGR_P (decl) = 0;
4024 /* Do not mark DECL as an explicit specialization if it was not
4025 already marked as an instantiation; a declaration should
4026 never be marked as a specialization unless we know what
4027 template is being specialized. */
4028 if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
4030 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
4032 /* [temp.expl.spec] An explicit specialization of a static data
4033 member of a template is a definition if the declaration
4034 includes an initializer; otherwise, it is a declaration.
4036 We check for processing_specialization so this only applies
4037 to the new specialization syntax. */
4038 if (!initialized && processing_specialization)
4039 DECL_EXTERNAL (decl) = 1;
4042 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
4043 pedwarn ("declaration of %q#D outside of class is not definition",
4047 was_public = TREE_PUBLIC (decl);
4049 /* Enter this declaration into the symbol table. */
4050 tem = maybe_push_decl (decl);
4052 if (processing_template_decl)
4053 tem = push_template_decl (tem);
4054 if (tem == error_mark_node)
4055 return error_mark_node;
4057 /* Tell the back-end to use or not use .common as appropriate. If we say
4058 -fconserve-space, we want this to save .data space, at the expense of
4059 wrong semantics. If we say -fno-conserve-space, we want this to
4060 produce errors about redefs; to do this we force variables into the
4062 if (flag_conserve_space
4063 && TREE_CODE (tem) == VAR_DECL
4064 && TREE_PUBLIC (tem)
4065 && !DECL_THREAD_LOCAL_P (tem)
4066 && !have_global_bss_p ())
4067 DECL_COMMON (tem) = 1;
4069 if (TREE_CODE (tem) == VAR_DECL
4070 && DECL_NAMESPACE_SCOPE_P (tem) && !TREE_PUBLIC (tem) && !was_public
4071 && !DECL_THIS_STATIC (tem) && !DECL_ARTIFICIAL (tem))
4073 /* This is a const variable with implicit 'static'. Set
4074 DECL_THIS_STATIC so we can tell it from variables that are
4075 !TREE_PUBLIC because of the anonymous namespace. */
4076 gcc_assert (cp_type_readonly (TREE_TYPE (tem)));
4077 DECL_THIS_STATIC (tem) = 1;
4080 if (!processing_template_decl && TREE_CODE (tem) == VAR_DECL)
4081 start_decl_1 (tem, initialized);
4087 start_decl_1 (tree decl, bool initialized)
4091 gcc_assert (!processing_template_decl);
4093 if (error_operand_p (decl))
4096 gcc_assert (TREE_CODE (decl) == VAR_DECL);
4097 type = TREE_TYPE (decl);
4100 /* Is it valid for this decl to have an initializer at all?
4101 If not, set INITIALIZED to zero, which will indirectly
4102 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
4104 /* Don't allow initializations for incomplete types except for
4105 arrays which might be completed by the initialization. */
4106 if (COMPLETE_TYPE_P (complete_type (type)))
4107 ; /* A complete type is ok. */
4108 else if (TREE_CODE (type) != ARRAY_TYPE)
4110 error ("variable %q#D has initializer but incomplete type", decl);
4112 type = TREE_TYPE (decl) = error_mark_node;
4114 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
4116 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
4117 error ("elements of array %q#D have incomplete type", decl);
4118 /* else we already gave an error in start_decl. */
4122 else if (IS_AGGR_TYPE (type)
4123 && ! DECL_EXTERNAL (decl))
4125 if (!COMPLETE_TYPE_P (complete_type (type)))
4127 error ("aggregate %q#D has incomplete type and cannot be defined",
4129 /* Change the type so that assemble_variable will give
4130 DECL an rtl we can live with: (mem (const_int 0)). */
4131 type = TREE_TYPE (decl) = error_mark_node;
4135 /* If any base type in the hierarchy of TYPE needs a constructor,
4136 then we set initialized to 1. This way any nodes which are
4137 created for the purposes of initializing this aggregate
4138 will live as long as it does. This is necessary for global
4139 aggregates which do not have their initializers processed until
4140 the end of the file. */
4141 initialized = TYPE_NEEDS_CONSTRUCTING (type);
4145 /* Create a new scope to hold this declaration if necessary.
4146 Whether or not a new scope is necessary cannot be determined
4147 until after the type has been completed; if the type is a
4148 specialization of a class template it is not until after
4149 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4150 will be set correctly. */
4151 maybe_push_cleanup_level (type);
4154 /* Handle initialization of references. DECL, TYPE, and INIT have the
4155 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
4156 but will be set to a new CLEANUP_STMT if a temporary is created
4157 that must be destroyed subsequently.
4159 Returns an initializer expression to use to initialize DECL, or
4160 NULL if the initialization can be performed statically.
4162 Quotes on semantics can be found in ARM 8.4.3. */
4165 grok_reference_init (tree decl, tree type, tree init, tree *cleanup)
4169 if (init == NULL_TREE)
4171 if ((DECL_LANG_SPECIFIC (decl) == 0
4172 || DECL_IN_AGGR_P (decl) == 0)
4173 && ! DECL_THIS_EXTERN (decl))
4174 error ("%qD declared as reference but not initialized", decl);
4178 if (TREE_CODE (init) == CONSTRUCTOR)
4180 error ("ISO C++ forbids use of initializer list to "
4181 "initialize reference %qD", decl);
4185 if (TREE_CODE (init) == TREE_LIST)
4186 init = build_x_compound_expr_from_list (init, "initializer");
4188 if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
4189 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
4190 /* Note: default conversion is only called in very special cases. */
4191 init = decay_conversion (init);
4193 /* Convert INIT to the reference type TYPE. This may involve the
4194 creation of a temporary, whose lifetime must be the same as that
4195 of the reference. If so, a DECL_EXPR for the temporary will be
4196 added just after the DECL_EXPR for DECL. That's why we don't set
4197 DECL_INITIAL for local references (instead assigning to them
4198 explicitly); we need to allow the temporary to be initialized
4200 tmp = initialize_reference (type, init, decl, cleanup);
4202 if (tmp == error_mark_node)
4204 else if (tmp == NULL_TREE)
4206 error ("cannot initialize %qT from %qT", type, TREE_TYPE (init));
4210 if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
4213 DECL_INITIAL (decl) = tmp;
4218 /* Designated initializers in arrays are not supported in GNU C++.
4219 The parser cannot detect this error since it does not know whether
4220 a given brace-enclosed initializer is for a class type or for an
4221 array. This function checks that CE does not use a designated
4222 initializer. If it does, an error is issued. Returns true if CE
4223 is valid, i.e., does not have a designated initializer. */
4226 check_array_designated_initializer (const constructor_elt *ce)
4228 /* Designated initializers for array elements arenot supported. */
4231 /* The parser only allows identifiers as designated
4233 gcc_assert (TREE_CODE (ce->index) == IDENTIFIER_NODE);
4234 error ("name %qD used in a GNU-style designated "
4235 "initializer for an array", ce->index);
4242 /* When parsing `int a[] = {1, 2};' we don't know the size of the
4243 array until we finish parsing the initializer. If that's the
4244 situation we're in, update DECL accordingly. */
4247 maybe_deduce_size_from_array_init (tree decl, tree init)
4249 tree type = TREE_TYPE (decl);
4251 if (TREE_CODE (type) == ARRAY_TYPE
4252 && TYPE_DOMAIN (type) == NULL_TREE
4253 && TREE_CODE (decl) != TYPE_DECL)
4255 /* do_default is really a C-ism to deal with tentative definitions.
4256 But let's leave it here to ease the eventual merge. */
4257 int do_default = !DECL_EXTERNAL (decl);
4258 tree initializer = init ? init : DECL_INITIAL (decl);
4261 /* Check that there are no designated initializers in INIT, as
4262 those are not supported in GNU C++, and as the middle-end
4263 will crash if presented with a non-numeric designated
4265 if (initializer && TREE_CODE (initializer) == CONSTRUCTOR)
4267 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initializer);
4268 constructor_elt *ce;
4271 VEC_iterate (constructor_elt, v, i, ce);
4273 if (!check_array_designated_initializer (ce))
4279 failure = cp_complete_array_type (&TREE_TYPE (decl), initializer,
4283 error ("initializer fails to determine size of %qD", decl);
4284 TREE_TYPE (decl) = error_mark_node;
4286 else if (failure == 2)
4290 error ("array size missing in %qD", decl);
4291 TREE_TYPE (decl) = error_mark_node;
4293 /* If a `static' var's size isn't known, make it extern as
4294 well as static, so it does not get allocated. If it's not
4295 `static', then don't mark it extern; finish_incomplete_decl
4296 will give it a default size and it will get allocated. */
4297 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
4298 DECL_EXTERNAL (decl) = 1;
4300 else if (failure == 3)
4302 error ("zero-size array %qD", decl);
4303 TREE_TYPE (decl) = error_mark_node;
4307 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl)), decl);
4309 layout_decl (decl, 0);
4313 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
4314 any appropriate error messages regarding the layout. */
4317 layout_var_decl (tree decl)
4321 type = TREE_TYPE (decl);
4322 if (type == error_mark_node)
4325 /* If we haven't already layed out this declaration, do so now.
4326 Note that we must not call complete type for an external object
4327 because it's type might involve templates that we are not
4328 supposed to instantiate yet. (And it's perfectly valid to say
4329 `extern X x' for some incomplete type `X'.) */
4330 if (!DECL_EXTERNAL (decl))
4331 complete_type (type);
4332 if (!DECL_SIZE (decl)
4333 && TREE_TYPE (decl) != error_mark_node
4334 && (COMPLETE_TYPE_P (type)
4335 || (TREE_CODE (type) == ARRAY_TYPE
4336 && !TYPE_DOMAIN (type)
4337 && COMPLETE_TYPE_P (TREE_TYPE (type)))))
4338 layout_decl (decl, 0);
4340 if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
4342 /* An automatic variable with an incomplete type: that is an error.
4343 Don't talk about array types here, since we took care of that
4344 message in grokdeclarator. */
4345 error ("storage size of %qD isn't known", decl);
4346 TREE_TYPE (decl) = error_mark_node;
4349 /* Keep this code around in case we later want to control debug info
4350 based on whether a type is "used". (jason 1999-11-11) */
4352 else if (!DECL_EXTERNAL (decl) && IS_AGGR_TYPE (ttype))
4353 /* Let debugger know it should output info for this type. */
4354 note_debug_info_needed (ttype);
4356 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
4357 note_debug_info_needed (DECL_CONTEXT (decl));
4360 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
4361 && DECL_SIZE (decl) != NULL_TREE
4362 && ! TREE_CONSTANT (DECL_SIZE (decl)))
4364 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
4365 constant_expression_warning (DECL_SIZE (decl));
4367 error ("storage size of %qD isn't constant", decl);
4371 /* If a local static variable is declared in an inline function, or if
4372 we have a weak definition, we must endeavor to create only one
4373 instance of the variable at link-time. */
4376 maybe_commonize_var (tree decl)
4378 /* Static data in a function with comdat linkage also has comdat
4380 if (TREE_STATIC (decl)
4381 /* Don't mess with __FUNCTION__. */
4382 && ! DECL_ARTIFICIAL (decl)
4383 && DECL_FUNCTION_SCOPE_P (decl)
4384 /* Unfortunately, import_export_decl has not always been called
4385 before the function is processed, so we cannot simply check
4387 && (DECL_COMDAT (DECL_CONTEXT (decl))
4388 || ((DECL_DECLARED_INLINE_P (DECL_CONTEXT (decl))
4389 || DECL_TEMPLATE_INSTANTIATION (DECL_CONTEXT (decl)))
4390 && TREE_PUBLIC (DECL_CONTEXT (decl)))))
4394 /* With weak symbols, we simply make the variable COMDAT;
4395 that will cause copies in multiple translations units to
4397 comdat_linkage (decl);
4401 if (DECL_INITIAL (decl) == NULL_TREE
4402 || DECL_INITIAL (decl) == error_mark_node)
4404 /* Without weak symbols, we can use COMMON to merge
4405 uninitialized variables. */
4406 TREE_PUBLIC (decl) = 1;
4407 DECL_COMMON (decl) = 1;
4411 /* While for initialized variables, we must use internal
4412 linkage -- which means that multiple copies will not
4414 TREE_PUBLIC (decl) = 0;
4415 DECL_COMMON (decl) = 0;
4416 warning (0, "sorry: semantics of inline function static "
4417 "data %q+#D are wrong (you'll wind up "
4418 "with multiple copies)", decl);
4419 warning (0, "%J you can work around this by removing "
4425 else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
4426 /* Set it up again; we might have set DECL_INITIAL since the last
4428 comdat_linkage (decl);
4431 /* Issue an error message if DECL is an uninitialized const variable. */
4434 check_for_uninitialized_const_var (tree decl)
4436 tree type = TREE_TYPE (decl);
4438 /* ``Unless explicitly declared extern, a const object does not have
4439 external linkage and must be initialized. ($8.4; $12.1)'' ARM
4441 if (TREE_CODE (decl) == VAR_DECL
4442 && TREE_CODE (type) != REFERENCE_TYPE
4443 && CP_TYPE_CONST_P (type)
4444 && !TYPE_NEEDS_CONSTRUCTING (type)
4445 && !DECL_INITIAL (decl))
4446 error ("uninitialized const %qD", decl);
4450 /* Structure holding the current initializer being processed by reshape_init.
4451 CUR is a pointer to the current element being processed, END is a pointer
4452 after the last element present in the initializer. */
4453 typedef struct reshape_iterator_t
4455 constructor_elt *cur;
4456 constructor_elt *end;
4459 static tree reshape_init_r (tree, reshape_iter *, bool);
4461 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
4462 returned is the next FIELD_DECL (possibly FIELD itself) that can be
4463 initialized. If there are no more such fields, the return value
4467 next_initializable_field (tree field)
4470 && (TREE_CODE (field) != FIELD_DECL
4471 || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
4472 || DECL_ARTIFICIAL (field)))
4473 field = TREE_CHAIN (field);
4478 /* Subroutine of reshape_init_array and reshape_init_vector, which does
4479 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
4480 INTEGER_CST representing the size of the array minus one (the maximum index),
4481 or NULL_TREE if the array was declared without specifying the size. D is
4482 the iterator within the constructor. */
4485 reshape_init_array_1 (tree elt_type, tree max_index, reshape_iter *d)
4488 bool sized_array_p = (max_index != NULL_TREE);
4489 unsigned HOST_WIDE_INT max_index_cst = 0;
4490 unsigned HOST_WIDE_INT index;
4492 /* The initializer for an array is always a CONSTRUCTOR. */
4493 new_init = build_constructor (NULL_TREE, NULL);
4497 /* Minus 1 is used for zero sized arrays. */
4498 if (integer_all_onesp (max_index))
4501 if (host_integerp (max_index, 1))
4502 max_index_cst = tree_low_cst (max_index, 1);
4503 /* sizetype is sign extended, not zero extended. */
4505 max_index_cst = tree_low_cst (fold_convert (size_type_node, max_index),
4509 /* Loop until there are no more initializers. */
4511 d->cur != d->end && (!sized_array_p || index <= max_index_cst);
4516 check_array_designated_initializer (d->cur);
4517 elt_init = reshape_init_r (elt_type, d, /*first_initializer_p=*/false);
4518 if (elt_init == error_mark_node)
4519 return error_mark_node;
4520 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), NULL_TREE, elt_init);
4526 /* Subroutine of reshape_init_r, processes the initializers for arrays.
4527 Parameters are the same of reshape_init_r. */
4530 reshape_init_array (tree type, reshape_iter *d)
4532 tree max_index = NULL_TREE;
4534 gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
4536 if (TYPE_DOMAIN (type))
4537 max_index = array_type_nelts (type);
4539 return reshape_init_array_1 (TREE_TYPE (type), max_index, d);
4542 /* Subroutine of reshape_init_r, processes the initializers for vectors.
4543 Parameters are the same of reshape_init_r. */
4546 reshape_init_vector (tree type, reshape_iter *d)
4548 tree max_index = NULL_TREE;
4551 gcc_assert (TREE_CODE (type) == VECTOR_TYPE);
4553 if (COMPOUND_LITERAL_P (d->cur->value))
4555 tree value = d->cur->value;
4556 if (!same_type_p (TREE_TYPE (value), type))
4558 error ("invalid type %qT as initializer for a vector of type %qT",
4559 TREE_TYPE (d->cur->value), type);
4560 value = error_mark_node;
4566 /* For a vector, the representation type is a struct
4567 containing a single member which is an array of the
4568 appropriate size. */
4569 rtype = TYPE_DEBUG_REPRESENTATION_TYPE (type);
4570 if (rtype && TYPE_DOMAIN (TREE_TYPE (TYPE_FIELDS (rtype))))
4571 max_index = array_type_nelts (TREE_TYPE (TYPE_FIELDS (rtype)));
4573 return reshape_init_array_1 (TREE_TYPE (type), max_index, d);
4576 /* Subroutine of reshape_init_r, processes the initializers for classes
4577 or union. Parameters are the same of reshape_init_r. */
4580 reshape_init_class (tree type, reshape_iter *d, bool first_initializer_p)
4585 gcc_assert (CLASS_TYPE_P (type));
4587 /* The initializer for a class is always a CONSTRUCTOR. */
4588 new_init = build_constructor (NULL_TREE, NULL);
4589 field = next_initializable_field (TYPE_FIELDS (type));
4595 An initializer for an aggregate member that is an
4596 empty class shall have the form of an empty
4597 initializer-list {}. */
4598 if (!first_initializer_p)
4600 error ("initializer for %qT must be brace-enclosed", type);
4601 return error_mark_node;
4606 /* Loop through the initializable fields, gathering initializers. */
4607 while (d->cur != d->end)
4611 /* Handle designated initializers, as an extension. */
4614 field = lookup_field_1 (type, d->cur->index, /*want_type=*/false);
4616 if (!field || TREE_CODE (field) != FIELD_DECL)
4618 error ("%qT has no non-static data member named %qD", type,
4620 return error_mark_node;
4624 /* If we processed all the member of the class, we are done. */
4628 field_init = reshape_init_r (TREE_TYPE (field), d,
4629 /*first_initializer_p=*/false);
4630 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), field, field_init);
4634 When a union is initialized with a brace-enclosed
4635 initializer, the braces shall only contain an
4636 initializer for the first member of the union. */
4637 if (TREE_CODE (type) == UNION_TYPE)
4640 field = next_initializable_field (TREE_CHAIN (field));
4646 /* Subroutine of reshape_init, which processes a single initializer (part of
4647 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
4648 iterator within the CONSTRUCTOR which points to the initializer to process.
4649 FIRST_INITIALIZER_P is true if this is the first initializer of the
4650 CONSTRUCTOR node. */
4653 reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p)
4655 tree init = d->cur->value;
4657 /* A non-aggregate type is always initialized with a single
4659 if (!CP_AGGREGATE_TYPE_P (type))
4661 /* It is invalid to initialize a non-aggregate type with a
4662 brace-enclosed initializer.
4663 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
4664 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
4665 a CONSTRUCTOR (with a record type). */
4666 if (TREE_CODE (init) == CONSTRUCTOR
4667 && BRACE_ENCLOSED_INITIALIZER_P (init)) /* p7626.C */
4669 error ("braces around scalar initializer for type %qT", type);
4670 init = error_mark_node;
4679 All implicit type conversions (clause _conv_) are considered when
4680 initializing the aggregate member with an initializer from an
4681 initializer-list. If the initializer can initialize a member,
4682 the member is initialized. Otherwise, if the member is itself a
4683 non-empty subaggregate, brace elision is assumed and the
4684 initializer is considered for the initialization of the first
4685 member of the subaggregate. */
4686 if (TREE_CODE (init) != CONSTRUCTOR
4687 && can_convert_arg (type, TREE_TYPE (init), init, LOOKUP_NORMAL))
4693 /* [dcl.init.string]
4695 A char array (whether plain char, signed char, or unsigned char)
4696 can be initialized by a string-literal (optionally enclosed in
4697 braces); a wchar_t array can be initialized by a wide
4698 string-literal (optionally enclosed in braces). */
4699 if (TREE_CODE (type) == ARRAY_TYPE
4700 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
4702 tree str_init = init;
4704 /* Strip one level of braces if and only if they enclose a single
4705 element (as allowed by [dcl.init.string]). */
4706 if (!first_initializer_p
4707 && TREE_CODE (str_init) == CONSTRUCTOR
4708 && VEC_length (constructor_elt, CONSTRUCTOR_ELTS (str_init)) == 1)
4710 str_init = VEC_index (constructor_elt,
4711 CONSTRUCTOR_ELTS (str_init), 0)->value;
4714 /* If it's a string literal, then it's the initializer for the array
4715 as a whole. Otherwise, continue with normal initialization for
4716 array types (one value per array element). */
4717 if (TREE_CODE (str_init) == STRING_CST)
4724 /* The following cases are about aggregates. If we are not within a full
4725 initializer already, and there is not a CONSTRUCTOR, it means that there
4726 is a missing set of braces (that is, we are processing the case for
4727 which reshape_init exists). */
4728 if (!first_initializer_p)
4730 if (TREE_CODE (init) == CONSTRUCTOR)
4732 if (TREE_TYPE (init) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init)))
4733 /* There is no need to reshape pointer-to-member function
4734 initializers, as they are always constructed correctly
4735 by the front end. */
4737 else if (COMPOUND_LITERAL_P (init))
4738 /* For a nested compound literal, there is no need to reshape since
4739 brace elision is not allowed. Even if we decided to allow it,
4740 we should add a call to reshape_init in finish_compound_literal,
4741 before calling digest_init, so changing this code would still
4742 not be necessary. */
4743 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init));
4747 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
4748 return reshape_init (type, init);
4752 warning (OPT_Wmissing_braces, "missing braces around initializer for %qT",
4756 /* Dispatch to specialized routines. */
4757 if (CLASS_TYPE_P (type))
4758 return reshape_init_class (type, d, first_initializer_p);
4759 else if (TREE_CODE (type) == ARRAY_TYPE)
4760 return reshape_init_array (type, d);
4761 else if (TREE_CODE (type) == VECTOR_TYPE)
4762 return reshape_init_vector (type, d);
4767 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
4768 brace-enclosed aggregate initializer.
4770 INIT is the CONSTRUCTOR containing the list of initializers describing
4771 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
4772 It may not presently match the shape of the TYPE; for example:
4774 struct S { int a; int b; };
4775 struct S a[] = { 1, 2, 3, 4 };
4777 Here INIT will hold a VEC of four elements, rather than a
4778 VEC of two elements, each itself a VEC of two elements. This
4779 routine transforms INIT from the former form into the latter. The
4780 revised CONSTRUCTOR node is returned. */
4783 reshape_init (tree type, tree init)
4785 VEC(constructor_elt, gc) *v;
4789 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
4791 v = CONSTRUCTOR_ELTS (init);
4793 /* An empty constructor does not need reshaping, and it is always a valid
4795 if (VEC_empty (constructor_elt, v))
4798 /* Recurse on this CONSTRUCTOR. */
4799 d.cur = VEC_index (constructor_elt, v, 0);
4800 d.end = d.cur + VEC_length (constructor_elt, v);
4802 new_init = reshape_init_r (type, &d, true);
4803 if (new_init == error_mark_node)
4804 return error_mark_node;
4806 /* Make sure all the element of the constructor were used. Otherwise,
4807 issue an error about exceeding initializers. */
4809 error ("too many initializers for %qT", type);
4814 /* Verify INIT (the initializer for DECL), and record the
4815 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
4816 grok_reference_init.
4818 If the return value is non-NULL, it is an expression that must be
4819 evaluated dynamically to initialize DECL. */
4822 check_initializer (tree decl, tree init, int flags, tree *cleanup)
4824 tree type = TREE_TYPE (decl);
4825 tree init_code = NULL;
4827 /* Things that are going to be initialized need to have complete
4829 TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
4831 if (type == error_mark_node)
4832 /* We will have already complained. */
4835 if (TREE_CODE (type) == ARRAY_TYPE)
4837 tree element_type = TREE_TYPE (type);
4839 /* The array type itself need not be complete, because the
4840 initializer may tell us how many elements are in the array.
4841 But, the elements of the array must be complete. */
4842 if (!COMPLETE_TYPE_P (complete_type (element_type)))
4844 error ("elements of array %q#D have incomplete type", decl);
4847 /* It is not valid to initialize an a VLA. */
4849 && ((COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
4850 || !TREE_CONSTANT (TYPE_SIZE (element_type))))
4852 error ("variable-sized object %qD may not be initialized", decl);
4856 else if (!COMPLETE_TYPE_P (type))
4858 error ("%qD has incomplete type", decl);
4859 TREE_TYPE (decl) = error_mark_node;
4863 /* There is no way to make a variable-sized class type in GNU C++. */
4864 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type)));
4866 if (!CP_AGGREGATE_TYPE_P (type)
4867 && init && BRACE_ENCLOSED_INITIALIZER_P (init)
4868 && VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init)) != 1)
4870 error ("scalar object %qD requires one element in initializer", decl);
4871 TREE_TYPE (decl) = error_mark_node;
4875 if (TREE_CODE (decl) == CONST_DECL)
4877 gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);
4879 DECL_INITIAL (decl) = init;
4881 gcc_assert (init != NULL_TREE);
4884 else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
4885 init = grok_reference_init (decl, type, init, cleanup);
4888 /* Do not reshape constructors of vectors (they don't need to be
4890 if (TREE_CODE (init) == CONSTRUCTOR
4891 && !COMPOUND_LITERAL_P (init)
4892 && !TREE_TYPE (init)) /* ptrmemfunc */
4894 init = reshape_init (type, init);
4896 if ((*targetm.vector_opaque_p) (type))
4898 error ("opaque vector types cannot be initialized");
4899 init = error_mark_node;
4903 /* If DECL has an array type without a specific bound, deduce the
4904 array size from the initializer. */
4905 maybe_deduce_size_from_array_init (decl, init);
4906 type = TREE_TYPE (decl);
4907 if (type == error_mark_node)
4910 if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type))
4912 if (TREE_CODE (type) == ARRAY_TYPE)
4913 goto initialize_aggr;
4914 else if (TREE_CODE (init) == CONSTRUCTOR)
4916 if (TYPE_NON_AGGREGATE_CLASS (type))
4918 error ("%qD must be initialized by constructor, "
4921 init = error_mark_node;
4924 goto dont_use_constructor;
4928 int saved_stmts_are_full_exprs_p;
4931 saved_stmts_are_full_exprs_p = 0;
4932 if (building_stmt_tree ())
4934 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
4935 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
4937 init = build_aggr_init (decl, init, flags);
4938 if (building_stmt_tree ())
4939 current_stmt_tree ()->stmts_are_full_exprs_p =
4940 saved_stmts_are_full_exprs_p;
4946 dont_use_constructor:
4947 if (TREE_CODE (init) != TREE_VEC)
4949 init_code = store_init_value (decl, init);
4950 if (pedantic && TREE_CODE (type) == ARRAY_TYPE
4951 && DECL_INITIAL (decl)
4952 && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST
4953 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl)))
4954 warning (0, "array %qD initialized by parenthesized string literal %qE",
4955 decl, DECL_INITIAL (decl));
4960 else if (DECL_EXTERNAL (decl))
4962 else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
4963 goto initialize_aggr;
4964 else if (IS_AGGR_TYPE (type))
4966 tree core_type = strip_array_types (type);
4968 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
4969 error ("structure %qD with uninitialized const members", decl);
4970 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
4971 error ("structure %qD with uninitialized reference members", decl);
4973 check_for_uninitialized_const_var (decl);
4976 check_for_uninitialized_const_var (decl);
4978 if (init && init != error_mark_node)
4979 init_code = build2 (INIT_EXPR, type, decl, init);
4984 /* If DECL is not a local variable, give it RTL. */
4987 make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
4989 int toplev = toplevel_bindings_p ();
4991 const char *filename;
4993 /* Set the DECL_ASSEMBLER_NAME for the object. */
4996 /* The `register' keyword, when used together with an
4997 asm-specification, indicates that the variable should be
4998 placed in a particular register. */
4999 if (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
5001 set_user_assembler_name (decl, asmspec);
5002 DECL_HARD_REGISTER (decl) = 1;
5006 if (TREE_CODE (decl) == FUNCTION_DECL
5007 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
5008 set_builtin_user_assembler_name (decl, asmspec);
5009 set_user_assembler_name (decl, asmspec);
5013 /* Handle non-variables up front. */
5014 if (TREE_CODE (decl) != VAR_DECL)
5016 rest_of_decl_compilation (decl, toplev, at_eof);
5020 /* If we see a class member here, it should be a static data
5022 if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
5024 gcc_assert (TREE_STATIC (decl));
5025 /* APPLE LOCAL begin templated static data 6298605 */
5026 /* An in-class declaration of a static data member should be
5027 external if the decl is accessible from outside this
5028 translation unit (eg something not in an anonymous
5029 namespace); it is only a declaration, and not a
5031 if (init == NULL_TREE && TREE_PUBLIC (decl))
5032 gcc_assert (DECL_EXTERNAL (decl));
5033 /* APPLE LOCAL end templated static data 6298605 */
5036 /* We don't create any RTL for local variables. */
5037 if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
5040 /* We defer emission of local statics until the corresponding
5041 DECL_EXPR is expanded. */
5042 defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
5044 /* We try to defer namespace-scope static constants so that they are
5045 not emitted into the object file unnecessarily. */
5046 filename = input_filename;
5047 if (!DECL_VIRTUAL_P (decl)
5048 && TREE_READONLY (decl)
5049 && DECL_INITIAL (decl) != NULL_TREE
5050 && DECL_INITIAL (decl) != error_mark_node
5052 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
5054 && !TREE_PUBLIC (decl))
5056 /* Fool with the linkage of static consts according to #pragma
5058 struct c_fileinfo *finfo = get_fileinfo (filename);
5059 if (!finfo->interface_unknown && !TREE_PUBLIC (decl))
5061 TREE_PUBLIC (decl) = 1;
5062 DECL_EXTERNAL (decl) = finfo->interface_only;
5067 /* Likewise for template instantiations. */
5068 else if (DECL_LANG_SPECIFIC (decl)
5069 && DECL_IMPLICIT_INSTANTIATION (decl))
5072 /* If we're not deferring, go ahead and assemble the variable. */
5074 rest_of_decl_compilation (decl, toplev, at_eof);
5077 /* Generate code to initialize DECL (a local variable). */
5080 initialize_local_var (tree decl, tree init)
5082 tree type = TREE_TYPE (decl);
5085 gcc_assert (TREE_CODE (decl) == VAR_DECL
5086 || TREE_CODE (decl) == RESULT_DECL);
5087 gcc_assert (!TREE_STATIC (decl));
5089 if (DECL_SIZE (decl) == NULL_TREE)
5091 /* If we used it already as memory, it must stay in memory. */
5092 DECL_INITIAL (decl) = NULL_TREE;
5093 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
5096 if (DECL_SIZE (decl) && type != error_mark_node)
5100 /* Compute and store the initial value. */
5101 already_used = TREE_USED (decl) || TREE_USED (type);
5103 /* Perform the initialization. */
5106 int saved_stmts_are_full_exprs_p;
5108 gcc_assert (building_stmt_tree ());
5109 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
5110 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
5111 finish_expr_stmt (init);
5112 current_stmt_tree ()->stmts_are_full_exprs_p =
5113 saved_stmts_are_full_exprs_p;
5116 /* Set this to 0 so we can tell whether an aggregate which was
5117 initialized was ever used. Don't do this if it has a
5118 destructor, so we don't complain about the 'resource
5119 allocation is initialization' idiom. Now set
5120 attribute((unused)) on types so decls of that type will be
5121 marked used. (see TREE_USED, above.) */
5122 if (TYPE_NEEDS_CONSTRUCTING (type)
5124 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
5125 && DECL_NAME (decl))
5126 TREE_USED (decl) = 0;
5127 else if (already_used)
5128 TREE_USED (decl) = 1;
5131 /* Generate a cleanup, if necessary. */
5132 cleanup = cxx_maybe_build_cleanup (decl);
5133 if (DECL_SIZE (decl) && cleanup)
5134 finish_decl_cleanup (decl, cleanup);
5137 /* DECL is a VAR_DECL for a compiler-generated variable with static
5138 storage duration (like a virtual table) whose initializer is a
5139 compile-time constant. INIT must be either a TREE_LIST of values,
5140 or a CONSTRUCTOR. Initialize the variable and provide it to the
5144 initialize_artificial_var (tree decl, tree init)
5146 gcc_assert (DECL_ARTIFICIAL (decl));
5147 if (TREE_CODE (init) == TREE_LIST)
5148 init = build_constructor_from_list (NULL_TREE, init);
5149 gcc_assert (TREE_CODE (init) == CONSTRUCTOR);
5150 DECL_INITIAL (decl) = init;
5151 DECL_INITIALIZED_P (decl) = 1;
5152 determine_visibility (decl);
5153 layout_var_decl (decl);
5154 maybe_commonize_var (decl);
5155 make_rtl_for_nonlocal_decl (decl, init, /*asmspec=*/NULL);
5158 /* INIT is the initializer for a variable, as represented by the
5159 parser. Returns true iff INIT is value-dependent. */
5162 value_dependent_init_p (tree init)
5164 if (TREE_CODE (init) == TREE_LIST)
5165 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
5166 return any_value_dependent_elements_p (init);
5167 else if (TREE_CODE (init) == CONSTRUCTOR)
5168 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
5170 VEC(constructor_elt, gc) *elts;
5174 elts = CONSTRUCTOR_ELTS (init);
5175 nelts = VEC_length (constructor_elt, elts);
5176 for (i = 0; i < nelts; ++i)
5177 if (value_dependent_init_p (VEC_index (constructor_elt,
5182 /* It must be a simple expression, e.g., int i = 3; */
5183 return value_dependent_expression_p (init);
5188 /* APPLE LOCAL begin blocks 6040305 (cr) */
5189 #define BLOCK_ALIGN_MAX 18
5190 static tree block_byref_id_object_copy[BLOCK_BYREF_CURRENT_MAX*(BLOCK_ALIGN_MAX+1)];
5191 static tree block_byref_id_object_dispose[BLOCK_BYREF_CURRENT_MAX*(BLOCK_ALIGN_MAX+1)];
5194 This routine builds:
5196 void __Block_byref_id_object_copy(struct Block_byref_id_object *dst,
5197 struct Block_byref_id_object *src) {
5198 _Block_object_assign (&_dest->object, _src->object, BLOCK_FIELD_IS_OBJECT[|BLOCK_FIELD_IS_WEAK]) // objects
5199 _Block_object_assign(&_dest->object, _src->object, BLOCK_FIELD_IS_BLOCK[|BLOCK_FIELD_IS_WEAK]) // blocks
5202 synth_block_byref_id_object_copy_func (int flag, int kind)
5205 tree dst_arg, src_arg;
5206 tree dst_obj, src_obj;
5209 gcc_assert (block_byref_id_object_copy[kind]);
5210 /* Set up: (void* _dest, void*_src) parameters. */
5211 dst_arg = build_decl (PARM_DECL, get_identifier ("_dst"),
5213 TREE_USED (dst_arg) = 1;
5214 DECL_ARG_TYPE (dst_arg) = ptr_type_node;
5215 src_arg = build_decl (PARM_DECL, get_identifier ("_src"),
5217 TREE_USED (src_arg) = 1;
5218 DECL_ARG_TYPE (src_arg) = ptr_type_node;
5219 /* arg_info = xcalloc (1, sizeof (struct c_arg_info)); */
5220 TREE_CHAIN (dst_arg) = src_arg;
5221 /* arg_info->parms = dst_arg; */
5222 /* arg_info->types = tree_cons (NULL_TREE, ptr_type_node,
5223 tree_cons (NULL_TREE,
5226 DECL_ARGUMENTS (block_byref_id_object_copy[kind]) = dst_arg;
5227 /* function header synthesis. */
5228 push_function_context ();
5229 /* start_block_helper_function (block_byref_id_object_copy[kind], true); */
5230 /* store_parm_decls_from (arg_info); */
5231 start_preparsed_function (block_byref_id_object_copy[kind],
5235 /* Body of the function. */
5236 stmt = begin_compound_stmt (BCS_FN_BODY);
5237 /* Build dst->object */
5238 dst_obj = build_indirect_object_id_exp (dst_arg);
5241 /* src_obj is: _src->object. */
5242 src_obj = build_indirect_object_id_exp (src_arg);
5243 /* APPLE LOCAL begin radar 6180456 */
5244 /* _Block_object_assign (&_dest->object, _src->object, BLOCK_FIELD_IS_OBJECT) or:
5245 _Block_object_assign (&_dest->object, _src->object, BLOCK_FIELD_IS_BLOCK) */
5246 /* APPLE LOCAL begin radar 6573923 */
5247 /* Also add the new flag when calling _Block_object_dispose
5248 from byref dispose helper. */
5249 flag |= BLOCK_BYREF_CALLER;
5250 /* APPLE LOCAL end radar 6573923 */
5251 call_exp = build_block_object_assign_call_exp (build_fold_addr_expr (dst_obj), src_obj, flag);
5252 add_stmt (call_exp);
5253 /* APPLE LOCAL end radar 6180456 */
5255 finish_compound_stmt (stmt);
5256 /* APPLE LOCAL radar 6169580 */
5257 finish_function (4);
5258 pop_function_context ();
5262 This routine builds:
5264 void __Block_byref_id_object_dispose(struct Block_byref_id_object *_src) {
5265 _Block_object_dispose(_src->object, BLOCK_FIELD_IS_OBJECT[|BLOCK_FIELD_IS_WEAK]) // objects
5266 _Block_object_dispose(_src->object, BLOCK_FIELD_IS_BLOCK[|BLOCK_FIELD_IS_WEAK]) // blocks
5268 static void synth_block_byref_id_object_dispose_func (int flag, int kind)
5271 tree src_arg, src_obj, rel_exp;
5273 gcc_assert (block_byref_id_object_dispose[kind]);
5274 /* Set up: (void *_src) parameter. */
5275 src_arg = build_decl (PARM_DECL, get_identifier ("_src"),
5277 TREE_USED (src_arg) = 1;
5278 DECL_ARG_TYPE (src_arg) = ptr_type_node;
5279 /* arg_info = xcalloc (1, sizeof (struct c_arg_info));
5280 arg_info->parms = src_arg;
5281 arg_info->types = tree_cons (NULL_TREE, ptr_type_node,
5283 DECL_ARGUMENTS (block_byref_id_object_dispose[kind]) = src_arg;
5284 /* function header synthesis. */
5285 push_function_context ();
5286 /* start_block_helper_function (block_byref_id_object_dispose[kind], true); */
5287 /* store_parm_decls_from (arg_info); */
5288 start_preparsed_function (block_byref_id_object_dispose[kind],
5292 /* Body of the function. */
5293 stmt = begin_compound_stmt (BCS_FN_BODY);
5294 src_obj = build_indirect_object_id_exp (src_arg);
5296 /* APPLE LOCAL begin radar 6180456 */
5297 /* _Block_object_dispose(_src->object, BLOCK_FIELD_IS_OBJECT) or:
5298 _Block_object_dispose(_src->object, BLOCK_FIELD_IS_BLOCK) */
5299 /* APPLE LOCAL begin radar 6573923 */
5300 /* Also add the new flag when calling _Block_object_dispose
5301 from byref dispose helper. */
5302 flag |= BLOCK_BYREF_CALLER;
5303 /* APPLE LOCAL end radar 6573923 */
5304 rel_exp = build_block_object_dispose_call_exp (src_obj, flag);
5305 /* APPLE LOCAL end radar 6180456 */
5308 finish_compound_stmt (stmt);
5309 /* APPLE LOCAL radar 6169580 */
5310 finish_function (4);
5311 pop_function_context ();
5315 block_start_struct (tree name)
5318 /* The idea here is to mimic the actions that the C++ parser takes when
5319 constructing 'extern "C" struct NAME {'. */
5320 push_lang_context (lang_name_c);
5322 s = xref_tag (record_type, name, ts_global, 0);
5323 CLASSTYPE_DECLARED_CLASS (s) = 0; /* this is a 'struct', not a 'class'. */
5324 xref_basetypes (s, NULL_TREE); /* no base classes here! */
5326 return begin_class_definition (s, NULL_TREE);
5330 block_finish_struct (tree t, tree fieldlist)
5332 tree field, next_field;
5334 for (field = fieldlist; field; field = next_field)
5336 next_field = TREE_CHAIN (field); /* insert one field at a time; */
5337 TREE_CHAIN (field) = NULL_TREE; /* otherwise, grokfield croaks. */
5338 finish_member_declaration (field);
5340 t = finish_struct (t, NULL);
5341 pop_lang_context ();
5346 /* new_block_byref_decl - This routine changes a 'typex x' declared variable into:
5348 struct __Block_byref_x {
5349 // APPLE LOCAL radar 6244520
5350 void *__isa; // NULL for everything except __weak pointers
5351 struct Block_byref_x *__forwarding;
5354 void *__ByrefKeepFuncPtr; // Only if variable is __block ObjC object
5355 void *__ByrefDestroyFuncPtr; // Only if variable is __block ObjC object
5361 new_block_byref_decl (tree decl)
5363 static int unique_count;
5364 /* APPLE LOCAL radar 5847976 */
5365 int save_flag_objc_gc;
5366 tree Block_byref_type;
5367 tree fields = NULL_TREE, field;
5368 const char *prefix = "__Block_byref_";
5369 char *string = (char*)alloca (strlen (IDENTIFIER_POINTER (DECL_NAME (decl))) +
5370 strlen (prefix) + 8 /* to hold the count */);
5372 sprintf (string, "%s%d_%s", prefix, ++unique_count,
5373 IDENTIFIER_POINTER (DECL_NAME (decl)));
5375 push_to_top_level ();
5377 /* Block_byref_type = start_struct (RECORD_TYPE, get_identifier (string)); */
5378 Block_byref_type = block_start_struct (get_identifier (string));
5380 /* APPLE LOCAL begin radar 6244520 */
5382 field = build_decl (FIELD_DECL, get_identifier ("__isa"), ptr_type_node);
5384 /* APPLE LOCAL end radar 6244520 */
5386 /* struct Block_byref_x *__forwarding; */
5387 field = build_decl (FIELD_DECL, get_identifier ("__forwarding"),
5388 build_pointer_type (Block_byref_type));
5389 /* APPLE LOCAL radar 6244520 */
5390 chainon (fields, field);
5392 /* int32_t __flags; */
5393 field = build_decl (FIELD_DECL, get_identifier ("__flags"),
5394 unsigned_type_node);
5395 chainon (fields, field);
5397 /* int32_t __size; */
5398 field = build_decl (FIELD_DECL, get_identifier ("__size"),
5399 unsigned_type_node);
5400 chainon (fields, field);
5402 if (COPYABLE_BYREF_LOCAL_NONPOD (decl))
5404 /* void *__ByrefKeepFuncPtr; */
5405 field = build_decl (FIELD_DECL, get_identifier ("__ByrefKeepFuncPtr"),
5407 chainon (fields, field);
5409 /* void *__ByrefDestroyFuncPtr; */
5410 field = build_decl (FIELD_DECL, get_identifier ("__ByrefDestroyFuncPtr"),
5412 chainon (fields, field);
5416 field = build_decl (FIELD_DECL, DECL_NAME (decl), TREE_TYPE (decl));
5417 chainon (fields, field);
5419 /* APPLE LOCAL begin radar 5847976 */
5420 /* Hack so we don't issue warning on a field_decl having __weak attribute */
5421 save_flag_objc_gc = flag_objc_gc;
5423 /* finish_struct (Block_byref_type, field_decl_chain, NULL_TREE); */
5424 block_finish_struct (Block_byref_type, fields);
5425 flag_objc_gc = save_flag_objc_gc;
5426 /* APPLE LOCAL end radar 5847976 */
5427 pop_from_top_level ();
5429 TREE_TYPE (decl) = Block_byref_type;
5430 /* Force layout_decl to recompute these fields. */
5431 DECL_SIZE (decl) = DECL_SIZE_UNIT (decl) = 0;
5432 layout_decl (decl, 0);
5436 /* init_byref_decl - This routine builds the initializer for the __Block_byref_x
5437 type in the form of:
5438 { NULL, &x, 0, sizeof(struct __Block_byref_x), initializer-expr};
5441 { NULL, &x, 0, sizeof(struct __Block_byref_x)};
5442 when INIT is NULL_TREE
5444 For __block ObjC objects, it also adds "byref_keep" and "byref_destroy"
5445 Funtion pointers. So the most general initializers would be:
5447 { NULL, &x, 0, sizeof(struct __Block_byref_x), &byref_keep, &byref_destroy,
5451 init_byref_decl (tree decl, tree init, int flag)
5454 tree block_byref_type = TREE_TYPE (decl);
5455 int size = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (block_byref_type));
5459 if (COPYABLE_BYREF_LOCAL_NONPOD (decl))
5460 flags = BLOCK_HAS_COPY_DISPOSE;
5462 fields = TYPE_FIELDS (block_byref_type);
5463 /* APPLE LOCAL begin radar 6244520 */
5464 initlist = tree_cons (fields, fold_convert (ptr_type_node, ((flag & BLOCK_FIELD_IS_WEAK) != 0) ? integer_one_node
5465 : integer_zero_node),
5467 fields = TREE_CHAIN (fields);
5469 initlist = tree_cons (fields,
5470 build_unary_op (ADDR_EXPR, decl, 0), initlist);
5471 /* APPLE LOCAL end radar 6244520 */
5472 fields = TREE_CHAIN (fields);
5474 initlist = tree_cons (fields, build_int_cst (TREE_TYPE (fields), flags),
5476 fields = TREE_CHAIN (fields);
5477 initlist = tree_cons (fields, build_int_cst (TREE_TYPE (fields), size),
5479 fields = TREE_CHAIN (fields);
5481 if (COPYABLE_BYREF_LOCAL_NONPOD (decl))
5484 int align = exact_log2 ((DECL_ALIGN (decl)+TYPE_ALIGN (ptr_type_node)-1) / TYPE_ALIGN (ptr_type_node));
5486 if (align == -1 || align > BLOCK_ALIGN_MAX) {
5487 error ("invalid alignment for __block variable");
5490 kind = align*BLOCK_BYREF_CURRENT_MAX + flag;
5491 /* Add &__Block_byref_id_object_copy, &__Block_byref_id_object_dispose
5493 if (!block_byref_id_object_copy[kind])
5496 push_lang_context (lang_name_c);
5497 /* Build a void __Block_byref_id_object_copy(void*, void*) type. */
5499 build_function_type (void_type_node,
5500 tree_cons (NULL_TREE, ptr_type_node,
5501 tree_cons (NULL_TREE, ptr_type_node,
5503 sprintf (name, "__Block_byref_id_object_copy%d", kind);
5504 block_byref_id_object_copy[kind] = build_helper_func_decl (get_identifier (name),
5506 DECL_CONTEXT (block_byref_id_object_copy[kind]) = current_function_decl;
5507 /* Synthesize function definition. */
5508 synth_block_byref_id_object_copy_func (flag, kind);
5509 pop_lang_context ();
5511 initlist = tree_cons (fields,
5512 build_fold_addr_expr (block_byref_id_object_copy[kind]),
5514 fields = TREE_CHAIN (fields);
5516 if (!block_byref_id_object_dispose[kind])
5519 push_lang_context (lang_name_c);
5520 /* Synthesize void __Block_byref_id_object_dispose (void*) and
5521 build &__Block_byref_id_object_dispose. */
5523 build_function_type (void_type_node,
5524 tree_cons (NULL_TREE, ptr_type_node, void_list_node));
5525 sprintf (name, "__Block_byref_id_object_dispose%d", kind);
5526 block_byref_id_object_dispose[kind] = build_helper_func_decl (get_identifier (name),
5528 DECL_CONTEXT (block_byref_id_object_dispose[kind]) = current_function_decl;
5529 /* Synthesize function definition. */
5530 synth_block_byref_id_object_dispose_func (flag, kind);
5531 pop_lang_context ();
5533 initlist = tree_cons (fields,
5534 build_fold_addr_expr (block_byref_id_object_dispose[kind]),
5536 fields = TREE_CHAIN (fields);
5541 init = digest_init (TREE_TYPE (fields), init);
5542 initlist = tree_cons (fields, init, initlist);
5544 init = build_constructor_from_list (block_byref_type, nreverse (initlist));
5547 /* APPLE LOCAL end blocks 6040305 (cr) */
5549 /* Finish processing of a declaration;
5550 install its line number and initial value.
5551 If the length of an array type is not known before,
5552 it must be determined now, from the initial value, or it is an error.
5554 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
5555 true, then INIT is an integral constant expression.
5557 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
5558 if the (init) syntax was used. */
5561 cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
5562 tree asmspec_tree, int flags)
5566 const char *asmspec = NULL;
5567 int was_readonly = 0;
5568 bool var_definition_p = false;
5569 int saved_processing_template_decl;
5571 if (decl == error_mark_node)
5576 error ("assignment (not initialization) in declaration");
5580 gcc_assert (TREE_CODE (decl) != RESULT_DECL);
5581 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
5582 gcc_assert (TREE_CODE (decl) != PARM_DECL);
5584 type = TREE_TYPE (decl);
5585 if (type == error_mark_node)
5588 /* Assume no cleanup is required. */
5589 cleanup = NULL_TREE;
5590 saved_processing_template_decl = processing_template_decl;
5592 /* If a name was specified, get the string. */
5593 if (global_scope_p (current_binding_level))
5594 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
5595 if (asmspec_tree && asmspec_tree != error_mark_node)
5596 asmspec = TREE_STRING_POINTER (asmspec_tree);
5598 if (current_class_type
5599 && CP_DECL_CONTEXT (decl) == current_class_type
5600 && TYPE_BEING_DEFINED (current_class_type)
5601 && (DECL_INITIAL (decl) || init))
5602 DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
5604 if (processing_template_decl)
5606 bool type_dependent_p;
5608 /* Add this declaration to the statement-tree. */
5609 if (at_function_scope_p ())
5610 add_decl_expr (decl);
5612 type_dependent_p = dependent_type_p (type);
5614 if (init && init_const_expr_p)
5616 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
5617 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl))
5618 TREE_CONSTANT (decl) = 1;
5621 /* Generally, initializers in templates are expanded when the
5622 template is instantiated. But, if DECL is an integral
5623 constant static data member, then it can be used in future
5624 integral constant expressions, and its value must be
5627 && DECL_CLASS_SCOPE_P (decl)
5628 && DECL_INTEGRAL_CONSTANT_VAR_P (decl)
5629 && !type_dependent_p
5630 && !value_dependent_init_p (init)))
5633 DECL_INITIAL (decl) = init;
5634 if (TREE_CODE (decl) == VAR_DECL
5635 && !DECL_PRETTY_FUNCTION_P (decl)
5636 && !type_dependent_p)
5637 maybe_deduce_size_from_array_init (decl, init);
5641 init = fold_non_dependent_expr (init);
5642 processing_template_decl = 0;
5645 /* Take care of TYPE_DECLs up front. */
5646 if (TREE_CODE (decl) == TYPE_DECL)
5648 if (type != error_mark_node
5649 && IS_AGGR_TYPE (type) && DECL_NAME (decl))
5651 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
5652 warning (0, "shadowing previous type declaration of %q#D", decl);
5653 set_identifier_type_value (DECL_NAME (decl), decl);
5656 /* If we have installed this as the canonical typedef for this
5657 type, and that type has not been defined yet, delay emitting
5658 the debug information for it, as we will emit it later. */
5659 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
5660 && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
5661 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
5663 rest_of_decl_compilation (decl, DECL_CONTEXT (decl) == NULL_TREE,
5668 /* A reference will be modified here, as it is initialized. */
5669 if (! DECL_EXTERNAL (decl)
5670 && TREE_READONLY (decl)
5671 && TREE_CODE (type) == REFERENCE_TYPE)
5674 TREE_READONLY (decl) = 0;
5677 if (TREE_CODE (decl) == VAR_DECL)
5679 /* Only PODs can have thread-local storage. Other types may require
5680 various kinds of non-trivial initialization. */
5681 if (DECL_THREAD_LOCAL_P (decl) && !pod_type_p (TREE_TYPE (decl)))
5682 error ("%qD cannot be thread-local because it has non-POD type %qT",
5683 decl, TREE_TYPE (decl));
5684 /* APPLE LOCAL begin blocks 6040305 (cq) */
5685 if (COPYABLE_BYREF_LOCAL_VAR (decl)) {
5686 if (DECL_EXTERNAL (decl) || TREE_STATIC (decl))
5688 error ("__block attribute on %q+D not allowed, only allowed on local variables", decl);
5689 COPYABLE_BYREF_LOCAL_VAR (decl) = 0;
5690 COPYABLE_BYREF_LOCAL_NONPOD (decl) = 0;
5693 /* APPLE LOCAL end blocks 6040305 (cq) */
5695 /* If this is a local variable that will need a mangled name,
5696 register it now. We must do this before processing the
5697 initializer for the variable, since the initialization might
5698 require a guard variable, and since the mangled name of the
5699 guard variable will depend on the mangled name of this
5701 if (!processing_template_decl
5702 && DECL_FUNCTION_SCOPE_P (decl)
5703 && TREE_STATIC (decl)
5704 && !DECL_ARTIFICIAL (decl))
5705 push_local_name (decl);
5706 /* Convert the initializer to the type of DECL, if we have not
5707 already initialized DECL. */
5708 if (!DECL_INITIALIZED_P (decl)
5709 /* If !DECL_EXTERNAL then DECL is being defined. In the
5710 case of a static data member initialized inside the
5711 class-specifier, there can be an initializer even if DECL
5712 is *not* defined. */
5713 && (!DECL_EXTERNAL (decl) || init))
5717 DECL_NONTRIVIALLY_INITIALIZED_P (decl) = 1;
5718 if (init_const_expr_p)
5720 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
5721 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl))
5722 TREE_CONSTANT (decl) = 1;
5725 init = check_initializer (decl, init, flags, &cleanup);
5726 /* Thread-local storage cannot be dynamically initialized. */
5727 if (DECL_THREAD_LOCAL_P (decl) && init)
5729 error ("%qD is thread-local and so cannot be dynamically "
5730 "initialized", decl);
5734 /* Check that the initializer for a static data member was a
5735 constant. Although we check in the parser that the
5736 initializer is an integral constant expression, we do not
5737 simplify division-by-zero at the point at which it
5738 occurs. Therefore, in:
5740 struct S { static const int i = 7 / 0; };
5742 we issue an error at this point. It would
5743 probably be better to forbid division by zero in
5744 integral constant expressions. */
5745 if (DECL_EXTERNAL (decl) && init)
5747 error ("%qD cannot be initialized by a non-constant expression"
5748 " when being declared", decl);
5749 DECL_INITIALIZED_IN_CLASS_P (decl) = 0;
5757 The memory occupied by any object of static storage
5758 duration is zero-initialized at program startup before
5759 any other initialization takes place.
5761 We cannot create an appropriate initializer until after
5762 the type of DECL is finalized. If DECL_INITIAL is set,
5763 then the DECL is statically initialized, and any
5764 necessary zero-initialization has already been performed. */
5765 if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
5766 DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
5767 /*nelts=*/NULL_TREE,
5768 /*static_storage_p=*/true);
5769 /* Remember that the initialization for this variable has
5771 DECL_INITIALIZED_P (decl) = 1;
5772 /* This declaration is the definition of this variable,
5773 unless we are initializing a static data member within
5774 the class specifier. */
5775 if (!DECL_EXTERNAL (decl))
5776 var_definition_p = true;
5778 /* If the variable has an array type, lay out the type, even if
5779 there is no initializer. It is valid to index through the
5780 array, and we must get TYPE_ALIGN set correctly on the array
5782 else if (TREE_CODE (type) == ARRAY_TYPE)
5786 /* Add this declaration to the statement-tree. This needs to happen
5787 after the call to check_initializer so that the DECL_EXPR for a
5788 reference temp is added before the DECL_EXPR for the reference itself. */
5789 if (at_function_scope_p ())
5790 add_decl_expr (decl);
5792 /* Let the middle end know about variables and functions -- but not
5793 static data members in uninstantiated class templates. */
5794 if (!saved_processing_template_decl
5795 && (TREE_CODE (decl) == VAR_DECL
5796 || TREE_CODE (decl) == FUNCTION_DECL))
5798 if (TREE_CODE (decl) == VAR_DECL)
5800 layout_var_decl (decl);
5801 maybe_commonize_var (decl);
5804 make_rtl_for_nonlocal_decl (decl, init, asmspec);
5806 /* Check for abstractness of the type. Notice that there is no
5807 need to strip array types here since the check for those types
5808 is already done within create_array_type_for_decl. */
5809 if (TREE_CODE (type) == FUNCTION_TYPE
5810 || TREE_CODE (type) == METHOD_TYPE)
5811 abstract_virtuals_error (decl, TREE_TYPE (type));
5813 abstract_virtuals_error (decl, type);
5815 /* This needs to happen after the linkage is set. */
5816 determine_visibility (decl);
5818 if (TREE_CODE (decl) == FUNCTION_DECL
5819 || TREE_TYPE (decl) == error_mark_node)
5820 /* No initialization required. */
5822 else if (DECL_EXTERNAL (decl)
5823 && ! (DECL_LANG_SPECIFIC (decl)
5824 && DECL_NOT_REALLY_EXTERN (decl)))
5827 DECL_INITIAL (decl) = init;
5831 /* A variable definition. */
5832 if (DECL_FUNCTION_SCOPE_P (decl))
5834 /* Initialize the local variable. */
5835 if (processing_template_decl)
5836 DECL_INITIAL (decl) = init;
5837 else if (!TREE_STATIC (decl))
5838 initialize_local_var (decl, init);
5841 /* If a variable is defined, and then a subsequent
5842 definition with external linkage is encountered, we will
5843 get here twice for the same variable. We want to avoid
5844 calling expand_static_init more than once. For variables
5845 that are not static data members, we can call
5846 expand_static_init only when we actually process the
5847 initializer. It is not legal to redeclare a static data
5848 member, so this issue does not arise in that case. */
5849 if (var_definition_p && TREE_STATIC (decl))
5851 /* If a TREE_READONLY variable needs initialization
5852 at runtime, it is no longer readonly and we need to
5853 avoid MEM_READONLY_P being set on RTL created for it. */
5856 if (TREE_READONLY (decl))
5857 TREE_READONLY (decl) = 0;
5860 expand_static_init (decl, init);
5865 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
5866 reference, insert it in the statement-tree now. */
5868 push_cleanup (decl, cleanup, false);
5871 processing_template_decl = saved_processing_template_decl;
5874 TREE_READONLY (decl) = 1;
5876 /* If this was marked 'used', be sure it will be output. */
5877 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
5878 mark_decl_referenced (decl);
5881 /* This is here for a midend callback from c-common.c. */
5884 finish_decl (tree decl, tree init, tree asmspec_tree)
5886 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, asmspec_tree, 0);
5889 /* Returns a declaration for a VAR_DECL as if:
5891 extern "C" TYPE NAME;
5893 had been seen. Used to create compiler-generated global
5897 declare_global_var (tree name, tree type)
5901 push_to_top_level ();
5902 decl = build_decl (VAR_DECL, name, type);
5903 TREE_PUBLIC (decl) = 1;
5904 DECL_EXTERNAL (decl) = 1;
5905 DECL_ARTIFICIAL (decl) = 1;
5906 /* If the user has explicitly declared this variable (perhaps
5907 because the code we are compiling is part of a low-level runtime
5908 library), then it is possible that our declaration will be merged
5909 with theirs by pushdecl. */
5910 decl = pushdecl (decl);
5911 finish_decl (decl, NULL_TREE, NULL_TREE);
5912 pop_from_top_level ();
5917 /* Returns a pointer to the `atexit' function. Note that if
5918 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
5919 `__cxa_atexit' function specified in the IA64 C++ ABI. */
5922 get_atexit_node (void)
5929 bool use_aeabi_atexit;
5934 if (flag_use_cxa_atexit)
5936 /* The declaration for `__cxa_atexit' is:
5938 int __cxa_atexit (void (*)(void *), void *, void *)
5940 We build up the argument types and then then function type
5943 use_aeabi_atexit = targetm.cxx.use_aeabi_atexit ();
5944 /* First, build the pointer-to-function type for the first
5946 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5947 fn_type = build_function_type (void_type_node, arg_types);
5948 fn_ptr_type = build_pointer_type (fn_type);
5949 /* Then, build the rest of the argument types. */
5950 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5951 if (use_aeabi_atexit)
5953 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
5954 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
5958 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
5959 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
5961 /* And the final __cxa_atexit type. */
5962 fn_type = build_function_type (integer_type_node, arg_types);
5963 fn_ptr_type = build_pointer_type (fn_type);
5964 if (use_aeabi_atexit)
5965 name = "__aeabi_atexit";
5967 name = "__cxa_atexit";
5971 /* The declaration for `atexit' is:
5973 int atexit (void (*)());
5975 We build up the argument types and then then function type
5977 fn_type = build_function_type (void_type_node, void_list_node);
5978 fn_ptr_type = build_pointer_type (fn_type);
5979 arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
5980 /* Build the final atexit type. */
5981 fn_type = build_function_type (integer_type_node, arg_types);
5985 /* Now, build the function declaration. */
5986 push_lang_context (lang_name_c);
5987 atexit_fndecl = build_library_fn_ptr (name, fn_type);
5988 mark_used (atexit_fndecl);
5989 pop_lang_context ();
5990 atexit_node = decay_conversion (atexit_fndecl);
5995 /* Returns the __dso_handle VAR_DECL. */
5998 get_dso_handle_node (void)
6000 if (dso_handle_node)
6001 return dso_handle_node;
6003 /* Declare the variable. */
6004 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
6007 return dso_handle_node;
6010 /* Begin a new function with internal linkage whose job will be simply
6011 to destroy some particular variable. */
6013 static GTY(()) int start_cleanup_cnt;
6016 start_cleanup_fn (void)
6023 push_to_top_level ();
6025 /* No need to mangle this. */
6026 push_lang_context (lang_name_c);
6028 /* Build the parameter-types. */
6029 parmtypes = void_list_node;
6030 /* Functions passed to __cxa_atexit take an additional parameter.
6031 We'll just ignore it. After we implement the new calling
6032 convention for destructors, we can eliminate the use of
6033 additional cleanup functions entirely in the -fnew-abi case. */
6034 if (flag_use_cxa_atexit)
6035 parmtypes = tree_cons (NULL_TREE, ptr_type_node, parmtypes);
6036 /* Build the function type itself. */
6037 fntype = build_function_type (void_type_node, parmtypes);
6038 /* Build the name of the function. */
6039 sprintf (name, "__tcf_%d", start_cleanup_cnt++);
6040 /* Build the function declaration. */
6041 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
6042 /* It's a function with internal linkage, generated by the
6044 TREE_PUBLIC (fndecl) = 0;
6045 DECL_ARTIFICIAL (fndecl) = 1;
6046 /* Make the function `inline' so that it is only emitted if it is
6047 actually needed. It is unlikely that it will be inlined, since
6048 it is only called via a function pointer, but we avoid unnecessary
6049 emissions this way. */
6050 DECL_INLINE (fndecl) = 1;
6051 DECL_DECLARED_INLINE_P (fndecl) = 1;
6052 DECL_INTERFACE_KNOWN (fndecl) = 1;
6053 /* Build the parameter. */
6054 if (flag_use_cxa_atexit)
6058 parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
6059 DECL_CONTEXT (parmdecl) = fndecl;
6060 TREE_USED (parmdecl) = 1;
6061 DECL_ARGUMENTS (fndecl) = parmdecl;
6065 start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED);
6067 pop_lang_context ();
6069 return current_function_decl;
6072 /* Finish the cleanup function begun by start_cleanup_fn. */
6075 end_cleanup_fn (void)
6077 expand_or_defer_fn (finish_function (0));
6079 pop_from_top_level ();
6082 /* Generate code to handle the destruction of DECL, an object with
6083 static storage duration. */
6086 register_dtor_fn (tree decl)
6093 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
6094 return void_zero_node;
6096 /* Call build_cleanup before we enter the anonymous function so that
6097 any access checks will be done relative to the current scope,
6098 rather than the scope of the anonymous function. */
6099 build_cleanup (decl);
6101 /* Now start the function. */
6102 cleanup = start_cleanup_fn ();
6104 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
6105 to the original function, rather than the anonymous one. That
6106 will make the back-end think that nested functions are in use,
6107 which causes confusion. */
6109 push_deferring_access_checks (dk_no_check);
6110 fcall = build_cleanup (decl);
6111 pop_deferring_access_checks ();
6113 /* Create the body of the anonymous function. */
6114 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
6115 finish_expr_stmt (fcall);
6116 finish_compound_stmt (compound_stmt);
6119 /* Call atexit with the cleanup function. */
6120 cxx_mark_addressable (cleanup);
6121 mark_used (cleanup);
6122 cleanup = build_unary_op (ADDR_EXPR, cleanup, 0);
6123 if (flag_use_cxa_atexit)
6125 args = tree_cons (NULL_TREE,
6126 build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0),
6128 if (targetm.cxx.use_aeabi_atexit ())
6130 args = tree_cons (NULL_TREE, cleanup, args);
6131 args = tree_cons (NULL_TREE, null_pointer_node, args);
6135 args = tree_cons (NULL_TREE, null_pointer_node, args);
6136 args = tree_cons (NULL_TREE, cleanup, args);
6140 args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
6141 return build_function_call (get_atexit_node (), args);
6144 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
6145 is its initializer. Generate code to handle the construction
6146 and destruction of DECL. */
6149 expand_static_init (tree decl, tree init)
6151 gcc_assert (TREE_CODE (decl) == VAR_DECL);
6152 gcc_assert (TREE_STATIC (decl));
6154 /* Some variables require no initialization. */
6156 && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
6157 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
6160 /* APPLE LOCAL begin radar 5733674 */
6161 if (c_dialect_objc () && flag_objc_gc && init && TREE_CODE (init) == INIT_EXPR)
6163 tree result = objc_generate_write_barrier (TREE_OPERAND (init, 0),
6164 INIT_EXPR, TREE_OPERAND (init, 1));
6168 /* APPLE LOCAL end radar 5733674 */
6170 if (DECL_FUNCTION_SCOPE_P (decl))
6172 /* Emit code to perform this initialization but once. */
6173 tree if_stmt = NULL_TREE, inner_if_stmt = NULL_TREE;
6174 tree then_clause = NULL_TREE, inner_then_clause = NULL_TREE;
6175 tree guard, guard_addr, guard_addr_list;
6176 tree acquire_fn, release_fn, abort_fn;
6179 /* Emit code to perform this initialization but once. This code
6182 static <type> guard;
6183 if (!guard.first_byte) {
6184 if (__cxa_guard_acquire (&guard)) {
6187 // Do initialization.
6188 flag = true; __cxa_guard_release (&guard);
6189 // Register variable for destruction at end of program.
6191 if (!flag) __cxa_guard_abort (&guard);
6195 Note that the `flag' variable is only set to 1 *after* the
6196 initialization is complete. This ensures that an exception,
6197 thrown during the construction, will cause the variable to
6198 reinitialized when we pass through this code again, as per:
6202 If the initialization exits by throwing an exception, the
6203 initialization is not complete, so it will be tried again
6204 the next time control enters the declaration.
6206 This process should be thread-safe, too; multiple threads
6207 should not be able to initialize the variable more than
6210 /* Create the guard variable. */
6211 guard = get_guard (decl);
6213 /* This optimization isn't safe on targets with relaxed memory
6214 consistency. On such targets we force synchronization in
6215 __cxa_guard_acquire. */
6216 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
6218 /* Begin the conditional initialization. */
6219 if_stmt = begin_if_stmt ();
6220 finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
6221 then_clause = begin_compound_stmt (BCS_NO_SCOPE);
6224 if (flag_threadsafe_statics)
6226 guard_addr = build_address (guard);
6227 guard_addr_list = build_tree_list (NULL_TREE, guard_addr);
6229 acquire_fn = get_identifier ("__cxa_guard_acquire");
6230 release_fn = get_identifier ("__cxa_guard_release");
6231 abort_fn = get_identifier ("__cxa_guard_abort");
6232 if (!get_global_value_if_present (acquire_fn, &acquire_fn))
6234 tree argtypes = tree_cons (NULL_TREE, TREE_TYPE (guard_addr),
6236 tree vfntype = build_function_type (void_type_node, argtypes);
6237 acquire_fn = push_library_fn
6238 (acquire_fn, build_function_type (integer_type_node, argtypes));
6239 release_fn = push_library_fn (release_fn, vfntype);
6240 abort_fn = push_library_fn (abort_fn, vfntype);
6244 release_fn = identifier_global_value (release_fn);
6245 abort_fn = identifier_global_value (abort_fn);
6248 inner_if_stmt = begin_if_stmt ();
6249 finish_if_stmt_cond (build_call (acquire_fn, guard_addr_list),
6252 inner_then_clause = begin_compound_stmt (BCS_NO_SCOPE);
6253 begin = get_target_expr (boolean_false_node);
6254 flag = TARGET_EXPR_SLOT (begin);
6256 TARGET_EXPR_CLEANUP (begin)
6257 = build3 (COND_EXPR, void_type_node, flag,
6259 build_call (abort_fn, guard_addr_list));
6260 CLEANUP_EH_ONLY (begin) = 1;
6262 /* Do the initialization itself. */
6263 init = add_stmt_to_compound (begin, init);
6264 init = add_stmt_to_compound
6265 (init, build2 (MODIFY_EXPR, void_type_node, flag, boolean_true_node));
6266 init = add_stmt_to_compound
6267 (init, build_call (release_fn, guard_addr_list));
6270 init = add_stmt_to_compound (init, set_guard (guard));
6272 /* Use atexit to register a function for destroying this static
6274 init = add_stmt_to_compound (init, register_dtor_fn (decl));
6276 finish_expr_stmt (init);
6278 if (flag_threadsafe_statics)
6280 finish_compound_stmt (inner_then_clause);
6281 finish_then_clause (inner_if_stmt);
6282 finish_if_stmt (inner_if_stmt);
6285 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
6287 finish_compound_stmt (then_clause);
6288 finish_then_clause (if_stmt);
6289 finish_if_stmt (if_stmt);
6293 static_aggregates = tree_cons (init, decl, static_aggregates);
6297 /* Make TYPE a complete type based on INITIAL_VALUE.
6298 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6299 2 if there was no information (in which case assume 0 if DO_DEFAULT),
6300 3 if the initializer list is empty (in pedantic mode). */
6303 cp_complete_array_type (tree *ptype, tree initial_value, bool do_default)
6306 tree type, elt_type;
6310 /* An array of character type can be initialized from a
6311 brace-enclosed string constant.
6313 FIXME: this code is duplicated from reshape_init. Probably
6314 we should just call reshape_init here? */
6315 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype)))
6316 && TREE_CODE (initial_value) == CONSTRUCTOR
6317 && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (initial_value)))
6319 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
6320 tree value = VEC_index (constructor_elt, v, 0)->value;
6322 if (TREE_CODE (value) == STRING_CST
6323 && VEC_length (constructor_elt, v) == 1)
6324 initial_value = value;
6328 failure = complete_array_type (ptype, initial_value, do_default);
6330 /* We can create the array before the element type is complete, which
6331 means that we didn't have these two bits set in the original type
6332 either. In completing the type, we are expected to propagate these
6333 bits. See also complete_type which does the same thing for arrays
6336 if (TYPE_DOMAIN (type))
6338 elt_type = TREE_TYPE (type);
6339 TYPE_NEEDS_CONSTRUCTING (type) = TYPE_NEEDS_CONSTRUCTING (elt_type);
6340 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
6341 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type);
6347 /* Return zero if something is declared to be a member of type
6348 CTYPE when in the context of CUR_TYPE. STRING is the error
6349 message to print in that case. Otherwise, quietly return 1. */
6352 member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
6354 if (ctype && ctype != cur_type)
6356 if (flags == DTOR_FLAG)
6357 error ("destructor for alien class %qT cannot be a member", ctype);
6359 error ("constructor for alien class %qT cannot be a member", ctype);
6365 /* Subroutine of `grokdeclarator'. */
6367 /* Generate errors possibly applicable for a given set of specifiers.
6368 This is for ARM $7.1.2. */
6371 bad_specifiers (tree object,
6380 error ("%qD declared as a %<virtual%> %s", object, type);
6382 error ("%qD declared as an %<inline%> %s", object, type);
6384 error ("%<const%> and %<volatile%> function specifiers on "
6385 "%qD invalid in %s declaration",
6388 error ("%q+D declared as a friend", object);
6390 && (TREE_CODE (object) == TYPE_DECL
6391 || (!TYPE_PTRFN_P (TREE_TYPE (object))
6392 && !TYPE_REFFN_P (TREE_TYPE (object))
6393 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
6394 error ("%q+D declared with an exception specification", object);
6397 /* DECL is a member function or static data member and is presently
6398 being defined. Check that the definition is taking place in a
6402 check_class_member_definition_namespace (tree decl)
6404 /* These checks only apply to member functions and static data
6406 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
6407 || TREE_CODE (decl) == VAR_DECL);
6408 /* We check for problems with specializations in pt.c in
6409 check_specialization_namespace, where we can issue better
6411 if (processing_specialization)
6413 /* There are no restrictions on the placement of
6414 explicit instantiations. */
6415 if (processing_explicit_instantiation)
6419 A member function definition that appears outside of the
6420 class definition shall appear in a namespace scope enclosing
6421 the class definition.
6425 The definition for a static data member shall appear in a
6426 namespace scope enclosing the member's class definition. */
6427 if (!is_ancestor (current_namespace, DECL_CONTEXT (decl)))
6428 pedwarn ("definition of %qD is not in namespace enclosing %qT",
6429 decl, DECL_CONTEXT (decl));
6432 /* Build a PARM_DECL for the "this" parameter. TYPE is the
6433 METHOD_TYPE for a non-static member function; QUALS are the
6434 cv-qualifiers that apply to the function. */
6437 build_this_parm (tree type, cp_cv_quals quals)
6442 cp_cv_quals this_quals;
6444 this_type = TREE_VALUE (TYPE_ARG_TYPES (type));
6445 /* The `this' parameter is implicitly `const'; it cannot be
6447 this_quals = (quals & TYPE_QUAL_RESTRICT) | TYPE_QUAL_CONST;
6448 qual_type = cp_build_qualified_type (this_type, this_quals);
6449 parm = build_artificial_parm (this_identifier, qual_type);
6450 cp_apply_type_quals_to_decl (this_quals, parm);
6454 /* CTYPE is class type, or null if non-class.
6455 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
6457 DECLARATOR is the function's name.
6458 PARMS is a chain of PARM_DECLs for the function.
6459 VIRTUALP is truthvalue of whether the function is virtual or not.
6460 FLAGS are to be passed through to `grokclassfn'.
6461 QUALS are qualifiers indicating whether the function is `const'
6463 RAISES is a list of exceptions that this function can raise.
6464 CHECK is 1 if we must find this method in CTYPE, 0 if we should
6465 not look, and -1 if we should not call `grokclassfn' at all.
6467 SFK is the kind of special function (if any) for the new function.
6469 Returns `NULL_TREE' if something goes wrong, after issuing
6470 applicable error messages. */
6473 grokfndecl (tree ctype,
6477 tree orig_declarator,
6479 enum overload_flags flags,
6486 special_function_kind sfk,
6493 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
6497 type = build_exception_variant (type, raises);
6499 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
6500 if (TREE_CODE (type) == METHOD_TYPE)
6503 parm = build_this_parm (type, quals);
6504 TREE_CHAIN (parm) = parms;
6507 DECL_ARGUMENTS (decl) = parms;
6508 /* Propagate volatile out from type to decl. */
6509 if (TYPE_VOLATILE (type))
6510 TREE_THIS_VOLATILE (decl) = 1;
6512 /* If pointers to member functions use the least significant bit to
6513 indicate whether a function is virtual, ensure a pointer
6514 to this function will have that bit clear. */
6515 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
6516 && TREE_CODE (type) == METHOD_TYPE
6517 && DECL_ALIGN (decl) < 2 * BITS_PER_UNIT)
6518 DECL_ALIGN (decl) = 2 * BITS_PER_UNIT;
6521 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
6525 ("defining explicit specialization %qD in friend declaration",
6529 tree fns = TREE_OPERAND (orig_declarator, 0);
6530 tree args = TREE_OPERAND (orig_declarator, 1);
6532 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
6534 /* Something like `template <class T> friend void f<T>()'. */
6535 error ("invalid use of template-id %qD in declaration "
6536 "of primary template",
6542 /* A friend declaration of the form friend void f<>(). Record
6543 the information in the TEMPLATE_ID_EXPR. */
6544 SET_DECL_IMPLICIT_INSTANTIATION (decl);
6546 if (TREE_CODE (fns) == COMPONENT_REF)
6548 /* Due to bison parser ickiness, we will have already looked
6549 up an operator_name or PFUNCNAME within the current class
6550 (see template_id in parse.y). If the current class contains
6551 such a name, we'll get a COMPONENT_REF here. Undo that. */
6553 gcc_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
6554 == current_class_type);
6555 fns = TREE_OPERAND (fns, 1);
6557 gcc_assert (TREE_CODE (fns) == IDENTIFIER_NODE
6558 || TREE_CODE (fns) == OVERLOAD);
6559 DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
6561 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
6562 if (TREE_PURPOSE (t)
6563 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
6565 error ("default arguments are not allowed in declaration "
6566 "of friend template specialization %qD",
6573 error ("%<inline%> is not allowed in declaration of friend "
6574 "template specialization %qD",
6581 /* If this decl has namespace scope, set that up. */
6583 set_decl_namespace (decl, in_namespace, friendp);
6585 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
6587 /* `main' and builtins have implicit 'C' linkage. */
6588 if ((MAIN_NAME_P (declarator)
6589 || (IDENTIFIER_LENGTH (declarator) > 10
6590 && IDENTIFIER_POINTER (declarator)[0] == '_'
6591 && IDENTIFIER_POINTER (declarator)[1] == '_'
6592 && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
6593 && current_lang_name == lang_name_cplusplus
6594 && ctype == NULL_TREE
6595 /* NULL_TREE means global namespace. */
6596 && DECL_CONTEXT (decl) == NULL_TREE)
6597 SET_DECL_LANGUAGE (decl, lang_c);
6599 /* Should probably propagate const out from type to decl I bet (mrs). */
6602 DECL_STATIC_FUNCTION_P (decl) = 1;
6603 DECL_CONTEXT (decl) = ctype;
6608 DECL_CONTEXT (decl) = ctype;
6610 check_class_member_definition_namespace (decl);
6613 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
6615 if (processing_template_decl)
6616 error ("cannot declare %<::main%> to be a template");
6618 error ("cannot declare %<::main%> to be inline");
6620 error ("cannot declare %<::main%> to be static");
6625 /* Members of anonymous types and local classes have no linkage; make
6626 them internal. If a typedef is made later, this will be changed. */
6627 if (ctype && (TYPE_ANONYMOUS_P (ctype)
6628 || decl_function_context (TYPE_MAIN_DECL (ctype))))
6633 /* [basic.link]: A name with no linkage (notably, the name of a class
6634 or enumeration declared in a local scope) shall not be used to
6635 declare an entity with linkage.
6637 Only check this for public decls for now. See core 319, 389. */
6638 t = no_linkage_check (TREE_TYPE (decl),
6639 /*relaxed_p=*/false);
6642 if (TYPE_ANONYMOUS_P (t))
6644 if (DECL_EXTERN_C_P (decl))
6645 /* Allow this; it's pretty common in C. */;
6648 pedwarn ("non-local function %q#D uses anonymous type",
6650 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
6651 pedwarn ("%q+#D does not refer to the unqualified "
6652 "type, so it is not used for linkage",
6657 pedwarn ("non-local function %q#D uses local type %qT", decl, t);
6661 TREE_PUBLIC (decl) = publicp;
6664 DECL_INTERFACE_KNOWN (decl) = 1;
6665 DECL_NOT_REALLY_EXTERN (decl) = 1;
6668 /* If the declaration was declared inline, mark it as such. */
6670 DECL_DECLARED_INLINE_P (decl) = 1;
6671 /* We inline functions that are explicitly declared inline, or, when
6672 the user explicitly asks us to, all functions. */
6673 if (DECL_DECLARED_INLINE_P (decl)
6674 || (flag_inline_trees == 2 && !DECL_INLINE (decl) && funcdef_flag))
6675 DECL_INLINE (decl) = 1;
6677 DECL_EXTERNAL (decl) = 1;
6678 if (quals && TREE_CODE (type) == FUNCTION_TYPE)
6680 error ("%smember function %qD cannot have cv-qualifier",
6681 (ctype ? "static " : "non-"), decl);
6682 quals = TYPE_UNQUALIFIED;
6685 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl))
6686 && !grok_op_properties (decl, /*complain=*/true))
6689 if (ctype && decl_function_context (decl))
6690 DECL_NO_STATIC_CHAIN (decl) = 1;
6693 /* Make the init_value nonzero so pushdecl knows this is not
6694 tentative. error_mark_node is replaced later with the BLOCK. */
6695 DECL_INITIAL (decl) = error_mark_node;
6697 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
6698 TREE_NOTHROW (decl) = 1;
6700 /* Caller will do the rest of this. */
6704 if (ctype != NULL_TREE)
6706 if (sfk == sfk_constructor)
6707 DECL_CONSTRUCTOR_P (decl) = 1;
6709 grokclassfn (ctype, decl, flags);
6712 decl = check_explicit_specialization (orig_declarator, decl,
6715 4 * (friendp != 0));
6716 if (decl == error_mark_node)
6721 cplus_decl_attributes (&decl, *attrlist, 0);
6722 *attrlist = NULL_TREE;
6725 /* Check main's type after attributes have been applied. */
6726 if (ctype == NULL_TREE && DECL_MAIN_P (decl)
6727 && !same_type_p (TREE_TYPE (TREE_TYPE (decl)),
6730 tree oldtypeargs = TYPE_ARG_TYPES (TREE_TYPE (decl));
6732 error ("%<::main%> must return %<int%>");
6733 newtype = build_function_type (integer_type_node, oldtypeargs);
6734 TREE_TYPE (decl) = newtype;
6737 if (ctype != NULL_TREE
6738 && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
6743 old_decl = check_classfn (ctype, decl,
6744 (processing_template_decl
6745 > template_class_depth (ctype))
6746 ? current_template_parms
6753 if (TREE_CODE (old_decl) == TEMPLATE_DECL)
6754 /* Because grokfndecl is always supposed to return a
6755 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
6756 here. We depend on our callers to figure out that its
6757 really a template that's being returned. */
6758 old_decl = DECL_TEMPLATE_RESULT (old_decl);
6760 if (DECL_STATIC_FUNCTION_P (old_decl)
6761 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
6762 /* Remove the `this' parm added by grokclassfn.
6763 XXX Isn't this done in start_function, too? */
6764 revert_static_member_fn (decl);
6765 if (DECL_ARTIFICIAL (old_decl))
6766 error ("definition of implicitly-declared %qD", old_decl);
6768 /* Since we've smashed OLD_DECL to its
6769 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
6770 if (TREE_CODE (decl) == TEMPLATE_DECL)
6771 decl = DECL_TEMPLATE_RESULT (decl);
6773 /* Attempt to merge the declarations. This can fail, in
6774 the case of some invalid specialization declarations. */
6775 pushed_scope = push_scope (ctype);
6776 ok = duplicate_decls (decl, old_decl, friendp);
6778 pop_scope (pushed_scope);
6781 error ("no %q#D member function declared in class %qT",
6789 if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
6792 if (ctype == NULL_TREE || check)
6796 DECL_VIRTUAL_P (decl) = 1;
6801 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
6802 the linkage that DECL will receive in the object file. */
6805 set_linkage_for_static_data_member (tree decl)
6807 /* A static data member always has static storage duration and
6808 external linkage. Note that static data members are forbidden in
6809 local classes -- the only situation in which a class has
6810 non-external linkage. */
6811 TREE_PUBLIC (decl) = 1;
6812 TREE_STATIC (decl) = 1;
6813 /* For non-template classes, static data members are always put
6814 out in exactly those files where they are defined, just as
6815 with ordinary namespace-scope variables. */
6816 if (!processing_template_decl)
6817 DECL_INTERFACE_KNOWN (decl) = 1;
6820 /* Create a VAR_DECL named NAME with the indicated TYPE.
6822 If SCOPE is non-NULL, it is the class type or namespace containing
6823 the variable. If SCOPE is NULL, the variable should is created in
6824 the innermost enclosings scope. */
6827 grokvardecl (tree type,
6829 const cp_decl_specifier_seq *declspecs,
6835 tree explicit_scope;
6837 gcc_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE);
6839 /* Compute the scope in which to place the variable, but remember
6840 whether or not that scope was explicitly specified by the user. */
6841 explicit_scope = scope;
6844 /* An explicit "extern" specifier indicates a namespace-scope
6846 if (declspecs->storage_class == sc_extern)
6847 scope = current_namespace;
6848 else if (!at_function_scope_p ())
6849 scope = current_scope ();
6853 && (/* If the variable is a namespace-scope variable declared in a
6854 template, we need DECL_LANG_SPECIFIC. */
6855 (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
6856 /* Similarly for namespace-scope variables with language linkage
6858 || (TREE_CODE (scope) == NAMESPACE_DECL
6859 && current_lang_name != lang_name_cplusplus)
6860 /* Similarly for static data members. */
6862 decl = build_lang_decl (VAR_DECL, name, type);
6864 decl = build_decl (VAR_DECL, name, type);
6866 if (explicit_scope && TREE_CODE (explicit_scope) == NAMESPACE_DECL)
6867 set_decl_namespace (decl, explicit_scope, 0);
6869 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
6871 if (declspecs->storage_class == sc_extern)
6873 DECL_THIS_EXTERN (decl) = 1;
6874 DECL_EXTERNAL (decl) = !initialized;
6877 if (DECL_CLASS_SCOPE_P (decl))
6879 set_linkage_for_static_data_member (decl);
6880 /* This function is only called with out-of-class definitions. */
6881 DECL_EXTERNAL (decl) = 0;
6882 check_class_member_definition_namespace (decl);
6884 /* At top level, either `static' or no s.c. makes a definition
6885 (perhaps tentative), and absence of `static' makes it public. */
6886 else if (toplevel_bindings_p ())
6888 TREE_PUBLIC (decl) = (declspecs->storage_class != sc_static
6889 && (DECL_THIS_EXTERN (decl) || ! constp));
6890 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
6892 /* Not at top level, only `static' makes a static definition. */
6895 TREE_STATIC (decl) = declspecs->storage_class == sc_static;
6896 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
6899 if (declspecs->specs[(int)ds_thread])
6901 if (targetm.have_tls)
6902 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
6904 /* A mere warning is sure to result in improper semantics
6905 at runtime. Don't bother to allow this to compile. */
6906 error ("thread-local storage not supported for this target");
6909 if (TREE_PUBLIC (decl))
6911 /* [basic.link]: A name with no linkage (notably, the name of a class
6912 or enumeration declared in a local scope) shall not be used to
6913 declare an entity with linkage.
6915 Only check this for public decls for now. */
6916 tree t = no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false);
6919 if (TYPE_ANONYMOUS_P (t))
6921 if (DECL_EXTERN_C_P (decl))
6922 /* Allow this; it's pretty common in C. */
6926 /* DRs 132, 319 and 389 seem to indicate types with
6927 no linkage can only be used to declare extern "C"
6928 entities. Since it's not always an error in the
6929 ISO C++ 90 Standard, we only issue a warning. */
6930 warning (0, "non-local variable %q#D uses anonymous type",
6932 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
6933 warning (0, "%q+#D does not refer to the unqualified "
6934 "type, so it is not used for linkage",
6939 warning (0, "non-local variable %q#D uses local type %qT", decl, t);
6943 DECL_INTERFACE_KNOWN (decl) = 1;
6948 /* Create and return a canonical pointer to member function type, for
6949 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
6952 build_ptrmemfunc_type (tree type)
6956 tree unqualified_variant = NULL_TREE;
6958 if (type == error_mark_node)
6961 /* If a canonical type already exists for this type, use it. We use
6962 this method instead of type_hash_canon, because it only does a
6963 simple equality check on the list of field members. */
6965 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
6968 /* Make sure that we always have the unqualified pointer-to-member
6970 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
6972 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
6974 t = make_aggr_type (RECORD_TYPE);
6975 xref_basetypes (t, NULL_TREE);
6977 /* Let the front-end know this is a pointer to member function... */
6978 TYPE_PTRMEMFUNC_FLAG (t) = 1;
6979 /* ... and not really an aggregate. */
6980 SET_IS_AGGR_TYPE (t, 0);
6982 field = build_decl (FIELD_DECL, pfn_identifier, type);
6985 field = build_decl (FIELD_DECL, delta_identifier, delta_type_node);
6986 TREE_CHAIN (field) = fields;
6989 finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
6991 /* Zap out the name so that the back-end will give us the debugging
6992 information for this anonymous RECORD_TYPE. */
6993 TYPE_NAME (t) = NULL_TREE;
6995 /* If this is not the unqualified form of this pointer-to-member
6996 type, set the TYPE_MAIN_VARIANT for this type to be the
6997 unqualified type. Since they are actually RECORD_TYPEs that are
6998 not variants of each other, we must do this manually. */
6999 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
7001 t = build_qualified_type (t, cp_type_quals (type));
7002 TYPE_MAIN_VARIANT (t) = unqualified_variant;
7003 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
7004 TYPE_NEXT_VARIANT (unqualified_variant) = t;
7007 /* Cache this pointer-to-member type so that we can find it again
7009 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
7014 /* Create and return a pointer to data member type. */
7017 build_ptrmem_type (tree class_type, tree member_type)
7019 if (TREE_CODE (member_type) == METHOD_TYPE)
7023 arg_types = TYPE_ARG_TYPES (member_type);
7024 class_type = (cp_build_qualified_type
7026 cp_type_quals (TREE_TYPE (TREE_VALUE (arg_types)))));
7028 = build_method_type_directly (class_type,
7029 TREE_TYPE (member_type),
7030 TREE_CHAIN (arg_types));
7031 return build_ptrmemfunc_type (build_pointer_type (member_type));
7035 gcc_assert (TREE_CODE (member_type) != FUNCTION_TYPE);
7036 return build_offset_type (class_type, member_type);
7040 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
7041 Check to see that the definition is valid. Issue appropriate error
7042 messages. Return 1 if the definition is particularly bad, or 0
7046 check_static_variable_definition (tree decl, tree type)
7048 /* Motion 10 at San Diego: If a static const integral data member is
7049 initialized with an integral constant expression, the initializer
7050 may appear either in the declaration (within the class), or in
7051 the definition, but not both. If it appears in the class, the
7052 member is a member constant. The file-scope definition is always
7054 if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
7056 error ("invalid in-class initialization of static data member "
7057 "of non-integral type %qT",
7059 /* If we just return the declaration, crashes will sometimes
7060 occur. We therefore return void_type_node, as if this were a
7061 friend declaration, to cause callers to completely ignore
7062 this declaration. */
7065 else if (!CP_TYPE_CONST_P (type))
7066 error ("ISO C++ forbids in-class initialization of non-const "
7067 "static member %qD",
7069 else if (pedantic && !INTEGRAL_TYPE_P (type))
7070 pedwarn ("ISO C++ forbids initialization of member constant "
7071 "%qD of non-integral type %qT", decl, type);
7076 /* Given the SIZE (i.e., number of elements) in an array, compute an
7077 appropriate index type for the array. If non-NULL, NAME is the
7078 name of the thing being declared. */
7081 compute_array_index_type (tree name, tree size)
7086 if (error_operand_p (size))
7087 return error_mark_node;
7089 type = TREE_TYPE (size);
7090 /* The array bound must be an integer type. */
7091 if (!dependent_type_p (type) && !INTEGRAL_TYPE_P (type))
7094 error ("size of array %qD has non-integral type %qT", name, type);
7096 error ("size of array has non-integral type %qT", type);
7097 size = integer_one_node;
7098 type = TREE_TYPE (size);
7101 if (abi_version_at_least (2)
7102 /* We should only handle value dependent expressions specially. */
7103 ? value_dependent_expression_p (size)
7104 /* But for abi-1, we handled all instances in templates. This
7105 effects the manglings produced. */
7106 : processing_template_decl)
7107 return build_index_type (build_min (MINUS_EXPR, sizetype,
7108 size, integer_one_node));
7110 /* The size might be the result of a cast. */
7111 STRIP_TYPE_NOPS (size);
7113 /* It might be a const variable or enumeration constant. */
7114 size = integral_constant_value (size);
7116 /* Normally, the array-bound will be a constant. */
7117 if (TREE_CODE (size) == INTEGER_CST)
7119 /* Check to see if the array bound overflowed. Make that an
7120 error, no matter how generous we're being. */
7121 int old_flag_pedantic_errors = flag_pedantic_errors;
7122 int old_pedantic = pedantic;
7123 pedantic = flag_pedantic_errors = 1;
7124 constant_expression_warning (size);
7125 pedantic = old_pedantic;
7126 flag_pedantic_errors = old_flag_pedantic_errors;
7128 /* An array must have a positive number of elements. */
7129 if (INT_CST_LT (size, integer_zero_node))
7132 error ("size of array %qD is negative", name);
7134 error ("size of array is negative");
7135 size = integer_one_node;
7137 /* As an extension we allow zero-sized arrays. We always allow
7138 them in system headers because glibc uses them. */
7139 else if (integer_zerop (size) && pedantic && !in_system_header)
7142 pedwarn ("ISO C++ forbids zero-size array %qD", name);
7144 pedwarn ("ISO C++ forbids zero-size array");
7147 else if (TREE_CONSTANT (size))
7149 /* `(int) &fn' is not a valid array bound. */
7151 error ("size of array %qD is not an integral constant-expression",
7154 error ("size of array is not an integral constant-expression");
7155 size = integer_one_node;
7157 else if (pedantic && warn_vla != 0)
7160 pedwarn ("ISO C++ forbids variable length array %qD", name);
7162 pedwarn ("ISO C++ forbids variable length array");
7164 else if (warn_vla > 0)
7168 "variable length array %qD is used", name);
7171 "variable length array is used");
7174 if (processing_template_decl && !TREE_CONSTANT (size))
7175 /* A variable sized array. */
7176 itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node);
7179 HOST_WIDE_INT saved_processing_template_decl;
7181 /* Compute the index of the largest element in the array. It is
7182 one less than the number of elements in the array. We save
7183 and restore PROCESSING_TEMPLATE_DECL so that computations in
7184 cp_build_binary_op will be appropriately folded. */
7185 saved_processing_template_decl = processing_template_decl;
7186 processing_template_decl = 0;
7187 itype = cp_build_binary_op (MINUS_EXPR,
7188 cp_convert (ssizetype, size),
7189 cp_convert (ssizetype, integer_one_node));
7190 itype = fold (itype);
7191 processing_template_decl = saved_processing_template_decl;
7193 if (!TREE_CONSTANT (itype))
7194 /* A variable sized array. */
7195 itype = variable_size (itype);
7196 /* Make sure that there was no overflow when creating to a signed
7197 index type. (For example, on a 32-bit machine, an array with
7198 size 2^32 - 1 is too big.) */
7199 else if (TREE_CODE (itype) == INTEGER_CST
7200 && TREE_OVERFLOW (itype))
7202 error ("overflow in array dimension");
7203 TREE_OVERFLOW (itype) = 0;
7207 /* Create and return the appropriate index type. */
7208 return build_index_type (itype);
7211 /* Returns the scope (if any) in which the entity declared by
7212 DECLARATOR will be located. If the entity was declared with an
7213 unqualified name, NULL_TREE is returned. */
7216 get_scope_of_declarator (const cp_declarator *declarator)
7218 while (declarator && declarator->kind != cdk_id)
7219 declarator = declarator->declarator;
7221 /* If the declarator-id is a SCOPE_REF, the scope in which the
7222 declaration occurs is the first operand. */
7224 && declarator->u.id.qualifying_scope)
7225 return declarator->u.id.qualifying_scope;
7227 /* Otherwise, the declarator is not a qualified name; the entity will
7228 be declared in the current scope. */
7232 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
7233 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
7237 create_array_type_for_decl (tree name, tree type, tree size)
7239 tree itype = NULL_TREE;
7240 const char* error_msg;
7242 /* If things have already gone awry, bail now. */
7243 if (type == error_mark_node || size == error_mark_node)
7244 return error_mark_node;
7246 /* Assume that everything will go OK. */
7249 /* There are some types which cannot be array elements. */
7250 switch (TREE_CODE (type))
7253 error_msg = "array of void";
7257 error_msg = "array of functions";
7260 case REFERENCE_TYPE:
7261 error_msg = "array of references";
7265 error_msg = "array of function members";
7272 /* If something went wrong, issue an error-message and return. */
7276 error ("declaration of %qD as %s", name, error_msg);
7278 error ("creating %s", error_msg);
7280 return error_mark_node;
7285 The constant expressions that specify the bounds of the arrays
7286 can be omitted only for the first member of the sequence. */
7287 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
7290 error ("declaration of %qD as multidimensional array must "
7291 "have bounds for all dimensions except the first",
7294 error ("multidimensional array must have bounds for all "
7295 "dimensions except the first");
7297 return error_mark_node;
7300 /* Figure out the index type for the array. */
7302 itype = compute_array_index_type (name, size);
7305 T is called the array element type; this type shall not be [...] an
7306 abstract class type. */
7307 abstract_virtuals_error (name, type);
7309 return build_cplus_array_type (type, itype);
7312 /* Check that it's OK to declare a function with the indicated TYPE.
7313 SFK indicates the kind of special function (if any) that this
7314 function is. OPTYPE is the type given in a conversion operator
7315 declaration, or the class type for a constructor/destructor.
7316 Returns the actual return type of the function; that
7317 may be different than TYPE if an error occurs, or for certain
7318 special functions. */
7321 check_special_function_return_type (special_function_kind sfk,
7327 case sfk_constructor:
7329 error ("return type specification for constructor invalid");
7331 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
7332 type = build_pointer_type (optype);
7334 type = void_type_node;
7337 case sfk_destructor:
7339 error ("return type specification for destructor invalid");
7340 /* We can't use the proper return type here because we run into
7341 problems with ambiguous bases and covariant returns.
7342 Java classes are left unchanged because (void *) isn't a valid
7343 Java type, and we don't want to change the Java ABI. */
7344 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
7345 type = build_pointer_type (void_type_node);
7347 type = void_type_node;
7350 case sfk_conversion:
7351 if (type && !same_type_p (type, optype))
7352 error ("operator %qT declared to return %qT", optype, type);
7354 pedwarn ("return type specified for %<operator %T%>", optype);
7365 /* A variable or data member (whose unqualified name is IDENTIFIER)
7366 has been declared with the indicated TYPE. If the TYPE is not
7367 acceptable, issue an error message and return a type to use for
7368 error-recovery purposes. */
7371 check_var_type (tree identifier, tree type)
7373 if (VOID_TYPE_P (type))
7376 error ("unnamed variable or field declared void");
7377 else if (TREE_CODE (identifier) == IDENTIFIER_NODE)
7379 gcc_assert (!IDENTIFIER_OPNAME_P (identifier));
7380 error ("variable or field %qE declared void", identifier);
7383 error ("variable or field declared void");
7384 type = error_mark_node;
7390 /* Given declspecs and a declarator (abstract or otherwise), determine
7391 the name and type of the object declared and construct a DECL node
7394 DECLSPECS is a chain of tree_list nodes whose value fields
7395 are the storage classes and type specifiers.
7397 DECL_CONTEXT says which syntactic context this declaration is in:
7398 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
7399 FUNCDEF for a function definition. Like NORMAL but a few different
7400 error messages in each case. Return value may be zero meaning
7401 this definition is too screwy to try to parse.
7402 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
7403 handle member functions (which have FIELD context).
7404 Return value may be zero meaning this definition is too screwy to
7406 PARM for a parameter declaration (either within a function prototype
7407 or before a function body). Make a PARM_DECL, or return void_type_node.
7408 CATCHPARM for a parameter declaration before a catch clause.
7409 TYPENAME if for a typename (in a cast or sizeof).
7410 Don't make a DECL node; just return the ..._TYPE node.
7411 FIELD for a struct or union field; make a FIELD_DECL.
7412 BITFIELD for a field with specified width.
7413 INITIALIZED is 1 if the decl has an initializer.
7415 ATTRLIST is a pointer to the list of attributes, which may be NULL
7416 if there are none; *ATTRLIST may be modified if attributes from inside
7417 the declarator should be applied to the declaration.
7419 When this function is called, scoping variables (such as
7420 CURRENT_CLASS_TYPE) should reflect the scope in which the
7421 declaration occurs, not the scope in which the new declaration will
7422 be placed. For example, on:
7426 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
7429 Returns a DECL (if a declarator is present), a TYPE (if there is no
7430 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
7434 grokdeclarator (const cp_declarator *declarator,
7435 const cp_decl_specifier_seq *declspecs,
7436 enum decl_context decl_context,
7440 tree type = NULL_TREE;
7442 int virtualp, explicitp, friendp, inlinep, staticp;
7443 int explicit_int = 0;
7444 int explicit_char = 0;
7445 int defaulted_int = 0;
7446 tree dependent_name = NULL_TREE;
7448 tree typedef_decl = NULL_TREE;
7449 const char *name = NULL;
7450 tree typedef_type = NULL_TREE;
7451 /* True if this declarator is a function definition. */
7452 bool funcdef_flag = false;
7453 cp_declarator_kind innermost_code = cdk_error;
7456 /* See the code below that used this. */
7457 tree decl_attr = NULL_TREE;
7460 /* Keep track of what sort of function is being processed
7461 so that we can warn about default return values, or explicit
7462 return values which do not match prescribed defaults. */
7463 special_function_kind sfk = sfk_none;
7465 tree dname = NULL_TREE;
7466 tree ctor_return_type = NULL_TREE;
7467 enum overload_flags flags = NO_SPECIAL;
7468 /* cv-qualifiers that apply to the declarator, for a declaration of
7469 a member function. */
7470 cp_cv_quals memfn_quals = TYPE_UNQUALIFIED;
7471 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
7473 tree raises = NULL_TREE;
7474 int template_count = 0;
7475 tree returned_attrs = NULL_TREE;
7476 tree parms = NULL_TREE;
7477 const cp_declarator *id_declarator;
7478 /* The unqualified name of the declarator; either an
7479 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
7480 tree unqualified_id;
7481 /* The class type, if any, in which this entity is located,
7482 or NULL_TREE if none. Note that this value may be different from
7483 the current class type; for example if an attempt is made to declare
7484 "A::f" inside "B", this value will be "A". */
7485 tree ctype = current_class_type;
7486 /* The NAMESPACE_DECL for the namespace in which this entity is
7487 located. If an unqualified name is used to declare the entity,
7488 this value will be NULL_TREE, even if the entity is located at
7490 tree in_namespace = NULL_TREE;
7491 cp_storage_class storage_class;
7492 bool unsigned_p, signed_p, short_p, long_p, thread_p;
7493 bool type_was_error_mark_node = false;
7495 signed_p = declspecs->specs[(int)ds_signed];
7496 unsigned_p = declspecs->specs[(int)ds_unsigned];
7497 short_p = declspecs->specs[(int)ds_short];
7498 long_p = declspecs->specs[(int)ds_long];
7499 longlong = declspecs->specs[(int)ds_long] >= 2;
7500 thread_p = declspecs->specs[(int)ds_thread];
7502 if (decl_context == FUNCDEF)
7503 funcdef_flag = true, decl_context = NORMAL;
7504 else if (decl_context == MEMFUNCDEF)
7505 funcdef_flag = true, decl_context = FIELD;
7506 else if (decl_context == BITFIELD)
7507 bitfield = 1, decl_context = FIELD;
7509 /* Look inside a declarator for the name being declared
7510 and get it as a string, for an error message. */
7511 for (id_declarator = declarator;
7513 id_declarator = id_declarator->declarator)
7515 if (id_declarator->kind != cdk_id)
7516 innermost_code = id_declarator->kind;
7518 switch (id_declarator->kind)
7521 if (id_declarator->declarator
7522 && id_declarator->declarator->kind == cdk_id)
7524 sfk = id_declarator->declarator->u.id.sfk;
7525 if (sfk == sfk_destructor)
7532 tree qualifying_scope = id_declarator->u.id.qualifying_scope;
7533 tree decl = id_declarator->u.id.unqualified_name;
7536 if (qualifying_scope)
7538 if (at_function_scope_p ())
7542 A declarator-id shall not be qualified except
7545 None of the cases are permitted in block
7547 if (qualifying_scope == global_namespace)
7548 error ("invalid use of qualified-name %<::%D%>",
7550 else if (TYPE_P (qualifying_scope))
7551 error ("invalid use of qualified-name %<%T::%D%>",
7552 qualifying_scope, decl);
7554 error ("invalid use of qualified-name %<%D::%D%>",
7555 qualifying_scope, decl);
7556 return error_mark_node;
7558 else if (TYPE_P (qualifying_scope))
7560 ctype = qualifying_scope;
7561 if (innermost_code != cdk_function
7562 && current_class_type
7563 && !UNIQUELY_DERIVED_FROM_P (ctype,
7564 current_class_type))
7566 error ("type %qT is not derived from type %qT",
7567 ctype, current_class_type);
7568 return error_mark_node;
7571 else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL)
7572 in_namespace = qualifying_scope;
7574 switch (TREE_CODE (decl))
7580 if (innermost_code != cdk_function)
7582 error ("declaration of %qD as non-function", decl);
7583 return error_mark_node;
7585 else if (!qualifying_scope
7586 && !(current_class_type && at_class_scope_p ()))
7588 error ("declaration of %qD as non-member", decl);
7589 return error_mark_node;
7592 type = TREE_OPERAND (decl, 0);
7593 name = IDENTIFIER_POINTER (constructor_name (type));
7598 case TEMPLATE_ID_EXPR:
7600 tree fns = TREE_OPERAND (decl, 0);
7603 if (TREE_CODE (dname) != IDENTIFIER_NODE)
7605 gcc_assert (is_overloaded_fn (dname));
7606 dname = DECL_NAME (get_first_fn (dname));
7611 case IDENTIFIER_NODE:
7612 if (TREE_CODE (decl) == IDENTIFIER_NODE)
7615 if (C_IS_RESERVED_WORD (dname))
7617 error ("declarator-id missing; using reserved word %qD",
7619 name = IDENTIFIER_POINTER (dname);
7621 else if (!IDENTIFIER_TYPENAME_P (dname))
7622 name = IDENTIFIER_POINTER (dname);
7625 gcc_assert (flags == NO_SPECIAL);
7626 flags = TYPENAME_FLAG;
7627 ctor_return_type = TREE_TYPE (dname);
7628 sfk = sfk_conversion;
7629 if (is_typename_at_global_scope (dname))
7630 name = IDENTIFIER_POINTER (dname);
7632 name = "<invalid operator>";
7645 /* APPLE LOCAL blocks 6040305 */
7646 case cdk_block_pointer:
7650 return error_mark_node;
7656 if (id_declarator->kind == cdk_id)
7662 The declarator in a function-definition shall have the form
7663 D1 ( parameter-declaration-clause) ... */
7664 if (funcdef_flag && innermost_code != cdk_function)
7666 error ("function definition does not declare parameters");
7667 return error_mark_node;
7670 if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
7671 && innermost_code != cdk_function
7672 && ! (ctype && !declspecs->any_specifiers_p))
7674 error ("declaration of %qD as non-function", dname);
7675 return error_mark_node;
7678 /* Anything declared one level down from the top level
7679 must be one of the parameters of a function
7680 (because the body is at least two levels down). */
7682 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
7683 by not allowing C++ class definitions to specify their parameters
7684 with xdecls (must be spec.d in the parmlist).
7686 Since we now wait to push a class scope until we are sure that
7687 we are in a legitimate method context, we must set oldcname
7688 explicitly (since current_class_name is not yet alive).
7690 We also want to avoid calling this a PARM if it is in a namespace. */
7692 if (decl_context == NORMAL && !toplevel_bindings_p ())
7694 struct cp_binding_level *b = current_binding_level;
7695 current_binding_level = b->level_chain;
7696 if (current_binding_level != 0 && toplevel_bindings_p ())
7697 decl_context = PARM;
7698 current_binding_level = b;
7702 name = decl_context == PARM ? "parameter" : "type name";
7704 /* If there were multiple types specified in the decl-specifier-seq,
7705 issue an error message. */
7706 if (declspecs->multiple_types_p)
7708 error ("two or more data types in declaration of %qs", name);
7709 return error_mark_node;
7712 /* Extract the basic type from the decl-specifier-seq. */
7713 type = declspecs->type;
7714 if (type == error_mark_node)
7717 type_was_error_mark_node = true;
7720 /* APPLE LOCAL begin unavailable attribute (radar 2809697) --bowdidge */
7721 /* If the entire declaration is itself tagged as unavailable then
7722 suppress reports of unavailable/deprecated items. If the
7723 entire declaration is tagged as only deprecated we still
7724 report unavailable uses. */
7725 if (type && TREE_DEPRECATED (type) && TREE_UNAVAILABLE (type))
7727 if (deprecated_state != DEPRECATED_UNAVAILABLE_SUPPRESS)
7728 warn_deprecated_use (type);
7731 /* APPLE LOCAL end unavailable attribute (radar 2809697) --bowdidge */
7732 /* If the entire declaration is itself tagged as deprecated then
7733 suppress reports of deprecated items. */
7734 if (type && TREE_DEPRECATED (type)
7735 && deprecated_state != DEPRECATED_SUPPRESS)
7736 warn_deprecated_use (type);
7737 if (type && TREE_CODE (type) == TYPE_DECL)
7739 typedef_decl = type;
7740 type = TREE_TYPE (typedef_decl);
7742 /* No type at all: default to `int', and set DEFAULTED_INT
7743 because it was not a user-defined typedef. */
7744 if (type == NULL_TREE && (signed_p || unsigned_p || long_p || short_p))
7746 /* These imply 'int'. */
7747 type = integer_type_node;
7751 explicit_int = declspecs->explicit_int_p;
7752 explicit_char = declspecs->explicit_char_p;
7755 /* See the code below that used this. */
7757 decl_attr = DECL_ATTRIBUTES (typedef_decl);
7759 typedef_type = type;
7762 if (sfk != sfk_conversion)
7763 ctor_return_type = ctype;
7765 if (sfk != sfk_none)
7766 type = check_special_function_return_type (sfk, type,
7768 else if (type == NULL_TREE)
7774 /* We handle `main' specially here, because 'main () { }' is so
7775 common. With no options, it is allowed. With -Wreturn-type,
7776 it is a warning. It is only an error with -pedantic-errors. */
7777 is_main = (funcdef_flag
7778 && dname && MAIN_NAME_P (dname)
7779 && ctype == NULL_TREE
7780 && in_namespace == NULL_TREE
7781 && current_namespace == global_namespace);
7783 if (type_was_error_mark_node)
7784 /* We've already issued an error, don't complain more. */;
7785 else if (in_system_header || flag_ms_extensions)
7786 /* Allow it, sigh. */;
7787 else if (pedantic || ! is_main)
7788 pedwarn ("ISO C++ forbids declaration of %qs with no type", name);
7789 else if (warn_return_type)
7790 warning (0, "ISO C++ forbids declaration of %qs with no type", name);
7792 type = integer_type_node;
7797 /* Now process the modifiers that were specified
7798 and check for invalid combinations. */
7800 /* Long double is a special combination. */
7801 if (long_p && !longlong && TYPE_MAIN_VARIANT (type) == double_type_node)
7804 type = build_qualified_type (long_double_type_node,
7805 cp_type_quals (type));
7808 /* Check all other uses of type modifiers. */
7810 if (unsigned_p || signed_p || long_p || short_p)
7814 if ((signed_p || unsigned_p) && TREE_CODE (type) != INTEGER_TYPE)
7815 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
7816 else if (signed_p && unsigned_p)
7817 error ("%<signed%> and %<unsigned%> specified together for %qs", name);
7818 else if (longlong && TREE_CODE (type) != INTEGER_TYPE)
7819 error ("%<long long%> invalid for %qs", name);
7820 else if (long_p && TREE_CODE (type) == REAL_TYPE)
7821 error ("%<long%> invalid for %qs", name);
7822 else if (short_p && TREE_CODE (type) == REAL_TYPE)
7823 error ("%<short%> invalid for %qs", name);
7824 else if ((long_p || short_p) && TREE_CODE (type) != INTEGER_TYPE)
7825 error ("%<long%> or %<short%> invalid for %qs", name);
7826 else if ((long_p || short_p) && explicit_char)
7827 error ("%<long%> or %<short%> specified with char for %qs", name);
7828 else if (long_p && short_p)
7829 error ("%<long%> and %<short%> specified together for %qs", name);
7833 if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
7835 pedwarn ("long, short, signed or unsigned used invalidly for %qs",
7837 if (flag_pedantic_errors)
7842 /* Discard the type modifiers if they are invalid. */
7853 /* Decide whether an integer type is signed or not.
7854 Optionally treat bitfields as signed by default. */
7858 It is implementation-defined whether a plain (neither
7859 explicitly signed or unsigned) char, short, int, or long
7860 bit-field is signed or unsigned.
7862 Naturally, we extend this to long long as well. Note that
7863 this does not include wchar_t. */
7864 || (bitfield && !flag_signed_bitfields
7866 /* A typedef for plain `int' without `signed' can be
7867 controlled just like plain `int', but a typedef for
7868 `signed int' cannot be so controlled. */
7870 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
7871 && TREE_CODE (type) == INTEGER_TYPE
7872 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
7875 type = long_long_unsigned_type_node;
7877 type = long_unsigned_type_node;
7879 type = short_unsigned_type_node;
7880 else if (type == char_type_node)
7881 type = unsigned_char_type_node;
7882 else if (typedef_decl)
7883 type = c_common_unsigned_type (type);
7885 type = unsigned_type_node;
7887 else if (signed_p && type == char_type_node)
7888 type = signed_char_type_node;
7890 type = long_long_integer_type_node;
7892 type = long_integer_type_node;
7894 type = short_integer_type_node;
7896 if (declspecs->specs[(int)ds_complex])
7898 if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
7899 error ("complex invalid for %qs", name);
7900 /* If we just have "complex", it is equivalent to
7901 "complex double", but if any modifiers at all are specified it is
7902 the complex form of TYPE. E.g, "complex short" is
7903 "complex short int". */
7905 else if (defaulted_int && ! longlong
7906 && ! (long_p || short_p || signed_p || unsigned_p))
7907 type = complex_double_type_node;
7908 else if (type == integer_type_node)
7909 type = complex_integer_type_node;
7910 else if (type == float_type_node)
7911 type = complex_float_type_node;
7912 else if (type == double_type_node)
7913 type = complex_double_type_node;
7914 else if (type == long_double_type_node)
7915 type = complex_long_double_type_node;
7917 type = build_complex_type (type);
7920 type_quals = TYPE_UNQUALIFIED;
7921 if (declspecs->specs[(int)ds_const])
7922 type_quals |= TYPE_QUAL_CONST;
7923 if (declspecs->specs[(int)ds_volatile])
7924 type_quals |= TYPE_QUAL_VOLATILE;
7925 if (declspecs->specs[(int)ds_restrict])
7926 type_quals |= TYPE_QUAL_RESTRICT;
7927 if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
7928 error ("qualifiers are not allowed on declaration of %<operator %T%>",
7931 if (TREE_CODE (type) == FUNCTION_TYPE
7932 && type_quals != TYPE_UNQUALIFIED)
7934 /* This was an error in C++98 (cv-qualifiers cannot be added to
7935 a function type), but DR 295 makes the code well-formed by
7936 dropping the extra qualifiers. */
7939 tree bad_type = build_qualified_type (type, type_quals);
7940 pedwarn ("ignoring %qV qualifiers added to function type %qT",
7943 type_quals = TYPE_UNQUALIFIED;
7945 type_quals |= cp_type_quals (type);
7946 type = cp_build_qualified_type_real
7947 (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
7948 ? tf_ignore_bad_quals : 0) | tf_warning_or_error));
7949 /* We might have ignored or rejected some of the qualifiers. */
7950 type_quals = cp_type_quals (type);
7953 inlinep = !! declspecs->specs[(int)ds_inline];
7954 virtualp = !! declspecs->specs[(int)ds_virtual];
7955 explicitp = !! declspecs->specs[(int)ds_explicit];
7957 storage_class = declspecs->storage_class;
7958 if (storage_class == sc_static)
7959 staticp = 1 + (decl_context == FIELD);
7961 if (virtualp && staticp == 2)
7963 error ("member %qD cannot be declared both virtual and static", dname);
7964 storage_class = sc_none;
7967 friendp = !! declspecs->specs[(int)ds_friend];
7969 if (dependent_name && !friendp)
7971 error ("%<%T::%D%> is not a valid declarator", ctype, dependent_name);
7972 return error_mark_node;
7975 /* Issue errors about use of storage classes for parameters. */
7976 if (decl_context == PARM)
7978 if (declspecs->specs[(int)ds_typedef])
7980 error ("typedef declaration invalid in parameter declaration");
7981 return error_mark_node;
7983 else if (storage_class == sc_static
7984 || storage_class == sc_extern
7986 error ("storage class specifiers invalid in parameter declarations");
7989 /* Give error if `virtual' is used outside of class declaration. */
7991 && (current_class_name == NULL_TREE || decl_context != FIELD))
7993 error ("virtual outside class declaration");
7997 /* Static anonymous unions are dealt with here. */
7998 if (staticp && decl_context == TYPENAME
8000 && ANON_AGGR_TYPE_P (declspecs->type))
8001 decl_context = FIELD;
8003 /* Warn about storage classes that are invalid for certain
8004 kinds of declarations (parameters, typenames, etc.). */
8007 && storage_class != sc_extern
8008 && storage_class != sc_static)
8009 || declspecs->specs[(int)ds_typedef]))
8011 error ("multiple storage classes in declaration of %qs", name);
8014 if (declspecs->conflicting_specifiers_p)
8016 error ("conflicting specifiers in declaration of %qs", name);
8017 storage_class = sc_none;
8019 else if (decl_context != NORMAL
8020 && ((storage_class != sc_none
8021 && storage_class != sc_mutable)
8024 if ((decl_context == PARM || decl_context == CATCHPARM)
8025 && (storage_class == sc_register
8026 || storage_class == sc_auto))
8028 else if (declspecs->specs[(int)ds_typedef])
8030 else if (decl_context == FIELD
8031 /* C++ allows static class elements. */
8032 && storage_class == sc_static)
8033 /* C++ also allows inlines and signed and unsigned elements,
8034 but in those cases we don't come in here. */
8038 if (decl_context == FIELD)
8039 error ("storage class specified for %qs", name);
8042 if (decl_context == PARM || decl_context == CATCHPARM)
8043 error ("storage class specified for parameter %qs", name);
8045 error ("storage class specified for typename");
8047 if (storage_class == sc_register
8048 || storage_class == sc_auto
8049 || storage_class == sc_extern
8051 storage_class = sc_none;
8054 else if (storage_class == sc_extern && initialized
8057 if (toplevel_bindings_p ())
8059 /* It's common practice (and completely valid) to have a const
8060 be initialized and declared extern. */
8061 if (!(type_quals & TYPE_QUAL_CONST))
8062 warning (0, "%qs initialized and declared %<extern%>", name);
8065 error ("%qs has both %<extern%> and initializer", name);
8067 else if (storage_class == sc_extern && funcdef_flag
8068 && ! toplevel_bindings_p ())
8069 error ("nested function %qs declared %<extern%>", name);
8070 else if (toplevel_bindings_p ())
8072 if (storage_class == sc_auto)
8073 error ("top-level declaration of %qs specifies %<auto%>", name);
8076 && storage_class != sc_extern
8077 && storage_class != sc_static)
8079 error ("function-scope %qs implicitly auto and declared %<__thread%>",
8084 if (storage_class && friendp)
8085 error ("storage class specifiers invalid in friend function declarations");
8088 unqualified_id = NULL_TREE;
8091 unqualified_id = id_declarator->u.id.unqualified_name;
8092 switch (TREE_CODE (unqualified_id))
8096 = constructor_name (TREE_OPERAND (unqualified_id, 0));
8099 case IDENTIFIER_NODE:
8100 case TEMPLATE_ID_EXPR:
8108 /* Determine the type of the entity declared by recurring on the
8110 for (; declarator; declarator = declarator->declarator)
8112 const cp_declarator *inner_declarator;
8115 if (type == error_mark_node)
8116 return error_mark_node;
8118 attrs = declarator->attributes;
8124 if (declarator == NULL || declarator->kind == cdk_id)
8125 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
8126 if (declarator->kind == cdk_function)
8127 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
8128 if (declarator->kind == cdk_array)
8129 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
8130 returned_attrs = decl_attributes (&type,
8131 chainon (returned_attrs, attrs),
8135 if (declarator->kind == cdk_id)
8138 inner_declarator = declarator->declarator;
8140 switch (declarator->kind)
8143 type = create_array_type_for_decl (dname, type,
8144 declarator->u.array.bounds);
8152 /* Declaring a function type.
8153 Make sure we have a valid type for the function to return. */
8155 /* We now know that the TYPE_QUALS don't apply to the
8156 decl, but to its return type. */
8157 type_quals = TYPE_UNQUALIFIED;
8159 /* Warn about some types functions can't return. */
8161 if (TREE_CODE (type) == FUNCTION_TYPE)
8163 error ("%qs declared as function returning a function", name);
8164 type = integer_type_node;
8166 if (TREE_CODE (type) == ARRAY_TYPE)
8168 error ("%qs declared as function returning an array", name);
8169 type = integer_type_node;
8172 /* Pick up type qualifiers which should be applied to `this'. */
8173 memfn_quals = declarator->u.function.qualifiers;
8175 /* Pick up the exception specifications. */
8176 raises = declarator->u.function.exception_specification;
8178 /* Say it's a definition only for the CALL_EXPR
8179 closest to the identifier. */
8180 funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id;
8182 if (ctype == NULL_TREE
8183 && decl_context == FIELD
8185 && (friendp == 0 || dname == current_class_name))
8186 ctype = current_class_type;
8188 if (ctype && (sfk == sfk_constructor
8189 || sfk == sfk_destructor))
8191 /* We are within a class's scope. If our declarator name
8192 is the same as the class name, and we are defining
8193 a function, then it is a constructor/destructor, and
8194 therefore returns a void type. */
8196 /* ISO C++ 12.4/2. A destructor may not be declared
8197 const or volatile. A destructor may not be
8200 ISO C++ 12.1. A constructor may not be declared
8201 const or volatile. A constructor may not be
8202 virtual. A constructor may not be static. */
8204 error ((flags == DTOR_FLAG)
8205 ? "destructor cannot be static member function"
8206 : "constructor cannot be static member function");
8209 error ((flags == DTOR_FLAG)
8210 ? "destructors may not be cv-qualified"
8211 : "constructors may not be cv-qualified");
8212 memfn_quals = TYPE_UNQUALIFIED;
8215 if (decl_context == FIELD
8216 && !member_function_or_else (ctype,
8219 return error_mark_node;
8221 if (flags != DTOR_FLAG)
8223 /* It's a constructor. */
8228 pedwarn ("constructors cannot be declared virtual");
8231 if (decl_context == FIELD
8232 && sfk != sfk_constructor)
8233 return error_mark_node;
8235 if (decl_context == FIELD)
8241 error ("can't initialize friend function %qs", name);
8244 /* Cannot be both friend and virtual. */
8245 error ("virtual functions cannot be friends");
8248 if (decl_context == NORMAL)
8249 error ("friend declaration not in class definition");
8250 if (current_function_decl && funcdef_flag)
8251 error ("can't define friend function %qs in a local "
8256 arg_types = grokparms (declarator->u.function.parameters,
8259 if (inner_declarator
8260 && inner_declarator->kind == cdk_id
8261 && inner_declarator->u.id.sfk == sfk_destructor
8262 && arg_types != void_list_node)
8264 error ("destructors may not have parameters");
8265 arg_types = void_list_node;
8269 type = build_function_type (type, arg_types);
8276 /* Filter out pointers-to-references and references-to-references.
8277 We can get these if a TYPE_DECL is used. */
8279 if (TREE_CODE (type) == REFERENCE_TYPE)
8281 error (declarator->kind == cdk_reference
8282 ? "cannot declare reference to %q#T"
8283 : "cannot declare pointer to %q#T", type);
8284 type = TREE_TYPE (type);
8286 else if (VOID_TYPE_P (type))
8288 if (declarator->kind == cdk_reference)
8289 error ("cannot declare reference to %q#T", type);
8290 else if (declarator->kind == cdk_ptrmem)
8291 error ("cannot declare pointer to %q#T member", type);
8294 /* We now know that the TYPE_QUALS don't apply to the decl,
8295 but to the target of the pointer. */
8296 type_quals = TYPE_UNQUALIFIED;
8298 if (declarator->kind == cdk_ptrmem
8299 && (TREE_CODE (type) == FUNCTION_TYPE || memfn_quals))
8301 memfn_quals |= cp_type_quals (type);
8302 type = build_memfn_type (type,
8303 declarator->u.pointer.class_type,
8305 memfn_quals = TYPE_UNQUALIFIED;
8308 if (declarator->kind == cdk_reference)
8310 if (!VOID_TYPE_P (type))
8311 type = build_reference_type (type);
8313 else if (TREE_CODE (type) == METHOD_TYPE)
8314 type = build_ptrmemfunc_type (build_pointer_type (type));
8315 else if (declarator->kind == cdk_ptrmem)
8317 gcc_assert (TREE_CODE (declarator->u.pointer.class_type)
8319 if (declarator->u.pointer.class_type == error_mark_node)
8320 /* We will already have complained. */
8321 type = error_mark_node;
8323 type = build_ptrmem_type (declarator->u.pointer.class_type,
8327 type = build_pointer_type (type);
8329 /* Process a list of type modifier keywords (such as
8330 const or volatile) that were given inside the `*' or `&'. */
8332 if (declarator->u.pointer.qualifiers)
8335 = cp_build_qualified_type (type,
8336 declarator->u.pointer.qualifiers);
8337 type_quals = cp_type_quals (type);
8342 /* APPLE LOCAL begin blocks 6040305 (cj) */
8343 case cdk_block_pointer:
8344 if (TREE_CODE (type) != FUNCTION_TYPE)
8346 error ("block pointer to non-function type is invalid");
8347 type = error_mark_node;
8351 /* We now know that the TYPE_QUALS don't apply to the decl,
8352 but to the target of the pointer. */
8353 type_quals = TYPE_UNQUALIFIED;
8355 type = build_block_pointer_type (type);
8357 if (declarator->u.pointer.qualifiers)
8360 = cp_build_qualified_type (type,
8361 declarator->u.pointer.qualifiers);
8362 type_quals = cp_type_quals (type);
8367 /* APPLE LOCAL end blocks 6040305 (cj) */
8377 if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR
8378 && TREE_CODE (type) != FUNCTION_TYPE
8379 && TREE_CODE (type) != METHOD_TYPE)
8381 error ("template-id %qD used as a declarator",
8383 unqualified_id = dname;
8386 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
8387 qualified with a class-name, turn it into a METHOD_TYPE, unless
8388 we know that the function is static. We take advantage of this
8389 opportunity to do other processing that pertains to entities
8390 explicitly declared to be class members. Note that if DECLARATOR
8391 is non-NULL, we know it is a cdk_id declarator; otherwise, we
8392 would not have exited the loop above. */
8394 && declarator->u.id.qualifying_scope
8395 && TYPE_P (declarator->u.id.qualifying_scope))
8399 ctype = declarator->u.id.qualifying_scope;
8400 ctype = TYPE_MAIN_VARIANT (ctype);
8402 while (t != NULL_TREE && CLASS_TYPE_P (t))
8404 /* You're supposed to have one `template <...>' for every
8405 template class, but you don't need one for a full
8406 specialization. For example:
8408 template <class T> struct S{};
8409 template <> struct S<int> { void f(); };
8410 void S<int>::f () {}
8412 is correct; there shouldn't be a `template <>' for the
8413 definition of `S<int>::f'. */
8414 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t)
8415 && !any_dependent_template_arguments_p (CLASSTYPE_TI_ARGS (t)))
8416 /* T is an explicit (not partial) specialization. All
8417 containing classes must therefore also be explicitly
8420 if ((CLASSTYPE_USE_TEMPLATE (t) || CLASSTYPE_IS_TEMPLATE (t))
8421 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
8422 template_count += 1;
8424 t = TYPE_MAIN_DECL (t);
8425 t = DECL_CONTEXT (t);
8428 if (ctype == current_class_type)
8431 pedwarn ("member functions are implicitly friends of their class");
8433 pedwarn ("extra qualification %<%T::%> on member %qs",
8436 else if (/* If the qualifying type is already complete, then we
8437 can skip the following checks. */
8438 !COMPLETE_TYPE_P (ctype)
8439 && (/* If the function is being defined, then
8440 qualifying type must certainly be complete. */
8442 /* A friend declaration of "T::f" is OK, even if
8443 "T" is a template parameter. But, if this
8444 function is not a friend, the qualifying type
8446 || (!friendp && !CLASS_TYPE_P (ctype))
8447 /* For a declaration, the type need not be
8448 complete, if either it is dependent (since there
8449 is no meaningful definition of complete in that
8450 case) or the qualifying class is currently being
8452 || !(dependent_type_p (ctype)
8453 || currently_open_class (ctype)))
8454 /* Check that the qualifying type is complete. */
8455 && !complete_type_or_else (ctype, NULL_TREE))
8456 return error_mark_node;
8457 else if (TREE_CODE (type) == FUNCTION_TYPE)
8459 tree sname = declarator->u.id.unqualified_name;
8461 if (current_class_type
8462 && (!friendp || funcdef_flag))
8465 ? "cannot define member function %<%T::%s%> within %<%T%>"
8466 : "cannot declare member function %<%T::%s%> within %<%T%>",
8467 ctype, name, current_class_type);
8468 return error_mark_node;
8471 if (TREE_CODE (sname) == IDENTIFIER_NODE
8472 && NEW_DELETE_OPNAME_P (sname))
8473 /* Overloaded operator new and operator delete
8474 are always static functions. */
8477 type = build_memfn_type (type, ctype, memfn_quals);
8479 else if (declspecs->specs[(int)ds_typedef]
8480 && current_class_type)
8482 error ("cannot declare member %<%T::%s%> within %qT",
8483 ctype, name, current_class_type);
8484 return error_mark_node;
8488 /* Now TYPE has the actual type. */
8493 *attrlist = chainon (returned_attrs, *attrlist);
8495 attrlist = &returned_attrs;
8498 /* Did array size calculations overflow? */
8500 if (TREE_CODE (type) == ARRAY_TYPE
8501 && COMPLETE_TYPE_P (type)
8502 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
8503 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
8505 error ("size of array %qs is too large", name);
8506 /* If we proceed with the array type as it is, we'll eventually
8507 crash in tree_low_cst(). */
8508 type = error_mark_node;
8511 if ((decl_context == FIELD || decl_context == PARM)
8512 && !processing_template_decl
8513 && variably_modified_type_p (type, NULL_TREE))
8515 if (decl_context == FIELD)
8516 error ("data member may not have variably modified type %qT", type);
8518 error ("parameter may not have variably modified type %qT", type);
8519 type = error_mark_node;
8522 if (explicitp == 1 || (explicitp && friendp))
8524 /* [dcl.fct.spec] The explicit specifier shall only be used in
8525 declarations of constructors within a class definition. */
8526 error ("only declarations of constructors can be %<explicit%>");
8530 if (storage_class == sc_mutable)
8532 if (decl_context != FIELD || friendp)
8534 error ("non-member %qs cannot be declared %<mutable%>", name);
8535 storage_class = sc_none;
8537 else if (decl_context == TYPENAME || declspecs->specs[(int)ds_typedef])
8539 error ("non-object member %qs cannot be declared %<mutable%>", name);
8540 storage_class = sc_none;
8542 else if (TREE_CODE (type) == FUNCTION_TYPE
8543 || TREE_CODE (type) == METHOD_TYPE)
8545 error ("function %qs cannot be declared %<mutable%>", name);
8546 storage_class = sc_none;
8550 error ("static %qs cannot be declared %<mutable%>", name);
8551 storage_class = sc_none;
8553 else if (type_quals & TYPE_QUAL_CONST)
8555 error ("const %qs cannot be declared %<mutable%>", name);
8556 storage_class = sc_none;
8560 /* APPLE LOCAL begin blocks 6339747 */
8561 if (decl_context == BLOCKDEF)
8565 if (type == error_mark_node)
8566 return error_mark_node;
8568 if (TREE_CODE (type) != FUNCTION_TYPE)
8570 tree t = make_node (FUNCTION_TYPE);
8572 if (TREE_CODE (type) == ARRAY_TYPE)
8574 error ("block declared as returning an array");
8575 return error_mark_node;
8578 TYPE_ARG_TYPES (t) = void_list_node;
8579 TREE_TYPE (t) = type;
8585 type = build_exception_variant (type, raises);
8586 decl = build_lang_decl (FUNCTION_DECL, NULL_TREE, type);
8587 DECL_ARGUMENTS (decl) = parms;
8590 /* APPLE LOCAL end blocks 6339747 */
8592 /* If this is declaring a typedef name, return a TYPE_DECL. */
8593 if (declspecs->specs[(int)ds_typedef] && decl_context != TYPENAME)
8597 /* Note that the grammar rejects storage classes
8598 in typenames, fields or parameters. */
8599 if (current_lang_name == lang_name_java)
8600 TYPE_FOR_JAVA (type) = 1;
8602 /* This declaration:
8604 typedef void f(int) const;
8606 declares a function type which is not a member of any
8607 particular class, but which is cv-qualified; for
8608 example "f S::*" declares a pointer to a const-qualified
8609 member function of S. We record the cv-qualification in the
8611 if (memfn_quals && TREE_CODE (type) == FUNCTION_TYPE)
8612 type = cp_build_qualified_type (type, memfn_quals);
8614 if (decl_context == FIELD)
8615 decl = build_lang_decl (TYPE_DECL, unqualified_id, type);
8617 decl = build_decl (TYPE_DECL, unqualified_id, type);
8618 if (id_declarator && declarator->u.id.qualifying_scope)
8619 error ("%Jtypedef name may not be a nested-name-specifier", decl);
8621 if (decl_context != FIELD)
8623 if (!current_function_decl)
8624 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
8625 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl)
8626 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
8627 (current_function_decl)))
8628 /* The TYPE_DECL is "abstract" because there will be
8629 clones of this constructor/destructor, and there will
8630 be copies of this TYPE_DECL generated in those
8632 DECL_ABSTRACT (decl) = 1;
8634 else if (constructor_name_p (unqualified_id, current_class_type))
8635 pedwarn ("ISO C++ forbids nested type %qD with same name "
8636 "as enclosing class",
8639 /* If the user declares "typedef struct {...} foo" then the
8640 struct will have an anonymous name. Fill that name in now.
8641 Nothing can refer to it, so nothing needs know about the name
8643 if (type != error_mark_node
8646 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
8647 && TYPE_ANONYMOUS_P (type)
8648 /* Don't do this if there are attributes. */
8649 && (!attrlist || !*attrlist)
8650 && cp_type_quals (type) == TYPE_UNQUALIFIED)
8652 tree oldname = TYPE_NAME (type);
8655 /* Replace the anonymous name with the real name everywhere. */
8656 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
8657 if (TYPE_NAME (t) == oldname)
8658 TYPE_NAME (t) = decl;
8660 if (TYPE_LANG_SPECIFIC (type))
8661 TYPE_WAS_ANONYMOUS (type) = 1;
8663 /* If this is a typedef within a template class, the nested
8664 type is a (non-primary) template. The name for the
8665 template needs updating as well. */
8666 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
8667 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
8668 = TYPE_IDENTIFIER (type);
8670 /* FIXME remangle member functions; member functions of a
8671 type with external linkage have external linkage. */
8674 /* Any qualifiers on a function type typedef have already been
8676 if (memfn_quals && !ctype && TREE_CODE (type) == FUNCTION_TYPE)
8677 memfn_quals = TYPE_UNQUALIFIED;
8680 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
8681 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
8683 bad_specifiers (decl, "type", virtualp,
8684 memfn_quals != TYPE_UNQUALIFIED,
8685 inlinep, friendp, raises != NULL_TREE);
8690 /* Detect the case of an array type of unspecified size
8691 which came, as such, direct from a typedef name.
8692 We must copy the type, so that the array's domain can be
8693 individually set by the object's initializer. */
8695 if (type && typedef_type
8696 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
8697 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
8698 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
8700 /* Detect where we're using a typedef of function type to declare a
8701 function. PARMS will not be set, so we must create it now. */
8703 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
8705 tree decls = NULL_TREE;
8708 for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
8710 tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
8712 TREE_CHAIN (decl) = decls;
8716 parms = nreverse (decls);
8718 if (decl_context != TYPENAME)
8720 /* A cv-qualifier-seq shall only be part of the function type
8721 for a non-static member function. [8.3.5/4 dcl.fct] */
8722 if (cp_type_quals (type) != TYPE_UNQUALIFIED
8723 && (current_class_type == NULL_TREE || staticp) )
8725 error ("qualified function types cannot be used to declare %s functions",
8726 (staticp? "static member" : "free"));
8727 type = TYPE_MAIN_VARIANT (type);
8730 /* The qualifiers on the function type become the qualifiers on
8731 the non-static member function. */
8732 memfn_quals |= cp_type_quals (type);
8736 /* If this is a type name (such as, in a cast or sizeof),
8737 compute the type and return it now. */
8739 if (decl_context == TYPENAME)
8741 /* Note that the grammar rejects storage classes
8742 in typenames, fields or parameters. */
8743 if (type_quals != TYPE_UNQUALIFIED)
8744 type_quals = TYPE_UNQUALIFIED;
8746 /* Special case: "friend class foo" looks like a TYPENAME context. */
8749 if (type_quals != TYPE_UNQUALIFIED)
8751 error ("type qualifiers specified for friend class declaration");
8752 type_quals = TYPE_UNQUALIFIED;
8756 error ("%<inline%> specified for friend class declaration");
8762 /* Don't allow friend declaration without a class-key. */
8763 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
8764 pedwarn ("template parameters cannot be friends");
8765 else if (TREE_CODE (type) == TYPENAME_TYPE)
8766 pedwarn ("friend declaration requires class-key, "
8767 "i.e. %<friend class %T::%D%>",
8768 TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
8770 pedwarn ("friend declaration requires class-key, "
8771 "i.e. %<friend %#T%>",
8775 /* Only try to do this stuff if we didn't already give up. */
8776 if (type != integer_type_node)
8778 /* A friendly class? */
8779 if (current_class_type)
8780 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
8783 error ("trying to make class %qT a friend of global scope",
8786 type = void_type_node;
8789 else if (memfn_quals)
8791 if (ctype == NULL_TREE)
8793 if (TREE_CODE (type) != METHOD_TYPE)
8794 error ("invalid qualifiers on non-member function type");
8796 ctype = TYPE_METHOD_BASETYPE (type);
8799 type = build_memfn_type (type, ctype, memfn_quals);
8804 else if (unqualified_id == NULL_TREE && decl_context != PARM
8805 && decl_context != CATCHPARM
8806 && TREE_CODE (type) != UNION_TYPE
8809 error ("abstract declarator %qT used as declaration", type);
8810 return error_mark_node;
8813 /* Only functions may be declared using an operator-function-id. */
8815 && IDENTIFIER_OPNAME_P (unqualified_id)
8816 && TREE_CODE (type) != FUNCTION_TYPE
8817 && TREE_CODE (type) != METHOD_TYPE)
8819 error ("declaration of %qD as non-function", unqualified_id);
8820 return error_mark_node;
8823 /* We don't check parameter types here because we can emit a better
8824 error message later. */
8825 if (decl_context != PARM)
8827 type = check_var_type (unqualified_id, type);
8828 if (type == error_mark_node)
8829 return error_mark_node;
8832 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
8833 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
8835 if (decl_context == PARM || decl_context == CATCHPARM)
8837 if (ctype || in_namespace)
8838 error ("cannot use %<::%> in parameter declaration");
8840 /* A parameter declared as an array of T is really a pointer to T.
8841 One declared as a function is really a pointer to a function.
8842 One declared as a member is really a pointer to member. */
8844 if (TREE_CODE (type) == ARRAY_TYPE)
8846 /* Transfer const-ness of array into that of type pointed to. */
8847 type = build_pointer_type (TREE_TYPE (type));
8848 type_quals = TYPE_UNQUALIFIED;
8850 else if (TREE_CODE (type) == FUNCTION_TYPE)
8851 type = build_pointer_type (type);
8857 if (decl_context == PARM)
8859 decl = cp_build_parm_decl (unqualified_id, type);
8861 bad_specifiers (decl, "parameter", virtualp,
8862 memfn_quals != TYPE_UNQUALIFIED,
8863 inlinep, friendp, raises != NULL_TREE);
8865 else if (decl_context == FIELD)
8867 /* The C99 flexible array extension. */
8868 if (!staticp && TREE_CODE (type) == ARRAY_TYPE
8869 && TYPE_DOMAIN (type) == NULL_TREE)
8871 tree itype = compute_array_index_type (dname, integer_zero_node);
8872 type = build_cplus_array_type (TREE_TYPE (type), itype);
8875 if (type == error_mark_node)
8877 /* Happens when declaring arrays of sizes which
8878 are error_mark_node, for example. */
8881 else if (in_namespace && !friendp)
8883 /* Something like struct S { int N::j; }; */
8884 error ("invalid use of %<::%>");
8885 return error_mark_node;
8887 else if (TREE_CODE (type) == FUNCTION_TYPE)
8890 tree function_context;
8894 if (ctype == NULL_TREE)
8895 ctype = current_class_type;
8897 if (ctype == NULL_TREE)
8899 error ("can't make %qD into a method -- not in a class",
8901 return error_mark_node;
8904 /* ``A union may [ ... ] not [ have ] virtual functions.''
8906 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
8908 error ("function %qD declared virtual inside a union",
8910 return error_mark_node;
8913 if (NEW_DELETE_OPNAME_P (unqualified_id))
8917 error ("%qD cannot be declared virtual, since it "
8923 else if (staticp < 2)
8924 type = build_memfn_type (type, ctype, memfn_quals);
8927 /* Check that the name used for a destructor makes sense. */
8928 if (sfk == sfk_destructor)
8932 gcc_assert (friendp);
8933 error ("expected qualified name in friend declaration "
8934 "for destructor %qD",
8935 id_declarator->u.id.unqualified_name);
8936 return error_mark_node;
8939 if (!same_type_p (TREE_OPERAND
8940 (id_declarator->u.id.unqualified_name, 0),
8943 error ("declaration of %qD as member of %qT",
8944 id_declarator->u.id.unqualified_name, ctype);
8945 return error_mark_node;
8949 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
8950 function_context = (ctype != NULL_TREE) ?
8951 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
8952 publicp = (! friendp || ! staticp)
8953 && function_context == NULL_TREE;
8954 decl = grokfndecl (ctype, type,
8955 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
8956 ? unqualified_id : dname,
8959 virtualp, flags, memfn_quals, raises,
8960 friendp ? -1 : 0, friendp, publicp, inlinep,
8962 funcdef_flag, template_count, in_namespace, attrlist);
8963 if (decl == NULL_TREE)
8964 return error_mark_node;
8966 /* This clobbers the attrs stored in `decl' from `attrlist'. */
8967 /* The decl and setting of decl_attr is also turned off. */
8968 decl = build_decl_attribute_variant (decl, decl_attr);
8971 /* [class.conv.ctor]
8973 A constructor declared without the function-specifier
8974 explicit that can be called with a single parameter
8975 specifies a conversion from the type of its first
8976 parameter to the type of its class. Such a constructor
8977 is called a converting constructor. */
8979 DECL_NONCONVERTING_P (decl) = 1;
8980 else if (DECL_CONSTRUCTOR_P (decl))
8982 /* The constructor can be called with exactly one
8983 parameter if there is at least one parameter, and
8984 any subsequent parameters have default arguments.
8985 Ignore any compiler-added parms. */
8986 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
8988 if (arg_types == void_list_node
8990 && TREE_CHAIN (arg_types)
8991 && TREE_CHAIN (arg_types) != void_list_node
8992 && !TREE_PURPOSE (TREE_CHAIN (arg_types))))
8993 DECL_NONCONVERTING_P (decl) = 1;
8996 else if (TREE_CODE (type) == METHOD_TYPE)
8998 /* We only get here for friend declarations of
8999 members of other classes. */
9000 /* All method decls are public, so tell grokfndecl to set
9001 TREE_PUBLIC, also. */
9002 decl = grokfndecl (ctype, type,
9003 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
9004 ? unqualified_id : dname,
9007 virtualp, flags, memfn_quals, raises,
9008 friendp ? -1 : 0, friendp, 1, 0, sfk,
9009 funcdef_flag, template_count, in_namespace,
9011 if (decl == NULL_TREE)
9012 return error_mark_node;
9014 else if (!staticp && !dependent_type_p (type)
9015 && !COMPLETE_TYPE_P (complete_type (type))
9016 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
9019 error ("field %qD has incomplete type", unqualified_id);
9021 error ("name %qT has incomplete type", type);
9023 /* If we're instantiating a template, tell them which
9024 instantiation made the field's type be incomplete. */
9025 if (current_class_type
9026 && TYPE_NAME (current_class_type)
9027 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
9029 && declspecs->type == type)
9030 error (" in instantiation of template %qT",
9031 current_class_type);
9033 return error_mark_node;
9039 error ("%qE is neither function nor member function; "
9040 "cannot be declared friend", unqualified_id);
9048 /* Friends are treated specially. */
9049 if (ctype == current_class_type)
9050 ; /* We already issued a pedwarn. */
9051 else if (decl && DECL_NAME (decl))
9053 if (template_class_depth (current_class_type) == 0)
9055 decl = check_explicit_specialization
9056 (unqualified_id, decl, template_count,
9057 2 * funcdef_flag + 4);
9058 if (decl == error_mark_node)
9059 return error_mark_node;
9062 decl = do_friend (ctype, unqualified_id, decl,
9068 return error_mark_node;
9071 /* Structure field. It may not be a function, except for C++. */
9073 if (decl == NULL_TREE)
9079 /* An attempt is being made to initialize a non-static
9080 member. But, from [class.mem]:
9082 4 A member-declarator can contain a
9083 constant-initializer only if it declares a static
9084 member (_class.static_) of integral or enumeration
9085 type, see _class.static.data_.
9087 This used to be relatively common practice, but
9088 the rest of the compiler does not correctly
9089 handle the initialization unless the member is
9090 static so we make it static below. */
9091 pedwarn ("ISO C++ forbids initialization of member %qD",
9093 pedwarn ("making %qD static", unqualified_id);
9097 if (uses_template_parms (type))
9098 /* We'll check at instantiation time. */
9100 else if (check_static_variable_definition (unqualified_id,
9102 /* If we just return the declaration, crashes
9103 will sometimes occur. We therefore return
9104 void_type_node, as if this was a friend
9105 declaration, to cause callers to completely
9106 ignore this declaration. */
9107 return error_mark_node;
9112 /* C++ allows static class members. All other work
9113 for this is done by grokfield. */
9114 decl = build_lang_decl (VAR_DECL, unqualified_id, type);
9115 set_linkage_for_static_data_member (decl);
9116 /* Even if there is an in-class initialization, DECL
9117 is considered undefined until an out-of-class
9118 definition is provided. */
9119 DECL_EXTERNAL (decl) = 1;
9123 if (targetm.have_tls)
9124 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
9126 /* A mere warning is sure to result in improper
9127 semantics at runtime. Don't bother to allow this to
9129 error ("thread-local storage not supported for this target");
9134 decl = build_decl (FIELD_DECL, unqualified_id, type);
9135 DECL_NONADDRESSABLE_P (decl) = bitfield;
9136 if (storage_class == sc_mutable)
9138 DECL_MUTABLE_P (decl) = 1;
9139 storage_class = sc_none;
9143 bad_specifiers (decl, "field", virtualp,
9144 memfn_quals != TYPE_UNQUALIFIED,
9145 inlinep, friendp, raises != NULL_TREE);
9148 else if (TREE_CODE (type) == FUNCTION_TYPE
9149 || TREE_CODE (type) == METHOD_TYPE)
9154 if (!unqualified_id)
9155 return error_mark_node;
9157 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
9158 original_name = dname;
9160 original_name = unqualified_id;
9162 if (storage_class == sc_auto)
9163 error ("storage class %<auto%> invalid for function %qs", name);
9164 else if (storage_class == sc_register)
9165 error ("storage class %<register%> invalid for function %qs", name);
9167 error ("storage class %<__thread%> invalid for function %qs", name);
9169 /* Function declaration not at top level.
9170 Storage classes other than `extern' are not allowed
9171 and `extern' makes no difference. */
9172 if (! toplevel_bindings_p ()
9173 && (storage_class == sc_static
9174 || declspecs->specs[(int)ds_inline])
9177 if (storage_class == sc_static)
9178 pedwarn ("%<static%> specified invalid for function %qs "
9179 "declared out of global scope", name);
9181 pedwarn ("%<inline%> specifier invalid for function %qs "
9182 "declared out of global scope", name);
9185 if (ctype == NULL_TREE)
9189 error ("virtual non-class function %qs", name);
9193 else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2
9194 && !NEW_DELETE_OPNAME_P (original_name))
9195 type = build_method_type_directly (ctype,
9197 TYPE_ARG_TYPES (type));
9199 /* Record presence of `static'. */
9200 publicp = (ctype != NULL_TREE
9201 || storage_class == sc_extern
9202 || storage_class != sc_static);
9204 decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
9205 virtualp, flags, memfn_quals, raises,
9207 publicp, inlinep, sfk, funcdef_flag,
9208 template_count, in_namespace, attrlist);
9209 if (decl == NULL_TREE)
9210 return error_mark_node;
9214 int invalid_static = 0;
9216 /* Don't allow a static member function in a class, and forbid
9217 declaring main to be static. */
9218 if (TREE_CODE (type) == METHOD_TYPE)
9220 pedwarn ("cannot declare member function %qD to have "
9221 "static linkage", decl);
9224 else if (current_function_decl)
9226 /* FIXME need arm citation */
9227 error ("cannot declare static function inside another function");
9234 storage_class = sc_none;
9240 /* It's a variable. */
9242 /* An uninitialized decl with `extern' is a reference. */
9243 decl = grokvardecl (type, unqualified_id,
9246 (type_quals & TYPE_QUAL_CONST) != 0,
9247 ctype ? ctype : in_namespace);
9248 bad_specifiers (decl, "variable", virtualp,
9249 memfn_quals != TYPE_UNQUALIFIED,
9250 inlinep, friendp, raises != NULL_TREE);
9254 DECL_CONTEXT (decl) = ctype;
9257 pedwarn ("%<static%> may not be used when defining "
9258 "(as opposed to declaring) a static data member");
9260 storage_class = sc_none;
9262 if (storage_class == sc_register && TREE_STATIC (decl))
9264 error ("static member %qD declared %<register%>", decl);
9265 storage_class = sc_none;
9267 if (storage_class == sc_extern && pedantic)
9269 pedwarn ("cannot explicitly declare member %q#D to have "
9272 storage_class = sc_none;
9277 /* Record `register' declaration for warnings on &
9278 and in case doing stupid register allocation. */
9280 if (storage_class == sc_register)
9281 DECL_REGISTER (decl) = 1;
9282 else if (storage_class == sc_extern)
9283 DECL_THIS_EXTERN (decl) = 1;
9284 else if (storage_class == sc_static)
9285 DECL_THIS_STATIC (decl) = 1;
9287 /* Record constancy and volatility. There's no need to do this
9288 when processing a template; we'll do this for the instantiated
9289 declaration based on the type of DECL. */
9290 if (!processing_template_decl)
9291 cp_apply_type_quals_to_decl (type_quals, decl);
9297 /* Subroutine of start_function. Ensure that each of the parameter
9298 types (as listed in PARMS) is complete, as is required for a
9299 function definition. */
9302 require_complete_types_for_parms (tree parms)
9304 for (; parms; parms = TREE_CHAIN (parms))
9306 if (dependent_type_p (TREE_TYPE (parms)))
9308 if (!VOID_TYPE_P (TREE_TYPE (parms))
9309 && complete_type_or_else (TREE_TYPE (parms), parms))
9311 relayout_decl (parms);
9312 DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
9315 /* grokparms or complete_type_or_else will have already issued
9317 TREE_TYPE (parms) = error_mark_node;
9321 /* Returns nonzero if T is a local variable. */
9324 local_variable_p (tree t)
9326 if ((TREE_CODE (t) == VAR_DECL
9327 /* A VAR_DECL with a context that is a _TYPE is a static data
9329 && !TYPE_P (CP_DECL_CONTEXT (t))
9330 /* Any other non-local variable must be at namespace scope. */
9331 && !DECL_NAMESPACE_SCOPE_P (t))
9332 || (TREE_CODE (t) == PARM_DECL))
9338 /* Returns nonzero if T is an automatic local variable or a label.
9339 (These are the declarations that need to be remapped when the code
9340 containing them is duplicated.) */
9343 nonstatic_local_decl_p (tree t)
9345 return ((local_variable_p (t) && !TREE_STATIC (t))
9346 || TREE_CODE (t) == LABEL_DECL
9347 || TREE_CODE (t) == RESULT_DECL);
9350 /* Like local_variable_p, but suitable for use as a tree-walking
9354 local_variable_p_walkfn (tree *tp, int *walk_subtrees,
9355 void *data ATTRIBUTE_UNUSED)
9357 if (local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
9359 else if (TYPE_P (*tp))
9366 /* Check that ARG, which is a default-argument expression for a
9367 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
9368 something goes wrong. DECL may also be a _TYPE node, rather than a
9369 DECL, if there is no DECL available. */
9372 check_default_argument (tree decl, tree arg)
9377 if (TREE_CODE (arg) == DEFAULT_ARG)
9378 /* We get a DEFAULT_ARG when looking at an in-class declaration
9379 with a default argument. Ignore the argument for now; we'll
9380 deal with it after the class is complete. */
9389 decl_type = TREE_TYPE (decl);
9391 if (arg == error_mark_node
9392 || decl == error_mark_node
9393 || TREE_TYPE (arg) == error_mark_node
9394 || decl_type == error_mark_node)
9395 /* Something already went wrong. There's no need to check
9397 return error_mark_node;
9399 /* [dcl.fct.default]
9401 A default argument expression is implicitly converted to the
9403 if (!TREE_TYPE (arg)
9404 || !can_convert_arg (decl_type, TREE_TYPE (arg), arg, LOOKUP_NORMAL))
9407 error ("default argument for %q#D has type %qT",
9408 decl, TREE_TYPE (arg));
9410 error ("default argument for parameter of type %qT has type %qT",
9411 decl_type, TREE_TYPE (arg));
9413 return error_mark_node;
9416 /* [dcl.fct.default]
9418 Local variables shall not be used in default argument
9421 The keyword `this' shall not be used in a default argument of a
9423 var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn,
9427 error ("default argument %qE uses local variable %qD", arg, var);
9428 return error_mark_node;
9435 /* Decode the list of parameter types for a function type.
9436 Given the list of things declared inside the parens,
9437 return a list of types.
9439 If this parameter does not end with an ellipsis, we append
9442 *PARMS is set to the chain of PARM_DECLs created. */
9444 /* APPLE LOCAL blocks 6040305 (ce) */
9446 grokparms (cp_parameter_declarator *first_parm, tree *parms)
9448 tree result = NULL_TREE;
9449 tree decls = NULL_TREE;
9450 int ellipsis = !first_parm || first_parm->ellipsis_p;
9451 cp_parameter_declarator *parm;
9454 for (parm = first_parm; parm != NULL; parm = parm->next)
9456 tree type = NULL_TREE;
9457 tree init = parm->default_argument;
9461 if (parm == no_parameters)
9464 attrs = parm->decl_specifiers.attributes;
9465 parm->decl_specifiers.attributes = NULL_TREE;
9466 decl = grokdeclarator (parm->declarator, &parm->decl_specifiers,
9467 PARM, init != NULL_TREE, &attrs);
9468 if (! decl || TREE_TYPE (decl) == error_mark_node)
9472 cplus_decl_attributes (&decl, attrs, 0);
9474 type = TREE_TYPE (decl);
9475 if (VOID_TYPE_P (type))
9477 if (same_type_p (type, void_type_node)
9478 && DECL_SELF_REFERENCE_P (type)
9479 && !DECL_NAME (decl) && !result && !parm->next && !ellipsis)
9480 /* this is a parmlist of `(void)', which is ok. */
9482 cxx_incomplete_type_error (decl, type);
9483 /* It's not a good idea to actually create parameters of
9484 type `void'; other parts of the compiler assume that a
9485 void type terminates the parameter list. */
9486 type = error_mark_node;
9487 TREE_TYPE (decl) = error_mark_node;
9490 if (type != error_mark_node)
9492 /* Top-level qualifiers on the parameters are
9493 ignored for function types. */
9494 type = cp_build_qualified_type (type, 0);
9495 if (TREE_CODE (type) == METHOD_TYPE)
9497 error ("parameter %qD invalidly declared method type", decl);
9498 type = build_pointer_type (type);
9499 TREE_TYPE (decl) = type;
9501 else if (abstract_virtuals_error (decl, type))
9502 any_error = 1; /* Seems like a good idea. */
9503 else if (POINTER_TYPE_P (type))
9505 /* [dcl.fct]/6, parameter types cannot contain pointers
9506 (references) to arrays of unknown bound. */
9507 tree t = TREE_TYPE (type);
9508 int ptr = TYPE_PTR_P (type);
9514 else if (TREE_CODE (t) != ARRAY_TYPE)
9516 else if (!TYPE_DOMAIN (t))
9520 if (TREE_CODE (t) == ARRAY_TYPE)
9521 error ("parameter %qD includes %s to array of unknown "
9523 decl, ptr ? "pointer" : "reference", t);
9528 else if (init && !processing_template_decl)
9529 init = check_default_argument (decl, init);
9532 TREE_CHAIN (decl) = decls;
9534 result = tree_cons (init, type, result);
9536 decls = nreverse (decls);
9537 result = nreverse (result);
9539 result = chainon (result, void_list_node);
9546 /* D is a constructor or overloaded `operator='.
9548 Let T be the class in which D is declared. Then, this function
9551 -1 if D's is an ill-formed constructor or copy assignment operator
9552 whose first parameter is of type `T'.
9553 0 if D is not a copy constructor or copy assignment
9555 1 if D is a copy constructor or copy assignment operator whose
9556 first parameter is a reference to const qualified T.
9557 2 if D is a copy constructor or copy assignment operator whose
9558 first parameter is a reference to non-const qualified T.
9560 This function can be used as a predicate. Positive values indicate
9561 a copy constructor and nonzero values indicate a copy assignment
9571 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
9573 if (TREE_CODE (d) == TEMPLATE_DECL
9574 || (DECL_TEMPLATE_INFO (d)
9575 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
9576 /* Instantiations of template member functions are never copy
9577 functions. Note that member functions of templated classes are
9578 represented as template functions internally, and we must
9579 accept those as copy functions. */
9582 args = FUNCTION_FIRST_USER_PARMTYPE (d);
9586 arg_type = TREE_VALUE (args);
9587 if (arg_type == error_mark_node)
9590 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
9592 /* Pass by value copy assignment operator. */
9595 else if (TREE_CODE (arg_type) == REFERENCE_TYPE
9596 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
9598 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
9604 args = TREE_CHAIN (args);
9606 if (args && args != void_list_node && !TREE_PURPOSE (args))
9607 /* There are more non-optional args. */
9613 /* Remember any special properties of member function DECL. */
9615 void grok_special_member_properties (tree decl)
9619 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
9622 class_type = DECL_CONTEXT (decl);
9623 if (DECL_CONSTRUCTOR_P (decl))
9625 int ctor = copy_fn_p (decl);
9627 TYPE_HAS_CONSTRUCTOR (class_type) = 1;
9633 A non-template constructor for class X is a copy
9634 constructor if its first parameter is of type X&, const
9635 X&, volatile X& or const volatile X&, and either there
9636 are no other parameters or else all other parameters have
9637 default arguments. */
9638 TYPE_HAS_INIT_REF (class_type) = 1;
9640 TYPE_HAS_CONST_INIT_REF (class_type) = 1;
9642 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
9643 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type) = 1;
9645 else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
9649 A non-template assignment operator for class X is a copy
9650 assignment operator if its parameter is of type X, X&, const
9651 X&, volatile X& or const volatile X&. */
9653 int assop = copy_fn_p (decl);
9657 TYPE_HAS_ASSIGN_REF (class_type) = 1;
9659 TYPE_HAS_CONST_ASSIGN_REF (class_type) = 1;
9664 /* Check a constructor DECL has the correct form. Complains
9665 if the class has a constructor of the form X(X). */
9668 grok_ctor_properties (tree ctype, tree decl)
9670 int ctor_parm = copy_fn_p (decl);
9676 A declaration of a constructor for a class X is ill-formed if
9677 its first parameter is of type (optionally cv-qualified) X
9678 and either there are no other parameters or else all other
9679 parameters have default arguments.
9681 We *don't* complain about member template instantiations that
9682 have this form, though; they can occur as we try to decide
9683 what constructor to use during overload resolution. Since
9684 overload resolution will never prefer such a constructor to
9685 the non-template copy constructor (which is either explicitly
9686 or implicitly defined), there's no need to worry about their
9687 existence. Theoretically, they should never even be
9688 instantiated, but that's hard to forestall. */
9689 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
9697 /* An operator with this code is unary, but can also be binary. */
9700 ambi_op_p (enum tree_code code)
9702 return (code == INDIRECT_REF
9703 || code == ADDR_EXPR
9704 || code == UNARY_PLUS_EXPR
9705 || code == NEGATE_EXPR
9706 || code == PREINCREMENT_EXPR
9707 || code == PREDECREMENT_EXPR);
9710 /* An operator with this name can only be unary. */
9713 unary_op_p (enum tree_code code)
9715 return (code == TRUTH_NOT_EXPR
9716 || code == BIT_NOT_EXPR
9717 || code == COMPONENT_REF
9718 || code == TYPE_EXPR);
9721 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
9722 errors are issued for invalid declarations. */
9725 grok_op_properties (tree decl, bool complain)
9727 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
9729 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
9730 tree name = DECL_NAME (decl);
9731 enum tree_code operator_code;
9736 /* Count the number of arguments and check for ellipsis. */
9737 for (argtype = argtypes, arity = 0;
9738 argtype && argtype != void_list_node;
9739 argtype = TREE_CHAIN (argtype))
9741 ellipsis_p = !argtype;
9743 class_type = DECL_CONTEXT (decl);
9744 if (class_type && !CLASS_TYPE_P (class_type))
9745 class_type = NULL_TREE;
9747 if (DECL_CONV_FN_P (decl))
9748 operator_code = TYPE_EXPR;
9752 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
9753 if (ansi_opname (CODE) == name) \
9755 operator_code = (CODE); \
9758 else if (ansi_assopname (CODE) == name) \
9760 operator_code = (CODE); \
9761 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
9765 #include "operators.def"
9771 gcc_assert (operator_code != LAST_CPLUS_TREE_CODE);
9772 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
9775 switch (operator_code)
9778 TYPE_HAS_NEW_OPERATOR (class_type) = 1;
9782 TYPE_GETS_DELETE (class_type) |= 1;
9786 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type) = 1;
9789 case VEC_DELETE_EXPR:
9790 TYPE_GETS_DELETE (class_type) |= 2;
9797 /* [basic.std.dynamic.allocation]/1:
9799 A program is ill-formed if an allocation function is declared
9800 in a namespace scope other than global scope or declared static
9803 The same also holds true for deallocation functions. */
9804 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR
9805 || operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
9807 if (DECL_NAMESPACE_SCOPE_P (decl))
9809 if (CP_DECL_CONTEXT (decl) != global_namespace)
9811 error ("%qD may not be declared within a namespace", decl);
9814 else if (!TREE_PUBLIC (decl))
9816 error ("%qD may not be declared as static", decl);
9822 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
9823 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
9824 else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
9825 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
9828 /* An operator function must either be a non-static member function
9829 or have at least one parameter of a class, a reference to a class,
9830 an enumeration, or a reference to an enumeration. 13.4.0.6 */
9831 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
9833 if (operator_code == TYPE_EXPR
9834 || operator_code == CALL_EXPR
9835 || operator_code == COMPONENT_REF
9836 || operator_code == ARRAY_REF
9837 || operator_code == NOP_EXPR)
9839 error ("%qD must be a nonstatic member function", decl);
9846 if (DECL_STATIC_FUNCTION_P (decl))
9848 error ("%qD must be either a non-static member "
9849 "function or a non-member function", decl);
9853 for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
9855 tree arg = non_reference (TREE_VALUE (p));
9856 if (arg == error_mark_node)
9859 /* IS_AGGR_TYPE, rather than CLASS_TYPE_P, is used
9860 because these checks are performed even on
9861 template functions. */
9862 if (IS_AGGR_TYPE (arg) || TREE_CODE (arg) == ENUMERAL_TYPE)
9866 if (!p || p == void_list_node)
9869 error ("%qD must have an argument of class or "
9870 "enumerated type", decl);
9876 /* There are no restrictions on the arguments to an overloaded
9878 if (operator_code == CALL_EXPR)
9881 /* Warn about conversion operators that will never be used. */
9882 if (IDENTIFIER_TYPENAME_P (name)
9883 && ! DECL_TEMPLATE_INFO (decl)
9885 /* Warn only declaring the function; there is no need to
9886 warn again about out-of-class definitions. */
9887 && class_type == current_class_type)
9889 tree t = TREE_TYPE (name);
9890 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
9891 const char *what = 0;
9894 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
9896 if (TREE_CODE (t) == VOID_TYPE)
9898 else if (class_type)
9900 if (t == class_type)
9901 what = "the same type";
9902 /* Don't force t to be complete here. */
9903 else if (IS_AGGR_TYPE (t)
9904 && COMPLETE_TYPE_P (t)
9905 && DERIVED_FROM_P (t, class_type))
9906 what = "a base class";
9910 warning (OPT_Wconversion, "conversion to %s%s will never use a type "
9911 "conversion operator",
9912 ref ? "a reference to " : "", what);
9915 if (operator_code == COND_EXPR)
9918 error ("ISO C++ prohibits overloading operator ?:");
9921 else if (ellipsis_p)
9923 error ("%qD must not have variable number of arguments", decl);
9926 else if (ambi_op_p (operator_code))
9929 /* We pick the one-argument operator codes by default, so
9930 we don't have to change anything. */
9932 else if (arity == 2)
9934 /* If we thought this was a unary operator, we now know
9935 it to be a binary operator. */
9936 switch (operator_code)
9939 operator_code = MULT_EXPR;
9943 operator_code = BIT_AND_EXPR;
9946 case UNARY_PLUS_EXPR:
9947 operator_code = PLUS_EXPR;
9951 operator_code = MINUS_EXPR;
9954 case PREINCREMENT_EXPR:
9955 operator_code = POSTINCREMENT_EXPR;
9958 case PREDECREMENT_EXPR:
9959 operator_code = POSTDECREMENT_EXPR;
9966 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
9968 if ((operator_code == POSTINCREMENT_EXPR
9969 || operator_code == POSTDECREMENT_EXPR)
9970 && ! processing_template_decl
9971 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
9974 error ("postfix %qD must take %<int%> as its argument",
9977 error ("postfix %qD must take %<int%> as its second "
9985 error ("%qD must take either zero or one argument", decl);
9987 error ("%qD must take either one or two arguments", decl);
9991 /* More Effective C++ rule 6. */
9993 && (operator_code == POSTINCREMENT_EXPR
9994 || operator_code == POSTDECREMENT_EXPR
9995 || operator_code == PREINCREMENT_EXPR
9996 || operator_code == PREDECREMENT_EXPR))
9998 tree arg = TREE_VALUE (argtypes);
9999 tree ret = TREE_TYPE (TREE_TYPE (decl));
10000 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
10001 arg = TREE_TYPE (arg);
10002 arg = TYPE_MAIN_VARIANT (arg);
10003 if (operator_code == PREINCREMENT_EXPR
10004 || operator_code == PREDECREMENT_EXPR)
10006 if (TREE_CODE (ret) != REFERENCE_TYPE
10007 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
10009 warning (OPT_Weffc__, "prefix %qD should return %qT", decl,
10010 build_reference_type (arg));
10014 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
10015 warning (OPT_Weffc__, "postfix %qD should return %qT", decl, arg);
10019 else if (unary_op_p (operator_code))
10024 error ("%qD must take %<void%>", decl);
10026 error ("%qD must take exactly one argument", decl);
10030 else /* if (binary_op_p (operator_code)) */
10035 error ("%qD must take exactly one argument", decl);
10037 error ("%qD must take exactly two arguments", decl);
10041 /* More Effective C++ rule 7. */
10043 && (operator_code == TRUTH_ANDIF_EXPR
10044 || operator_code == TRUTH_ORIF_EXPR
10045 || operator_code == COMPOUND_EXPR))
10046 warning (OPT_Weffc__, "user-defined %qD always evaluates both arguments",
10050 /* Effective C++ rule 23. */
10053 && !DECL_ASSIGNMENT_OPERATOR_P (decl)
10054 && (operator_code == PLUS_EXPR
10055 || operator_code == MINUS_EXPR
10056 || operator_code == TRUNC_DIV_EXPR
10057 || operator_code == MULT_EXPR
10058 || operator_code == TRUNC_MOD_EXPR)
10059 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
10060 warning (OPT_Weffc__, "%qD should return by value", decl);
10062 /* [over.oper]/8 */
10063 for (; argtypes && argtypes != void_list_node;
10064 argtypes = TREE_CHAIN (argtypes))
10065 if (TREE_PURPOSE (argtypes))
10067 TREE_PURPOSE (argtypes) = NULL_TREE;
10068 if (operator_code == POSTINCREMENT_EXPR
10069 || operator_code == POSTDECREMENT_EXPR)
10072 pedwarn ("%qD cannot have default arguments", decl);
10076 error ("%qD cannot have default arguments", decl);
10084 /* Return a string giving the keyword associate with CODE. */
10086 static const char *
10087 tag_name (enum tag_types code)
10099 case typename_type:
10102 gcc_unreachable ();
10106 /* Name lookup in an elaborated-type-specifier (after the keyword
10107 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
10108 elaborated-type-specifier is invalid, issue a diagnostic and return
10109 error_mark_node; otherwise, return the *_TYPE to which it referred.
10110 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
10113 check_elaborated_type_specifier (enum tag_types tag_code,
10115 bool allow_template_p)
10121 struct S { struct S *p; };
10123 name lookup will find the TYPE_DECL for the implicit "S::S"
10124 typedef. Adjust for that here. */
10125 if (DECL_SELF_REFERENCE_P (decl))
10126 decl = TYPE_NAME (TREE_TYPE (decl));
10128 type = TREE_TYPE (decl);
10130 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
10131 is false for this case as well. */
10132 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
10134 error ("using template type parameter %qT after %qs",
10135 type, tag_name (tag_code));
10136 return error_mark_node;
10140 If the identifier resolves to a typedef-name or a template
10141 type-parameter, the elaborated-type-specifier is ill-formed.
10143 In other words, the only legitimate declaration to use in the
10144 elaborated type specifier is the implicit typedef created when
10145 the type is declared. */
10146 else if (!DECL_IMPLICIT_TYPEDEF_P (decl)
10147 && tag_code != typename_type)
10149 error ("using typedef-name %qD after %qs", decl, tag_name (tag_code));
10150 error ("%q+D has a previous declaration here", decl);
10151 return error_mark_node;
10153 else if (TREE_CODE (type) != RECORD_TYPE
10154 && TREE_CODE (type) != UNION_TYPE
10155 && tag_code != enum_type
10156 && tag_code != typename_type)
10158 error ("%qT referred to as %qs", type, tag_name (tag_code));
10159 error ("%q+T has a previous declaration here", type);
10160 return error_mark_node;
10162 else if (TREE_CODE (type) != ENUMERAL_TYPE
10163 && tag_code == enum_type)
10165 error ("%qT referred to as enum", type);
10166 error ("%q+T has a previous declaration here", type);
10167 return error_mark_node;
10169 else if (!allow_template_p
10170 && TREE_CODE (type) == RECORD_TYPE
10171 && CLASSTYPE_IS_TEMPLATE (type))
10173 /* If a class template appears as elaborated type specifier
10174 without a template header such as:
10176 template <class T> class C {};
10177 void f(class C); // No template header here
10179 then the required template argument is missing. */
10180 error ("template argument required for %<%s %T%>",
10181 tag_name (tag_code),
10182 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
10183 return error_mark_node;
10189 /* Lookup NAME in elaborate type specifier in scope according to
10190 SCOPE and issue diagnostics if necessary.
10191 Return *_TYPE node upon success, NULL_TREE when the NAME is not
10192 found, and ERROR_MARK_NODE for type error. */
10195 lookup_and_check_tag (enum tag_types tag_code, tree name,
10196 tag_scope scope, bool template_header_p)
10200 if (scope == ts_global)
10202 /* First try ordinary name lookup, ignoring hidden class name
10203 injected via friend declaration. */
10204 decl = lookup_name_prefer_type (name, 2);
10205 /* If that fails, the name will be placed in the smallest
10206 non-class, non-function-prototype scope according to 3.3.1/5.
10207 We may already have a hidden name declared as friend in this
10208 scope. So lookup again but not ignoring hidden names.
10209 If we find one, that name will be made visible rather than
10210 creating a new tag. */
10212 decl = lookup_type_scope (name, ts_within_enclosing_non_class);
10215 decl = lookup_type_scope (name, scope);
10217 if (decl && DECL_CLASS_TEMPLATE_P (decl))
10218 decl = DECL_TEMPLATE_RESULT (decl);
10220 if (decl && TREE_CODE (decl) == TYPE_DECL)
10222 /* Look for invalid nested type:
10226 if (scope == ts_current && DECL_SELF_REFERENCE_P (decl))
10228 error ("%qD has the same name as the class in which it is "
10231 return error_mark_node;
10234 /* Two cases we need to consider when deciding if a class
10235 template is allowed as an elaborated type specifier:
10236 1. It is a self reference to its own class.
10237 2. It comes with a template header.
10241 template <class T> class C {
10242 class C *c1; // DECL_SELF_REFERENCE_P is true
10245 template <class U> class C; // template_header_p is true
10246 template <class T> class C<T>::D {
10247 class C *c2; // DECL_SELF_REFERENCE_P is true
10250 t = check_elaborated_type_specifier (tag_code,
10253 | DECL_SELF_REFERENCE_P (decl));
10256 else if (decl && TREE_CODE (decl) == TREE_LIST)
10258 error ("reference to %qD is ambiguous", name);
10259 print_candidates (decl);
10260 return error_mark_node;
10266 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
10267 Define the tag as a forward-reference if it is not defined.
10269 If a declaration is given, process it here, and report an error if
10270 multiple declarations are not identical.
10272 SCOPE is TS_CURRENT when this is also a definition. Only look in
10273 the current frame for the name (since C++ allows new names in any
10274 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
10275 declaration. Only look beginning from the current scope outward up
10276 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
10278 TEMPLATE_HEADER_P is true when this declaration is preceded by
10279 a set of template parameters. */
10282 xref_tag (enum tag_types tag_code, tree name,
10283 tag_scope scope, bool template_header_p)
10285 enum tree_code code;
10287 tree context = NULL_TREE;
10289 timevar_push (TV_NAME_LOOKUP);
10291 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
10297 code = RECORD_TYPE;
10303 code = ENUMERAL_TYPE;
10306 gcc_unreachable ();
10309 /* In case of anonymous name, xref_tag is only called to
10310 make type node and push name. Name lookup is not required. */
10311 if (ANON_AGGRNAME_P (name))
10314 t = lookup_and_check_tag (tag_code, name,
10315 scope, template_header_p);
10317 if (t == error_mark_node)
10318 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10320 if (scope != ts_current && t && current_class_type
10321 && template_class_depth (current_class_type)
10322 && template_header_p)
10324 /* Since SCOPE is not TS_CURRENT, we are not looking at a
10325 definition of this tag. Since, in addition, we are currently
10326 processing a (member) template declaration of a template
10327 class, we must be very careful; consider:
10334 { template <class V>
10335 friend struct S1; };
10337 Here, the S2::S1 declaration should not be confused with the
10338 outer declaration. In particular, the inner version should
10339 have a template parameter of level 2, not level 1. This
10340 would be particularly important if the member declaration
10343 template <class V = U> friend struct S1;
10345 say, when we should tsubst into `U' when instantiating
10346 S2. On the other hand, when presented with:
10356 we must find the inner binding eventually. We
10357 accomplish this by making sure that the new type we
10358 create to represent this declaration has the right
10360 context = TYPE_CONTEXT (t);
10366 /* If no such tag is yet defined, create a forward-reference node
10367 and record it as the "definition".
10368 When a real declaration of this type is found,
10369 the forward-reference will be altered into a real type. */
10370 if (code == ENUMERAL_TYPE)
10372 error ("use of enum %q#D without previous declaration", name);
10373 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10377 t = make_aggr_type (code);
10378 TYPE_CONTEXT (t) = context;
10379 t = pushtag (name, t, scope);
10384 if (template_header_p && IS_AGGR_TYPE (t))
10386 if (!redeclare_class_template (t, current_template_parms))
10387 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10389 else if (!processing_template_decl
10390 && CLASS_TYPE_P (t)
10391 && CLASSTYPE_IS_TEMPLATE (t))
10393 error ("redeclaration of %qT as a non-template", t);
10394 error ("previous declaration %q+D", t);
10395 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10398 /* Make injected friend class visible. */
10399 if (scope != ts_within_enclosing_non_class
10400 && hidden_name_p (TYPE_NAME (t)))
10402 DECL_ANTICIPATED (TYPE_NAME (t)) = 0;
10403 DECL_FRIEND_P (TYPE_NAME (t)) = 0;
10405 if (TYPE_TEMPLATE_INFO (t))
10407 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t)) = 0;
10408 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t)) = 0;
10413 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
10417 xref_tag_from_type (tree old, tree id, tag_scope scope)
10419 enum tag_types tag_kind;
10421 if (TREE_CODE (old) == RECORD_TYPE)
10422 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
10424 tag_kind = union_type;
10426 if (id == NULL_TREE)
10427 id = TYPE_IDENTIFIER (old);
10429 return xref_tag (tag_kind, id, scope, false);
10432 /* Create the binfo hierarchy for REF with (possibly NULL) base list
10433 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
10434 access_* node, and the TREE_VALUE is the type of the base-class.
10435 Non-NULL TREE_TYPE indicates virtual inheritance.
10437 Returns true if the binfo heirarchy was successfully created,
10438 false if an error was detected. */
10441 xref_basetypes (tree ref, tree base_list)
10444 tree binfo, base_binfo;
10445 unsigned max_vbases = 0; /* Maximum direct & indirect virtual bases. */
10446 unsigned max_bases = 0; /* Maximum direct bases. */
10448 tree default_access;
10449 tree igo_prev; /* Track Inheritance Graph Order. */
10451 if (ref == error_mark_node)
10454 /* The base of a derived class is private by default, all others are
10456 default_access = (TREE_CODE (ref) == RECORD_TYPE
10457 && CLASSTYPE_DECLARED_CLASS (ref)
10458 ? access_private_node : access_public_node);
10460 /* First, make sure that any templates in base-classes are
10461 instantiated. This ensures that if we call ourselves recursively
10462 we do not get confused about which classes are marked and which
10464 basep = &base_list;
10467 tree basetype = TREE_VALUE (*basep);
10469 if (!(processing_template_decl && uses_template_parms (basetype))
10470 && !complete_type_or_else (basetype, NULL))
10471 /* An incomplete type. Remove it from the list. */
10472 *basep = TREE_CHAIN (*basep);
10476 if (TREE_TYPE (*basep))
10478 if (CLASS_TYPE_P (basetype))
10479 max_vbases += VEC_length (tree, CLASSTYPE_VBASECLASSES (basetype));
10480 basep = &TREE_CHAIN (*basep);
10484 TYPE_MARKED_P (ref) = 1;
10486 /* The binfo slot should be empty, unless this is an (ill-formed)
10488 gcc_assert (!TYPE_BINFO (ref) || TYPE_SIZE (ref));
10489 gcc_assert (TYPE_MAIN_VARIANT (ref) == ref);
10491 binfo = make_tree_binfo (max_bases);
10493 TYPE_BINFO (ref) = binfo;
10494 BINFO_OFFSET (binfo) = size_zero_node;
10495 BINFO_TYPE (binfo) = ref;
10499 BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, gc, max_bases);
10500 /* An aggregate cannot have baseclasses. */
10501 CLASSTYPE_NON_AGGREGATE (ref) = 1;
10503 if (TREE_CODE (ref) == UNION_TYPE)
10505 error ("derived union %qT invalid", ref);
10512 if (TYPE_FOR_JAVA (ref))
10514 error ("Java class %qT cannot have multiple bases", ref);
10521 CLASSTYPE_VBASECLASSES (ref) = VEC_alloc (tree, gc, max_vbases);
10523 if (TYPE_FOR_JAVA (ref))
10525 error ("Java class %qT cannot have virtual bases", ref);
10530 for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list))
10532 tree access = TREE_PURPOSE (base_list);
10533 int via_virtual = TREE_TYPE (base_list) != NULL_TREE;
10534 tree basetype = TREE_VALUE (base_list);
10536 if (access == access_default_node)
10537 access = default_access;
10539 if (TREE_CODE (basetype) == TYPE_DECL)
10540 basetype = TREE_TYPE (basetype);
10541 if (TREE_CODE (basetype) != RECORD_TYPE
10542 && TREE_CODE (basetype) != TYPENAME_TYPE
10543 && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
10544 && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM)
10546 error ("base type %qT fails to be a struct or class type",
10551 if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0))
10552 TYPE_FOR_JAVA (ref) = 1;
10554 base_binfo = NULL_TREE;
10555 if (CLASS_TYPE_P (basetype) && !dependent_type_p (basetype))
10557 base_binfo = TYPE_BINFO (basetype);
10558 /* The original basetype could have been a typedef'd type. */
10559 basetype = BINFO_TYPE (base_binfo);
10561 /* Inherit flags from the base. */
10562 TYPE_HAS_NEW_OPERATOR (ref)
10563 |= TYPE_HAS_NEW_OPERATOR (basetype);
10564 TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
10565 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
10566 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
10567 TYPE_HAS_CONVERSION (ref) |= TYPE_HAS_CONVERSION (basetype);
10568 CLASSTYPE_DIAMOND_SHAPED_P (ref)
10569 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype);
10570 CLASSTYPE_REPEATED_BASE_P (ref)
10571 |= CLASSTYPE_REPEATED_BASE_P (basetype);
10574 /* We must do this test after we've seen through a typedef
10576 if (TYPE_MARKED_P (basetype))
10578 if (basetype == ref)
10579 error ("recursive type %qT undefined", basetype);
10581 error ("duplicate base type %qT invalid", basetype);
10584 TYPE_MARKED_P (basetype) = 1;
10586 base_binfo = copy_binfo (base_binfo, basetype, ref,
10587 &igo_prev, via_virtual);
10588 if (!BINFO_INHERITANCE_CHAIN (base_binfo))
10589 BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
10591 BINFO_BASE_APPEND (binfo, base_binfo);
10592 BINFO_BASE_ACCESS_APPEND (binfo, access);
10595 if (VEC_space (tree, CLASSTYPE_VBASECLASSES (ref), 1))
10596 /* If we have space in the vbase vector, we must have shared at
10597 least one of them, and are therefore diamond shaped. */
10598 CLASSTYPE_DIAMOND_SHAPED_P (ref) = 1;
10600 /* Unmark all the types. */
10601 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
10602 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
10603 TYPE_MARKED_P (ref) = 0;
10605 /* Now see if we have a repeated base type. */
10606 if (!CLASSTYPE_REPEATED_BASE_P (ref))
10608 for (base_binfo = binfo; base_binfo;
10609 base_binfo = TREE_CHAIN (base_binfo))
10611 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
10613 CLASSTYPE_REPEATED_BASE_P (ref) = 1;
10616 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 1;
10618 for (base_binfo = binfo; base_binfo;
10619 base_binfo = TREE_CHAIN (base_binfo))
10620 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
10621 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
10630 /* Begin compiling the definition of an enumeration type.
10632 Returns the type object, as yet incomplete.
10633 Also records info about it so that build_enumerator
10634 may be used to declare the individual values as they are read. */
10637 start_enum (tree name)
10641 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
10643 /* If this is the real definition for a previous forward reference,
10644 fill in the contents in the same object that used to be the
10645 forward reference. */
10647 enumtype = lookup_and_check_tag (enum_type, name,
10648 /*tag_scope=*/ts_current,
10649 /*template_header_p=*/false);
10651 if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
10653 error ("multiple definition of %q#T", enumtype);
10654 error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype));
10655 /* Clear out TYPE_VALUES, and start again. */
10656 TYPE_VALUES (enumtype) = NULL_TREE;
10660 /* In case of error, make a dummy enum to allow parsing to
10662 if (enumtype == error_mark_node)
10663 name = make_anon_name ();
10665 enumtype = make_node (ENUMERAL_TYPE);
10666 enumtype = pushtag (name, enumtype, /*tag_scope=*/ts_current);
10672 /* After processing and defining all the values of an enumeration type,
10673 install their decls in the enumeration type and finish it off.
10674 ENUMTYPE is the type object and VALUES a list of name-value pairs. */
10677 finish_enum (tree enumtype)
10686 bool use_short_enum;
10690 integer_type_kind itk;
10691 tree underlying_type = NULL_TREE;
10693 /* We built up the VALUES in reverse order. */
10694 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
10696 /* For an enum defined in a template, just set the type of the values;
10697 all further processing is postponed until the template is
10698 instantiated. We need to set the type so that tsubst of a CONST_DECL
10700 if (processing_template_decl)
10702 for (values = TYPE_VALUES (enumtype);
10704 values = TREE_CHAIN (values))
10705 TREE_TYPE (TREE_VALUE (values)) = enumtype;
10706 if (at_function_scope_p ())
10707 add_stmt (build_min (TAG_DEFN, enumtype));
10711 /* Determine the minimum and maximum values of the enumerators. */
10712 if (TYPE_VALUES (enumtype))
10714 minnode = maxnode = NULL_TREE;
10716 for (values = TYPE_VALUES (enumtype);
10718 values = TREE_CHAIN (values))
10720 decl = TREE_VALUE (values);
10722 /* [dcl.enum]: Following the closing brace of an enum-specifier,
10723 each enumerator has the type of its enumeration. Prior to the
10724 closing brace, the type of each enumerator is the type of its
10725 initializing value. */
10726 TREE_TYPE (decl) = enumtype;
10728 /* Update the minimum and maximum values, if appropriate. */
10729 value = DECL_INITIAL (decl);
10730 if (value == error_mark_node)
10731 value = integer_zero_node;
10732 /* Figure out what the minimum and maximum values of the
10733 enumerators are. */
10735 minnode = maxnode = value;
10736 else if (tree_int_cst_lt (maxnode, value))
10738 else if (tree_int_cst_lt (value, minnode))
10745 If the enumerator-list is empty, the underlying type is as if
10746 the enumeration had a single enumerator with value 0. */
10747 minnode = maxnode = integer_zero_node;
10749 /* Compute the number of bits require to represent all values of the
10750 enumeration. We must do this before the type of MINNODE and
10751 MAXNODE are transformed, since min_precision relies on the
10752 TREE_TYPE of the value it is passed. */
10753 unsignedp = tree_int_cst_sgn (minnode) >= 0;
10754 lowprec = min_precision (minnode, unsignedp);
10755 highprec = min_precision (maxnode, unsignedp);
10756 precision = MAX (lowprec, highprec);
10758 /* Determine the underlying type of the enumeration.
10762 The underlying type of an enumeration is an integral type that
10763 can represent all the enumerator values defined in the
10764 enumeration. It is implementation-defined which integral type is
10765 used as the underlying type for an enumeration except that the
10766 underlying type shall not be larger than int unless the value of
10767 an enumerator cannot fit in an int or unsigned int.
10769 We use "int" or an "unsigned int" as the underlying type, even if
10770 a smaller integral type would work, unless the user has
10771 explicitly requested that we use the smallest possible type. The
10772 user can request that for all enumerations with a command line
10773 flag, or for just one enumeration with an attribute. */
10775 use_short_enum = flag_short_enums
10776 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype));
10778 for (itk = (use_short_enum ? itk_char : itk_int);
10782 underlying_type = integer_types[itk];
10783 if (TYPE_PRECISION (underlying_type) >= precision
10784 && TYPE_UNSIGNED (underlying_type) == unsignedp)
10787 if (itk == itk_none)
10791 IF no integral type can represent all the enumerator values, the
10792 enumeration is ill-formed. */
10793 error ("no integral type can represent all of the enumerator values "
10794 "for %qT", enumtype);
10795 precision = TYPE_PRECISION (long_long_integer_type_node);
10796 underlying_type = integer_types[itk_unsigned_long_long];
10799 /* Compute the minium and maximum values for the type.
10803 For an enumeration where emin is the smallest enumerator and emax
10804 is the largest, the values of the enumeration are the values of the
10805 underlying type in the range bmin to bmax, where bmin and bmax are,
10806 respectively, the smallest and largest values of the smallest bit-
10807 field that can store emin and emax. */
10809 /* The middle-end currently assumes that types with TYPE_PRECISION
10810 narrower than their underlying type are suitably zero or sign
10811 extended to fill their mode. g++ doesn't make these guarantees.
10812 Until the middle-end can represent such paradoxical types, we
10813 set the TYPE_PRECISION to the width of the underlying type. */
10814 TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type);
10816 set_min_and_max_values_for_integral_type (enumtype, precision, unsignedp);
10820 The value of sizeof() applied to an enumeration type, an object
10821 of an enumeration type, or an enumerator, is the value of sizeof()
10822 applied to the underlying type. */
10823 TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
10824 TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
10825 TYPE_MODE (enumtype) = TYPE_MODE (underlying_type);
10826 TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
10827 TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
10828 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);
10830 /* Convert each of the enumerators to the type of the underlying
10831 type of the enumeration. */
10832 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
10834 location_t saved_location;
10836 decl = TREE_VALUE (values);
10837 saved_location = input_location;
10838 input_location = DECL_SOURCE_LOCATION (decl);
10839 value = perform_implicit_conversion (underlying_type,
10840 DECL_INITIAL (decl));
10841 input_location = saved_location;
10843 /* Do not clobber shared ints. */
10844 value = copy_node (value);
10846 TREE_TYPE (value) = enumtype;
10847 DECL_INITIAL (decl) = value;
10848 TREE_VALUE (values) = value;
10851 /* Fix up all variant types of this enum type. */
10852 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
10854 TYPE_VALUES (t) = TYPE_VALUES (enumtype);
10855 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
10856 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
10857 TYPE_SIZE (t) = TYPE_SIZE (enumtype);
10858 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
10859 TYPE_MODE (t) = TYPE_MODE (enumtype);
10860 TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
10861 TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
10862 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
10863 TYPE_UNSIGNED (t) = TYPE_UNSIGNED (enumtype);
10866 /* Finish debugging output for this type. */
10867 rest_of_type_compilation (enumtype, namespace_bindings_p ());
10870 /* Build and install a CONST_DECL for an enumeration constant of the
10871 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
10872 Assignment of sequential values by default is handled here. */
10875 build_enumerator (tree name, tree value, tree enumtype)
10881 /* If the VALUE was erroneous, pretend it wasn't there; that will
10882 result in the enum being assigned the next value in sequence. */
10883 if (value == error_mark_node)
10886 /* Remove no-op casts from the value. */
10888 STRIP_TYPE_NOPS (value);
10890 if (! processing_template_decl)
10892 /* Validate and default VALUE. */
10893 if (value != NULL_TREE)
10895 value = integral_constant_value (value);
10897 if (TREE_CODE (value) == INTEGER_CST)
10899 value = perform_integral_promotions (value);
10900 constant_expression_warning (value);
10904 error ("enumerator value for %qD not integer constant", name);
10909 /* Default based on previous value. */
10910 if (value == NULL_TREE)
10912 if (TYPE_VALUES (enumtype))
10915 unsigned HOST_WIDE_INT lo;
10919 /* The next value is the previous value plus one. We can
10920 safely assume that the previous value is an INTEGER_CST.
10921 add_double doesn't know the type of the target expression,
10922 so we must check with int_fits_type_p as well. */
10923 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
10924 overflowed = add_double (TREE_INT_CST_LOW (prev_value),
10925 TREE_INT_CST_HIGH (prev_value),
10927 value = build_int_cst_wide (TREE_TYPE (prev_value), lo, hi);
10928 overflowed |= !int_fits_type_p (value, TREE_TYPE (prev_value));
10932 error ("overflow in enumeration values at %qD", name);
10933 value = error_mark_node;
10937 value = integer_zero_node;
10940 /* Remove no-op casts from the value. */
10941 STRIP_TYPE_NOPS (value);
10944 /* C++ associates enums with global, function, or class declarations. */
10945 context = current_scope ();
10947 /* Build the actual enumeration constant. Note that the enumeration
10948 constants have the type of their initializers until the
10949 enumeration is complete:
10953 Following the closing brace of an enum-specifier, each enumer-
10954 ator has the type of its enumeration. Prior to the closing
10955 brace, the type of each enumerator is the type of its
10956 initializing value.
10958 In finish_enum we will reset the type. Of course, if we're
10959 processing a template, there may be no value. */
10960 type = value ? TREE_TYPE (value) : NULL_TREE;
10962 if (context && context == current_class_type)
10963 /* This enum declaration is local to the class. We need the full
10964 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
10965 decl = build_lang_decl (CONST_DECL, name, type);
10967 /* It's a global enum, or it's local to a function. (Note local to
10968 a function could mean local to a class method. */
10969 decl = build_decl (CONST_DECL, name, type);
10971 DECL_CONTEXT (decl) = FROB_CONTEXT (context);
10972 TREE_CONSTANT (decl) = 1;
10973 TREE_INVARIANT (decl) = 1;
10974 TREE_READONLY (decl) = 1;
10975 DECL_INITIAL (decl) = value;
10977 if (context && context == current_class_type)
10978 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
10979 on the TYPE_FIELDS list for `S'. (That's so that you can say
10980 things like `S::i' later.) */
10981 finish_member_declaration (decl);
10985 /* Add this enumeration constant to the list for this type. */
10986 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
10990 /* We're defining DECL. Make sure that it's type is OK. */
10993 check_function_type (tree decl, tree current_function_parms)
10995 tree fntype = TREE_TYPE (decl);
10996 tree return_type = complete_type (TREE_TYPE (fntype));
10998 /* In a function definition, arg types must be complete. */
10999 require_complete_types_for_parms (current_function_parms);
11001 if (dependent_type_p (return_type))
11003 if (!COMPLETE_OR_VOID_TYPE_P (return_type))
11005 tree args = TYPE_ARG_TYPES (fntype);
11007 error ("return type %q#T is incomplete", return_type);
11009 /* Make it return void instead. */
11010 if (TREE_CODE (fntype) == METHOD_TYPE)
11011 fntype = build_method_type_directly (TREE_TYPE (TREE_VALUE (args)),
11013 TREE_CHAIN (args));
11015 fntype = build_function_type (void_type_node, args);
11017 = build_exception_variant (fntype,
11018 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)));
11021 abstract_virtuals_error (decl, TREE_TYPE (fntype));
11024 /* Create the FUNCTION_DECL for a function definition.
11025 DECLSPECS and DECLARATOR are the parts of the declaration;
11026 they describe the function's name and the type it returns,
11027 but twisted together in a fashion that parallels the syntax of C.
11029 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
11030 DECLARATOR is really the DECL for the function we are about to
11031 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
11032 indicating that the function is an inline defined in-class.
11034 This function creates a binding context for the function body
11035 as well as setting up the FUNCTION_DECL in current_function_decl.
11037 For C++, we must first check whether that datum makes any sense.
11038 For example, "class A local_a(1,2);" means that variable local_a
11039 is an aggregate of type A, which should have a constructor
11040 applied to it with the argument list [1, 2].
11042 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
11043 or may be a BLOCK if the function has been defined previously
11044 in this translation unit. On exit, DECL_INITIAL (decl1) will be
11045 error_mark_node if the function has never been defined, or
11046 a BLOCK if the function has been defined somewhere. */
11049 start_preparsed_function (tree decl1, tree attrs, int flags)
11051 tree ctype = NULL_TREE;
11054 int doing_friend = 0;
11055 struct cp_binding_level *bl;
11056 tree current_function_parms;
11057 struct c_fileinfo *finfo
11058 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1)));
11059 bool honor_interface;
11061 /* Sanity check. */
11062 gcc_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE);
11063 gcc_assert (TREE_CHAIN (void_list_node) == NULL_TREE);
11065 fntype = TREE_TYPE (decl1);
11066 if (TREE_CODE (fntype) == METHOD_TYPE)
11067 ctype = TYPE_METHOD_BASETYPE (fntype);
11069 /* ISO C++ 11.4/5. A friend function defined in a class is in
11070 the (lexical) scope of the class in which it is defined. */
11071 if (!ctype && DECL_FRIEND_P (decl1))
11073 ctype = DECL_FRIEND_CONTEXT (decl1);
11075 /* CTYPE could be null here if we're dealing with a template;
11076 for example, `inline friend float foo()' inside a template
11077 will have no CTYPE set. */
11078 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
11084 if (DECL_DECLARED_INLINE_P (decl1)
11085 && lookup_attribute ("noinline", attrs))
11086 warning (0, "inline function %q+D given attribute noinline", decl1);
11088 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
11089 /* This is a constructor, we must ensure that any default args
11090 introduced by this definition are propagated to the clones
11091 now. The clones are used directly in overload resolution. */
11092 adjust_clone_args (decl1);
11094 /* Sometimes we don't notice that a function is a static member, and
11095 build a METHOD_TYPE for it. Fix that up now. */
11096 if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
11097 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
11099 revert_static_member_fn (decl1);
11103 /* Set up current_class_type, and enter the scope of the class, if
11106 push_nested_class (ctype);
11107 else if (DECL_STATIC_FUNCTION_P (decl1))
11108 push_nested_class (DECL_CONTEXT (decl1));
11110 /* Now that we have entered the scope of the class, we must restore
11111 the bindings for any template parameters surrounding DECL1, if it
11112 is an inline member template. (Order is important; consider the
11113 case where a template parameter has the same name as a field of
11114 the class.) It is not until after this point that
11115 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
11116 if (flags & SF_INCLASS_INLINE)
11117 maybe_begin_member_template_processing (decl1);
11119 /* Effective C++ rule 15. */
11121 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
11122 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
11123 warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");
11125 /* Make the init_value nonzero so pushdecl knows this is not tentative.
11126 error_mark_node is replaced below (in poplevel) with the BLOCK. */
11127 if (!DECL_INITIAL (decl1))
11128 DECL_INITIAL (decl1) = error_mark_node;
11130 /* This function exists in static storage.
11131 (This does not mean `static' in the C sense!) */
11132 TREE_STATIC (decl1) = 1;
11134 /* We must call push_template_decl after current_class_type is set
11135 up. (If we are processing inline definitions after exiting a
11136 class scope, current_class_type will be NULL_TREE until set above
11137 by push_nested_class.) */
11138 if (processing_template_decl)
11140 /* FIXME: Handle error_mark_node more gracefully. */
11141 tree newdecl1 = push_template_decl (decl1);
11142 if (newdecl1 != error_mark_node)
11146 /* We are now in the scope of the function being defined. */
11147 current_function_decl = decl1;
11149 /* Save the parm names or decls from this function's declarator
11150 where store_parm_decls will find them. */
11151 current_function_parms = DECL_ARGUMENTS (decl1);
11153 /* Make sure the parameter and return types are reasonable. When
11154 you declare a function, these types can be incomplete, but they
11155 must be complete when you define the function. */
11156 check_function_type (decl1, current_function_parms);
11158 /* Build the return declaration for the function. */
11159 restype = TREE_TYPE (fntype);
11160 /* Promote the value to int before returning it. */
11161 if (c_promoting_integer_type_p (restype))
11162 restype = type_promotes_to (restype);
11163 if (DECL_RESULT (decl1) == NULL_TREE)
11167 resdecl = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
11168 DECL_ARTIFICIAL (resdecl) = 1;
11169 DECL_IGNORED_P (resdecl) = 1;
11170 DECL_RESULT (decl1) = resdecl;
11172 cp_apply_type_quals_to_decl (cp_type_quals (restype), resdecl);
11175 /* Let the user know we're compiling this function. */
11176 announce_function (decl1);
11178 /* Record the decl so that the function name is defined.
11179 If we already have a decl for this name, and it is a FUNCTION_DECL,
11180 use the old decl. */
11181 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
11183 /* A specialization is not used to guide overload resolution. */
11184 if (!DECL_FUNCTION_MEMBER_P (decl1)
11185 && !(DECL_USE_TEMPLATE (decl1) &&
11186 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1))))
11188 tree olddecl = pushdecl (decl1);
11190 if (olddecl == error_mark_node)
11191 /* If something went wrong when registering the declaration,
11192 use DECL1; we have to have a FUNCTION_DECL to use when
11193 parsing the body of the function. */
11196 /* Otherwise, OLDDECL is either a previous declaration of
11197 the same function or DECL1 itself. */
11202 /* We need to set the DECL_CONTEXT. */
11203 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
11204 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
11206 fntype = TREE_TYPE (decl1);
11208 /* If #pragma weak applies, mark the decl appropriately now.
11209 The pragma only applies to global functions. Because
11210 determining whether or not the #pragma applies involves
11211 computing the mangled name for the declaration, we cannot
11212 apply the pragma until after we have merged this declaration
11213 with any previous declarations; if the original declaration
11214 has a linkage specification, that specification applies to
11215 the definition as well, and may affect the mangled name. */
11216 if (!DECL_CONTEXT (decl1))
11217 maybe_apply_pragma_weak (decl1);
11220 /* Reset this in case the call to pushdecl changed it. */
11221 current_function_decl = decl1;
11223 gcc_assert (DECL_INITIAL (decl1));
11225 /* This function may already have been parsed, in which case just
11226 return; our caller will skip over the body without parsing. */
11227 if (DECL_INITIAL (decl1) != error_mark_node)
11230 /* Initialize RTL machinery. We cannot do this until
11231 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
11232 even when processing a template; this is how we get
11233 CFUN set up, and our per-function variables initialized.
11234 FIXME factor out the non-RTL stuff. */
11235 bl = current_binding_level;
11236 allocate_struct_function (decl1);
11237 current_binding_level = bl;
11239 /* Even though we're inside a function body, we still don't want to
11240 call expand_expr to calculate the size of a variable-sized array.
11241 We haven't necessarily assigned RTL to all variables yet, so it's
11242 not safe to try to expand expressions involving them. */
11243 cfun->x_dont_save_pending_sizes_p = 1;
11245 /* Start the statement-tree, start the tree now. */
11246 DECL_SAVED_TREE (decl1) = push_stmt_list ();
11248 /* If we are (erroneously) defining a function that we have already
11249 defined before, wipe out what we knew before. */
11250 if (!DECL_PENDING_INLINE_P (decl1))
11251 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
11253 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
11255 /* We know that this was set up by `grokclassfn'. We do not
11256 wait until `store_parm_decls', since evil parse errors may
11257 never get us to that point. Here we keep the consistency
11258 between `current_class_type' and `current_class_ptr'. */
11259 tree t = DECL_ARGUMENTS (decl1);
11261 gcc_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL);
11262 gcc_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE);
11264 cp_function_chain->x_current_class_ref
11265 = build_indirect_ref (t, NULL);
11266 cp_function_chain->x_current_class_ptr = t;
11268 /* Constructors and destructors need to know whether they're "in
11269 charge" of initializing virtual base classes. */
11270 t = TREE_CHAIN (t);
11271 if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
11273 current_in_charge_parm = t;
11274 t = TREE_CHAIN (t);
11276 if (DECL_HAS_VTT_PARM_P (decl1))
11278 gcc_assert (DECL_NAME (t) == vtt_parm_identifier);
11279 current_vtt_parm = t;
11283 honor_interface = (!DECL_TEMPLATE_INSTANTIATION (decl1)
11284 /* Implicitly-defined methods (like the
11285 destructor for a class in which no destructor
11286 is explicitly declared) must not be defined
11287 until their definition is needed. So, we
11288 ignore interface specifications for
11289 compiler-generated functions. */
11290 && !DECL_ARTIFICIAL (decl1));
11292 if (DECL_INTERFACE_KNOWN (decl1))
11294 tree ctx = decl_function_context (decl1);
11296 if (DECL_NOT_REALLY_EXTERN (decl1))
11297 DECL_EXTERNAL (decl1) = 0;
11299 if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
11300 && TREE_PUBLIC (ctx))
11301 /* This is a function in a local class in an extern inline
11303 comdat_linkage (decl1);
11305 /* If this function belongs to an interface, it is public.
11306 If it belongs to someone else's interface, it is also external.
11307 This only affects inlines and template instantiations. */
11308 else if (!finfo->interface_unknown && honor_interface)
11310 if (DECL_DECLARED_INLINE_P (decl1)
11311 || DECL_TEMPLATE_INSTANTIATION (decl1)
11312 || processing_template_decl)
11314 DECL_EXTERNAL (decl1)
11315 = (finfo->interface_only
11316 || (DECL_DECLARED_INLINE_P (decl1)
11317 && ! flag_implement_inlines
11318 && !DECL_VINDEX (decl1)));
11320 /* For WIN32 we also want to put these in linkonce sections. */
11321 maybe_make_one_only (decl1);
11324 DECL_EXTERNAL (decl1) = 0;
11325 DECL_INTERFACE_KNOWN (decl1) = 1;
11326 /* If this function is in an interface implemented in this file,
11327 make sure that the backend knows to emit this function
11329 if (!DECL_EXTERNAL (decl1))
11330 mark_needed (decl1);
11332 else if (finfo->interface_unknown && finfo->interface_only
11333 && honor_interface)
11335 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
11336 interface, we will have both finfo->interface_unknown and
11337 finfo->interface_only set. In that case, we don't want to
11338 use the normal heuristics because someone will supply a
11339 #pragma implementation elsewhere, and deducing it here would
11340 produce a conflict. */
11341 comdat_linkage (decl1);
11342 DECL_EXTERNAL (decl1) = 0;
11343 DECL_INTERFACE_KNOWN (decl1) = 1;
11344 DECL_DEFER_OUTPUT (decl1) = 1;
11348 /* This is a definition, not a reference.
11349 So clear DECL_EXTERNAL. */
11350 DECL_EXTERNAL (decl1) = 0;
11352 if ((DECL_DECLARED_INLINE_P (decl1)
11353 || DECL_TEMPLATE_INSTANTIATION (decl1))
11354 && ! DECL_INTERFACE_KNOWN (decl1)
11355 /* Don't try to defer nested functions for now. */
11356 && ! decl_function_context (decl1))
11357 DECL_DEFER_OUTPUT (decl1) = 1;
11359 DECL_INTERFACE_KNOWN (decl1) = 1;
11362 /* Determine the ELF visibility attribute for the function. We must not
11363 do this before calling "pushdecl", as we must allow "duplicate_decls"
11364 to merge any attributes appropriately. We also need to wait until
11366 if (!DECL_CLONED_FUNCTION_P (decl1))
11367 determine_visibility (decl1);
11369 begin_scope (sk_function_parms, decl1);
11373 if (DECL_DESTRUCTOR_P (decl1)
11374 || (DECL_CONSTRUCTOR_P (decl1)
11375 && targetm.cxx.cdtor_returns_this ()))
11377 cdtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
11378 DECL_CONTEXT (cdtor_label) = current_function_decl;
11381 start_fname_decls ();
11383 store_parm_decls (current_function_parms);
11387 /* APPLE LOCAL begin warn missing prototype 6261539 */
11389 fn_previously_found (tree decl, tree olddecl)
11396 if (TREE_CODE (olddecl) == OVERLOAD)
11398 if (OVL_CHAIN (olddecl) == NULL_TREE)
11399 olddecl = OVL_CURRENT (olddecl);
11403 for (match = olddecl; match; match = OVL_NEXT (match))
11405 if (fn_previously_found (decl, OVL_CURRENT (match)))
11412 /* Don't warn about previously erroneous things that have the same
11414 if (TREE_TYPE (olddecl) == error_mark_node)
11417 /* Internally defined things still need a prototype to escape the
11419 if (DECL_ARTIFICIAL (olddecl))
11422 if (TREE_CODE (olddecl) != FUNCTION_DECL)
11425 /* These will match or error, don't also spew prototype warnings. */
11426 if (DECL_EXTERN_C_P (olddecl)
11427 && DECL_EXTERN_C_P (decl))
11430 /* These will match or error, don't also spew prototype warnings. */
11431 if (compparms (TYPE_ARG_TYPES (TREE_TYPE (decl)),
11432 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
11435 types_match = decls_match (decl, olddecl);
11444 check_missing_prototype (tree decl)
11446 if (warn_missing_prototypes
11447 && namespace_bindings_p ()
11448 && TREE_PUBLIC (decl)
11449 && !DECL_MAIN_P (decl)
11450 && DECL_NON_THUNK_FUNCTION_P (decl)
11451 && ! DECL_FUNCTION_MEMBER_P (decl)
11452 && DECL_NAMESPACE_SCOPE_P (decl)
11453 && ! decl_anon_ns_mem_p (decl)
11454 && ! DECL_DECLARED_INLINE_P (decl))
11456 tree olddecl = namespace_binding (DECL_NAME (decl), DECL_CONTEXT (decl));
11457 if (!fn_previously_found (decl, olddecl))
11458 warning (OPT_Wmissing_prototypes, "no previous prototype for %q+D", decl);
11461 /* APPLE LOCAL end warn missing prototype 6261539 */
11463 /* Like start_preparsed_function, except that instead of a
11464 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
11466 Returns 1 on success. If the DECLARATOR is not suitable for a function
11467 (it defines a datum instead), we return 0, which tells
11468 yyparse to report a parse error. */
11471 start_function (cp_decl_specifier_seq *declspecs,
11472 const cp_declarator *declarator,
11477 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
11478 /* If the declarator is not suitable for a function definition,
11479 cause a syntax error. */
11480 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
11483 if (DECL_MAIN_P (decl1))
11484 /* main must return int. grokfndecl should have corrected it
11485 (and issued a diagnostic) if the user got it wrong. */
11486 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1)),
11487 integer_type_node));
11489 /* APPLE LOCAL begin warn missing prototype 6261539 */
11490 check_missing_prototype (decl1);
11491 /* APPLE LOCAL end warn missing prototype 6261539 */
11493 start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT);
11498 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
11502 use_eh_spec_block (tree fn)
11504 return (flag_exceptions && flag_enforce_eh_specs
11505 && !processing_template_decl
11506 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn))
11507 /* We insert the EH_SPEC_BLOCK only in the original
11508 function; then, it is copied automatically to the
11510 && !DECL_CLONED_FUNCTION_P (fn)
11511 /* Implicitly-generated constructors and destructors have
11512 exception specifications. However, those specifications
11513 are the union of the possible exceptions specified by the
11514 constructors/destructors for bases and members, so no
11515 unallowed exception will ever reach this function. By
11516 not creating the EH_SPEC_BLOCK we save a little memory,
11517 and we avoid spurious warnings about unreachable
11519 && !DECL_ARTIFICIAL (fn));
11522 /* Store the parameter declarations into the current function declaration.
11523 This is called after parsing the parameter declarations, before
11524 digesting the body of the function.
11526 Also install to binding contour return value identifier, if any. */
11529 store_parm_decls (tree current_function_parms)
11531 tree fndecl = current_function_decl;
11534 /* This is a chain of any other decls that came in among the parm
11535 declarations. If a parm is declared with enum {foo, bar} x;
11536 then CONST_DECLs for foo and bar are put here. */
11537 tree nonparms = NULL_TREE;
11539 if (current_function_parms)
11541 /* This case is when the function was defined with an ANSI prototype.
11542 The parms already have decls, so we need not do anything here
11543 except record them as in effect
11544 and complain if any redundant old-style parm decls were written. */
11546 tree specparms = current_function_parms;
11549 /* Must clear this because it might contain TYPE_DECLs declared
11551 current_binding_level->names = NULL;
11553 /* If we're doing semantic analysis, then we'll call pushdecl
11554 for each of these. We must do them in reverse order so that
11555 they end in the correct forward order. */
11556 specparms = nreverse (specparms);
11558 for (parm = specparms; parm; parm = next)
11560 next = TREE_CHAIN (parm);
11561 if (TREE_CODE (parm) == PARM_DECL)
11563 if (DECL_NAME (parm) == NULL_TREE
11564 || TREE_CODE (parm) != VOID_TYPE)
11567 error ("parameter %qD declared void", parm);
11571 /* If we find an enum constant or a type tag,
11572 put it aside for the moment. */
11573 TREE_CHAIN (parm) = NULL_TREE;
11574 nonparms = chainon (nonparms, parm);
11578 /* Get the decls in their original chain order and record in the
11579 function. This is all and only the PARM_DECLs that were
11580 pushed into scope by the loop above. */
11581 DECL_ARGUMENTS (fndecl) = getdecls ();
11584 DECL_ARGUMENTS (fndecl) = NULL_TREE;
11586 /* Now store the final chain of decls for the arguments
11587 as the decl-chain of the current lexical scope.
11588 Put the enumerators in as well, at the front so that
11589 DECL_ARGUMENTS is not modified. */
11590 current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));
11592 if (use_eh_spec_block (current_function_decl))
11593 current_eh_spec_block = begin_eh_spec_block ();
11597 /* We have finished doing semantic analysis on DECL, but have not yet
11598 generated RTL for its body. Save away our current state, so that
11599 when we want to generate RTL later we know what to do. */
11602 save_function_data (tree decl)
11604 struct language_function *f;
11606 /* Save the language-specific per-function data so that we can
11607 get it back when we really expand this function. */
11608 gcc_assert (!DECL_PENDING_INLINE_P (decl));
11611 f = GGC_NEW (struct language_function);
11612 memcpy (f, cp_function_chain, sizeof (struct language_function));
11613 DECL_SAVED_FUNCTION_DATA (decl) = f;
11615 /* Clear out the bits we don't need. */
11616 f->base.x_stmt_tree.x_cur_stmt_list = NULL_TREE;
11617 f->bindings = NULL;
11618 f->x_local_names = NULL;
11622 /* Set the return value of the constructor (if present). */
11625 finish_constructor_body (void)
11630 if (targetm.cxx.cdtor_returns_this ())
11632 /* Any return from a constructor will end up here. */
11633 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
11635 val = DECL_ARGUMENTS (current_function_decl);
11636 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
11637 DECL_RESULT (current_function_decl), val);
11638 /* Return the address of the object. */
11639 exprstmt = build_stmt (RETURN_EXPR, val);
11640 add_stmt (exprstmt);
11644 /* Do all the processing for the beginning of a destructor; set up the
11645 vtable pointers and cleanups for bases and members. */
11648 begin_destructor_body (void)
11650 tree compound_stmt;
11652 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
11653 issued an error message. We still want to try to process the
11654 body of the function, but initialize_vtbl_ptrs will crash if
11655 TYPE_BINFO is NULL. */
11656 if (COMPLETE_TYPE_P (current_class_type))
11658 compound_stmt = begin_compound_stmt (0);
11659 /* Make all virtual function table pointers in non-virtual base
11660 classes point to CURRENT_CLASS_TYPE's virtual function
11662 initialize_vtbl_ptrs (current_class_ptr);
11663 finish_compound_stmt (compound_stmt);
11665 /* And insert cleanups for our bases and members so that they
11666 will be properly destroyed if we throw. */
11667 push_base_cleanups ();
11671 /* At the end of every destructor we generate code to delete the object if
11672 necessary. Do that now. */
11675 finish_destructor_body (void)
11679 /* Any return from a destructor will end up here; that way all base
11680 and member cleanups will be run when the function returns. */
11681 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
11683 /* In a virtual destructor, we must call delete. */
11684 if (DECL_VIRTUAL_P (current_function_decl))
11687 tree virtual_size = cxx_sizeof (current_class_type);
11691 At the point of definition of a virtual destructor (including
11692 an implicit definition), non-placement operator delete shall
11693 be looked up in the scope of the destructor's class and if
11694 found shall be accessible and unambiguous. */
11695 exprstmt = build_op_delete_call(DELETE_EXPR, current_class_ptr,
11697 /*global_p=*/false,
11698 /*placement=*/NULL_TREE,
11699 /*alloc_fn=*/NULL_TREE);
11701 if_stmt = begin_if_stmt ();
11702 finish_if_stmt_cond (build2 (BIT_AND_EXPR, integer_type_node,
11703 current_in_charge_parm,
11706 finish_expr_stmt (exprstmt);
11707 finish_then_clause (if_stmt);
11708 finish_if_stmt (if_stmt);
11711 if (targetm.cxx.cdtor_returns_this ())
11715 val = DECL_ARGUMENTS (current_function_decl);
11716 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
11717 DECL_RESULT (current_function_decl), val);
11718 /* Return the address of the object. */
11719 exprstmt = build_stmt (RETURN_EXPR, val);
11720 add_stmt (exprstmt);
11724 /* Do the necessary processing for the beginning of a function body, which
11725 in this case includes member-initializers, but not the catch clauses of
11726 a function-try-block. Currently, this means opening a binding level
11727 for the member-initializers (in a ctor) and member cleanups (in a dtor). */
11730 begin_function_body (void)
11734 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
11737 if (processing_template_decl)
11738 /* Do nothing now. */;
11740 /* Always keep the BLOCK node associated with the outermost pair of
11741 curly braces of a function. These are needed for correct
11742 operation of dwarfout.c. */
11743 keep_next_level (true);
11745 stmt = begin_compound_stmt (BCS_FN_BODY);
11747 if (processing_template_decl)
11748 /* Do nothing now. */;
11749 else if (DECL_DESTRUCTOR_P (current_function_decl))
11750 begin_destructor_body ();
11755 /* Do the processing for the end of a function body. Currently, this means
11756 closing out the cleanups for fully-constructed bases and members, and in
11757 the case of the destructor, deleting the object if desired. Again, this
11758 is only meaningful for [cd]tors, since they are the only functions where
11759 there is a significant distinction between the main body and any
11760 function catch clauses. Handling, say, main() return semantics here
11761 would be wrong, as flowing off the end of a function catch clause for
11762 main() would also need to return 0. */
11765 finish_function_body (tree compstmt)
11767 if (compstmt == NULL_TREE)
11770 /* Close the block. */
11771 finish_compound_stmt (compstmt);
11773 if (processing_template_decl)
11774 /* Do nothing now. */;
11775 else if (DECL_CONSTRUCTOR_P (current_function_decl))
11776 finish_constructor_body ();
11777 else if (DECL_DESTRUCTOR_P (current_function_decl))
11778 finish_destructor_body ();
11781 /* Given a function, returns the BLOCK corresponding to the outermost level
11782 of curly braces, skipping the artificial block created for constructor
11786 outer_curly_brace_block (tree fndecl)
11788 tree block = BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl));
11789 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
11790 /* Skip the artificial function body block. */
11791 block = BLOCK_SUBBLOCKS (block);
11795 /* Finish up a function declaration and compile that function
11796 all the way to assembler language output. The free the storage
11797 for the function definition.
11799 FLAGS is a bitwise or of the following values:
11801 We just finished processing the body of an in-class inline
11802 function definition. (This processing will have taken place
11803 after the class definition is complete.) */
11806 finish_function (int flags)
11808 tree fndecl = current_function_decl;
11809 tree fntype, ctype = NULL_TREE;
11810 int inclass_inline = (flags & 2) != 0;
11811 /* APPLE LOCAL radar 6169580 */
11812 int in_blocks_helper_function = (flags & 4) != 0;
11815 /* When we get some parse errors, we can end up without a
11816 current_function_decl, so cope. */
11817 if (fndecl == NULL_TREE)
11818 return error_mark_node;
11820 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
11821 && DECL_VIRTUAL_P (fndecl)
11822 && !processing_template_decl)
11824 tree fnclass = DECL_CONTEXT (fndecl);
11825 if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
11826 keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
11829 nested = function_depth > 1;
11830 fntype = TREE_TYPE (fndecl);
11832 /* TREE_READONLY (fndecl) = 1;
11833 This caused &foo to be of type ptr-to-const-function
11834 which then got a warning when stored in a ptr-to-function variable. */
11836 gcc_assert (building_stmt_tree ());
11837 /* The current function is being defined, so its DECL_INITIAL should
11838 be set, and unless there's a multiple definition, it should be
11839 error_mark_node. */
11840 gcc_assert (DECL_INITIAL (fndecl) == error_mark_node);
11842 /* For a cloned function, we've already got all the code we need;
11843 there's no need to add any extra bits. */
11844 if (!DECL_CLONED_FUNCTION_P (fndecl))
11846 if (DECL_MAIN_P (current_function_decl))
11850 /* Make it so that `main' always returns 0 by default (or
11853 stmt = finish_return_stmt (integer_one_node);
11855 stmt = finish_return_stmt (integer_zero_node);
11857 /* Hack. We don't want the middle-end to warn that this
11858 return is unreachable, so put the statement on the
11860 #ifdef USE_MAPPED_LOCATION
11861 SET_EXPR_LOCATION (stmt, UNKNOWN_LOCATION);
11863 annotate_with_file_line (stmt, input_filename, 0);
11867 if (use_eh_spec_block (current_function_decl))
11868 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
11869 (TREE_TYPE (current_function_decl)),
11870 current_eh_spec_block);
11873 /* If we're saving up tree structure, tie off the function now. */
11874 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
11876 finish_fname_decls ();
11878 /* If this function can't throw any exceptions, remember that. */
11879 if (!processing_template_decl
11880 && !cp_function_chain->can_throw
11881 && !flag_non_call_exceptions
11882 && !DECL_REPLACEABLE_P (fndecl))
11883 TREE_NOTHROW (fndecl) = 1;
11885 /* This must come after expand_function_end because cleanups might
11886 have declarations (from inline functions) that need to go into
11887 this function's blocks. */
11889 /* If the current binding level isn't the outermost binding level
11890 for this function, either there is a bug, or we have experienced
11891 syntax errors and the statement tree is malformed. */
11892 if (current_binding_level->kind != sk_function_parms)
11894 /* Make sure we have already experienced errors. */
11895 gcc_assert (errorcount);
11897 /* Throw away the broken statement tree and extra binding
11899 DECL_SAVED_TREE (fndecl) = alloc_stmt_list ();
11901 while (current_binding_level->kind != sk_function_parms)
11903 if (current_binding_level->kind == sk_class)
11904 pop_nested_class ();
11906 poplevel (0, 0, 0);
11909 poplevel (1, 0, 1);
11911 /* Statements should always be full-expressions at the outermost set
11912 of curly braces for a function. */
11913 gcc_assert (stmts_are_full_exprs_p ());
11915 /* Set up the named return value optimization, if we can. Candidate
11916 variables are selected in check_return_expr. */
11917 if (current_function_return_value)
11919 tree r = current_function_return_value;
11922 if (r != error_mark_node
11923 /* This is only worth doing for fns that return in memory--and
11924 simpler, since we don't have to worry about promoted modes. */
11925 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
11926 /* Only allow this for variables declared in the outer scope of
11927 the function so we know that their lifetime always ends with a
11928 return; see g++.dg/opt/nrv6.C. We could be more flexible if
11929 we were to do this optimization in tree-ssa. */
11930 && (outer = outer_curly_brace_block (fndecl))
11931 && chain_member (r, BLOCK_VARS (outer)))
11932 finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));
11934 current_function_return_value = NULL_TREE;
11937 /* Remember that we were in class scope. */
11938 if (current_class_name)
11939 ctype = current_class_type;
11941 /* Must mark the RESULT_DECL as being in this function. */
11942 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
11944 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
11945 to the FUNCTION_DECL node itself. */
11946 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
11948 /* Save away current state, if appropriate. */
11949 if (!processing_template_decl)
11950 save_function_data (fndecl);
11952 /* Complain if there's just no return statement. */
11953 if (warn_return_type
11954 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
11955 && !dependent_type_p (TREE_TYPE (fntype))
11956 && !current_function_returns_value && !current_function_returns_null
11957 /* Don't complain if we abort or throw. */
11958 && !current_function_returns_abnormally
11959 && !DECL_NAME (DECL_RESULT (fndecl))
11960 /* Normally, with -Wreturn-type, flow will complain. Unless we're an
11961 inline function, as we might never be compiled separately. */
11962 && (DECL_INLINE (fndecl) || processing_template_decl)
11963 /* Structor return values (if any) are set by the compiler. */
11964 && !DECL_CONSTRUCTOR_P (fndecl)
11965 && !DECL_DESTRUCTOR_P (fndecl))
11966 warning (OPT_Wreturn_type, "no return statement in function returning non-void");
11968 /* Store the end of the function, so that we get good line number
11969 info for the epilogue. */
11970 cfun->function_end_locus = input_location;
11972 /* Genericize before inlining. */
11973 if (!processing_template_decl)
11975 struct language_function *f = DECL_SAVED_FUNCTION_DATA (fndecl);
11976 cp_genericize (fndecl);
11977 /* Clear out the bits we don't need. */
11978 f->x_current_class_ptr = NULL;
11979 f->x_current_class_ref = NULL;
11980 f->x_eh_spec_block = NULL;
11981 f->x_in_charge_parm = NULL;
11982 f->x_vtt_parm = NULL;
11983 f->x_return_value = NULL;
11984 f->bindings = NULL;
11985 f->extern_decl_map = NULL;
11987 /* Handle attribute((warn_unused_result)). Relies on gimple input. */
11988 c_warn_unused_result (&DECL_SAVED_TREE (fndecl));
11990 /* Clear out the bits we don't need. */
11991 local_names = NULL;
11993 /* We're leaving the context of this function, so zap cfun. It's still in
11994 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
11996 current_function_decl = NULL;
11998 /* If this is an in-class inline definition, we may have to pop the
11999 bindings for the template parameters that we added in
12000 maybe_begin_member_template_processing when start_function was
12002 if (inclass_inline)
12003 maybe_end_member_template_processing ();
12005 /* Leave the scope of the class. */
12006 /* APPLE LOCAL radar 6169580 */
12007 if (ctype && !in_blocks_helper_function)
12008 pop_nested_class ();
12014 /* Let the error reporting routines know that we're outside a
12015 function. For a nested function, this value is used in
12016 cxx_pop_function_context and then reset via pop_function_context. */
12017 current_function_decl = NULL_TREE;
12022 /* Create the FUNCTION_DECL for a function definition.
12023 DECLSPECS and DECLARATOR are the parts of the declaration;
12024 they describe the return type and the name of the function,
12025 but twisted together in a fashion that parallels the syntax of C.
12027 This function creates a binding context for the function body
12028 as well as setting up the FUNCTION_DECL in current_function_decl.
12030 Returns a FUNCTION_DECL on success.
12032 If the DECLARATOR is not suitable for a function (it defines a datum
12033 instead), we return 0, which tells yyparse to report a parse error.
12035 May return void_type_node indicating that this method is actually
12036 a friend. See grokfield for more details.
12038 Came here with a `.pushlevel' .
12040 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
12041 CHANGES TO CODE IN `grokfield'. */
12044 start_method (cp_decl_specifier_seq *declspecs,
12045 const cp_declarator *declarator, tree attrlist)
12047 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
12050 if (fndecl == error_mark_node)
12051 return error_mark_node;
12053 if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
12055 error ("invalid member function declaration");
12056 return error_mark_node;
12060 cplus_decl_attributes (&fndecl, attrlist, 0);
12062 /* Pass friends other than inline friend functions back. */
12063 if (fndecl == void_type_node)
12066 if (DECL_IN_AGGR_P (fndecl))
12068 if (DECL_CONTEXT (fndecl)
12069 && TREE_CODE (DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
12070 error ("%qD is already defined in class %qT", fndecl,
12071 DECL_CONTEXT (fndecl));
12072 return error_mark_node;
12075 check_template_shadow (fndecl);
12077 DECL_DECLARED_INLINE_P (fndecl) = 1;
12078 if (flag_default_inline)
12079 DECL_INLINE (fndecl) = 1;
12081 /* We process method specializations in finish_struct_1. */
12082 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
12084 fndecl = push_template_decl (fndecl);
12085 if (fndecl == error_mark_node)
12089 if (! DECL_FRIEND_P (fndecl))
12091 if (TREE_CHAIN (fndecl))
12093 fndecl = copy_node (fndecl);
12094 TREE_CHAIN (fndecl) = NULL_TREE;
12098 finish_decl (fndecl, NULL_TREE, NULL_TREE);
12100 /* Make a place for the parms. */
12101 begin_scope (sk_function_parms, fndecl);
12103 DECL_IN_AGGR_P (fndecl) = 1;
12107 /* Go through the motions of finishing a function definition.
12108 We don't compile this method until after the whole class has
12111 FINISH_METHOD must return something that looks as though it
12112 came from GROKFIELD (since we are defining a method, after all).
12114 This is called after parsing the body of the function definition.
12115 STMTS is the chain of statements that makes up the function body.
12117 DECL is the ..._DECL that `start_method' provided. */
12120 finish_method (tree decl)
12122 tree fndecl = decl;
12127 if (decl == void_type_node)
12130 old_initial = DECL_INITIAL (fndecl);
12132 /* Undo the level for the parms (from start_method).
12133 This is like poplevel, but it causes nothing to be
12134 saved. Saving information here confuses symbol-table
12135 output routines. Besides, this information will
12136 be correctly output when this method is actually
12139 /* Clear out the meanings of the local variables of this level;
12140 also record in each decl which block it belongs to. */
12142 for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
12144 if (DECL_NAME (link) != NULL_TREE)
12145 pop_binding (DECL_NAME (link), link);
12146 gcc_assert (TREE_CODE (link) != FUNCTION_DECL);
12147 DECL_CONTEXT (link) = NULL_TREE;
12150 poplevel (0, 0, 0);
12152 DECL_INITIAL (fndecl) = old_initial;
12154 /* We used to check if the context of FNDECL was different from
12155 current_class_type as another way to get inside here. This didn't work
12156 for String.cc in libg++. */
12157 if (DECL_FRIEND_P (fndecl))
12159 VEC_safe_push (tree, gc, CLASSTYPE_INLINE_FRIENDS (current_class_type),
12161 decl = void_type_node;
12168 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
12169 we can lay it out later, when and if its type becomes complete. */
12172 maybe_register_incomplete_var (tree var)
12174 gcc_assert (TREE_CODE (var) == VAR_DECL);
12176 /* Keep track of variables with incomplete types. */
12177 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
12178 && DECL_EXTERNAL (var))
12180 tree inner_type = TREE_TYPE (var);
12182 while (TREE_CODE (inner_type) == ARRAY_TYPE)
12183 inner_type = TREE_TYPE (inner_type);
12184 inner_type = TYPE_MAIN_VARIANT (inner_type);
12186 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
12187 /* RTTI TD entries are created while defining the type_info. */
12188 || (TYPE_LANG_SPECIFIC (inner_type)
12189 && TYPE_BEING_DEFINED (inner_type)))
12190 incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
12194 /* Called when a class type (given by TYPE) is defined. If there are
12195 any existing VAR_DECLs whose type hsa been completed by this
12196 declaration, update them now. */
12199 complete_vars (tree type)
12201 tree *list = &incomplete_vars;
12203 gcc_assert (CLASS_TYPE_P (type));
12206 if (same_type_p (type, TREE_PURPOSE (*list)))
12208 tree var = TREE_VALUE (*list);
12209 tree type = TREE_TYPE (var);
12210 /* Complete the type of the variable. The VAR_DECL itself
12211 will be laid out in expand_expr. */
12212 complete_type (type);
12213 cp_apply_type_quals_to_decl (cp_type_quals (type), var);
12214 /* Remove this entry from the list. */
12215 *list = TREE_CHAIN (*list);
12218 list = &TREE_CHAIN (*list);
12221 /* Check for pending declarations which may have abstract type. */
12222 complete_type_check_abstract (type);
12225 /* If DECL is of a type which needs a cleanup, build that cleanup
12229 cxx_maybe_build_cleanup (tree decl)
12231 tree type = TREE_TYPE (decl);
12233 /* APPLE LOCAL begin omit calls to empty destructors 5559195 */
12234 tree dtor = NULL_TREE;
12235 bool build_cleanup = false;
12237 if (TREE_CODE (type) == RECORD_TYPE)
12238 dtor = CLASSTYPE_DESTRUCTORS (type);
12240 if (type != error_mark_node)
12242 if (TREE_CODE (type) == RECORD_TYPE)
12243 /* For RECORD_TYPEs, we can refer to more precise flags than
12244 TYPE_HAS_NONTRIVIAL_DESTRUCTOR. */
12245 build_cleanup = (dtor && TREE_PRIVATE (dtor))
12246 || CLASSTYPE_HAS_NONTRIVIAL_DESTRUCTOR_BODY (type)
12247 || CLASSTYPE_DESTRUCTOR_NONTRIVIAL_BECAUSE_OF_BASE (type);
12249 build_cleanup = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type);
12254 /* APPLE LOCAL end omit calls to empty destructors 5559195 */
12255 int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
12257 bool has_vbases = (TREE_CODE (type) == RECORD_TYPE
12258 && CLASSTYPE_VBASECLASSES (type));
12259 if (TREE_CODE (type) == ARRAY_TYPE)
12263 cxx_mark_addressable (decl);
12264 rval = build_unary_op (ADDR_EXPR, decl, 0);
12267 /* Optimize for space over speed here. */
12268 if (!has_vbases || flag_expensive_optimizations)
12269 flags |= LOOKUP_NONVIRTUAL;
12271 rval = build_delete (TREE_TYPE (rval), rval,
12272 sfk_complete_destructor, flags, 0);
12279 /* When a stmt has been parsed, this function is called. */
12286 /* DECL was originally constructed as a non-static member function,
12287 but turned out to be static. Update it accordingly. */
12290 revert_static_member_fn (tree decl)
12293 tree function = TREE_TYPE (decl);
12294 tree args = TYPE_ARG_TYPES (function);
12296 if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
12297 != TYPE_UNQUALIFIED)
12298 error ("static member function %q#D declared with type qualifiers", decl);
12300 args = TREE_CHAIN (args);
12301 tmp = build_function_type (TREE_TYPE (function), args);
12302 tmp = build_qualified_type (tmp, cp_type_quals (function));
12303 tmp = build_exception_variant (tmp,
12304 TYPE_RAISES_EXCEPTIONS (function));
12305 TREE_TYPE (decl) = tmp;
12306 if (DECL_ARGUMENTS (decl))
12307 DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
12308 DECL_STATIC_FUNCTION_P (decl) = 1;
12311 /* Initialize the variables used during compilation of a C++
12315 cxx_push_function_context (struct function * f)
12317 struct language_function *p = GGC_CNEW (struct language_function);
12320 /* Whenever we start a new function, we destroy temporaries in the
12322 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
12328 if (DECL_SAVED_FUNCTION_DATA (fn))
12330 /* If we already parsed this function, and we're just expanding it
12331 now, restore saved state. */
12332 *cp_function_chain = *DECL_SAVED_FUNCTION_DATA (fn);
12334 /* We don't need the saved data anymore. Unless this is an inline
12335 function; we need the named return value info for
12336 declare_return_variable. */
12337 if (! DECL_INLINE (fn))
12338 DECL_SAVED_FUNCTION_DATA (fn) = NULL;
12343 /* Free the language-specific parts of F, now that we've finished
12344 compiling the function. */
12347 cxx_pop_function_context (struct function * f)
12352 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
12353 one of the language-independent trees. */
12355 enum cp_tree_node_structure_enum
12356 cp_tree_node_structure (union lang_tree_node * t)
12358 switch (TREE_CODE (&t->generic))
12360 case DEFAULT_ARG: return TS_CP_DEFAULT_ARG;
12361 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER;
12362 case OVERLOAD: return TS_CP_OVERLOAD;
12363 case TEMPLATE_PARM_INDEX: return TS_CP_TPI;
12364 case TINST_LEVEL: return TS_CP_TINST_LEVEL;
12365 case PTRMEM_CST: return TS_CP_PTRMEM;
12366 case BASELINK: return TS_CP_BASELINK;
12367 default: return TS_CP_GENERIC;
12371 /* Build the void_list_node (void_type_node having been created). */
12373 build_void_list_node (void)
12375 tree t = build_tree_list (NULL_TREE, void_type_node);
12380 cp_missing_noreturn_ok_p (tree decl)
12382 /* A missing noreturn is ok for the `main' function. */
12383 return DECL_MAIN_P (decl);
12386 /* Return the COMDAT group into which DECL should be placed. */
12389 cxx_comdat_group (tree decl)
12393 /* Virtual tables, construction virtual tables, and virtual table
12394 tables all go in a single COMDAT group, named after the primary
12396 if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
12397 name = DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl)));
12398 /* For all other DECLs, the COMDAT group is the mangled name of the
12399 declaration itself. */
12402 while (DECL_THUNK_P (decl))
12404 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
12405 into the same section as the target function. In that case
12406 we must return target's name. */
12407 tree target = THUNK_TARGET (decl);
12408 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target)
12409 && DECL_SECTION_NAME (target) != NULL
12410 && DECL_ONE_ONLY (target))
12415 name = DECL_ASSEMBLER_NAME (decl);
12418 return IDENTIFIER_POINTER (name);
12421 #include "gt-cp-decl.h"