1 /* Process declarations and variables for C++ compiler.
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 Free Software Foundation, Inc.
5 Contributed by Michael Tiemann (tiemann@cygnus.com)
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
24 /* Process declarations and symbol lookup for C++ front end.
25 Also constructs types; the standard scalar types at initialization,
26 and structure, union, array and enum types when they are declared. */
28 /* ??? not all decl nodes are given the most useful possible
29 line numbers. For example, the CONST_DECLs for enum values. */
33 #include "coretypes.h"
40 #include "tree-inline.h"
50 #include "diagnostic.h"
54 #include "tree-flow.h"
55 #include "pointer-set.h"
57 static tree
grokparms (cp_parameter_declarator
*, tree
*);
58 static const char *redeclaration_error_message (tree
, tree
);
60 static int decl_jump_unsafe (tree
);
61 static void require_complete_types_for_parms (tree
);
62 static int ambi_op_p (enum tree_code
);
63 static int unary_op_p (enum tree_code
);
64 static void push_local_name (tree
);
65 static tree
grok_reference_init (tree
, tree
, tree
, tree
*);
66 static tree
grokvardecl (tree
, tree
, const cp_decl_specifier_seq
*,
68 static void record_unknown_type (tree
, const char *);
69 static tree
builtin_function_1 (tree
, tree
);
70 static tree
build_library_fn_1 (tree
, enum tree_code
, tree
);
71 static int member_function_or_else (tree
, tree
, enum overload_flags
);
72 static void bad_specifiers (tree
, const char *, int, int, int, int,
74 static void check_for_uninitialized_const_var (tree
);
75 static hashval_t
typename_hash (const void *);
76 static int typename_compare (const void *, const void *);
77 static tree
local_variable_p_walkfn (tree
*, int *, void *);
78 static tree
record_builtin_java_type (const char *, int);
79 static const char *tag_name (enum tag_types
);
80 static tree
lookup_and_check_tag (enum tag_types
, tree
, tag_scope
, bool);
81 static int walk_namespaces_r (tree
, walk_namespaces_fn
, void *);
82 static void maybe_deduce_size_from_array_init (tree
, tree
);
83 static void layout_var_decl (tree
);
84 static void maybe_commonize_var (tree
);
85 static tree
check_initializer (tree
, tree
, int, tree
*);
86 static void make_rtl_for_nonlocal_decl (tree
, tree
, const char *);
87 static void save_function_data (tree
);
88 static void check_function_type (tree
, tree
);
89 static void finish_constructor_body (void);
90 static void begin_destructor_body (void);
91 static void finish_destructor_body (void);
92 static tree
create_array_type_for_decl (tree
, tree
, tree
);
93 static tree
get_atexit_node (void);
94 static tree
get_dso_handle_node (void);
95 static tree
start_cleanup_fn (void);
96 static void end_cleanup_fn (void);
97 static tree
cp_make_fname_decl (tree
, int);
98 static void initialize_predefined_identifiers (void);
99 static tree check_special_function_return_type
100 (special_function_kind
, tree
, tree
);
101 static tree
push_cp_library_fn (enum tree_code
, tree
);
102 static tree
build_cp_library_fn (tree
, enum tree_code
, tree
);
103 static void store_parm_decls (tree
);
104 static void initialize_local_var (tree
, tree
);
105 static void expand_static_init (tree
, tree
);
106 static tree
next_initializable_field (tree
);
108 /* The following symbols are subsumed in the cp_global_trees array, and
109 listed here individually for documentation purposes.
112 tree wchar_decl_node;
114 tree vtable_entry_type;
115 tree delta_type_node;
116 tree __t_desc_type_node;
118 tree class_type_node;
119 tree unknown_type_node;
121 Array type `vtable_entry_type[]'
124 tree vtbl_ptr_type_node;
131 A FUNCTION_DECL which can call `abort'. Not necessarily the
132 one that the user will declare, but sufficient to be called
133 by routines that want to abort the program.
137 The FUNCTION_DECL for the default `::operator delete'.
139 tree global_delete_fndecl;
142 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
143 tree tinfo_var_id; */
145 tree cp_global_trees
[CPTI_MAX
];
147 /* Indicates that there is a type value in some namespace, although
148 that is not necessarily in scope at the moment. */
150 tree global_type_node
;
152 /* The node that holds the "name" of the global scope. */
153 tree global_scope_name
;
155 #define local_names cp_function_chain->x_local_names
157 /* A list of objects which have constructors or destructors
158 which reside in the global scope. The decl is stored in
159 the TREE_VALUE slot and the initializer is stored
160 in the TREE_PURPOSE slot. */
161 tree static_aggregates
;
165 /* A node for the integer constants 2, and 3. */
167 tree integer_two_node
, integer_three_node
;
169 /* Used only for jumps to as-yet undefined labels, since jumps to
170 defined labels can have their validity checked immediately. */
172 struct named_label_use_entry
GTY(())
174 struct named_label_use_entry
*next
;
175 /* The binding level to which this entry is *currently* attached.
176 This is initially the binding level in which the goto appeared,
177 but is modified as scopes are closed. */
178 struct cp_binding_level
*binding_level
;
179 /* The head of the names list that was current when the goto appeared,
180 or the inner scope popped. These are the decls that will *not* be
181 skipped when jumping to the label. */
183 /* The location of the goto, for error reporting. */
184 location_t o_goto_locus
;
185 /* True if an OpenMP structured block scope has been closed since
186 the goto appeared. This means that the branch from the label will
187 illegally exit an OpenMP scope. */
191 /* A list of all LABEL_DECLs in the function that have names. Here so
192 we can clear out their names' definitions at the end of the
193 function, and so we can check the validity of jumps to these labels. */
195 struct named_label_entry
GTY(())
197 /* The decl itself. */
200 /* The binding level to which the label is *currently* attached.
201 This is initially set to the binding level in which the label
202 is defined, but is modified as scopes are closed. */
203 struct cp_binding_level
*binding_level
;
204 /* The head of the names list that was current when the label was
205 defined, or the inner scope popped. These are the decls that will
206 be skipped when jumping to the label. */
208 /* A tree list of all decls from all binding levels that would be
209 crossed by a backward branch to the label. */
212 /* A list of uses of the label, before the label is defined. */
213 struct named_label_use_entry
*uses
;
215 /* The following bits are set after the label is defined, and are
216 updated as scopes are popped. They indicate that a backward jump
217 to the label will illegally enter a scope of the given flavor. */
223 #define named_labels cp_function_chain->x_named_labels
225 /* The number of function bodies which we are currently processing.
226 (Zero if we are at namespace scope, one inside the body of a
227 function, two inside the body of a function in a local class, etc.) */
230 /* States indicating how grokdeclarator() should handle declspecs marked
231 with __attribute__((deprecated)). An object declared as
232 __attribute__((deprecated)) suppresses warnings of uses of other
235 enum deprecated_states
{
240 static enum deprecated_states deprecated_state
= DEPRECATED_NORMAL
;
243 /* A TREE_LIST of VAR_DECLs. The TREE_PURPOSE is a RECORD_TYPE or
244 UNION_TYPE; the TREE_VALUE is a VAR_DECL with that type. At the
245 time the VAR_DECL was declared, the type was incomplete. */
247 static GTY(()) tree incomplete_vars
;
249 /* Returns the kind of template specialization we are currently
250 processing, given that it's declaration contained N_CLASS_SCOPES
251 explicit scope qualifications. */
254 current_tmpl_spec_kind (int n_class_scopes
)
256 int n_template_parm_scopes
= 0;
257 int seen_specialization_p
= 0;
258 int innermost_specialization_p
= 0;
259 struct cp_binding_level
*b
;
261 /* Scan through the template parameter scopes. */
262 for (b
= current_binding_level
;
263 b
->kind
== sk_template_parms
;
266 /* If we see a specialization scope inside a parameter scope,
267 then something is wrong. That corresponds to a declaration
270 template <class T> template <> ...
272 which is always invalid since [temp.expl.spec] forbids the
273 specialization of a class member template if the enclosing
274 class templates are not explicitly specialized as well. */
275 if (b
->explicit_spec_p
)
277 if (n_template_parm_scopes
== 0)
278 innermost_specialization_p
= 1;
280 seen_specialization_p
= 1;
282 else if (seen_specialization_p
== 1)
283 return tsk_invalid_member_spec
;
285 ++n_template_parm_scopes
;
288 /* Handle explicit instantiations. */
289 if (processing_explicit_instantiation
)
291 if (n_template_parm_scopes
!= 0)
292 /* We've seen a template parameter list during an explicit
293 instantiation. For example:
295 template <class T> template void f(int);
297 This is erroneous. */
298 return tsk_invalid_expl_inst
;
300 return tsk_expl_inst
;
303 if (n_template_parm_scopes
< n_class_scopes
)
304 /* We've not seen enough template headers to match all the
305 specialized classes present. For example:
307 template <class T> void R<T>::S<T>::f(int);
309 This is invalid; there needs to be one set of template
310 parameters for each class. */
311 return tsk_insufficient_parms
;
312 else if (n_template_parm_scopes
== n_class_scopes
)
313 /* We're processing a non-template declaration (even though it may
314 be a member of a template class.) For example:
316 template <class T> void S<T>::f(int);
318 The `class T' maches the `S<T>', leaving no template headers
319 corresponding to the `f'. */
321 else if (n_template_parm_scopes
> n_class_scopes
+ 1)
322 /* We've got too many template headers. For example:
324 template <> template <class T> void f (T);
326 There need to be more enclosing classes. */
327 return tsk_excessive_parms
;
329 /* This must be a template. It's of the form:
331 template <class T> template <class U> void S<T>::f(U);
333 This is a specialization if the innermost level was a
334 specialization; otherwise it's just a definition of the
336 return innermost_specialization_p
? tsk_expl_spec
: tsk_template
;
339 /* Exit the current scope. */
347 /* When a label goes out of scope, check to see if that label was used
348 in a valid manner, and issue any appropriate warnings or errors. */
351 pop_label (tree label
, tree old_value
)
353 if (!processing_template_decl
)
355 if (DECL_INITIAL (label
) == NULL_TREE
)
359 error ("label %q+D used but not defined", label
);
360 location
= input_location
; /* FIXME want (input_filename, (line)0) */
361 /* Avoid crashing later. */
362 define_label (location
, DECL_NAME (label
));
365 warn_for_unused_label (label
);
368 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label
), old_value
);
371 /* At the end of a function, all labels declared within the function
372 go out of scope. BLOCK is the top-level block for the
376 pop_labels_1 (void **slot
, void *data
)
378 struct named_label_entry
*ent
= (struct named_label_entry
*) *slot
;
379 tree block
= (tree
) data
;
381 pop_label (ent
->label_decl
, NULL_TREE
);
383 /* Put the labels into the "variables" of the top-level block,
384 so debugger can see them. */
385 TREE_CHAIN (ent
->label_decl
) = BLOCK_VARS (block
);
386 BLOCK_VARS (block
) = ent
->label_decl
;
388 htab_clear_slot (named_labels
, slot
);
394 pop_labels (tree block
)
398 htab_traverse (named_labels
, pop_labels_1
, block
);
403 /* At the end of a block with local labels, restore the outer definition. */
406 pop_local_label (tree label
, tree old_value
)
408 struct named_label_entry dummy
;
411 pop_label (label
, old_value
);
413 dummy
.label_decl
= label
;
414 slot
= htab_find_slot (named_labels
, &dummy
, NO_INSERT
);
415 htab_clear_slot (named_labels
, slot
);
418 /* The following two routines are used to interface to Objective-C++.
419 The binding level is purposely treated as an opaque type. */
422 objc_get_current_scope (void)
424 return current_binding_level
;
427 /* The following routine is used by the NeXT-style SJLJ exceptions;
428 variables get marked 'volatile' so as to not be clobbered by
429 _setjmp()/_longjmp() calls. All variables in the current scope,
430 as well as parent scopes up to (but not including) ENCLOSING_BLK
431 shall be thusly marked. */
434 objc_mark_locals_volatile (void *enclosing_blk
)
436 struct cp_binding_level
*scope
;
438 for (scope
= current_binding_level
;
439 scope
&& scope
!= enclosing_blk
;
440 scope
= scope
->level_chain
)
444 for (decl
= scope
->names
; decl
; decl
= TREE_CHAIN (decl
))
445 objc_volatilize_decl (decl
);
447 /* Do not climb up past the current function. */
448 if (scope
->kind
== sk_function_parms
)
453 /* Update data for defined and undefined labels when leaving a scope. */
456 poplevel_named_label_1 (void **slot
, void *data
)
458 struct named_label_entry
*ent
= (struct named_label_entry
*) *slot
;
459 struct cp_binding_level
*bl
= (struct cp_binding_level
*) data
;
460 struct cp_binding_level
*obl
= bl
->level_chain
;
462 if (ent
->binding_level
== bl
)
466 for (decl
= ent
->names_in_scope
; decl
; decl
= TREE_CHAIN (decl
))
467 if (decl_jump_unsafe (decl
))
468 ent
->bad_decls
= tree_cons (NULL
, decl
, ent
->bad_decls
);
470 ent
->binding_level
= obl
;
471 ent
->names_in_scope
= obl
->names
;
475 ent
->in_try_scope
= true;
478 ent
->in_catch_scope
= true;
481 ent
->in_omp_scope
= true;
489 struct named_label_use_entry
*use
;
491 for (use
= ent
->uses
; use
; use
= use
->next
)
492 if (use
->binding_level
== bl
)
494 use
->binding_level
= obl
;
495 use
->names_in_scope
= obl
->names
;
496 if (bl
->kind
== sk_omp
)
497 use
->in_omp_scope
= true;
504 /* Exit a binding level.
505 Pop the level off, and restore the state of the identifier-decl mappings
506 that were in effect when this level was entered.
508 If KEEP == 1, this level had explicit declarations, so
509 and create a "block" (a BLOCK node) for the level
510 to record its declarations and subblocks for symbol table output.
512 If FUNCTIONBODY is nonzero, this level is the body of a function,
513 so create a block as if KEEP were set and also clear out all
516 If REVERSE is nonzero, reverse the order of decls before putting
517 them into the BLOCK. */
520 poplevel (int keep
, int reverse
, int functionbody
)
523 /* The chain of decls was accumulated in reverse order.
524 Put it into forward order, just for cleanliness. */
526 int tmp
= functionbody
;
527 int real_functionbody
;
531 int leaving_for_scope
;
534 timevar_push (TV_NAME_LOOKUP
);
539 gcc_assert (current_binding_level
->kind
!= sk_class
);
541 real_functionbody
= (current_binding_level
->kind
== sk_cleanup
542 ? ((functionbody
= 0), tmp
) : functionbody
);
543 subblocks
= functionbody
>= 0 ? current_binding_level
->blocks
: 0;
545 gcc_assert (!VEC_length(cp_class_binding
,
546 current_binding_level
->class_shadowed
));
548 /* We used to use KEEP == 2 to indicate that the new block should go
549 at the beginning of the list of blocks at this binding level,
550 rather than the end. This hack is no longer used. */
551 gcc_assert (keep
== 0 || keep
== 1);
553 if (current_binding_level
->keep
)
556 /* Any uses of undefined labels, and any defined labels, now operate
557 under constraints of next binding contour. */
558 if (cfun
&& !functionbody
&& named_labels
)
559 htab_traverse (named_labels
, poplevel_named_label_1
,
560 current_binding_level
);
562 /* Get the decls in the order they were written.
563 Usually current_binding_level->names is in reverse order.
564 But parameter decls were previously put in forward order. */
567 current_binding_level
->names
568 = decls
= nreverse (current_binding_level
->names
);
570 decls
= current_binding_level
->names
;
572 /* If there were any declarations or structure tags in that level,
573 or if this level is a function body,
574 create a BLOCK to record them for the life of this function. */
576 if (keep
== 1 || functionbody
)
577 block
= make_node (BLOCK
);
578 if (block
!= NULL_TREE
)
580 BLOCK_VARS (block
) = decls
;
581 BLOCK_SUBBLOCKS (block
) = subblocks
;
584 /* In each subblock, record that this is its superior. */
586 for (link
= subblocks
; link
; link
= BLOCK_CHAIN (link
))
587 BLOCK_SUPERCONTEXT (link
) = block
;
589 /* We still support the old for-scope rules, whereby the variables
590 in a for-init statement were in scope after the for-statement
591 ended. We only use the new rules if flag_new_for_scope is
594 = current_binding_level
->kind
== sk_for
&& flag_new_for_scope
== 1;
596 /* Before we remove the declarations first check for unused variables. */
597 if (warn_unused_variable
598 && !processing_template_decl
)
599 for (decl
= getdecls (); decl
; decl
= TREE_CHAIN (decl
))
600 if (TREE_CODE (decl
) == VAR_DECL
601 && ! TREE_USED (decl
)
602 && ! DECL_IN_SYSTEM_HEADER (decl
)
603 && DECL_NAME (decl
) && ! DECL_ARTIFICIAL (decl
))
604 warning (OPT_Wunused_variable
, "unused variable %q+D", decl
);
606 /* Remove declarations for all the DECLs in this level. */
607 for (link
= decls
; link
; link
= TREE_CHAIN (link
))
609 if (leaving_for_scope
&& TREE_CODE (link
) == VAR_DECL
612 tree name
= DECL_NAME (link
);
616 ob
= outer_binding (name
,
617 IDENTIFIER_BINDING (name
),
620 ns_binding
= IDENTIFIER_NAMESPACE_VALUE (name
);
622 ns_binding
= NULL_TREE
;
624 if (ob
&& ob
->scope
== current_binding_level
->level_chain
)
625 /* We have something like:
630 and we are leaving the `for' scope. There's no reason to
631 keep the binding of the inner `i' in this case. */
632 pop_binding (name
, link
);
633 else if ((ob
&& (TREE_CODE (ob
->value
) == TYPE_DECL
))
634 || (ns_binding
&& TREE_CODE (ns_binding
) == TYPE_DECL
))
635 /* Here, we have something like:
643 We must pop the for-scope binding so we know what's a
644 type and what isn't. */
645 pop_binding (name
, link
);
648 /* Mark this VAR_DECL as dead so that we can tell we left it
649 there only for backward compatibility. */
650 DECL_DEAD_FOR_LOCAL (link
) = 1;
652 /* Keep track of what should have happened when we
653 popped the binding. */
656 SET_DECL_SHADOWED_FOR_VAR (link
, ob
->value
);
657 DECL_HAS_SHADOWED_FOR_VAR_P (link
) = 1;
660 /* Add it to the list of dead variables in the next
661 outermost binding to that we can remove these when we
662 leave that binding. */
663 current_binding_level
->level_chain
->dead_vars_from_for
664 = tree_cons (NULL_TREE
, link
,
665 current_binding_level
->level_chain
->
668 /* Although we don't pop the cxx_binding, we do clear
669 its SCOPE since the scope is going away now. */
670 IDENTIFIER_BINDING (name
)->scope
671 = current_binding_level
->level_chain
;
678 /* Remove the binding. */
681 if (TREE_CODE (decl
) == TREE_LIST
)
682 decl
= TREE_VALUE (decl
);
685 if (TREE_CODE (name
) == OVERLOAD
)
686 name
= OVL_FUNCTION (name
);
688 gcc_assert (DECL_P (name
));
689 pop_binding (DECL_NAME (name
), decl
);
693 /* Remove declarations for any `for' variables from inner scopes
694 that we kept around. */
695 for (link
= current_binding_level
->dead_vars_from_for
;
696 link
; link
= TREE_CHAIN (link
))
697 pop_binding (DECL_NAME (TREE_VALUE (link
)), TREE_VALUE (link
));
699 /* Restore the IDENTIFIER_TYPE_VALUEs. */
700 for (link
= current_binding_level
->type_shadowed
;
701 link
; link
= TREE_CHAIN (link
))
702 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link
), TREE_VALUE (link
));
704 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
705 for (link
= current_binding_level
->shadowed_labels
;
707 link
= TREE_CHAIN (link
))
708 pop_local_label (TREE_VALUE (link
), TREE_PURPOSE (link
));
710 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
711 list if a `using' declaration put them there. The debugging
712 back ends won't understand OVERLOAD, so we remove them here.
713 Because the BLOCK_VARS are (temporarily) shared with
714 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
715 popped all the bindings. */
720 for (d
= &BLOCK_VARS (block
); *d
; )
722 if (TREE_CODE (*d
) == TREE_LIST
)
723 *d
= TREE_CHAIN (*d
);
725 d
= &TREE_CHAIN (*d
);
729 /* If the level being exited is the top level of a function,
730 check over all the labels. */
733 /* Since this is the top level block of a function, the vars are
734 the function's parameters. Don't leave them in the BLOCK
735 because they are found in the FUNCTION_DECL instead. */
736 BLOCK_VARS (block
) = 0;
740 kind
= current_binding_level
->kind
;
741 if (kind
== sk_cleanup
)
745 /* If this is a temporary binding created for a cleanup, then we'll
746 have pushed a statement list level. Pop that, create a new
747 BIND_EXPR for the block, and insert it into the stream. */
748 stmt
= pop_stmt_list (current_binding_level
->statement_list
);
749 stmt
= c_build_bind_expr (block
, stmt
);
756 /* The current function is being defined, so its DECL_INITIAL
757 should be error_mark_node. */
758 gcc_assert (DECL_INITIAL (current_function_decl
) == error_mark_node
);
759 DECL_INITIAL (current_function_decl
) = block
;
762 current_binding_level
->blocks
763 = chainon (current_binding_level
->blocks
, block
);
765 /* If we did not make a block for the level just exited,
766 any blocks made for inner levels
767 (since they cannot be recorded as subblocks in that level)
768 must be carried forward so they will later become subblocks
769 of something else. */
771 current_binding_level
->blocks
772 = chainon (current_binding_level
->blocks
, subblocks
);
774 /* Each and every BLOCK node created here in `poplevel' is important
775 (e.g. for proper debugging information) so if we created one
776 earlier, mark it as "used". */
778 TREE_USED (block
) = 1;
780 /* All temporary bindings created for cleanups are popped silently. */
781 if (kind
== sk_cleanup
)
784 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, block
);
787 /* Insert BLOCK at the end of the list of subblocks of the
788 current binding level. This is used when a BIND_EXPR is expanded,
789 to handle the BLOCK node inside the BIND_EXPR. */
792 insert_block (tree block
)
794 TREE_USED (block
) = 1;
795 current_binding_level
->blocks
796 = chainon (current_binding_level
->blocks
, block
);
799 /* Walk all the namespaces contained NAMESPACE, including NAMESPACE
800 itself, calling F for each. The DATA is passed to F as well. */
803 walk_namespaces_r (tree
namespace, walk_namespaces_fn f
, void* data
)
806 tree current
= NAMESPACE_LEVEL (namespace)->namespaces
;
808 result
|= (*f
) (namespace, data
);
810 for (; current
; current
= TREE_CHAIN (current
))
811 result
|= walk_namespaces_r (current
, f
, data
);
816 /* Walk all the namespaces, calling F for each. The DATA is passed to
820 walk_namespaces (walk_namespaces_fn f
, void* data
)
822 return walk_namespaces_r (global_namespace
, f
, data
);
825 /* Call wrapup_globals_declarations for the globals in NAMESPACE. If
826 DATA is non-NULL, this is the last time we will call
827 wrapup_global_declarations for this NAMESPACE. */
830 wrapup_globals_for_namespace (tree
namespace, void* data
)
832 struct cp_binding_level
*level
= NAMESPACE_LEVEL (namespace);
833 VEC(tree
,gc
) *statics
= level
->static_decls
;
834 tree
*vec
= VEC_address (tree
, statics
);
835 int len
= VEC_length (tree
, statics
);
836 int last_time
= (data
!= 0);
840 check_global_declarations (vec
, len
);
841 emit_debug_global_declarations (vec
, len
);
845 /* Write out any globals that need to be output. */
846 return wrapup_global_declarations (vec
, len
);
850 /* In C++, you don't have to write `struct S' to refer to `S'; you
851 can just use `S'. We accomplish this by creating a TYPE_DECL as
852 if the user had written `typedef struct S S'. Create and return
853 the TYPE_DECL for TYPE. */
856 create_implicit_typedef (tree name
, tree type
)
860 decl
= build_decl (TYPE_DECL
, name
, type
);
861 DECL_ARTIFICIAL (decl
) = 1;
862 /* There are other implicit type declarations, like the one *within*
863 a class that allows you to write `S::S'. We must distinguish
865 SET_DECL_IMPLICIT_TYPEDEF_P (decl
);
866 TYPE_NAME (type
) = decl
;
871 /* Remember a local name for name-mangling purposes. */
874 push_local_name (tree decl
)
879 timevar_push (TV_NAME_LOOKUP
);
881 name
= DECL_NAME (decl
);
883 nelts
= VEC_length (tree
, local_names
);
884 for (i
= 0; i
< nelts
; i
++)
886 t
= VEC_index (tree
, local_names
, i
);
887 if (DECL_NAME (t
) == name
)
889 if (!DECL_LANG_SPECIFIC (decl
))
890 retrofit_lang_decl (decl
);
891 DECL_LANG_SPECIFIC (decl
)->decl_flags
.u2sel
= 1;
892 if (DECL_LANG_SPECIFIC (t
))
893 DECL_DISCRIMINATOR (decl
) = DECL_DISCRIMINATOR (t
) + 1;
895 DECL_DISCRIMINATOR (decl
) = 1;
897 VEC_replace (tree
, local_names
, i
, decl
);
898 timevar_pop (TV_NAME_LOOKUP
);
903 VEC_safe_push (tree
, gc
, local_names
, decl
);
904 timevar_pop (TV_NAME_LOOKUP
);
907 /* Subroutine of duplicate_decls: return truthvalue of whether
908 or not types of these decls match.
910 For C++, we must compare the parameter list so that `int' can match
911 `int&' in a parameter position, but `int&' is not confused with
915 decls_match (tree newdecl
, tree olddecl
)
919 if (newdecl
== olddecl
)
922 if (TREE_CODE (newdecl
) != TREE_CODE (olddecl
))
923 /* If the two DECLs are not even the same kind of thing, we're not
924 interested in their types. */
927 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
929 tree f1
= TREE_TYPE (newdecl
);
930 tree f2
= TREE_TYPE (olddecl
);
931 tree p1
= TYPE_ARG_TYPES (f1
);
932 tree p2
= TYPE_ARG_TYPES (f2
);
934 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
935 && ! (DECL_EXTERN_C_P (newdecl
)
936 && DECL_EXTERN_C_P (olddecl
)))
939 if (TREE_CODE (f1
) != TREE_CODE (f2
))
942 if (same_type_p (TREE_TYPE (f1
), TREE_TYPE (f2
)))
944 if (p2
== NULL_TREE
&& DECL_EXTERN_C_P (olddecl
)
945 && (DECL_BUILT_IN (olddecl
)
946 #ifndef NO_IMPLICIT_EXTERN_C
947 || (DECL_IN_SYSTEM_HEADER (newdecl
) && !DECL_CLASS_SCOPE_P (newdecl
))
948 || (DECL_IN_SYSTEM_HEADER (olddecl
) && !DECL_CLASS_SCOPE_P (olddecl
))
952 types_match
= self_promoting_args_p (p1
);
953 if (p1
== void_list_node
)
954 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
956 #ifndef NO_IMPLICIT_EXTERN_C
957 else if (p1
== NULL_TREE
958 && (DECL_EXTERN_C_P (olddecl
)
959 && DECL_IN_SYSTEM_HEADER (olddecl
)
960 && !DECL_CLASS_SCOPE_P (olddecl
))
961 && (DECL_EXTERN_C_P (newdecl
)
962 && DECL_IN_SYSTEM_HEADER (newdecl
)
963 && !DECL_CLASS_SCOPE_P (newdecl
)))
965 types_match
= self_promoting_args_p (p2
);
966 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
);
970 types_match
= compparms (p1
, p2
);
975 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
977 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
))
978 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)))
981 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
982 DECL_TEMPLATE_PARMS (olddecl
)))
985 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
986 types_match
= same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
)),
987 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
)));
989 types_match
= decls_match (DECL_TEMPLATE_RESULT (olddecl
),
990 DECL_TEMPLATE_RESULT (newdecl
));
994 /* Need to check scope for variable declaration (VAR_DECL).
995 For typedef (TYPE_DECL), scope is ignored. */
996 if (TREE_CODE (newdecl
) == VAR_DECL
997 && CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
)
999 Two declarations for an object with C language linkage
1000 with the same name (ignoring the namespace that qualify
1001 it) that appear in different namespace scopes refer to
1003 && !(DECL_EXTERN_C_P (olddecl
) && DECL_EXTERN_C_P (newdecl
)))
1006 if (TREE_TYPE (newdecl
) == error_mark_node
)
1007 types_match
= TREE_TYPE (olddecl
) == error_mark_node
;
1008 else if (TREE_TYPE (olddecl
) == NULL_TREE
)
1009 types_match
= TREE_TYPE (newdecl
) == NULL_TREE
;
1010 else if (TREE_TYPE (newdecl
) == NULL_TREE
)
1013 types_match
= comptypes (TREE_TYPE (newdecl
),
1014 TREE_TYPE (olddecl
),
1015 COMPARE_REDECLARATION
);
1021 /* If NEWDECL is `static' and an `extern' was seen previously,
1022 warn about it. OLDDECL is the previous declaration.
1024 Note that this does not apply to the C++ case of declaring
1025 a variable `extern const' and then later `const'.
1027 Don't complain about built-in functions, since they are beyond
1028 the user's control. */
1031 warn_extern_redeclared_static (tree newdecl
, tree olddecl
)
1035 if (TREE_CODE (newdecl
) == TYPE_DECL
1036 || TREE_CODE (newdecl
) == TEMPLATE_DECL
1037 || TREE_CODE (newdecl
) == CONST_DECL
1038 || TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1041 /* Don't get confused by static member functions; that's a different
1043 if (TREE_CODE (newdecl
) == FUNCTION_DECL
1044 && DECL_STATIC_FUNCTION_P (newdecl
))
1047 /* If the old declaration was `static', or the new one isn't, then
1048 then everything is OK. */
1049 if (DECL_THIS_STATIC (olddecl
) || !DECL_THIS_STATIC (newdecl
))
1052 /* It's OK to declare a builtin function as `static'. */
1053 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1054 && DECL_ARTIFICIAL (olddecl
))
1057 name
= DECL_ASSEMBLER_NAME (newdecl
);
1058 permerror ("%qD was declared %<extern%> and later %<static%>", newdecl
);
1059 permerror ("previous declaration of %q+D", olddecl
);
1062 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1063 function templates. If their exception specifications do not
1064 match, issue a diagnostic. */
1067 check_redeclaration_exception_specification (tree new_decl
,
1072 tree new_exceptions
;
1073 tree old_exceptions
;
1075 new_type
= TREE_TYPE (new_decl
);
1076 new_exceptions
= TYPE_RAISES_EXCEPTIONS (new_type
);
1077 old_type
= TREE_TYPE (old_decl
);
1078 old_exceptions
= TYPE_RAISES_EXCEPTIONS (old_type
);
1082 If any declaration of a function has an exception-specification,
1083 all declarations, including the definition and an explicit
1084 specialization, of that function shall have an
1085 exception-specification with the same set of type-ids. */
1086 if ((pedantic
|| ! DECL_IN_SYSTEM_HEADER (old_decl
))
1087 && ! DECL_IS_BUILTIN (old_decl
)
1089 && !comp_except_specs (new_exceptions
, old_exceptions
,
1092 error ("declaration of %qF throws different exceptions", new_decl
);
1093 error ("from previous declaration %q+F", old_decl
);
1097 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1098 && lookup_attribute ("gnu_inline", \
1099 DECL_ATTRIBUTES (fn)))
1101 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1102 If the redeclaration is invalid, a diagnostic is issued, and the
1103 error_mark_node is returned. Otherwise, OLDDECL is returned.
1105 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1108 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1111 duplicate_decls (tree newdecl
, tree olddecl
, bool newdecl_is_friend
)
1113 unsigned olddecl_uid
= DECL_UID (olddecl
);
1114 int olddecl_friend
= 0, types_match
= 0, hidden_friend
= 0;
1115 int new_defines_function
= 0;
1118 if (newdecl
== olddecl
)
1121 types_match
= decls_match (newdecl
, olddecl
);
1123 /* If either the type of the new decl or the type of the old decl is an
1124 error_mark_node, then that implies that we have already issued an
1125 error (earlier) for some bogus type specification, and in that case,
1126 it is rather pointless to harass the user with yet more error message
1127 about the same declaration, so just pretend the types match here. */
1128 if (TREE_TYPE (newdecl
) == error_mark_node
1129 || TREE_TYPE (olddecl
) == error_mark_node
)
1130 return error_mark_node
;
1132 if (DECL_P (olddecl
)
1133 && TREE_CODE (newdecl
) == FUNCTION_DECL
1134 && TREE_CODE (olddecl
) == FUNCTION_DECL
1135 && (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
)))
1137 if (DECL_DECLARED_INLINE_P (newdecl
)
1138 && DECL_UNINLINABLE (newdecl
)
1139 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
1140 /* Already warned elsewhere. */;
1141 else if (DECL_DECLARED_INLINE_P (olddecl
)
1142 && DECL_UNINLINABLE (olddecl
)
1143 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
1144 /* Already warned. */;
1145 else if (DECL_DECLARED_INLINE_P (newdecl
)
1146 && DECL_UNINLINABLE (olddecl
)
1147 && lookup_attribute ("noinline", DECL_ATTRIBUTES (olddecl
)))
1149 warning (OPT_Wattributes
, "function %q+D redeclared as inline",
1151 warning (OPT_Wattributes
, "previous declaration of %q+D "
1152 "with attribute noinline", olddecl
);
1154 else if (DECL_DECLARED_INLINE_P (olddecl
)
1155 && DECL_UNINLINABLE (newdecl
)
1156 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl
)))
1158 warning (OPT_Wattributes
, "function %q+D redeclared with "
1159 "attribute noinline", newdecl
);
1160 warning (OPT_Wattributes
, "previous declaration of %q+D was inline",
1165 /* Check for redeclaration and other discrepancies. */
1166 if (TREE_CODE (olddecl
) == FUNCTION_DECL
1167 && DECL_ARTIFICIAL (olddecl
))
1169 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl
));
1170 if (TREE_CODE (newdecl
) != FUNCTION_DECL
)
1172 /* Avoid warnings redeclaring built-ins which have not been
1173 explicitly declared. */
1174 if (DECL_ANTICIPATED (olddecl
))
1177 /* If you declare a built-in or predefined function name as static,
1178 the old definition is overridden, but optionally warn this was a
1179 bad choice of name. */
1180 if (! TREE_PUBLIC (newdecl
))
1182 warning (OPT_Wshadow
, "shadowing %s function %q#D",
1183 DECL_BUILT_IN (olddecl
) ? "built-in" : "library",
1185 /* Discard the old built-in function. */
1188 /* If the built-in is not ansi, then programs can override
1189 it even globally without an error. */
1190 else if (! DECL_BUILT_IN (olddecl
))
1191 warning (0, "library function %q#D redeclared as non-function %q#D",
1195 error ("declaration of %q#D", newdecl
);
1196 error ("conflicts with built-in declaration %q#D",
1201 else if (!types_match
)
1203 /* Avoid warnings redeclaring built-ins which have not been
1204 explicitly declared. */
1205 if (DECL_ANTICIPATED (olddecl
))
1207 /* Deal with fileptr_type_node. FILE type is not known
1208 at the time we create the builtins. */
1211 for (t1
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1212 t2
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1214 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
1217 else if (TREE_VALUE (t2
) == fileptr_type_node
)
1219 tree t
= TREE_VALUE (t1
);
1221 if (TREE_CODE (t
) == POINTER_TYPE
1222 && TYPE_NAME (TREE_TYPE (t
))
1223 && DECL_NAME (TYPE_NAME (TREE_TYPE (t
)))
1224 == get_identifier ("FILE")
1225 && compparms (TREE_CHAIN (t1
), TREE_CHAIN (t2
)))
1227 tree oldargs
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1229 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))
1230 = TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
1231 types_match
= decls_match (newdecl
, olddecl
);
1233 return duplicate_decls (newdecl
, olddecl
,
1235 TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) = oldargs
;
1238 else if (! same_type_p (TREE_VALUE (t1
), TREE_VALUE (t2
)))
1241 else if ((DECL_EXTERN_C_P (newdecl
)
1242 && DECL_EXTERN_C_P (olddecl
))
1243 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1244 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
1246 /* A near match; override the builtin. */
1248 if (TREE_PUBLIC (newdecl
))
1250 warning (0, "new declaration %q#D", newdecl
);
1251 warning (0, "ambiguates built-in declaration %q#D",
1255 warning (OPT_Wshadow
, "shadowing %s function %q#D",
1256 DECL_BUILT_IN (olddecl
) ? "built-in" : "library",
1260 /* Discard the old built-in function. */
1263 /* Replace the old RTL to avoid problems with inlining. */
1264 COPY_DECL_RTL (newdecl
, olddecl
);
1266 /* Even if the types match, prefer the new declarations type for
1267 built-ins which have not been explicitly declared, for
1268 exception lists, etc... */
1269 else if (DECL_ANTICIPATED (olddecl
))
1271 tree type
= TREE_TYPE (newdecl
);
1272 tree attribs
= (*targetm
.merge_type_attributes
)
1273 (TREE_TYPE (olddecl
), type
);
1275 type
= cp_build_type_attribute_variant (type
, attribs
);
1276 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = type
;
1279 /* If a function is explicitly declared "throw ()", propagate that to
1280 the corresponding builtin. */
1281 if (DECL_BUILT_IN_CLASS (olddecl
) == BUILT_IN_NORMAL
1282 && DECL_ANTICIPATED (olddecl
)
1283 && TREE_NOTHROW (newdecl
)
1284 && !TREE_NOTHROW (olddecl
)
1285 && built_in_decls
[DECL_FUNCTION_CODE (olddecl
)] != NULL_TREE
1286 && built_in_decls
[DECL_FUNCTION_CODE (olddecl
)] != olddecl
1288 TREE_NOTHROW (built_in_decls
[DECL_FUNCTION_CODE (olddecl
)]) = 1;
1290 /* Whether or not the builtin can throw exceptions has no
1291 bearing on this declarator. */
1292 TREE_NOTHROW (olddecl
) = 0;
1294 if (DECL_THIS_STATIC (newdecl
) && !DECL_THIS_STATIC (olddecl
))
1296 /* If a builtin function is redeclared as `static', merge
1297 the declarations, but make the original one static. */
1298 DECL_THIS_STATIC (olddecl
) = 1;
1299 TREE_PUBLIC (olddecl
) = 0;
1301 /* Make the old declaration consistent with the new one so
1302 that all remnants of the builtin-ness of this function
1303 will be banished. */
1304 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
1305 COPY_DECL_RTL (newdecl
, olddecl
);
1308 else if (TREE_CODE (olddecl
) != TREE_CODE (newdecl
))
1310 /* C++ Standard, 3.3, clause 4:
1311 "[Note: a namespace name or a class template name must be unique
1312 in its declarative region (7.3.2, clause 14). ]" */
1313 if (TREE_CODE (olddecl
) != NAMESPACE_DECL
1314 && TREE_CODE (newdecl
) != NAMESPACE_DECL
1315 && (TREE_CODE (olddecl
) != TEMPLATE_DECL
1316 || TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) != TYPE_DECL
)
1317 && (TREE_CODE (newdecl
) != TEMPLATE_DECL
1318 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != TYPE_DECL
))
1320 if ((TREE_CODE (olddecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (olddecl
)
1321 && TREE_CODE (newdecl
) != TYPE_DECL
)
1322 || (TREE_CODE (newdecl
) == TYPE_DECL
&& DECL_ARTIFICIAL (newdecl
)
1323 && TREE_CODE (olddecl
) != TYPE_DECL
))
1325 /* We do nothing special here, because C++ does such nasty
1326 things with TYPE_DECLs. Instead, just let the TYPE_DECL
1327 get shadowed, and know that if we need to find a TYPE_DECL
1328 for a given name, we can look in the IDENTIFIER_TYPE_VALUE
1329 slot of the identifier. */
1333 if ((TREE_CODE (newdecl
) == FUNCTION_DECL
1334 && DECL_FUNCTION_TEMPLATE_P (olddecl
))
1335 || (TREE_CODE (olddecl
) == FUNCTION_DECL
1336 && DECL_FUNCTION_TEMPLATE_P (newdecl
)))
1340 error ("%q#D redeclared as different kind of symbol", newdecl
);
1341 if (TREE_CODE (olddecl
) == TREE_LIST
)
1342 olddecl
= TREE_VALUE (olddecl
);
1343 error ("previous declaration of %q+#D", olddecl
);
1345 return error_mark_node
;
1347 else if (!types_match
)
1349 if (CP_DECL_CONTEXT (newdecl
) != CP_DECL_CONTEXT (olddecl
))
1350 /* These are certainly not duplicate declarations; they're
1351 from different scopes. */
1354 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1356 /* The name of a class template may not be declared to refer to
1357 any other template, class, function, object, namespace, value,
1358 or type in the same scope. */
1359 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == TYPE_DECL
1360 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
1362 error ("declaration of template %q#D", newdecl
);
1363 error ("conflicts with previous declaration %q+#D", olddecl
);
1365 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
)) == FUNCTION_DECL
1366 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == FUNCTION_DECL
1367 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl
))),
1368 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl
))))
1369 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl
),
1370 DECL_TEMPLATE_PARMS (olddecl
))
1371 /* Template functions can be disambiguated by
1373 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl
)),
1374 TREE_TYPE (TREE_TYPE (olddecl
))))
1376 error ("new declaration %q#D", newdecl
);
1377 error ("ambiguates old declaration %q+#D", olddecl
);
1381 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1383 if (DECL_EXTERN_C_P (newdecl
) && DECL_EXTERN_C_P (olddecl
))
1385 error ("declaration of C function %q#D conflicts with",
1387 error ("previous declaration %q+#D here", olddecl
);
1389 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl
)),
1390 TYPE_ARG_TYPES (TREE_TYPE (olddecl
))))
1392 error ("new declaration %q#D", newdecl
);
1393 error ("ambiguates old declaration %q+#D", olddecl
);
1394 return error_mark_node
;
1401 error ("conflicting declaration %q#D", newdecl
);
1402 error ("%q+D has a previous declaration as %q#D", olddecl
, olddecl
);
1403 return error_mark_node
;
1406 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1407 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl
)
1408 && (!DECL_TEMPLATE_INFO (newdecl
)
1409 || (DECL_TI_TEMPLATE (newdecl
)
1410 != DECL_TI_TEMPLATE (olddecl
))))
1411 || (DECL_TEMPLATE_SPECIALIZATION (newdecl
)
1412 && (!DECL_TEMPLATE_INFO (olddecl
)
1413 || (DECL_TI_TEMPLATE (olddecl
)
1414 != DECL_TI_TEMPLATE (newdecl
))))))
1415 /* It's OK to have a template specialization and a non-template
1416 with the same type, or to have specializations of two
1417 different templates with the same type. Note that if one is a
1418 specialization, and the other is an instantiation of the same
1419 template, that we do not exit at this point. That situation
1420 can occur if we instantiate a template class, and then
1421 specialize one of its methods. This situation is valid, but
1422 the declarations must be merged in the usual way. */
1424 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
1425 && ((DECL_TEMPLATE_INSTANTIATION (olddecl
)
1426 && !DECL_USE_TEMPLATE (newdecl
))
1427 || (DECL_TEMPLATE_INSTANTIATION (newdecl
)
1428 && !DECL_USE_TEMPLATE (olddecl
))))
1429 /* One of the declarations is a template instantiation, and the
1430 other is not a template at all. That's OK. */
1432 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
1434 /* In [namespace.alias] we have:
1436 In a declarative region, a namespace-alias-definition can be
1437 used to redefine a namespace-alias declared in that declarative
1438 region to refer only to the namespace to which it already
1441 Therefore, if we encounter a second alias directive for the same
1442 alias, we can just ignore the second directive. */
1443 if (DECL_NAMESPACE_ALIAS (newdecl
)
1444 && (DECL_NAMESPACE_ALIAS (newdecl
)
1445 == DECL_NAMESPACE_ALIAS (olddecl
)))
1447 /* [namespace.alias]
1449 A namespace-name or namespace-alias shall not be declared as
1450 the name of any other entity in the same declarative region.
1451 A namespace-name defined at global scope shall not be
1452 declared as the name of any other entity in any global scope
1454 error ("declaration of namespace %qD conflicts with", newdecl
);
1455 error ("previous declaration of namespace %q+D here", olddecl
);
1456 return error_mark_node
;
1460 const char *errmsg
= redeclaration_error_message (newdecl
, olddecl
);
1463 error (errmsg
, newdecl
);
1464 if (DECL_NAME (olddecl
) != NULL_TREE
)
1465 error ((DECL_INITIAL (olddecl
) && namespace_bindings_p ())
1466 ? "%q+#D previously defined here"
1467 : "%q+#D previously declared here", olddecl
);
1468 return error_mark_node
;
1470 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
1471 && DECL_INITIAL (olddecl
) != NULL_TREE
1472 && TYPE_ARG_TYPES (TREE_TYPE (olddecl
)) == NULL_TREE
1473 && TYPE_ARG_TYPES (TREE_TYPE (newdecl
)) != NULL_TREE
)
1475 /* Prototype decl follows defn w/o prototype. */
1476 warning (0, "prototype for %q+#D", newdecl
);
1477 warning (0, "%Jfollows non-prototype definition here", olddecl
);
1479 else if ((TREE_CODE (olddecl
) == FUNCTION_DECL
1480 || TREE_CODE (olddecl
) == VAR_DECL
)
1481 && DECL_LANGUAGE (newdecl
) != DECL_LANGUAGE (olddecl
))
1484 If two declarations of the same function or object
1485 specify different linkage-specifications ..., the program
1486 is ill-formed.... Except for functions with C++ linkage,
1487 a function declaration without a linkage specification
1488 shall not precede the first linkage specification for
1489 that function. A function can be declared without a
1490 linkage specification after an explicit linkage
1491 specification has been seen; the linkage explicitly
1492 specified in the earlier declaration is not affected by
1493 such a function declaration.
1495 DR 563 raises the question why the restrictions on
1496 functions should not also apply to objects. Older
1497 versions of G++ silently ignore the linkage-specification
1505 which is clearly wrong. Therefore, we now treat objects
1507 if (current_lang_depth () == 0)
1509 /* There is no explicit linkage-specification, so we use
1510 the linkage from the previous declaration. */
1511 if (!DECL_LANG_SPECIFIC (newdecl
))
1512 retrofit_lang_decl (newdecl
);
1513 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
1517 error ("previous declaration of %q+#D with %qL linkage",
1518 olddecl
, DECL_LANGUAGE (olddecl
));
1519 error ("conflicts with new declaration with %qL linkage",
1520 DECL_LANGUAGE (newdecl
));
1524 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_USE_TEMPLATE (olddecl
))
1526 else if (TREE_CODE (olddecl
) == FUNCTION_DECL
)
1528 tree t1
= TYPE_ARG_TYPES (TREE_TYPE (olddecl
));
1529 tree t2
= TYPE_ARG_TYPES (TREE_TYPE (newdecl
));
1532 if (TREE_CODE (TREE_TYPE (newdecl
)) == METHOD_TYPE
)
1533 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
);
1535 for (; t1
&& t1
!= void_list_node
;
1536 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
), i
++)
1537 if (TREE_PURPOSE (t1
) && TREE_PURPOSE (t2
))
1539 if (1 == simple_cst_equal (TREE_PURPOSE (t1
),
1542 permerror ("default argument given for parameter %d of %q#D",
1544 permerror ("after previous specification in %q+#D", olddecl
);
1548 error ("default argument given for parameter %d of %q#D",
1550 error ("after previous specification in %q+#D",
1555 if (DECL_DECLARED_INLINE_P (newdecl
)
1556 && ! DECL_DECLARED_INLINE_P (olddecl
)
1557 && TREE_ADDRESSABLE (olddecl
) && warn_inline
)
1559 warning (0, "%q#D was used before it was declared inline", newdecl
);
1560 warning (0, "%Jprevious non-inline declaration here", olddecl
);
1565 /* Do not merge an implicit typedef with an explicit one. In:
1569 typedef class A A __attribute__ ((foo));
1571 the attribute should apply only to the typedef. */
1572 if (TREE_CODE (olddecl
) == TYPE_DECL
1573 && (DECL_IMPLICIT_TYPEDEF_P (olddecl
)
1574 || DECL_IMPLICIT_TYPEDEF_P (newdecl
)))
1577 /* If new decl is `static' and an `extern' was seen previously,
1579 warn_extern_redeclared_static (newdecl
, olddecl
);
1581 /* We have committed to returning 1 at this point. */
1582 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1584 /* Now that functions must hold information normally held
1585 by field decls, there is extra work to do so that
1586 declaration information does not get destroyed during
1588 if (DECL_VINDEX (olddecl
))
1589 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
1590 if (DECL_CONTEXT (olddecl
))
1591 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
1592 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
1593 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
1594 DECL_PURE_VIRTUAL_P (newdecl
) |= DECL_PURE_VIRTUAL_P (olddecl
);
1595 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
1596 DECL_INVALID_OVERRIDER_P (newdecl
) |= DECL_INVALID_OVERRIDER_P (olddecl
);
1597 DECL_THIS_STATIC (newdecl
) |= DECL_THIS_STATIC (olddecl
);
1598 if (DECL_OVERLOADED_OPERATOR_P (olddecl
) != ERROR_MARK
)
1599 SET_OVERLOADED_OPERATOR_CODE
1600 (newdecl
, DECL_OVERLOADED_OPERATOR_P (olddecl
));
1601 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
1603 /* Optionally warn about more than one declaration for the same
1604 name, but don't warn about a function declaration followed by a
1606 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
1607 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
1608 /* Don't warn about extern decl followed by definition. */
1609 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
1610 /* Don't warn about friends, let add_friend take care of it. */
1611 && ! (newdecl_is_friend
|| DECL_FRIEND_P (olddecl
)))
1613 warning (OPT_Wredundant_decls
, "redundant redeclaration of %qD in same scope", newdecl
);
1614 warning (OPT_Wredundant_decls
, "previous declaration of %q+D", olddecl
);
1618 /* Deal with C++: must preserve virtual function table size. */
1619 if (TREE_CODE (olddecl
) == TYPE_DECL
)
1621 tree newtype
= TREE_TYPE (newdecl
);
1622 tree oldtype
= TREE_TYPE (olddecl
);
1624 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
1625 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
1626 CLASSTYPE_FRIEND_CLASSES (newtype
)
1627 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
1629 DECL_ORIGINAL_TYPE (newdecl
) = DECL_ORIGINAL_TYPE (olddecl
);
1632 /* Copy all the DECL_... slots specified in the new decl
1633 except for any that we copy here from the old type. */
1634 DECL_ATTRIBUTES (newdecl
)
1635 = (*targetm
.merge_decl_attributes
) (olddecl
, newdecl
);
1637 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1641 old_result
= DECL_TEMPLATE_RESULT (olddecl
);
1642 new_result
= DECL_TEMPLATE_RESULT (newdecl
);
1643 TREE_TYPE (olddecl
) = TREE_TYPE (old_result
);
1644 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
1645 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
1646 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
1648 DECL_ATTRIBUTES (old_result
)
1649 = (*targetm
.merge_decl_attributes
) (old_result
, new_result
);
1651 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
1653 if (GNU_INLINE_P (old_result
) != GNU_INLINE_P (new_result
)
1654 && DECL_INITIAL (new_result
))
1656 if (DECL_INITIAL (old_result
))
1658 DECL_INLINE (old_result
) = 0;
1659 DECL_UNINLINABLE (old_result
) = 1;
1663 DECL_INLINE (old_result
) = DECL_INLINE (new_result
);
1664 DECL_UNINLINABLE (old_result
) = DECL_UNINLINABLE (new_result
);
1666 DECL_EXTERNAL (old_result
) = DECL_EXTERNAL (new_result
);
1667 DECL_NOT_REALLY_EXTERN (old_result
)
1668 = DECL_NOT_REALLY_EXTERN (new_result
);
1669 DECL_INTERFACE_KNOWN (old_result
)
1670 = DECL_INTERFACE_KNOWN (new_result
);
1671 DECL_DECLARED_INLINE_P (old_result
)
1672 = DECL_DECLARED_INLINE_P (new_result
);
1673 DECL_DISREGARD_INLINE_LIMITS (old_result
)
1674 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
1679 DECL_INLINE (old_result
)
1680 |= DECL_INLINE (new_result
);
1681 DECL_DECLARED_INLINE_P (old_result
)
1682 |= DECL_DECLARED_INLINE_P (new_result
);
1683 DECL_DISREGARD_INLINE_LIMITS (old_result
)
1684 |= DECL_DISREGARD_INLINE_LIMITS (new_result
);
1685 check_redeclaration_exception_specification (newdecl
, olddecl
);
1689 /* If the new declaration is a definition, update the file and
1690 line information on the declaration, and also make
1691 the old declaration the same definition. */
1692 if (DECL_INITIAL (new_result
) != NULL_TREE
)
1694 DECL_SOURCE_LOCATION (olddecl
)
1695 = DECL_SOURCE_LOCATION (old_result
)
1696 = DECL_SOURCE_LOCATION (newdecl
);
1697 DECL_INITIAL (old_result
) = DECL_INITIAL (new_result
);
1698 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
1699 DECL_ARGUMENTS (old_result
)
1700 = DECL_ARGUMENTS (new_result
);
1708 /* Automatically handles default parameters. */
1709 tree oldtype
= TREE_TYPE (olddecl
);
1712 /* Merge the data types specified in the two decls. */
1713 newtype
= merge_types (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
1715 /* If merge_types produces a non-typedef type, just use the old type. */
1716 if (TREE_CODE (newdecl
) == TYPE_DECL
1717 && newtype
== DECL_ORIGINAL_TYPE (newdecl
))
1720 if (TREE_CODE (newdecl
) == VAR_DECL
)
1722 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
1723 DECL_INITIALIZED_P (newdecl
) |= DECL_INITIALIZED_P (olddecl
);
1724 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl
)
1725 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl
);
1726 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl
)
1727 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl
);
1729 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
1730 if (DECL_LANG_SPECIFIC (olddecl
)
1731 && CP_DECL_THREADPRIVATE_P (olddecl
))
1733 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
1734 if (!DECL_LANG_SPECIFIC (newdecl
))
1735 retrofit_lang_decl (newdecl
);
1737 DECL_TLS_MODEL (newdecl
) = DECL_TLS_MODEL (olddecl
);
1738 CP_DECL_THREADPRIVATE_P (newdecl
) = 1;
1742 /* Do this after calling `merge_types' so that default
1743 parameters don't confuse us. */
1744 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1745 check_redeclaration_exception_specification (newdecl
, olddecl
);
1746 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
1748 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1749 check_default_args (newdecl
);
1751 /* Lay the type out, unless already done. */
1752 if (! same_type_p (newtype
, oldtype
)
1753 && TREE_TYPE (newdecl
) != error_mark_node
1754 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
1755 layout_type (TREE_TYPE (newdecl
));
1757 if ((TREE_CODE (newdecl
) == VAR_DECL
1758 || TREE_CODE (newdecl
) == PARM_DECL
1759 || TREE_CODE (newdecl
) == RESULT_DECL
1760 || TREE_CODE (newdecl
) == FIELD_DECL
1761 || TREE_CODE (newdecl
) == TYPE_DECL
)
1762 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
1763 layout_decl (newdecl
, 0);
1765 /* Merge the type qualifiers. */
1766 if (TREE_READONLY (newdecl
))
1767 TREE_READONLY (olddecl
) = 1;
1768 if (TREE_THIS_VOLATILE (newdecl
))
1769 TREE_THIS_VOLATILE (olddecl
) = 1;
1770 if (TREE_NOTHROW (newdecl
))
1771 TREE_NOTHROW (olddecl
) = 1;
1773 /* Merge deprecatedness. */
1774 if (TREE_DEPRECATED (newdecl
))
1775 TREE_DEPRECATED (olddecl
) = 1;
1777 /* Merge the initialization information. */
1778 if (DECL_INITIAL (newdecl
) == NULL_TREE
1779 && DECL_INITIAL (olddecl
) != NULL_TREE
)
1781 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
1782 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
1783 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl
)
1784 && DECL_LANG_SPECIFIC (newdecl
)
1785 && DECL_LANG_SPECIFIC (olddecl
))
1787 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
1788 DECL_STRUCT_FUNCTION (newdecl
) = DECL_STRUCT_FUNCTION (olddecl
);
1792 /* Merge the section attribute.
1793 We want to issue an error if the sections conflict but that must be
1794 done later in decl_attributes since we are called before attributes
1796 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
1797 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
1799 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1801 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
1802 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
1803 DECL_NO_LIMIT_STACK (newdecl
) |= DECL_NO_LIMIT_STACK (olddecl
);
1804 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
1805 TREE_NOTHROW (newdecl
) |= TREE_NOTHROW (olddecl
);
1806 DECL_IS_MALLOC (newdecl
) |= DECL_IS_MALLOC (olddecl
);
1807 DECL_IS_OPERATOR_NEW (newdecl
) |= DECL_IS_OPERATOR_NEW (olddecl
);
1808 DECL_PURE_P (newdecl
) |= DECL_PURE_P (olddecl
);
1809 TREE_READONLY (newdecl
) |= TREE_READONLY (olddecl
);
1810 DECL_LOOPING_CONST_OR_PURE_P (newdecl
)
1811 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl
);
1812 /* Keep the old RTL. */
1813 COPY_DECL_RTL (olddecl
, newdecl
);
1815 else if (TREE_CODE (newdecl
) == VAR_DECL
1816 && (DECL_SIZE (olddecl
) || !DECL_SIZE (newdecl
)))
1818 /* Keep the old RTL. We cannot keep the old RTL if the old
1819 declaration was for an incomplete object and the new
1820 declaration is not since many attributes of the RTL will
1822 COPY_DECL_RTL (olddecl
, newdecl
);
1825 /* If cannot merge, then use the new type and qualifiers,
1826 and don't preserve the old rtl. */
1829 /* Clean out any memory we had of the old declaration. */
1830 tree oldstatic
= value_member (olddecl
, static_aggregates
);
1832 TREE_VALUE (oldstatic
) = error_mark_node
;
1834 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
1835 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
1836 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
1837 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
1840 /* Merge the storage class information. */
1841 merge_weak (newdecl
, olddecl
);
1843 DECL_ONE_ONLY (newdecl
) |= DECL_ONE_ONLY (olddecl
);
1844 DECL_DEFER_OUTPUT (newdecl
) |= DECL_DEFER_OUTPUT (olddecl
);
1845 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
1846 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
1847 if (! DECL_EXTERNAL (olddecl
))
1848 DECL_EXTERNAL (newdecl
) = 0;
1850 new_template
= NULL_TREE
;
1851 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
1853 bool new_redefines_gnu_inline
= false;
1855 if (new_defines_function
1856 && ((DECL_INTERFACE_KNOWN (olddecl
)
1857 && TREE_CODE (olddecl
) == FUNCTION_DECL
)
1858 || (TREE_CODE (olddecl
) == TEMPLATE_DECL
1859 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
1860 == FUNCTION_DECL
))))
1864 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
1865 fn
= DECL_TEMPLATE_RESULT (olddecl
);
1867 new_redefines_gnu_inline
= GNU_INLINE_P (fn
) && DECL_INITIAL (fn
);
1870 if (!new_redefines_gnu_inline
)
1872 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
1873 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
1874 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
1876 DECL_TEMPLATE_INSTANTIATED (newdecl
)
1877 |= DECL_TEMPLATE_INSTANTIATED (olddecl
);
1879 /* If the OLDDECL is an instantiation and/or specialization,
1880 then the NEWDECL must be too. But, it may not yet be marked
1881 as such if the caller has created NEWDECL, but has not yet
1882 figured out that it is a redeclaration. */
1883 if (!DECL_USE_TEMPLATE (newdecl
))
1884 DECL_USE_TEMPLATE (newdecl
) = DECL_USE_TEMPLATE (olddecl
);
1886 /* Don't really know how much of the language-specific
1887 values we should copy from old to new. */
1888 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
1889 DECL_LANG_SPECIFIC (newdecl
)->decl_flags
.u2
=
1890 DECL_LANG_SPECIFIC (olddecl
)->decl_flags
.u2
;
1891 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
1892 DECL_REPO_AVAILABLE_P (newdecl
) = DECL_REPO_AVAILABLE_P (olddecl
);
1893 if (DECL_TEMPLATE_INFO (newdecl
))
1894 new_template
= DECL_TI_TEMPLATE (newdecl
);
1895 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
1896 DECL_INITIALIZED_IN_CLASS_P (newdecl
)
1897 |= DECL_INITIALIZED_IN_CLASS_P (olddecl
);
1898 olddecl_friend
= DECL_FRIEND_P (olddecl
);
1899 hidden_friend
= (DECL_ANTICIPATED (olddecl
)
1900 && DECL_HIDDEN_FRIEND_P (olddecl
)
1901 && newdecl_is_friend
);
1903 /* Only functions have DECL_BEFRIENDING_CLASSES. */
1904 if (TREE_CODE (newdecl
) == FUNCTION_DECL
1905 || DECL_FUNCTION_TEMPLATE_P (newdecl
))
1907 DECL_BEFRIENDING_CLASSES (newdecl
)
1908 = chainon (DECL_BEFRIENDING_CLASSES (newdecl
),
1909 DECL_BEFRIENDING_CLASSES (olddecl
));
1910 /* DECL_THUNKS is only valid for virtual functions,
1911 otherwise it is a DECL_FRIEND_CONTEXT. */
1912 if (DECL_VIRTUAL_P (newdecl
))
1913 DECL_THUNKS (newdecl
) = DECL_THUNKS (olddecl
);
1917 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1919 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
1920 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
1922 /* If newdecl is not a specialization, then it is not a
1923 template-related function at all. And that means that we
1924 should have exited above, returning 0. */
1925 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
));
1927 if (TREE_USED (olddecl
))
1928 /* From [temp.expl.spec]:
1930 If a template, a member template or the member of a class
1931 template is explicitly specialized then that
1932 specialization shall be declared before the first use of
1933 that specialization that would cause an implicit
1934 instantiation to take place, in every translation unit in
1935 which such a use occurs. */
1936 error ("explicit specialization of %qD after first use",
1939 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
1941 /* Don't propagate visibility from the template to the
1942 specialization here. We'll do that in determine_visibility if
1944 DECL_VISIBILITY_SPECIFIED (olddecl
) = 0;
1946 /* [temp.expl.spec/14] We don't inline explicit specialization
1947 just because the primary template says so. */
1949 else if (new_defines_function
&& DECL_INITIAL (olddecl
))
1951 /* C++ is always in in unit-at-a-time mode, so we never
1952 inline re-defined extern inline functions. */
1953 DECL_INLINE (newdecl
) = 0;
1954 DECL_UNINLINABLE (newdecl
) = 1;
1958 if (DECL_PENDING_INLINE_INFO (newdecl
) == 0)
1959 DECL_PENDING_INLINE_INFO (newdecl
) = DECL_PENDING_INLINE_INFO (olddecl
);
1961 DECL_DECLARED_INLINE_P (newdecl
) |= DECL_DECLARED_INLINE_P (olddecl
);
1963 /* If either decl says `inline', this fn is inline, unless
1964 its definition was passed already. */
1965 if (DECL_INLINE (newdecl
) && DECL_INITIAL (olddecl
) == NULL_TREE
)
1966 DECL_INLINE (olddecl
) = 1;
1967 DECL_INLINE (newdecl
) = DECL_INLINE (olddecl
);
1969 DECL_UNINLINABLE (newdecl
) = DECL_UNINLINABLE (olddecl
)
1970 = (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
));
1972 DECL_DISREGARD_INLINE_LIMITS (newdecl
)
1973 = DECL_DISREGARD_INLINE_LIMITS (olddecl
)
1974 = (DECL_DISREGARD_INLINE_LIMITS (newdecl
)
1975 || DECL_DISREGARD_INLINE_LIMITS (olddecl
));
1978 /* Preserve abstractness on cloned [cd]tors. */
1979 DECL_ABSTRACT (newdecl
) = DECL_ABSTRACT (olddecl
);
1983 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
1984 COPY_DECL_ASSEMBLER_NAME (newdecl
, olddecl
);
1985 COPY_DECL_RTL (newdecl
, olddecl
);
1987 if (! types_match
|| new_defines_function
)
1989 /* These need to be copied so that the names are available.
1990 Note that if the types do match, we'll preserve inline
1991 info and other bits, but if not, we won't. */
1992 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
1993 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
1995 if (new_defines_function
)
1996 /* If defining a function declared with other language
1997 linkage, use the previously declared language linkage. */
1998 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
1999 else if (types_match
)
2001 /* If redeclaring a builtin function, and not a definition,
2002 it stays built in. */
2003 if (DECL_BUILT_IN (olddecl
))
2005 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
2006 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
2007 /* If we're keeping the built-in definition, keep the rtl,
2008 regardless of declaration matches. */
2009 COPY_DECL_RTL (olddecl
, newdecl
);
2012 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
2013 /* Don't clear out the arguments if we're redefining a function. */
2014 if (DECL_ARGUMENTS (olddecl
))
2015 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
2018 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
2019 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
2021 /* Now preserve various other info from the definition. */
2022 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
2023 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
2024 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
2025 COPY_DECL_ASSEMBLER_NAME (olddecl
, newdecl
);
2027 /* Warn about conflicting visibility specifications. */
2028 if (DECL_VISIBILITY_SPECIFIED (olddecl
)
2029 && DECL_VISIBILITY_SPECIFIED (newdecl
)
2030 && DECL_VISIBILITY (newdecl
) != DECL_VISIBILITY (olddecl
))
2032 warning (OPT_Wattributes
, "%q+D: visibility attribute ignored "
2033 "because it", newdecl
);
2034 warning (OPT_Wattributes
, "%Jconflicts with previous "
2035 "declaration here", olddecl
);
2037 /* Choose the declaration which specified visibility. */
2038 if (DECL_VISIBILITY_SPECIFIED (olddecl
))
2040 DECL_VISIBILITY (newdecl
) = DECL_VISIBILITY (olddecl
);
2041 DECL_VISIBILITY_SPECIFIED (newdecl
) = 1;
2043 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2044 so keep this behavior. */
2045 if (TREE_CODE (newdecl
) == VAR_DECL
&& DECL_HAS_INIT_PRIORITY_P (newdecl
))
2047 SET_DECL_INIT_PRIORITY (olddecl
, DECL_INIT_PRIORITY (newdecl
));
2048 DECL_HAS_INIT_PRIORITY_P (olddecl
) = 1;
2051 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2052 with that from NEWDECL below. */
2053 if (DECL_LANG_SPECIFIC (olddecl
))
2055 gcc_assert (DECL_LANG_SPECIFIC (olddecl
)
2056 != DECL_LANG_SPECIFIC (newdecl
));
2057 ggc_free (DECL_LANG_SPECIFIC (olddecl
));
2060 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2064 function_size
= sizeof (struct tree_decl_common
);
2066 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2067 (char *) newdecl
+ sizeof (struct tree_common
),
2068 function_size
- sizeof (struct tree_common
));
2070 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2071 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2072 sizeof (struct tree_function_decl
) - sizeof (struct tree_decl_common
));
2074 /* If newdecl is a template instantiation, it is possible that
2075 the following sequence of events has occurred:
2077 o A friend function was declared in a class template. The
2078 class template was instantiated.
2080 o The instantiation of the friend declaration was
2081 recorded on the instantiation list, and is newdecl.
2083 o Later, however, instantiate_class_template called pushdecl
2084 on the newdecl to perform name injection. But, pushdecl in
2085 turn called duplicate_decls when it discovered that another
2086 declaration of a global function with the same name already
2089 o Here, in duplicate_decls, we decided to clobber newdecl.
2091 If we're going to do that, we'd better make sure that
2092 olddecl, and not newdecl, is on the list of
2093 instantiations so that if we try to do the instantiation
2094 again we won't get the clobbered declaration. */
2095 reregister_specialization (newdecl
,
2101 size_t size
= tree_code_size (TREE_CODE (olddecl
));
2102 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2103 (char *) newdecl
+ sizeof (struct tree_common
),
2104 sizeof (struct tree_decl_common
) - sizeof (struct tree_common
));
2105 switch (TREE_CODE (olddecl
))
2115 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2116 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2117 size
- sizeof (struct tree_decl_common
)
2118 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2122 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2123 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2124 sizeof (struct tree_decl_non_common
) - sizeof (struct tree_decl_common
)
2125 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2129 DECL_UID (olddecl
) = olddecl_uid
;
2131 DECL_FRIEND_P (olddecl
) = 1;
2134 DECL_ANTICIPATED (olddecl
) = 1;
2135 DECL_HIDDEN_FRIEND_P (olddecl
) = 1;
2138 /* NEWDECL contains the merged attribute lists.
2139 Update OLDDECL to be the same. */
2140 DECL_ATTRIBUTES (olddecl
) = DECL_ATTRIBUTES (newdecl
);
2142 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2143 so that encode_section_info has a chance to look at the new decl
2144 flags and attributes. */
2145 if (DECL_RTL_SET_P (olddecl
)
2146 && (TREE_CODE (olddecl
) == FUNCTION_DECL
2147 || (TREE_CODE (olddecl
) == VAR_DECL
2148 && TREE_STATIC (olddecl
))))
2149 make_decl_rtl (olddecl
);
2151 /* The NEWDECL will no longer be needed. Because every out-of-class
2152 declaration of a member results in a call to duplicate_decls,
2153 freeing these nodes represents in a significant savings. */
2159 /* Return zero if the declaration NEWDECL is valid
2160 when the declaration OLDDECL (assumed to be for the same name)
2161 has already been seen.
2162 Otherwise return an error message format string with a %s
2163 where the identifier should go. */
2166 redeclaration_error_message (tree newdecl
, tree olddecl
)
2168 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2170 /* Because C++ can put things into name space for free,
2171 constructs like "typedef struct foo { ... } foo"
2172 would look like an erroneous redeclaration. */
2173 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
2176 return "redefinition of %q#D";
2178 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2180 /* If this is a pure function, its olddecl will actually be
2181 the original initialization to `0' (which we force to call
2182 abort()). Don't complain about redefinition in this case. */
2183 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_PURE_VIRTUAL_P (olddecl
)
2184 && DECL_INITIAL (olddecl
) == NULL_TREE
)
2187 /* If both functions come from different namespaces, this is not
2188 a redeclaration - this is a conflict with a used function. */
2189 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
2190 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
)
2191 && ! decls_match (olddecl
, newdecl
))
2192 return "%qD conflicts with used function";
2194 /* We'll complain about linkage mismatches in
2195 warn_extern_redeclared_static. */
2197 /* Defining the same name twice is no good. */
2198 if (DECL_INITIAL (olddecl
) != NULL_TREE
2199 && DECL_INITIAL (newdecl
) != NULL_TREE
)
2201 if (DECL_NAME (olddecl
) == NULL_TREE
)
2202 return "%q#D not declared in class";
2203 else if (!GNU_INLINE_P (olddecl
)
2204 || GNU_INLINE_P (newdecl
))
2205 return "redefinition of %q#D";
2208 if (DECL_DECLARED_INLINE_P (olddecl
) && DECL_DECLARED_INLINE_P (newdecl
))
2210 bool olda
= GNU_INLINE_P (olddecl
);
2211 bool newa
= GNU_INLINE_P (newdecl
);
2216 return "%q+D redeclared inline with %<gnu_inline%> attribute";
2218 return "%q+D redeclared inline without %<gnu_inline%> attribute";
2224 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2228 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2230 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl
))
2231 && COMPLETE_TYPE_P (TREE_TYPE (olddecl
)))
2232 return "redefinition of %q#D";
2236 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != FUNCTION_DECL
2237 || (DECL_TEMPLATE_RESULT (newdecl
)
2238 == DECL_TEMPLATE_RESULT (olddecl
)))
2241 nt
= DECL_TEMPLATE_RESULT (newdecl
);
2242 if (DECL_TEMPLATE_INFO (nt
))
2243 nt
= DECL_TEMPLATE_RESULT (template_for_substitution (nt
));
2244 ot
= DECL_TEMPLATE_RESULT (olddecl
);
2245 if (DECL_TEMPLATE_INFO (ot
))
2246 ot
= DECL_TEMPLATE_RESULT (template_for_substitution (ot
));
2247 if (DECL_INITIAL (nt
) && DECL_INITIAL (ot
)
2248 && (!GNU_INLINE_P (ot
) || GNU_INLINE_P (nt
)))
2249 return "redefinition of %q#D";
2251 if (DECL_DECLARED_INLINE_P (ot
) && DECL_DECLARED_INLINE_P (nt
))
2253 bool olda
= GNU_INLINE_P (ot
);
2254 bool newa
= GNU_INLINE_P (nt
);
2259 return "%q+D redeclared inline with %<gnu_inline%> attribute";
2261 return "%q+D redeclared inline without %<gnu_inline%> attribute";
2265 /* Core issue #226 (C++0x):
2267 If a friend function template declaration specifies a
2268 default template-argument, that declaration shall be a
2269 definition and shall be the only declaration of the
2270 function template in the translation unit. */
2271 if ((cxx_dialect
!= cxx98
)
2272 && TREE_CODE (ot
) == FUNCTION_DECL
&& DECL_FRIEND_P (ot
)
2273 && !check_default_tmpl_args (nt
, DECL_TEMPLATE_PARMS (newdecl
),
2274 /*is_primary=*/1, /*is_partial=*/0,
2275 /*is_friend_decl=*/2))
2276 return "redeclaration of friend %q#D may not have default template arguments";
2280 else if (TREE_CODE (newdecl
) == VAR_DECL
2281 && DECL_THREAD_LOCAL_P (newdecl
) != DECL_THREAD_LOCAL_P (olddecl
)
2282 && (! DECL_LANG_SPECIFIC (olddecl
)
2283 || ! CP_DECL_THREADPRIVATE_P (olddecl
)
2284 || DECL_THREAD_LOCAL_P (newdecl
)))
2286 /* Only variables can be thread-local, and all declarations must
2287 agree on this property. */
2288 if (DECL_THREAD_LOCAL_P (newdecl
))
2289 return "thread-local declaration of %q#D follows "
2290 "non-thread-local declaration";
2292 return "non-thread-local declaration of %q#D follows "
2293 "thread-local declaration";
2295 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl
))
2297 /* The objects have been declared at namespace scope. If either
2298 is a member of an anonymous union, then this is an invalid
2299 redeclaration. For example:
2305 if ((TREE_CODE (newdecl
) == VAR_DECL
&& DECL_ANON_UNION_VAR_P (newdecl
))
2306 || (TREE_CODE (olddecl
) == VAR_DECL
&& DECL_ANON_UNION_VAR_P (olddecl
)))
2307 return "redeclaration of %q#D";
2308 /* If at least one declaration is a reference, there is no
2309 conflict. For example:
2315 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
2317 /* Reject two definitions. */
2318 return "redefinition of %q#D";
2322 /* Objects declared with block scope: */
2323 /* Reject two definitions, and reject a definition
2324 together with an external reference. */
2325 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
2326 return "redeclaration of %q#D";
2331 /* Hash and equality functions for the named_label table. */
2334 named_label_entry_hash (const void *data
)
2336 const struct named_label_entry
*ent
= (const struct named_label_entry
*) data
;
2337 return DECL_UID (ent
->label_decl
);
2341 named_label_entry_eq (const void *a
, const void *b
)
2343 const struct named_label_entry
*ent_a
= (const struct named_label_entry
*) a
;
2344 const struct named_label_entry
*ent_b
= (const struct named_label_entry
*) b
;
2345 return ent_a
->label_decl
== ent_b
->label_decl
;
2348 /* Create a new label, named ID. */
2351 make_label_decl (tree id
, int local_p
)
2353 struct named_label_entry
*ent
;
2357 decl
= build_decl (LABEL_DECL
, id
, void_type_node
);
2359 DECL_CONTEXT (decl
) = current_function_decl
;
2360 DECL_MODE (decl
) = VOIDmode
;
2361 C_DECLARED_LABEL_FLAG (decl
) = local_p
;
2363 /* Say where one reference is to the label, for the sake of the
2364 error if it is not defined. */
2365 DECL_SOURCE_LOCATION (decl
) = input_location
;
2367 /* Record the fact that this identifier is bound to this label. */
2368 SET_IDENTIFIER_LABEL_VALUE (id
, decl
);
2370 /* Create the label htab for the function on demand. */
2372 named_labels
= htab_create_ggc (13, named_label_entry_hash
,
2373 named_label_entry_eq
, NULL
);
2375 /* Record this label on the list of labels used in this function.
2376 We do this before calling make_label_decl so that we get the
2377 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2378 ent
= GGC_CNEW (struct named_label_entry
);
2379 ent
->label_decl
= decl
;
2381 slot
= htab_find_slot (named_labels
, ent
, INSERT
);
2382 gcc_assert (*slot
== NULL
);
2388 /* Look for a label named ID in the current function. If one cannot
2389 be found, create one. (We keep track of used, but undefined,
2390 labels, and complain about them at the end of a function.) */
2393 lookup_label (tree id
)
2397 timevar_push (TV_NAME_LOOKUP
);
2398 /* You can't use labels at global scope. */
2399 if (current_function_decl
== NULL_TREE
)
2401 error ("label %qE referenced outside of any function", id
);
2402 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
2405 /* See if we've already got this label. */
2406 decl
= IDENTIFIER_LABEL_VALUE (id
);
2407 if (decl
!= NULL_TREE
&& DECL_CONTEXT (decl
) == current_function_decl
)
2408 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2410 decl
= make_label_decl (id
, /*local_p=*/0);
2411 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2414 /* Declare a local label named ID. */
2417 declare_local_label (tree id
)
2421 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2422 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2423 shadow
= tree_cons (IDENTIFIER_LABEL_VALUE (id
), NULL_TREE
,
2424 current_binding_level
->shadowed_labels
);
2425 current_binding_level
->shadowed_labels
= shadow
;
2427 decl
= make_label_decl (id
, /*local_p=*/1);
2428 TREE_VALUE (shadow
) = decl
;
2433 /* Returns nonzero if it is ill-formed to jump past the declaration of
2434 DECL. Returns 2 if it's also a real problem. */
2437 decl_jump_unsafe (tree decl
)
2439 if (TREE_CODE (decl
) != VAR_DECL
|| TREE_STATIC (decl
)
2440 || TREE_TYPE (decl
) == error_mark_node
)
2443 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
))
2444 || DECL_NONTRIVIALLY_INITIALIZED_P (decl
))
2447 if (pod_type_p (TREE_TYPE (decl
)))
2450 /* The POD stuff is just pedantry; why should it matter if the class
2451 contains a field of pointer to member type? */
2455 /* A subroutine of check_previous_goto_1 to identify a branch to the user. */
2458 identify_goto (tree decl
, const location_t
*locus
)
2461 permerror ("jump to label %qD", decl
);
2463 permerror ("jump to case label");
2465 permerror ("%H from here", locus
);
2468 /* Check that a single previously seen jump to a newly defined label
2469 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2470 the jump context; NAMES are the names in scope in LEVEL at the jump
2471 context; LOCUS is the source position of the jump or 0. Returns
2472 true if all is well. */
2475 check_previous_goto_1 (tree decl
, struct cp_binding_level
* level
, tree names
,
2476 bool exited_omp
, const location_t
*locus
)
2478 struct cp_binding_level
*b
;
2479 bool identified
= false, saw_eh
= false, saw_omp
= false;
2483 identify_goto (decl
, locus
);
2484 error (" exits OpenMP structured block");
2485 identified
= saw_omp
= true;
2488 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
2490 tree new_decls
, old_decls
= (b
== level
? names
: NULL_TREE
);
2492 for (new_decls
= b
->names
; new_decls
!= old_decls
;
2493 new_decls
= TREE_CHAIN (new_decls
))
2495 int problem
= decl_jump_unsafe (new_decls
);
2501 identify_goto (decl
, locus
);
2505 error (" crosses initialization of %q+#D", new_decls
);
2507 permerror (" enters scope of non-POD %q+#D", new_decls
);
2512 if ((b
->kind
== sk_try
|| b
->kind
== sk_catch
) && !saw_eh
)
2516 identify_goto (decl
, locus
);
2519 if (b
->kind
== sk_try
)
2520 error (" enters try block");
2522 error (" enters catch block");
2525 if (b
->kind
== sk_omp
&& !saw_omp
)
2529 identify_goto (decl
, locus
);
2532 error (" enters OpenMP structured block");
2541 check_previous_goto (tree decl
, struct named_label_use_entry
*use
)
2543 check_previous_goto_1 (decl
, use
->binding_level
,
2544 use
->names_in_scope
, use
->in_omp_scope
,
2545 &use
->o_goto_locus
);
2549 check_switch_goto (struct cp_binding_level
* level
)
2551 return check_previous_goto_1 (NULL_TREE
, level
, level
->names
, false, NULL
);
2554 /* Check that a new jump to a label DECL is OK. Called by
2555 finish_goto_stmt. */
2558 check_goto (tree decl
)
2560 struct named_label_entry
*ent
, dummy
;
2561 bool saw_catch
= false, identified
= false;
2564 /* We can't know where a computed goto is jumping.
2565 So we assume that it's OK. */
2566 if (TREE_CODE (decl
) != LABEL_DECL
)
2569 /* We didn't record any information about this label when we created it,
2570 and there's not much point since it's trivial to analyze as a return. */
2571 if (decl
== cdtor_label
)
2574 dummy
.label_decl
= decl
;
2575 ent
= (struct named_label_entry
*) htab_find (named_labels
, &dummy
);
2576 gcc_assert (ent
!= NULL
);
2578 /* If the label hasn't been defined yet, defer checking. */
2579 if (! DECL_INITIAL (decl
))
2581 struct named_label_use_entry
*new_use
;
2583 /* Don't bother creating another use if the last goto had the
2584 same data, and will therefore create the same set of errors. */
2586 && ent
->uses
->names_in_scope
== current_binding_level
->names
)
2589 new_use
= GGC_NEW (struct named_label_use_entry
);
2590 new_use
->binding_level
= current_binding_level
;
2591 new_use
->names_in_scope
= current_binding_level
->names
;
2592 new_use
->o_goto_locus
= input_location
;
2593 new_use
->in_omp_scope
= false;
2595 new_use
->next
= ent
->uses
;
2596 ent
->uses
= new_use
;
2600 if (ent
->in_try_scope
|| ent
->in_catch_scope
2601 || ent
->in_omp_scope
|| ent
->bad_decls
)
2603 permerror ("jump to label %q+D", decl
);
2604 permerror (" from here");
2608 for (bad
= ent
->bad_decls
; bad
; bad
= TREE_CHAIN (bad
))
2610 tree b
= TREE_VALUE (bad
);
2611 int u
= decl_jump_unsafe (b
);
2613 if (u
> 1 && DECL_ARTIFICIAL (b
))
2615 /* Can't skip init of __exception_info. */
2616 error ("%J enters catch block", b
);
2620 error (" skips initialization of %q+#D", b
);
2622 permerror (" enters scope of non-POD %q+#D", b
);
2625 if (ent
->in_try_scope
)
2626 error (" enters try block");
2627 else if (ent
->in_catch_scope
&& !saw_catch
)
2628 error (" enters catch block");
2630 if (ent
->in_omp_scope
)
2631 error (" enters OpenMP structured block");
2632 else if (flag_openmp
)
2634 struct cp_binding_level
*b
;
2635 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
2637 if (b
== ent
->binding_level
)
2639 if (b
->kind
== sk_omp
)
2643 permerror ("jump to label %q+D", decl
);
2644 permerror (" from here");
2647 error (" exits OpenMP structured block");
2654 /* Check that a return is ok wrt OpenMP structured blocks.
2655 Called by finish_return_stmt. Returns true if all is well. */
2658 check_omp_return (void)
2660 struct cp_binding_level
*b
;
2661 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
2662 if (b
->kind
== sk_omp
)
2664 error ("invalid exit from OpenMP structured block");
2670 /* Define a label, specifying the location in the source file.
2671 Return the LABEL_DECL node for the label. */
2674 define_label (location_t location
, tree name
)
2676 struct named_label_entry
*ent
, dummy
;
2677 struct cp_binding_level
*p
;
2680 timevar_push (TV_NAME_LOOKUP
);
2682 decl
= lookup_label (name
);
2684 dummy
.label_decl
= decl
;
2685 ent
= (struct named_label_entry
*) htab_find (named_labels
, &dummy
);
2686 gcc_assert (ent
!= NULL
);
2688 /* After labels, make any new cleanups in the function go into their
2689 own new (temporary) binding contour. */
2690 for (p
= current_binding_level
;
2691 p
->kind
!= sk_function_parms
;
2693 p
->more_cleanups_ok
= 0;
2695 if (name
== get_identifier ("wchar_t"))
2696 permerror ("label named wchar_t");
2698 if (DECL_INITIAL (decl
) != NULL_TREE
)
2700 error ("duplicate label %qD", decl
);
2701 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
2705 struct named_label_use_entry
*use
;
2707 /* Mark label as having been defined. */
2708 DECL_INITIAL (decl
) = error_mark_node
;
2709 /* Say where in the source. */
2710 DECL_SOURCE_LOCATION (decl
) = location
;
2712 ent
->binding_level
= current_binding_level
;
2713 ent
->names_in_scope
= current_binding_level
->names
;
2715 for (use
= ent
->uses
; use
; use
= use
->next
)
2716 check_previous_goto (decl
, use
);
2720 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2725 struct cp_binding_level
*level
;
2726 struct cp_switch
*next
;
2727 /* The SWITCH_STMT being built. */
2729 /* A splay-tree mapping the low element of a case range to the high
2730 element, or NULL_TREE if there is no high element. Used to
2731 determine whether or not a new case label duplicates an old case
2732 label. We need a tree, rather than simply a hash table, because
2733 of the GNU case range extension. */
2737 /* A stack of the currently active switch statements. The innermost
2738 switch statement is on the top of the stack. There is no need to
2739 mark the stack for garbage collection because it is only active
2740 during the processing of the body of a function, and we never
2741 collect at that point. */
2743 static struct cp_switch
*switch_stack
;
2745 /* Called right after a switch-statement condition is parsed.
2746 SWITCH_STMT is the switch statement being parsed. */
2749 push_switch (tree switch_stmt
)
2751 struct cp_switch
*p
= XNEW (struct cp_switch
);
2752 p
->level
= current_binding_level
;
2753 p
->next
= switch_stack
;
2754 p
->switch_stmt
= switch_stmt
;
2755 p
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
2762 struct cp_switch
*cs
= switch_stack
;
2763 location_t switch_location
;
2765 /* Emit warnings as needed. */
2766 if (EXPR_HAS_LOCATION (cs
->switch_stmt
))
2767 switch_location
= EXPR_LOCATION (cs
->switch_stmt
);
2769 switch_location
= input_location
;
2770 if (!processing_template_decl
)
2771 c_do_switch_warnings (cs
->cases
, switch_location
,
2772 SWITCH_STMT_TYPE (cs
->switch_stmt
),
2773 SWITCH_STMT_COND (cs
->switch_stmt
));
2775 splay_tree_delete (cs
->cases
);
2776 switch_stack
= switch_stack
->next
;
2780 /* Note that we've seen a definition of a case label, and complain if this
2781 is a bad place for one. */
2784 finish_case_label (tree low_value
, tree high_value
)
2787 struct cp_binding_level
*p
;
2789 if (processing_template_decl
)
2793 /* For templates, just add the case label; we'll do semantic
2794 analysis at instantiation-time. */
2795 label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
2796 return add_stmt (build_case_label (low_value
, high_value
, label
));
2799 /* Find the condition on which this switch statement depends. */
2800 cond
= SWITCH_STMT_COND (switch_stack
->switch_stmt
);
2801 if (cond
&& TREE_CODE (cond
) == TREE_LIST
)
2802 cond
= TREE_VALUE (cond
);
2804 if (!check_switch_goto (switch_stack
->level
))
2805 return error_mark_node
;
2807 r
= c_add_case_label (switch_stack
->cases
, cond
, TREE_TYPE (cond
),
2808 low_value
, high_value
);
2810 /* After labels, make any new cleanups in the function go into their
2811 own new (temporary) binding contour. */
2812 for (p
= current_binding_level
;
2813 p
->kind
!= sk_function_parms
;
2815 p
->more_cleanups_ok
= 0;
2820 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
2823 typename_hash (const void* k
)
2826 const_tree
const t
= (const_tree
) k
;
2828 hash
= (htab_hash_pointer (TYPE_CONTEXT (t
))
2829 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t
))));
2834 typedef struct typename_info
{
2842 /* Compare two TYPENAME_TYPEs. K1 is really of type `tree', K2 is
2843 really of type `typename_info*' */
2846 typename_compare (const void * k1
, const void * k2
)
2848 const_tree
const t1
= (const_tree
) k1
;
2849 const typename_info
*const t2
= (const typename_info
*) k2
;
2851 return (DECL_NAME (TYPE_NAME (t1
)) == t2
->name
2852 && TYPE_CONTEXT (t1
) == t2
->scope
2853 && TYPENAME_TYPE_FULLNAME (t1
) == t2
->template_id
2854 && TYPENAME_IS_ENUM_P (t1
) == t2
->enum_p
2855 && TYPENAME_IS_CLASS_P (t1
) == t2
->class_p
);
2858 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
2859 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
2861 Returns the new TYPENAME_TYPE. */
2863 static GTY ((param_is (union tree_node
))) htab_t typename_htab
;
2866 build_typename_type (tree context
, tree name
, tree fullname
,
2867 enum tag_types tag_type
)
2875 if (typename_htab
== NULL
)
2876 typename_htab
= htab_create_ggc (61, &typename_hash
,
2877 &typename_compare
, NULL
);
2879 ti
.scope
= FROB_CONTEXT (context
);
2881 ti
.template_id
= fullname
;
2882 ti
.enum_p
= tag_type
== enum_type
;
2883 ti
.class_p
= (tag_type
== class_type
2884 || tag_type
== record_type
2885 || tag_type
== union_type
);
2886 hash
= (htab_hash_pointer (ti
.scope
)
2887 ^ htab_hash_pointer (ti
.name
));
2889 /* See if we already have this type. */
2890 e
= htab_find_slot_with_hash (typename_htab
, &ti
, hash
, INSERT
);
2895 /* Build the TYPENAME_TYPE. */
2896 t
= cxx_make_type (TYPENAME_TYPE
);
2897 TYPE_CONTEXT (t
) = ti
.scope
;
2898 TYPENAME_TYPE_FULLNAME (t
) = ti
.template_id
;
2899 TYPENAME_IS_ENUM_P (t
) = ti
.enum_p
;
2900 TYPENAME_IS_CLASS_P (t
) = ti
.class_p
;
2902 /* Build the corresponding TYPE_DECL. */
2903 d
= build_decl (TYPE_DECL
, name
, t
);
2904 TYPE_NAME (TREE_TYPE (d
)) = d
;
2905 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
2906 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
2907 DECL_ARTIFICIAL (d
) = 1;
2909 /* Store it in the hash table. */
2912 /* TYPENAME_TYPEs must always be compared structurally, because
2913 they may or may not resolve down to another type depending on
2914 the currently open classes. */
2915 SET_TYPE_STRUCTURAL_EQUALITY (t
);
2921 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
2922 provided to name the type. Returns an appropriate type, unless an
2923 error occurs, in which case error_mark_node is returned. If we
2924 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
2925 return that, rather than the _TYPE it corresponds to, in other
2926 cases we look through the type decl. If TF_ERROR is set, complain
2927 about errors, otherwise be quiet. */
2930 make_typename_type (tree context
, tree name
, enum tag_types tag_type
,
2931 tsubst_flags_t complain
)
2937 if (name
== error_mark_node
2938 || context
== NULL_TREE
2939 || context
== error_mark_node
)
2940 return error_mark_node
;
2944 if (!(TYPE_LANG_SPECIFIC (name
)
2945 && (CLASSTYPE_IS_TEMPLATE (name
)
2946 || CLASSTYPE_USE_TEMPLATE (name
))))
2947 name
= TYPE_IDENTIFIER (name
);
2949 /* Create a TEMPLATE_ID_EXPR for the type. */
2950 name
= build_nt (TEMPLATE_ID_EXPR
,
2951 CLASSTYPE_TI_TEMPLATE (name
),
2952 CLASSTYPE_TI_ARGS (name
));
2954 else if (TREE_CODE (name
) == TYPE_DECL
)
2955 name
= DECL_NAME (name
);
2959 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
2961 name
= TREE_OPERAND (name
, 0);
2962 if (TREE_CODE (name
) == TEMPLATE_DECL
)
2963 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
2964 else if (TREE_CODE (name
) == OVERLOAD
)
2966 error ("%qD is not a type", name
);
2967 return error_mark_node
;
2970 if (TREE_CODE (name
) == TEMPLATE_DECL
)
2972 error ("%qD used without template parameters", name
);
2973 return error_mark_node
;
2975 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
2976 gcc_assert (TYPE_P (context
));
2978 /* When the CONTEXT is a dependent type, NAME could refer to a
2979 dependent base class of CONTEXT. So we cannot peek inside it,
2980 even if CONTEXT is a currently open scope. */
2981 if (dependent_type_p (context
))
2982 return build_typename_type (context
, name
, fullname
, tag_type
);
2984 if (!MAYBE_CLASS_TYPE_P (context
))
2986 if (complain
& tf_error
)
2987 error ("%q#T is not a class", context
);
2988 return error_mark_node
;
2991 want_template
= TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
;
2993 /* We should only set WANT_TYPE when we're a nested typename type.
2994 Then we can give better diagnostics if we find a non-type. */
2995 t
= lookup_field (context
, name
, 0, /*want_type=*/true);
2998 if (complain
& tf_error
)
2999 error (want_template
? "no class template named %q#T in %q#T"
3000 : "no type named %q#T in %q#T", name
, context
);
3001 return error_mark_node
;
3004 if (want_template
&& !DECL_CLASS_TEMPLATE_P (t
))
3006 if (complain
& tf_error
)
3007 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3009 return error_mark_node
;
3011 if (!want_template
&& TREE_CODE (t
) != TYPE_DECL
)
3013 if (complain
& tf_error
)
3014 error ("%<typename %T::%D%> names %q#T, which is not a type",
3016 return error_mark_node
;
3019 if (complain
& tf_error
)
3020 perform_or_defer_access_check (TYPE_BINFO (context
), t
, t
);
3023 return lookup_template_class (t
, TREE_OPERAND (fullname
, 1),
3025 /*entering_scope=*/0,
3026 tf_warning_or_error
| tf_user
);
3028 if (DECL_ARTIFICIAL (t
) || !(complain
& tf_keep_type_decl
))
3034 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3035 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3036 in which case error_mark_node is returned.
3038 If PARM_LIST is non-NULL, also make sure that the template parameter
3039 list of TEMPLATE_DECL matches.
3041 If COMPLAIN zero, don't complain about any errors that occur. */
3044 make_unbound_class_template (tree context
, tree name
, tree parm_list
,
3045 tsubst_flags_t complain
)
3051 name
= TYPE_IDENTIFIER (name
);
3052 else if (DECL_P (name
))
3053 name
= DECL_NAME (name
);
3054 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
3056 if (!dependent_type_p (context
)
3057 || currently_open_class (context
))
3059 tree tmpl
= NULL_TREE
;
3061 if (MAYBE_CLASS_TYPE_P (context
))
3062 tmpl
= lookup_field (context
, name
, 0, false);
3064 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
3066 if (complain
& tf_error
)
3067 error ("no class template named %q#T in %q#T", name
, context
);
3068 return error_mark_node
;
3072 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl
), parm_list
))
3074 if (complain
& tf_error
)
3076 error ("template parameters do not match template");
3077 error ("%q+D declared here", tmpl
);
3079 return error_mark_node
;
3082 if (complain
& tf_error
)
3083 perform_or_defer_access_check (TYPE_BINFO (context
), tmpl
, tmpl
);
3088 /* Build the UNBOUND_CLASS_TEMPLATE. */
3089 t
= cxx_make_type (UNBOUND_CLASS_TEMPLATE
);
3090 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
3091 TREE_TYPE (t
) = NULL_TREE
;
3092 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3094 /* Build the corresponding TEMPLATE_DECL. */
3095 d
= build_decl (TEMPLATE_DECL
, name
, t
);
3096 TYPE_NAME (TREE_TYPE (d
)) = d
;
3097 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3098 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3099 DECL_ARTIFICIAL (d
) = 1;
3100 DECL_TEMPLATE_PARMS (d
) = parm_list
;
3107 /* Push the declarations of builtin types into the namespace.
3108 RID_INDEX is the index of the builtin type in the array
3109 RID_POINTERS. NAME is the name used when looking up the builtin
3110 type. TYPE is the _TYPE node for the builtin type. */
3113 record_builtin_type (enum rid rid_index
,
3117 tree rname
= NULL_TREE
, tname
= NULL_TREE
;
3118 tree tdecl
= NULL_TREE
;
3120 if ((int) rid_index
< (int) RID_MAX
)
3121 rname
= ridpointers
[(int) rid_index
];
3123 tname
= get_identifier (name
);
3125 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
3126 eliminated. Built-in types should not be looked up name; their
3127 names are keywords that the parser can recognize. However, there
3128 is code in c-common.c that uses identifier_global_value to look
3129 up built-in types by name. */
3132 tdecl
= build_decl (TYPE_DECL
, tname
, type
);
3133 DECL_ARTIFICIAL (tdecl
) = 1;
3134 SET_IDENTIFIER_GLOBAL_VALUE (tname
, tdecl
);
3140 tdecl
= build_decl (TYPE_DECL
, rname
, type
);
3141 DECL_ARTIFICIAL (tdecl
) = 1;
3143 SET_IDENTIFIER_GLOBAL_VALUE (rname
, tdecl
);
3146 if (!TYPE_NAME (type
))
3147 TYPE_NAME (type
) = tdecl
;
3150 debug_hooks
->type_decl (tdecl
, 0);
3153 /* Record one of the standard Java types.
3154 * Declare it as having the given NAME.
3155 * If SIZE > 0, it is the size of one of the integral types;
3156 * otherwise it is the negative of the size of one of the other types. */
3159 record_builtin_java_type (const char* name
, int size
)
3163 type
= make_signed_type (size
);
3164 else if (size
> -32)
3165 { /* "__java_char" or ""__java_boolean". */
3166 type
= make_unsigned_type (-size
);
3167 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
3170 { /* "__java_float" or ""__java_double". */
3171 type
= make_node (REAL_TYPE
);
3172 TYPE_PRECISION (type
) = - size
;
3175 record_builtin_type (RID_MAX
, name
, type
);
3176 decl
= TYPE_NAME (type
);
3178 /* Suppress generate debug symbol entries for these types,
3179 since for normal C++ they are just clutter.
3180 However, push_lang_context undoes this if extern "Java" is seen. */
3181 DECL_IGNORED_P (decl
) = 1;
3183 TYPE_FOR_JAVA (type
) = 1;
3187 /* Push a type into the namespace so that the back ends ignore it. */
3190 record_unknown_type (tree type
, const char* name
)
3192 tree decl
= pushdecl (build_decl (TYPE_DECL
, get_identifier (name
), type
));
3193 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3194 DECL_IGNORED_P (decl
) = 1;
3195 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
3196 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
3197 TYPE_ALIGN (type
) = 1;
3198 TYPE_USER_ALIGN (type
) = 0;
3199 TYPE_MODE (type
) = TYPE_MODE (void_type_node
);
3202 /* A string for which we should create an IDENTIFIER_NODE at
3205 typedef struct predefined_identifier
3207 /* The name of the identifier. */
3208 const char *const name
;
3209 /* The place where the IDENTIFIER_NODE should be stored. */
3211 /* Nonzero if this is the name of a constructor or destructor. */
3212 const int ctor_or_dtor_p
;
3213 } predefined_identifier
;
3215 /* Create all the predefined identifiers. */
3218 initialize_predefined_identifiers (void)
3220 const predefined_identifier
*pid
;
3222 /* A table of identifiers to create at startup. */
3223 static const predefined_identifier predefined_identifiers
[] = {
3224 { "C++", &lang_name_cplusplus
, 0 },
3225 { "C", &lang_name_c
, 0 },
3226 { "Java", &lang_name_java
, 0 },
3227 /* Some of these names have a trailing space so that it is
3228 impossible for them to conflict with names written by users. */
3229 { "__ct ", &ctor_identifier
, 1 },
3230 { "__base_ctor ", &base_ctor_identifier
, 1 },
3231 { "__comp_ctor ", &complete_ctor_identifier
, 1 },
3232 { "__dt ", &dtor_identifier
, 1 },
3233 { "__comp_dtor ", &complete_dtor_identifier
, 1 },
3234 { "__base_dtor ", &base_dtor_identifier
, 1 },
3235 { "__deleting_dtor ", &deleting_dtor_identifier
, 1 },
3236 { IN_CHARGE_NAME
, &in_charge_identifier
, 0 },
3237 { "nelts", &nelts_identifier
, 0 },
3238 { THIS_NAME
, &this_identifier
, 0 },
3239 { VTABLE_DELTA_NAME
, &delta_identifier
, 0 },
3240 { VTABLE_PFN_NAME
, &pfn_identifier
, 0 },
3241 { "_vptr", &vptr_identifier
, 0 },
3242 { "__vtt_parm", &vtt_parm_identifier
, 0 },
3243 { "::", &global_scope_name
, 0 },
3244 { "std", &std_identifier
, 0 },
3248 for (pid
= predefined_identifiers
; pid
->name
; ++pid
)
3250 *pid
->node
= get_identifier (pid
->name
);
3251 if (pid
->ctor_or_dtor_p
)
3252 IDENTIFIER_CTOR_OR_DTOR_P (*pid
->node
) = 1;
3256 /* Create the predefined scalar types of C,
3257 and some nodes representing standard constants (0, 1, (void *)0).
3258 Initialize the global binding level.
3259 Make definitions for built-in primitive functions. */
3262 cxx_init_decl_processing (void)
3265 tree void_ftype_ptr
;
3267 build_common_tree_nodes (flag_signed_char
, false);
3269 /* Create all the identifiers we need. */
3270 initialize_predefined_identifiers ();
3272 /* Create the global variables. */
3273 push_to_top_level ();
3275 current_function_decl
= NULL_TREE
;
3276 current_binding_level
= NULL
;
3277 /* Enter the global namespace. */
3278 gcc_assert (global_namespace
== NULL_TREE
);
3279 global_namespace
= build_lang_decl (NAMESPACE_DECL
, global_scope_name
,
3281 TREE_PUBLIC (global_namespace
) = 1;
3282 begin_scope (sk_namespace
, global_namespace
);
3284 current_lang_name
= NULL_TREE
;
3286 if (flag_visibility_ms_compat
)
3287 default_visibility
= VISIBILITY_HIDDEN
;
3290 current_lang_name
= lang_name_c
;
3292 /* Create the `std' namespace. */
3293 push_namespace (std_identifier
);
3294 std_node
= current_namespace
;
3297 c_common_nodes_and_builtins ();
3299 java_byte_type_node
= record_builtin_java_type ("__java_byte", 8);
3300 java_short_type_node
= record_builtin_java_type ("__java_short", 16);
3301 java_int_type_node
= record_builtin_java_type ("__java_int", 32);
3302 java_long_type_node
= record_builtin_java_type ("__java_long", 64);
3303 java_float_type_node
= record_builtin_java_type ("__java_float", -32);
3304 java_double_type_node
= record_builtin_java_type ("__java_double", -64);
3305 java_char_type_node
= record_builtin_java_type ("__java_char", -16);
3306 java_boolean_type_node
= record_builtin_java_type ("__java_boolean", -1);
3308 integer_two_node
= build_int_cst (NULL_TREE
, 2);
3309 integer_three_node
= build_int_cst (NULL_TREE
, 3);
3311 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
3312 truthvalue_type_node
= boolean_type_node
;
3313 truthvalue_false_node
= boolean_false_node
;
3314 truthvalue_true_node
= boolean_true_node
;
3316 empty_except_spec
= build_tree_list (NULL_TREE
, NULL_TREE
);
3319 record_builtin_type (RID_MAX
, NULL
, string_type_node
);
3322 delta_type_node
= ptrdiff_type_node
;
3323 vtable_index_type
= ptrdiff_type_node
;
3325 vtt_parm_type
= build_pointer_type (const_ptr_type_node
);
3326 void_ftype
= build_function_type (void_type_node
, void_list_node
);
3327 void_ftype_ptr
= build_function_type (void_type_node
,
3328 tree_cons (NULL_TREE
,
3332 = build_exception_variant (void_ftype_ptr
, empty_except_spec
);
3334 /* C++ extensions */
3336 unknown_type_node
= make_node (UNKNOWN_TYPE
);
3337 record_unknown_type (unknown_type_node
, "unknown type");
3339 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3340 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
3342 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3344 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
3345 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
3347 init_list_type_node
= make_node (UNKNOWN_TYPE
);
3348 record_unknown_type (init_list_type_node
, "init list");
3351 /* Make sure we get a unique function type, so we can give
3352 its pointer type a name. (This wins for gdb.) */
3353 tree vfunc_type
= make_node (FUNCTION_TYPE
);
3354 TREE_TYPE (vfunc_type
) = integer_type_node
;
3355 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
3356 layout_type (vfunc_type
);
3358 vtable_entry_type
= build_pointer_type (vfunc_type
);
3360 record_builtin_type (RID_MAX
, VTBL_PTR_TYPE
, vtable_entry_type
);
3363 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
3364 layout_type (vtbl_type_node
);
3365 vtbl_type_node
= build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
3366 record_builtin_type (RID_MAX
, NULL
, vtbl_type_node
);
3367 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
3368 layout_type (vtbl_ptr_type_node
);
3369 record_builtin_type (RID_MAX
, NULL
, vtbl_ptr_type_node
);
3371 push_namespace (get_identifier ("__cxxabiv1"));
3372 abi_node
= current_namespace
;
3375 global_type_node
= make_node (LANG_TYPE
);
3376 record_unknown_type (global_type_node
, "global type");
3379 current_lang_name
= lang_name_cplusplus
;
3383 tree bad_alloc_type_node
;
3384 tree bad_alloc_decl
;
3385 tree newtype
, deltype
;
3386 tree ptr_ftype_sizetype
;
3388 push_namespace (std_identifier
);
3389 bad_alloc_id
= get_identifier ("bad_alloc");
3390 bad_alloc_type_node
= make_class_type (RECORD_TYPE
);
3391 TYPE_CONTEXT (bad_alloc_type_node
) = current_namespace
;
3393 = create_implicit_typedef (bad_alloc_id
, bad_alloc_type_node
);
3394 DECL_CONTEXT (bad_alloc_decl
) = current_namespace
;
3395 TYPE_STUB_DECL (bad_alloc_type_node
) = bad_alloc_decl
;
3399 = build_function_type (ptr_type_node
,
3400 tree_cons (NULL_TREE
,
3403 newtype
= build_exception_variant
3404 (ptr_ftype_sizetype
, add_exception_specifier
3405 (NULL_TREE
, bad_alloc_type_node
, -1));
3406 deltype
= build_exception_variant (void_ftype_ptr
, empty_except_spec
);
3407 push_cp_library_fn (NEW_EXPR
, newtype
);
3408 push_cp_library_fn (VEC_NEW_EXPR
, newtype
);
3409 global_delete_fndecl
= push_cp_library_fn (DELETE_EXPR
, deltype
);
3410 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
);
3414 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype
);
3416 /* Perform other language dependent initializations. */
3417 init_class_processing ();
3418 init_rtti_processing ();
3420 if (flag_exceptions
)
3421 init_exception_processing ();
3423 if (! supports_one_only ())
3426 make_fname_decl
= cp_make_fname_decl
;
3427 start_fname_decls ();
3429 /* Show we use EH for cleanups. */
3430 if (flag_exceptions
)
3431 using_eh_for_cleanups ();
3434 /* Generate an initializer for a function naming variable from
3435 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3436 filled in with the type of the init. */
3439 cp_fname_init (const char* name
, tree
*type_p
)
3441 tree domain
= NULL_TREE
;
3443 tree init
= NULL_TREE
;
3448 length
= strlen (name
);
3449 domain
= build_index_type (size_int (length
));
3450 init
= build_string (length
+ 1, name
);
3453 type
= build_qualified_type (char_type_node
, TYPE_QUAL_CONST
);
3454 type
= build_cplus_array_type (type
, domain
);
3459 TREE_TYPE (init
) = type
;
3461 init
= error_mark_node
;
3466 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
3467 decl, NAME is the initialization string and TYPE_DEP indicates whether
3468 NAME depended on the type of the function. We make use of that to detect
3469 __PRETTY_FUNCTION__ inside a template fn. This is being done
3470 lazily at the point of first use, so we mustn't push the decl now. */
3473 cp_make_fname_decl (tree id
, int type_dep
)
3475 const char *const name
= (type_dep
&& processing_template_decl
3476 ? NULL
: fname_as_string (type_dep
));
3478 tree init
= cp_fname_init (name
, &type
);
3479 tree decl
= build_decl (VAR_DECL
, id
, type
);
3482 free (CONST_CAST (char *, name
));
3484 /* As we're using pushdecl_with_scope, we must set the context. */
3485 DECL_CONTEXT (decl
) = current_function_decl
;
3486 DECL_PRETTY_FUNCTION_P (decl
) = type_dep
;
3488 TREE_STATIC (decl
) = 1;
3489 TREE_READONLY (decl
) = 1;
3490 DECL_ARTIFICIAL (decl
) = 1;
3492 TREE_USED (decl
) = 1;
3494 if (current_function_decl
)
3496 struct cp_binding_level
*b
= current_binding_level
;
3497 while (b
->level_chain
->kind
!= sk_function_parms
)
3499 pushdecl_with_scope (decl
, b
, /*is_friend=*/false);
3500 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, NULL_TREE
,
3501 LOOKUP_ONLYCONVERTING
);
3504 pushdecl_top_level_and_finish (decl
, init
);
3510 builtin_function_1 (tree decl
, tree context
)
3512 tree id
= DECL_NAME (decl
);
3513 const char *name
= IDENTIFIER_POINTER (id
);
3515 retrofit_lang_decl (decl
);
3517 /* All nesting of C++ functions is lexical; there is never a "static
3518 chain" in the sense of GNU C nested functions. */
3519 DECL_NO_STATIC_CHAIN (decl
) = 1;
3521 DECL_ARTIFICIAL (decl
) = 1;
3522 SET_OVERLOADED_OPERATOR_CODE (decl
, ERROR_MARK
);
3523 SET_DECL_LANGUAGE (decl
, lang_c
);
3524 /* Runtime library routines are, by definition, available in an
3525 external shared object. */
3526 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
3527 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
3529 DECL_CONTEXT (decl
) = context
;
3533 /* A function in the user's namespace should have an explicit
3534 declaration before it is used. Mark the built-in function as
3535 anticipated but not actually declared. */
3536 if (name
[0] != '_' || name
[1] != '_')
3537 DECL_ANTICIPATED (decl
) = 1;
3538 else if (strncmp (name
+ 2, "builtin_", strlen ("builtin_")) != 0)
3540 size_t len
= strlen (name
);
3542 /* Treat __*_chk fortification functions as anticipated as well,
3543 unless they are __builtin_*. */
3544 if (len
> strlen ("___chk")
3545 && memcmp (name
+ len
- strlen ("_chk"),
3546 "_chk", strlen ("_chk") + 1) == 0)
3547 DECL_ANTICIPATED (decl
) = 1;
3554 cxx_builtin_function (tree decl
)
3556 tree id
= DECL_NAME (decl
);
3557 const char *name
= IDENTIFIER_POINTER (id
);
3558 /* All builtins that don't begin with an '_' should additionally
3559 go in the 'std' namespace. */
3562 tree decl2
= copy_node(decl
);
3563 push_namespace (std_identifier
);
3564 builtin_function_1 (decl2
, std_node
);
3568 return builtin_function_1 (decl
, NULL_TREE
);
3571 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
3572 function. Not called directly. */
3575 build_library_fn_1 (tree name
, enum tree_code operator_code
, tree type
)
3577 tree fn
= build_lang_decl (FUNCTION_DECL
, name
, type
);
3578 DECL_EXTERNAL (fn
) = 1;
3579 TREE_PUBLIC (fn
) = 1;
3580 DECL_ARTIFICIAL (fn
) = 1;
3581 SET_OVERLOADED_OPERATOR_CODE (fn
, operator_code
);
3582 SET_DECL_LANGUAGE (fn
, lang_c
);
3583 /* Runtime library routines are, by definition, available in an
3584 external shared object. */
3585 DECL_VISIBILITY (fn
) = VISIBILITY_DEFAULT
;
3586 DECL_VISIBILITY_SPECIFIED (fn
) = 1;
3590 /* Returns the _DECL for a library function with C linkage.
3591 We assume that such functions never throw; if this is incorrect,
3592 callers should unset TREE_NOTHROW. */
3595 build_library_fn (tree name
, tree type
)
3597 tree fn
= build_library_fn_1 (name
, ERROR_MARK
, type
);
3598 TREE_NOTHROW (fn
) = 1;
3602 /* Returns the _DECL for a library function with C++ linkage. */
3605 build_cp_library_fn (tree name
, enum tree_code operator_code
, tree type
)
3607 tree fn
= build_library_fn_1 (name
, operator_code
, type
);
3608 TREE_NOTHROW (fn
) = TYPE_NOTHROW_P (type
);
3609 DECL_CONTEXT (fn
) = FROB_CONTEXT (current_namespace
);
3610 SET_DECL_LANGUAGE (fn
, lang_cplusplus
);
3614 /* Like build_library_fn, but takes a C string instead of an
3618 build_library_fn_ptr (const char* name
, tree type
)
3620 return build_library_fn (get_identifier (name
), type
);
3623 /* Like build_cp_library_fn, but takes a C string instead of an
3627 build_cp_library_fn_ptr (const char* name
, tree type
)
3629 return build_cp_library_fn (get_identifier (name
), ERROR_MARK
, type
);
3632 /* Like build_library_fn, but also pushes the function so that we will
3633 be able to find it via IDENTIFIER_GLOBAL_VALUE. */
3636 push_library_fn (tree name
, tree type
)
3638 tree fn
= build_library_fn (name
, type
);
3639 pushdecl_top_level (fn
);
3643 /* Like build_cp_library_fn, but also pushes the function so that it
3644 will be found by normal lookup. */
3647 push_cp_library_fn (enum tree_code operator_code
, tree type
)
3649 tree fn
= build_cp_library_fn (ansi_opname (operator_code
),
3656 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
3660 push_void_library_fn (tree name
, tree parmtypes
)
3662 tree type
= build_function_type (void_type_node
, parmtypes
);
3663 return push_library_fn (name
, type
);
3666 /* Like push_library_fn, but also note that this function throws
3667 and does not return. Used for __throw_foo and the like. */
3670 push_throw_library_fn (tree name
, tree type
)
3672 tree fn
= push_library_fn (name
, type
);
3673 TREE_THIS_VOLATILE (fn
) = 1;
3674 TREE_NOTHROW (fn
) = 0;
3678 /* When we call finish_struct for an anonymous union, we create
3679 default copy constructors and such. But, an anonymous union
3680 shouldn't have such things; this function undoes the damage to the
3681 anonymous union type T.
3683 (The reason that we create the synthesized methods is that we don't
3684 distinguish `union { int i; }' from `typedef union { int i; } U'.
3685 The first is an anonymous union; the second is just an ordinary
3689 fixup_anonymous_aggr (tree t
)
3693 /* Wipe out memory of synthesized methods. */
3694 TYPE_HAS_USER_CONSTRUCTOR (t
) = 0;
3695 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
3696 TYPE_HAS_INIT_REF (t
) = 0;
3697 TYPE_HAS_CONST_INIT_REF (t
) = 0;
3698 TYPE_HAS_ASSIGN_REF (t
) = 0;
3699 TYPE_HAS_CONST_ASSIGN_REF (t
) = 0;
3701 /* Splice the implicitly generated functions out of the TYPE_METHODS
3703 q
= &TYPE_METHODS (t
);
3706 if (DECL_ARTIFICIAL (*q
))
3707 *q
= TREE_CHAIN (*q
);
3709 q
= &TREE_CHAIN (*q
);
3712 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
3713 if (TYPE_METHODS (t
))
3715 tree decl
= TYPE_MAIN_DECL (t
);
3717 if (TREE_CODE (t
) != UNION_TYPE
)
3718 error ("%Jan anonymous struct cannot have function members", decl
);
3720 error ("%Jan anonymous union cannot have function members", decl
);
3723 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
3724 assignment operators (because they cannot have these methods themselves).
3725 For anonymous unions this is already checked because they are not allowed
3726 in any union, otherwise we have to check it. */
3727 if (TREE_CODE (t
) != UNION_TYPE
)
3731 for (field
= TYPE_FIELDS (t
); field
; field
= TREE_CHAIN (field
))
3732 if (TREE_CODE (field
) == FIELD_DECL
)
3734 type
= TREE_TYPE (field
);
3735 if (CLASS_TYPE_P (type
))
3737 if (TYPE_NEEDS_CONSTRUCTING (type
))
3738 error ("member %q+#D with constructor not allowed "
3739 "in anonymous aggregate", field
);
3740 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
3741 error ("member %q+#D with destructor not allowed "
3742 "in anonymous aggregate", field
);
3743 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type
))
3744 error ("member %q+#D with copy assignment operator "
3745 "not allowed in anonymous aggregate", field
);
3751 /* Make sure that a declaration with no declarator is well-formed, i.e.
3752 just declares a tagged type or anonymous union.
3754 Returns the type declared; or NULL_TREE if none. */
3757 check_tag_decl (cp_decl_specifier_seq
*declspecs
)
3759 int saw_friend
= declspecs
->specs
[(int)ds_friend
] != 0;
3760 int saw_typedef
= declspecs
->specs
[(int)ds_typedef
] != 0;
3761 /* If a class, struct, or enum type is declared by the DECLSPECS
3762 (i.e, if a class-specifier, enum-specifier, or non-typename
3763 elaborated-type-specifier appears in the DECLSPECS),
3764 DECLARED_TYPE is set to the corresponding type. */
3765 tree declared_type
= NULL_TREE
;
3766 bool error_p
= false;
3768 if (declspecs
->multiple_types_p
)
3769 error ("multiple types in one declaration");
3770 else if (declspecs
->redefined_builtin_type
)
3772 if (!in_system_header
)
3773 permerror ("redeclaration of C++ built-in type %qT",
3774 declspecs
->redefined_builtin_type
);
3779 && TYPE_P (declspecs
->type
)
3780 && ((TREE_CODE (declspecs
->type
) != TYPENAME_TYPE
3781 && MAYBE_CLASS_TYPE_P (declspecs
->type
))
3782 || TREE_CODE (declspecs
->type
) == ENUMERAL_TYPE
))
3783 declared_type
= declspecs
->type
;
3784 else if (declspecs
->type
== error_mark_node
)
3786 if (declared_type
== NULL_TREE
&& ! saw_friend
&& !error_p
)
3787 permerror ("declaration does not declare anything");
3788 /* Check for an anonymous union. */
3789 else if (declared_type
&& RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type
))
3790 && TYPE_ANONYMOUS_P (declared_type
))
3792 /* 7/3 In a simple-declaration, the optional init-declarator-list
3793 can be omitted only when declaring a class (clause 9) or
3794 enumeration (7.2), that is, when the decl-specifier-seq contains
3795 either a class-specifier, an elaborated-type-specifier with
3796 a class-key (9.1), or an enum-specifier. In these cases and
3797 whenever a class-specifier or enum-specifier is present in the
3798 decl-specifier-seq, the identifiers in these specifiers are among
3799 the names being declared by the declaration (as class-name,
3800 enum-names, or enumerators, depending on the syntax). In such
3801 cases, and except for the declaration of an unnamed bit-field (9.6),
3802 the decl-specifier-seq shall introduce one or more names into the
3803 program, or shall redeclare a name introduced by a previous
3804 declaration. [Example:
3805 enum { }; // ill-formed
3806 typedef class { }; // ill-formed
3810 error ("missing type-name in typedef-declaration");
3813 /* Anonymous unions are objects, so they can have specifiers. */;
3814 SET_ANON_AGGR_TYPE_P (declared_type
);
3816 if (TREE_CODE (declared_type
) != UNION_TYPE
&& pedantic
3817 && !in_system_header
)
3818 pedwarn ("ISO C++ prohibits anonymous structs");
3823 if (declspecs
->specs
[(int)ds_inline
]
3824 || declspecs
->specs
[(int)ds_virtual
])
3825 error ("%qs can only be specified for functions",
3826 declspecs
->specs
[(int)ds_inline
]
3827 ? "inline" : "virtual");
3829 && (!current_class_type
3830 || current_scope () != current_class_type
))
3831 error ("%<friend%> can only be specified inside a class");
3832 else if (declspecs
->specs
[(int)ds_explicit
])
3833 error ("%<explicit%> can only be specified for constructors");
3834 else if (declspecs
->storage_class
)
3835 error ("a storage class can only be specified for objects "
3837 else if (declspecs
->specs
[(int)ds_const
]
3838 || declspecs
->specs
[(int)ds_volatile
]
3839 || declspecs
->specs
[(int)ds_restrict
]
3840 || declspecs
->specs
[(int)ds_thread
])
3841 error ("qualifiers can only be specified for objects "
3843 else if (saw_typedef
)
3844 warning (0, "%<typedef%> was ignored in this declaration");
3847 return declared_type
;
3850 /* Called when a declaration is seen that contains no names to declare.
3851 If its type is a reference to a structure, union or enum inherited
3852 from a containing scope, shadow that tag name for the current scope
3853 with a forward reference.
3854 If its type defines a new named structure or union
3855 or defines an enum, it is valid but we need not do anything here.
3856 Otherwise, it is an error.
3858 C++: may have to grok the declspecs to learn about static,
3859 complain for anonymous unions.
3861 Returns the TYPE declared -- or NULL_TREE if none. */
3864 shadow_tag (cp_decl_specifier_seq
*declspecs
)
3866 tree t
= check_tag_decl (declspecs
);
3871 if (declspecs
->attributes
)
3873 warning (0, "attribute ignored in declaration of %q+#T", t
);
3874 warning (0, "attribute for %q+#T must follow the %qs keyword",
3875 t
, class_key_or_enum_as_string (t
));
3879 if (maybe_process_partial_specialization (t
) == error_mark_node
)
3882 /* This is where the variables in an anonymous union are
3883 declared. An anonymous union declaration looks like:
3885 because there is no declarator after the union, the parser
3886 sends that declaration here. */
3887 if (ANON_AGGR_TYPE_P (t
))
3889 fixup_anonymous_aggr (t
);
3891 if (TYPE_FIELDS (t
))
3893 tree decl
= grokdeclarator (/*declarator=*/NULL
,
3894 declspecs
, NORMAL
, 0, NULL
);
3895 finish_anon_union (decl
);
3902 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
3905 groktypename (cp_decl_specifier_seq
*type_specifiers
,
3906 const cp_declarator
*declarator
)
3910 attrs
= type_specifiers
->attributes
;
3911 type_specifiers
->attributes
= NULL_TREE
;
3912 type
= grokdeclarator (declarator
, type_specifiers
, TYPENAME
, 0, &attrs
);
3913 if (attrs
&& type
!= error_mark_node
)
3915 if (CLASS_TYPE_P (type
))
3916 warning (OPT_Wattributes
, "ignoring attributes applied to class type %qT "
3917 "outside of definition", type
);
3918 else if (MAYBE_CLASS_TYPE_P (type
))
3919 /* A template type parameter or other dependent type. */
3920 warning (OPT_Wattributes
, "ignoring attributes applied to dependent "
3921 "type %qT without an associated declaration", type
);
3923 cplus_decl_attributes (&type
, attrs
, 0);
3928 /* Process a DECLARATOR for a function-scope variable declaration,
3929 namespace-scope variable declaration, or function declaration.
3930 (Function definitions go through start_function; class member
3931 declarations appearing in the body of the class go through
3932 grokfield.) The DECL corresponding to the DECLARATOR is returned.
3933 If an error occurs, the error_mark_node is returned instead.
3935 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED
3936 is true if an explicit initializer is present, but false if this is
3937 a variable implicitly initialized via a default constructor.
3938 ATTRIBUTES and PREFIX_ATTRIBUTES are GNU attributes associated with
3939 this declaration. *PUSHED_SCOPE_P is set to the scope entered in
3940 this function, if any; if set, the caller is responsible for
3941 calling pop_scope. */
3944 start_decl (const cp_declarator
*declarator
,
3945 cp_decl_specifier_seq
*declspecs
,
3948 tree prefix_attributes
,
3949 tree
*pushed_scope_p
)
3957 *pushed_scope_p
= NULL_TREE
;
3959 /* An object declared as __attribute__((deprecated)) suppresses
3960 warnings of uses of other deprecated items. */
3961 if (lookup_attribute ("deprecated", attributes
))
3962 deprecated_state
= DEPRECATED_SUPPRESS
;
3964 attributes
= chainon (attributes
, prefix_attributes
);
3966 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
3969 deprecated_state
= DEPRECATED_NORMAL
;
3971 if (decl
== NULL_TREE
|| TREE_CODE (decl
) == VOID_TYPE
3972 || decl
== error_mark_node
)
3973 return error_mark_node
;
3975 type
= TREE_TYPE (decl
);
3977 context
= DECL_CONTEXT (decl
);
3981 *pushed_scope_p
= push_scope (context
);
3983 /* We are only interested in class contexts, later. */
3984 if (TREE_CODE (context
) == NAMESPACE_DECL
)
3985 context
= NULL_TREE
;
3989 /* Is it valid for this decl to have an initializer at all?
3990 If not, set INITIALIZED to zero, which will indirectly
3991 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
3992 switch (TREE_CODE (decl
))
3995 error ("typedef %qD is initialized (use __typeof__ instead)", decl
);
3996 return error_mark_node
;
3999 error ("function %q#D is initialized like a variable", decl
);
4000 return error_mark_node
;
4008 if (! toplevel_bindings_p ()
4009 && DECL_EXTERNAL (decl
))
4010 warning (0, "declaration of %q#D has %<extern%> and is initialized",
4012 DECL_EXTERNAL (decl
) = 0;
4013 if (toplevel_bindings_p ())
4014 TREE_STATIC (decl
) = 1;
4017 /* If this is a typedef that names the class for linkage purposes
4018 (7.1.3p8), apply any attributes directly to the type. */
4019 if (TREE_CODE (decl
) == TYPE_DECL
4020 && TAGGED_TYPE_P (TREE_TYPE (decl
))
4021 && decl
== TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl
))))
4022 flags
= ATTR_FLAG_TYPE_IN_PLACE
;
4026 /* Set attributes here so if duplicate decl, will have proper attributes. */
4027 cplus_decl_attributes (&decl
, attributes
, flags
);
4029 /* Dllimported symbols cannot be defined. Static data members (which
4030 can be initialized in-class and dllimported) go through grokfield,
4031 not here, so we don't need to exclude those decls when checking for
4033 if (initialized
&& DECL_DLLIMPORT_P (decl
))
4035 error ("definition of %q#D is marked %<dllimport%>", decl
);
4036 DECL_DLLIMPORT_P (decl
) = 0;
4039 /* If #pragma weak was used, mark the decl weak now. */
4040 maybe_apply_pragma_weak (decl
);
4042 if (TREE_CODE (decl
) == FUNCTION_DECL
4043 && DECL_DECLARED_INLINE_P (decl
)
4044 && DECL_UNINLINABLE (decl
)
4045 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
4046 warning (0, "inline function %q+D given attribute noinline", decl
);
4048 if (context
&& COMPLETE_TYPE_P (complete_type (context
)))
4050 if (TREE_CODE (decl
) == VAR_DECL
)
4052 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, false);
4053 if (field
== NULL_TREE
|| TREE_CODE (field
) != VAR_DECL
)
4054 error ("%q#D is not a static member of %q#T", decl
, context
);
4057 if (DECL_CONTEXT (field
) != context
)
4059 if (!same_type_p (DECL_CONTEXT (field
), context
))
4060 permerror ("ISO C++ does not permit %<%T::%D%> "
4061 "to be defined as %<%T::%D%>",
4062 DECL_CONTEXT (field
), DECL_NAME (decl
),
4063 context
, DECL_NAME (decl
));
4064 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
4066 if (processing_specialization
4067 && template_class_depth (context
) == 0
4068 && CLASSTYPE_TEMPLATE_SPECIALIZATION (context
))
4069 error ("template header not allowed in member definition "
4070 "of explicitly specialized class");
4071 /* Static data member are tricky; an in-class initialization
4072 still doesn't provide a definition, so the in-class
4073 declaration will have DECL_EXTERNAL set, but will have an
4074 initialization. Thus, duplicate_decls won't warn
4075 about this situation, and so we check here. */
4076 if (initialized
&& DECL_INITIALIZED_IN_CLASS_P (field
))
4077 error ("duplicate initialization of %qD", decl
);
4078 if (duplicate_decls (decl
, field
, /*newdecl_is_friend=*/false))
4084 tree field
= check_classfn (context
, decl
,
4085 (processing_template_decl
4086 > template_class_depth (context
))
4087 ? current_template_parms
4089 if (field
&& field
!= error_mark_node
4090 && duplicate_decls (decl
, field
,
4091 /*newdecl_is_friend=*/false))
4095 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
4096 DECL_IN_AGGR_P (decl
) = 0;
4097 /* Do not mark DECL as an explicit specialization if it was not
4098 already marked as an instantiation; a declaration should
4099 never be marked as a specialization unless we know what
4100 template is being specialized. */
4101 if (DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
4103 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
4105 /* [temp.expl.spec] An explicit specialization of a static data
4106 member of a template is a definition if the declaration
4107 includes an initializer; otherwise, it is a declaration.
4109 We check for processing_specialization so this only applies
4110 to the new specialization syntax. */
4111 if (!initialized
&& processing_specialization
)
4112 DECL_EXTERNAL (decl
) = 1;
4115 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
))
4116 permerror ("declaration of %q#D outside of class is not definition",
4120 was_public
= TREE_PUBLIC (decl
);
4122 /* Enter this declaration into the symbol table. */
4123 decl
= maybe_push_decl (decl
);
4125 if (processing_template_decl
)
4126 decl
= push_template_decl (decl
);
4127 if (decl
== error_mark_node
)
4128 return error_mark_node
;
4130 /* Tell the back end to use or not use .common as appropriate. If we say
4131 -fconserve-space, we want this to save .data space, at the expense of
4132 wrong semantics. If we say -fno-conserve-space, we want this to
4133 produce errors about redefs; to do this we force variables into the
4135 if (flag_conserve_space
4136 && TREE_CODE (decl
) == VAR_DECL
4137 && TREE_PUBLIC (decl
)
4138 && !DECL_THREAD_LOCAL_P (decl
)
4139 && !have_global_bss_p ())
4140 DECL_COMMON (decl
) = 1;
4142 if (TREE_CODE (decl
) == VAR_DECL
4143 && DECL_NAMESPACE_SCOPE_P (decl
) && !TREE_PUBLIC (decl
) && !was_public
4144 && !DECL_THIS_STATIC (decl
) && !DECL_ARTIFICIAL (decl
))
4146 /* This is a const variable with implicit 'static'. Set
4147 DECL_THIS_STATIC so we can tell it from variables that are
4148 !TREE_PUBLIC because of the anonymous namespace. */
4149 gcc_assert (cp_type_readonly (TREE_TYPE (decl
)));
4150 DECL_THIS_STATIC (decl
) = 1;
4153 if (!processing_template_decl
&& TREE_CODE (decl
) == VAR_DECL
)
4154 start_decl_1 (decl
, initialized
);
4159 /* Process the declaration of a variable DECL. INITIALIZED is true
4160 iff DECL is explicitly initialized. (INITIALIZED is false if the
4161 variable is initialized via an implicitly-called constructor.)
4162 This function must be called for ordinary variables (including, for
4163 example, implicit instantiations of templates), but must not be
4164 called for template declarations. */
4167 start_decl_1 (tree decl
, bool initialized
)
4171 bool aggregate_definition_p
;
4173 gcc_assert (!processing_template_decl
);
4175 if (error_operand_p (decl
))
4178 gcc_assert (TREE_CODE (decl
) == VAR_DECL
);
4180 type
= TREE_TYPE (decl
);
4181 complete_p
= COMPLETE_TYPE_P (type
);
4182 aggregate_definition_p
= MAYBE_CLASS_TYPE_P (type
) && !DECL_EXTERNAL (decl
);
4184 /* If an explicit initializer is present, or if this is a definition
4185 of an aggregate, then we need a complete type at this point.
4186 (Scalars are always complete types, so there is nothing to
4187 check.) This code just sets COMPLETE_P; errors (if necessary)
4188 are issued below. */
4189 if ((initialized
|| aggregate_definition_p
)
4191 && COMPLETE_TYPE_P (complete_type (type
)))
4194 /* We will not yet have set TREE_READONLY on DECL if the type
4195 was "const", but incomplete, before this point. But, now, we
4196 have a complete type, so we can try again. */
4197 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
4201 /* Is it valid for this decl to have an initializer at all? */
4203 /* Don't allow initializations for incomplete types except for
4204 arrays which might be completed by the initialization. */
4206 ; /* A complete type is ok. */
4207 else if (TREE_CODE (type
) != ARRAY_TYPE
)
4209 error ("variable %q#D has initializer but incomplete type", decl
);
4210 type
= TREE_TYPE (decl
) = error_mark_node
;
4212 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
4214 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
4215 error ("elements of array %q#D have incomplete type", decl
);
4216 /* else we already gave an error in start_decl. */
4219 else if (aggregate_definition_p
&& !complete_p
)
4221 error ("aggregate %q#D has incomplete type and cannot be defined",
4223 /* Change the type so that assemble_variable will give
4224 DECL an rtl we can live with: (mem (const_int 0)). */
4225 type
= TREE_TYPE (decl
) = error_mark_node
;
4228 /* Create a new scope to hold this declaration if necessary.
4229 Whether or not a new scope is necessary cannot be determined
4230 until after the type has been completed; if the type is a
4231 specialization of a class template it is not until after
4232 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4233 will be set correctly. */
4234 maybe_push_cleanup_level (type
);
4237 /* Handle initialization of references. DECL, TYPE, and INIT have the
4238 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
4239 but will be set to a new CLEANUP_STMT if a temporary is created
4240 that must be destroyed subsequently.
4242 Returns an initializer expression to use to initialize DECL, or
4243 NULL if the initialization can be performed statically.
4245 Quotes on semantics can be found in ARM 8.4.3. */
4248 grok_reference_init (tree decl
, tree type
, tree init
, tree
*cleanup
)
4252 if (init
== NULL_TREE
)
4254 if ((DECL_LANG_SPECIFIC (decl
) == 0
4255 || DECL_IN_AGGR_P (decl
) == 0)
4256 && ! DECL_THIS_EXTERN (decl
))
4257 error ("%qD declared as reference but not initialized", decl
);
4261 if (TREE_CODE (init
) == CONSTRUCTOR
)
4263 error ("ISO C++ forbids use of initializer list to "
4264 "initialize reference %qD", decl
);
4268 if (TREE_CODE (init
) == TREE_LIST
)
4269 init
= build_x_compound_expr_from_list (init
, "initializer");
4271 if (TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
4272 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
4273 /* Note: default conversion is only called in very special cases. */
4274 init
= decay_conversion (init
);
4276 /* Convert INIT to the reference type TYPE. This may involve the
4277 creation of a temporary, whose lifetime must be the same as that
4278 of the reference. If so, a DECL_EXPR for the temporary will be
4279 added just after the DECL_EXPR for DECL. That's why we don't set
4280 DECL_INITIAL for local references (instead assigning to them
4281 explicitly); we need to allow the temporary to be initialized
4283 tmp
= initialize_reference (type
, init
, decl
, cleanup
);
4285 if (tmp
== error_mark_node
)
4287 else if (tmp
== NULL_TREE
)
4289 error ("cannot initialize %qT from %qT", type
, TREE_TYPE (init
));
4293 if (TREE_STATIC (decl
) && !TREE_CONSTANT (tmp
))
4296 DECL_INITIAL (decl
) = tmp
;
4301 /* Subroutine of check_initializer. We're initializing a DECL of
4302 std::initializer_list<T> TYPE from a braced-init-list INIT, and need to
4303 extend the lifetime of the underlying array to match that of the decl,
4304 just like for reference initialization. CLEANUP is as for
4305 grok_reference_init. */
4308 build_init_list_var_init (tree decl
, tree type
, tree init
, tree
*cleanup
)
4310 tree aggr_init
, array
, arrtype
;
4311 init
= perform_implicit_conversion (type
, init
, tf_warning_or_error
);
4312 aggr_init
= TARGET_EXPR_INITIAL (init
);
4313 init
= build2 (INIT_EXPR
, type
, decl
, init
);
4315 array
= AGGR_INIT_EXPR_ARG (aggr_init
, 1);
4316 arrtype
= TREE_TYPE (array
);
4318 gcc_assert (TREE_CODE (array
) == ADDR_EXPR
);
4319 array
= TREE_OPERAND (array
, 0);
4320 /* If the array is constant, finish_compound_literal already made it a
4321 static variable and we don't need to do anything here. */
4322 if (decl
&& TREE_CODE (array
) == TARGET_EXPR
)
4325 tree var
= set_up_extended_ref_temp (decl
, array
, cleanup
, &subinit
);
4326 var
= build_address (var
);
4327 var
= convert (arrtype
, var
);
4328 AGGR_INIT_EXPR_ARG (aggr_init
, 1) = var
;
4329 init
= build2 (COMPOUND_EXPR
, TREE_TYPE (init
), subinit
, init
);
4334 /* Designated initializers in arrays are not supported in GNU C++.
4335 The parser cannot detect this error since it does not know whether
4336 a given brace-enclosed initializer is for a class type or for an
4337 array. This function checks that CE does not use a designated
4338 initializer. If it does, an error is issued. Returns true if CE
4339 is valid, i.e., does not have a designated initializer. */
4342 check_array_designated_initializer (const constructor_elt
*ce
)
4344 /* Designated initializers for array elements are not supported. */
4347 /* The parser only allows identifiers as designated
4349 gcc_assert (TREE_CODE (ce
->index
) == IDENTIFIER_NODE
);
4350 error ("name %qD used in a GNU-style designated "
4351 "initializer for an array", ce
->index
);
4358 /* When parsing `int a[] = {1, 2};' we don't know the size of the
4359 array until we finish parsing the initializer. If that's the
4360 situation we're in, update DECL accordingly. */
4363 maybe_deduce_size_from_array_init (tree decl
, tree init
)
4365 tree type
= TREE_TYPE (decl
);
4367 if (TREE_CODE (type
) == ARRAY_TYPE
4368 && TYPE_DOMAIN (type
) == NULL_TREE
4369 && TREE_CODE (decl
) != TYPE_DECL
)
4371 /* do_default is really a C-ism to deal with tentative definitions.
4372 But let's leave it here to ease the eventual merge. */
4373 int do_default
= !DECL_EXTERNAL (decl
);
4374 tree initializer
= init
? init
: DECL_INITIAL (decl
);
4377 /* Check that there are no designated initializers in INIT, as
4378 those are not supported in GNU C++, and as the middle-end
4379 will crash if presented with a non-numeric designated
4381 if (initializer
&& TREE_CODE (initializer
) == CONSTRUCTOR
)
4383 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (initializer
);
4384 constructor_elt
*ce
;
4387 VEC_iterate (constructor_elt
, v
, i
, ce
);
4389 if (!check_array_designated_initializer (ce
))
4395 failure
= cp_complete_array_type (&TREE_TYPE (decl
), initializer
,
4399 error ("initializer fails to determine size of %qD", decl
);
4400 TREE_TYPE (decl
) = error_mark_node
;
4402 else if (failure
== 2)
4406 error ("array size missing in %qD", decl
);
4407 TREE_TYPE (decl
) = error_mark_node
;
4409 /* If a `static' var's size isn't known, make it extern as
4410 well as static, so it does not get allocated. If it's not
4411 `static', then don't mark it extern; finish_incomplete_decl
4412 will give it a default size and it will get allocated. */
4413 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
4414 DECL_EXTERNAL (decl
) = 1;
4416 else if (failure
== 3)
4418 error ("zero-size array %qD", decl
);
4419 TREE_TYPE (decl
) = error_mark_node
;
4423 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl
)), decl
);
4425 layout_decl (decl
, 0);
4429 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
4430 any appropriate error messages regarding the layout. */
4433 layout_var_decl (tree decl
)
4437 type
= TREE_TYPE (decl
);
4438 if (type
== error_mark_node
)
4441 /* If we haven't already layed out this declaration, do so now.
4442 Note that we must not call complete type for an external object
4443 because it's type might involve templates that we are not
4444 supposed to instantiate yet. (And it's perfectly valid to say
4445 `extern X x' for some incomplete type `X'.) */
4446 if (!DECL_EXTERNAL (decl
))
4447 complete_type (type
);
4448 if (!DECL_SIZE (decl
)
4449 && TREE_TYPE (decl
) != error_mark_node
4450 && (COMPLETE_TYPE_P (type
)
4451 || (TREE_CODE (type
) == ARRAY_TYPE
4452 && !TYPE_DOMAIN (type
)
4453 && COMPLETE_TYPE_P (TREE_TYPE (type
)))))
4454 layout_decl (decl
, 0);
4456 if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
4458 /* An automatic variable with an incomplete type: that is an error.
4459 Don't talk about array types here, since we took care of that
4460 message in grokdeclarator. */
4461 error ("storage size of %qD isn't known", decl
);
4462 TREE_TYPE (decl
) = error_mark_node
;
4465 /* Keep this code around in case we later want to control debug info
4466 based on whether a type is "used". (jason 1999-11-11) */
4468 else if (!DECL_EXTERNAL (decl
) && MAYBE_CLASS_TYPE_P (ttype
))
4469 /* Let debugger know it should output info for this type. */
4470 note_debug_info_needed (ttype
);
4472 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
4473 note_debug_info_needed (DECL_CONTEXT (decl
));
4476 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
4477 && DECL_SIZE (decl
) != NULL_TREE
4478 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
4480 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
4481 constant_expression_warning (DECL_SIZE (decl
));
4484 error ("storage size of %qD isn't constant", decl
);
4485 TREE_TYPE (decl
) = error_mark_node
;
4490 /* If a local static variable is declared in an inline function, or if
4491 we have a weak definition, we must endeavor to create only one
4492 instance of the variable at link-time. */
4495 maybe_commonize_var (tree decl
)
4497 /* Static data in a function with comdat linkage also has comdat
4499 if (TREE_STATIC (decl
)
4500 /* Don't mess with __FUNCTION__. */
4501 && ! DECL_ARTIFICIAL (decl
)
4502 && DECL_FUNCTION_SCOPE_P (decl
)
4503 /* Unfortunately, import_export_decl has not always been called
4504 before the function is processed, so we cannot simply check
4506 && (DECL_COMDAT (DECL_CONTEXT (decl
))
4507 || ((DECL_DECLARED_INLINE_P (DECL_CONTEXT (decl
))
4508 || DECL_TEMPLATE_INSTANTIATION (DECL_CONTEXT (decl
)))
4509 && TREE_PUBLIC (DECL_CONTEXT (decl
)))))
4513 /* With weak symbols, we simply make the variable COMDAT;
4514 that will cause copies in multiple translations units to
4516 comdat_linkage (decl
);
4520 if (DECL_INITIAL (decl
) == NULL_TREE
4521 || DECL_INITIAL (decl
) == error_mark_node
)
4523 /* Without weak symbols, we can use COMMON to merge
4524 uninitialized variables. */
4525 TREE_PUBLIC (decl
) = 1;
4526 DECL_COMMON (decl
) = 1;
4530 /* While for initialized variables, we must use internal
4531 linkage -- which means that multiple copies will not
4533 TREE_PUBLIC (decl
) = 0;
4534 DECL_COMMON (decl
) = 0;
4535 warning (0, "sorry: semantics of inline function static "
4536 "data %q+#D are wrong (you'll wind up "
4537 "with multiple copies)", decl
);
4538 warning (0, "%J you can work around this by removing "
4544 else if (DECL_LANG_SPECIFIC (decl
) && DECL_COMDAT (decl
))
4545 /* Set it up again; we might have set DECL_INITIAL since the last
4547 comdat_linkage (decl
);
4550 /* Issue an error message if DECL is an uninitialized const variable. */
4553 check_for_uninitialized_const_var (tree decl
)
4555 tree type
= TREE_TYPE (decl
);
4557 /* ``Unless explicitly declared extern, a const object does not have
4558 external linkage and must be initialized. ($8.4; $12.1)'' ARM
4560 if (TREE_CODE (decl
) == VAR_DECL
4561 && TREE_CODE (type
) != REFERENCE_TYPE
4562 && CP_TYPE_CONST_P (type
)
4563 && !TYPE_NEEDS_CONSTRUCTING (type
)
4564 && !DECL_INITIAL (decl
))
4565 error ("uninitialized const %qD", decl
);
4569 /* Structure holding the current initializer being processed by reshape_init.
4570 CUR is a pointer to the current element being processed, END is a pointer
4571 after the last element present in the initializer. */
4572 typedef struct reshape_iterator_t
4574 constructor_elt
*cur
;
4575 constructor_elt
*end
;
4578 static tree
reshape_init_r (tree
, reshape_iter
*, bool);
4580 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
4581 returned is the next FIELD_DECL (possibly FIELD itself) that can be
4582 initialized. If there are no more such fields, the return value
4586 next_initializable_field (tree field
)
4589 && (TREE_CODE (field
) != FIELD_DECL
4590 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
4591 || DECL_ARTIFICIAL (field
)))
4592 field
= TREE_CHAIN (field
);
4597 /* Subroutine of reshape_init_array and reshape_init_vector, which does
4598 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
4599 INTEGER_CST representing the size of the array minus one (the maximum index),
4600 or NULL_TREE if the array was declared without specifying the size. D is
4601 the iterator within the constructor. */
4604 reshape_init_array_1 (tree elt_type
, tree max_index
, reshape_iter
*d
)
4607 bool sized_array_p
= (max_index
!= NULL_TREE
);
4608 unsigned HOST_WIDE_INT max_index_cst
= 0;
4609 unsigned HOST_WIDE_INT index
;
4611 /* The initializer for an array is always a CONSTRUCTOR. */
4612 new_init
= build_constructor (init_list_type_node
, NULL
);
4616 /* Minus 1 is used for zero sized arrays. */
4617 if (integer_all_onesp (max_index
))
4620 if (host_integerp (max_index
, 1))
4621 max_index_cst
= tree_low_cst (max_index
, 1);
4622 /* sizetype is sign extended, not zero extended. */
4624 max_index_cst
= tree_low_cst (fold_convert (size_type_node
, max_index
),
4628 /* Loop until there are no more initializers. */
4630 d
->cur
!= d
->end
&& (!sized_array_p
|| index
<= max_index_cst
);
4635 check_array_designated_initializer (d
->cur
);
4636 elt_init
= reshape_init_r (elt_type
, d
, /*first_initializer_p=*/false);
4637 if (elt_init
== error_mark_node
)
4638 return error_mark_node
;
4639 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
), NULL_TREE
, elt_init
);
4645 /* Subroutine of reshape_init_r, processes the initializers for arrays.
4646 Parameters are the same of reshape_init_r. */
4649 reshape_init_array (tree type
, reshape_iter
*d
)
4651 tree max_index
= NULL_TREE
;
4653 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
4655 if (TYPE_DOMAIN (type
))
4656 max_index
= array_type_nelts (type
);
4658 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
);
4661 /* Subroutine of reshape_init_r, processes the initializers for vectors.
4662 Parameters are the same of reshape_init_r. */
4665 reshape_init_vector (tree type
, reshape_iter
*d
)
4667 tree max_index
= NULL_TREE
;
4670 gcc_assert (TREE_CODE (type
) == VECTOR_TYPE
);
4672 if (COMPOUND_LITERAL_P (d
->cur
->value
))
4674 tree value
= d
->cur
->value
;
4675 if (!same_type_p (TREE_TYPE (value
), type
))
4677 error ("invalid type %qT as initializer for a vector of type %qT",
4678 TREE_TYPE (d
->cur
->value
), type
);
4679 value
= error_mark_node
;
4685 /* For a vector, the representation type is a struct
4686 containing a single member which is an array of the
4687 appropriate size. */
4688 rtype
= TYPE_DEBUG_REPRESENTATION_TYPE (type
);
4689 if (rtype
&& TYPE_DOMAIN (TREE_TYPE (TYPE_FIELDS (rtype
))))
4690 max_index
= array_type_nelts (TREE_TYPE (TYPE_FIELDS (rtype
)));
4692 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
);
4695 /* Subroutine of reshape_init_r, processes the initializers for classes
4696 or union. Parameters are the same of reshape_init_r. */
4699 reshape_init_class (tree type
, reshape_iter
*d
, bool first_initializer_p
)
4704 gcc_assert (CLASS_TYPE_P (type
));
4706 /* The initializer for a class is always a CONSTRUCTOR. */
4707 new_init
= build_constructor (init_list_type_node
, NULL
);
4708 field
= next_initializable_field (TYPE_FIELDS (type
));
4714 An initializer for an aggregate member that is an
4715 empty class shall have the form of an empty
4716 initializer-list {}. */
4717 if (!first_initializer_p
)
4719 error ("initializer for %qT must be brace-enclosed", type
);
4720 return error_mark_node
;
4725 /* Loop through the initializable fields, gathering initializers. */
4726 while (d
->cur
!= d
->end
)
4730 /* Handle designated initializers, as an extension. */
4733 field
= lookup_field_1 (type
, d
->cur
->index
, /*want_type=*/false);
4735 if (!field
|| TREE_CODE (field
) != FIELD_DECL
)
4737 error ("%qT has no non-static data member named %qD", type
,
4739 return error_mark_node
;
4743 /* If we processed all the member of the class, we are done. */
4747 field_init
= reshape_init_r (TREE_TYPE (field
), d
,
4748 /*first_initializer_p=*/false);
4749 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
), field
, field_init
);
4753 When a union is initialized with a brace-enclosed
4754 initializer, the braces shall only contain an
4755 initializer for the first member of the union. */
4756 if (TREE_CODE (type
) == UNION_TYPE
)
4759 field
= next_initializable_field (TREE_CHAIN (field
));
4765 /* Subroutine of reshape_init, which processes a single initializer (part of
4766 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
4767 iterator within the CONSTRUCTOR which points to the initializer to process.
4768 FIRST_INITIALIZER_P is true if this is the first initializer of the
4769 CONSTRUCTOR node. */
4772 reshape_init_r (tree type
, reshape_iter
*d
, bool first_initializer_p
)
4774 tree init
= d
->cur
->value
;
4776 /* A non-aggregate type is always initialized with a single
4778 if (!CP_AGGREGATE_TYPE_P (type
))
4780 /* It is invalid to initialize a non-aggregate type with a
4781 brace-enclosed initializer.
4782 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
4783 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
4784 a CONSTRUCTOR (with a record type). */
4785 if (TREE_CODE (init
) == CONSTRUCTOR
4786 && BRACE_ENCLOSED_INITIALIZER_P (init
)) /* p7626.C */
4788 error ("braces around scalar initializer for type %qT", type
);
4789 init
= error_mark_node
;
4798 All implicit type conversions (clause _conv_) are considered when
4799 initializing the aggregate member with an initializer from an
4800 initializer-list. If the initializer can initialize a member,
4801 the member is initialized. Otherwise, if the member is itself a
4802 non-empty subaggregate, brace elision is assumed and the
4803 initializer is considered for the initialization of the first
4804 member of the subaggregate. */
4805 if (TREE_CODE (init
) != CONSTRUCTOR
4806 && can_convert_arg (type
, TREE_TYPE (init
), init
, LOOKUP_NORMAL
))
4812 /* [dcl.init.string]
4814 A char array (whether plain char, signed char, or unsigned char)
4815 can be initialized by a string-literal (optionally enclosed in
4816 braces); a wchar_t array can be initialized by a wide
4817 string-literal (optionally enclosed in braces). */
4818 if (TREE_CODE (type
) == ARRAY_TYPE
4819 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type
))))
4821 tree str_init
= init
;
4823 /* Strip one level of braces if and only if they enclose a single
4824 element (as allowed by [dcl.init.string]). */
4825 if (!first_initializer_p
4826 && TREE_CODE (str_init
) == CONSTRUCTOR
4827 && VEC_length (constructor_elt
, CONSTRUCTOR_ELTS (str_init
)) == 1)
4829 str_init
= VEC_index (constructor_elt
,
4830 CONSTRUCTOR_ELTS (str_init
), 0)->value
;
4833 /* If it's a string literal, then it's the initializer for the array
4834 as a whole. Otherwise, continue with normal initialization for
4835 array types (one value per array element). */
4836 if (TREE_CODE (str_init
) == STRING_CST
)
4843 /* The following cases are about aggregates. If we are not within a full
4844 initializer already, and there is not a CONSTRUCTOR, it means that there
4845 is a missing set of braces (that is, we are processing the case for
4846 which reshape_init exists). */
4847 if (!first_initializer_p
)
4849 if (TREE_CODE (init
) == CONSTRUCTOR
)
4851 if (TREE_TYPE (init
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init
)))
4852 /* There is no need to reshape pointer-to-member function
4853 initializers, as they are always constructed correctly
4854 by the front end. */
4856 else if (COMPOUND_LITERAL_P (init
))
4857 /* For a nested compound literal, there is no need to reshape since
4858 brace elision is not allowed. Even if we decided to allow it,
4859 we should add a call to reshape_init in finish_compound_literal,
4860 before calling digest_init, so changing this code would still
4861 not be necessary. */
4862 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init
));
4866 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
4867 return reshape_init (type
, init
);
4871 warning (OPT_Wmissing_braces
, "missing braces around initializer for %qT",
4875 /* Dispatch to specialized routines. */
4876 if (CLASS_TYPE_P (type
))
4877 return reshape_init_class (type
, d
, first_initializer_p
);
4878 else if (TREE_CODE (type
) == ARRAY_TYPE
)
4879 return reshape_init_array (type
, d
);
4880 else if (TREE_CODE (type
) == VECTOR_TYPE
)
4881 return reshape_init_vector (type
, d
);
4886 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
4887 brace-enclosed aggregate initializer.
4889 INIT is the CONSTRUCTOR containing the list of initializers describing
4890 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
4891 It may not presently match the shape of the TYPE; for example:
4893 struct S { int a; int b; };
4894 struct S a[] = { 1, 2, 3, 4 };
4896 Here INIT will hold a VEC of four elements, rather than a
4897 VEC of two elements, each itself a VEC of two elements. This
4898 routine transforms INIT from the former form into the latter. The
4899 revised CONSTRUCTOR node is returned. */
4902 reshape_init (tree type
, tree init
)
4904 VEC(constructor_elt
, gc
) *v
;
4908 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
4910 v
= CONSTRUCTOR_ELTS (init
);
4912 /* An empty constructor does not need reshaping, and it is always a valid
4914 if (VEC_empty (constructor_elt
, v
))
4917 /* Recurse on this CONSTRUCTOR. */
4918 d
.cur
= VEC_index (constructor_elt
, v
, 0);
4919 d
.end
= d
.cur
+ VEC_length (constructor_elt
, v
);
4921 new_init
= reshape_init_r (type
, &d
, true);
4922 if (new_init
== error_mark_node
)
4923 return error_mark_node
;
4925 /* Make sure all the element of the constructor were used. Otherwise,
4926 issue an error about exceeding initializers. */
4928 error ("too many initializers for %qT", type
);
4933 /* Verify array initializer. Returns true if errors have been reported. */
4936 check_array_initializer (tree decl
, tree type
, tree init
)
4938 tree element_type
= TREE_TYPE (type
);
4940 /* The array type itself need not be complete, because the
4941 initializer may tell us how many elements are in the array.
4942 But, the elements of the array must be complete. */
4943 if (!COMPLETE_TYPE_P (complete_type (element_type
)))
4946 error ("elements of array %q#D have incomplete type", decl
);
4948 error ("elements of array %q#T have incomplete type", type
);
4951 /* It is not valid to initialize a VLA. */
4953 && ((COMPLETE_TYPE_P (type
) && !TREE_CONSTANT (TYPE_SIZE (type
)))
4954 || !TREE_CONSTANT (TYPE_SIZE (element_type
))))
4957 error ("variable-sized object %qD may not be initialized", decl
);
4959 error ("variable-sized compound literal");
4965 /* Subroutine of check_initializer; args are passed down from that function.
4966 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
4969 build_aggr_init_full_exprs (tree decl
, tree init
, int flags
)
4972 int saved_stmts_are_full_exprs_p
= 0;
4973 if (building_stmt_tree ())
4975 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
4976 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
4978 init
= build_aggr_init (decl
, init
, flags
, tf_warning_or_error
);
4979 if (building_stmt_tree ())
4980 current_stmt_tree ()->stmts_are_full_exprs_p
=
4981 saved_stmts_are_full_exprs_p
;
4985 /* Verify INIT (the initializer for DECL), and record the
4986 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
4987 grok_reference_init.
4989 If the return value is non-NULL, it is an expression that must be
4990 evaluated dynamically to initialize DECL. */
4993 check_initializer (tree decl
, tree init
, int flags
, tree
*cleanup
)
4995 tree type
= TREE_TYPE (decl
);
4996 tree init_code
= NULL
;
4998 /* Things that are going to be initialized need to have complete
5000 TREE_TYPE (decl
) = type
= complete_type (TREE_TYPE (decl
));
5002 if (type
== error_mark_node
)
5003 /* We will have already complained. */
5006 if (TREE_CODE (type
) == ARRAY_TYPE
)
5008 if (check_array_initializer (decl
, type
, init
))
5011 else if (!COMPLETE_TYPE_P (type
))
5013 error ("%qD has incomplete type", decl
);
5014 TREE_TYPE (decl
) = error_mark_node
;
5018 /* There is no way to make a variable-sized class type in GNU C++. */
5019 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type
)));
5021 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
))
5023 int init_len
= VEC_length (constructor_elt
, CONSTRUCTOR_ELTS (init
));
5024 if (SCALAR_TYPE_P (type
))
5028 maybe_warn_cpp0x ("extended initializer lists");
5029 init
= build_zero_init (type
, NULL_TREE
, false);
5031 else if (init_len
!= 1)
5033 error ("scalar object %qD requires one element in initializer",
5035 TREE_TYPE (decl
) = error_mark_node
;
5041 if (TREE_CODE (decl
) == CONST_DECL
)
5043 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
5045 DECL_INITIAL (decl
) = init
;
5047 gcc_assert (init
!= NULL_TREE
);
5050 else if (!DECL_EXTERNAL (decl
) && TREE_CODE (type
) == REFERENCE_TYPE
)
5051 init
= grok_reference_init (decl
, type
, init
, cleanup
);
5054 /* Do not reshape constructors of vectors (they don't need to be
5056 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
5058 if (is_std_init_list (type
))
5059 return build_init_list_var_init (decl
, type
, init
, cleanup
);
5060 else if (TYPE_NON_AGGREGATE_CLASS (type
))
5062 /* Don't reshape if the class has constructors. */
5063 if (cxx_dialect
== cxx98
)
5064 error ("in C++98 %qD must be initialized by constructor, "
5067 init
= build_tree_list (NULL_TREE
, init
);
5069 else if ((*targetm
.vector_opaque_p
) (type
))
5071 error ("opaque vector types cannot be initialized");
5072 init
= error_mark_node
;
5075 init
= reshape_init (type
, init
);
5078 /* If DECL has an array type without a specific bound, deduce the
5079 array size from the initializer. */
5080 maybe_deduce_size_from_array_init (decl
, init
);
5081 type
= TREE_TYPE (decl
);
5082 if (type
== error_mark_node
)
5085 if (TYPE_NEEDS_CONSTRUCTING (type
)
5086 || (CLASS_TYPE_P (type
)
5087 && !BRACE_ENCLOSED_INITIALIZER_P (init
)))
5088 return build_aggr_init_full_exprs (decl
, init
, flags
);
5089 else if (TREE_CODE (init
) != TREE_VEC
)
5091 init_code
= store_init_value (decl
, init
);
5092 if (pedantic
&& TREE_CODE (type
) == ARRAY_TYPE
5093 && DECL_INITIAL (decl
)
5094 && TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
5095 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl
)))
5096 warning (0, "array %qD initialized by parenthesized string literal %qE",
5097 decl
, DECL_INITIAL (decl
));
5101 else if (DECL_EXTERNAL (decl
))
5103 else if (TYPE_P (type
) && TYPE_NEEDS_CONSTRUCTING (type
))
5104 return build_aggr_init_full_exprs (decl
, init
, flags
);
5105 else if (MAYBE_CLASS_TYPE_P (type
))
5107 tree core_type
= strip_array_types (type
);
5109 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
))
5110 error ("structure %qD with uninitialized const members", decl
);
5111 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
))
5112 error ("structure %qD with uninitialized reference members", decl
);
5114 check_for_uninitialized_const_var (decl
);
5117 check_for_uninitialized_const_var (decl
);
5119 if (init
&& init
!= error_mark_node
)
5120 init_code
= build2 (INIT_EXPR
, type
, decl
, init
);
5125 /* If DECL is not a local variable, give it RTL. */
5128 make_rtl_for_nonlocal_decl (tree decl
, tree init
, const char* asmspec
)
5130 int toplev
= toplevel_bindings_p ();
5132 const char *filename
;
5134 /* Set the DECL_ASSEMBLER_NAME for the object. */
5137 /* The `register' keyword, when used together with an
5138 asm-specification, indicates that the variable should be
5139 placed in a particular register. */
5140 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_REGISTER (decl
))
5142 set_user_assembler_name (decl
, asmspec
);
5143 DECL_HARD_REGISTER (decl
) = 1;
5147 if (TREE_CODE (decl
) == FUNCTION_DECL
5148 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
5149 set_builtin_user_assembler_name (decl
, asmspec
);
5150 set_user_assembler_name (decl
, asmspec
);
5154 /* Handle non-variables up front. */
5155 if (TREE_CODE (decl
) != VAR_DECL
)
5157 rest_of_decl_compilation (decl
, toplev
, at_eof
);
5161 /* If we see a class member here, it should be a static data
5163 if (DECL_LANG_SPECIFIC (decl
) && DECL_IN_AGGR_P (decl
))
5165 gcc_assert (TREE_STATIC (decl
));
5166 /* An in-class declaration of a static data member should be
5167 external; it is only a declaration, and not a definition. */
5168 if (init
== NULL_TREE
)
5169 gcc_assert (DECL_EXTERNAL (decl
) || !TREE_PUBLIC (decl
));
5172 /* We don't create any RTL for local variables. */
5173 if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
5176 /* We defer emission of local statics until the corresponding
5177 DECL_EXPR is expanded. */
5178 defer_p
= DECL_FUNCTION_SCOPE_P (decl
) || DECL_VIRTUAL_P (decl
);
5180 /* We try to defer namespace-scope static constants so that they are
5181 not emitted into the object file unnecessarily. */
5182 filename
= input_filename
;
5183 if (!DECL_VIRTUAL_P (decl
)
5184 && TREE_READONLY (decl
)
5185 && DECL_INITIAL (decl
) != NULL_TREE
5186 && DECL_INITIAL (decl
) != error_mark_node
5188 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
))
5190 && !TREE_PUBLIC (decl
))
5192 /* Fool with the linkage of static consts according to #pragma
5194 struct c_fileinfo
*finfo
= get_fileinfo (filename
);
5195 if (!finfo
->interface_unknown
&& !TREE_PUBLIC (decl
))
5197 TREE_PUBLIC (decl
) = 1;
5198 DECL_EXTERNAL (decl
) = finfo
->interface_only
;
5203 /* Likewise for template instantiations. */
5204 else if (DECL_LANG_SPECIFIC (decl
)
5205 && DECL_IMPLICIT_INSTANTIATION (decl
))
5208 /* If we're not deferring, go ahead and assemble the variable. */
5210 rest_of_decl_compilation (decl
, toplev
, at_eof
);
5213 /* walk_tree helper for wrap_temporary_cleanups, below. */
5216 wrap_cleanups_r (tree
*stmt_p
, int *walk_subtrees
, void *data
)
5218 if (TYPE_P (*stmt_p
))
5224 if (TREE_CODE (*stmt_p
) == TARGET_EXPR
)
5226 tree guard
= (tree
)data
;
5227 tree tcleanup
= TARGET_EXPR_CLEANUP (*stmt_p
);
5229 tcleanup
= build2 (TRY_CATCH_EXPR
, void_type_node
, tcleanup
, guard
);
5230 /* Tell honor_protect_cleanup_actions to handle this as a separate
5232 TRY_CATCH_IS_CLEANUP (tcleanup
) = 1;
5234 TARGET_EXPR_CLEANUP (*stmt_p
) = tcleanup
;
5240 /* We're initializing a local variable which has a cleanup GUARD. If there
5241 are any temporaries used in the initializer INIT of this variable, we
5242 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
5243 variable will be cleaned up properly if one of them throws.
5245 Unfortunately, there's no way to express this properly in terms of
5246 nesting, as the regions for the temporaries overlap the region for the
5247 variable itself; if there are two temporaries, the variable needs to be
5248 the first thing destroyed if either of them throws. However, we only
5249 want to run the variable's cleanup if it actually got constructed. So
5250 we need to guard the temporary cleanups with the variable's cleanup if
5251 they are run on the normal path, but not if they are run on the
5252 exceptional path. We implement this by telling
5253 honor_protect_cleanup_actions to strip the variable cleanup from the
5254 exceptional path. */
5257 wrap_temporary_cleanups (tree init
, tree guard
)
5259 cp_walk_tree_without_duplicates (&init
, wrap_cleanups_r
, (void *)guard
);
5262 /* Generate code to initialize DECL (a local variable). */
5265 initialize_local_var (tree decl
, tree init
)
5267 tree type
= TREE_TYPE (decl
);
5271 gcc_assert (TREE_CODE (decl
) == VAR_DECL
5272 || TREE_CODE (decl
) == RESULT_DECL
);
5273 gcc_assert (!TREE_STATIC (decl
));
5275 if (DECL_SIZE (decl
) == NULL_TREE
)
5277 /* If we used it already as memory, it must stay in memory. */
5278 DECL_INITIAL (decl
) = NULL_TREE
;
5279 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
5283 if (type
== error_mark_node
)
5286 /* Compute and store the initial value. */
5287 already_used
= TREE_USED (decl
) || TREE_USED (type
);
5289 /* Generate a cleanup, if necessary. */
5290 cleanup
= cxx_maybe_build_cleanup (decl
);
5292 /* Perform the initialization. */
5295 int saved_stmts_are_full_exprs_p
;
5297 /* If we're only initializing a single object, guard the destructors
5298 of any temporaries used in its initializer with its destructor.
5299 This isn't right for arrays because each element initialization is
5300 a full-expression. */
5301 if (cleanup
&& TREE_CODE (type
) != ARRAY_TYPE
)
5302 wrap_temporary_cleanups (init
, cleanup
);
5304 gcc_assert (building_stmt_tree ());
5305 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
5306 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
5307 finish_expr_stmt (init
);
5308 current_stmt_tree ()->stmts_are_full_exprs_p
=
5309 saved_stmts_are_full_exprs_p
;
5312 /* Set this to 0 so we can tell whether an aggregate which was
5313 initialized was ever used. Don't do this if it has a
5314 destructor, so we don't complain about the 'resource
5315 allocation is initialization' idiom. Now set
5316 attribute((unused)) on types so decls of that type will be
5317 marked used. (see TREE_USED, above.) */
5318 if (TYPE_NEEDS_CONSTRUCTING (type
)
5320 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type
)
5321 && DECL_NAME (decl
))
5322 TREE_USED (decl
) = 0;
5323 else if (already_used
)
5324 TREE_USED (decl
) = 1;
5327 finish_decl_cleanup (decl
, cleanup
);
5330 /* DECL is a VAR_DECL for a compiler-generated variable with static
5331 storage duration (like a virtual table) whose initializer is a
5332 compile-time constant. INIT must be either a TREE_LIST of values,
5333 or a CONSTRUCTOR. Initialize the variable and provide it to the
5337 initialize_artificial_var (tree decl
, tree init
)
5339 gcc_assert (DECL_ARTIFICIAL (decl
));
5340 if (TREE_CODE (init
) == TREE_LIST
)
5341 init
= build_constructor_from_list (TREE_TYPE (decl
), init
);
5342 gcc_assert (TREE_CODE (init
) == CONSTRUCTOR
);
5343 DECL_INITIAL (decl
) = init
;
5344 DECL_INITIALIZED_P (decl
) = 1;
5345 determine_visibility (decl
);
5346 layout_var_decl (decl
);
5347 maybe_commonize_var (decl
);
5348 make_rtl_for_nonlocal_decl (decl
, init
, /*asmspec=*/NULL
);
5351 /* INIT is the initializer for a variable, as represented by the
5352 parser. Returns true iff INIT is value-dependent. */
5355 value_dependent_init_p (tree init
)
5357 if (TREE_CODE (init
) == TREE_LIST
)
5358 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
5359 return any_value_dependent_elements_p (init
);
5360 else if (TREE_CODE (init
) == CONSTRUCTOR
)
5361 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
5363 VEC(constructor_elt
, gc
) *elts
;
5367 elts
= CONSTRUCTOR_ELTS (init
);
5368 nelts
= VEC_length (constructor_elt
, elts
);
5369 for (i
= 0; i
< nelts
; ++i
)
5370 if (value_dependent_init_p (VEC_index (constructor_elt
,
5375 /* It must be a simple expression, e.g., int i = 3; */
5376 return value_dependent_expression_p (init
);
5381 /* Finish processing of a declaration;
5382 install its line number and initial value.
5383 If the length of an array type is not known before,
5384 it must be determined now, from the initial value, or it is an error.
5386 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
5387 true, then INIT is an integral constant expression.
5389 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
5390 if the (init) syntax was used. */
5393 cp_finish_decl (tree decl
, tree init
, bool init_const_expr_p
,
5394 tree asmspec_tree
, int flags
)
5398 const char *asmspec
= NULL
;
5399 int was_readonly
= 0;
5400 bool var_definition_p
= false;
5401 int saved_processing_template_decl
;
5403 if (decl
== error_mark_node
)
5408 error ("assignment (not initialization) in declaration");
5412 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
5413 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
5414 gcc_assert (TREE_CODE (decl
) != PARM_DECL
);
5416 type
= TREE_TYPE (decl
);
5417 if (type
== error_mark_node
)
5420 /* Assume no cleanup is required. */
5421 cleanup
= NULL_TREE
;
5422 saved_processing_template_decl
= processing_template_decl
;
5424 /* If a name was specified, get the string. */
5425 if (global_scope_p (current_binding_level
))
5426 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
5427 if (asmspec_tree
&& asmspec_tree
!= error_mark_node
)
5428 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
5430 if (current_class_type
5431 && CP_DECL_CONTEXT (decl
) == current_class_type
5432 && TYPE_BEING_DEFINED (current_class_type
)
5433 && (DECL_INITIAL (decl
) || init
))
5434 DECL_INITIALIZED_IN_CLASS_P (decl
) = 1;
5436 if (processing_template_decl
)
5438 bool type_dependent_p
;
5440 /* Add this declaration to the statement-tree. */
5441 if (at_function_scope_p ())
5442 add_decl_expr (decl
);
5444 type_dependent_p
= dependent_type_p (type
);
5446 if (check_for_bare_parameter_packs (init
))
5449 DECL_INITIAL (decl
) = NULL_TREE
;
5452 if (init
&& init_const_expr_p
)
5454 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = 1;
5455 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl
))
5456 TREE_CONSTANT (decl
) = 1;
5459 /* Generally, initializers in templates are expanded when the
5460 template is instantiated. But, if DECL is an integral
5461 constant static data member, then it can be used in future
5462 integral constant expressions, and its value must be
5465 && DECL_CLASS_SCOPE_P (decl
)
5466 && DECL_INTEGRAL_CONSTANT_VAR_P (decl
)
5467 && !type_dependent_p
5468 && !value_dependent_init_p (init
)))
5471 DECL_INITIAL (decl
) = init
;
5472 if (TREE_CODE (decl
) == VAR_DECL
5473 && !DECL_PRETTY_FUNCTION_P (decl
)
5474 && !type_dependent_p
)
5475 maybe_deduce_size_from_array_init (decl
, init
);
5479 if (TREE_CODE (init
) == TREE_LIST
)
5481 /* If the parenthesized-initializer form was used (e.g.,
5482 "int A<N>::i(X)"), then INIT will be a TREE_LIST of initializer
5483 arguments. (There is generally only one.) We convert them
5486 for (; list
; list
= TREE_CHAIN (list
))
5488 tree elt
= TREE_VALUE (list
);
5489 TREE_VALUE (list
) = fold_non_dependent_expr (elt
);
5493 init
= fold_non_dependent_expr (init
);
5494 processing_template_decl
= 0;
5497 /* Take care of TYPE_DECLs up front. */
5498 if (TREE_CODE (decl
) == TYPE_DECL
)
5500 if (type
!= error_mark_node
5501 && MAYBE_CLASS_TYPE_P (type
) && DECL_NAME (decl
))
5503 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
5504 warning (0, "shadowing previous type declaration of %q#D", decl
);
5505 set_identifier_type_value (DECL_NAME (decl
), decl
);
5508 /* If we have installed this as the canonical typedef for this
5509 type, and that type has not been defined yet, delay emitting
5510 the debug information for it, as we will emit it later. */
5511 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
5512 && !COMPLETE_TYPE_P (TREE_TYPE (decl
)))
5513 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
5515 rest_of_decl_compilation (decl
, DECL_CONTEXT (decl
) == NULL_TREE
,
5520 /* A reference will be modified here, as it is initialized. */
5521 if (! DECL_EXTERNAL (decl
)
5522 && TREE_READONLY (decl
)
5523 && TREE_CODE (type
) == REFERENCE_TYPE
)
5526 TREE_READONLY (decl
) = 0;
5529 if (TREE_CODE (decl
) == VAR_DECL
)
5531 /* Only PODs can have thread-local storage. Other types may require
5532 various kinds of non-trivial initialization. */
5533 if (DECL_THREAD_LOCAL_P (decl
) && !pod_type_p (TREE_TYPE (decl
)))
5534 error ("%qD cannot be thread-local because it has non-POD type %qT",
5535 decl
, TREE_TYPE (decl
));
5536 /* If this is a local variable that will need a mangled name,
5537 register it now. We must do this before processing the
5538 initializer for the variable, since the initialization might
5539 require a guard variable, and since the mangled name of the
5540 guard variable will depend on the mangled name of this
5542 if (DECL_FUNCTION_SCOPE_P (decl
)
5543 && TREE_STATIC (decl
)
5544 && !DECL_ARTIFICIAL (decl
))
5545 push_local_name (decl
);
5546 /* Convert the initializer to the type of DECL, if we have not
5547 already initialized DECL. */
5548 if (!DECL_INITIALIZED_P (decl
)
5549 /* If !DECL_EXTERNAL then DECL is being defined. In the
5550 case of a static data member initialized inside the
5551 class-specifier, there can be an initializer even if DECL
5552 is *not* defined. */
5553 && (!DECL_EXTERNAL (decl
) || init
))
5555 if (TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
5558 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
5559 /* Allow libjava/prims.cc define primitive classes. */
5560 if (init
!= NULL_TREE
5561 || jclass
== NULL_TREE
5562 || TREE_CODE (jclass
) != TYPE_DECL
5563 || !POINTER_TYPE_P (TREE_TYPE (jclass
))
5564 || !same_type_ignoring_top_level_qualifiers_p
5565 (type
, TREE_TYPE (TREE_TYPE (jclass
))))
5566 error ("Java object %qD not allocated with %<new%>", decl
);
5571 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = 1;
5572 if (init_const_expr_p
)
5574 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = 1;
5575 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl
))
5576 TREE_CONSTANT (decl
) = 1;
5579 init
= check_initializer (decl
, init
, flags
, &cleanup
);
5580 /* Thread-local storage cannot be dynamically initialized. */
5581 if (DECL_THREAD_LOCAL_P (decl
) && init
)
5583 error ("%qD is thread-local and so cannot be dynamically "
5584 "initialized", decl
);
5588 /* Check that the initializer for a static data member was a
5589 constant. Although we check in the parser that the
5590 initializer is an integral constant expression, we do not
5591 simplify division-by-zero at the point at which it
5592 occurs. Therefore, in:
5594 struct S { static const int i = 7 / 0; };
5596 we issue an error at this point. It would
5597 probably be better to forbid division by zero in
5598 integral constant expressions. */
5599 if (DECL_EXTERNAL (decl
) && init
)
5601 error ("%qD cannot be initialized by a non-constant expression"
5602 " when being declared", decl
);
5603 DECL_INITIALIZED_IN_CLASS_P (decl
) = 0;
5611 The memory occupied by any object of static storage
5612 duration is zero-initialized at program startup before
5613 any other initialization takes place.
5615 We cannot create an appropriate initializer until after
5616 the type of DECL is finalized. If DECL_INITIAL is set,
5617 then the DECL is statically initialized, and any
5618 necessary zero-initialization has already been performed. */
5619 if (TREE_STATIC (decl
) && !DECL_INITIAL (decl
))
5620 DECL_INITIAL (decl
) = build_zero_init (TREE_TYPE (decl
),
5621 /*nelts=*/NULL_TREE
,
5622 /*static_storage_p=*/true);
5623 /* Remember that the initialization for this variable has
5625 DECL_INITIALIZED_P (decl
) = 1;
5626 /* This declaration is the definition of this variable,
5627 unless we are initializing a static data member within
5628 the class specifier. */
5629 if (!DECL_EXTERNAL (decl
))
5630 var_definition_p
= true;
5632 /* If the variable has an array type, lay out the type, even if
5633 there is no initializer. It is valid to index through the
5634 array, and we must get TYPE_ALIGN set correctly on the array
5636 else if (TREE_CODE (type
) == ARRAY_TYPE
)
5639 else if (TREE_CODE (decl
) == FIELD_DECL
5640 && TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
5641 error ("non-static data member %qD has Java class type", decl
);
5643 /* Add this declaration to the statement-tree. This needs to happen
5644 after the call to check_initializer so that the DECL_EXPR for a
5645 reference temp is added before the DECL_EXPR for the reference itself. */
5646 if (at_function_scope_p ())
5647 add_decl_expr (decl
);
5649 /* Let the middle end know about variables and functions -- but not
5650 static data members in uninstantiated class templates. */
5651 if (!saved_processing_template_decl
5652 && (TREE_CODE (decl
) == VAR_DECL
5653 || TREE_CODE (decl
) == FUNCTION_DECL
))
5655 if (TREE_CODE (decl
) == VAR_DECL
)
5657 layout_var_decl (decl
);
5658 maybe_commonize_var (decl
);
5661 /* This needs to happen after the linkage is set. */
5662 determine_visibility (decl
);
5664 if (var_definition_p
&& TREE_STATIC (decl
))
5666 /* If a TREE_READONLY variable needs initialization
5667 at runtime, it is no longer readonly and we need to
5668 avoid MEM_READONLY_P being set on RTL created for it. */
5671 if (TREE_READONLY (decl
))
5672 TREE_READONLY (decl
) = 0;
5675 else if (was_readonly
)
5676 TREE_READONLY (decl
) = 1;
5679 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
);
5681 /* Check for abstractness of the type. Notice that there is no
5682 need to strip array types here since the check for those types
5683 is already done within create_array_type_for_decl. */
5684 if (TREE_CODE (type
) == FUNCTION_TYPE
5685 || TREE_CODE (type
) == METHOD_TYPE
)
5686 abstract_virtuals_error (decl
, TREE_TYPE (type
));
5688 abstract_virtuals_error (decl
, type
);
5690 if (TREE_CODE (decl
) == FUNCTION_DECL
5691 || TREE_TYPE (decl
) == error_mark_node
)
5692 /* No initialization required. */
5694 else if (DECL_EXTERNAL (decl
)
5695 && ! (DECL_LANG_SPECIFIC (decl
)
5696 && DECL_NOT_REALLY_EXTERN (decl
)))
5699 DECL_INITIAL (decl
) = init
;
5701 /* A variable definition. */
5702 else if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
5703 /* Initialize the local variable. */
5704 initialize_local_var (decl
, init
);
5706 /* If a variable is defined, and then a subsequent
5707 definition with external linkage is encountered, we will
5708 get here twice for the same variable. We want to avoid
5709 calling expand_static_init more than once. For variables
5710 that are not static data members, we can call
5711 expand_static_init only when we actually process the
5712 initializer. It is not legal to redeclare a static data
5713 member, so this issue does not arise in that case. */
5714 else if (var_definition_p
&& TREE_STATIC (decl
))
5715 expand_static_init (decl
, init
);
5718 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
5719 reference, insert it in the statement-tree now. */
5721 push_cleanup (decl
, cleanup
, false);
5724 processing_template_decl
= saved_processing_template_decl
;
5727 TREE_READONLY (decl
) = 1;
5729 /* If this was marked 'used', be sure it will be output. */
5730 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl
)))
5731 mark_decl_referenced (decl
);
5734 /* This is here for a midend callback from c-common.c. */
5737 finish_decl (tree decl
, tree init
, tree asmspec_tree
)
5739 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, asmspec_tree
, 0);
5742 /* Returns a declaration for a VAR_DECL as if:
5744 extern "C" TYPE NAME;
5746 had been seen. Used to create compiler-generated global
5750 declare_global_var (tree name
, tree type
)
5754 push_to_top_level ();
5755 decl
= build_decl (VAR_DECL
, name
, type
);
5756 TREE_PUBLIC (decl
) = 1;
5757 DECL_EXTERNAL (decl
) = 1;
5758 DECL_ARTIFICIAL (decl
) = 1;
5759 /* If the user has explicitly declared this variable (perhaps
5760 because the code we are compiling is part of a low-level runtime
5761 library), then it is possible that our declaration will be merged
5762 with theirs by pushdecl. */
5763 decl
= pushdecl (decl
);
5764 finish_decl (decl
, NULL_TREE
, NULL_TREE
);
5765 pop_from_top_level ();
5770 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
5771 if "__cxa_atexit" is not being used) corresponding to the function
5772 to be called when the program exits. */
5775 get_atexit_fn_ptr_type (void)
5780 if (!atexit_fn_ptr_type_node
)
5782 if (flag_use_cxa_atexit
5783 && !targetm
.cxx
.use_atexit_for_cxa_atexit ())
5784 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
5785 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, void_list_node
);
5787 /* The parameter to "atexit" is "void (*)(void)". */
5788 arg_types
= void_list_node
;
5790 fn_type
= build_function_type (void_type_node
, arg_types
);
5791 atexit_fn_ptr_type_node
= build_pointer_type (fn_type
);
5794 return atexit_fn_ptr_type_node
;
5797 /* Returns a pointer to the `atexit' function. Note that if
5798 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
5799 `__cxa_atexit' function specified in the IA64 C++ ABI. */
5802 get_atexit_node (void)
5809 bool use_aeabi_atexit
;
5814 if (flag_use_cxa_atexit
&& !targetm
.cxx
.use_atexit_for_cxa_atexit ())
5816 /* The declaration for `__cxa_atexit' is:
5818 int __cxa_atexit (void (*)(void *), void *, void *)
5820 We build up the argument types and then then function type
5823 use_aeabi_atexit
= targetm
.cxx
.use_aeabi_atexit ();
5824 /* First, build the pointer-to-function type for the first
5826 fn_ptr_type
= get_atexit_fn_ptr_type ();
5827 /* Then, build the rest of the argument types. */
5828 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, void_list_node
);
5829 if (use_aeabi_atexit
)
5831 arg_types
= tree_cons (NULL_TREE
, fn_ptr_type
, arg_types
);
5832 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, arg_types
);
5836 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, arg_types
);
5837 arg_types
= tree_cons (NULL_TREE
, fn_ptr_type
, arg_types
);
5839 /* And the final __cxa_atexit type. */
5840 fn_type
= build_function_type (integer_type_node
, arg_types
);
5841 fn_ptr_type
= build_pointer_type (fn_type
);
5842 if (use_aeabi_atexit
)
5843 name
= "__aeabi_atexit";
5845 name
= "__cxa_atexit";
5849 /* The declaration for `atexit' is:
5851 int atexit (void (*)());
5853 We build up the argument types and then then function type
5855 fn_ptr_type
= get_atexit_fn_ptr_type ();
5856 arg_types
= tree_cons (NULL_TREE
, fn_ptr_type
, void_list_node
);
5857 /* Build the final atexit type. */
5858 fn_type
= build_function_type (integer_type_node
, arg_types
);
5862 /* Now, build the function declaration. */
5863 push_lang_context (lang_name_c
);
5864 atexit_fndecl
= build_library_fn_ptr (name
, fn_type
);
5865 mark_used (atexit_fndecl
);
5866 pop_lang_context ();
5867 atexit_node
= decay_conversion (atexit_fndecl
);
5872 /* Returns the __dso_handle VAR_DECL. */
5875 get_dso_handle_node (void)
5877 if (dso_handle_node
)
5878 return dso_handle_node
;
5880 /* Declare the variable. */
5881 dso_handle_node
= declare_global_var (get_identifier ("__dso_handle"),
5884 return dso_handle_node
;
5887 /* Begin a new function with internal linkage whose job will be simply
5888 to destroy some particular variable. */
5890 static GTY(()) int start_cleanup_cnt
;
5893 start_cleanup_fn (void)
5898 bool use_cxa_atexit
= flag_use_cxa_atexit
5899 && !targetm
.cxx
.use_atexit_for_cxa_atexit ();
5901 push_to_top_level ();
5903 /* No need to mangle this. */
5904 push_lang_context (lang_name_c
);
5906 /* Build the name of the function. */
5907 sprintf (name
, "__tcf_%d", start_cleanup_cnt
++);
5908 /* Build the function declaration. */
5909 fntype
= TREE_TYPE (get_atexit_fn_ptr_type ());
5910 fndecl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), fntype
);
5911 /* It's a function with internal linkage, generated by the
5913 TREE_PUBLIC (fndecl
) = 0;
5914 DECL_ARTIFICIAL (fndecl
) = 1;
5915 /* Make the function `inline' so that it is only emitted if it is
5916 actually needed. It is unlikely that it will be inlined, since
5917 it is only called via a function pointer, but we avoid unnecessary
5918 emissions this way. */
5919 DECL_INLINE (fndecl
) = 1;
5920 DECL_DECLARED_INLINE_P (fndecl
) = 1;
5921 DECL_INTERFACE_KNOWN (fndecl
) = 1;
5922 /* Build the parameter. */
5927 parmdecl
= cp_build_parm_decl (NULL_TREE
, ptr_type_node
);
5928 DECL_CONTEXT (parmdecl
) = fndecl
;
5929 TREE_USED (parmdecl
) = 1;
5930 DECL_ARGUMENTS (fndecl
) = parmdecl
;
5934 start_preparsed_function (fndecl
, NULL_TREE
, SF_PRE_PARSED
);
5936 pop_lang_context ();
5938 return current_function_decl
;
5941 /* Finish the cleanup function begun by start_cleanup_fn. */
5944 end_cleanup_fn (void)
5946 expand_or_defer_fn (finish_function (0));
5948 pop_from_top_level ();
5951 /* Generate code to handle the destruction of DECL, an object with
5952 static storage duration. */
5955 register_dtor_fn (tree decl
)
5964 type
= TREE_TYPE (decl
);
5965 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
5966 return void_zero_node
;
5968 /* If we're using "__cxa_atexit" (or "__aeabi_atexit"), and DECL is
5969 a class object, we can just pass the destructor to
5970 "__cxa_atexit"; we don't have to build a temporary function to do
5972 use_dtor
= (flag_use_cxa_atexit
5973 && !targetm
.cxx
.use_atexit_for_cxa_atexit ()
5974 && CLASS_TYPE_P (type
));
5979 /* Find the destructor. */
5980 idx
= lookup_fnfields_1 (type
, complete_dtor_identifier
);
5981 gcc_assert (idx
>= 0);
5982 cleanup
= VEC_index (tree
, CLASSTYPE_METHOD_VEC (type
), idx
);
5983 /* Make sure it is accessible. */
5984 perform_or_defer_access_check (TYPE_BINFO (type
), cleanup
, cleanup
);
5988 /* Call build_cleanup before we enter the anonymous function so
5989 that any access checks will be done relative to the current
5990 scope, rather than the scope of the anonymous function. */
5991 build_cleanup (decl
);
5993 /* Now start the function. */
5994 cleanup
= start_cleanup_fn ();
5996 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
5997 to the original function, rather than the anonymous one. That
5998 will make the back end think that nested functions are in use,
5999 which causes confusion. */
6000 push_deferring_access_checks (dk_no_check
);
6001 fcall
= build_cleanup (decl
);
6002 pop_deferring_access_checks ();
6004 /* Create the body of the anonymous function. */
6005 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
6006 finish_expr_stmt (fcall
);
6007 finish_compound_stmt (compound_stmt
);
6011 /* Call atexit with the cleanup function. */
6012 mark_used (cleanup
);
6013 cleanup
= build_address (cleanup
);
6014 if (flag_use_cxa_atexit
&& !targetm
.cxx
.use_atexit_for_cxa_atexit ())
6020 /* We must convert CLEANUP to the type that "__cxa_atexit"
6022 cleanup
= build_nop (get_atexit_fn_ptr_type (), cleanup
);
6023 /* "__cxa_atexit" will pass the address of DECL to the
6024 cleanup function. */
6026 addr
= build_address (decl
);
6027 /* The declared type of the parameter to "__cxa_atexit" is
6028 "void *". For plain "T*", we could just let the
6029 machinery in cp_build_function_call convert it -- but if the
6030 type is "cv-qualified T *", then we need to convert it
6031 before passing it in, to avoid spurious errors. */
6032 addr
= build_nop (ptr_type_node
, addr
);
6035 /* Since the cleanup functions we build ignore the address
6036 they're given, there's no reason to pass the actual address
6037 in, and, in general, it's cheaper to pass NULL than any
6039 addr
= null_pointer_node
;
6040 args
= tree_cons (NULL_TREE
,
6041 cp_build_unary_op (ADDR_EXPR
, get_dso_handle_node (), 0,
6042 tf_warning_or_error
),
6044 if (targetm
.cxx
.use_aeabi_atexit ())
6046 args
= tree_cons (NULL_TREE
, cleanup
, args
);
6047 args
= tree_cons (NULL_TREE
, addr
, args
);
6051 args
= tree_cons (NULL_TREE
, addr
, args
);
6052 args
= tree_cons (NULL_TREE
, cleanup
, args
);
6056 args
= tree_cons (NULL_TREE
, cleanup
, NULL_TREE
);
6057 return cp_build_function_call (get_atexit_node (), args
,
6058 tf_warning_or_error
);
6061 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
6062 is its initializer. Generate code to handle the construction
6063 and destruction of DECL. */
6066 expand_static_init (tree decl
, tree init
)
6068 gcc_assert (TREE_CODE (decl
) == VAR_DECL
);
6069 gcc_assert (TREE_STATIC (decl
));
6071 /* Some variables require no initialization. */
6073 && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
))
6074 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
6077 if (DECL_FUNCTION_SCOPE_P (decl
))
6079 /* Emit code to perform this initialization but once. */
6080 tree if_stmt
= NULL_TREE
, inner_if_stmt
= NULL_TREE
;
6081 tree then_clause
= NULL_TREE
, inner_then_clause
= NULL_TREE
;
6082 tree guard
, guard_addr
;
6083 tree acquire_fn
, release_fn
, abort_fn
;
6086 /* Emit code to perform this initialization but once. This code
6089 static <type> guard;
6090 if (!guard.first_byte) {
6091 if (__cxa_guard_acquire (&guard)) {
6094 // Do initialization.
6095 flag = true; __cxa_guard_release (&guard);
6096 // Register variable for destruction at end of program.
6098 if (!flag) __cxa_guard_abort (&guard);
6102 Note that the `flag' variable is only set to 1 *after* the
6103 initialization is complete. This ensures that an exception,
6104 thrown during the construction, will cause the variable to
6105 reinitialized when we pass through this code again, as per:
6109 If the initialization exits by throwing an exception, the
6110 initialization is not complete, so it will be tried again
6111 the next time control enters the declaration.
6113 This process should be thread-safe, too; multiple threads
6114 should not be able to initialize the variable more than
6117 /* Create the guard variable. */
6118 guard
= get_guard (decl
);
6120 /* This optimization isn't safe on targets with relaxed memory
6121 consistency. On such targets we force synchronization in
6122 __cxa_guard_acquire. */
6123 if (!targetm
.relaxed_ordering
|| !flag_threadsafe_statics
)
6125 /* Begin the conditional initialization. */
6126 if_stmt
= begin_if_stmt ();
6127 finish_if_stmt_cond (get_guard_cond (guard
), if_stmt
);
6128 then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
6131 if (flag_threadsafe_statics
)
6133 guard_addr
= build_address (guard
);
6135 acquire_fn
= get_identifier ("__cxa_guard_acquire");
6136 release_fn
= get_identifier ("__cxa_guard_release");
6137 abort_fn
= get_identifier ("__cxa_guard_abort");
6138 if (!get_global_value_if_present (acquire_fn
, &acquire_fn
))
6140 tree argtypes
= tree_cons (NULL_TREE
, TREE_TYPE (guard_addr
),
6142 tree vfntype
= build_function_type (void_type_node
, argtypes
);
6143 acquire_fn
= push_library_fn
6144 (acquire_fn
, build_function_type (integer_type_node
, argtypes
));
6145 release_fn
= push_library_fn (release_fn
, vfntype
);
6146 abort_fn
= push_library_fn (abort_fn
, vfntype
);
6150 release_fn
= identifier_global_value (release_fn
);
6151 abort_fn
= identifier_global_value (abort_fn
);
6154 inner_if_stmt
= begin_if_stmt ();
6155 finish_if_stmt_cond (build_call_n (acquire_fn
, 1, guard_addr
),
6158 inner_then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
6159 begin
= get_target_expr (boolean_false_node
);
6160 flag
= TARGET_EXPR_SLOT (begin
);
6162 TARGET_EXPR_CLEANUP (begin
)
6163 = build3 (COND_EXPR
, void_type_node
, flag
,
6165 build_call_n (abort_fn
, 1, guard_addr
));
6166 CLEANUP_EH_ONLY (begin
) = 1;
6168 /* Do the initialization itself. */
6169 init
= add_stmt_to_compound (begin
, init
);
6170 init
= add_stmt_to_compound
6171 (init
, build2 (MODIFY_EXPR
, void_type_node
, flag
, boolean_true_node
));
6172 init
= add_stmt_to_compound
6173 (init
, build_call_n (release_fn
, 1, guard_addr
));
6176 init
= add_stmt_to_compound (init
, set_guard (guard
));
6178 /* Use atexit to register a function for destroying this static
6180 init
= add_stmt_to_compound (init
, register_dtor_fn (decl
));
6182 finish_expr_stmt (init
);
6184 if (flag_threadsafe_statics
)
6186 finish_compound_stmt (inner_then_clause
);
6187 finish_then_clause (inner_if_stmt
);
6188 finish_if_stmt (inner_if_stmt
);
6191 if (!targetm
.relaxed_ordering
|| !flag_threadsafe_statics
)
6193 finish_compound_stmt (then_clause
);
6194 finish_then_clause (if_stmt
);
6195 finish_if_stmt (if_stmt
);
6199 static_aggregates
= tree_cons (init
, decl
, static_aggregates
);
6203 /* Make TYPE a complete type based on INITIAL_VALUE.
6204 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6205 2 if there was no information (in which case assume 0 if DO_DEFAULT),
6206 3 if the initializer list is empty (in pedantic mode). */
6209 cp_complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
6212 tree type
, elt_type
;
6216 unsigned HOST_WIDE_INT i
;
6219 /* An array of character type can be initialized from a
6220 brace-enclosed string constant.
6222 FIXME: this code is duplicated from reshape_init. Probably
6223 we should just call reshape_init here? */
6224 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype
)))
6225 && TREE_CODE (initial_value
) == CONSTRUCTOR
6226 && !VEC_empty (constructor_elt
, CONSTRUCTOR_ELTS (initial_value
)))
6228 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (initial_value
);
6229 tree value
= VEC_index (constructor_elt
, v
, 0)->value
;
6231 if (TREE_CODE (value
) == STRING_CST
6232 && VEC_length (constructor_elt
, v
) == 1)
6233 initial_value
= value
;
6236 /* If any of the elements are parameter packs, we can't actually
6237 complete this type now because the array size is dependent. */
6238 if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
6240 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value
),
6243 if (PACK_EXPANSION_P (value
))
6249 failure
= complete_array_type (ptype
, initial_value
, do_default
);
6251 /* We can create the array before the element type is complete, which
6252 means that we didn't have these two bits set in the original type
6253 either. In completing the type, we are expected to propagate these
6254 bits. See also complete_type which does the same thing for arrays
6257 if (TYPE_DOMAIN (type
))
6259 elt_type
= TREE_TYPE (type
);
6260 TYPE_NEEDS_CONSTRUCTING (type
) = TYPE_NEEDS_CONSTRUCTING (elt_type
);
6261 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
6262 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
);
6268 /* Return zero if something is declared to be a member of type
6269 CTYPE when in the context of CUR_TYPE. STRING is the error
6270 message to print in that case. Otherwise, quietly return 1. */
6273 member_function_or_else (tree ctype
, tree cur_type
, enum overload_flags flags
)
6275 if (ctype
&& ctype
!= cur_type
)
6277 if (flags
== DTOR_FLAG
)
6278 error ("destructor for alien class %qT cannot be a member", ctype
);
6280 error ("constructor for alien class %qT cannot be a member", ctype
);
6286 /* Subroutine of `grokdeclarator'. */
6288 /* Generate errors possibly applicable for a given set of specifiers.
6289 This is for ARM $7.1.2. */
6292 bad_specifiers (tree object
,
6301 error ("%qD declared as a %<virtual%> %s", object
, type
);
6303 error ("%qD declared as an %<inline%> %s", object
, type
);
6305 error ("%<const%> and %<volatile%> function specifiers on "
6306 "%qD invalid in %s declaration",
6309 error ("%q+D declared as a friend", object
);
6311 && (TREE_CODE (object
) == TYPE_DECL
6312 || (!TYPE_PTRFN_P (TREE_TYPE (object
))
6313 && !TYPE_REFFN_P (TREE_TYPE (object
))
6314 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object
)))))
6315 error ("%q+D declared with an exception specification", object
);
6318 /* DECL is a member function or static data member and is presently
6319 being defined. Check that the definition is taking place in a
6323 check_class_member_definition_namespace (tree decl
)
6325 /* These checks only apply to member functions and static data
6327 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
6328 || TREE_CODE (decl
) == VAR_DECL
);
6329 /* We check for problems with specializations in pt.c in
6330 check_specialization_namespace, where we can issue better
6332 if (processing_specialization
)
6334 /* There are no restrictions on the placement of
6335 explicit instantiations. */
6336 if (processing_explicit_instantiation
)
6340 A member function definition that appears outside of the
6341 class definition shall appear in a namespace scope enclosing
6342 the class definition.
6346 The definition for a static data member shall appear in a
6347 namespace scope enclosing the member's class definition. */
6348 if (!is_ancestor (current_namespace
, DECL_CONTEXT (decl
)))
6349 permerror ("definition of %qD is not in namespace enclosing %qT",
6350 decl
, DECL_CONTEXT (decl
));
6353 /* Build a PARM_DECL for the "this" parameter. TYPE is the
6354 METHOD_TYPE for a non-static member function; QUALS are the
6355 cv-qualifiers that apply to the function. */
6358 build_this_parm (tree type
, cp_cv_quals quals
)
6363 cp_cv_quals this_quals
;
6365 this_type
= TREE_VALUE (TYPE_ARG_TYPES (type
));
6366 /* The `this' parameter is implicitly `const'; it cannot be
6368 this_quals
= (quals
& TYPE_QUAL_RESTRICT
) | TYPE_QUAL_CONST
;
6369 qual_type
= cp_build_qualified_type (this_type
, this_quals
);
6370 parm
= build_artificial_parm (this_identifier
, qual_type
);
6371 cp_apply_type_quals_to_decl (this_quals
, parm
);
6375 /* CTYPE is class type, or null if non-class.
6376 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
6378 DECLARATOR is the function's name.
6379 PARMS is a chain of PARM_DECLs for the function.
6380 VIRTUALP is truthvalue of whether the function is virtual or not.
6381 FLAGS are to be passed through to `grokclassfn'.
6382 QUALS are qualifiers indicating whether the function is `const'
6384 RAISES is a list of exceptions that this function can raise.
6385 CHECK is 1 if we must find this method in CTYPE, 0 if we should
6386 not look, and -1 if we should not call `grokclassfn' at all.
6388 SFK is the kind of special function (if any) for the new function.
6390 Returns `NULL_TREE' if something goes wrong, after issuing
6391 applicable error messages. */
6394 grokfndecl (tree ctype
,
6398 tree orig_declarator
,
6400 enum overload_flags flags
,
6407 special_function_kind sfk
,
6414 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
6418 type
= build_exception_variant (type
, raises
);
6420 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
6421 if (TREE_CODE (type
) == METHOD_TYPE
)
6424 parm
= build_this_parm (type
, quals
);
6425 TREE_CHAIN (parm
) = parms
;
6428 DECL_ARGUMENTS (decl
) = parms
;
6429 /* Propagate volatile out from type to decl. */
6430 if (TYPE_VOLATILE (type
))
6431 TREE_THIS_VOLATILE (decl
) = 1;
6433 /* Setup decl according to sfk. */
6436 case sfk_constructor
:
6437 case sfk_copy_constructor
:
6438 DECL_CONSTRUCTOR_P (decl
) = 1;
6440 case sfk_destructor
:
6441 DECL_DESTRUCTOR_P (decl
) = 1;
6447 /* If pointers to member functions use the least significant bit to
6448 indicate whether a function is virtual, ensure a pointer
6449 to this function will have that bit clear. */
6450 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
6451 && TREE_CODE (type
) == METHOD_TYPE
6452 && DECL_ALIGN (decl
) < 2 * BITS_PER_UNIT
)
6453 DECL_ALIGN (decl
) = 2 * BITS_PER_UNIT
;
6456 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
6460 ("defining explicit specialization %qD in friend declaration",
6464 tree fns
= TREE_OPERAND (orig_declarator
, 0);
6465 tree args
= TREE_OPERAND (orig_declarator
, 1);
6467 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
6469 /* Something like `template <class T> friend void f<T>()'. */
6470 error ("invalid use of template-id %qD in declaration "
6471 "of primary template",
6477 /* A friend declaration of the form friend void f<>(). Record
6478 the information in the TEMPLATE_ID_EXPR. */
6479 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
6481 if (TREE_CODE (fns
) == COMPONENT_REF
)
6483 /* Due to bison parser ickiness, we will have already looked
6484 up an operator_name or PFUNCNAME within the current class
6485 (see template_id in parse.y). If the current class contains
6486 such a name, we'll get a COMPONENT_REF here. Undo that. */
6488 gcc_assert (TREE_TYPE (TREE_OPERAND (fns
, 0))
6489 == current_class_type
);
6490 fns
= TREE_OPERAND (fns
, 1);
6492 gcc_assert (TREE_CODE (fns
) == IDENTIFIER_NODE
6493 || TREE_CODE (fns
) == OVERLOAD
);
6494 DECL_TEMPLATE_INFO (decl
) = tree_cons (fns
, args
, NULL_TREE
);
6496 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
6497 if (TREE_PURPOSE (t
)
6498 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
6500 error ("default arguments are not allowed in declaration "
6501 "of friend template specialization %qD",
6508 error ("%<inline%> is not allowed in declaration of friend "
6509 "template specialization %qD",
6516 /* If this decl has namespace scope, set that up. */
6518 set_decl_namespace (decl
, in_namespace
, friendp
);
6520 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
6522 /* `main' and builtins have implicit 'C' linkage. */
6523 if ((MAIN_NAME_P (declarator
)
6524 || (IDENTIFIER_LENGTH (declarator
) > 10
6525 && IDENTIFIER_POINTER (declarator
)[0] == '_'
6526 && IDENTIFIER_POINTER (declarator
)[1] == '_'
6527 && strncmp (IDENTIFIER_POINTER (declarator
)+2, "builtin_", 8) == 0))
6528 && current_lang_name
== lang_name_cplusplus
6529 && ctype
== NULL_TREE
6530 /* NULL_TREE means global namespace. */
6531 && DECL_CONTEXT (decl
) == NULL_TREE
)
6532 SET_DECL_LANGUAGE (decl
, lang_c
);
6534 /* Should probably propagate const out from type to decl I bet (mrs). */
6537 DECL_STATIC_FUNCTION_P (decl
) = 1;
6538 DECL_CONTEXT (decl
) = ctype
;
6543 DECL_CONTEXT (decl
) = ctype
;
6545 check_class_member_definition_namespace (decl
);
6548 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
6550 if (processing_template_decl
)
6551 error ("cannot declare %<::main%> to be a template");
6553 error ("cannot declare %<::main%> to be inline");
6555 error ("cannot declare %<::main%> to be static");
6560 /* Members of anonymous types and local classes have no linkage; make
6561 them internal. If a typedef is made later, this will be changed. */
6562 if (ctype
&& (TYPE_ANONYMOUS_P (ctype
)
6563 || decl_function_context (TYPE_MAIN_DECL (ctype
))))
6568 /* [basic.link]: A name with no linkage (notably, the name of a class
6569 or enumeration declared in a local scope) shall not be used to
6570 declare an entity with linkage.
6572 Only check this for public decls for now. See core 319, 389. */
6573 t
= no_linkage_check (TREE_TYPE (decl
),
6574 /*relaxed_p=*/false);
6577 if (TYPE_ANONYMOUS_P (t
))
6579 if (DECL_EXTERN_C_P (decl
))
6580 /* Allow this; it's pretty common in C. */;
6583 permerror ("non-local function %q#D uses anonymous type",
6585 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
6586 permerror ("%q+#D does not refer to the unqualified "
6587 "type, so it is not used for linkage",
6592 permerror ("non-local function %q#D uses local type %qT", decl
, t
);
6596 TREE_PUBLIC (decl
) = publicp
;
6599 DECL_INTERFACE_KNOWN (decl
) = 1;
6600 DECL_NOT_REALLY_EXTERN (decl
) = 1;
6603 /* If the declaration was declared inline, mark it as such. */
6605 DECL_DECLARED_INLINE_P (decl
) = 1;
6606 /* We inline functions that are explicitly declared inline, or, when
6607 the user explicitly asks us to, all functions. */
6608 if (DECL_DECLARED_INLINE_P (decl
)
6609 || (flag_inline_trees
== 2 && !DECL_INLINE (decl
) && funcdef_flag
))
6610 DECL_INLINE (decl
) = 1;
6612 DECL_EXTERNAL (decl
) = 1;
6613 if (quals
&& TREE_CODE (type
) == FUNCTION_TYPE
)
6616 ? G_("static member function %qD cannot have cv-qualifier")
6617 : G_("non-member function %qD cannot have cv-qualifier"),
6619 quals
= TYPE_UNQUALIFIED
;
6622 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
))
6623 && !grok_op_properties (decl
, /*complain=*/true))
6626 if (ctype
&& decl_function_context (decl
))
6627 DECL_NO_STATIC_CHAIN (decl
) = 1;
6630 /* Make the init_value nonzero so pushdecl knows this is not
6631 tentative. error_mark_node is replaced later with the BLOCK. */
6632 DECL_INITIAL (decl
) = error_mark_node
;
6634 if (TYPE_NOTHROW_P (type
) || nothrow_libfn_p (decl
))
6635 TREE_NOTHROW (decl
) = 1;
6637 /* Caller will do the rest of this. */
6641 if (ctype
!= NULL_TREE
)
6642 grokclassfn (ctype
, decl
, flags
);
6644 decl
= check_explicit_specialization (orig_declarator
, decl
,
6647 4 * (friendp
!= 0));
6648 if (decl
== error_mark_node
)
6653 cplus_decl_attributes (&decl
, *attrlist
, 0);
6654 *attrlist
= NULL_TREE
;
6657 /* Check main's type after attributes have been applied. */
6658 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
6660 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
6663 tree oldtypeargs
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
6665 error ("%<::main%> must return %<int%>");
6666 newtype
= build_function_type (integer_type_node
, oldtypeargs
);
6667 TREE_TYPE (decl
) = newtype
;
6669 check_main_parameter_types (decl
);
6672 if (ctype
!= NULL_TREE
6673 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
6676 tree old_decl
= check_classfn (ctype
, decl
,
6677 (processing_template_decl
6678 > template_class_depth (ctype
))
6679 ? current_template_parms
6682 if (old_decl
== error_mark_node
)
6690 if (TREE_CODE (old_decl
) == TEMPLATE_DECL
)
6691 /* Because grokfndecl is always supposed to return a
6692 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
6693 here. We depend on our callers to figure out that its
6694 really a template that's being returned. */
6695 old_decl
= DECL_TEMPLATE_RESULT (old_decl
);
6697 if (DECL_STATIC_FUNCTION_P (old_decl
)
6698 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
6699 /* Remove the `this' parm added by grokclassfn.
6700 XXX Isn't this done in start_function, too? */
6701 revert_static_member_fn (decl
);
6702 if (DECL_ARTIFICIAL (old_decl
))
6704 error ("definition of implicitly-declared %qD", old_decl
);
6708 /* Since we've smashed OLD_DECL to its
6709 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
6710 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
6711 decl
= DECL_TEMPLATE_RESULT (decl
);
6713 /* Attempt to merge the declarations. This can fail, in
6714 the case of some invalid specialization declarations. */
6715 pushed_scope
= push_scope (ctype
);
6716 ok
= duplicate_decls (decl
, old_decl
, friendp
);
6718 pop_scope (pushed_scope
);
6721 error ("no %q#D member function declared in class %qT",
6729 if (DECL_CONSTRUCTOR_P (decl
) && !grok_ctor_properties (ctype
, decl
))
6732 if (ctype
== NULL_TREE
|| check
)
6736 DECL_VIRTUAL_P (decl
) = 1;
6741 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
6742 the linkage that DECL will receive in the object file. */
6745 set_linkage_for_static_data_member (tree decl
)
6747 /* A static data member always has static storage duration and
6748 external linkage. Note that static data members are forbidden in
6749 local classes -- the only situation in which a class has
6750 non-external linkage. */
6751 TREE_PUBLIC (decl
) = 1;
6752 TREE_STATIC (decl
) = 1;
6753 /* For non-template classes, static data members are always put
6754 out in exactly those files where they are defined, just as
6755 with ordinary namespace-scope variables. */
6756 if (!processing_template_decl
)
6757 DECL_INTERFACE_KNOWN (decl
) = 1;
6760 /* Create a VAR_DECL named NAME with the indicated TYPE.
6762 If SCOPE is non-NULL, it is the class type or namespace containing
6763 the variable. If SCOPE is NULL, the variable should is created in
6764 the innermost enclosings scope. */
6767 grokvardecl (tree type
,
6769 const cp_decl_specifier_seq
*declspecs
,
6775 tree explicit_scope
;
6777 gcc_assert (!name
|| TREE_CODE (name
) == IDENTIFIER_NODE
);
6779 /* Compute the scope in which to place the variable, but remember
6780 whether or not that scope was explicitly specified by the user. */
6781 explicit_scope
= scope
;
6784 /* An explicit "extern" specifier indicates a namespace-scope
6786 if (declspecs
->storage_class
== sc_extern
)
6787 scope
= current_namespace
;
6788 else if (!at_function_scope_p ())
6789 scope
= current_scope ();
6793 && (/* If the variable is a namespace-scope variable declared in a
6794 template, we need DECL_LANG_SPECIFIC. */
6795 (TREE_CODE (scope
) == NAMESPACE_DECL
&& processing_template_decl
)
6796 /* Similarly for namespace-scope variables with language linkage
6798 || (TREE_CODE (scope
) == NAMESPACE_DECL
6799 && current_lang_name
!= lang_name_cplusplus
)
6800 /* Similarly for static data members. */
6802 decl
= build_lang_decl (VAR_DECL
, name
, type
);
6804 decl
= build_decl (VAR_DECL
, name
, type
);
6806 if (explicit_scope
&& TREE_CODE (explicit_scope
) == NAMESPACE_DECL
)
6807 set_decl_namespace (decl
, explicit_scope
, 0);
6809 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
6811 if (declspecs
->storage_class
== sc_extern
)
6813 DECL_THIS_EXTERN (decl
) = 1;
6814 DECL_EXTERNAL (decl
) = !initialized
;
6817 if (DECL_CLASS_SCOPE_P (decl
))
6819 set_linkage_for_static_data_member (decl
);
6820 /* This function is only called with out-of-class definitions. */
6821 DECL_EXTERNAL (decl
) = 0;
6822 check_class_member_definition_namespace (decl
);
6824 /* At top level, either `static' or no s.c. makes a definition
6825 (perhaps tentative), and absence of `static' makes it public. */
6826 else if (toplevel_bindings_p ())
6828 TREE_PUBLIC (decl
) = (declspecs
->storage_class
!= sc_static
6829 && (DECL_THIS_EXTERN (decl
) || ! constp
));
6830 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
6832 /* Not at top level, only `static' makes a static definition. */
6835 TREE_STATIC (decl
) = declspecs
->storage_class
== sc_static
;
6836 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
6839 if (declspecs
->specs
[(int)ds_thread
])
6840 DECL_TLS_MODEL (decl
) = decl_default_tls_model (decl
);
6842 if (TREE_PUBLIC (decl
))
6844 /* [basic.link]: A name with no linkage (notably, the name of a class
6845 or enumeration declared in a local scope) shall not be used to
6846 declare an entity with linkage.
6848 Only check this for public decls for now. */
6849 tree t
= no_linkage_check (TREE_TYPE (decl
), /*relaxed_p=*/false);
6852 if (TYPE_ANONYMOUS_P (t
))
6854 if (DECL_EXTERN_C_P (decl
))
6855 /* Allow this; it's pretty common in C. */
6859 /* DRs 132, 319 and 389 seem to indicate types with
6860 no linkage can only be used to declare extern "C"
6861 entities. Since it's not always an error in the
6862 ISO C++ 90 Standard, we only issue a warning. */
6863 warning (0, "non-local variable %q#D uses anonymous type",
6865 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
6866 warning (0, "%q+#D does not refer to the unqualified "
6867 "type, so it is not used for linkage",
6872 warning (0, "non-local variable %q#D uses local type %qT", decl
, t
);
6876 DECL_INTERFACE_KNOWN (decl
) = 1;
6881 /* Create and return a canonical pointer to member function type, for
6882 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
6885 build_ptrmemfunc_type (tree type
)
6889 tree unqualified_variant
= NULL_TREE
;
6891 if (type
== error_mark_node
)
6894 /* If a canonical type already exists for this type, use it. We use
6895 this method instead of type_hash_canon, because it only does a
6896 simple equality check on the list of field members. */
6898 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
6901 /* Make sure that we always have the unqualified pointer-to-member
6903 if (cp_type_quals (type
) != TYPE_UNQUALIFIED
)
6905 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type
));
6907 t
= make_class_type (RECORD_TYPE
);
6908 xref_basetypes (t
, NULL_TREE
);
6910 /* Let the front end know this is a pointer to member function... */
6911 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
6912 /* ... and not really a class type. */
6913 SET_CLASS_TYPE_P (t
, 0);
6915 field
= build_decl (FIELD_DECL
, pfn_identifier
, type
);
6918 field
= build_decl (FIELD_DECL
, delta_identifier
, delta_type_node
);
6919 TREE_CHAIN (field
) = fields
;
6922 finish_builtin_struct (t
, "__ptrmemfunc_type", fields
, ptr_type_node
);
6924 /* Zap out the name so that the back end will give us the debugging
6925 information for this anonymous RECORD_TYPE. */
6926 TYPE_NAME (t
) = NULL_TREE
;
6928 /* If this is not the unqualified form of this pointer-to-member
6929 type, set the TYPE_MAIN_VARIANT for this type to be the
6930 unqualified type. Since they are actually RECORD_TYPEs that are
6931 not variants of each other, we must do this manually. */
6932 if (cp_type_quals (type
) != TYPE_UNQUALIFIED
)
6934 t
= build_qualified_type (t
, cp_type_quals (type
));
6935 TYPE_MAIN_VARIANT (t
) = unqualified_variant
;
6936 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (unqualified_variant
);
6937 TYPE_NEXT_VARIANT (unqualified_variant
) = t
;
6940 /* Cache this pointer-to-member type so that we can find it again
6942 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
6944 /* Managing canonical types for the RECORD_TYPE behind a
6945 pointer-to-member function is a nightmare, so use structural
6946 equality for now. */
6947 SET_TYPE_STRUCTURAL_EQUALITY (t
);
6952 /* Create and return a pointer to data member type. */
6955 build_ptrmem_type (tree class_type
, tree member_type
)
6957 if (TREE_CODE (member_type
) == METHOD_TYPE
)
6961 arg_types
= TYPE_ARG_TYPES (member_type
);
6962 class_type
= (cp_build_qualified_type
6964 cp_type_quals (TREE_TYPE (TREE_VALUE (arg_types
)))));
6966 = build_method_type_directly (class_type
,
6967 TREE_TYPE (member_type
),
6968 TREE_CHAIN (arg_types
));
6969 return build_ptrmemfunc_type (build_pointer_type (member_type
));
6973 gcc_assert (TREE_CODE (member_type
) != FUNCTION_TYPE
);
6974 return build_offset_type (class_type
, member_type
);
6978 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
6979 Check to see that the definition is valid. Issue appropriate error
6980 messages. Return 1 if the definition is particularly bad, or 0
6984 check_static_variable_definition (tree decl
, tree type
)
6986 /* Motion 10 at San Diego: If a static const integral data member is
6987 initialized with an integral constant expression, the initializer
6988 may appear either in the declaration (within the class), or in
6989 the definition, but not both. If it appears in the class, the
6990 member is a member constant. The file-scope definition is always
6992 if (!ARITHMETIC_TYPE_P (type
) && TREE_CODE (type
) != ENUMERAL_TYPE
)
6994 error ("invalid in-class initialization of static data member "
6995 "of non-integral type %qT",
6997 /* If we just return the declaration, crashes will sometimes
6998 occur. We therefore return void_type_node, as if this were a
6999 friend declaration, to cause callers to completely ignore
7000 this declaration. */
7003 else if (!CP_TYPE_CONST_P (type
))
7004 error ("ISO C++ forbids in-class initialization of non-const "
7005 "static member %qD",
7007 else if (pedantic
&& !INTEGRAL_TYPE_P (type
))
7008 pedwarn ("ISO C++ forbids initialization of member constant "
7009 "%qD of non-integral type %qT", decl
, type
);
7014 /* Given the SIZE (i.e., number of elements) in an array, compute an
7015 appropriate index type for the array. If non-NULL, NAME is the
7016 name of the thing being declared. */
7019 compute_array_index_type (tree name
, tree size
)
7023 tree abi_1_itype
= NULL_TREE
;
7025 if (error_operand_p (size
))
7026 return error_mark_node
;
7028 type
= TREE_TYPE (size
);
7029 /* The array bound must be an integer type. */
7030 if (!dependent_type_p (type
) && !INTEGRAL_TYPE_P (type
))
7033 error ("size of array %qD has non-integral type %qT", name
, type
);
7035 error ("size of array has non-integral type %qT", type
);
7036 size
= integer_one_node
;
7037 type
= TREE_TYPE (size
);
7040 if (value_dependent_expression_p (size
))
7042 /* We cannot do any checking for a value-dependent SIZE. Just
7043 build the index type and mark that it requires structural
7045 itype
= build_index_type (build_min (MINUS_EXPR
, sizetype
,
7046 size
, integer_one_node
));
7047 SET_TYPE_STRUCTURAL_EQUALITY (itype
);
7051 if (!abi_version_at_least (2) && processing_template_decl
)
7052 /* For abi-1, we handled all instances in templates the same way,
7053 even when they were non-dependent. This effects the manglings
7054 produced. So, we do the normal checking for non-dependent
7055 sizes, but at the end we'll return the same type that abi-1
7056 would have, but with TYPE_CANONICAL set to the "right"
7057 value that the current ABI would provide. */
7058 abi_1_itype
= build_index_type (build_min (MINUS_EXPR
, sizetype
,
7059 size
, integer_one_node
));
7061 /* The size might be the result of a cast. */
7062 STRIP_TYPE_NOPS (size
);
7064 /* It might be a const variable or enumeration constant. */
7065 size
= integral_constant_value (size
);
7067 /* Normally, the array-bound will be a constant. */
7068 if (TREE_CODE (size
) == INTEGER_CST
)
7070 /* Check to see if the array bound overflowed. Make that an
7071 error, no matter how generous we're being. */
7072 constant_expression_error (size
);
7074 /* An array must have a positive number of elements. */
7075 if (INT_CST_LT (size
, integer_zero_node
))
7078 error ("size of array %qD is negative", name
);
7080 error ("size of array is negative");
7081 size
= integer_one_node
;
7083 /* As an extension we allow zero-sized arrays. We always allow
7084 them in system headers because glibc uses them. */
7085 else if (integer_zerop (size
) && pedantic
&& !in_system_header
)
7088 pedwarn ("ISO C++ forbids zero-size array %qD", name
);
7090 pedwarn ("ISO C++ forbids zero-size array");
7093 else if (TREE_CONSTANT (size
))
7095 /* `(int) &fn' is not a valid array bound. */
7097 error ("size of array %qD is not an integral constant-expression",
7100 error ("size of array is not an integral constant-expression");
7101 size
= integer_one_node
;
7103 else if (pedantic
&& warn_vla
!= 0)
7106 pedwarn ("ISO C++ forbids variable length array %qD", name
);
7108 pedwarn ("ISO C++ forbids variable length array");
7110 else if (warn_vla
> 0)
7114 "variable length array %qD is used", name
);
7117 "variable length array is used");
7120 if (processing_template_decl
&& !TREE_CONSTANT (size
))
7121 /* A variable sized array. */
7122 itype
= build_min (MINUS_EXPR
, sizetype
, size
, integer_one_node
);
7125 HOST_WIDE_INT saved_processing_template_decl
;
7127 /* Compute the index of the largest element in the array. It is
7128 one less than the number of elements in the array. We save
7129 and restore PROCESSING_TEMPLATE_DECL so that computations in
7130 cp_build_binary_op will be appropriately folded. */
7131 saved_processing_template_decl
= processing_template_decl
;
7132 processing_template_decl
= 0;
7133 itype
= cp_build_binary_op (MINUS_EXPR
,
7134 cp_convert (ssizetype
, size
),
7135 cp_convert (ssizetype
, integer_one_node
),
7136 tf_warning_or_error
);
7137 itype
= fold (itype
);
7138 processing_template_decl
= saved_processing_template_decl
;
7140 if (!TREE_CONSTANT (itype
))
7141 /* A variable sized array. */
7142 itype
= variable_size (itype
);
7143 /* Make sure that there was no overflow when creating to a signed
7144 index type. (For example, on a 32-bit machine, an array with
7145 size 2^32 - 1 is too big.) */
7146 else if (TREE_CODE (itype
) == INTEGER_CST
7147 && TREE_OVERFLOW (itype
))
7149 error ("overflow in array dimension");
7150 TREE_OVERFLOW (itype
) = 0;
7154 /* Create and return the appropriate index type. */
7157 tree t
= build_index_type (itype
);
7158 TYPE_CANONICAL (abi_1_itype
) = TYPE_CANONICAL (t
);
7162 return build_index_type (itype
);
7165 /* Returns the scope (if any) in which the entity declared by
7166 DECLARATOR will be located. If the entity was declared with an
7167 unqualified name, NULL_TREE is returned. */
7170 get_scope_of_declarator (const cp_declarator
*declarator
)
7172 while (declarator
&& declarator
->kind
!= cdk_id
)
7173 declarator
= declarator
->declarator
;
7175 /* If the declarator-id is a SCOPE_REF, the scope in which the
7176 declaration occurs is the first operand. */
7178 && declarator
->u
.id
.qualifying_scope
)
7179 return declarator
->u
.id
.qualifying_scope
;
7181 /* Otherwise, the declarator is not a qualified name; the entity will
7182 be declared in the current scope. */
7186 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
7187 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
7191 create_array_type_for_decl (tree name
, tree type
, tree size
)
7193 tree itype
= NULL_TREE
;
7194 const char* error_msg
;
7196 /* If things have already gone awry, bail now. */
7197 if (type
== error_mark_node
|| size
== error_mark_node
)
7198 return error_mark_node
;
7200 /* Assume that everything will go OK. */
7203 /* There are some types which cannot be array elements. */
7204 switch (TREE_CODE (type
))
7207 error_msg
= "array of void";
7211 error_msg
= "array of functions";
7214 case REFERENCE_TYPE
:
7215 error_msg
= "array of references";
7219 error_msg
= "array of function members";
7226 /* If something went wrong, issue an error-message and return. */
7230 error ("declaration of %qD as %s", name
, error_msg
);
7232 error ("creating %s", error_msg
);
7234 return error_mark_node
;
7239 The constant expressions that specify the bounds of the arrays
7240 can be omitted only for the first member of the sequence. */
7241 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
7244 error ("declaration of %qD as multidimensional array must "
7245 "have bounds for all dimensions except the first",
7248 error ("multidimensional array must have bounds for all "
7249 "dimensions except the first");
7251 return error_mark_node
;
7254 /* Figure out the index type for the array. */
7256 itype
= compute_array_index_type (name
, size
);
7259 T is called the array element type; this type shall not be [...] an
7260 abstract class type. */
7261 abstract_virtuals_error (name
, type
);
7263 return build_cplus_array_type (type
, itype
);
7266 /* Check that it's OK to declare a function with the indicated TYPE.
7267 SFK indicates the kind of special function (if any) that this
7268 function is. OPTYPE is the type given in a conversion operator
7269 declaration, or the class type for a constructor/destructor.
7270 Returns the actual return type of the function; that
7271 may be different than TYPE if an error occurs, or for certain
7272 special functions. */
7275 check_special_function_return_type (special_function_kind sfk
,
7281 case sfk_constructor
:
7283 error ("return type specification for constructor invalid");
7285 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
7286 type
= build_pointer_type (optype
);
7288 type
= void_type_node
;
7291 case sfk_destructor
:
7293 error ("return type specification for destructor invalid");
7294 /* We can't use the proper return type here because we run into
7295 problems with ambiguous bases and covariant returns.
7296 Java classes are left unchanged because (void *) isn't a valid
7297 Java type, and we don't want to change the Java ABI. */
7298 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
7299 type
= build_pointer_type (void_type_node
);
7301 type
= void_type_node
;
7304 case sfk_conversion
:
7306 error ("return type specified for %<operator %T%>", optype
);
7317 /* A variable or data member (whose unqualified name is IDENTIFIER)
7318 has been declared with the indicated TYPE. If the TYPE is not
7319 acceptable, issue an error message and return a type to use for
7320 error-recovery purposes. */
7323 check_var_type (tree identifier
, tree type
)
7325 if (VOID_TYPE_P (type
))
7328 error ("unnamed variable or field declared void");
7329 else if (TREE_CODE (identifier
) == IDENTIFIER_NODE
)
7331 gcc_assert (!IDENTIFIER_OPNAME_P (identifier
));
7332 error ("variable or field %qE declared void", identifier
);
7335 error ("variable or field declared void");
7336 type
= error_mark_node
;
7342 /* Given declspecs and a declarator (abstract or otherwise), determine
7343 the name and type of the object declared and construct a DECL node
7346 DECLSPECS points to the representation of declaration-specifier
7347 sequence that precedes declarator.
7349 DECL_CONTEXT says which syntactic context this declaration is in:
7350 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
7351 FUNCDEF for a function definition. Like NORMAL but a few different
7352 error messages in each case. Return value may be zero meaning
7353 this definition is too screwy to try to parse.
7354 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
7355 handle member functions (which have FIELD context).
7356 Return value may be zero meaning this definition is too screwy to
7358 PARM for a parameter declaration (either within a function prototype
7359 or before a function body). Make a PARM_DECL, or return void_type_node.
7360 CATCHPARM for a parameter declaration before a catch clause.
7361 TYPENAME if for a typename (in a cast or sizeof).
7362 Don't make a DECL node; just return the ..._TYPE node.
7363 FIELD for a struct or union field; make a FIELD_DECL.
7364 BITFIELD for a field with specified width.
7365 INITIALIZED is 1 if the decl has an initializer.
7367 ATTRLIST is a pointer to the list of attributes, which may be NULL
7368 if there are none; *ATTRLIST may be modified if attributes from inside
7369 the declarator should be applied to the declaration.
7371 When this function is called, scoping variables (such as
7372 CURRENT_CLASS_TYPE) should reflect the scope in which the
7373 declaration occurs, not the scope in which the new declaration will
7374 be placed. For example, on:
7378 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
7381 Returns a DECL (if a declarator is present), a TYPE (if there is no
7382 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
7386 grokdeclarator (const cp_declarator
*declarator
,
7387 const cp_decl_specifier_seq
*declspecs
,
7388 enum decl_context decl_context
,
7392 tree type
= NULL_TREE
;
7394 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
7395 int explicit_int
= 0;
7396 int explicit_char
= 0;
7397 int defaulted_int
= 0;
7398 tree dependent_name
= NULL_TREE
;
7400 tree typedef_decl
= NULL_TREE
;
7401 const char *name
= NULL
;
7402 tree typedef_type
= NULL_TREE
;
7403 /* True if this declarator is a function definition. */
7404 bool funcdef_flag
= false;
7405 cp_declarator_kind innermost_code
= cdk_error
;
7408 /* See the code below that used this. */
7409 tree decl_attr
= NULL_TREE
;
7412 /* Keep track of what sort of function is being processed
7413 so that we can warn about default return values, or explicit
7414 return values which do not match prescribed defaults. */
7415 special_function_kind sfk
= sfk_none
;
7417 tree dname
= NULL_TREE
;
7418 tree ctor_return_type
= NULL_TREE
;
7419 enum overload_flags flags
= NO_SPECIAL
;
7420 /* cv-qualifiers that apply to the declarator, for a declaration of
7421 a member function. */
7422 cp_cv_quals memfn_quals
= TYPE_UNQUALIFIED
;
7423 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
7425 tree raises
= NULL_TREE
;
7426 int template_count
= 0;
7427 tree returned_attrs
= NULL_TREE
;
7428 tree parms
= NULL_TREE
;
7429 const cp_declarator
*id_declarator
;
7430 /* The unqualified name of the declarator; either an
7431 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
7432 tree unqualified_id
;
7433 /* The class type, if any, in which this entity is located,
7434 or NULL_TREE if none. Note that this value may be different from
7435 the current class type; for example if an attempt is made to declare
7436 "A::f" inside "B", this value will be "A". */
7437 tree ctype
= current_class_type
;
7438 /* The NAMESPACE_DECL for the namespace in which this entity is
7439 located. If an unqualified name is used to declare the entity,
7440 this value will be NULL_TREE, even if the entity is located at
7442 tree in_namespace
= NULL_TREE
;
7443 cp_storage_class storage_class
;
7444 bool unsigned_p
, signed_p
, short_p
, long_p
, thread_p
;
7445 bool type_was_error_mark_node
= false;
7446 bool parameter_pack_p
= declarator
? declarator
->parameter_pack_p
: false;
7447 bool set_no_warning
= false;
7449 signed_p
= declspecs
->specs
[(int)ds_signed
];
7450 unsigned_p
= declspecs
->specs
[(int)ds_unsigned
];
7451 short_p
= declspecs
->specs
[(int)ds_short
];
7452 long_p
= declspecs
->specs
[(int)ds_long
];
7453 longlong
= declspecs
->specs
[(int)ds_long
] >= 2;
7454 thread_p
= declspecs
->specs
[(int)ds_thread
];
7456 if (decl_context
== FUNCDEF
)
7457 funcdef_flag
= true, decl_context
= NORMAL
;
7458 else if (decl_context
== MEMFUNCDEF
)
7459 funcdef_flag
= true, decl_context
= FIELD
;
7460 else if (decl_context
== BITFIELD
)
7461 bitfield
= 1, decl_context
= FIELD
;
7463 /* Look inside a declarator for the name being declared
7464 and get it as a string, for an error message. */
7465 for (id_declarator
= declarator
;
7467 id_declarator
= id_declarator
->declarator
)
7469 if (id_declarator
->kind
!= cdk_id
)
7470 innermost_code
= id_declarator
->kind
;
7472 switch (id_declarator
->kind
)
7475 if (id_declarator
->declarator
7476 && id_declarator
->declarator
->kind
== cdk_id
)
7478 sfk
= id_declarator
->declarator
->u
.id
.sfk
;
7479 if (sfk
== sfk_destructor
)
7486 tree qualifying_scope
= id_declarator
->u
.id
.qualifying_scope
;
7487 tree decl
= id_declarator
->u
.id
.unqualified_name
;
7490 if (qualifying_scope
)
7492 if (at_function_scope_p ())
7496 A declarator-id shall not be qualified except
7499 None of the cases are permitted in block
7501 if (qualifying_scope
== global_namespace
)
7502 error ("invalid use of qualified-name %<::%D%>",
7504 else if (TYPE_P (qualifying_scope
))
7505 error ("invalid use of qualified-name %<%T::%D%>",
7506 qualifying_scope
, decl
);
7508 error ("invalid use of qualified-name %<%D::%D%>",
7509 qualifying_scope
, decl
);
7510 return error_mark_node
;
7512 else if (TYPE_P (qualifying_scope
))
7514 ctype
= qualifying_scope
;
7515 if (innermost_code
!= cdk_function
7516 && current_class_type
7517 && !UNIQUELY_DERIVED_FROM_P (ctype
,
7518 current_class_type
))
7520 error ("type %qT is not derived from type %qT",
7521 ctype
, current_class_type
);
7522 return error_mark_node
;
7525 else if (TREE_CODE (qualifying_scope
) == NAMESPACE_DECL
)
7526 in_namespace
= qualifying_scope
;
7528 switch (TREE_CODE (decl
))
7534 if (innermost_code
!= cdk_function
)
7536 error ("declaration of %qD as non-function", decl
);
7537 return error_mark_node
;
7539 else if (!qualifying_scope
7540 && !(current_class_type
&& at_class_scope_p ()))
7542 error ("declaration of %qD as non-member", decl
);
7543 return error_mark_node
;
7546 type
= TREE_OPERAND (decl
, 0);
7547 name
= IDENTIFIER_POINTER (constructor_name (type
));
7552 case TEMPLATE_ID_EXPR
:
7554 tree fns
= TREE_OPERAND (decl
, 0);
7557 if (TREE_CODE (dname
) != IDENTIFIER_NODE
)
7559 gcc_assert (is_overloaded_fn (dname
));
7560 dname
= DECL_NAME (get_first_fn (dname
));
7565 case IDENTIFIER_NODE
:
7566 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
7569 if (C_IS_RESERVED_WORD (dname
))
7571 error ("declarator-id missing; using reserved word %qD",
7573 name
= IDENTIFIER_POINTER (dname
);
7575 else if (!IDENTIFIER_TYPENAME_P (dname
))
7576 name
= IDENTIFIER_POINTER (dname
);
7579 gcc_assert (flags
== NO_SPECIAL
);
7580 flags
= TYPENAME_FLAG
;
7581 ctor_return_type
= TREE_TYPE (dname
);
7582 sfk
= sfk_conversion
;
7583 if (is_typename_at_global_scope (dname
))
7584 name
= IDENTIFIER_POINTER (dname
);
7586 name
= "<invalid operator>";
7603 return error_mark_node
;
7608 if (id_declarator
->kind
== cdk_id
)
7614 The declarator in a function-definition shall have the form
7615 D1 ( parameter-declaration-clause) ... */
7616 if (funcdef_flag
&& innermost_code
!= cdk_function
)
7618 error ("function definition does not declare parameters");
7619 return error_mark_node
;
7622 if (((dname
&& IDENTIFIER_OPNAME_P (dname
)) || flags
== TYPENAME_FLAG
)
7623 && innermost_code
!= cdk_function
7624 && ! (ctype
&& !declspecs
->any_specifiers_p
))
7626 error ("declaration of %qD as non-function", dname
);
7627 return error_mark_node
;
7630 /* Anything declared one level down from the top level
7631 must be one of the parameters of a function
7632 (because the body is at least two levels down). */
7634 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
7635 by not allowing C++ class definitions to specify their parameters
7636 with xdecls (must be spec.d in the parmlist).
7638 Since we now wait to push a class scope until we are sure that
7639 we are in a legitimate method context, we must set oldcname
7640 explicitly (since current_class_name is not yet alive).
7642 We also want to avoid calling this a PARM if it is in a namespace. */
7644 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
7646 struct cp_binding_level
*b
= current_binding_level
;
7647 current_binding_level
= b
->level_chain
;
7648 if (current_binding_level
!= 0 && toplevel_bindings_p ())
7649 decl_context
= PARM
;
7650 current_binding_level
= b
;
7654 name
= decl_context
== PARM
? "parameter" : "type name";
7656 /* If there were multiple types specified in the decl-specifier-seq,
7657 issue an error message. */
7658 if (declspecs
->multiple_types_p
)
7660 error ("two or more data types in declaration of %qs", name
);
7661 return error_mark_node
;
7664 if (declspecs
->conflicting_specifiers_p
)
7666 error ("conflicting specifiers in declaration of %qs", name
);
7667 return error_mark_node
;
7670 /* Extract the basic type from the decl-specifier-seq. */
7671 type
= declspecs
->type
;
7672 if (type
== error_mark_node
)
7675 type_was_error_mark_node
= true;
7677 /* If the entire declaration is itself tagged as deprecated then
7678 suppress reports of deprecated items. */
7679 if (type
&& TREE_DEPRECATED (type
)
7680 && deprecated_state
!= DEPRECATED_SUPPRESS
)
7681 warn_deprecated_use (type
);
7682 if (type
&& TREE_CODE (type
) == TYPE_DECL
)
7684 typedef_decl
= type
;
7685 type
= TREE_TYPE (typedef_decl
);
7686 if (TREE_DEPRECATED (type
)
7687 && DECL_ARTIFICIAL (typedef_decl
)
7688 && deprecated_state
!= DEPRECATED_SUPPRESS
)
7689 warn_deprecated_use (type
);
7691 /* No type at all: default to `int', and set DEFAULTED_INT
7692 because it was not a user-defined typedef. */
7693 if (type
== NULL_TREE
&& (signed_p
|| unsigned_p
|| long_p
|| short_p
))
7695 /* These imply 'int'. */
7696 type
= integer_type_node
;
7700 explicit_int
= declspecs
->explicit_int_p
;
7701 explicit_char
= declspecs
->explicit_char_p
;
7704 /* See the code below that used this. */
7706 decl_attr
= DECL_ATTRIBUTES (typedef_decl
);
7708 typedef_type
= type
;
7711 if (sfk
!= sfk_conversion
)
7712 ctor_return_type
= ctype
;
7714 if (sfk
!= sfk_none
)
7715 type
= check_special_function_return_type (sfk
, type
,
7717 else if (type
== NULL_TREE
)
7723 /* We handle `main' specially here, because 'main () { }' is so
7724 common. With no options, it is allowed. With -Wreturn-type,
7725 it is a warning. It is only an error with -pedantic-errors. */
7726 is_main
= (funcdef_flag
7727 && dname
&& MAIN_NAME_P (dname
)
7728 && ctype
== NULL_TREE
7729 && in_namespace
== NULL_TREE
7730 && current_namespace
== global_namespace
);
7732 if (type_was_error_mark_node
)
7733 /* We've already issued an error, don't complain more. */;
7734 else if (in_system_header
|| flag_ms_extensions
)
7735 /* Allow it, sigh. */;
7737 permerror ("ISO C++ forbids declaration of %qs with no type", name
);
7739 pedwarn ("ISO C++ forbids declaration of %qs with no type", name
);
7741 warning (OPT_Wreturn_type
,
7742 "ISO C++ forbids declaration of %qs with no type", name
);
7744 type
= integer_type_node
;
7749 /* Now process the modifiers that were specified
7750 and check for invalid combinations. */
7752 /* Long double is a special combination. */
7753 if (long_p
&& !longlong
&& TYPE_MAIN_VARIANT (type
) == double_type_node
)
7756 type
= build_qualified_type (long_double_type_node
,
7757 cp_type_quals (type
));
7760 /* Check all other uses of type modifiers. */
7762 if (unsigned_p
|| signed_p
|| long_p
|| short_p
)
7766 if ((signed_p
|| unsigned_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
7767 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
7768 else if (signed_p
&& unsigned_p
)
7769 error ("%<signed%> and %<unsigned%> specified together for %qs", name
);
7770 else if (longlong
&& TREE_CODE (type
) != INTEGER_TYPE
)
7771 error ("%<long long%> invalid for %qs", name
);
7772 else if (long_p
&& TREE_CODE (type
) == REAL_TYPE
)
7773 error ("%<long%> invalid for %qs", name
);
7774 else if (short_p
&& TREE_CODE (type
) == REAL_TYPE
)
7775 error ("%<short%> invalid for %qs", name
);
7776 else if ((long_p
|| short_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
7777 error ("%<long%> or %<short%> invalid for %qs", name
);
7778 else if ((long_p
|| short_p
) && explicit_char
)
7779 error ("%<long%> or %<short%> specified with char for %qs", name
);
7780 else if (long_p
&& short_p
)
7781 error ("%<long%> and %<short%> specified together for %qs", name
);
7782 else if (type
== char16_type_node
|| type
== char32_type_node
)
7784 if (signed_p
|| unsigned_p
)
7785 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
7786 else if (short_p
|| long_p
)
7787 error ("%<short%> or %<long%> invalid for %qs", name
);
7792 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& pedantic
)
7794 pedwarn ("long, short, signed or unsigned used invalidly for %qs",
7796 if (flag_pedantic_errors
)
7801 /* Discard the type modifiers if they are invalid. */
7812 /* Decide whether an integer type is signed or not.
7813 Optionally treat bitfields as signed by default. */
7817 It is implementation-defined whether a plain (neither
7818 explicitly signed or unsigned) char, short, int, or long
7819 bit-field is signed or unsigned.
7821 Naturally, we extend this to long long as well. Note that
7822 this does not include wchar_t. */
7823 || (bitfield
&& !flag_signed_bitfields
7825 /* A typedef for plain `int' without `signed' can be
7826 controlled just like plain `int', but a typedef for
7827 `signed int' cannot be so controlled. */
7829 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
7830 && TREE_CODE (type
) == INTEGER_TYPE
7831 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
7834 type
= long_long_unsigned_type_node
;
7836 type
= long_unsigned_type_node
;
7838 type
= short_unsigned_type_node
;
7839 else if (type
== char_type_node
)
7840 type
= unsigned_char_type_node
;
7841 else if (typedef_decl
)
7842 type
= unsigned_type_for (type
);
7844 type
= unsigned_type_node
;
7846 else if (signed_p
&& type
== char_type_node
)
7847 type
= signed_char_type_node
;
7849 type
= long_long_integer_type_node
;
7851 type
= long_integer_type_node
;
7853 type
= short_integer_type_node
;
7855 if (declspecs
->specs
[(int)ds_complex
])
7857 if (TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
7858 error ("complex invalid for %qs", name
);
7859 /* If we just have "complex", it is equivalent to
7860 "complex double", but if any modifiers at all are specified it is
7861 the complex form of TYPE. E.g, "complex short" is
7862 "complex short int". */
7864 else if (defaulted_int
&& ! longlong
7865 && ! (long_p
|| short_p
|| signed_p
|| unsigned_p
))
7866 type
= complex_double_type_node
;
7867 else if (type
== integer_type_node
)
7868 type
= complex_integer_type_node
;
7869 else if (type
== float_type_node
)
7870 type
= complex_float_type_node
;
7871 else if (type
== double_type_node
)
7872 type
= complex_double_type_node
;
7873 else if (type
== long_double_type_node
)
7874 type
= complex_long_double_type_node
;
7876 type
= build_complex_type (type
);
7879 type_quals
= TYPE_UNQUALIFIED
;
7880 if (declspecs
->specs
[(int)ds_const
])
7881 type_quals
|= TYPE_QUAL_CONST
;
7882 if (declspecs
->specs
[(int)ds_volatile
])
7883 type_quals
|= TYPE_QUAL_VOLATILE
;
7884 if (declspecs
->specs
[(int)ds_restrict
])
7885 type_quals
|= TYPE_QUAL_RESTRICT
;
7886 if (sfk
== sfk_conversion
&& type_quals
!= TYPE_UNQUALIFIED
)
7887 error ("qualifiers are not allowed on declaration of %<operator %T%>",
7890 if (TREE_CODE (type
) == FUNCTION_TYPE
7891 && type_quals
!= TYPE_UNQUALIFIED
)
7893 /* This was an error in C++98 (cv-qualifiers cannot be added to
7894 a function type), but DR 295 makes the code well-formed by
7895 dropping the extra qualifiers. */
7898 tree bad_type
= build_qualified_type (type
, type_quals
);
7899 pedwarn ("ignoring %qV qualifiers added to function type %qT",
7902 type_quals
= TYPE_UNQUALIFIED
;
7904 type_quals
|= cp_type_quals (type
);
7905 type
= cp_build_qualified_type_real
7906 (type
, type_quals
, ((typedef_decl
&& !DECL_ARTIFICIAL (typedef_decl
)
7907 ? tf_ignore_bad_quals
: 0) | tf_warning_or_error
));
7908 /* We might have ignored or rejected some of the qualifiers. */
7909 type_quals
= cp_type_quals (type
);
7912 inlinep
= !! declspecs
->specs
[(int)ds_inline
];
7913 virtualp
= !! declspecs
->specs
[(int)ds_virtual
];
7914 explicitp
= !! declspecs
->specs
[(int)ds_explicit
];
7916 storage_class
= declspecs
->storage_class
;
7917 if (storage_class
== sc_static
)
7918 staticp
= 1 + (decl_context
== FIELD
);
7920 if (virtualp
&& staticp
== 2)
7922 error ("member %qD cannot be declared both virtual and static", dname
);
7923 storage_class
= sc_none
;
7926 friendp
= !! declspecs
->specs
[(int)ds_friend
];
7928 if (dependent_name
&& !friendp
)
7930 error ("%<%T::%D%> is not a valid declarator", ctype
, dependent_name
);
7931 return error_mark_node
;
7934 /* Issue errors about use of storage classes for parameters. */
7935 if (decl_context
== PARM
)
7937 if (declspecs
->specs
[(int)ds_typedef
])
7939 error ("typedef declaration invalid in parameter declaration");
7940 return error_mark_node
;
7942 else if (storage_class
== sc_static
7943 || storage_class
== sc_extern
7945 error ("storage class specifiers invalid in parameter declarations");
7948 /* Give error if `virtual' is used outside of class declaration. */
7950 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
7952 error ("%<virtual%> outside class declaration");
7956 /* Static anonymous unions are dealt with here. */
7957 if (staticp
&& decl_context
== TYPENAME
7959 && ANON_AGGR_TYPE_P (declspecs
->type
))
7960 decl_context
= FIELD
;
7962 /* Warn about storage classes that are invalid for certain
7963 kinds of declarations (parameters, typenames, etc.). */
7966 && storage_class
!= sc_extern
7967 && storage_class
!= sc_static
)
7968 || declspecs
->specs
[(int)ds_typedef
]))
7970 error ("multiple storage classes in declaration of %qs", name
);
7973 if (decl_context
!= NORMAL
7974 && ((storage_class
!= sc_none
7975 && storage_class
!= sc_mutable
)
7978 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
7979 && (storage_class
== sc_register
7980 || storage_class
== sc_auto
))
7982 else if (declspecs
->specs
[(int)ds_typedef
])
7984 else if (decl_context
== FIELD
7985 /* C++ allows static class elements. */
7986 && storage_class
== sc_static
)
7987 /* C++ also allows inlines and signed and unsigned elements,
7988 but in those cases we don't come in here. */
7992 if (decl_context
== FIELD
)
7993 error ("storage class specified for %qs", name
);
7996 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
7997 error ("storage class specified for parameter %qs", name
);
7999 error ("storage class specified for typename");
8001 if (storage_class
== sc_register
8002 || storage_class
== sc_auto
8003 || storage_class
== sc_extern
8005 storage_class
= sc_none
;
8008 else if (storage_class
== sc_extern
&& initialized
8011 if (toplevel_bindings_p ())
8013 /* It's common practice (and completely valid) to have a const
8014 be initialized and declared extern. */
8015 if (!(type_quals
& TYPE_QUAL_CONST
))
8016 warning (0, "%qs initialized and declared %<extern%>", name
);
8019 error ("%qs has both %<extern%> and initializer", name
);
8021 else if (storage_class
== sc_extern
&& funcdef_flag
8022 && ! toplevel_bindings_p ())
8023 error ("nested function %qs declared %<extern%>", name
);
8024 else if (toplevel_bindings_p ())
8026 if (storage_class
== sc_auto
)
8027 error ("top-level declaration of %qs specifies %<auto%>", name
);
8030 && storage_class
!= sc_extern
8031 && storage_class
!= sc_static
)
8033 error ("function-scope %qs implicitly auto and declared %<__thread%>",
8038 if (storage_class
&& friendp
)
8039 error ("storage class specifiers invalid in friend function declarations");
8042 unqualified_id
= NULL_TREE
;
8045 unqualified_id
= id_declarator
->u
.id
.unqualified_name
;
8046 switch (TREE_CODE (unqualified_id
))
8050 = constructor_name (TREE_OPERAND (unqualified_id
, 0));
8053 case IDENTIFIER_NODE
:
8054 case TEMPLATE_ID_EXPR
:
8062 /* Determine the type of the entity declared by recurring on the
8064 for (; declarator
; declarator
= declarator
->declarator
)
8066 const cp_declarator
*inner_declarator
;
8069 if (type
== error_mark_node
)
8070 return error_mark_node
;
8072 attrs
= declarator
->attributes
;
8078 if (declarator
== NULL
|| declarator
->kind
== cdk_id
)
8079 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
8080 if (declarator
->kind
== cdk_function
)
8081 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
8082 if (declarator
->kind
== cdk_array
)
8083 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
8084 returned_attrs
= decl_attributes (&type
,
8085 chainon (returned_attrs
, attrs
),
8089 if (declarator
->kind
== cdk_id
)
8092 inner_declarator
= declarator
->declarator
;
8094 switch (declarator
->kind
)
8097 type
= create_array_type_for_decl (dname
, type
,
8098 declarator
->u
.array
.bounds
);
8106 /* Declaring a function type.
8107 Make sure we have a valid type for the function to return. */
8109 if (type_quals
!= TYPE_UNQUALIFIED
)
8111 if (SCALAR_TYPE_P (type
) || VOID_TYPE_P (type
))
8112 warning (OPT_Wignored_qualifiers
,
8113 "type qualifiers ignored on function return type");
8114 /* We now know that the TYPE_QUALS don't apply to the
8115 decl, but to its return type. */
8116 type_quals
= TYPE_UNQUALIFIED
;
8117 set_no_warning
= true;
8120 /* Error about some types functions can't return. */
8122 if (TREE_CODE (type
) == FUNCTION_TYPE
)
8124 error ("%qs declared as function returning a function", name
);
8125 return error_mark_node
;
8127 if (TREE_CODE (type
) == ARRAY_TYPE
)
8129 error ("%qs declared as function returning an array", name
);
8130 return error_mark_node
;
8133 /* Pick up type qualifiers which should be applied to `this'. */
8134 memfn_quals
= declarator
->u
.function
.qualifiers
;
8136 /* Pick up the exception specifications. */
8137 raises
= declarator
->u
.function
.exception_specification
;
8139 /* Say it's a definition only for the CALL_EXPR
8140 closest to the identifier. */
8141 funcdecl_p
= inner_declarator
&& inner_declarator
->kind
== cdk_id
;
8143 if (ctype
== NULL_TREE
8144 && decl_context
== FIELD
8146 && (friendp
== 0 || dname
== current_class_name
))
8147 ctype
= current_class_type
;
8149 if (ctype
&& (sfk
== sfk_constructor
8150 || sfk
== sfk_destructor
))
8152 /* We are within a class's scope. If our declarator name
8153 is the same as the class name, and we are defining
8154 a function, then it is a constructor/destructor, and
8155 therefore returns a void type. */
8157 /* ISO C++ 12.4/2. A destructor may not be declared
8158 const or volatile. A destructor may not be
8161 ISO C++ 12.1. A constructor may not be declared
8162 const or volatile. A constructor may not be
8163 virtual. A constructor may not be static. */
8165 error ((flags
== DTOR_FLAG
)
8166 ? "destructor cannot be static member function"
8167 : "constructor cannot be static member function");
8170 error ((flags
== DTOR_FLAG
)
8171 ? "destructors may not be cv-qualified"
8172 : "constructors may not be cv-qualified");
8173 memfn_quals
= TYPE_UNQUALIFIED
;
8176 if (decl_context
== FIELD
8177 && !member_function_or_else (ctype
,
8180 return error_mark_node
;
8182 if (flags
!= DTOR_FLAG
)
8184 /* It's a constructor. */
8189 permerror ("constructors cannot be declared virtual");
8192 if (decl_context
== FIELD
8193 && sfk
!= sfk_constructor
)
8194 return error_mark_node
;
8196 if (decl_context
== FIELD
)
8202 error ("can't initialize friend function %qs", name
);
8205 /* Cannot be both friend and virtual. */
8206 error ("virtual functions cannot be friends");
8209 if (decl_context
== NORMAL
)
8210 error ("friend declaration not in class definition");
8211 if (current_function_decl
&& funcdef_flag
)
8212 error ("can't define friend function %qs in a local "
8217 arg_types
= grokparms (declarator
->u
.function
.parameters
,
8220 if (inner_declarator
8221 && inner_declarator
->kind
== cdk_id
8222 && inner_declarator
->u
.id
.sfk
== sfk_destructor
8223 && arg_types
!= void_list_node
)
8225 error ("destructors may not have parameters");
8226 arg_types
= void_list_node
;
8230 type
= build_function_type (type
, arg_types
);
8237 /* Filter out pointers-to-references and references-to-references.
8238 We can get these if a TYPE_DECL is used. */
8240 if (TREE_CODE (type
) == REFERENCE_TYPE
)
8242 if (declarator
->kind
!= cdk_reference
)
8244 error ("cannot declare pointer to %q#T", type
);
8245 type
= TREE_TYPE (type
);
8248 /* In C++0x, we allow reference to reference declarations
8249 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
8250 and template type arguments [14.3.1/4 temp.arg.type]. The
8251 check for direct reference to reference declarations, which
8252 are still forbidden, occurs below. Reasoning behind the change
8253 can be found in DR106, DR540, and the rvalue reference
8255 else if (cxx_dialect
== cxx98
)
8257 error ("cannot declare reference to %q#T", type
);
8258 type
= TREE_TYPE (type
);
8261 else if (VOID_TYPE_P (type
))
8263 if (declarator
->kind
== cdk_reference
)
8264 error ("cannot declare reference to %q#T", type
);
8265 else if (declarator
->kind
== cdk_ptrmem
)
8266 error ("cannot declare pointer to %q#T member", type
);
8269 /* We now know that the TYPE_QUALS don't apply to the decl,
8270 but to the target of the pointer. */
8271 type_quals
= TYPE_UNQUALIFIED
;
8273 if (declarator
->kind
== cdk_ptrmem
8274 && (TREE_CODE (type
) == FUNCTION_TYPE
8275 || (memfn_quals
&& TREE_CODE (type
) == METHOD_TYPE
)))
8277 memfn_quals
|= cp_type_quals (type
);
8278 type
= build_memfn_type (type
,
8279 declarator
->u
.pointer
.class_type
,
8281 memfn_quals
= TYPE_UNQUALIFIED
;
8284 if (declarator
->kind
== cdk_reference
)
8286 /* In C++0x, the type we are creating a reference to might be
8287 a typedef which is itself a reference type. In that case,
8288 we follow the reference collapsing rules in
8289 [7.1.3/8 dcl.typedef] to create the final reference type:
8291 "If a typedef TD names a type that is a reference to a type
8292 T, an attempt to create the type 'lvalue reference to cv TD'
8293 creates the type 'lvalue reference to T,' while an attempt
8294 to create the type "rvalue reference to cv TD' creates the
8297 if (!VOID_TYPE_P (type
))
8298 type
= cp_build_reference_type
8299 ((TREE_CODE (type
) == REFERENCE_TYPE
8300 ? TREE_TYPE (type
) : type
),
8301 (declarator
->u
.reference
.rvalue_ref
8302 && (TREE_CODE(type
) != REFERENCE_TYPE
8303 || TYPE_REF_IS_RVALUE (type
))));
8305 /* In C++0x, we need this check for direct reference to
8306 reference declarations, which are forbidden by
8307 [8.3.2/5 dcl.ref]. Reference to reference declarations
8308 are only allowed indirectly through typedefs and template
8309 type arguments. Example:
8311 void foo(int & &); // invalid ref-to-ref decl
8313 typedef int & int_ref;
8314 void foo(int_ref &); // valid ref-to-ref decl
8316 if (inner_declarator
&& inner_declarator
->kind
== cdk_reference
)
8317 error ("cannot declare reference to %q#T, which is not "
8318 "a typedef or a template type argument", type
);
8320 else if (TREE_CODE (type
) == METHOD_TYPE
)
8321 type
= build_ptrmemfunc_type (build_pointer_type (type
));
8322 else if (declarator
->kind
== cdk_ptrmem
)
8324 gcc_assert (TREE_CODE (declarator
->u
.pointer
.class_type
)
8326 if (declarator
->u
.pointer
.class_type
== error_mark_node
)
8327 /* We will already have complained. */
8328 type
= error_mark_node
;
8330 type
= build_ptrmem_type (declarator
->u
.pointer
.class_type
,
8334 type
= build_pointer_type (type
);
8336 /* Process a list of type modifier keywords (such as
8337 const or volatile) that were given inside the `*' or `&'. */
8339 if (declarator
->u
.pointer
.qualifiers
)
8342 = cp_build_qualified_type (type
,
8343 declarator
->u
.pointer
.qualifiers
);
8344 type_quals
= cp_type_quals (type
);
8357 if (unqualified_id
&& TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
8358 && TREE_CODE (type
) != FUNCTION_TYPE
8359 && TREE_CODE (type
) != METHOD_TYPE
)
8361 error ("template-id %qD used as a declarator",
8363 unqualified_id
= dname
;
8366 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
8367 qualified with a class-name, turn it into a METHOD_TYPE, unless
8368 we know that the function is static. We take advantage of this
8369 opportunity to do other processing that pertains to entities
8370 explicitly declared to be class members. Note that if DECLARATOR
8371 is non-NULL, we know it is a cdk_id declarator; otherwise, we
8372 would not have exited the loop above. */
8374 && declarator
->u
.id
.qualifying_scope
8375 && TYPE_P (declarator
->u
.id
.qualifying_scope
))
8379 ctype
= declarator
->u
.id
.qualifying_scope
;
8380 ctype
= TYPE_MAIN_VARIANT (ctype
);
8382 while (t
!= NULL_TREE
&& CLASS_TYPE_P (t
))
8384 /* You're supposed to have one `template <...>' for every
8385 template class, but you don't need one for a full
8386 specialization. For example:
8388 template <class T> struct S{};
8389 template <> struct S<int> { void f(); };
8390 void S<int>::f () {}
8392 is correct; there shouldn't be a `template <>' for the
8393 definition of `S<int>::f'. */
8394 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
)
8395 && !any_dependent_template_arguments_p (CLASSTYPE_TI_ARGS (t
)))
8396 /* T is an explicit (not partial) specialization. All
8397 containing classes must therefore also be explicitly
8400 if ((CLASSTYPE_USE_TEMPLATE (t
) || CLASSTYPE_IS_TEMPLATE (t
))
8401 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)))
8402 template_count
+= 1;
8404 t
= TYPE_MAIN_DECL (t
);
8405 t
= DECL_CONTEXT (t
);
8408 if (ctype
== current_class_type
)
8412 permerror ("member functions are implicitly friends of their class");
8416 permerror ("extra qualification %<%T::%> on member %qs",
8419 else if (/* If the qualifying type is already complete, then we
8420 can skip the following checks. */
8421 !COMPLETE_TYPE_P (ctype
)
8422 && (/* If the function is being defined, then
8423 qualifying type must certainly be complete. */
8425 /* A friend declaration of "T::f" is OK, even if
8426 "T" is a template parameter. But, if this
8427 function is not a friend, the qualifying type
8429 || (!friendp
&& !CLASS_TYPE_P (ctype
))
8430 /* For a declaration, the type need not be
8431 complete, if either it is dependent (since there
8432 is no meaningful definition of complete in that
8433 case) or the qualifying class is currently being
8435 || !(dependent_type_p (ctype
)
8436 || currently_open_class (ctype
)))
8437 /* Check that the qualifying type is complete. */
8438 && !complete_type_or_else (ctype
, NULL_TREE
))
8439 return error_mark_node
;
8440 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
8442 tree sname
= declarator
->u
.id
.unqualified_name
;
8444 if (current_class_type
8445 && (!friendp
|| funcdef_flag
))
8448 ? "cannot define member function %<%T::%s%> within %<%T%>"
8449 : "cannot declare member function %<%T::%s%> within %<%T%>",
8450 ctype
, name
, current_class_type
);
8451 return error_mark_node
;
8454 if (TREE_CODE (sname
) == IDENTIFIER_NODE
8455 && NEW_DELETE_OPNAME_P (sname
))
8456 /* Overloaded operator new and operator delete
8457 are always static functions. */
8460 type
= build_memfn_type (type
, ctype
, memfn_quals
);
8462 else if (declspecs
->specs
[(int)ds_typedef
]
8463 && current_class_type
)
8465 error ("cannot declare member %<%T::%s%> within %qT",
8466 ctype
, name
, current_class_type
);
8467 return error_mark_node
;
8471 /* Now TYPE has the actual type. */
8476 *attrlist
= chainon (returned_attrs
, *attrlist
);
8478 attrlist
= &returned_attrs
;
8481 /* Handle parameter packs. */
8482 if (parameter_pack_p
)
8484 if (decl_context
== PARM
)
8485 /* Turn the type into a pack expansion.*/
8486 type
= make_pack_expansion (type
);
8488 error ("non-parameter %qs cannot be a parameter pack", name
);
8491 /* Did array size calculations overflow? */
8493 if (TREE_CODE (type
) == ARRAY_TYPE
8494 && COMPLETE_TYPE_P (type
)
8495 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
8496 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type
)))
8498 error ("size of array %qs is too large", name
);
8499 /* If we proceed with the array type as it is, we'll eventually
8500 crash in tree_low_cst(). */
8501 type
= error_mark_node
;
8504 if ((decl_context
== FIELD
|| decl_context
== PARM
)
8505 && !processing_template_decl
8506 && variably_modified_type_p (type
, NULL_TREE
))
8508 if (decl_context
== FIELD
)
8509 error ("data member may not have variably modified type %qT", type
);
8511 error ("parameter may not have variably modified type %qT", type
);
8512 type
= error_mark_node
;
8515 if (explicitp
== 1 || (explicitp
&& friendp
))
8517 /* [dcl.fct.spec] The explicit specifier shall only be used in
8518 declarations of constructors within a class definition. */
8519 error ("only declarations of constructors can be %<explicit%>");
8523 if (storage_class
== sc_mutable
)
8525 if (decl_context
!= FIELD
|| friendp
)
8527 error ("non-member %qs cannot be declared %<mutable%>", name
);
8528 storage_class
= sc_none
;
8530 else if (decl_context
== TYPENAME
|| declspecs
->specs
[(int)ds_typedef
])
8532 error ("non-object member %qs cannot be declared %<mutable%>", name
);
8533 storage_class
= sc_none
;
8535 else if (TREE_CODE (type
) == FUNCTION_TYPE
8536 || TREE_CODE (type
) == METHOD_TYPE
)
8538 error ("function %qs cannot be declared %<mutable%>", name
);
8539 storage_class
= sc_none
;
8543 error ("static %qs cannot be declared %<mutable%>", name
);
8544 storage_class
= sc_none
;
8546 else if (type_quals
& TYPE_QUAL_CONST
)
8548 error ("const %qs cannot be declared %<mutable%>", name
);
8549 storage_class
= sc_none
;
8553 /* If this is declaring a typedef name, return a TYPE_DECL. */
8554 if (declspecs
->specs
[(int)ds_typedef
] && decl_context
!= TYPENAME
)
8558 /* Note that the grammar rejects storage classes
8559 in typenames, fields or parameters. */
8560 if (current_lang_name
== lang_name_java
)
8561 TYPE_FOR_JAVA (type
) = 1;
8563 /* This declaration:
8565 typedef void f(int) const;
8567 declares a function type which is not a member of any
8568 particular class, but which is cv-qualified; for
8569 example "f S::*" declares a pointer to a const-qualified
8570 member function of S. We record the cv-qualification in the
8572 if (memfn_quals
&& TREE_CODE (type
) == FUNCTION_TYPE
)
8574 type
= cp_build_qualified_type (type
, memfn_quals
);
8576 /* We have now dealt with these qualifiers. */
8577 memfn_quals
= TYPE_UNQUALIFIED
;
8580 if (decl_context
== FIELD
)
8581 decl
= build_lang_decl (TYPE_DECL
, unqualified_id
, type
);
8583 decl
= build_decl (TYPE_DECL
, unqualified_id
, type
);
8584 if (id_declarator
&& declarator
->u
.id
.qualifying_scope
)
8585 error ("%Jtypedef name may not be a nested-name-specifier", decl
);
8587 if (decl_context
!= FIELD
)
8589 if (!current_function_decl
)
8590 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
8591 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl
)
8592 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
8593 (current_function_decl
)))
8594 /* The TYPE_DECL is "abstract" because there will be
8595 clones of this constructor/destructor, and there will
8596 be copies of this TYPE_DECL generated in those
8598 DECL_ABSTRACT (decl
) = 1;
8600 else if (constructor_name_p (unqualified_id
, current_class_type
))
8601 permerror ("ISO C++ forbids nested type %qD with same name "
8602 "as enclosing class",
8605 /* If the user declares "typedef struct {...} foo" then the
8606 struct will have an anonymous name. Fill that name in now.
8607 Nothing can refer to it, so nothing needs know about the name
8609 if (type
!= error_mark_node
8612 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
8613 && TYPE_ANONYMOUS_P (type
)
8614 && cp_type_quals (type
) == TYPE_UNQUALIFIED
)
8616 tree oldname
= TYPE_NAME (type
);
8619 /* Replace the anonymous name with the real name everywhere. */
8620 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
8621 if (TYPE_NAME (t
) == oldname
)
8622 TYPE_NAME (t
) = decl
;
8624 if (TYPE_LANG_SPECIFIC (type
))
8625 TYPE_WAS_ANONYMOUS (type
) = 1;
8627 /* If this is a typedef within a template class, the nested
8628 type is a (non-primary) template. The name for the
8629 template needs updating as well. */
8630 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
8631 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
8632 = TYPE_IDENTIFIER (type
);
8634 /* FIXME remangle member functions; member functions of a
8635 type with external linkage have external linkage. */
8639 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
8640 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
8642 bad_specifiers (decl
, "type", virtualp
,
8643 memfn_quals
!= TYPE_UNQUALIFIED
,
8644 inlinep
, friendp
, raises
!= NULL_TREE
);
8649 /* Detect the case of an array type of unspecified size
8650 which came, as such, direct from a typedef name.
8651 We must copy the type, so that the array's domain can be
8652 individually set by the object's initializer. */
8654 if (type
&& typedef_type
8655 && TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
8656 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (typedef_type
))
8657 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
8659 /* Detect where we're using a typedef of function type to declare a
8660 function. PARMS will not be set, so we must create it now. */
8662 if (type
== typedef_type
&& TREE_CODE (type
) == FUNCTION_TYPE
)
8664 tree decls
= NULL_TREE
;
8667 for (args
= TYPE_ARG_TYPES (type
); args
; args
= TREE_CHAIN (args
))
8669 tree decl
= cp_build_parm_decl (NULL_TREE
, TREE_VALUE (args
));
8671 TREE_CHAIN (decl
) = decls
;
8675 parms
= nreverse (decls
);
8677 if (decl_context
!= TYPENAME
)
8679 /* A cv-qualifier-seq shall only be part of the function type
8680 for a non-static member function. [8.3.5/4 dcl.fct] */
8681 if (cp_type_quals (type
) != TYPE_UNQUALIFIED
8682 && (current_class_type
== NULL_TREE
|| staticp
) )
8685 ? G_("qualified function types cannot be used to "
8686 "declare static member functions")
8687 : G_("qualified function types cannot be used to "
8688 "declare free functions"));
8689 type
= TYPE_MAIN_VARIANT (type
);
8692 /* The qualifiers on the function type become the qualifiers on
8693 the non-static member function. */
8694 memfn_quals
|= cp_type_quals (type
);
8698 /* If this is a type name (such as, in a cast or sizeof),
8699 compute the type and return it now. */
8701 if (decl_context
== TYPENAME
)
8703 /* Note that the grammar rejects storage classes
8704 in typenames, fields or parameters. */
8705 if (type_quals
!= TYPE_UNQUALIFIED
)
8706 type_quals
= TYPE_UNQUALIFIED
;
8708 /* Special case: "friend class foo" looks like a TYPENAME context. */
8711 if (type_quals
!= TYPE_UNQUALIFIED
)
8713 error ("type qualifiers specified for friend class declaration");
8714 type_quals
= TYPE_UNQUALIFIED
;
8718 error ("%<inline%> specified for friend class declaration");
8724 /* Don't allow friend declaration without a class-key. */
8725 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
8726 permerror ("template parameters cannot be friends");
8727 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
8728 permerror ("friend declaration requires class-key, "
8729 "i.e. %<friend class %T::%D%>",
8730 TYPE_CONTEXT (type
), TYPENAME_TYPE_FULLNAME (type
));
8732 permerror ("friend declaration requires class-key, "
8733 "i.e. %<friend %#T%>",
8737 /* Only try to do this stuff if we didn't already give up. */
8738 if (type
!= integer_type_node
)
8740 /* A friendly class? */
8741 if (current_class_type
)
8742 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
),
8745 error ("trying to make class %qT a friend of global scope",
8748 type
= void_type_node
;
8751 else if (memfn_quals
)
8753 if (ctype
== NULL_TREE
)
8755 if (TREE_CODE (type
) != METHOD_TYPE
)
8756 error ("invalid qualifiers on non-member function type");
8758 ctype
= TYPE_METHOD_BASETYPE (type
);
8761 type
= build_memfn_type (type
, ctype
, memfn_quals
);
8766 else if (unqualified_id
== NULL_TREE
&& decl_context
!= PARM
8767 && decl_context
!= CATCHPARM
8768 && TREE_CODE (type
) != UNION_TYPE
8771 error ("abstract declarator %qT used as declaration", type
);
8772 return error_mark_node
;
8775 /* Only functions may be declared using an operator-function-id. */
8777 && IDENTIFIER_OPNAME_P (unqualified_id
)
8778 && TREE_CODE (type
) != FUNCTION_TYPE
8779 && TREE_CODE (type
) != METHOD_TYPE
)
8781 error ("declaration of %qD as non-function", unqualified_id
);
8782 return error_mark_node
;
8785 /* We don't check parameter types here because we can emit a better
8786 error message later. */
8787 if (decl_context
!= PARM
)
8789 type
= check_var_type (unqualified_id
, type
);
8790 if (type
== error_mark_node
)
8791 return error_mark_node
;
8794 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
8795 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
8797 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
8799 if (ctype
|| in_namespace
)
8800 error ("cannot use %<::%> in parameter declaration");
8802 /* A parameter declared as an array of T is really a pointer to T.
8803 One declared as a function is really a pointer to a function.
8804 One declared as a member is really a pointer to member. */
8806 if (TREE_CODE (type
) == ARRAY_TYPE
)
8808 /* Transfer const-ness of array into that of type pointed to. */
8809 type
= build_pointer_type (TREE_TYPE (type
));
8810 type_quals
= TYPE_UNQUALIFIED
;
8812 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
8813 type
= build_pointer_type (type
);
8819 if (decl_context
== PARM
)
8821 decl
= cp_build_parm_decl (unqualified_id
, type
);
8823 bad_specifiers (decl
, "parameter", virtualp
,
8824 memfn_quals
!= TYPE_UNQUALIFIED
,
8825 inlinep
, friendp
, raises
!= NULL_TREE
);
8827 else if (decl_context
== FIELD
)
8829 /* The C99 flexible array extension. */
8830 if (!staticp
&& TREE_CODE (type
) == ARRAY_TYPE
8831 && TYPE_DOMAIN (type
) == NULL_TREE
)
8833 tree itype
= compute_array_index_type (dname
, integer_zero_node
);
8834 type
= build_cplus_array_type (TREE_TYPE (type
), itype
);
8837 if (type
== error_mark_node
)
8839 /* Happens when declaring arrays of sizes which
8840 are error_mark_node, for example. */
8843 else if (in_namespace
&& !friendp
)
8845 /* Something like struct S { int N::j; }; */
8846 error ("invalid use of %<::%>");
8847 return error_mark_node
;
8849 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
8852 tree function_context
;
8856 if (ctype
== NULL_TREE
)
8857 ctype
= current_class_type
;
8859 if (ctype
== NULL_TREE
)
8861 error ("can't make %qD into a method -- not in a class",
8863 return error_mark_node
;
8866 /* ``A union may [ ... ] not [ have ] virtual functions.''
8868 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
8870 error ("function %qD declared virtual inside a union",
8872 return error_mark_node
;
8875 if (NEW_DELETE_OPNAME_P (unqualified_id
))
8879 error ("%qD cannot be declared virtual, since it "
8885 else if (staticp
< 2)
8886 type
= build_memfn_type (type
, ctype
, memfn_quals
);
8889 /* Check that the name used for a destructor makes sense. */
8890 if (sfk
== sfk_destructor
)
8894 gcc_assert (friendp
);
8895 error ("expected qualified name in friend declaration "
8896 "for destructor %qD",
8897 id_declarator
->u
.id
.unqualified_name
);
8898 return error_mark_node
;
8901 if (!same_type_p (TREE_OPERAND
8902 (id_declarator
->u
.id
.unqualified_name
, 0),
8905 error ("declaration of %qD as member of %qT",
8906 id_declarator
->u
.id
.unqualified_name
, ctype
);
8907 return error_mark_node
;
8910 else if (sfk
== sfk_constructor
&& friendp
)
8912 error ("expected qualified name in friend declaration "
8913 "for constructor %qD",
8914 id_declarator
->u
.id
.unqualified_name
);
8915 return error_mark_node
;
8918 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
8919 function_context
= (ctype
!= NULL_TREE
) ?
8920 decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
8921 publicp
= (! friendp
|| ! staticp
)
8922 && function_context
== NULL_TREE
;
8923 decl
= grokfndecl (ctype
, type
,
8924 TREE_CODE (unqualified_id
) != TEMPLATE_ID_EXPR
8925 ? unqualified_id
: dname
,
8928 virtualp
, flags
, memfn_quals
, raises
,
8929 friendp
? -1 : 0, friendp
, publicp
, inlinep
,
8931 funcdef_flag
, template_count
, in_namespace
, attrlist
);
8932 if (decl
== NULL_TREE
)
8933 return error_mark_node
;
8935 /* This clobbers the attrs stored in `decl' from `attrlist'. */
8936 /* The decl and setting of decl_attr is also turned off. */
8937 decl
= build_decl_attribute_variant (decl
, decl_attr
);
8940 /* [class.conv.ctor]
8942 A constructor declared without the function-specifier
8943 explicit that can be called with a single parameter
8944 specifies a conversion from the type of its first
8945 parameter to the type of its class. Such a constructor
8946 is called a converting constructor. */
8948 DECL_NONCONVERTING_P (decl
) = 1;
8949 else if (DECL_CONSTRUCTOR_P (decl
))
8951 /* A constructor with no parms is not a conversion.
8952 Ignore any compiler-added parms. */
8953 tree arg_types
= FUNCTION_FIRST_USER_PARMTYPE (decl
);
8955 if (arg_types
== void_list_node
)
8956 DECL_NONCONVERTING_P (decl
) = 1;
8959 else if (TREE_CODE (type
) == METHOD_TYPE
)
8961 /* We only get here for friend declarations of
8962 members of other classes. */
8963 /* All method decls are public, so tell grokfndecl to set
8964 TREE_PUBLIC, also. */
8965 decl
= grokfndecl (ctype
, type
,
8966 TREE_CODE (unqualified_id
) != TEMPLATE_ID_EXPR
8967 ? unqualified_id
: dname
,
8970 virtualp
, flags
, memfn_quals
, raises
,
8971 friendp
? -1 : 0, friendp
, 1, 0, sfk
,
8972 funcdef_flag
, template_count
, in_namespace
,
8974 if (decl
== NULL_TREE
)
8975 return error_mark_node
;
8977 else if (!staticp
&& !dependent_type_p (type
)
8978 && !COMPLETE_TYPE_P (complete_type (type
))
8979 && (TREE_CODE (type
) != ARRAY_TYPE
|| initialized
== 0))
8982 error ("field %qD has incomplete type", unqualified_id
);
8984 error ("name %qT has incomplete type", type
);
8986 /* If we're instantiating a template, tell them which
8987 instantiation made the field's type be incomplete. */
8988 if (current_class_type
8989 && TYPE_NAME (current_class_type
)
8990 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type
))
8992 && declspecs
->type
== type
)
8993 error (" in instantiation of template %qT",
8994 current_class_type
);
8996 return error_mark_node
;
9002 error ("%qE is neither function nor member function; "
9003 "cannot be declared friend", unqualified_id
);
9011 /* Friends are treated specially. */
9012 if (ctype
== current_class_type
)
9013 ; /* We already issued a permerror. */
9014 else if (decl
&& DECL_NAME (decl
))
9016 if (template_class_depth (current_class_type
) == 0)
9018 decl
= check_explicit_specialization
9019 (unqualified_id
, decl
, template_count
,
9020 2 * funcdef_flag
+ 4);
9021 if (decl
== error_mark_node
)
9022 return error_mark_node
;
9025 decl
= do_friend (ctype
, unqualified_id
, decl
,
9031 return error_mark_node
;
9034 /* Structure field. It may not be a function, except for C++. */
9036 if (decl
== NULL_TREE
)
9042 /* An attempt is being made to initialize a non-static
9043 member. But, from [class.mem]:
9045 4 A member-declarator can contain a
9046 constant-initializer only if it declares a static
9047 member (_class.static_) of integral or enumeration
9048 type, see _class.static.data_.
9050 This used to be relatively common practice, but
9051 the rest of the compiler does not correctly
9052 handle the initialization unless the member is
9053 static so we make it static below. */
9054 permerror ("ISO C++ forbids initialization of member %qD",
9056 permerror ("making %qD static", unqualified_id
);
9060 if (uses_template_parms (type
))
9061 /* We'll check at instantiation time. */
9063 else if (check_static_variable_definition (unqualified_id
,
9065 /* If we just return the declaration, crashes
9066 will sometimes occur. We therefore return
9067 void_type_node, as if this was a friend
9068 declaration, to cause callers to completely
9069 ignore this declaration. */
9070 return error_mark_node
;
9075 /* C++ allows static class members. All other work
9076 for this is done by grokfield. */
9077 decl
= build_lang_decl (VAR_DECL
, unqualified_id
, type
);
9078 set_linkage_for_static_data_member (decl
);
9079 /* Even if there is an in-class initialization, DECL
9080 is considered undefined until an out-of-class
9081 definition is provided. */
9082 DECL_EXTERNAL (decl
) = 1;
9085 DECL_TLS_MODEL (decl
) = decl_default_tls_model (decl
);
9089 decl
= build_decl (FIELD_DECL
, unqualified_id
, type
);
9090 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
9091 if (bitfield
&& !unqualified_id
)
9092 TREE_NO_WARNING (decl
) = 1;
9094 if (storage_class
== sc_mutable
)
9096 DECL_MUTABLE_P (decl
) = 1;
9097 storage_class
= sc_none
;
9101 bad_specifiers (decl
, "field", virtualp
,
9102 memfn_quals
!= TYPE_UNQUALIFIED
,
9103 inlinep
, friendp
, raises
!= NULL_TREE
);
9106 else if (TREE_CODE (type
) == FUNCTION_TYPE
9107 || TREE_CODE (type
) == METHOD_TYPE
)
9112 if (!unqualified_id
)
9113 return error_mark_node
;
9115 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
9116 original_name
= dname
;
9118 original_name
= unqualified_id
;
9120 if (storage_class
== sc_auto
)
9121 error ("storage class %<auto%> invalid for function %qs", name
);
9122 else if (storage_class
== sc_register
)
9123 error ("storage class %<register%> invalid for function %qs", name
);
9125 error ("storage class %<__thread%> invalid for function %qs", name
);
9127 /* Function declaration not at top level.
9128 Storage classes other than `extern' are not allowed
9129 and `extern' makes no difference. */
9130 if (! toplevel_bindings_p ()
9131 && (storage_class
== sc_static
9132 || declspecs
->specs
[(int)ds_inline
])
9135 if (storage_class
== sc_static
)
9136 pedwarn ("%<static%> specified invalid for function %qs "
9137 "declared out of global scope", name
);
9139 pedwarn ("%<inline%> specifier invalid for function %qs "
9140 "declared out of global scope", name
);
9143 if (ctype
== NULL_TREE
)
9147 error ("virtual non-class function %qs", name
);
9151 else if (TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2
9152 && !NEW_DELETE_OPNAME_P (original_name
))
9153 type
= build_method_type_directly (ctype
,
9155 TYPE_ARG_TYPES (type
));
9157 /* Record presence of `static'. */
9158 publicp
= (ctype
!= NULL_TREE
9159 || storage_class
== sc_extern
9160 || storage_class
!= sc_static
);
9162 decl
= grokfndecl (ctype
, type
, original_name
, parms
, unqualified_id
,
9163 virtualp
, flags
, memfn_quals
, raises
,
9165 publicp
, inlinep
, sfk
, funcdef_flag
,
9166 template_count
, in_namespace
, attrlist
);
9167 if (decl
== NULL_TREE
)
9168 return error_mark_node
;
9172 int invalid_static
= 0;
9174 /* Don't allow a static member function in a class, and forbid
9175 declaring main to be static. */
9176 if (TREE_CODE (type
) == METHOD_TYPE
)
9178 permerror ("cannot declare member function %qD to have "
9179 "static linkage", decl
);
9182 else if (current_function_decl
)
9184 /* FIXME need arm citation */
9185 error ("cannot declare static function inside another function");
9192 storage_class
= sc_none
;
9198 /* It's a variable. */
9200 /* An uninitialized decl with `extern' is a reference. */
9201 decl
= grokvardecl (type
, unqualified_id
,
9204 (type_quals
& TYPE_QUAL_CONST
) != 0,
9205 ctype
? ctype
: in_namespace
);
9206 bad_specifiers (decl
, "variable", virtualp
,
9207 memfn_quals
!= TYPE_UNQUALIFIED
,
9208 inlinep
, friendp
, raises
!= NULL_TREE
);
9212 DECL_CONTEXT (decl
) = ctype
;
9215 permerror ("%<static%> may not be used when defining "
9216 "(as opposed to declaring) a static data member");
9218 storage_class
= sc_none
;
9220 if (storage_class
== sc_register
&& TREE_STATIC (decl
))
9222 error ("static member %qD declared %<register%>", decl
);
9223 storage_class
= sc_none
;
9225 if (storage_class
== sc_extern
&& pedantic
)
9227 pedwarn ("cannot explicitly declare member %q#D to have "
9230 storage_class
= sc_none
;
9235 /* Record `register' declaration for warnings on &
9236 and in case doing stupid register allocation. */
9238 if (storage_class
== sc_register
)
9239 DECL_REGISTER (decl
) = 1;
9240 else if (storage_class
== sc_extern
)
9241 DECL_THIS_EXTERN (decl
) = 1;
9242 else if (storage_class
== sc_static
)
9243 DECL_THIS_STATIC (decl
) = 1;
9245 /* Record constancy and volatility on the DECL itself . There's
9246 no need to do this when processing a template; we'll do this
9247 for the instantiated declaration based on the type of DECL. */
9248 if (!processing_template_decl
)
9249 cp_apply_type_quals_to_decl (type_quals
, decl
);
9252 TREE_NO_WARNING (decl
) = 1;
9258 /* Subroutine of start_function. Ensure that each of the parameter
9259 types (as listed in PARMS) is complete, as is required for a
9260 function definition. */
9263 require_complete_types_for_parms (tree parms
)
9265 for (; parms
; parms
= TREE_CHAIN (parms
))
9267 if (dependent_type_p (TREE_TYPE (parms
)))
9269 if (!VOID_TYPE_P (TREE_TYPE (parms
))
9270 && complete_type_or_else (TREE_TYPE (parms
), parms
))
9272 relayout_decl (parms
);
9273 DECL_ARG_TYPE (parms
) = type_passed_as (TREE_TYPE (parms
));
9276 /* grokparms or complete_type_or_else will have already issued
9278 TREE_TYPE (parms
) = error_mark_node
;
9282 /* Returns nonzero if T is a local variable. */
9285 local_variable_p (const_tree t
)
9287 if ((TREE_CODE (t
) == VAR_DECL
9288 /* A VAR_DECL with a context that is a _TYPE is a static data
9290 && !TYPE_P (CP_DECL_CONTEXT (t
))
9291 /* Any other non-local variable must be at namespace scope. */
9292 && !DECL_NAMESPACE_SCOPE_P (t
))
9293 || (TREE_CODE (t
) == PARM_DECL
))
9299 /* Like local_variable_p, but suitable for use as a tree-walking
9303 local_variable_p_walkfn (tree
*tp
, int *walk_subtrees
,
9304 void *data ATTRIBUTE_UNUSED
)
9306 if (local_variable_p (*tp
) && !DECL_ARTIFICIAL (*tp
))
9308 else if (TYPE_P (*tp
))
9315 /* Check that ARG, which is a default-argument expression for a
9316 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
9317 something goes wrong. DECL may also be a _TYPE node, rather than a
9318 DECL, if there is no DECL available. */
9321 check_default_argument (tree decl
, tree arg
)
9326 if (TREE_CODE (arg
) == DEFAULT_ARG
)
9327 /* We get a DEFAULT_ARG when looking at an in-class declaration
9328 with a default argument. Ignore the argument for now; we'll
9329 deal with it after the class is complete. */
9338 decl_type
= TREE_TYPE (decl
);
9340 if (arg
== error_mark_node
9341 || decl
== error_mark_node
9342 || TREE_TYPE (arg
) == error_mark_node
9343 || decl_type
== error_mark_node
)
9344 /* Something already went wrong. There's no need to check
9346 return error_mark_node
;
9348 /* [dcl.fct.default]
9350 A default argument expression is implicitly converted to the
9352 if (!TREE_TYPE (arg
)
9353 || !can_convert_arg (decl_type
, TREE_TYPE (arg
), arg
, LOOKUP_NORMAL
))
9356 error ("default argument for %q#D has type %qT",
9357 decl
, TREE_TYPE (arg
));
9359 error ("default argument for parameter of type %qT has type %qT",
9360 decl_type
, TREE_TYPE (arg
));
9362 return error_mark_node
;
9365 /* [dcl.fct.default]
9367 Local variables shall not be used in default argument
9370 The keyword `this' shall not be used in a default argument of a
9372 var
= cp_walk_tree_without_duplicates (&arg
, local_variable_p_walkfn
, NULL
);
9375 error ("default argument %qE uses local variable %qD", arg
, var
);
9376 return error_mark_node
;
9383 /* Decode the list of parameter types for a function type.
9384 Given the list of things declared inside the parens,
9385 return a list of types.
9387 If this parameter does not end with an ellipsis, we append
9390 *PARMS is set to the chain of PARM_DECLs created. */
9393 grokparms (cp_parameter_declarator
*first_parm
, tree
*parms
)
9395 tree result
= NULL_TREE
;
9396 tree decls
= NULL_TREE
;
9397 int ellipsis
= !first_parm
|| first_parm
->ellipsis_p
;
9398 cp_parameter_declarator
*parm
;
9400 struct pointer_set_t
*unique_decls
= pointer_set_create ();
9402 for (parm
= first_parm
; parm
!= NULL
; parm
= parm
->next
)
9404 tree type
= NULL_TREE
;
9405 tree init
= parm
->default_argument
;
9409 if (parm
== no_parameters
)
9412 attrs
= parm
->decl_specifiers
.attributes
;
9413 parm
->decl_specifiers
.attributes
= NULL_TREE
;
9414 decl
= grokdeclarator (parm
->declarator
, &parm
->decl_specifiers
,
9415 PARM
, init
!= NULL_TREE
, &attrs
);
9416 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
9420 cplus_decl_attributes (&decl
, attrs
, 0);
9422 type
= TREE_TYPE (decl
);
9423 if (VOID_TYPE_P (type
))
9425 if (same_type_p (type
, void_type_node
)
9426 && DECL_SELF_REFERENCE_P (type
)
9427 && !DECL_NAME (decl
) && !result
&& !parm
->next
&& !ellipsis
)
9428 /* this is a parmlist of `(void)', which is ok. */
9430 cxx_incomplete_type_error (decl
, type
);
9431 /* It's not a good idea to actually create parameters of
9432 type `void'; other parts of the compiler assume that a
9433 void type terminates the parameter list. */
9434 type
= error_mark_node
;
9435 TREE_TYPE (decl
) = error_mark_node
;
9438 if (type
!= error_mark_node
9439 && TYPE_FOR_JAVA (type
)
9440 && MAYBE_CLASS_TYPE_P (type
))
9442 error ("parameter %qD has Java class type", decl
);
9443 type
= error_mark_node
;
9444 TREE_TYPE (decl
) = error_mark_node
;
9448 if (type
!= error_mark_node
)
9450 /* Top-level qualifiers on the parameters are
9451 ignored for function types. */
9452 type
= cp_build_qualified_type (type
, 0);
9453 if (TREE_CODE (type
) == METHOD_TYPE
)
9455 error ("parameter %qD invalidly declared method type", decl
);
9456 type
= build_pointer_type (type
);
9457 TREE_TYPE (decl
) = type
;
9459 else if (abstract_virtuals_error (decl
, type
))
9460 any_error
= 1; /* Seems like a good idea. */
9461 else if (POINTER_TYPE_P (type
))
9463 /* [dcl.fct]/6, parameter types cannot contain pointers
9464 (references) to arrays of unknown bound. */
9465 tree t
= TREE_TYPE (type
);
9466 int ptr
= TYPE_PTR_P (type
);
9472 else if (TREE_CODE (t
) != ARRAY_TYPE
)
9474 else if (!TYPE_DOMAIN (t
))
9478 if (TREE_CODE (t
) == ARRAY_TYPE
)
9479 error ("parameter %qD includes %s to array of unknown "
9481 decl
, ptr
? "pointer" : "reference", t
);
9486 else if (init
&& !processing_template_decl
)
9487 init
= check_default_argument (decl
, init
);
9490 if (TREE_CODE (decl
) == PARM_DECL
9491 && FUNCTION_PARAMETER_PACK_P (decl
)
9493 error ("parameter packs must be at the end of the parameter list");
9495 if (DECL_NAME (decl
))
9497 if (pointer_set_contains (unique_decls
, DECL_NAME (decl
)))
9498 error ("multiple parameters named %qE", DECL_NAME (decl
));
9500 pointer_set_insert (unique_decls
, DECL_NAME (decl
));
9503 TREE_CHAIN (decl
) = decls
;
9505 result
= tree_cons (init
, type
, result
);
9507 decls
= nreverse (decls
);
9508 result
= nreverse (result
);
9510 result
= chainon (result
, void_list_node
);
9513 pointer_set_destroy (unique_decls
);
9518 /* D is a constructor or overloaded `operator='.
9520 Let T be the class in which D is declared. Then, this function
9523 -1 if D's is an ill-formed constructor or copy assignment operator
9524 whose first parameter is of type `T'.
9525 0 if D is not a copy constructor or copy assignment
9527 1 if D is a copy constructor or copy assignment operator whose
9528 first parameter is a reference to const qualified T.
9529 2 if D is a copy constructor or copy assignment operator whose
9530 first parameter is a reference to non-const qualified T.
9532 This function can be used as a predicate. Positive values indicate
9533 a copy constructor and nonzero values indicate a copy assignment
9537 copy_fn_p (const_tree d
)
9543 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
9545 if (TREE_CODE (d
) == TEMPLATE_DECL
9546 || (DECL_TEMPLATE_INFO (d
)
9547 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
9548 /* Instantiations of template member functions are never copy
9549 functions. Note that member functions of templated classes are
9550 represented as template functions internally, and we must
9551 accept those as copy functions. */
9554 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
9558 arg_type
= TREE_VALUE (args
);
9559 if (arg_type
== error_mark_node
)
9562 if (TYPE_MAIN_VARIANT (arg_type
) == DECL_CONTEXT (d
))
9564 /* Pass by value copy assignment operator. */
9567 else if (TREE_CODE (arg_type
) == REFERENCE_TYPE
9568 && !TYPE_REF_IS_RVALUE (arg_type
)
9569 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)) == DECL_CONTEXT (d
))
9571 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type
)))
9577 args
= TREE_CHAIN (args
);
9579 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
9580 /* There are more non-optional args. */
9586 /* D is a constructor or overloaded `operator='.
9588 Let T be the class in which D is declared. Then, this function
9589 returns true when D is a move constructor or move assignment
9590 operator, false otherwise. */
9593 move_fn_p (const_tree d
)
9597 bool result
= false;
9599 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
9601 if (cxx_dialect
== cxx98
)
9602 /* There are no move constructors if we are in C++98 mode. */
9605 if (TREE_CODE (d
) == TEMPLATE_DECL
9606 || (DECL_TEMPLATE_INFO (d
)
9607 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
9608 /* Instantiations of template member functions are never copy
9609 functions. Note that member functions of templated classes are
9610 represented as template functions internally, and we must
9611 accept those as copy functions. */
9614 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
9618 arg_type
= TREE_VALUE (args
);
9619 if (arg_type
== error_mark_node
)
9622 if (TREE_CODE (arg_type
) == REFERENCE_TYPE
9623 && TYPE_REF_IS_RVALUE (arg_type
)
9624 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)),
9628 args
= TREE_CHAIN (args
);
9630 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
9631 /* There are more non-optional args. */
9637 /* Remember any special properties of member function DECL. */
9640 grok_special_member_properties (tree decl
)
9644 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
9647 class_type
= DECL_CONTEXT (decl
);
9648 if (DECL_CONSTRUCTOR_P (decl
))
9650 int ctor
= copy_fn_p (decl
);
9652 if (!DECL_ARTIFICIAL (decl
))
9653 TYPE_HAS_USER_CONSTRUCTOR (class_type
) = 1;
9659 A non-template constructor for class X is a copy
9660 constructor if its first parameter is of type X&, const
9661 X&, volatile X& or const volatile X&, and either there
9662 are no other parameters or else all other parameters have
9663 default arguments. */
9664 TYPE_HAS_INIT_REF (class_type
) = 1;
9666 TYPE_HAS_CONST_INIT_REF (class_type
) = 1;
9668 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl
)))
9669 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type
) = 1;
9670 else if (is_list_ctor (decl
))
9671 TYPE_HAS_LIST_CTOR (class_type
) = 1;
9673 else if (DECL_OVERLOADED_OPERATOR_P (decl
) == NOP_EXPR
)
9677 A non-template assignment operator for class X is a copy
9678 assignment operator if its parameter is of type X, X&, const
9679 X&, volatile X& or const volatile X&. */
9681 int assop
= copy_fn_p (decl
);
9685 TYPE_HAS_ASSIGN_REF (class_type
) = 1;
9687 TYPE_HAS_CONST_ASSIGN_REF (class_type
) = 1;
9692 /* Check a constructor DECL has the correct form. Complains
9693 if the class has a constructor of the form X(X). */
9696 grok_ctor_properties (const_tree ctype
, const_tree decl
)
9698 int ctor_parm
= copy_fn_p (decl
);
9704 A declaration of a constructor for a class X is ill-formed if
9705 its first parameter is of type (optionally cv-qualified) X
9706 and either there are no other parameters or else all other
9707 parameters have default arguments.
9709 We *don't* complain about member template instantiations that
9710 have this form, though; they can occur as we try to decide
9711 what constructor to use during overload resolution. Since
9712 overload resolution will never prefer such a constructor to
9713 the non-template copy constructor (which is either explicitly
9714 or implicitly defined), there's no need to worry about their
9715 existence. Theoretically, they should never even be
9716 instantiated, but that's hard to forestall. */
9717 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
9725 /* An operator with this code is unary, but can also be binary. */
9728 ambi_op_p (enum tree_code code
)
9730 return (code
== INDIRECT_REF
9731 || code
== ADDR_EXPR
9732 || code
== UNARY_PLUS_EXPR
9733 || code
== NEGATE_EXPR
9734 || code
== PREINCREMENT_EXPR
9735 || code
== PREDECREMENT_EXPR
);
9738 /* An operator with this name can only be unary. */
9741 unary_op_p (enum tree_code code
)
9743 return (code
== TRUTH_NOT_EXPR
9744 || code
== BIT_NOT_EXPR
9745 || code
== COMPONENT_REF
9746 || code
== TYPE_EXPR
);
9749 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
9750 errors are issued for invalid declarations. */
9753 grok_op_properties (tree decl
, bool complain
)
9755 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
9757 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
9758 tree name
= DECL_NAME (decl
);
9759 enum tree_code operator_code
;
9764 /* Count the number of arguments and check for ellipsis. */
9765 for (argtype
= argtypes
, arity
= 0;
9766 argtype
&& argtype
!= void_list_node
;
9767 argtype
= TREE_CHAIN (argtype
))
9769 ellipsis_p
= !argtype
;
9771 class_type
= DECL_CONTEXT (decl
);
9772 if (class_type
&& !CLASS_TYPE_P (class_type
))
9773 class_type
= NULL_TREE
;
9775 if (DECL_CONV_FN_P (decl
))
9776 operator_code
= TYPE_EXPR
;
9780 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
9781 if (ansi_opname (CODE) == name) \
9783 operator_code = (CODE); \
9786 else if (ansi_assopname (CODE) == name) \
9788 operator_code = (CODE); \
9789 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
9793 #include "operators.def"
9799 gcc_assert (operator_code
!= MAX_TREE_CODES
);
9800 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
9803 switch (operator_code
)
9806 TYPE_HAS_NEW_OPERATOR (class_type
) = 1;
9810 TYPE_GETS_DELETE (class_type
) |= 1;
9814 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type
) = 1;
9817 case VEC_DELETE_EXPR
:
9818 TYPE_GETS_DELETE (class_type
) |= 2;
9825 /* [basic.std.dynamic.allocation]/1:
9827 A program is ill-formed if an allocation function is declared
9828 in a namespace scope other than global scope or declared static
9831 The same also holds true for deallocation functions. */
9832 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
9833 || operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
9835 if (DECL_NAMESPACE_SCOPE_P (decl
))
9837 if (CP_DECL_CONTEXT (decl
) != global_namespace
)
9839 error ("%qD may not be declared within a namespace", decl
);
9842 else if (!TREE_PUBLIC (decl
))
9844 error ("%qD may not be declared as static", decl
);
9850 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
)
9852 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
9853 DECL_IS_OPERATOR_NEW (decl
) = 1;
9855 else if (operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
9856 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
9859 /* An operator function must either be a non-static member function
9860 or have at least one parameter of a class, a reference to a class,
9861 an enumeration, or a reference to an enumeration. 13.4.0.6 */
9862 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
9864 if (operator_code
== TYPE_EXPR
9865 || operator_code
== CALL_EXPR
9866 || operator_code
== COMPONENT_REF
9867 || operator_code
== ARRAY_REF
9868 || operator_code
== NOP_EXPR
)
9870 error ("%qD must be a nonstatic member function", decl
);
9877 if (DECL_STATIC_FUNCTION_P (decl
))
9879 error ("%qD must be either a non-static member "
9880 "function or a non-member function", decl
);
9884 for (p
= argtypes
; p
&& p
!= void_list_node
; p
= TREE_CHAIN (p
))
9886 tree arg
= non_reference (TREE_VALUE (p
));
9887 if (arg
== error_mark_node
)
9890 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
9891 because these checks are performed even on
9892 template functions. */
9893 if (MAYBE_CLASS_TYPE_P (arg
)
9894 || TREE_CODE (arg
) == ENUMERAL_TYPE
)
9898 if (!p
|| p
== void_list_node
)
9901 error ("%qD must have an argument of class or "
9902 "enumerated type", decl
);
9908 /* There are no restrictions on the arguments to an overloaded
9910 if (operator_code
== CALL_EXPR
)
9913 /* Warn about conversion operators that will never be used. */
9914 if (IDENTIFIER_TYPENAME_P (name
)
9915 && ! DECL_TEMPLATE_INFO (decl
)
9917 /* Warn only declaring the function; there is no need to
9918 warn again about out-of-class definitions. */
9919 && class_type
== current_class_type
)
9921 tree t
= TREE_TYPE (name
);
9922 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
9923 const char *what
= 0;
9926 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
9928 if (TREE_CODE (t
) == VOID_TYPE
)
9930 else if (class_type
)
9932 if (t
== class_type
)
9933 what
= "the same type";
9934 /* Don't force t to be complete here. */
9935 else if (MAYBE_CLASS_TYPE_P (t
)
9936 && COMPLETE_TYPE_P (t
)
9937 && DERIVED_FROM_P (t
, class_type
))
9938 what
= "a base class";
9942 warning (OPT_Wconversion
, "conversion to %s%s will never use a type "
9943 "conversion operator",
9944 ref
? "a reference to " : "", what
);
9947 if (operator_code
== COND_EXPR
)
9950 error ("ISO C++ prohibits overloading operator ?:");
9953 else if (ellipsis_p
)
9955 error ("%qD must not have variable number of arguments", decl
);
9958 else if (ambi_op_p (operator_code
))
9961 /* We pick the one-argument operator codes by default, so
9962 we don't have to change anything. */
9964 else if (arity
== 2)
9966 /* If we thought this was a unary operator, we now know
9967 it to be a binary operator. */
9968 switch (operator_code
)
9971 operator_code
= MULT_EXPR
;
9975 operator_code
= BIT_AND_EXPR
;
9978 case UNARY_PLUS_EXPR
:
9979 operator_code
= PLUS_EXPR
;
9983 operator_code
= MINUS_EXPR
;
9986 case PREINCREMENT_EXPR
:
9987 operator_code
= POSTINCREMENT_EXPR
;
9990 case PREDECREMENT_EXPR
:
9991 operator_code
= POSTDECREMENT_EXPR
;
9998 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
10000 if ((operator_code
== POSTINCREMENT_EXPR
10001 || operator_code
== POSTDECREMENT_EXPR
)
10002 && ! processing_template_decl
10003 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)), integer_type_node
))
10006 error ("postfix %qD must take %<int%> as its argument",
10009 error ("postfix %qD must take %<int%> as its second "
10017 error ("%qD must take either zero or one argument", decl
);
10019 error ("%qD must take either one or two arguments", decl
);
10023 /* More Effective C++ rule 6. */
10025 && (operator_code
== POSTINCREMENT_EXPR
10026 || operator_code
== POSTDECREMENT_EXPR
10027 || operator_code
== PREINCREMENT_EXPR
10028 || operator_code
== PREDECREMENT_EXPR
))
10030 tree arg
= TREE_VALUE (argtypes
);
10031 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
10032 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
10033 arg
= TREE_TYPE (arg
);
10034 arg
= TYPE_MAIN_VARIANT (arg
);
10035 if (operator_code
== PREINCREMENT_EXPR
10036 || operator_code
== PREDECREMENT_EXPR
)
10038 if (TREE_CODE (ret
) != REFERENCE_TYPE
10039 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
10041 warning (OPT_Weffc__
, "prefix %qD should return %qT", decl
,
10042 build_reference_type (arg
));
10046 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
10047 warning (OPT_Weffc__
, "postfix %qD should return %qT", decl
, arg
);
10051 else if (unary_op_p (operator_code
))
10056 error ("%qD must take %<void%>", decl
);
10058 error ("%qD must take exactly one argument", decl
);
10062 else /* if (binary_op_p (operator_code)) */
10067 error ("%qD must take exactly one argument", decl
);
10069 error ("%qD must take exactly two arguments", decl
);
10073 /* More Effective C++ rule 7. */
10075 && (operator_code
== TRUTH_ANDIF_EXPR
10076 || operator_code
== TRUTH_ORIF_EXPR
10077 || operator_code
== COMPOUND_EXPR
))
10078 warning (OPT_Weffc__
, "user-defined %qD always evaluates both arguments",
10082 /* Effective C++ rule 23. */
10085 && !DECL_ASSIGNMENT_OPERATOR_P (decl
)
10086 && (operator_code
== PLUS_EXPR
10087 || operator_code
== MINUS_EXPR
10088 || operator_code
== TRUNC_DIV_EXPR
10089 || operator_code
== MULT_EXPR
10090 || operator_code
== TRUNC_MOD_EXPR
)
10091 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
10092 warning (OPT_Weffc__
, "%qD should return by value", decl
);
10094 /* [over.oper]/8 */
10095 for (; argtypes
&& argtypes
!= void_list_node
;
10096 argtypes
= TREE_CHAIN (argtypes
))
10097 if (TREE_PURPOSE (argtypes
))
10099 TREE_PURPOSE (argtypes
) = NULL_TREE
;
10100 if (operator_code
== POSTINCREMENT_EXPR
10101 || operator_code
== POSTDECREMENT_EXPR
)
10104 pedwarn ("%qD cannot have default arguments", decl
);
10108 error ("%qD cannot have default arguments", decl
);
10116 /* Return a string giving the keyword associate with CODE. */
10118 static const char *
10119 tag_name (enum tag_types code
)
10131 case typename_type
:
10134 gcc_unreachable ();
10138 /* Name lookup in an elaborated-type-specifier (after the keyword
10139 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
10140 elaborated-type-specifier is invalid, issue a diagnostic and return
10141 error_mark_node; otherwise, return the *_TYPE to which it referred.
10142 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
10145 check_elaborated_type_specifier (enum tag_types tag_code
,
10147 bool allow_template_p
)
10153 struct S { struct S *p; };
10155 name lookup will find the TYPE_DECL for the implicit "S::S"
10156 typedef. Adjust for that here. */
10157 if (DECL_SELF_REFERENCE_P (decl
))
10158 decl
= TYPE_NAME (TREE_TYPE (decl
));
10160 type
= TREE_TYPE (decl
);
10162 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
10163 is false for this case as well. */
10164 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
10166 error ("using template type parameter %qT after %qs",
10167 type
, tag_name (tag_code
));
10168 return error_mark_node
;
10172 If the identifier resolves to a typedef-name or a template
10173 type-parameter, the elaborated-type-specifier is ill-formed.
10175 In other words, the only legitimate declaration to use in the
10176 elaborated type specifier is the implicit typedef created when
10177 the type is declared. */
10178 else if (!DECL_IMPLICIT_TYPEDEF_P (decl
)
10179 && tag_code
!= typename_type
)
10181 error ("using typedef-name %qD after %qs", decl
, tag_name (tag_code
));
10182 error ("%q+D has a previous declaration here", decl
);
10183 return error_mark_node
;
10185 else if (TREE_CODE (type
) != RECORD_TYPE
10186 && TREE_CODE (type
) != UNION_TYPE
10187 && tag_code
!= enum_type
10188 && tag_code
!= typename_type
)
10190 error ("%qT referred to as %qs", type
, tag_name (tag_code
));
10191 error ("%q+T has a previous declaration here", type
);
10192 return error_mark_node
;
10194 else if (TREE_CODE (type
) != ENUMERAL_TYPE
10195 && tag_code
== enum_type
)
10197 error ("%qT referred to as enum", type
);
10198 error ("%q+T has a previous declaration here", type
);
10199 return error_mark_node
;
10201 else if (!allow_template_p
10202 && TREE_CODE (type
) == RECORD_TYPE
10203 && CLASSTYPE_IS_TEMPLATE (type
))
10205 /* If a class template appears as elaborated type specifier
10206 without a template header such as:
10208 template <class T> class C {};
10209 void f(class C); // No template header here
10211 then the required template argument is missing. */
10212 error ("template argument required for %<%s %T%>",
10213 tag_name (tag_code
),
10214 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
)));
10215 return error_mark_node
;
10221 /* Lookup NAME in elaborate type specifier in scope according to
10222 SCOPE and issue diagnostics if necessary.
10223 Return *_TYPE node upon success, NULL_TREE when the NAME is not
10224 found, and ERROR_MARK_NODE for type error. */
10227 lookup_and_check_tag (enum tag_types tag_code
, tree name
,
10228 tag_scope scope
, bool template_header_p
)
10232 if (scope
== ts_global
)
10234 /* First try ordinary name lookup, ignoring hidden class name
10235 injected via friend declaration. */
10236 decl
= lookup_name_prefer_type (name
, 2);
10237 /* If that fails, the name will be placed in the smallest
10238 non-class, non-function-prototype scope according to 3.3.1/5.
10239 We may already have a hidden name declared as friend in this
10240 scope. So lookup again but not ignoring hidden names.
10241 If we find one, that name will be made visible rather than
10242 creating a new tag. */
10244 decl
= lookup_type_scope (name
, ts_within_enclosing_non_class
);
10247 decl
= lookup_type_scope (name
, scope
);
10249 if (decl
&& DECL_CLASS_TEMPLATE_P (decl
))
10250 decl
= DECL_TEMPLATE_RESULT (decl
);
10252 if (decl
&& TREE_CODE (decl
) == TYPE_DECL
)
10254 /* Look for invalid nested type:
10258 if (scope
== ts_current
&& DECL_SELF_REFERENCE_P (decl
))
10260 error ("%qD has the same name as the class in which it is "
10263 return error_mark_node
;
10266 /* Two cases we need to consider when deciding if a class
10267 template is allowed as an elaborated type specifier:
10268 1. It is a self reference to its own class.
10269 2. It comes with a template header.
10273 template <class T> class C {
10274 class C *c1; // DECL_SELF_REFERENCE_P is true
10277 template <class U> class C; // template_header_p is true
10278 template <class T> class C<T>::D {
10279 class C *c2; // DECL_SELF_REFERENCE_P is true
10282 t
= check_elaborated_type_specifier (tag_code
,
10285 | DECL_SELF_REFERENCE_P (decl
));
10288 else if (decl
&& TREE_CODE (decl
) == TREE_LIST
)
10290 error ("reference to %qD is ambiguous", name
);
10291 print_candidates (decl
);
10292 return error_mark_node
;
10298 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
10299 Define the tag as a forward-reference if it is not defined.
10301 If a declaration is given, process it here, and report an error if
10302 multiple declarations are not identical.
10304 SCOPE is TS_CURRENT when this is also a definition. Only look in
10305 the current frame for the name (since C++ allows new names in any
10306 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
10307 declaration. Only look beginning from the current scope outward up
10308 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
10310 TEMPLATE_HEADER_P is true when this declaration is preceded by
10311 a set of template parameters. */
10314 xref_tag (enum tag_types tag_code
, tree name
,
10315 tag_scope scope
, bool template_header_p
)
10317 enum tree_code code
;
10319 tree context
= NULL_TREE
;
10321 timevar_push (TV_NAME_LOOKUP
);
10323 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
10329 code
= RECORD_TYPE
;
10335 code
= ENUMERAL_TYPE
;
10338 gcc_unreachable ();
10341 /* In case of anonymous name, xref_tag is only called to
10342 make type node and push name. Name lookup is not required. */
10343 if (ANON_AGGRNAME_P (name
))
10346 t
= lookup_and_check_tag (tag_code
, name
,
10347 scope
, template_header_p
);
10349 if (t
== error_mark_node
)
10350 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
10352 if (scope
!= ts_current
&& t
&& current_class_type
10353 && template_class_depth (current_class_type
)
10354 && template_header_p
)
10356 /* Since SCOPE is not TS_CURRENT, we are not looking at a
10357 definition of this tag. Since, in addition, we are currently
10358 processing a (member) template declaration of a template
10359 class, we must be very careful; consider:
10366 { template <class V>
10367 friend struct S1; };
10369 Here, the S2::S1 declaration should not be confused with the
10370 outer declaration. In particular, the inner version should
10371 have a template parameter of level 2, not level 1. This
10372 would be particularly important if the member declaration
10375 template <class V = U> friend struct S1;
10377 say, when we should tsubst into `U' when instantiating
10378 S2. On the other hand, when presented with:
10388 we must find the inner binding eventually. We
10389 accomplish this by making sure that the new type we
10390 create to represent this declaration has the right
10392 context
= TYPE_CONTEXT (t
);
10398 /* If no such tag is yet defined, create a forward-reference node
10399 and record it as the "definition".
10400 When a real declaration of this type is found,
10401 the forward-reference will be altered into a real type. */
10402 if (code
== ENUMERAL_TYPE
)
10404 error ("use of enum %q#D without previous declaration", name
);
10405 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
10409 t
= make_class_type (code
);
10410 TYPE_CONTEXT (t
) = context
;
10411 t
= pushtag (name
, t
, scope
);
10416 if (template_header_p
&& MAYBE_CLASS_TYPE_P (t
))
10418 if (!redeclare_class_template (t
, current_template_parms
))
10419 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
10421 else if (!processing_template_decl
10422 && CLASS_TYPE_P (t
)
10423 && CLASSTYPE_IS_TEMPLATE (t
))
10425 error ("redeclaration of %qT as a non-template", t
);
10426 error ("previous declaration %q+D", t
);
10427 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
10430 /* Make injected friend class visible. */
10431 if (scope
!= ts_within_enclosing_non_class
10432 && hidden_name_p (TYPE_NAME (t
)))
10434 DECL_ANTICIPATED (TYPE_NAME (t
)) = 0;
10435 DECL_FRIEND_P (TYPE_NAME (t
)) = 0;
10437 if (TYPE_TEMPLATE_INFO (t
))
10439 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t
)) = 0;
10440 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t
)) = 0;
10445 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
10449 xref_tag_from_type (tree old
, tree id
, tag_scope scope
)
10451 enum tag_types tag_kind
;
10453 if (TREE_CODE (old
) == RECORD_TYPE
)
10454 tag_kind
= (CLASSTYPE_DECLARED_CLASS (old
) ? class_type
: record_type
);
10456 tag_kind
= union_type
;
10458 if (id
== NULL_TREE
)
10459 id
= TYPE_IDENTIFIER (old
);
10461 return xref_tag (tag_kind
, id
, scope
, false);
10464 /* Create the binfo hierarchy for REF with (possibly NULL) base list
10465 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
10466 access_* node, and the TREE_VALUE is the type of the base-class.
10467 Non-NULL TREE_TYPE indicates virtual inheritance.
10469 Returns true if the binfo hierarchy was successfully created,
10470 false if an error was detected. */
10473 xref_basetypes (tree ref
, tree base_list
)
10476 tree binfo
, base_binfo
;
10477 unsigned max_vbases
= 0; /* Maximum direct & indirect virtual bases. */
10478 unsigned max_bases
= 0; /* Maximum direct bases. */
10480 tree default_access
;
10481 tree igo_prev
; /* Track Inheritance Graph Order. */
10483 if (ref
== error_mark_node
)
10486 /* The base of a derived class is private by default, all others are
10488 default_access
= (TREE_CODE (ref
) == RECORD_TYPE
10489 && CLASSTYPE_DECLARED_CLASS (ref
)
10490 ? access_private_node
: access_public_node
);
10492 /* First, make sure that any templates in base-classes are
10493 instantiated. This ensures that if we call ourselves recursively
10494 we do not get confused about which classes are marked and which
10496 basep
= &base_list
;
10499 tree basetype
= TREE_VALUE (*basep
);
10501 if (!(processing_template_decl
&& uses_template_parms (basetype
))
10502 && !complete_type_or_else (basetype
, NULL
))
10503 /* An incomplete type. Remove it from the list. */
10504 *basep
= TREE_CHAIN (*basep
);
10508 if (TREE_TYPE (*basep
))
10510 if (CLASS_TYPE_P (basetype
))
10511 max_vbases
+= VEC_length (tree
, CLASSTYPE_VBASECLASSES (basetype
));
10512 basep
= &TREE_CHAIN (*basep
);
10516 TYPE_MARKED_P (ref
) = 1;
10518 /* The binfo slot should be empty, unless this is an (ill-formed)
10520 gcc_assert (!TYPE_BINFO (ref
) || TYPE_SIZE (ref
));
10521 gcc_assert (TYPE_MAIN_VARIANT (ref
) == ref
);
10523 binfo
= make_tree_binfo (max_bases
);
10525 TYPE_BINFO (ref
) = binfo
;
10526 BINFO_OFFSET (binfo
) = size_zero_node
;
10527 BINFO_TYPE (binfo
) = ref
;
10531 BINFO_BASE_ACCESSES (binfo
) = VEC_alloc (tree
, gc
, max_bases
);
10532 /* An aggregate cannot have baseclasses. */
10533 CLASSTYPE_NON_AGGREGATE (ref
) = 1;
10535 if (TREE_CODE (ref
) == UNION_TYPE
)
10537 error ("derived union %qT invalid", ref
);
10544 if (TYPE_FOR_JAVA (ref
))
10546 error ("Java class %qT cannot have multiple bases", ref
);
10553 CLASSTYPE_VBASECLASSES (ref
) = VEC_alloc (tree
, gc
, max_vbases
);
10555 if (TYPE_FOR_JAVA (ref
))
10557 error ("Java class %qT cannot have virtual bases", ref
);
10562 for (igo_prev
= binfo
; base_list
; base_list
= TREE_CHAIN (base_list
))
10564 tree access
= TREE_PURPOSE (base_list
);
10565 int via_virtual
= TREE_TYPE (base_list
) != NULL_TREE
;
10566 tree basetype
= TREE_VALUE (base_list
);
10568 if (access
== access_default_node
)
10569 access
= default_access
;
10571 if (PACK_EXPANSION_P (basetype
))
10572 basetype
= PACK_EXPANSION_PATTERN (basetype
);
10573 if (TREE_CODE (basetype
) == TYPE_DECL
)
10574 basetype
= TREE_TYPE (basetype
);
10575 if (TREE_CODE (basetype
) != RECORD_TYPE
10576 && TREE_CODE (basetype
) != TYPENAME_TYPE
10577 && TREE_CODE (basetype
) != TEMPLATE_TYPE_PARM
10578 && TREE_CODE (basetype
) != BOUND_TEMPLATE_TEMPLATE_PARM
)
10580 error ("base type %qT fails to be a struct or class type",
10585 if (TYPE_FOR_JAVA (basetype
) && (current_lang_depth () == 0))
10586 TYPE_FOR_JAVA (ref
) = 1;
10588 base_binfo
= NULL_TREE
;
10589 if (CLASS_TYPE_P (basetype
) && !dependent_type_p (basetype
))
10591 base_binfo
= TYPE_BINFO (basetype
);
10592 /* The original basetype could have been a typedef'd type. */
10593 basetype
= BINFO_TYPE (base_binfo
);
10595 /* Inherit flags from the base. */
10596 TYPE_HAS_NEW_OPERATOR (ref
)
10597 |= TYPE_HAS_NEW_OPERATOR (basetype
);
10598 TYPE_HAS_ARRAY_NEW_OPERATOR (ref
)
10599 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype
);
10600 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
10601 TYPE_HAS_CONVERSION (ref
) |= TYPE_HAS_CONVERSION (basetype
);
10602 CLASSTYPE_DIAMOND_SHAPED_P (ref
)
10603 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype
);
10604 CLASSTYPE_REPEATED_BASE_P (ref
)
10605 |= CLASSTYPE_REPEATED_BASE_P (basetype
);
10608 /* We must do this test after we've seen through a typedef
10610 if (TYPE_MARKED_P (basetype
))
10612 if (basetype
== ref
)
10613 error ("recursive type %qT undefined", basetype
);
10615 error ("duplicate base type %qT invalid", basetype
);
10619 if (PACK_EXPANSION_P (TREE_VALUE (base_list
)))
10620 /* Regenerate the pack expansion for the bases. */
10621 basetype
= make_pack_expansion (basetype
);
10623 TYPE_MARKED_P (basetype
) = 1;
10625 base_binfo
= copy_binfo (base_binfo
, basetype
, ref
,
10626 &igo_prev
, via_virtual
);
10627 if (!BINFO_INHERITANCE_CHAIN (base_binfo
))
10628 BINFO_INHERITANCE_CHAIN (base_binfo
) = binfo
;
10630 BINFO_BASE_APPEND (binfo
, base_binfo
);
10631 BINFO_BASE_ACCESS_APPEND (binfo
, access
);
10634 if (VEC_space (tree
, CLASSTYPE_VBASECLASSES (ref
), 1))
10635 /* If we have space in the vbase vector, we must have shared at
10636 least one of them, and are therefore diamond shaped. */
10637 CLASSTYPE_DIAMOND_SHAPED_P (ref
) = 1;
10639 /* Unmark all the types. */
10640 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
10641 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
10642 TYPE_MARKED_P (ref
) = 0;
10644 /* Now see if we have a repeated base type. */
10645 if (!CLASSTYPE_REPEATED_BASE_P (ref
))
10647 for (base_binfo
= binfo
; base_binfo
;
10648 base_binfo
= TREE_CHAIN (base_binfo
))
10650 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
10652 CLASSTYPE_REPEATED_BASE_P (ref
) = 1;
10655 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 1;
10657 for (base_binfo
= binfo
; base_binfo
;
10658 base_binfo
= TREE_CHAIN (base_binfo
))
10659 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
10660 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
10669 /* Begin compiling the definition of an enumeration type.
10671 Returns the type object, as yet incomplete.
10672 Also records info about it so that build_enumerator
10673 may be used to declare the individual values as they are read. */
10676 start_enum (tree name
)
10680 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
10682 /* If this is the real definition for a previous forward reference,
10683 fill in the contents in the same object that used to be the
10684 forward reference. */
10686 enumtype
= lookup_and_check_tag (enum_type
, name
,
10687 /*tag_scope=*/ts_current
,
10688 /*template_header_p=*/false);
10690 if (enumtype
!= NULL_TREE
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
10692 error ("multiple definition of %q#T", enumtype
);
10693 error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype
));
10694 /* Clear out TYPE_VALUES, and start again. */
10695 TYPE_VALUES (enumtype
) = NULL_TREE
;
10699 /* In case of error, make a dummy enum to allow parsing to
10701 if (enumtype
== error_mark_node
)
10702 name
= make_anon_name ();
10704 enumtype
= make_node (ENUMERAL_TYPE
);
10705 enumtype
= pushtag (name
, enumtype
, /*tag_scope=*/ts_current
);
10711 /* After processing and defining all the values of an enumeration type,
10712 install their decls in the enumeration type and finish it off.
10713 ENUMTYPE is the type object and VALUES a list of name-value pairs. */
10716 finish_enum (tree enumtype
)
10725 bool use_short_enum
;
10729 integer_type_kind itk
;
10730 tree underlying_type
= NULL_TREE
;
10732 /* We built up the VALUES in reverse order. */
10733 TYPE_VALUES (enumtype
) = nreverse (TYPE_VALUES (enumtype
));
10735 /* For an enum defined in a template, just set the type of the values;
10736 all further processing is postponed until the template is
10737 instantiated. We need to set the type so that tsubst of a CONST_DECL
10739 if (processing_template_decl
)
10741 for (values
= TYPE_VALUES (enumtype
);
10743 values
= TREE_CHAIN (values
))
10744 TREE_TYPE (TREE_VALUE (values
)) = enumtype
;
10745 if (at_function_scope_p ())
10746 add_stmt (build_min (TAG_DEFN
, enumtype
));
10750 /* Determine the minimum and maximum values of the enumerators. */
10751 if (TYPE_VALUES (enumtype
))
10753 minnode
= maxnode
= NULL_TREE
;
10755 for (values
= TYPE_VALUES (enumtype
);
10757 values
= TREE_CHAIN (values
))
10759 decl
= TREE_VALUE (values
);
10761 /* [dcl.enum]: Following the closing brace of an enum-specifier,
10762 each enumerator has the type of its enumeration. Prior to the
10763 closing brace, the type of each enumerator is the type of its
10764 initializing value. */
10765 TREE_TYPE (decl
) = enumtype
;
10767 /* Update the minimum and maximum values, if appropriate. */
10768 value
= DECL_INITIAL (decl
);
10769 if (value
== error_mark_node
)
10770 value
= integer_zero_node
;
10771 /* Figure out what the minimum and maximum values of the
10772 enumerators are. */
10774 minnode
= maxnode
= value
;
10775 else if (tree_int_cst_lt (maxnode
, value
))
10777 else if (tree_int_cst_lt (value
, minnode
))
10784 If the enumerator-list is empty, the underlying type is as if
10785 the enumeration had a single enumerator with value 0. */
10786 minnode
= maxnode
= integer_zero_node
;
10788 /* Compute the number of bits require to represent all values of the
10789 enumeration. We must do this before the type of MINNODE and
10790 MAXNODE are transformed, since min_precision relies on the
10791 TREE_TYPE of the value it is passed. */
10792 unsignedp
= tree_int_cst_sgn (minnode
) >= 0;
10793 lowprec
= min_precision (minnode
, unsignedp
);
10794 highprec
= min_precision (maxnode
, unsignedp
);
10795 precision
= MAX (lowprec
, highprec
);
10797 /* Determine the underlying type of the enumeration.
10801 The underlying type of an enumeration is an integral type that
10802 can represent all the enumerator values defined in the
10803 enumeration. It is implementation-defined which integral type is
10804 used as the underlying type for an enumeration except that the
10805 underlying type shall not be larger than int unless the value of
10806 an enumerator cannot fit in an int or unsigned int.
10808 We use "int" or an "unsigned int" as the underlying type, even if
10809 a smaller integral type would work, unless the user has
10810 explicitly requested that we use the smallest possible type. The
10811 user can request that for all enumerations with a command line
10812 flag, or for just one enumeration with an attribute. */
10814 use_short_enum
= flag_short_enums
10815 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype
));
10817 for (itk
= (use_short_enum
? itk_char
: itk_int
);
10821 underlying_type
= integer_types
[itk
];
10822 if (TYPE_PRECISION (underlying_type
) >= precision
10823 && TYPE_UNSIGNED (underlying_type
) == unsignedp
)
10826 if (itk
== itk_none
)
10830 IF no integral type can represent all the enumerator values, the
10831 enumeration is ill-formed. */
10832 error ("no integral type can represent all of the enumerator values "
10833 "for %qT", enumtype
);
10834 precision
= TYPE_PRECISION (long_long_integer_type_node
);
10835 underlying_type
= integer_types
[itk_unsigned_long_long
];
10838 /* Compute the minium and maximum values for the type.
10842 For an enumeration where emin is the smallest enumerator and emax
10843 is the largest, the values of the enumeration are the values of the
10844 underlying type in the range bmin to bmax, where bmin and bmax are,
10845 respectively, the smallest and largest values of the smallest bit-
10846 field that can store emin and emax. */
10848 /* The middle-end currently assumes that types with TYPE_PRECISION
10849 narrower than their underlying type are suitably zero or sign
10850 extended to fill their mode. g++ doesn't make these guarantees.
10851 Until the middle-end can represent such paradoxical types, we
10852 set the TYPE_PRECISION to the width of the underlying type. */
10853 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (underlying_type
);
10855 set_min_and_max_values_for_integral_type (enumtype
, precision
, unsignedp
);
10859 The value of sizeof() applied to an enumeration type, an object
10860 of an enumeration type, or an enumerator, is the value of sizeof()
10861 applied to the underlying type. */
10862 TYPE_SIZE (enumtype
) = TYPE_SIZE (underlying_type
);
10863 TYPE_SIZE_UNIT (enumtype
) = TYPE_SIZE_UNIT (underlying_type
);
10864 TYPE_MODE (enumtype
) = TYPE_MODE (underlying_type
);
10865 TYPE_ALIGN (enumtype
) = TYPE_ALIGN (underlying_type
);
10866 TYPE_USER_ALIGN (enumtype
) = TYPE_USER_ALIGN (underlying_type
);
10867 TYPE_UNSIGNED (enumtype
) = TYPE_UNSIGNED (underlying_type
);
10869 /* Convert each of the enumerators to the type of the underlying
10870 type of the enumeration. */
10871 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
10873 location_t saved_location
;
10875 decl
= TREE_VALUE (values
);
10876 saved_location
= input_location
;
10877 input_location
= DECL_SOURCE_LOCATION (decl
);
10878 value
= perform_implicit_conversion (underlying_type
,
10879 DECL_INITIAL (decl
),
10880 tf_warning_or_error
);
10881 input_location
= saved_location
;
10883 /* Do not clobber shared ints. */
10884 value
= copy_node (value
);
10886 TREE_TYPE (value
) = enumtype
;
10887 DECL_INITIAL (decl
) = value
;
10888 TREE_VALUE (values
) = value
;
10891 /* Fix up all variant types of this enum type. */
10892 for (t
= TYPE_MAIN_VARIANT (enumtype
); t
; t
= TYPE_NEXT_VARIANT (t
))
10894 TYPE_VALUES (t
) = TYPE_VALUES (enumtype
);
10895 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (enumtype
);
10896 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (enumtype
);
10897 TYPE_SIZE (t
) = TYPE_SIZE (enumtype
);
10898 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (enumtype
);
10899 TYPE_MODE (t
) = TYPE_MODE (enumtype
);
10900 TYPE_PRECISION (t
) = TYPE_PRECISION (enumtype
);
10901 TYPE_ALIGN (t
) = TYPE_ALIGN (enumtype
);
10902 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (enumtype
);
10903 TYPE_UNSIGNED (t
) = TYPE_UNSIGNED (enumtype
);
10906 /* Finish debugging output for this type. */
10907 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
10910 /* Build and install a CONST_DECL for an enumeration constant of the
10911 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
10912 Assignment of sequential values by default is handled here. */
10915 build_enumerator (tree name
, tree value
, tree enumtype
)
10921 /* If the VALUE was erroneous, pretend it wasn't there; that will
10922 result in the enum being assigned the next value in sequence. */
10923 if (value
== error_mark_node
)
10926 /* Remove no-op casts from the value. */
10928 STRIP_TYPE_NOPS (value
);
10930 if (! processing_template_decl
)
10932 /* Validate and default VALUE. */
10933 if (value
!= NULL_TREE
)
10935 value
= integral_constant_value (value
);
10937 if (TREE_CODE (value
) == INTEGER_CST
)
10939 value
= perform_integral_promotions (value
);
10940 constant_expression_warning (value
);
10944 error ("enumerator value for %qD is not an integer constant", name
);
10949 /* Default based on previous value. */
10950 if (value
== NULL_TREE
)
10952 if (TYPE_VALUES (enumtype
))
10955 unsigned HOST_WIDE_INT lo
;
10959 /* The next value is the previous value plus one. We can
10960 safely assume that the previous value is an INTEGER_CST.
10961 add_double doesn't know the type of the target expression,
10962 so we must check with int_fits_type_p as well. */
10963 prev_value
= DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype
)));
10964 overflowed
= add_double (TREE_INT_CST_LOW (prev_value
),
10965 TREE_INT_CST_HIGH (prev_value
),
10967 value
= build_int_cst_wide (TREE_TYPE (prev_value
), lo
, hi
);
10968 overflowed
|= !int_fits_type_p (value
, TREE_TYPE (prev_value
));
10972 error ("overflow in enumeration values at %qD", name
);
10973 value
= error_mark_node
;
10977 value
= integer_zero_node
;
10980 /* Remove no-op casts from the value. */
10981 STRIP_TYPE_NOPS (value
);
10984 /* C++ associates enums with global, function, or class declarations. */
10985 context
= current_scope ();
10987 /* Build the actual enumeration constant. Note that the enumeration
10988 constants have the type of their initializers until the
10989 enumeration is complete:
10993 Following the closing brace of an enum-specifier, each enumer-
10994 ator has the type of its enumeration. Prior to the closing
10995 brace, the type of each enumerator is the type of its
10996 initializing value.
10998 In finish_enum we will reset the type. Of course, if we're
10999 processing a template, there may be no value. */
11000 type
= value
? TREE_TYPE (value
) : NULL_TREE
;
11002 if (context
&& context
== current_class_type
)
11003 /* This enum declaration is local to the class. We need the full
11004 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
11005 decl
= build_lang_decl (CONST_DECL
, name
, type
);
11007 /* It's a global enum, or it's local to a function. (Note local to
11008 a function could mean local to a class method. */
11009 decl
= build_decl (CONST_DECL
, name
, type
);
11011 DECL_CONTEXT (decl
) = FROB_CONTEXT (context
);
11012 TREE_CONSTANT (decl
) = 1;
11013 TREE_READONLY (decl
) = 1;
11014 DECL_INITIAL (decl
) = value
;
11016 if (context
&& context
== current_class_type
)
11017 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
11018 on the TYPE_FIELDS list for `S'. (That's so that you can say
11019 things like `S::i' later.) */
11020 finish_member_declaration (decl
);
11024 /* Add this enumeration constant to the list for this type. */
11025 TYPE_VALUES (enumtype
) = tree_cons (name
, decl
, TYPE_VALUES (enumtype
));
11029 /* We're defining DECL. Make sure that it's type is OK. */
11032 check_function_type (tree decl
, tree current_function_parms
)
11034 tree fntype
= TREE_TYPE (decl
);
11035 tree return_type
= complete_type (TREE_TYPE (fntype
));
11037 /* In a function definition, arg types must be complete. */
11038 require_complete_types_for_parms (current_function_parms
);
11040 if (dependent_type_p (return_type
))
11042 if (!COMPLETE_OR_VOID_TYPE_P (return_type
)
11043 || (TYPE_FOR_JAVA (return_type
) && MAYBE_CLASS_TYPE_P (return_type
)))
11045 tree args
= TYPE_ARG_TYPES (fntype
);
11047 if (!COMPLETE_OR_VOID_TYPE_P (return_type
))
11048 error ("return type %q#T is incomplete", return_type
);
11050 error ("return type has Java class type %q#T", return_type
);
11052 /* Make it return void instead. */
11053 if (TREE_CODE (fntype
) == METHOD_TYPE
)
11054 fntype
= build_method_type_directly (TREE_TYPE (TREE_VALUE (args
)),
11056 TREE_CHAIN (args
));
11058 fntype
= build_function_type (void_type_node
, args
);
11060 = build_exception_variant (fntype
,
11061 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl
)));
11064 abstract_virtuals_error (decl
, TREE_TYPE (fntype
));
11067 /* Create the FUNCTION_DECL for a function definition.
11068 DECLSPECS and DECLARATOR are the parts of the declaration;
11069 they describe the function's name and the type it returns,
11070 but twisted together in a fashion that parallels the syntax of C.
11072 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
11073 DECLARATOR is really the DECL for the function we are about to
11074 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
11075 indicating that the function is an inline defined in-class.
11077 This function creates a binding context for the function body
11078 as well as setting up the FUNCTION_DECL in current_function_decl.
11080 For C++, we must first check whether that datum makes any sense.
11081 For example, "class A local_a(1,2);" means that variable local_a
11082 is an aggregate of type A, which should have a constructor
11083 applied to it with the argument list [1, 2].
11085 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
11086 or may be a BLOCK if the function has been defined previously
11087 in this translation unit. On exit, DECL_INITIAL (decl1) will be
11088 error_mark_node if the function has never been defined, or
11089 a BLOCK if the function has been defined somewhere. */
11092 start_preparsed_function (tree decl1
, tree attrs
, int flags
)
11094 tree ctype
= NULL_TREE
;
11097 int doing_friend
= 0;
11098 struct cp_binding_level
*bl
;
11099 tree current_function_parms
;
11100 struct c_fileinfo
*finfo
11101 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1
)));
11102 bool honor_interface
;
11104 /* Sanity check. */
11105 gcc_assert (TREE_CODE (TREE_VALUE (void_list_node
)) == VOID_TYPE
);
11106 gcc_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
);
11108 fntype
= TREE_TYPE (decl1
);
11109 if (TREE_CODE (fntype
) == METHOD_TYPE
)
11110 ctype
= TYPE_METHOD_BASETYPE (fntype
);
11112 /* ISO C++ 11.4/5. A friend function defined in a class is in
11113 the (lexical) scope of the class in which it is defined. */
11114 if (!ctype
&& DECL_FRIEND_P (decl1
))
11116 ctype
= DECL_FRIEND_CONTEXT (decl1
);
11118 /* CTYPE could be null here if we're dealing with a template;
11119 for example, `inline friend float foo()' inside a template
11120 will have no CTYPE set. */
11121 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
11127 if (DECL_DECLARED_INLINE_P (decl1
)
11128 && lookup_attribute ("noinline", attrs
))
11129 warning (0, "inline function %q+D given attribute noinline", decl1
);
11131 /* Handle gnu_inline attribute. */
11132 if (GNU_INLINE_P (decl1
))
11134 DECL_EXTERNAL (decl1
) = 1;
11135 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
11136 DECL_INTERFACE_KNOWN (decl1
) = 1;
11137 DECL_DISREGARD_INLINE_LIMITS (decl1
) = 1;
11140 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1
))
11141 /* This is a constructor, we must ensure that any default args
11142 introduced by this definition are propagated to the clones
11143 now. The clones are used directly in overload resolution. */
11144 adjust_clone_args (decl1
);
11146 /* Sometimes we don't notice that a function is a static member, and
11147 build a METHOD_TYPE for it. Fix that up now. */
11148 if (ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
)
11149 && TREE_CODE (TREE_TYPE (decl1
)) == METHOD_TYPE
)
11151 revert_static_member_fn (decl1
);
11155 /* Set up current_class_type, and enter the scope of the class, if
11158 push_nested_class (ctype
);
11159 else if (DECL_STATIC_FUNCTION_P (decl1
))
11160 push_nested_class (DECL_CONTEXT (decl1
));
11162 /* Now that we have entered the scope of the class, we must restore
11163 the bindings for any template parameters surrounding DECL1, if it
11164 is an inline member template. (Order is important; consider the
11165 case where a template parameter has the same name as a field of
11166 the class.) It is not until after this point that
11167 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
11168 if (flags
& SF_INCLASS_INLINE
)
11169 maybe_begin_member_template_processing (decl1
);
11171 /* Effective C++ rule 15. */
11173 && DECL_OVERLOADED_OPERATOR_P (decl1
) == NOP_EXPR
11174 && TREE_CODE (TREE_TYPE (fntype
)) == VOID_TYPE
)
11175 warning (OPT_Weffc__
, "%<operator=%> should return a reference to %<*this%>");
11177 /* Make the init_value nonzero so pushdecl knows this is not tentative.
11178 error_mark_node is replaced below (in poplevel) with the BLOCK. */
11179 if (!DECL_INITIAL (decl1
))
11180 DECL_INITIAL (decl1
) = error_mark_node
;
11182 /* This function exists in static storage.
11183 (This does not mean `static' in the C sense!) */
11184 TREE_STATIC (decl1
) = 1;
11186 /* We must call push_template_decl after current_class_type is set
11187 up. (If we are processing inline definitions after exiting a
11188 class scope, current_class_type will be NULL_TREE until set above
11189 by push_nested_class.) */
11190 if (processing_template_decl
)
11192 /* FIXME: Handle error_mark_node more gracefully. */
11193 tree newdecl1
= push_template_decl (decl1
);
11194 if (newdecl1
!= error_mark_node
)
11198 /* We are now in the scope of the function being defined. */
11199 current_function_decl
= decl1
;
11201 /* Save the parm names or decls from this function's declarator
11202 where store_parm_decls will find them. */
11203 current_function_parms
= DECL_ARGUMENTS (decl1
);
11205 /* Make sure the parameter and return types are reasonable. When
11206 you declare a function, these types can be incomplete, but they
11207 must be complete when you define the function. */
11208 check_function_type (decl1
, current_function_parms
);
11210 /* Build the return declaration for the function. */
11211 restype
= TREE_TYPE (fntype
);
11212 if (DECL_RESULT (decl1
) == NULL_TREE
)
11216 resdecl
= build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (restype
));
11217 DECL_ARTIFICIAL (resdecl
) = 1;
11218 DECL_IGNORED_P (resdecl
) = 1;
11219 DECL_RESULT (decl1
) = resdecl
;
11221 cp_apply_type_quals_to_decl (cp_type_quals (restype
), resdecl
);
11224 /* Let the user know we're compiling this function. */
11225 announce_function (decl1
);
11227 /* Record the decl so that the function name is defined.
11228 If we already have a decl for this name, and it is a FUNCTION_DECL,
11229 use the old decl. */
11230 if (!processing_template_decl
&& !(flags
& SF_PRE_PARSED
))
11232 /* A specialization is not used to guide overload resolution. */
11233 if (!DECL_FUNCTION_MEMBER_P (decl1
)
11234 && !(DECL_USE_TEMPLATE (decl1
) &&
11235 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1
))))
11237 tree olddecl
= pushdecl (decl1
);
11239 if (olddecl
== error_mark_node
)
11240 /* If something went wrong when registering the declaration,
11241 use DECL1; we have to have a FUNCTION_DECL to use when
11242 parsing the body of the function. */
11246 /* Otherwise, OLDDECL is either a previous declaration
11247 of the same function or DECL1 itself. */
11249 if (warn_missing_declarations
11250 && olddecl
== decl1
11251 && !DECL_MAIN_P (decl1
)
11252 && TREE_PUBLIC (decl1
)
11253 && !DECL_DECLARED_INLINE_P (decl1
))
11257 /* Check whether DECL1 is in an anonymous
11259 for (context
= DECL_CONTEXT (decl1
);
11261 context
= DECL_CONTEXT (context
))
11263 if (TREE_CODE (context
) == NAMESPACE_DECL
11264 && DECL_NAME (context
) == NULL_TREE
)
11268 if (context
== NULL
)
11269 warning (OPT_Wmissing_declarations
,
11270 "no previous declaration for %q+D", decl1
);
11278 /* We need to set the DECL_CONTEXT. */
11279 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
11280 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
11282 fntype
= TREE_TYPE (decl1
);
11284 /* If #pragma weak applies, mark the decl appropriately now.
11285 The pragma only applies to global functions. Because
11286 determining whether or not the #pragma applies involves
11287 computing the mangled name for the declaration, we cannot
11288 apply the pragma until after we have merged this declaration
11289 with any previous declarations; if the original declaration
11290 has a linkage specification, that specification applies to
11291 the definition as well, and may affect the mangled name. */
11292 if (!DECL_CONTEXT (decl1
))
11293 maybe_apply_pragma_weak (decl1
);
11296 /* Reset this in case the call to pushdecl changed it. */
11297 current_function_decl
= decl1
;
11299 gcc_assert (DECL_INITIAL (decl1
));
11301 /* This function may already have been parsed, in which case just
11302 return; our caller will skip over the body without parsing. */
11303 if (DECL_INITIAL (decl1
) != error_mark_node
)
11306 /* Initialize RTL machinery. We cannot do this until
11307 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
11308 even when processing a template; this is how we get
11309 CFUN set up, and our per-function variables initialized.
11310 FIXME factor out the non-RTL stuff. */
11311 bl
= current_binding_level
;
11312 allocate_struct_function (decl1
, processing_template_decl
);
11314 /* Initialize the language data structures. Whenever we start
11315 a new function, we destroy temporaries in the usual way. */
11316 cfun
->language
= GGC_CNEW (struct language_function
);
11317 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
11318 current_binding_level
= bl
;
11320 /* Even though we're inside a function body, we still don't want to
11321 call expand_expr to calculate the size of a variable-sized array.
11322 We haven't necessarily assigned RTL to all variables yet, so it's
11323 not safe to try to expand expressions involving them. */
11324 cfun
->dont_save_pending_sizes_p
= 1;
11326 /* Start the statement-tree, start the tree now. */
11327 DECL_SAVED_TREE (decl1
) = push_stmt_list ();
11329 /* If we are (erroneously) defining a function that we have already
11330 defined before, wipe out what we knew before. */
11331 if (!DECL_PENDING_INLINE_P (decl1
))
11332 DECL_SAVED_FUNCTION_DATA (decl1
) = NULL
;
11334 if (ctype
&& !doing_friend
&& !DECL_STATIC_FUNCTION_P (decl1
))
11336 /* We know that this was set up by `grokclassfn'. We do not
11337 wait until `store_parm_decls', since evil parse errors may
11338 never get us to that point. Here we keep the consistency
11339 between `current_class_type' and `current_class_ptr'. */
11340 tree t
= DECL_ARGUMENTS (decl1
);
11342 gcc_assert (t
!= NULL_TREE
&& TREE_CODE (t
) == PARM_DECL
);
11343 gcc_assert (TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
);
11345 cp_function_chain
->x_current_class_ref
11346 = cp_build_indirect_ref (t
, NULL
, tf_warning_or_error
);
11347 cp_function_chain
->x_current_class_ptr
= t
;
11349 /* Constructors and destructors need to know whether they're "in
11350 charge" of initializing virtual base classes. */
11351 t
= TREE_CHAIN (t
);
11352 if (DECL_HAS_IN_CHARGE_PARM_P (decl1
))
11354 current_in_charge_parm
= t
;
11355 t
= TREE_CHAIN (t
);
11357 if (DECL_HAS_VTT_PARM_P (decl1
))
11359 gcc_assert (DECL_NAME (t
) == vtt_parm_identifier
);
11360 current_vtt_parm
= t
;
11364 honor_interface
= (!DECL_TEMPLATE_INSTANTIATION (decl1
)
11365 /* Implicitly-defined methods (like the
11366 destructor for a class in which no destructor
11367 is explicitly declared) must not be defined
11368 until their definition is needed. So, we
11369 ignore interface specifications for
11370 compiler-generated functions. */
11371 && !DECL_ARTIFICIAL (decl1
));
11373 if (DECL_INTERFACE_KNOWN (decl1
))
11375 tree ctx
= decl_function_context (decl1
);
11377 if (DECL_NOT_REALLY_EXTERN (decl1
))
11378 DECL_EXTERNAL (decl1
) = 0;
11380 if (ctx
!= NULL_TREE
&& DECL_DECLARED_INLINE_P (ctx
)
11381 && TREE_PUBLIC (ctx
))
11382 /* This is a function in a local class in an extern inline
11384 comdat_linkage (decl1
);
11386 /* If this function belongs to an interface, it is public.
11387 If it belongs to someone else's interface, it is also external.
11388 This only affects inlines and template instantiations. */
11389 else if (!finfo
->interface_unknown
&& honor_interface
)
11391 if (DECL_DECLARED_INLINE_P (decl1
)
11392 || DECL_TEMPLATE_INSTANTIATION (decl1
)
11393 || processing_template_decl
)
11395 DECL_EXTERNAL (decl1
)
11396 = (finfo
->interface_only
11397 || (DECL_DECLARED_INLINE_P (decl1
)
11398 && ! flag_implement_inlines
11399 && !DECL_VINDEX (decl1
)));
11401 /* For WIN32 we also want to put these in linkonce sections. */
11402 maybe_make_one_only (decl1
);
11405 DECL_EXTERNAL (decl1
) = 0;
11406 DECL_INTERFACE_KNOWN (decl1
) = 1;
11407 /* If this function is in an interface implemented in this file,
11408 make sure that the back end knows to emit this function
11410 if (!DECL_EXTERNAL (decl1
))
11411 mark_needed (decl1
);
11413 else if (finfo
->interface_unknown
&& finfo
->interface_only
11414 && honor_interface
)
11416 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
11417 interface, we will have both finfo->interface_unknown and
11418 finfo->interface_only set. In that case, we don't want to
11419 use the normal heuristics because someone will supply a
11420 #pragma implementation elsewhere, and deducing it here would
11421 produce a conflict. */
11422 comdat_linkage (decl1
);
11423 DECL_EXTERNAL (decl1
) = 0;
11424 DECL_INTERFACE_KNOWN (decl1
) = 1;
11425 DECL_DEFER_OUTPUT (decl1
) = 1;
11429 /* This is a definition, not a reference.
11430 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
11431 if (!GNU_INLINE_P (decl1
))
11432 DECL_EXTERNAL (decl1
) = 0;
11434 if ((DECL_DECLARED_INLINE_P (decl1
)
11435 || DECL_TEMPLATE_INSTANTIATION (decl1
))
11436 && ! DECL_INTERFACE_KNOWN (decl1
)
11437 /* Don't try to defer nested functions for now. */
11438 && ! decl_function_context (decl1
))
11439 DECL_DEFER_OUTPUT (decl1
) = 1;
11441 DECL_INTERFACE_KNOWN (decl1
) = 1;
11444 /* Determine the ELF visibility attribute for the function. We must not
11445 do this before calling "pushdecl", as we must allow "duplicate_decls"
11446 to merge any attributes appropriately. We also need to wait until
11448 if (!DECL_CLONED_FUNCTION_P (decl1
))
11449 determine_visibility (decl1
);
11451 begin_scope (sk_function_parms
, decl1
);
11455 if (DECL_DESTRUCTOR_P (decl1
)
11456 || (DECL_CONSTRUCTOR_P (decl1
)
11457 && targetm
.cxx
.cdtor_returns_this ()))
11459 cdtor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
11460 DECL_CONTEXT (cdtor_label
) = current_function_decl
;
11463 start_fname_decls ();
11465 store_parm_decls (current_function_parms
);
11469 /* Like start_preparsed_function, except that instead of a
11470 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
11472 Returns 1 on success. If the DECLARATOR is not suitable for a function
11473 (it defines a datum instead), we return 0, which tells
11474 yyparse to report a parse error. */
11477 start_function (cp_decl_specifier_seq
*declspecs
,
11478 const cp_declarator
*declarator
,
11483 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, &attrs
);
11484 /* If the declarator is not suitable for a function definition,
11485 cause a syntax error. */
11486 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
)
11489 if (DECL_MAIN_P (decl1
))
11490 /* main must return int. grokfndecl should have corrected it
11491 (and issued a diagnostic) if the user got it wrong. */
11492 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1
)),
11493 integer_type_node
));
11495 start_preparsed_function (decl1
, attrs
, /*flags=*/SF_DEFAULT
);
11500 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
11504 use_eh_spec_block (tree fn
)
11506 return (flag_exceptions
&& flag_enforce_eh_specs
11507 && !processing_template_decl
11508 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
))
11509 /* We insert the EH_SPEC_BLOCK only in the original
11510 function; then, it is copied automatically to the
11512 && !DECL_CLONED_FUNCTION_P (fn
)
11513 /* Implicitly-generated constructors and destructors have
11514 exception specifications. However, those specifications
11515 are the union of the possible exceptions specified by the
11516 constructors/destructors for bases and members, so no
11517 unallowed exception will ever reach this function. By
11518 not creating the EH_SPEC_BLOCK we save a little memory,
11519 and we avoid spurious warnings about unreachable
11521 && !DECL_ARTIFICIAL (fn
));
11524 /* Store the parameter declarations into the current function declaration.
11525 This is called after parsing the parameter declarations, before
11526 digesting the body of the function.
11528 Also install to binding contour return value identifier, if any. */
11531 store_parm_decls (tree current_function_parms
)
11533 tree fndecl
= current_function_decl
;
11536 /* This is a chain of any other decls that came in among the parm
11537 declarations. If a parm is declared with enum {foo, bar} x;
11538 then CONST_DECLs for foo and bar are put here. */
11539 tree nonparms
= NULL_TREE
;
11541 if (current_function_parms
)
11543 /* This case is when the function was defined with an ANSI prototype.
11544 The parms already have decls, so we need not do anything here
11545 except record them as in effect
11546 and complain if any redundant old-style parm decls were written. */
11548 tree specparms
= current_function_parms
;
11551 /* Must clear this because it might contain TYPE_DECLs declared
11553 current_binding_level
->names
= NULL
;
11555 /* If we're doing semantic analysis, then we'll call pushdecl
11556 for each of these. We must do them in reverse order so that
11557 they end in the correct forward order. */
11558 specparms
= nreverse (specparms
);
11560 for (parm
= specparms
; parm
; parm
= next
)
11562 next
= TREE_CHAIN (parm
);
11563 if (TREE_CODE (parm
) == PARM_DECL
)
11565 if (DECL_NAME (parm
) == NULL_TREE
11566 || TREE_CODE (parm
) != VOID_TYPE
)
11569 error ("parameter %qD declared void", parm
);
11573 /* If we find an enum constant or a type tag,
11574 put it aside for the moment. */
11575 TREE_CHAIN (parm
) = NULL_TREE
;
11576 nonparms
= chainon (nonparms
, parm
);
11580 /* Get the decls in their original chain order and record in the
11581 function. This is all and only the PARM_DECLs that were
11582 pushed into scope by the loop above. */
11583 DECL_ARGUMENTS (fndecl
) = getdecls ();
11586 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
11588 /* Now store the final chain of decls for the arguments
11589 as the decl-chain of the current lexical scope.
11590 Put the enumerators in as well, at the front so that
11591 DECL_ARGUMENTS is not modified. */
11592 current_binding_level
->names
= chainon (nonparms
, DECL_ARGUMENTS (fndecl
));
11594 if (use_eh_spec_block (current_function_decl
))
11595 current_eh_spec_block
= begin_eh_spec_block ();
11599 /* We have finished doing semantic analysis on DECL, but have not yet
11600 generated RTL for its body. Save away our current state, so that
11601 when we want to generate RTL later we know what to do. */
11604 save_function_data (tree decl
)
11606 struct language_function
*f
;
11608 /* Save the language-specific per-function data so that we can
11609 get it back when we really expand this function. */
11610 gcc_assert (!DECL_PENDING_INLINE_P (decl
));
11613 f
= GGC_NEW (struct language_function
);
11614 memcpy (f
, cp_function_chain
, sizeof (struct language_function
));
11615 DECL_SAVED_FUNCTION_DATA (decl
) = f
;
11617 /* Clear out the bits we don't need. */
11618 f
->base
.x_stmt_tree
.x_cur_stmt_list
= NULL_TREE
;
11619 f
->bindings
= NULL
;
11620 f
->x_local_names
= NULL
;
11624 /* Set the return value of the constructor (if present). */
11627 finish_constructor_body (void)
11632 if (targetm
.cxx
.cdtor_returns_this ()
11633 && (! TYPE_FOR_JAVA (current_class_type
)))
11635 /* Any return from a constructor will end up here. */
11636 add_stmt (build_stmt (LABEL_EXPR
, cdtor_label
));
11638 val
= DECL_ARGUMENTS (current_function_decl
);
11639 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
11640 DECL_RESULT (current_function_decl
), val
);
11641 /* Return the address of the object. */
11642 exprstmt
= build_stmt (RETURN_EXPR
, val
);
11643 add_stmt (exprstmt
);
11647 /* Do all the processing for the beginning of a destructor; set up the
11648 vtable pointers and cleanups for bases and members. */
11651 begin_destructor_body (void)
11653 tree compound_stmt
;
11655 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
11656 issued an error message. We still want to try to process the
11657 body of the function, but initialize_vtbl_ptrs will crash if
11658 TYPE_BINFO is NULL. */
11659 if (COMPLETE_TYPE_P (current_class_type
))
11661 compound_stmt
= begin_compound_stmt (0);
11662 /* Make all virtual function table pointers in non-virtual base
11663 classes point to CURRENT_CLASS_TYPE's virtual function
11665 initialize_vtbl_ptrs (current_class_ptr
);
11666 finish_compound_stmt (compound_stmt
);
11668 /* And insert cleanups for our bases and members so that they
11669 will be properly destroyed if we throw. */
11670 push_base_cleanups ();
11674 /* At the end of every destructor we generate code to delete the object if
11675 necessary. Do that now. */
11678 finish_destructor_body (void)
11682 /* Any return from a destructor will end up here; that way all base
11683 and member cleanups will be run when the function returns. */
11684 add_stmt (build_stmt (LABEL_EXPR
, cdtor_label
));
11686 /* In a virtual destructor, we must call delete. */
11687 if (DECL_VIRTUAL_P (current_function_decl
))
11690 tree virtual_size
= cxx_sizeof (current_class_type
);
11694 At the point of definition of a virtual destructor (including
11695 an implicit definition), non-placement operator delete shall
11696 be looked up in the scope of the destructor's class and if
11697 found shall be accessible and unambiguous. */
11698 exprstmt
= build_op_delete_call(DELETE_EXPR
, current_class_ptr
,
11700 /*global_p=*/false,
11701 /*placement=*/NULL_TREE
,
11702 /*alloc_fn=*/NULL_TREE
);
11704 if_stmt
= begin_if_stmt ();
11705 finish_if_stmt_cond (build2 (BIT_AND_EXPR
, integer_type_node
,
11706 current_in_charge_parm
,
11709 finish_expr_stmt (exprstmt
);
11710 finish_then_clause (if_stmt
);
11711 finish_if_stmt (if_stmt
);
11714 if (targetm
.cxx
.cdtor_returns_this ())
11718 val
= DECL_ARGUMENTS (current_function_decl
);
11719 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
11720 DECL_RESULT (current_function_decl
), val
);
11721 /* Return the address of the object. */
11722 exprstmt
= build_stmt (RETURN_EXPR
, val
);
11723 add_stmt (exprstmt
);
11727 /* Do the necessary processing for the beginning of a function body, which
11728 in this case includes member-initializers, but not the catch clauses of
11729 a function-try-block. Currently, this means opening a binding level
11730 for the member-initializers (in a ctor) and member cleanups (in a dtor). */
11733 begin_function_body (void)
11737 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
11740 if (processing_template_decl
)
11741 /* Do nothing now. */;
11743 /* Always keep the BLOCK node associated with the outermost pair of
11744 curly braces of a function. These are needed for correct
11745 operation of dwarfout.c. */
11746 keep_next_level (true);
11748 stmt
= begin_compound_stmt (BCS_FN_BODY
);
11750 if (processing_template_decl
)
11751 /* Do nothing now. */;
11752 else if (DECL_DESTRUCTOR_P (current_function_decl
))
11753 begin_destructor_body ();
11758 /* Do the processing for the end of a function body. Currently, this means
11759 closing out the cleanups for fully-constructed bases and members, and in
11760 the case of the destructor, deleting the object if desired. Again, this
11761 is only meaningful for [cd]tors, since they are the only functions where
11762 there is a significant distinction between the main body and any
11763 function catch clauses. Handling, say, main() return semantics here
11764 would be wrong, as flowing off the end of a function catch clause for
11765 main() would also need to return 0. */
11768 finish_function_body (tree compstmt
)
11770 if (compstmt
== NULL_TREE
)
11773 /* Close the block. */
11774 finish_compound_stmt (compstmt
);
11776 if (processing_template_decl
)
11777 /* Do nothing now. */;
11778 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
11779 finish_constructor_body ();
11780 else if (DECL_DESTRUCTOR_P (current_function_decl
))
11781 finish_destructor_body ();
11784 /* Given a function, returns the BLOCK corresponding to the outermost level
11785 of curly braces, skipping the artificial block created for constructor
11789 outer_curly_brace_block (tree fndecl
)
11791 tree block
= BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl
));
11792 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
11793 /* Skip the artificial function body block. */
11794 block
= BLOCK_SUBBLOCKS (block
);
11798 /* Finish up a function declaration and compile that function
11799 all the way to assembler language output. The free the storage
11800 for the function definition.
11802 FLAGS is a bitwise or of the following values:
11804 We just finished processing the body of an in-class inline
11805 function definition. (This processing will have taken place
11806 after the class definition is complete.) */
11809 finish_function (int flags
)
11811 tree fndecl
= current_function_decl
;
11812 tree fntype
, ctype
= NULL_TREE
;
11813 int inclass_inline
= (flags
& 2) != 0;
11816 /* When we get some parse errors, we can end up without a
11817 current_function_decl, so cope. */
11818 if (fndecl
== NULL_TREE
)
11819 return error_mark_node
;
11821 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl
)
11822 && DECL_VIRTUAL_P (fndecl
)
11823 && !processing_template_decl
)
11825 tree fnclass
= DECL_CONTEXT (fndecl
);
11826 if (fndecl
== CLASSTYPE_KEY_METHOD (fnclass
))
11827 keyed_classes
= tree_cons (NULL_TREE
, fnclass
, keyed_classes
);
11830 nested
= function_depth
> 1;
11831 fntype
= TREE_TYPE (fndecl
);
11833 /* TREE_READONLY (fndecl) = 1;
11834 This caused &foo to be of type ptr-to-const-function
11835 which then got a warning when stored in a ptr-to-function variable. */
11837 gcc_assert (building_stmt_tree ());
11838 /* The current function is being defined, so its DECL_INITIAL should
11839 be set, and unless there's a multiple definition, it should be
11840 error_mark_node. */
11841 gcc_assert (DECL_INITIAL (fndecl
) == error_mark_node
);
11843 /* For a cloned function, we've already got all the code we need;
11844 there's no need to add any extra bits. */
11845 if (!DECL_CLONED_FUNCTION_P (fndecl
))
11847 if (DECL_MAIN_P (current_function_decl
))
11851 /* Make it so that `main' always returns 0 by default (or
11854 stmt
= finish_return_stmt (integer_one_node
);
11856 stmt
= finish_return_stmt (integer_zero_node
);
11858 /* Hack. We don't want the middle-end to warn that this
11859 return is unreachable, so put the statement on the
11862 location_t linezero
= linemap_line_start (line_table
, 0, 1);
11863 SET_EXPR_LOCATION (stmt
, linezero
);
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. */
12007 pop_nested_class ();
12013 /* Let the error reporting routines know that we're outside a
12014 function. For a nested function, this value is used in
12015 cxx_pop_function_context and then reset via pop_function_context. */
12016 current_function_decl
= NULL_TREE
;
12021 /* Create the FUNCTION_DECL for a function definition.
12022 DECLSPECS and DECLARATOR are the parts of the declaration;
12023 they describe the return type and the name of the function,
12024 but twisted together in a fashion that parallels the syntax of C.
12026 This function creates a binding context for the function body
12027 as well as setting up the FUNCTION_DECL in current_function_decl.
12029 Returns a FUNCTION_DECL on success.
12031 If the DECLARATOR is not suitable for a function (it defines a datum
12032 instead), we return 0, which tells yyparse to report a parse error.
12034 May return void_type_node indicating that this method is actually
12035 a friend. See grokfield for more details.
12037 Came here with a `.pushlevel' .
12039 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
12040 CHANGES TO CODE IN `grokfield'. */
12043 start_method (cp_decl_specifier_seq
*declspecs
,
12044 const cp_declarator
*declarator
, tree attrlist
)
12046 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
12049 if (fndecl
== error_mark_node
)
12050 return error_mark_node
;
12052 if (fndecl
== NULL
|| TREE_CODE (fndecl
) != FUNCTION_DECL
)
12054 error ("invalid member function declaration");
12055 return error_mark_node
;
12059 cplus_decl_attributes (&fndecl
, attrlist
, 0);
12061 /* Pass friends other than inline friend functions back. */
12062 if (fndecl
== void_type_node
)
12065 if (DECL_IN_AGGR_P (fndecl
))
12067 if (DECL_CONTEXT (fndecl
)
12068 && TREE_CODE (DECL_CONTEXT (fndecl
)) != NAMESPACE_DECL
)
12069 error ("%qD is already defined in class %qT", fndecl
,
12070 DECL_CONTEXT (fndecl
));
12071 return error_mark_node
;
12074 check_template_shadow (fndecl
);
12076 DECL_DECLARED_INLINE_P (fndecl
) = 1;
12077 if (flag_default_inline
)
12078 DECL_INLINE (fndecl
) = 1;
12080 /* We process method specializations in finish_struct_1. */
12081 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
12083 fndecl
= push_template_decl (fndecl
);
12084 if (fndecl
== error_mark_node
)
12088 if (! DECL_FRIEND_P (fndecl
))
12090 if (TREE_CHAIN (fndecl
))
12092 fndecl
= copy_node (fndecl
);
12093 TREE_CHAIN (fndecl
) = NULL_TREE
;
12097 finish_decl (fndecl
, NULL_TREE
, NULL_TREE
);
12099 /* Make a place for the parms. */
12100 begin_scope (sk_function_parms
, fndecl
);
12102 DECL_IN_AGGR_P (fndecl
) = 1;
12106 /* Go through the motions of finishing a function definition.
12107 We don't compile this method until after the whole class has
12110 FINISH_METHOD must return something that looks as though it
12111 came from GROKFIELD (since we are defining a method, after all).
12113 This is called after parsing the body of the function definition.
12114 STMTS is the chain of statements that makes up the function body.
12116 DECL is the ..._DECL that `start_method' provided. */
12119 finish_method (tree decl
)
12121 tree fndecl
= decl
;
12126 if (decl
== void_type_node
)
12129 old_initial
= DECL_INITIAL (fndecl
);
12131 /* Undo the level for the parms (from start_method).
12132 This is like poplevel, but it causes nothing to be
12133 saved. Saving information here confuses symbol-table
12134 output routines. Besides, this information will
12135 be correctly output when this method is actually
12138 /* Clear out the meanings of the local variables of this level;
12139 also record in each decl which block it belongs to. */
12141 for (link
= current_binding_level
->names
; link
; link
= TREE_CHAIN (link
))
12143 if (DECL_NAME (link
) != NULL_TREE
)
12144 pop_binding (DECL_NAME (link
), link
);
12145 gcc_assert (TREE_CODE (link
) != FUNCTION_DECL
);
12146 DECL_CONTEXT (link
) = NULL_TREE
;
12149 poplevel (0, 0, 0);
12151 DECL_INITIAL (fndecl
) = old_initial
;
12153 /* We used to check if the context of FNDECL was different from
12154 current_class_type as another way to get inside here. This didn't work
12155 for String.cc in libg++. */
12156 if (DECL_FRIEND_P (fndecl
))
12158 VEC_safe_push (tree
, gc
, CLASSTYPE_INLINE_FRIENDS (current_class_type
),
12160 decl
= void_type_node
;
12167 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
12168 we can lay it out later, when and if its type becomes complete. */
12171 maybe_register_incomplete_var (tree var
)
12173 gcc_assert (TREE_CODE (var
) == VAR_DECL
);
12175 /* Keep track of variables with incomplete types. */
12176 if (!processing_template_decl
&& TREE_TYPE (var
) != error_mark_node
12177 && DECL_EXTERNAL (var
))
12179 tree inner_type
= TREE_TYPE (var
);
12181 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
12182 inner_type
= TREE_TYPE (inner_type
);
12183 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
12185 if ((!COMPLETE_TYPE_P (inner_type
) && CLASS_TYPE_P (inner_type
))
12186 /* RTTI TD entries are created while defining the type_info. */
12187 || (TYPE_LANG_SPECIFIC (inner_type
)
12188 && TYPE_BEING_DEFINED (inner_type
)))
12189 incomplete_vars
= tree_cons (inner_type
, var
, incomplete_vars
);
12193 /* Called when a class type (given by TYPE) is defined. If there are
12194 any existing VAR_DECLs whose type hsa been completed by this
12195 declaration, update them now. */
12198 complete_vars (tree type
)
12200 tree
*list
= &incomplete_vars
;
12202 gcc_assert (CLASS_TYPE_P (type
));
12205 if (same_type_p (type
, TREE_PURPOSE (*list
)))
12207 tree var
= TREE_VALUE (*list
);
12208 tree type
= TREE_TYPE (var
);
12209 /* Complete the type of the variable. The VAR_DECL itself
12210 will be laid out in expand_expr. */
12211 complete_type (type
);
12212 cp_apply_type_quals_to_decl (cp_type_quals (type
), var
);
12213 /* Remove this entry from the list. */
12214 *list
= TREE_CHAIN (*list
);
12217 list
= &TREE_CHAIN (*list
);
12220 /* Check for pending declarations which may have abstract type. */
12221 complete_type_check_abstract (type
);
12224 /* If DECL is of a type which needs a cleanup, build and return an
12225 expression to perform that cleanup here. Return NULL_TREE if no
12226 cleanup need be done. */
12229 cxx_maybe_build_cleanup (tree decl
)
12235 /* Assume no cleanup is required. */
12236 cleanup
= NULL_TREE
;
12238 if (error_operand_p (decl
))
12241 /* Handle "__attribute__((cleanup))". We run the cleanup function
12242 before the destructor since the destructor is what actually
12243 terminates the lifetime of the object. */
12244 attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
12251 /* Get the name specified by the user for the cleanup function. */
12252 id
= TREE_VALUE (TREE_VALUE (attr
));
12253 /* Look up the name to find the cleanup function to call. It is
12254 important to use lookup_name here because that is what is
12255 used in c-common.c:handle_cleanup_attribute when performing
12256 initial checks on the attribute. Note that those checks
12257 include ensuring that the function found is not an overloaded
12258 function, or an object with an overloaded call operator,
12259 etc.; we can rely on the fact that the functionfound is an
12260 ordinary FUNCTION_DECL. */
12261 fn
= lookup_name (id
);
12262 arg
= build_address (decl
);
12264 cleanup
= cp_build_function_call (fn
, build_tree_list (NULL_TREE
,
12266 tf_warning_or_error
);
12268 /* Handle ordinary C++ destructors. */
12269 type
= TREE_TYPE (decl
);
12270 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
12272 int flags
= LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
;
12273 bool has_vbases
= (TREE_CODE (type
) == RECORD_TYPE
12274 && CLASSTYPE_VBASECLASSES (type
));
12278 if (TREE_CODE (type
) == ARRAY_TYPE
)
12281 addr
= build_address (decl
);
12283 /* Optimize for space over speed here. */
12284 if (!has_vbases
|| flag_expensive_optimizations
)
12285 flags
|= LOOKUP_NONVIRTUAL
;
12287 call
= build_delete (TREE_TYPE (addr
), addr
,
12288 sfk_complete_destructor
, flags
, 0);
12290 cleanup
= build_compound_expr (cleanup
, call
);
12298 /* When a stmt has been parsed, this function is called. */
12305 /* DECL was originally constructed as a non-static member function,
12306 but turned out to be static. Update it accordingly. */
12309 revert_static_member_fn (tree decl
)
12312 tree function
= TREE_TYPE (decl
);
12313 tree args
= TYPE_ARG_TYPES (function
);
12315 if (cp_type_quals (TREE_TYPE (TREE_VALUE (args
)))
12316 != TYPE_UNQUALIFIED
)
12317 error ("static member function %q#D declared with type qualifiers", decl
);
12319 args
= TREE_CHAIN (args
);
12320 tmp
= build_function_type (TREE_TYPE (function
), args
);
12321 tmp
= build_qualified_type (tmp
, cp_type_quals (function
));
12322 tmp
= build_exception_variant (tmp
,
12323 TYPE_RAISES_EXCEPTIONS (function
));
12324 TREE_TYPE (decl
) = tmp
;
12325 if (DECL_ARGUMENTS (decl
))
12326 DECL_ARGUMENTS (decl
) = TREE_CHAIN (DECL_ARGUMENTS (decl
));
12327 DECL_STATIC_FUNCTION_P (decl
) = 1;
12330 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
12331 one of the language-independent trees. */
12333 enum cp_tree_node_structure_enum
12334 cp_tree_node_structure (union lang_tree_node
* t
)
12336 switch (TREE_CODE (&t
->generic
))
12338 case DEFAULT_ARG
: return TS_CP_DEFAULT_ARG
;
12339 case IDENTIFIER_NODE
: return TS_CP_IDENTIFIER
;
12340 case OVERLOAD
: return TS_CP_OVERLOAD
;
12341 case TEMPLATE_PARM_INDEX
: return TS_CP_TPI
;
12342 case PTRMEM_CST
: return TS_CP_PTRMEM
;
12343 case BASELINK
: return TS_CP_BASELINK
;
12344 case STATIC_ASSERT
: return TS_CP_STATIC_ASSERT
;
12345 case ARGUMENT_PACK_SELECT
: return TS_CP_ARGUMENT_PACK_SELECT
;
12346 case TRAIT_EXPR
: return TS_CP_TRAIT_EXPR
;
12347 default: return TS_CP_GENERIC
;
12351 /* Build the void_list_node (void_type_node having been created). */
12353 build_void_list_node (void)
12355 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
12360 cp_missing_noreturn_ok_p (tree decl
)
12362 /* A missing noreturn is ok for the `main' function. */
12363 return DECL_MAIN_P (decl
);
12366 /* Return the COMDAT group into which DECL should be placed. */
12369 cxx_comdat_group (tree decl
)
12373 /* Virtual tables, construction virtual tables, and virtual table
12374 tables all go in a single COMDAT group, named after the primary
12376 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_VTABLE_OR_VTT_P (decl
))
12377 name
= DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl
)));
12378 /* For all other DECLs, the COMDAT group is the mangled name of the
12379 declaration itself. */
12382 while (DECL_THUNK_P (decl
))
12384 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
12385 into the same section as the target function. In that case
12386 we must return target's name. */
12387 tree target
= THUNK_TARGET (decl
);
12388 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target
)
12389 && DECL_SECTION_NAME (target
) != NULL
12390 && DECL_ONE_ONLY (target
))
12395 name
= DECL_ASSEMBLER_NAME (decl
);
12398 return IDENTIFIER_POINTER (name
);
12401 #include "gt-cp-decl.h"