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
, bool);
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' matches 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 name_space
, walk_namespaces_fn f
, void* data
)
806 tree current
= NAMESPACE_LEVEL (name_space
)->namespaces
;
808 result
|= (*f
) (name_space
, 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 name_space
, void* data
)
832 struct cp_binding_level
*level
= NAMESPACE_LEVEL (name_space
);
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 (input_location
, "%qD was declared %<extern%> and later %<static%>", newdecl
);
1059 permerror (input_location
, "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 (input_location
, "default argument given for parameter %d of %q#D",
1544 permerror (input_location
, "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",
1557 /* Do not merge an implicit typedef with an explicit one. In:
1561 typedef class A A __attribute__ ((foo));
1563 the attribute should apply only to the typedef. */
1564 if (TREE_CODE (olddecl
) == TYPE_DECL
1565 && (DECL_IMPLICIT_TYPEDEF_P (olddecl
)
1566 || DECL_IMPLICIT_TYPEDEF_P (newdecl
)))
1569 /* If new decl is `static' and an `extern' was seen previously,
1571 warn_extern_redeclared_static (newdecl
, olddecl
);
1573 /* We have committed to returning 1 at this point. */
1574 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1576 /* Now that functions must hold information normally held
1577 by field decls, there is extra work to do so that
1578 declaration information does not get destroyed during
1580 if (DECL_VINDEX (olddecl
))
1581 DECL_VINDEX (newdecl
) = DECL_VINDEX (olddecl
);
1582 if (DECL_CONTEXT (olddecl
))
1583 DECL_CONTEXT (newdecl
) = DECL_CONTEXT (olddecl
);
1584 DECL_STATIC_CONSTRUCTOR (newdecl
) |= DECL_STATIC_CONSTRUCTOR (olddecl
);
1585 DECL_STATIC_DESTRUCTOR (newdecl
) |= DECL_STATIC_DESTRUCTOR (olddecl
);
1586 DECL_PURE_VIRTUAL_P (newdecl
) |= DECL_PURE_VIRTUAL_P (olddecl
);
1587 DECL_VIRTUAL_P (newdecl
) |= DECL_VIRTUAL_P (olddecl
);
1588 DECL_INVALID_OVERRIDER_P (newdecl
) |= DECL_INVALID_OVERRIDER_P (olddecl
);
1589 DECL_THIS_STATIC (newdecl
) |= DECL_THIS_STATIC (olddecl
);
1590 if (DECL_OVERLOADED_OPERATOR_P (olddecl
) != ERROR_MARK
)
1591 SET_OVERLOADED_OPERATOR_CODE
1592 (newdecl
, DECL_OVERLOADED_OPERATOR_P (olddecl
));
1593 new_defines_function
= DECL_INITIAL (newdecl
) != NULL_TREE
;
1595 /* Optionally warn about more than one declaration for the same
1596 name, but don't warn about a function declaration followed by a
1598 if (warn_redundant_decls
&& ! DECL_ARTIFICIAL (olddecl
)
1599 && !(new_defines_function
&& DECL_INITIAL (olddecl
) == NULL_TREE
)
1600 /* Don't warn about extern decl followed by definition. */
1601 && !(DECL_EXTERNAL (olddecl
) && ! DECL_EXTERNAL (newdecl
))
1602 /* Don't warn about friends, let add_friend take care of it. */
1603 && ! (newdecl_is_friend
|| DECL_FRIEND_P (olddecl
)))
1605 warning (OPT_Wredundant_decls
, "redundant redeclaration of %qD in same scope", newdecl
);
1606 warning (OPT_Wredundant_decls
, "previous declaration of %q+D", olddecl
);
1609 if (DECL_DELETED_FN (newdecl
))
1611 error ("deleted definition of %qD", newdecl
);
1612 error ("after previous declaration %q+D", olddecl
);
1616 /* Deal with C++: must preserve virtual function table size. */
1617 if (TREE_CODE (olddecl
) == TYPE_DECL
)
1619 tree newtype
= TREE_TYPE (newdecl
);
1620 tree oldtype
= TREE_TYPE (olddecl
);
1622 if (newtype
!= error_mark_node
&& oldtype
!= error_mark_node
1623 && TYPE_LANG_SPECIFIC (newtype
) && TYPE_LANG_SPECIFIC (oldtype
))
1624 CLASSTYPE_FRIEND_CLASSES (newtype
)
1625 = CLASSTYPE_FRIEND_CLASSES (oldtype
);
1627 DECL_ORIGINAL_TYPE (newdecl
) = DECL_ORIGINAL_TYPE (olddecl
);
1630 /* Copy all the DECL_... slots specified in the new decl
1631 except for any that we copy here from the old type. */
1632 DECL_ATTRIBUTES (newdecl
)
1633 = (*targetm
.merge_decl_attributes
) (olddecl
, newdecl
);
1635 if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
1639 old_result
= DECL_TEMPLATE_RESULT (olddecl
);
1640 new_result
= DECL_TEMPLATE_RESULT (newdecl
);
1641 TREE_TYPE (olddecl
) = TREE_TYPE (old_result
);
1642 DECL_TEMPLATE_SPECIALIZATIONS (olddecl
)
1643 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl
),
1644 DECL_TEMPLATE_SPECIALIZATIONS (newdecl
));
1646 DECL_ATTRIBUTES (old_result
)
1647 = (*targetm
.merge_decl_attributes
) (old_result
, new_result
);
1649 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
1651 if (GNU_INLINE_P (old_result
) != GNU_INLINE_P (new_result
)
1652 && DECL_INITIAL (new_result
))
1654 if (DECL_INITIAL (old_result
))
1655 DECL_UNINLINABLE (old_result
) = 1;
1657 DECL_UNINLINABLE (old_result
) = DECL_UNINLINABLE (new_result
);
1658 DECL_EXTERNAL (old_result
) = DECL_EXTERNAL (new_result
);
1659 DECL_NOT_REALLY_EXTERN (old_result
)
1660 = DECL_NOT_REALLY_EXTERN (new_result
);
1661 DECL_INTERFACE_KNOWN (old_result
)
1662 = DECL_INTERFACE_KNOWN (new_result
);
1663 DECL_DECLARED_INLINE_P (old_result
)
1664 = DECL_DECLARED_INLINE_P (new_result
);
1665 DECL_DISREGARD_INLINE_LIMITS (old_result
)
1666 |= DECL_DISREGARD_INLINE_LIMITS (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
);
1675 check_redeclaration_exception_specification (newdecl
, olddecl
);
1679 /* If the new declaration is a definition, update the file and
1680 line information on the declaration, and also make
1681 the old declaration the same definition. */
1682 if (DECL_INITIAL (new_result
) != NULL_TREE
)
1684 DECL_SOURCE_LOCATION (olddecl
)
1685 = DECL_SOURCE_LOCATION (old_result
)
1686 = DECL_SOURCE_LOCATION (newdecl
);
1687 DECL_INITIAL (old_result
) = DECL_INITIAL (new_result
);
1688 if (DECL_FUNCTION_TEMPLATE_P (newdecl
))
1689 DECL_ARGUMENTS (old_result
)
1690 = DECL_ARGUMENTS (new_result
);
1698 /* Automatically handles default parameters. */
1699 tree oldtype
= TREE_TYPE (olddecl
);
1702 /* Merge the data types specified in the two decls. */
1703 newtype
= merge_types (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
));
1705 /* If merge_types produces a non-typedef type, just use the old type. */
1706 if (TREE_CODE (newdecl
) == TYPE_DECL
1707 && newtype
== DECL_ORIGINAL_TYPE (newdecl
))
1710 if (TREE_CODE (newdecl
) == VAR_DECL
)
1712 DECL_THIS_EXTERN (newdecl
) |= DECL_THIS_EXTERN (olddecl
);
1713 DECL_INITIALIZED_P (newdecl
) |= DECL_INITIALIZED_P (olddecl
);
1714 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl
)
1715 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl
);
1716 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl
)
1717 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl
);
1719 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
1720 if (DECL_LANG_SPECIFIC (olddecl
)
1721 && CP_DECL_THREADPRIVATE_P (olddecl
))
1723 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
1724 if (!DECL_LANG_SPECIFIC (newdecl
))
1725 retrofit_lang_decl (newdecl
);
1727 DECL_TLS_MODEL (newdecl
) = DECL_TLS_MODEL (olddecl
);
1728 CP_DECL_THREADPRIVATE_P (newdecl
) = 1;
1732 /* Do this after calling `merge_types' so that default
1733 parameters don't confuse us. */
1734 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1735 check_redeclaration_exception_specification (newdecl
, olddecl
);
1736 TREE_TYPE (newdecl
) = TREE_TYPE (olddecl
) = newtype
;
1738 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1739 check_default_args (newdecl
);
1741 /* Lay the type out, unless already done. */
1742 if (! same_type_p (newtype
, oldtype
)
1743 && TREE_TYPE (newdecl
) != error_mark_node
1744 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
1745 layout_type (TREE_TYPE (newdecl
));
1747 if ((TREE_CODE (newdecl
) == VAR_DECL
1748 || TREE_CODE (newdecl
) == PARM_DECL
1749 || TREE_CODE (newdecl
) == RESULT_DECL
1750 || TREE_CODE (newdecl
) == FIELD_DECL
1751 || TREE_CODE (newdecl
) == TYPE_DECL
)
1752 && !(processing_template_decl
&& uses_template_parms (newdecl
)))
1753 layout_decl (newdecl
, 0);
1755 /* Merge the type qualifiers. */
1756 if (TREE_READONLY (newdecl
))
1757 TREE_READONLY (olddecl
) = 1;
1758 if (TREE_THIS_VOLATILE (newdecl
))
1759 TREE_THIS_VOLATILE (olddecl
) = 1;
1760 if (TREE_NOTHROW (newdecl
))
1761 TREE_NOTHROW (olddecl
) = 1;
1763 /* Merge deprecatedness. */
1764 if (TREE_DEPRECATED (newdecl
))
1765 TREE_DEPRECATED (olddecl
) = 1;
1767 /* Preserve function specific target and optimization options */
1768 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1770 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl
)
1771 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl
))
1772 DECL_FUNCTION_SPECIFIC_TARGET (newdecl
)
1773 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl
);
1775 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
)
1776 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
))
1777 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl
)
1778 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl
);
1781 /* Merge the initialization information. */
1782 if (DECL_INITIAL (newdecl
) == NULL_TREE
1783 && DECL_INITIAL (olddecl
) != NULL_TREE
)
1785 DECL_INITIAL (newdecl
) = DECL_INITIAL (olddecl
);
1786 DECL_SOURCE_LOCATION (newdecl
) = DECL_SOURCE_LOCATION (olddecl
);
1787 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl
)
1788 && DECL_LANG_SPECIFIC (newdecl
)
1789 && DECL_LANG_SPECIFIC (olddecl
))
1791 DECL_SAVED_TREE (newdecl
) = DECL_SAVED_TREE (olddecl
);
1792 DECL_STRUCT_FUNCTION (newdecl
) = DECL_STRUCT_FUNCTION (olddecl
);
1796 /* Merge the section attribute.
1797 We want to issue an error if the sections conflict but that must be
1798 done later in decl_attributes since we are called before attributes
1800 if (DECL_SECTION_NAME (newdecl
) == NULL_TREE
)
1801 DECL_SECTION_NAME (newdecl
) = DECL_SECTION_NAME (olddecl
);
1803 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1805 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl
)
1806 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl
);
1807 DECL_NO_LIMIT_STACK (newdecl
) |= DECL_NO_LIMIT_STACK (olddecl
);
1808 TREE_THIS_VOLATILE (newdecl
) |= TREE_THIS_VOLATILE (olddecl
);
1809 TREE_NOTHROW (newdecl
) |= TREE_NOTHROW (olddecl
);
1810 DECL_IS_MALLOC (newdecl
) |= DECL_IS_MALLOC (olddecl
);
1811 DECL_IS_OPERATOR_NEW (newdecl
) |= DECL_IS_OPERATOR_NEW (olddecl
);
1812 DECL_PURE_P (newdecl
) |= DECL_PURE_P (olddecl
);
1813 TREE_READONLY (newdecl
) |= TREE_READONLY (olddecl
);
1814 DECL_LOOPING_CONST_OR_PURE_P (newdecl
)
1815 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl
);
1816 /* Keep the old RTL. */
1817 COPY_DECL_RTL (olddecl
, newdecl
);
1819 else if (TREE_CODE (newdecl
) == VAR_DECL
1820 && (DECL_SIZE (olddecl
) || !DECL_SIZE (newdecl
)))
1822 /* Keep the old RTL. We cannot keep the old RTL if the old
1823 declaration was for an incomplete object and the new
1824 declaration is not since many attributes of the RTL will
1826 COPY_DECL_RTL (olddecl
, newdecl
);
1829 /* If cannot merge, then use the new type and qualifiers,
1830 and don't preserve the old rtl. */
1833 /* Clean out any memory we had of the old declaration. */
1834 tree oldstatic
= value_member (olddecl
, static_aggregates
);
1836 TREE_VALUE (oldstatic
) = error_mark_node
;
1838 TREE_TYPE (olddecl
) = TREE_TYPE (newdecl
);
1839 TREE_READONLY (olddecl
) = TREE_READONLY (newdecl
);
1840 TREE_THIS_VOLATILE (olddecl
) = TREE_THIS_VOLATILE (newdecl
);
1841 TREE_SIDE_EFFECTS (olddecl
) = TREE_SIDE_EFFECTS (newdecl
);
1844 /* Merge the storage class information. */
1845 merge_weak (newdecl
, olddecl
);
1847 DECL_ONE_ONLY (newdecl
) |= DECL_ONE_ONLY (olddecl
);
1848 DECL_DEFER_OUTPUT (newdecl
) |= DECL_DEFER_OUTPUT (olddecl
);
1849 TREE_PUBLIC (newdecl
) = TREE_PUBLIC (olddecl
);
1850 TREE_STATIC (olddecl
) = TREE_STATIC (newdecl
) |= TREE_STATIC (olddecl
);
1851 if (! DECL_EXTERNAL (olddecl
))
1852 DECL_EXTERNAL (newdecl
) = 0;
1854 new_template
= NULL_TREE
;
1855 if (DECL_LANG_SPECIFIC (newdecl
) && DECL_LANG_SPECIFIC (olddecl
))
1857 bool new_redefines_gnu_inline
= false;
1859 if (new_defines_function
1860 && ((DECL_INTERFACE_KNOWN (olddecl
)
1861 && TREE_CODE (olddecl
) == FUNCTION_DECL
)
1862 || (TREE_CODE (olddecl
) == TEMPLATE_DECL
1863 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl
))
1864 == FUNCTION_DECL
))))
1868 if (TREE_CODE (fn
) == TEMPLATE_DECL
)
1869 fn
= DECL_TEMPLATE_RESULT (olddecl
);
1871 new_redefines_gnu_inline
= GNU_INLINE_P (fn
) && DECL_INITIAL (fn
);
1874 if (!new_redefines_gnu_inline
)
1876 DECL_INTERFACE_KNOWN (newdecl
) |= DECL_INTERFACE_KNOWN (olddecl
);
1877 DECL_NOT_REALLY_EXTERN (newdecl
) |= DECL_NOT_REALLY_EXTERN (olddecl
);
1878 DECL_COMDAT (newdecl
) |= DECL_COMDAT (olddecl
);
1880 DECL_TEMPLATE_INSTANTIATED (newdecl
)
1881 |= DECL_TEMPLATE_INSTANTIATED (olddecl
);
1883 /* If the OLDDECL is an instantiation and/or specialization,
1884 then the NEWDECL must be too. But, it may not yet be marked
1885 as such if the caller has created NEWDECL, but has not yet
1886 figured out that it is a redeclaration. */
1887 if (!DECL_USE_TEMPLATE (newdecl
))
1888 DECL_USE_TEMPLATE (newdecl
) = DECL_USE_TEMPLATE (olddecl
);
1890 /* Don't really know how much of the language-specific
1891 values we should copy from old to new. */
1892 DECL_IN_AGGR_P (newdecl
) = DECL_IN_AGGR_P (olddecl
);
1893 DECL_LANG_SPECIFIC (newdecl
)->decl_flags
.u2
=
1894 DECL_LANG_SPECIFIC (olddecl
)->decl_flags
.u2
;
1895 DECL_NONCONVERTING_P (newdecl
) = DECL_NONCONVERTING_P (olddecl
);
1896 DECL_REPO_AVAILABLE_P (newdecl
) = DECL_REPO_AVAILABLE_P (olddecl
);
1897 if (DECL_TEMPLATE_INFO (newdecl
))
1898 new_template
= DECL_TI_TEMPLATE (newdecl
);
1899 DECL_TEMPLATE_INFO (newdecl
) = DECL_TEMPLATE_INFO (olddecl
);
1900 DECL_INITIALIZED_IN_CLASS_P (newdecl
)
1901 |= DECL_INITIALIZED_IN_CLASS_P (olddecl
);
1902 olddecl_friend
= DECL_FRIEND_P (olddecl
);
1903 hidden_friend
= (DECL_ANTICIPATED (olddecl
)
1904 && DECL_HIDDEN_FRIEND_P (olddecl
)
1905 && newdecl_is_friend
);
1907 /* Only functions have DECL_BEFRIENDING_CLASSES. */
1908 if (TREE_CODE (newdecl
) == FUNCTION_DECL
1909 || DECL_FUNCTION_TEMPLATE_P (newdecl
))
1911 DECL_BEFRIENDING_CLASSES (newdecl
)
1912 = chainon (DECL_BEFRIENDING_CLASSES (newdecl
),
1913 DECL_BEFRIENDING_CLASSES (olddecl
));
1914 /* DECL_THUNKS is only valid for virtual functions,
1915 otherwise it is a DECL_FRIEND_CONTEXT. */
1916 if (DECL_VIRTUAL_P (newdecl
))
1917 DECL_THUNKS (newdecl
) = DECL_THUNKS (olddecl
);
1921 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
1923 if (DECL_TEMPLATE_INSTANTIATION (olddecl
)
1924 && !DECL_TEMPLATE_INSTANTIATION (newdecl
))
1926 /* If newdecl is not a specialization, then it is not a
1927 template-related function at all. And that means that we
1928 should have exited above, returning 0. */
1929 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl
));
1931 if (TREE_USED (olddecl
))
1932 /* From [temp.expl.spec]:
1934 If a template, a member template or the member of a class
1935 template is explicitly specialized then that
1936 specialization shall be declared before the first use of
1937 that specialization that would cause an implicit
1938 instantiation to take place, in every translation unit in
1939 which such a use occurs. */
1940 error ("explicit specialization of %qD after first use",
1943 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl
);
1945 /* Don't propagate visibility from the template to the
1946 specialization here. We'll do that in determine_visibility if
1948 DECL_VISIBILITY_SPECIFIED (olddecl
) = 0;
1950 /* [temp.expl.spec/14] We don't inline explicit specialization
1951 just because the primary template says so. */
1953 else if (new_defines_function
&& DECL_INITIAL (olddecl
))
1955 /* Never inline re-defined extern inline functions.
1956 FIXME: this could be better handled by keeping both
1957 function as separate declarations. */
1958 DECL_UNINLINABLE (newdecl
) = 1;
1962 if (DECL_PENDING_INLINE_INFO (newdecl
) == 0)
1963 DECL_PENDING_INLINE_INFO (newdecl
) = DECL_PENDING_INLINE_INFO (olddecl
);
1965 DECL_DECLARED_INLINE_P (newdecl
) |= DECL_DECLARED_INLINE_P (olddecl
);
1967 DECL_UNINLINABLE (newdecl
) = DECL_UNINLINABLE (olddecl
)
1968 = (DECL_UNINLINABLE (newdecl
) || DECL_UNINLINABLE (olddecl
));
1970 DECL_DISREGARD_INLINE_LIMITS (newdecl
)
1971 = DECL_DISREGARD_INLINE_LIMITS (olddecl
)
1972 = (DECL_DISREGARD_INLINE_LIMITS (newdecl
)
1973 || DECL_DISREGARD_INLINE_LIMITS (olddecl
));
1976 /* Preserve abstractness on cloned [cd]tors. */
1977 DECL_ABSTRACT (newdecl
) = DECL_ABSTRACT (olddecl
);
1981 SET_DECL_LANGUAGE (olddecl
, DECL_LANGUAGE (newdecl
));
1982 COPY_DECL_ASSEMBLER_NAME (newdecl
, olddecl
);
1983 COPY_DECL_RTL (newdecl
, olddecl
);
1985 if (! types_match
|| new_defines_function
)
1987 /* These need to be copied so that the names are available.
1988 Note that if the types do match, we'll preserve inline
1989 info and other bits, but if not, we won't. */
1990 DECL_ARGUMENTS (olddecl
) = DECL_ARGUMENTS (newdecl
);
1991 DECL_RESULT (olddecl
) = DECL_RESULT (newdecl
);
1993 if (new_defines_function
)
1994 /* If defining a function declared with other language
1995 linkage, use the previously declared language linkage. */
1996 SET_DECL_LANGUAGE (newdecl
, DECL_LANGUAGE (olddecl
));
1997 else if (types_match
)
1999 /* If redeclaring a builtin function, and not a definition,
2000 it stays built in. */
2001 if (DECL_BUILT_IN (olddecl
))
2003 DECL_BUILT_IN_CLASS (newdecl
) = DECL_BUILT_IN_CLASS (olddecl
);
2004 DECL_FUNCTION_CODE (newdecl
) = DECL_FUNCTION_CODE (olddecl
);
2005 /* If we're keeping the built-in definition, keep the rtl,
2006 regardless of declaration matches. */
2007 COPY_DECL_RTL (olddecl
, newdecl
);
2010 DECL_RESULT (newdecl
) = DECL_RESULT (olddecl
);
2011 /* Don't clear out the arguments if we're redefining a function. */
2012 if (DECL_ARGUMENTS (olddecl
))
2013 DECL_ARGUMENTS (newdecl
) = DECL_ARGUMENTS (olddecl
);
2016 else if (TREE_CODE (newdecl
) == NAMESPACE_DECL
)
2017 NAMESPACE_LEVEL (newdecl
) = NAMESPACE_LEVEL (olddecl
);
2019 /* Now preserve various other info from the definition. */
2020 TREE_ADDRESSABLE (newdecl
) = TREE_ADDRESSABLE (olddecl
);
2021 TREE_ASM_WRITTEN (newdecl
) = TREE_ASM_WRITTEN (olddecl
);
2022 DECL_COMMON (newdecl
) = DECL_COMMON (olddecl
);
2023 COPY_DECL_ASSEMBLER_NAME (olddecl
, newdecl
);
2025 /* Warn about conflicting visibility specifications. */
2026 if (DECL_VISIBILITY_SPECIFIED (olddecl
)
2027 && DECL_VISIBILITY_SPECIFIED (newdecl
)
2028 && DECL_VISIBILITY (newdecl
) != DECL_VISIBILITY (olddecl
))
2030 warning (OPT_Wattributes
, "%q+D: visibility attribute ignored "
2031 "because it", newdecl
);
2032 warning (OPT_Wattributes
, "%Jconflicts with previous "
2033 "declaration here", olddecl
);
2035 /* Choose the declaration which specified visibility. */
2036 if (DECL_VISIBILITY_SPECIFIED (olddecl
))
2038 DECL_VISIBILITY (newdecl
) = DECL_VISIBILITY (olddecl
);
2039 DECL_VISIBILITY_SPECIFIED (newdecl
) = 1;
2041 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2042 so keep this behavior. */
2043 if (TREE_CODE (newdecl
) == VAR_DECL
&& DECL_HAS_INIT_PRIORITY_P (newdecl
))
2045 SET_DECL_INIT_PRIORITY (olddecl
, DECL_INIT_PRIORITY (newdecl
));
2046 DECL_HAS_INIT_PRIORITY_P (olddecl
) = 1;
2049 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2050 with that from NEWDECL below. */
2051 if (DECL_LANG_SPECIFIC (olddecl
))
2053 gcc_assert (DECL_LANG_SPECIFIC (olddecl
)
2054 != DECL_LANG_SPECIFIC (newdecl
));
2055 ggc_free (DECL_LANG_SPECIFIC (olddecl
));
2058 /* Merge the USED information. */
2059 if (TREE_USED (olddecl
))
2060 TREE_USED (newdecl
) = 1;
2061 else if (TREE_USED (newdecl
))
2062 TREE_USED (olddecl
) = 1;
2064 if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2068 function_size
= sizeof (struct tree_decl_common
);
2070 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2071 (char *) newdecl
+ sizeof (struct tree_common
),
2072 function_size
- sizeof (struct tree_common
));
2074 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2075 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2076 sizeof (struct tree_function_decl
) - sizeof (struct tree_decl_common
));
2078 /* If newdecl is a template instantiation, it is possible that
2079 the following sequence of events has occurred:
2081 o A friend function was declared in a class template. The
2082 class template was instantiated.
2084 o The instantiation of the friend declaration was
2085 recorded on the instantiation list, and is newdecl.
2087 o Later, however, instantiate_class_template called pushdecl
2088 on the newdecl to perform name injection. But, pushdecl in
2089 turn called duplicate_decls when it discovered that another
2090 declaration of a global function with the same name already
2093 o Here, in duplicate_decls, we decided to clobber newdecl.
2095 If we're going to do that, we'd better make sure that
2096 olddecl, and not newdecl, is on the list of
2097 instantiations so that if we try to do the instantiation
2098 again we won't get the clobbered declaration. */
2099 reregister_specialization (newdecl
,
2105 size_t size
= tree_code_size (TREE_CODE (olddecl
));
2106 memcpy ((char *) olddecl
+ sizeof (struct tree_common
),
2107 (char *) newdecl
+ sizeof (struct tree_common
),
2108 sizeof (struct tree_decl_common
) - sizeof (struct tree_common
));
2109 switch (TREE_CODE (olddecl
))
2119 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2120 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2121 size
- sizeof (struct tree_decl_common
)
2122 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2126 memcpy ((char *) olddecl
+ sizeof (struct tree_decl_common
),
2127 (char *) newdecl
+ sizeof (struct tree_decl_common
),
2128 sizeof (struct tree_decl_non_common
) - sizeof (struct tree_decl_common
)
2129 + TREE_CODE_LENGTH (TREE_CODE (newdecl
)) * sizeof (char *));
2133 DECL_UID (olddecl
) = olddecl_uid
;
2135 DECL_FRIEND_P (olddecl
) = 1;
2138 DECL_ANTICIPATED (olddecl
) = 1;
2139 DECL_HIDDEN_FRIEND_P (olddecl
) = 1;
2142 /* NEWDECL contains the merged attribute lists.
2143 Update OLDDECL to be the same. */
2144 DECL_ATTRIBUTES (olddecl
) = DECL_ATTRIBUTES (newdecl
);
2146 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2147 so that encode_section_info has a chance to look at the new decl
2148 flags and attributes. */
2149 if (DECL_RTL_SET_P (olddecl
)
2150 && (TREE_CODE (olddecl
) == FUNCTION_DECL
2151 || (TREE_CODE (olddecl
) == VAR_DECL
2152 && TREE_STATIC (olddecl
))))
2153 make_decl_rtl (olddecl
);
2155 /* The NEWDECL will no longer be needed. Because every out-of-class
2156 declaration of a member results in a call to duplicate_decls,
2157 freeing these nodes represents in a significant savings. */
2163 /* Return zero if the declaration NEWDECL is valid
2164 when the declaration OLDDECL (assumed to be for the same name)
2165 has already been seen.
2166 Otherwise return an error message format string with a %s
2167 where the identifier should go. */
2170 redeclaration_error_message (tree newdecl
, tree olddecl
)
2172 if (TREE_CODE (newdecl
) == TYPE_DECL
)
2174 /* Because C++ can put things into name space for free,
2175 constructs like "typedef struct foo { ... } foo"
2176 would look like an erroneous redeclaration. */
2177 if (same_type_p (TREE_TYPE (newdecl
), TREE_TYPE (olddecl
)))
2180 return "redefinition of %q#D";
2182 else if (TREE_CODE (newdecl
) == FUNCTION_DECL
)
2184 /* If this is a pure function, its olddecl will actually be
2185 the original initialization to `0' (which we force to call
2186 abort()). Don't complain about redefinition in this case. */
2187 if (DECL_LANG_SPECIFIC (olddecl
) && DECL_PURE_VIRTUAL_P (olddecl
)
2188 && DECL_INITIAL (olddecl
) == NULL_TREE
)
2191 /* If both functions come from different namespaces, this is not
2192 a redeclaration - this is a conflict with a used function. */
2193 if (DECL_NAMESPACE_SCOPE_P (olddecl
)
2194 && DECL_CONTEXT (olddecl
) != DECL_CONTEXT (newdecl
)
2195 && ! decls_match (olddecl
, newdecl
))
2196 return "%qD conflicts with used function";
2198 /* We'll complain about linkage mismatches in
2199 warn_extern_redeclared_static. */
2201 /* Defining the same name twice is no good. */
2202 if (DECL_INITIAL (olddecl
) != NULL_TREE
2203 && DECL_INITIAL (newdecl
) != NULL_TREE
)
2205 if (DECL_NAME (olddecl
) == NULL_TREE
)
2206 return "%q#D not declared in class";
2207 else if (!GNU_INLINE_P (olddecl
)
2208 || GNU_INLINE_P (newdecl
))
2209 return "redefinition of %q#D";
2212 if (DECL_DECLARED_INLINE_P (olddecl
) && DECL_DECLARED_INLINE_P (newdecl
))
2214 bool olda
= GNU_INLINE_P (olddecl
);
2215 bool newa
= GNU_INLINE_P (newdecl
);
2220 return "%q+D redeclared inline with %<gnu_inline%> attribute";
2222 return "%q+D redeclared inline without %<gnu_inline%> attribute";
2228 else if (TREE_CODE (newdecl
) == TEMPLATE_DECL
)
2232 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) == TYPE_DECL
)
2234 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl
))
2235 && COMPLETE_TYPE_P (TREE_TYPE (olddecl
)))
2236 return "redefinition of %q#D";
2240 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl
)) != FUNCTION_DECL
2241 || (DECL_TEMPLATE_RESULT (newdecl
)
2242 == DECL_TEMPLATE_RESULT (olddecl
)))
2245 nt
= DECL_TEMPLATE_RESULT (newdecl
);
2246 if (DECL_TEMPLATE_INFO (nt
))
2247 nt
= DECL_TEMPLATE_RESULT (template_for_substitution (nt
));
2248 ot
= DECL_TEMPLATE_RESULT (olddecl
);
2249 if (DECL_TEMPLATE_INFO (ot
))
2250 ot
= DECL_TEMPLATE_RESULT (template_for_substitution (ot
));
2251 if (DECL_INITIAL (nt
) && DECL_INITIAL (ot
)
2252 && (!GNU_INLINE_P (ot
) || GNU_INLINE_P (nt
)))
2253 return "redefinition of %q#D";
2255 if (DECL_DECLARED_INLINE_P (ot
) && DECL_DECLARED_INLINE_P (nt
))
2257 bool olda
= GNU_INLINE_P (ot
);
2258 bool newa
= GNU_INLINE_P (nt
);
2263 return "%q+D redeclared inline with %<gnu_inline%> attribute";
2265 return "%q+D redeclared inline without %<gnu_inline%> attribute";
2269 /* Core issue #226 (C++0x):
2271 If a friend function template declaration specifies a
2272 default template-argument, that declaration shall be a
2273 definition and shall be the only declaration of the
2274 function template in the translation unit. */
2275 if ((cxx_dialect
!= cxx98
)
2276 && TREE_CODE (ot
) == FUNCTION_DECL
&& DECL_FRIEND_P (ot
)
2277 && !check_default_tmpl_args (nt
, DECL_TEMPLATE_PARMS (newdecl
),
2278 /*is_primary=*/1, /*is_partial=*/0,
2279 /*is_friend_decl=*/2))
2280 return "redeclaration of friend %q#D may not have default template arguments";
2284 else if (TREE_CODE (newdecl
) == VAR_DECL
2285 && DECL_THREAD_LOCAL_P (newdecl
) != DECL_THREAD_LOCAL_P (olddecl
)
2286 && (! DECL_LANG_SPECIFIC (olddecl
)
2287 || ! CP_DECL_THREADPRIVATE_P (olddecl
)
2288 || DECL_THREAD_LOCAL_P (newdecl
)))
2290 /* Only variables can be thread-local, and all declarations must
2291 agree on this property. */
2292 if (DECL_THREAD_LOCAL_P (newdecl
))
2293 return "thread-local declaration of %q#D follows "
2294 "non-thread-local declaration";
2296 return "non-thread-local declaration of %q#D follows "
2297 "thread-local declaration";
2299 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl
))
2301 /* The objects have been declared at namespace scope. If either
2302 is a member of an anonymous union, then this is an invalid
2303 redeclaration. For example:
2309 if ((TREE_CODE (newdecl
) == VAR_DECL
&& DECL_ANON_UNION_VAR_P (newdecl
))
2310 || (TREE_CODE (olddecl
) == VAR_DECL
&& DECL_ANON_UNION_VAR_P (olddecl
)))
2311 return "redeclaration of %q#D";
2312 /* If at least one declaration is a reference, there is no
2313 conflict. For example:
2319 if (DECL_EXTERNAL (newdecl
) || DECL_EXTERNAL (olddecl
))
2321 /* Reject two definitions. */
2322 return "redefinition of %q#D";
2326 /* Objects declared with block scope: */
2327 /* Reject two definitions, and reject a definition
2328 together with an external reference. */
2329 if (!(DECL_EXTERNAL (newdecl
) && DECL_EXTERNAL (olddecl
)))
2330 return "redeclaration of %q#D";
2335 /* Hash and equality functions for the named_label table. */
2338 named_label_entry_hash (const void *data
)
2340 const struct named_label_entry
*ent
= (const struct named_label_entry
*) data
;
2341 return DECL_UID (ent
->label_decl
);
2345 named_label_entry_eq (const void *a
, const void *b
)
2347 const struct named_label_entry
*ent_a
= (const struct named_label_entry
*) a
;
2348 const struct named_label_entry
*ent_b
= (const struct named_label_entry
*) b
;
2349 return ent_a
->label_decl
== ent_b
->label_decl
;
2352 /* Create a new label, named ID. */
2355 make_label_decl (tree id
, int local_p
)
2357 struct named_label_entry
*ent
;
2361 decl
= build_decl (LABEL_DECL
, id
, void_type_node
);
2363 DECL_CONTEXT (decl
) = current_function_decl
;
2364 DECL_MODE (decl
) = VOIDmode
;
2365 C_DECLARED_LABEL_FLAG (decl
) = local_p
;
2367 /* Say where one reference is to the label, for the sake of the
2368 error if it is not defined. */
2369 DECL_SOURCE_LOCATION (decl
) = input_location
;
2371 /* Record the fact that this identifier is bound to this label. */
2372 SET_IDENTIFIER_LABEL_VALUE (id
, decl
);
2374 /* Create the label htab for the function on demand. */
2376 named_labels
= htab_create_ggc (13, named_label_entry_hash
,
2377 named_label_entry_eq
, NULL
);
2379 /* Record this label on the list of labels used in this function.
2380 We do this before calling make_label_decl so that we get the
2381 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2382 ent
= GGC_CNEW (struct named_label_entry
);
2383 ent
->label_decl
= decl
;
2385 slot
= htab_find_slot (named_labels
, ent
, INSERT
);
2386 gcc_assert (*slot
== NULL
);
2392 /* Look for a label named ID in the current function. If one cannot
2393 be found, create one. (We keep track of used, but undefined,
2394 labels, and complain about them at the end of a function.) */
2397 lookup_label (tree id
)
2401 timevar_push (TV_NAME_LOOKUP
);
2402 /* You can't use labels at global scope. */
2403 if (current_function_decl
== NULL_TREE
)
2405 error ("label %qE referenced outside of any function", id
);
2406 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, NULL_TREE
);
2409 /* See if we've already got this label. */
2410 decl
= IDENTIFIER_LABEL_VALUE (id
);
2411 if (decl
!= NULL_TREE
&& DECL_CONTEXT (decl
) == current_function_decl
)
2412 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2414 decl
= make_label_decl (id
, /*local_p=*/0);
2415 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2418 /* Declare a local label named ID. */
2421 declare_local_label (tree id
)
2425 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
2426 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2427 shadow
= tree_cons (IDENTIFIER_LABEL_VALUE (id
), NULL_TREE
,
2428 current_binding_level
->shadowed_labels
);
2429 current_binding_level
->shadowed_labels
= shadow
;
2431 decl
= make_label_decl (id
, /*local_p=*/1);
2432 TREE_VALUE (shadow
) = decl
;
2437 /* Returns nonzero if it is ill-formed to jump past the declaration of
2438 DECL. Returns 2 if it's also a real problem. */
2441 decl_jump_unsafe (tree decl
)
2443 if (TREE_CODE (decl
) != VAR_DECL
|| TREE_STATIC (decl
)
2444 || TREE_TYPE (decl
) == error_mark_node
)
2447 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
))
2448 || DECL_NONTRIVIALLY_INITIALIZED_P (decl
))
2451 if (pod_type_p (TREE_TYPE (decl
)))
2454 /* The POD stuff is just pedantry; why should it matter if the class
2455 contains a field of pointer to member type? */
2459 /* A subroutine of check_previous_goto_1 to identify a branch to the user. */
2462 identify_goto (tree decl
, const location_t
*locus
)
2465 permerror (input_location
, "jump to label %qD", decl
);
2467 permerror (input_location
, "jump to case label");
2469 permerror (input_location
, "%H from here", locus
);
2472 /* Check that a single previously seen jump to a newly defined label
2473 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2474 the jump context; NAMES are the names in scope in LEVEL at the jump
2475 context; LOCUS is the source position of the jump or 0. Returns
2476 true if all is well. */
2479 check_previous_goto_1 (tree decl
, struct cp_binding_level
* level
, tree names
,
2480 bool exited_omp
, const location_t
*locus
)
2482 struct cp_binding_level
*b
;
2483 bool identified
= false, saw_eh
= false, saw_omp
= false;
2487 identify_goto (decl
, locus
);
2488 error (" exits OpenMP structured block");
2489 identified
= saw_omp
= true;
2492 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
2494 tree new_decls
, old_decls
= (b
== level
? names
: NULL_TREE
);
2496 for (new_decls
= b
->names
; new_decls
!= old_decls
;
2497 new_decls
= TREE_CHAIN (new_decls
))
2499 int problem
= decl_jump_unsafe (new_decls
);
2505 identify_goto (decl
, locus
);
2509 error (" crosses initialization of %q+#D", new_decls
);
2511 permerror (input_location
, " enters scope of non-POD %q+#D", new_decls
);
2516 if ((b
->kind
== sk_try
|| b
->kind
== sk_catch
) && !saw_eh
)
2520 identify_goto (decl
, locus
);
2523 if (b
->kind
== sk_try
)
2524 error (" enters try block");
2526 error (" enters catch block");
2529 if (b
->kind
== sk_omp
&& !saw_omp
)
2533 identify_goto (decl
, locus
);
2536 error (" enters OpenMP structured block");
2545 check_previous_goto (tree decl
, struct named_label_use_entry
*use
)
2547 check_previous_goto_1 (decl
, use
->binding_level
,
2548 use
->names_in_scope
, use
->in_omp_scope
,
2549 &use
->o_goto_locus
);
2553 check_switch_goto (struct cp_binding_level
* level
)
2555 return check_previous_goto_1 (NULL_TREE
, level
, level
->names
, false, NULL
);
2558 /* Check that a new jump to a label DECL is OK. Called by
2559 finish_goto_stmt. */
2562 check_goto (tree decl
)
2564 struct named_label_entry
*ent
, dummy
;
2565 bool saw_catch
= false, identified
= false;
2568 /* We can't know where a computed goto is jumping.
2569 So we assume that it's OK. */
2570 if (TREE_CODE (decl
) != LABEL_DECL
)
2573 /* We didn't record any information about this label when we created it,
2574 and there's not much point since it's trivial to analyze as a return. */
2575 if (decl
== cdtor_label
)
2578 dummy
.label_decl
= decl
;
2579 ent
= (struct named_label_entry
*) htab_find (named_labels
, &dummy
);
2580 gcc_assert (ent
!= NULL
);
2582 /* If the label hasn't been defined yet, defer checking. */
2583 if (! DECL_INITIAL (decl
))
2585 struct named_label_use_entry
*new_use
;
2587 /* Don't bother creating another use if the last goto had the
2588 same data, and will therefore create the same set of errors. */
2590 && ent
->uses
->names_in_scope
== current_binding_level
->names
)
2593 new_use
= GGC_NEW (struct named_label_use_entry
);
2594 new_use
->binding_level
= current_binding_level
;
2595 new_use
->names_in_scope
= current_binding_level
->names
;
2596 new_use
->o_goto_locus
= input_location
;
2597 new_use
->in_omp_scope
= false;
2599 new_use
->next
= ent
->uses
;
2600 ent
->uses
= new_use
;
2604 if (ent
->in_try_scope
|| ent
->in_catch_scope
2605 || ent
->in_omp_scope
|| ent
->bad_decls
)
2607 permerror (input_location
, "jump to label %q+D", decl
);
2608 permerror (input_location
, " from here");
2612 for (bad
= ent
->bad_decls
; bad
; bad
= TREE_CHAIN (bad
))
2614 tree b
= TREE_VALUE (bad
);
2615 int u
= decl_jump_unsafe (b
);
2617 if (u
> 1 && DECL_ARTIFICIAL (b
))
2619 /* Can't skip init of __exception_info. */
2620 error ("%J enters catch block", b
);
2624 error (" skips initialization of %q+#D", b
);
2626 permerror (input_location
, " enters scope of non-POD %q+#D", b
);
2629 if (ent
->in_try_scope
)
2630 error (" enters try block");
2631 else if (ent
->in_catch_scope
&& !saw_catch
)
2632 error (" enters catch block");
2634 if (ent
->in_omp_scope
)
2635 error (" enters OpenMP structured block");
2636 else if (flag_openmp
)
2638 struct cp_binding_level
*b
;
2639 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
2641 if (b
== ent
->binding_level
)
2643 if (b
->kind
== sk_omp
)
2647 permerror (input_location
, "jump to label %q+D", decl
);
2648 permerror (input_location
, " from here");
2651 error (" exits OpenMP structured block");
2658 /* Check that a return is ok wrt OpenMP structured blocks.
2659 Called by finish_return_stmt. Returns true if all is well. */
2662 check_omp_return (void)
2664 struct cp_binding_level
*b
;
2665 for (b
= current_binding_level
; b
; b
= b
->level_chain
)
2666 if (b
->kind
== sk_omp
)
2668 error ("invalid exit from OpenMP structured block");
2674 /* Define a label, specifying the location in the source file.
2675 Return the LABEL_DECL node for the label. */
2678 define_label (location_t location
, tree name
)
2680 struct named_label_entry
*ent
, dummy
;
2681 struct cp_binding_level
*p
;
2684 timevar_push (TV_NAME_LOOKUP
);
2686 decl
= lookup_label (name
);
2688 dummy
.label_decl
= decl
;
2689 ent
= (struct named_label_entry
*) htab_find (named_labels
, &dummy
);
2690 gcc_assert (ent
!= NULL
);
2692 /* After labels, make any new cleanups in the function go into their
2693 own new (temporary) binding contour. */
2694 for (p
= current_binding_level
;
2695 p
->kind
!= sk_function_parms
;
2697 p
->more_cleanups_ok
= 0;
2699 if (name
== get_identifier ("wchar_t"))
2700 permerror (input_location
, "label named wchar_t");
2702 if (DECL_INITIAL (decl
) != NULL_TREE
)
2704 error ("duplicate label %qD", decl
);
2705 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
2709 struct named_label_use_entry
*use
;
2711 /* Mark label as having been defined. */
2712 DECL_INITIAL (decl
) = error_mark_node
;
2713 /* Say where in the source. */
2714 DECL_SOURCE_LOCATION (decl
) = location
;
2716 ent
->binding_level
= current_binding_level
;
2717 ent
->names_in_scope
= current_binding_level
->names
;
2719 for (use
= ent
->uses
; use
; use
= use
->next
)
2720 check_previous_goto (decl
, use
);
2724 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, decl
);
2729 struct cp_binding_level
*level
;
2730 struct cp_switch
*next
;
2731 /* The SWITCH_STMT being built. */
2733 /* A splay-tree mapping the low element of a case range to the high
2734 element, or NULL_TREE if there is no high element. Used to
2735 determine whether or not a new case label duplicates an old case
2736 label. We need a tree, rather than simply a hash table, because
2737 of the GNU case range extension. */
2741 /* A stack of the currently active switch statements. The innermost
2742 switch statement is on the top of the stack. There is no need to
2743 mark the stack for garbage collection because it is only active
2744 during the processing of the body of a function, and we never
2745 collect at that point. */
2747 static struct cp_switch
*switch_stack
;
2749 /* Called right after a switch-statement condition is parsed.
2750 SWITCH_STMT is the switch statement being parsed. */
2753 push_switch (tree switch_stmt
)
2755 struct cp_switch
*p
= XNEW (struct cp_switch
);
2756 p
->level
= current_binding_level
;
2757 p
->next
= switch_stack
;
2758 p
->switch_stmt
= switch_stmt
;
2759 p
->cases
= splay_tree_new (case_compare
, NULL
, NULL
);
2766 struct cp_switch
*cs
= switch_stack
;
2767 location_t switch_location
;
2769 /* Emit warnings as needed. */
2770 if (EXPR_HAS_LOCATION (cs
->switch_stmt
))
2771 switch_location
= EXPR_LOCATION (cs
->switch_stmt
);
2773 switch_location
= input_location
;
2774 if (!processing_template_decl
)
2775 c_do_switch_warnings (cs
->cases
, switch_location
,
2776 SWITCH_STMT_TYPE (cs
->switch_stmt
),
2777 SWITCH_STMT_COND (cs
->switch_stmt
));
2779 splay_tree_delete (cs
->cases
);
2780 switch_stack
= switch_stack
->next
;
2784 /* Note that we've seen a definition of a case label, and complain if this
2785 is a bad place for one. */
2788 finish_case_label (tree low_value
, tree high_value
)
2791 struct cp_binding_level
*p
;
2793 if (processing_template_decl
)
2797 /* For templates, just add the case label; we'll do semantic
2798 analysis at instantiation-time. */
2799 label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
2800 return add_stmt (build_case_label (low_value
, high_value
, label
));
2803 /* Find the condition on which this switch statement depends. */
2804 cond
= SWITCH_STMT_COND (switch_stack
->switch_stmt
);
2805 if (cond
&& TREE_CODE (cond
) == TREE_LIST
)
2806 cond
= TREE_VALUE (cond
);
2808 if (!check_switch_goto (switch_stack
->level
))
2809 return error_mark_node
;
2811 r
= c_add_case_label (switch_stack
->cases
, cond
, TREE_TYPE (cond
),
2812 low_value
, high_value
);
2814 /* After labels, make any new cleanups in the function go into their
2815 own new (temporary) binding contour. */
2816 for (p
= current_binding_level
;
2817 p
->kind
!= sk_function_parms
;
2819 p
->more_cleanups_ok
= 0;
2824 /* Hash a TYPENAME_TYPE. K is really of type `tree'. */
2827 typename_hash (const void* k
)
2830 const_tree
const t
= (const_tree
) k
;
2832 hash
= (htab_hash_pointer (TYPE_CONTEXT (t
))
2833 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t
))));
2838 typedef struct typename_info
{
2846 /* Compare two TYPENAME_TYPEs. K1 is really of type `tree', K2 is
2847 really of type `typename_info*' */
2850 typename_compare (const void * k1
, const void * k2
)
2852 const_tree
const t1
= (const_tree
) k1
;
2853 const typename_info
*const t2
= (const typename_info
*) k2
;
2855 return (DECL_NAME (TYPE_NAME (t1
)) == t2
->name
2856 && TYPE_CONTEXT (t1
) == t2
->scope
2857 && TYPENAME_TYPE_FULLNAME (t1
) == t2
->template_id
2858 && TYPENAME_IS_ENUM_P (t1
) == t2
->enum_p
2859 && TYPENAME_IS_CLASS_P (t1
) == t2
->class_p
);
2862 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
2863 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
2865 Returns the new TYPENAME_TYPE. */
2867 static GTY ((param_is (union tree_node
))) htab_t typename_htab
;
2870 build_typename_type (tree context
, tree name
, tree fullname
,
2871 enum tag_types tag_type
)
2879 if (typename_htab
== NULL
)
2880 typename_htab
= htab_create_ggc (61, &typename_hash
,
2881 &typename_compare
, NULL
);
2883 ti
.scope
= FROB_CONTEXT (context
);
2885 ti
.template_id
= fullname
;
2886 ti
.enum_p
= tag_type
== enum_type
;
2887 ti
.class_p
= (tag_type
== class_type
2888 || tag_type
== record_type
2889 || tag_type
== union_type
);
2890 hash
= (htab_hash_pointer (ti
.scope
)
2891 ^ htab_hash_pointer (ti
.name
));
2893 /* See if we already have this type. */
2894 e
= htab_find_slot_with_hash (typename_htab
, &ti
, hash
, INSERT
);
2899 /* Build the TYPENAME_TYPE. */
2900 t
= cxx_make_type (TYPENAME_TYPE
);
2901 TYPE_CONTEXT (t
) = ti
.scope
;
2902 TYPENAME_TYPE_FULLNAME (t
) = ti
.template_id
;
2903 TYPENAME_IS_ENUM_P (t
) = ti
.enum_p
;
2904 TYPENAME_IS_CLASS_P (t
) = ti
.class_p
;
2906 /* Build the corresponding TYPE_DECL. */
2907 d
= build_decl (TYPE_DECL
, name
, t
);
2908 TYPE_NAME (TREE_TYPE (d
)) = d
;
2909 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
2910 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
2911 DECL_ARTIFICIAL (d
) = 1;
2913 /* Store it in the hash table. */
2916 /* TYPENAME_TYPEs must always be compared structurally, because
2917 they may or may not resolve down to another type depending on
2918 the currently open classes. */
2919 SET_TYPE_STRUCTURAL_EQUALITY (t
);
2925 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
2926 provided to name the type. Returns an appropriate type, unless an
2927 error occurs, in which case error_mark_node is returned. If we
2928 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
2929 return that, rather than the _TYPE it corresponds to, in other
2930 cases we look through the type decl. If TF_ERROR is set, complain
2931 about errors, otherwise be quiet. */
2934 make_typename_type (tree context
, tree name
, enum tag_types tag_type
,
2935 tsubst_flags_t complain
)
2941 if (name
== error_mark_node
2942 || context
== NULL_TREE
2943 || context
== error_mark_node
)
2944 return error_mark_node
;
2948 if (!(TYPE_LANG_SPECIFIC (name
)
2949 && (CLASSTYPE_IS_TEMPLATE (name
)
2950 || CLASSTYPE_USE_TEMPLATE (name
))))
2951 name
= TYPE_IDENTIFIER (name
);
2953 /* Create a TEMPLATE_ID_EXPR for the type. */
2954 name
= build_nt (TEMPLATE_ID_EXPR
,
2955 CLASSTYPE_TI_TEMPLATE (name
),
2956 CLASSTYPE_TI_ARGS (name
));
2958 else if (TREE_CODE (name
) == TYPE_DECL
)
2959 name
= DECL_NAME (name
);
2963 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
2965 name
= TREE_OPERAND (name
, 0);
2966 if (TREE_CODE (name
) == TEMPLATE_DECL
)
2967 name
= TREE_OPERAND (fullname
, 0) = DECL_NAME (name
);
2968 else if (TREE_CODE (name
) == OVERLOAD
)
2970 error ("%qD is not a type", name
);
2971 return error_mark_node
;
2974 if (TREE_CODE (name
) == TEMPLATE_DECL
)
2976 error ("%qD used without template parameters", name
);
2977 return error_mark_node
;
2979 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
2980 gcc_assert (TYPE_P (context
));
2982 /* When the CONTEXT is a dependent type, NAME could refer to a
2983 dependent base class of CONTEXT. So we cannot peek inside it,
2984 even if CONTEXT is a currently open scope. */
2985 if (dependent_type_p (context
))
2986 return build_typename_type (context
, name
, fullname
, tag_type
);
2988 if (!MAYBE_CLASS_TYPE_P (context
))
2990 if (complain
& tf_error
)
2991 error ("%q#T is not a class", context
);
2992 return error_mark_node
;
2995 want_template
= TREE_CODE (fullname
) == TEMPLATE_ID_EXPR
;
2997 /* We should only set WANT_TYPE when we're a nested typename type.
2998 Then we can give better diagnostics if we find a non-type. */
2999 t
= lookup_field (context
, name
, 0, /*want_type=*/true);
3002 if (complain
& tf_error
)
3003 error (want_template
? "no class template named %q#T in %q#T"
3004 : "no type named %q#T in %q#T", name
, context
);
3005 return error_mark_node
;
3008 if (want_template
&& !DECL_CLASS_TEMPLATE_P (t
))
3010 if (complain
& tf_error
)
3011 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3013 return error_mark_node
;
3015 if (!want_template
&& TREE_CODE (t
) != TYPE_DECL
)
3017 if (complain
& tf_error
)
3018 error ("%<typename %T::%D%> names %q#T, which is not a type",
3020 return error_mark_node
;
3023 if (complain
& tf_error
)
3024 perform_or_defer_access_check (TYPE_BINFO (context
), t
, t
);
3027 return lookup_template_class (t
, TREE_OPERAND (fullname
, 1),
3029 /*entering_scope=*/0,
3030 tf_warning_or_error
| tf_user
);
3032 if (DECL_ARTIFICIAL (t
) || !(complain
& tf_keep_type_decl
))
3038 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3039 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3040 in which case error_mark_node is returned.
3042 If PARM_LIST is non-NULL, also make sure that the template parameter
3043 list of TEMPLATE_DECL matches.
3045 If COMPLAIN zero, don't complain about any errors that occur. */
3048 make_unbound_class_template (tree context
, tree name
, tree parm_list
,
3049 tsubst_flags_t complain
)
3055 name
= TYPE_IDENTIFIER (name
);
3056 else if (DECL_P (name
))
3057 name
= DECL_NAME (name
);
3058 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
3060 if (!dependent_type_p (context
)
3061 || currently_open_class (context
))
3063 tree tmpl
= NULL_TREE
;
3065 if (MAYBE_CLASS_TYPE_P (context
))
3066 tmpl
= lookup_field (context
, name
, 0, false);
3068 if (!tmpl
|| !DECL_CLASS_TEMPLATE_P (tmpl
))
3070 if (complain
& tf_error
)
3071 error ("no class template named %q#T in %q#T", name
, context
);
3072 return error_mark_node
;
3076 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl
), parm_list
))
3078 if (complain
& tf_error
)
3080 error ("template parameters do not match template");
3081 error ("%q+D declared here", tmpl
);
3083 return error_mark_node
;
3086 if (complain
& tf_error
)
3087 perform_or_defer_access_check (TYPE_BINFO (context
), tmpl
, tmpl
);
3092 /* Build the UNBOUND_CLASS_TEMPLATE. */
3093 t
= cxx_make_type (UNBOUND_CLASS_TEMPLATE
);
3094 TYPE_CONTEXT (t
) = FROB_CONTEXT (context
);
3095 TREE_TYPE (t
) = NULL_TREE
;
3096 SET_TYPE_STRUCTURAL_EQUALITY (t
);
3098 /* Build the corresponding TEMPLATE_DECL. */
3099 d
= build_decl (TEMPLATE_DECL
, name
, t
);
3100 TYPE_NAME (TREE_TYPE (d
)) = d
;
3101 TYPE_STUB_DECL (TREE_TYPE (d
)) = d
;
3102 DECL_CONTEXT (d
) = FROB_CONTEXT (context
);
3103 DECL_ARTIFICIAL (d
) = 1;
3104 DECL_TEMPLATE_PARMS (d
) = parm_list
;
3111 /* Push the declarations of builtin types into the namespace.
3112 RID_INDEX is the index of the builtin type in the array
3113 RID_POINTERS. NAME is the name used when looking up the builtin
3114 type. TYPE is the _TYPE node for the builtin type. */
3117 record_builtin_type (enum rid rid_index
,
3121 tree rname
= NULL_TREE
, tname
= NULL_TREE
;
3122 tree tdecl
= NULL_TREE
;
3124 if ((int) rid_index
< (int) RID_MAX
)
3125 rname
= ridpointers
[(int) rid_index
];
3127 tname
= get_identifier (name
);
3129 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
3130 eliminated. Built-in types should not be looked up name; their
3131 names are keywords that the parser can recognize. However, there
3132 is code in c-common.c that uses identifier_global_value to look
3133 up built-in types by name. */
3136 tdecl
= build_decl (TYPE_DECL
, tname
, type
);
3137 DECL_ARTIFICIAL (tdecl
) = 1;
3138 SET_IDENTIFIER_GLOBAL_VALUE (tname
, tdecl
);
3144 tdecl
= build_decl (TYPE_DECL
, rname
, type
);
3145 DECL_ARTIFICIAL (tdecl
) = 1;
3147 SET_IDENTIFIER_GLOBAL_VALUE (rname
, tdecl
);
3150 if (!TYPE_NAME (type
))
3151 TYPE_NAME (type
) = tdecl
;
3154 debug_hooks
->type_decl (tdecl
, 0);
3157 /* Record one of the standard Java types.
3158 * Declare it as having the given NAME.
3159 * If SIZE > 0, it is the size of one of the integral types;
3160 * otherwise it is the negative of the size of one of the other types. */
3163 record_builtin_java_type (const char* name
, int size
)
3167 type
= make_signed_type (size
);
3168 else if (size
> -32)
3169 { /* "__java_char" or ""__java_boolean". */
3170 type
= make_unsigned_type (-size
);
3171 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
3174 { /* "__java_float" or ""__java_double". */
3175 type
= make_node (REAL_TYPE
);
3176 TYPE_PRECISION (type
) = - size
;
3179 record_builtin_type (RID_MAX
, name
, type
);
3180 decl
= TYPE_NAME (type
);
3182 /* Suppress generate debug symbol entries for these types,
3183 since for normal C++ they are just clutter.
3184 However, push_lang_context undoes this if extern "Java" is seen. */
3185 DECL_IGNORED_P (decl
) = 1;
3187 TYPE_FOR_JAVA (type
) = 1;
3191 /* Push a type into the namespace so that the back ends ignore it. */
3194 record_unknown_type (tree type
, const char* name
)
3196 tree decl
= pushdecl (build_decl (TYPE_DECL
, get_identifier (name
), type
));
3197 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3198 DECL_IGNORED_P (decl
) = 1;
3199 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
3200 TYPE_SIZE (type
) = TYPE_SIZE (void_type_node
);
3201 TYPE_ALIGN (type
) = 1;
3202 TYPE_USER_ALIGN (type
) = 0;
3203 TYPE_MODE (type
) = TYPE_MODE (void_type_node
);
3206 /* A string for which we should create an IDENTIFIER_NODE at
3209 typedef struct predefined_identifier
3211 /* The name of the identifier. */
3212 const char *const name
;
3213 /* The place where the IDENTIFIER_NODE should be stored. */
3215 /* Nonzero if this is the name of a constructor or destructor. */
3216 const int ctor_or_dtor_p
;
3217 } predefined_identifier
;
3219 /* Create all the predefined identifiers. */
3222 initialize_predefined_identifiers (void)
3224 const predefined_identifier
*pid
;
3226 /* A table of identifiers to create at startup. */
3227 static const predefined_identifier predefined_identifiers
[] = {
3228 { "C++", &lang_name_cplusplus
, 0 },
3229 { "C", &lang_name_c
, 0 },
3230 { "Java", &lang_name_java
, 0 },
3231 /* Some of these names have a trailing space so that it is
3232 impossible for them to conflict with names written by users. */
3233 { "__ct ", &ctor_identifier
, 1 },
3234 { "__base_ctor ", &base_ctor_identifier
, 1 },
3235 { "__comp_ctor ", &complete_ctor_identifier
, 1 },
3236 { "__dt ", &dtor_identifier
, 1 },
3237 { "__comp_dtor ", &complete_dtor_identifier
, 1 },
3238 { "__base_dtor ", &base_dtor_identifier
, 1 },
3239 { "__deleting_dtor ", &deleting_dtor_identifier
, 1 },
3240 { IN_CHARGE_NAME
, &in_charge_identifier
, 0 },
3241 { "nelts", &nelts_identifier
, 0 },
3242 { THIS_NAME
, &this_identifier
, 0 },
3243 { VTABLE_DELTA_NAME
, &delta_identifier
, 0 },
3244 { VTABLE_PFN_NAME
, &pfn_identifier
, 0 },
3245 { "_vptr", &vptr_identifier
, 0 },
3246 { "__vtt_parm", &vtt_parm_identifier
, 0 },
3247 { "::", &global_scope_name
, 0 },
3248 { "std", &std_identifier
, 0 },
3252 for (pid
= predefined_identifiers
; pid
->name
; ++pid
)
3254 *pid
->node
= get_identifier (pid
->name
);
3255 if (pid
->ctor_or_dtor_p
)
3256 IDENTIFIER_CTOR_OR_DTOR_P (*pid
->node
) = 1;
3260 /* Create the predefined scalar types of C,
3261 and some nodes representing standard constants (0, 1, (void *)0).
3262 Initialize the global binding level.
3263 Make definitions for built-in primitive functions. */
3266 cxx_init_decl_processing (void)
3269 tree void_ftype_ptr
;
3271 build_common_tree_nodes (flag_signed_char
, false);
3273 /* Create all the identifiers we need. */
3274 initialize_predefined_identifiers ();
3276 /* Create the global variables. */
3277 push_to_top_level ();
3279 current_function_decl
= NULL_TREE
;
3280 current_binding_level
= NULL
;
3281 /* Enter the global namespace. */
3282 gcc_assert (global_namespace
== NULL_TREE
);
3283 global_namespace
= build_lang_decl (NAMESPACE_DECL
, global_scope_name
,
3285 TREE_PUBLIC (global_namespace
) = 1;
3286 begin_scope (sk_namespace
, global_namespace
);
3288 current_lang_name
= NULL_TREE
;
3290 if (flag_visibility_ms_compat
)
3291 default_visibility
= VISIBILITY_HIDDEN
;
3294 current_lang_name
= lang_name_c
;
3296 /* Create the `std' namespace. */
3297 push_namespace (std_identifier
);
3298 std_node
= current_namespace
;
3301 c_common_nodes_and_builtins ();
3303 java_byte_type_node
= record_builtin_java_type ("__java_byte", 8);
3304 java_short_type_node
= record_builtin_java_type ("__java_short", 16);
3305 java_int_type_node
= record_builtin_java_type ("__java_int", 32);
3306 java_long_type_node
= record_builtin_java_type ("__java_long", 64);
3307 java_float_type_node
= record_builtin_java_type ("__java_float", -32);
3308 java_double_type_node
= record_builtin_java_type ("__java_double", -64);
3309 java_char_type_node
= record_builtin_java_type ("__java_char", -16);
3310 java_boolean_type_node
= record_builtin_java_type ("__java_boolean", -1);
3312 integer_two_node
= build_int_cst (NULL_TREE
, 2);
3313 integer_three_node
= build_int_cst (NULL_TREE
, 3);
3315 record_builtin_type (RID_BOOL
, "bool", boolean_type_node
);
3316 truthvalue_type_node
= boolean_type_node
;
3317 truthvalue_false_node
= boolean_false_node
;
3318 truthvalue_true_node
= boolean_true_node
;
3320 empty_except_spec
= build_tree_list (NULL_TREE
, NULL_TREE
);
3323 record_builtin_type (RID_MAX
, NULL
, string_type_node
);
3326 delta_type_node
= ptrdiff_type_node
;
3327 vtable_index_type
= ptrdiff_type_node
;
3329 vtt_parm_type
= build_pointer_type (const_ptr_type_node
);
3330 void_ftype
= build_function_type (void_type_node
, void_list_node
);
3331 void_ftype_ptr
= build_function_type (void_type_node
,
3332 tree_cons (NULL_TREE
,
3336 = build_exception_variant (void_ftype_ptr
, empty_except_spec
);
3338 /* C++ extensions */
3340 unknown_type_node
= make_node (UNKNOWN_TYPE
);
3341 record_unknown_type (unknown_type_node
, "unknown type");
3343 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3344 TREE_TYPE (unknown_type_node
) = unknown_type_node
;
3346 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3348 TYPE_POINTER_TO (unknown_type_node
) = unknown_type_node
;
3349 TYPE_REFERENCE_TO (unknown_type_node
) = unknown_type_node
;
3351 init_list_type_node
= make_node (UNKNOWN_TYPE
);
3352 record_unknown_type (init_list_type_node
, "init list");
3355 /* Make sure we get a unique function type, so we can give
3356 its pointer type a name. (This wins for gdb.) */
3357 tree vfunc_type
= make_node (FUNCTION_TYPE
);
3358 TREE_TYPE (vfunc_type
) = integer_type_node
;
3359 TYPE_ARG_TYPES (vfunc_type
) = NULL_TREE
;
3360 layout_type (vfunc_type
);
3362 vtable_entry_type
= build_pointer_type (vfunc_type
);
3364 record_builtin_type (RID_MAX
, VTBL_PTR_TYPE
, vtable_entry_type
);
3367 = build_cplus_array_type (vtable_entry_type
, NULL_TREE
);
3368 layout_type (vtbl_type_node
);
3369 vtbl_type_node
= build_qualified_type (vtbl_type_node
, TYPE_QUAL_CONST
);
3370 record_builtin_type (RID_MAX
, NULL
, vtbl_type_node
);
3371 vtbl_ptr_type_node
= build_pointer_type (vtable_entry_type
);
3372 layout_type (vtbl_ptr_type_node
);
3373 record_builtin_type (RID_MAX
, NULL
, vtbl_ptr_type_node
);
3375 push_namespace (get_identifier ("__cxxabiv1"));
3376 abi_node
= current_namespace
;
3379 global_type_node
= make_node (LANG_TYPE
);
3380 record_unknown_type (global_type_node
, "global type");
3383 current_lang_name
= lang_name_cplusplus
;
3387 tree bad_alloc_type_node
;
3388 tree bad_alloc_decl
;
3389 tree newtype
, deltype
;
3390 tree ptr_ftype_sizetype
;
3392 push_namespace (std_identifier
);
3393 bad_alloc_id
= get_identifier ("bad_alloc");
3394 bad_alloc_type_node
= make_class_type (RECORD_TYPE
);
3395 TYPE_CONTEXT (bad_alloc_type_node
) = current_namespace
;
3397 = create_implicit_typedef (bad_alloc_id
, bad_alloc_type_node
);
3398 DECL_CONTEXT (bad_alloc_decl
) = current_namespace
;
3399 TYPE_STUB_DECL (bad_alloc_type_node
) = bad_alloc_decl
;
3403 = build_function_type (ptr_type_node
,
3404 tree_cons (NULL_TREE
,
3407 newtype
= build_exception_variant
3408 (ptr_ftype_sizetype
, add_exception_specifier
3409 (NULL_TREE
, bad_alloc_type_node
, -1));
3410 deltype
= build_exception_variant (void_ftype_ptr
, empty_except_spec
);
3411 push_cp_library_fn (NEW_EXPR
, newtype
);
3412 push_cp_library_fn (VEC_NEW_EXPR
, newtype
);
3413 global_delete_fndecl
= push_cp_library_fn (DELETE_EXPR
, deltype
);
3414 push_cp_library_fn (VEC_DELETE_EXPR
, deltype
);
3418 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype
);
3420 /* Perform other language dependent initializations. */
3421 init_class_processing ();
3422 init_rtti_processing ();
3424 if (flag_exceptions
)
3425 init_exception_processing ();
3427 if (! supports_one_only ())
3430 make_fname_decl
= cp_make_fname_decl
;
3431 start_fname_decls ();
3433 /* Show we use EH for cleanups. */
3434 if (flag_exceptions
)
3435 using_eh_for_cleanups ();
3438 /* Generate an initializer for a function naming variable from
3439 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
3440 filled in with the type of the init. */
3443 cp_fname_init (const char* name
, tree
*type_p
)
3445 tree domain
= NULL_TREE
;
3447 tree init
= NULL_TREE
;
3452 length
= strlen (name
);
3453 domain
= build_index_type (size_int (length
));
3454 init
= build_string (length
+ 1, name
);
3457 type
= build_qualified_type (char_type_node
, TYPE_QUAL_CONST
);
3458 type
= build_cplus_array_type (type
, domain
);
3463 TREE_TYPE (init
) = type
;
3465 init
= error_mark_node
;
3470 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
3471 decl, NAME is the initialization string and TYPE_DEP indicates whether
3472 NAME depended on the type of the function. We make use of that to detect
3473 __PRETTY_FUNCTION__ inside a template fn. This is being done
3474 lazily at the point of first use, so we mustn't push the decl now. */
3477 cp_make_fname_decl (tree id
, int type_dep
)
3479 const char *const name
= (type_dep
&& processing_template_decl
3480 ? NULL
: fname_as_string (type_dep
));
3482 tree init
= cp_fname_init (name
, &type
);
3483 tree decl
= build_decl (VAR_DECL
, id
, type
);
3486 free (CONST_CAST (char *, name
));
3488 /* As we're using pushdecl_with_scope, we must set the context. */
3489 DECL_CONTEXT (decl
) = current_function_decl
;
3490 DECL_PRETTY_FUNCTION_P (decl
) = type_dep
;
3492 TREE_STATIC (decl
) = 1;
3493 TREE_READONLY (decl
) = 1;
3494 DECL_ARTIFICIAL (decl
) = 1;
3496 TREE_USED (decl
) = 1;
3498 if (current_function_decl
)
3500 struct cp_binding_level
*b
= current_binding_level
;
3501 while (b
->level_chain
->kind
!= sk_function_parms
)
3503 pushdecl_with_scope (decl
, b
, /*is_friend=*/false);
3504 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, NULL_TREE
,
3505 LOOKUP_ONLYCONVERTING
);
3508 pushdecl_top_level_and_finish (decl
, init
);
3514 builtin_function_1 (tree decl
, tree context
, bool is_global
)
3516 tree id
= DECL_NAME (decl
);
3517 const char *name
= IDENTIFIER_POINTER (id
);
3519 retrofit_lang_decl (decl
);
3521 /* All nesting of C++ functions is lexical; there is never a "static
3522 chain" in the sense of GNU C nested functions. */
3523 DECL_NO_STATIC_CHAIN (decl
) = 1;
3525 DECL_ARTIFICIAL (decl
) = 1;
3526 SET_OVERLOADED_OPERATOR_CODE (decl
, ERROR_MARK
);
3527 SET_DECL_LANGUAGE (decl
, lang_c
);
3528 /* Runtime library routines are, by definition, available in an
3529 external shared object. */
3530 DECL_VISIBILITY (decl
) = VISIBILITY_DEFAULT
;
3531 DECL_VISIBILITY_SPECIFIED (decl
) = 1;
3533 DECL_CONTEXT (decl
) = context
;
3536 pushdecl_top_level (decl
);
3540 /* A function in the user's namespace should have an explicit
3541 declaration before it is used. Mark the built-in function as
3542 anticipated but not actually declared. */
3543 if (name
[0] != '_' || name
[1] != '_')
3544 DECL_ANTICIPATED (decl
) = 1;
3545 else if (strncmp (name
+ 2, "builtin_", strlen ("builtin_")) != 0)
3547 size_t len
= strlen (name
);
3549 /* Treat __*_chk fortification functions as anticipated as well,
3550 unless they are __builtin_*. */
3551 if (len
> strlen ("___chk")
3552 && memcmp (name
+ len
- strlen ("_chk"),
3553 "_chk", strlen ("_chk") + 1) == 0)
3554 DECL_ANTICIPATED (decl
) = 1;
3561 cxx_builtin_function (tree decl
)
3563 tree id
= DECL_NAME (decl
);
3564 const char *name
= IDENTIFIER_POINTER (id
);
3565 /* All builtins that don't begin with an '_' should additionally
3566 go in the 'std' namespace. */
3569 tree decl2
= copy_node(decl
);
3570 push_namespace (std_identifier
);
3571 builtin_function_1 (decl2
, std_node
, false);
3575 return builtin_function_1 (decl
, NULL_TREE
, false);
3578 /* Like cxx_builtin_function, but guarantee the function is added to the global
3579 scope. This is to allow function specific options to add new machine
3580 dependent builtins when the target ISA changes via attribute((target(...)))
3581 which saves space on program startup if the program does not use non-generic
3585 cxx_builtin_function_ext_scope (tree decl
)
3588 tree id
= DECL_NAME (decl
);
3589 const char *name
= IDENTIFIER_POINTER (id
);
3590 /* All builtins that don't begin with an '_' should additionally
3591 go in the 'std' namespace. */
3594 tree decl2
= copy_node(decl
);
3595 push_namespace (std_identifier
);
3596 builtin_function_1 (decl2
, std_node
, true);
3600 return builtin_function_1 (decl
, NULL_TREE
, true);
3603 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
3604 function. Not called directly. */
3607 build_library_fn_1 (tree name
, enum tree_code operator_code
, tree type
)
3609 tree fn
= build_lang_decl (FUNCTION_DECL
, name
, type
);
3610 DECL_EXTERNAL (fn
) = 1;
3611 TREE_PUBLIC (fn
) = 1;
3612 DECL_ARTIFICIAL (fn
) = 1;
3613 SET_OVERLOADED_OPERATOR_CODE (fn
, operator_code
);
3614 SET_DECL_LANGUAGE (fn
, lang_c
);
3615 /* Runtime library routines are, by definition, available in an
3616 external shared object. */
3617 DECL_VISIBILITY (fn
) = VISIBILITY_DEFAULT
;
3618 DECL_VISIBILITY_SPECIFIED (fn
) = 1;
3622 /* Returns the _DECL for a library function with C linkage.
3623 We assume that such functions never throw; if this is incorrect,
3624 callers should unset TREE_NOTHROW. */
3627 build_library_fn (tree name
, tree type
)
3629 tree fn
= build_library_fn_1 (name
, ERROR_MARK
, type
);
3630 TREE_NOTHROW (fn
) = 1;
3634 /* Returns the _DECL for a library function with C++ linkage. */
3637 build_cp_library_fn (tree name
, enum tree_code operator_code
, tree type
)
3639 tree fn
= build_library_fn_1 (name
, operator_code
, type
);
3640 TREE_NOTHROW (fn
) = TYPE_NOTHROW_P (type
);
3641 DECL_CONTEXT (fn
) = FROB_CONTEXT (current_namespace
);
3642 SET_DECL_LANGUAGE (fn
, lang_cplusplus
);
3646 /* Like build_library_fn, but takes a C string instead of an
3650 build_library_fn_ptr (const char* name
, tree type
)
3652 return build_library_fn (get_identifier (name
), type
);
3655 /* Like build_cp_library_fn, but takes a C string instead of an
3659 build_cp_library_fn_ptr (const char* name
, tree type
)
3661 return build_cp_library_fn (get_identifier (name
), ERROR_MARK
, type
);
3664 /* Like build_library_fn, but also pushes the function so that we will
3665 be able to find it via IDENTIFIER_GLOBAL_VALUE. Also, the function
3666 may throw exceptions listed in RAISES. */
3669 push_library_fn (tree name
, tree type
, tree raises
)
3674 type
= build_exception_variant (type
, raises
);
3676 fn
= build_library_fn (name
, type
);
3677 pushdecl_top_level (fn
);
3681 /* Like build_cp_library_fn, but also pushes the function so that it
3682 will be found by normal lookup. */
3685 push_cp_library_fn (enum tree_code operator_code
, tree type
)
3687 tree fn
= build_cp_library_fn (ansi_opname (operator_code
),
3694 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
3698 push_void_library_fn (tree name
, tree parmtypes
)
3700 tree type
= build_function_type (void_type_node
, parmtypes
);
3701 return push_library_fn (name
, type
, NULL_TREE
);
3704 /* Like push_library_fn, but also note that this function throws
3705 and does not return. Used for __throw_foo and the like. */
3708 push_throw_library_fn (tree name
, tree type
)
3710 tree fn
= push_library_fn (name
, type
, NULL_TREE
);
3711 TREE_THIS_VOLATILE (fn
) = 1;
3712 TREE_NOTHROW (fn
) = 0;
3716 /* When we call finish_struct for an anonymous union, we create
3717 default copy constructors and such. But, an anonymous union
3718 shouldn't have such things; this function undoes the damage to the
3719 anonymous union type T.
3721 (The reason that we create the synthesized methods is that we don't
3722 distinguish `union { int i; }' from `typedef union { int i; } U'.
3723 The first is an anonymous union; the second is just an ordinary
3727 fixup_anonymous_aggr (tree t
)
3731 /* Wipe out memory of synthesized methods. */
3732 TYPE_HAS_USER_CONSTRUCTOR (t
) = 0;
3733 TYPE_HAS_DEFAULT_CONSTRUCTOR (t
) = 0;
3734 TYPE_HAS_INIT_REF (t
) = 0;
3735 TYPE_HAS_CONST_INIT_REF (t
) = 0;
3736 TYPE_HAS_ASSIGN_REF (t
) = 0;
3737 TYPE_HAS_CONST_ASSIGN_REF (t
) = 0;
3739 /* Splice the implicitly generated functions out of the TYPE_METHODS
3741 q
= &TYPE_METHODS (t
);
3744 if (DECL_ARTIFICIAL (*q
))
3745 *q
= TREE_CHAIN (*q
);
3747 q
= &TREE_CHAIN (*q
);
3750 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
3751 if (TYPE_METHODS (t
))
3753 tree decl
= TYPE_MAIN_DECL (t
);
3755 if (TREE_CODE (t
) != UNION_TYPE
)
3756 error ("%Jan anonymous struct cannot have function members", decl
);
3758 error ("%Jan anonymous union cannot have function members", decl
);
3761 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
3762 assignment operators (because they cannot have these methods themselves).
3763 For anonymous unions this is already checked because they are not allowed
3764 in any union, otherwise we have to check it. */
3765 if (TREE_CODE (t
) != UNION_TYPE
)
3769 for (field
= TYPE_FIELDS (t
); field
; field
= TREE_CHAIN (field
))
3770 if (TREE_CODE (field
) == FIELD_DECL
)
3772 type
= TREE_TYPE (field
);
3773 if (CLASS_TYPE_P (type
))
3775 if (TYPE_NEEDS_CONSTRUCTING (type
))
3776 error ("member %q+#D with constructor not allowed "
3777 "in anonymous aggregate", field
);
3778 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
3779 error ("member %q+#D with destructor not allowed "
3780 "in anonymous aggregate", field
);
3781 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type
))
3782 error ("member %q+#D with copy assignment operator "
3783 "not allowed in anonymous aggregate", field
);
3789 /* Make sure that a declaration with no declarator is well-formed, i.e.
3790 just declares a tagged type or anonymous union.
3792 Returns the type declared; or NULL_TREE if none. */
3795 check_tag_decl (cp_decl_specifier_seq
*declspecs
)
3797 int saw_friend
= declspecs
->specs
[(int)ds_friend
] != 0;
3798 int saw_typedef
= declspecs
->specs
[(int)ds_typedef
] != 0;
3799 /* If a class, struct, or enum type is declared by the DECLSPECS
3800 (i.e, if a class-specifier, enum-specifier, or non-typename
3801 elaborated-type-specifier appears in the DECLSPECS),
3802 DECLARED_TYPE is set to the corresponding type. */
3803 tree declared_type
= NULL_TREE
;
3804 bool error_p
= false;
3806 if (declspecs
->multiple_types_p
)
3807 error ("multiple types in one declaration");
3808 else if (declspecs
->redefined_builtin_type
)
3810 if (!in_system_header
)
3811 permerror (input_location
, "redeclaration of C++ built-in type %qT",
3812 declspecs
->redefined_builtin_type
);
3817 && TYPE_P (declspecs
->type
)
3818 && ((TREE_CODE (declspecs
->type
) != TYPENAME_TYPE
3819 && MAYBE_CLASS_TYPE_P (declspecs
->type
))
3820 || TREE_CODE (declspecs
->type
) == ENUMERAL_TYPE
))
3821 declared_type
= declspecs
->type
;
3822 else if (declspecs
->type
== error_mark_node
)
3824 if (declared_type
== NULL_TREE
&& ! saw_friend
&& !error_p
)
3825 permerror (input_location
, "declaration does not declare anything");
3826 /* Check for an anonymous union. */
3827 else if (declared_type
&& RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type
))
3828 && TYPE_ANONYMOUS_P (declared_type
))
3830 /* 7/3 In a simple-declaration, the optional init-declarator-list
3831 can be omitted only when declaring a class (clause 9) or
3832 enumeration (7.2), that is, when the decl-specifier-seq contains
3833 either a class-specifier, an elaborated-type-specifier with
3834 a class-key (9.1), or an enum-specifier. In these cases and
3835 whenever a class-specifier or enum-specifier is present in the
3836 decl-specifier-seq, the identifiers in these specifiers are among
3837 the names being declared by the declaration (as class-name,
3838 enum-names, or enumerators, depending on the syntax). In such
3839 cases, and except for the declaration of an unnamed bit-field (9.6),
3840 the decl-specifier-seq shall introduce one or more names into the
3841 program, or shall redeclare a name introduced by a previous
3842 declaration. [Example:
3843 enum { }; // ill-formed
3844 typedef class { }; // ill-formed
3848 error ("missing type-name in typedef-declaration");
3851 /* Anonymous unions are objects, so they can have specifiers. */;
3852 SET_ANON_AGGR_TYPE_P (declared_type
);
3854 if (TREE_CODE (declared_type
) != UNION_TYPE
&& !in_system_header
)
3855 pedwarn (input_location
, OPT_pedantic
, "ISO C++ prohibits anonymous structs");
3860 if (declspecs
->specs
[(int)ds_inline
]
3861 || declspecs
->specs
[(int)ds_virtual
])
3862 error ("%qs can only be specified for functions",
3863 declspecs
->specs
[(int)ds_inline
]
3864 ? "inline" : "virtual");
3866 && (!current_class_type
3867 || current_scope () != current_class_type
))
3868 error ("%<friend%> can only be specified inside a class");
3869 else if (declspecs
->specs
[(int)ds_explicit
])
3870 error ("%<explicit%> can only be specified for constructors");
3871 else if (declspecs
->storage_class
)
3872 error ("a storage class can only be specified for objects "
3874 else if (declspecs
->specs
[(int)ds_const
]
3875 || declspecs
->specs
[(int)ds_volatile
]
3876 || declspecs
->specs
[(int)ds_restrict
]
3877 || declspecs
->specs
[(int)ds_thread
])
3878 error ("qualifiers can only be specified for objects "
3880 else if (saw_typedef
)
3881 warning (0, "%<typedef%> was ignored in this declaration");
3884 return declared_type
;
3887 /* Called when a declaration is seen that contains no names to declare.
3888 If its type is a reference to a structure, union or enum inherited
3889 from a containing scope, shadow that tag name for the current scope
3890 with a forward reference.
3891 If its type defines a new named structure or union
3892 or defines an enum, it is valid but we need not do anything here.
3893 Otherwise, it is an error.
3895 C++: may have to grok the declspecs to learn about static,
3896 complain for anonymous unions.
3898 Returns the TYPE declared -- or NULL_TREE if none. */
3901 shadow_tag (cp_decl_specifier_seq
*declspecs
)
3903 tree t
= check_tag_decl (declspecs
);
3908 if (declspecs
->attributes
)
3910 warning (0, "attribute ignored in declaration of %q+#T", t
);
3911 warning (0, "attribute for %q+#T must follow the %qs keyword",
3912 t
, class_key_or_enum_as_string (t
));
3916 if (maybe_process_partial_specialization (t
) == error_mark_node
)
3919 /* This is where the variables in an anonymous union are
3920 declared. An anonymous union declaration looks like:
3922 because there is no declarator after the union, the parser
3923 sends that declaration here. */
3924 if (ANON_AGGR_TYPE_P (t
))
3926 fixup_anonymous_aggr (t
);
3928 if (TYPE_FIELDS (t
))
3930 tree decl
= grokdeclarator (/*declarator=*/NULL
,
3931 declspecs
, NORMAL
, 0, NULL
);
3932 finish_anon_union (decl
);
3939 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
3942 groktypename (cp_decl_specifier_seq
*type_specifiers
,
3943 const cp_declarator
*declarator
)
3947 attrs
= type_specifiers
->attributes
;
3948 type_specifiers
->attributes
= NULL_TREE
;
3949 type
= grokdeclarator (declarator
, type_specifiers
, TYPENAME
, 0, &attrs
);
3950 if (attrs
&& type
!= error_mark_node
)
3952 if (CLASS_TYPE_P (type
))
3953 warning (OPT_Wattributes
, "ignoring attributes applied to class type %qT "
3954 "outside of definition", type
);
3955 else if (MAYBE_CLASS_TYPE_P (type
))
3956 /* A template type parameter or other dependent type. */
3957 warning (OPT_Wattributes
, "ignoring attributes applied to dependent "
3958 "type %qT without an associated declaration", type
);
3960 cplus_decl_attributes (&type
, attrs
, 0);
3965 /* Process a DECLARATOR for a function-scope variable declaration,
3966 namespace-scope variable declaration, or function declaration.
3967 (Function definitions go through start_function; class member
3968 declarations appearing in the body of the class go through
3969 grokfield.) The DECL corresponding to the DECLARATOR is returned.
3970 If an error occurs, the error_mark_node is returned instead.
3972 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
3973 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
3974 for an explicitly defaulted function, or SD_DELETED for an explicitly
3975 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
3976 implicitly initialized via a default constructor. ATTRIBUTES and
3977 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
3978 *PUSHED_SCOPE_P is set to the scope entered in this function, if any; if
3979 set, the caller is responsible for calling pop_scope. */
3982 start_decl (const cp_declarator
*declarator
,
3983 cp_decl_specifier_seq
*declspecs
,
3986 tree prefix_attributes
,
3987 tree
*pushed_scope_p
)
3995 *pushed_scope_p
= NULL_TREE
;
3997 /* An object declared as __attribute__((deprecated)) suppresses
3998 warnings of uses of other deprecated items. */
3999 if (lookup_attribute ("deprecated", attributes
))
4000 deprecated_state
= DEPRECATED_SUPPRESS
;
4002 attributes
= chainon (attributes
, prefix_attributes
);
4004 decl
= grokdeclarator (declarator
, declspecs
, NORMAL
, initialized
,
4007 deprecated_state
= DEPRECATED_NORMAL
;
4009 if (decl
== NULL_TREE
|| TREE_CODE (decl
) == VOID_TYPE
4010 || decl
== error_mark_node
)
4011 return error_mark_node
;
4013 type
= TREE_TYPE (decl
);
4015 context
= DECL_CONTEXT (decl
);
4019 *pushed_scope_p
= push_scope (context
);
4021 /* We are only interested in class contexts, later. */
4022 if (TREE_CODE (context
) == NAMESPACE_DECL
)
4023 context
= NULL_TREE
;
4027 /* Is it valid for this decl to have an initializer at all?
4028 If not, set INITIALIZED to zero, which will indirectly
4029 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
4030 switch (TREE_CODE (decl
))
4033 error ("typedef %qD is initialized (use decltype instead)", decl
);
4034 return error_mark_node
;
4037 if (initialized
== SD_DELETED
)
4038 /* We'll handle the rest of the semantics later, but we need to
4039 set this now so it's visible to duplicate_decls. */
4040 DECL_DELETED_FN (decl
) = 1;
4049 if (! toplevel_bindings_p ()
4050 && DECL_EXTERNAL (decl
))
4051 warning (0, "declaration of %q#D has %<extern%> and is initialized",
4053 DECL_EXTERNAL (decl
) = 0;
4054 if (toplevel_bindings_p ())
4055 TREE_STATIC (decl
) = 1;
4058 /* If this is a typedef that names the class for linkage purposes
4059 (7.1.3p8), apply any attributes directly to the type. */
4060 if (TREE_CODE (decl
) == TYPE_DECL
4061 && TAGGED_TYPE_P (TREE_TYPE (decl
))
4062 && decl
== TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl
))))
4063 flags
= ATTR_FLAG_TYPE_IN_PLACE
;
4067 /* Set attributes here so if duplicate decl, will have proper attributes. */
4068 cplus_decl_attributes (&decl
, attributes
, flags
);
4070 /* Dllimported symbols cannot be defined. Static data members (which
4071 can be initialized in-class and dllimported) go through grokfield,
4072 not here, so we don't need to exclude those decls when checking for
4074 if (initialized
&& DECL_DLLIMPORT_P (decl
))
4076 error ("definition of %q#D is marked %<dllimport%>", decl
);
4077 DECL_DLLIMPORT_P (decl
) = 0;
4080 /* If #pragma weak was used, mark the decl weak now. */
4081 maybe_apply_pragma_weak (decl
);
4083 if (TREE_CODE (decl
) == FUNCTION_DECL
4084 && DECL_DECLARED_INLINE_P (decl
)
4085 && DECL_UNINLINABLE (decl
)
4086 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl
)))
4087 warning (0, "inline function %q+D given attribute noinline", decl
);
4089 if (context
&& COMPLETE_TYPE_P (complete_type (context
)))
4091 if (TREE_CODE (decl
) == VAR_DECL
)
4093 tree field
= lookup_field (context
, DECL_NAME (decl
), 0, false);
4094 if (field
== NULL_TREE
|| TREE_CODE (field
) != VAR_DECL
)
4095 error ("%q#D is not a static member of %q#T", decl
, context
);
4098 if (DECL_CONTEXT (field
) != context
)
4100 if (!same_type_p (DECL_CONTEXT (field
), context
))
4101 permerror (input_location
, "ISO C++ does not permit %<%T::%D%> "
4102 "to be defined as %<%T::%D%>",
4103 DECL_CONTEXT (field
), DECL_NAME (decl
),
4104 context
, DECL_NAME (decl
));
4105 DECL_CONTEXT (decl
) = DECL_CONTEXT (field
);
4107 if (processing_specialization
4108 && template_class_depth (context
) == 0
4109 && CLASSTYPE_TEMPLATE_SPECIALIZATION (context
))
4110 error ("template header not allowed in member definition "
4111 "of explicitly specialized class");
4112 /* Static data member are tricky; an in-class initialization
4113 still doesn't provide a definition, so the in-class
4114 declaration will have DECL_EXTERNAL set, but will have an
4115 initialization. Thus, duplicate_decls won't warn
4116 about this situation, and so we check here. */
4117 if (initialized
&& DECL_INITIALIZED_IN_CLASS_P (field
))
4118 error ("duplicate initialization of %qD", decl
);
4119 if (duplicate_decls (decl
, field
, /*newdecl_is_friend=*/false))
4125 tree field
= check_classfn (context
, decl
,
4126 (processing_template_decl
4127 > template_class_depth (context
))
4128 ? current_template_parms
4130 if (field
&& field
!= error_mark_node
4131 && duplicate_decls (decl
, field
,
4132 /*newdecl_is_friend=*/false))
4136 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
4137 DECL_IN_AGGR_P (decl
) = 0;
4138 /* Do not mark DECL as an explicit specialization if it was not
4139 already marked as an instantiation; a declaration should
4140 never be marked as a specialization unless we know what
4141 template is being specialized. */
4142 if (DECL_LANG_SPECIFIC (decl
) && DECL_USE_TEMPLATE (decl
))
4144 SET_DECL_TEMPLATE_SPECIALIZATION (decl
);
4146 /* [temp.expl.spec] An explicit specialization of a static data
4147 member of a template is a definition if the declaration
4148 includes an initializer; otherwise, it is a declaration.
4150 We check for processing_specialization so this only applies
4151 to the new specialization syntax. */
4152 if (!initialized
&& processing_specialization
)
4153 DECL_EXTERNAL (decl
) = 1;
4156 if (DECL_EXTERNAL (decl
) && ! DECL_TEMPLATE_SPECIALIZATION (decl
))
4157 permerror (input_location
, "declaration of %q#D outside of class is not definition",
4161 was_public
= TREE_PUBLIC (decl
);
4163 /* Enter this declaration into the symbol table. */
4164 decl
= maybe_push_decl (decl
);
4166 if (processing_template_decl
)
4167 decl
= push_template_decl (decl
);
4168 if (decl
== error_mark_node
)
4169 return error_mark_node
;
4171 /* Tell the back end to use or not use .common as appropriate. If we say
4172 -fconserve-space, we want this to save .data space, at the expense of
4173 wrong semantics. If we say -fno-conserve-space, we want this to
4174 produce errors about redefs; to do this we force variables into the
4176 if (flag_conserve_space
4177 && TREE_CODE (decl
) == VAR_DECL
4178 && TREE_PUBLIC (decl
)
4179 && !DECL_THREAD_LOCAL_P (decl
)
4180 && !have_global_bss_p ())
4181 DECL_COMMON (decl
) = 1;
4183 if (TREE_CODE (decl
) == VAR_DECL
4184 && DECL_NAMESPACE_SCOPE_P (decl
) && !TREE_PUBLIC (decl
) && !was_public
4185 && !DECL_THIS_STATIC (decl
) && !DECL_ARTIFICIAL (decl
))
4187 /* This is a const variable with implicit 'static'. Set
4188 DECL_THIS_STATIC so we can tell it from variables that are
4189 !TREE_PUBLIC because of the anonymous namespace. */
4190 gcc_assert (cp_type_readonly (TREE_TYPE (decl
)));
4191 DECL_THIS_STATIC (decl
) = 1;
4194 if (!processing_template_decl
&& TREE_CODE (decl
) == VAR_DECL
)
4195 start_decl_1 (decl
, initialized
);
4200 /* Process the declaration of a variable DECL. INITIALIZED is true
4201 iff DECL is explicitly initialized. (INITIALIZED is false if the
4202 variable is initialized via an implicitly-called constructor.)
4203 This function must be called for ordinary variables (including, for
4204 example, implicit instantiations of templates), but must not be
4205 called for template declarations. */
4208 start_decl_1 (tree decl
, bool initialized
)
4212 bool aggregate_definition_p
;
4214 gcc_assert (!processing_template_decl
);
4216 if (error_operand_p (decl
))
4219 gcc_assert (TREE_CODE (decl
) == VAR_DECL
);
4221 type
= TREE_TYPE (decl
);
4222 complete_p
= COMPLETE_TYPE_P (type
);
4223 aggregate_definition_p
= MAYBE_CLASS_TYPE_P (type
) && !DECL_EXTERNAL (decl
);
4225 /* If an explicit initializer is present, or if this is a definition
4226 of an aggregate, then we need a complete type at this point.
4227 (Scalars are always complete types, so there is nothing to
4228 check.) This code just sets COMPLETE_P; errors (if necessary)
4229 are issued below. */
4230 if ((initialized
|| aggregate_definition_p
)
4232 && COMPLETE_TYPE_P (complete_type (type
)))
4235 /* We will not yet have set TREE_READONLY on DECL if the type
4236 was "const", but incomplete, before this point. But, now, we
4237 have a complete type, so we can try again. */
4238 cp_apply_type_quals_to_decl (cp_type_quals (type
), decl
);
4242 /* Is it valid for this decl to have an initializer at all? */
4244 /* Don't allow initializations for incomplete types except for
4245 arrays which might be completed by the initialization. */
4247 ; /* A complete type is ok. */
4248 else if (type_uses_auto (type
))
4249 ; /* An auto type is ok. */
4250 else if (TREE_CODE (type
) != ARRAY_TYPE
)
4252 error ("variable %q#D has initializer but incomplete type", decl
);
4253 type
= TREE_TYPE (decl
) = error_mark_node
;
4255 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type
))))
4257 if (DECL_LANG_SPECIFIC (decl
) && DECL_TEMPLATE_INFO (decl
))
4258 error ("elements of array %q#D have incomplete type", decl
);
4259 /* else we already gave an error in start_decl. */
4262 else if (aggregate_definition_p
&& !complete_p
)
4264 if (type_uses_auto (type
))
4265 error ("declaration of %q#D has no initializer", decl
);
4267 error ("aggregate %q#D has incomplete type and cannot be defined",
4269 /* Change the type so that assemble_variable will give
4270 DECL an rtl we can live with: (mem (const_int 0)). */
4271 type
= TREE_TYPE (decl
) = error_mark_node
;
4274 /* Create a new scope to hold this declaration if necessary.
4275 Whether or not a new scope is necessary cannot be determined
4276 until after the type has been completed; if the type is a
4277 specialization of a class template it is not until after
4278 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4279 will be set correctly. */
4280 maybe_push_cleanup_level (type
);
4283 /* Handle initialization of references. DECL, TYPE, and INIT have the
4284 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
4285 but will be set to a new CLEANUP_STMT if a temporary is created
4286 that must be destroyed subsequently.
4288 Returns an initializer expression to use to initialize DECL, or
4289 NULL if the initialization can be performed statically.
4291 Quotes on semantics can be found in ARM 8.4.3. */
4294 grok_reference_init (tree decl
, tree type
, tree init
, tree
*cleanup
)
4298 if (init
== NULL_TREE
)
4300 if ((DECL_LANG_SPECIFIC (decl
) == 0
4301 || DECL_IN_AGGR_P (decl
) == 0)
4302 && ! DECL_THIS_EXTERN (decl
))
4303 error ("%qD declared as reference but not initialized", decl
);
4307 if (TREE_CODE (init
) == CONSTRUCTOR
)
4309 error ("ISO C++ forbids use of initializer list to "
4310 "initialize reference %qD", decl
);
4314 if (TREE_CODE (init
) == TREE_LIST
)
4315 init
= build_x_compound_expr_from_list (init
, "initializer");
4317 if (TREE_CODE (TREE_TYPE (type
)) != ARRAY_TYPE
4318 && TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
)
4319 /* Note: default conversion is only called in very special cases. */
4320 init
= decay_conversion (init
);
4322 /* Convert INIT to the reference type TYPE. This may involve the
4323 creation of a temporary, whose lifetime must be the same as that
4324 of the reference. If so, a DECL_EXPR for the temporary will be
4325 added just after the DECL_EXPR for DECL. That's why we don't set
4326 DECL_INITIAL for local references (instead assigning to them
4327 explicitly); we need to allow the temporary to be initialized
4329 tmp
= initialize_reference (type
, init
, decl
, cleanup
);
4331 if (tmp
== error_mark_node
)
4333 else if (tmp
== NULL_TREE
)
4335 error ("cannot initialize %qT from %qT", type
, TREE_TYPE (init
));
4339 if (TREE_STATIC (decl
) && !TREE_CONSTANT (tmp
))
4342 DECL_INITIAL (decl
) = tmp
;
4347 /* Subroutine of check_initializer. We're initializing a DECL of
4348 std::initializer_list<T> TYPE from a braced-init-list INIT, and need to
4349 extend the lifetime of the underlying array to match that of the decl,
4350 just like for reference initialization. CLEANUP is as for
4351 grok_reference_init. */
4354 build_init_list_var_init (tree decl
, tree type
, tree init
, tree
*cleanup
)
4356 tree aggr_init
, array
, arrtype
;
4357 init
= perform_implicit_conversion (type
, init
, tf_warning_or_error
);
4358 aggr_init
= TARGET_EXPR_INITIAL (init
);
4359 init
= build2 (INIT_EXPR
, type
, decl
, init
);
4361 array
= AGGR_INIT_EXPR_ARG (aggr_init
, 1);
4362 arrtype
= TREE_TYPE (array
);
4364 gcc_assert (TREE_CODE (array
) == ADDR_EXPR
);
4365 array
= TREE_OPERAND (array
, 0);
4366 /* If the array is constant, finish_compound_literal already made it a
4367 static variable and we don't need to do anything here. */
4368 if (decl
&& TREE_CODE (array
) == TARGET_EXPR
)
4371 tree var
= set_up_extended_ref_temp (decl
, array
, cleanup
, &subinit
);
4372 var
= build_address (var
);
4373 var
= convert (arrtype
, var
);
4374 AGGR_INIT_EXPR_ARG (aggr_init
, 1) = var
;
4375 init
= build2 (COMPOUND_EXPR
, TREE_TYPE (init
), subinit
, init
);
4380 /* Designated initializers in arrays are not supported in GNU C++.
4381 The parser cannot detect this error since it does not know whether
4382 a given brace-enclosed initializer is for a class type or for an
4383 array. This function checks that CE does not use a designated
4384 initializer. If it does, an error is issued. Returns true if CE
4385 is valid, i.e., does not have a designated initializer. */
4388 check_array_designated_initializer (const constructor_elt
*ce
)
4390 /* Designated initializers for array elements are not supported. */
4393 /* The parser only allows identifiers as designated
4395 gcc_assert (TREE_CODE (ce
->index
) == IDENTIFIER_NODE
);
4396 error ("name %qD used in a GNU-style designated "
4397 "initializer for an array", ce
->index
);
4404 /* When parsing `int a[] = {1, 2};' we don't know the size of the
4405 array until we finish parsing the initializer. If that's the
4406 situation we're in, update DECL accordingly. */
4409 maybe_deduce_size_from_array_init (tree decl
, tree init
)
4411 tree type
= TREE_TYPE (decl
);
4413 if (TREE_CODE (type
) == ARRAY_TYPE
4414 && TYPE_DOMAIN (type
) == NULL_TREE
4415 && TREE_CODE (decl
) != TYPE_DECL
)
4417 /* do_default is really a C-ism to deal with tentative definitions.
4418 But let's leave it here to ease the eventual merge. */
4419 int do_default
= !DECL_EXTERNAL (decl
);
4420 tree initializer
= init
? init
: DECL_INITIAL (decl
);
4423 /* Check that there are no designated initializers in INIT, as
4424 those are not supported in GNU C++, and as the middle-end
4425 will crash if presented with a non-numeric designated
4427 if (initializer
&& TREE_CODE (initializer
) == CONSTRUCTOR
)
4429 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (initializer
);
4430 constructor_elt
*ce
;
4433 VEC_iterate (constructor_elt
, v
, i
, ce
);
4435 if (!check_array_designated_initializer (ce
))
4441 failure
= cp_complete_array_type (&TREE_TYPE (decl
), initializer
,
4445 error ("initializer fails to determine size of %qD", decl
);
4446 TREE_TYPE (decl
) = error_mark_node
;
4448 else if (failure
== 2)
4452 error ("array size missing in %qD", decl
);
4453 TREE_TYPE (decl
) = error_mark_node
;
4455 /* If a `static' var's size isn't known, make it extern as
4456 well as static, so it does not get allocated. If it's not
4457 `static', then don't mark it extern; finish_incomplete_decl
4458 will give it a default size and it will get allocated. */
4459 else if (!pedantic
&& TREE_STATIC (decl
) && !TREE_PUBLIC (decl
))
4460 DECL_EXTERNAL (decl
) = 1;
4462 else if (failure
== 3)
4464 error ("zero-size array %qD", decl
);
4465 TREE_TYPE (decl
) = error_mark_node
;
4469 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl
)), decl
);
4471 layout_decl (decl
, 0);
4475 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
4476 any appropriate error messages regarding the layout. */
4479 layout_var_decl (tree decl
)
4483 type
= TREE_TYPE (decl
);
4484 if (type
== error_mark_node
)
4487 /* If we haven't already layed out this declaration, do so now.
4488 Note that we must not call complete type for an external object
4489 because it's type might involve templates that we are not
4490 supposed to instantiate yet. (And it's perfectly valid to say
4491 `extern X x' for some incomplete type `X'.) */
4492 if (!DECL_EXTERNAL (decl
))
4493 complete_type (type
);
4494 if (!DECL_SIZE (decl
)
4495 && TREE_TYPE (decl
) != error_mark_node
4496 && (COMPLETE_TYPE_P (type
)
4497 || (TREE_CODE (type
) == ARRAY_TYPE
4498 && !TYPE_DOMAIN (type
)
4499 && COMPLETE_TYPE_P (TREE_TYPE (type
)))))
4500 layout_decl (decl
, 0);
4502 if (!DECL_EXTERNAL (decl
) && DECL_SIZE (decl
) == NULL_TREE
)
4504 /* An automatic variable with an incomplete type: that is an error.
4505 Don't talk about array types here, since we took care of that
4506 message in grokdeclarator. */
4507 error ("storage size of %qD isn't known", decl
);
4508 TREE_TYPE (decl
) = error_mark_node
;
4511 /* Keep this code around in case we later want to control debug info
4512 based on whether a type is "used". (jason 1999-11-11) */
4514 else if (!DECL_EXTERNAL (decl
) && MAYBE_CLASS_TYPE_P (ttype
))
4515 /* Let debugger know it should output info for this type. */
4516 note_debug_info_needed (ttype
);
4518 if (TREE_STATIC (decl
) && DECL_CLASS_SCOPE_P (decl
))
4519 note_debug_info_needed (DECL_CONTEXT (decl
));
4522 if ((DECL_EXTERNAL (decl
) || TREE_STATIC (decl
))
4523 && DECL_SIZE (decl
) != NULL_TREE
4524 && ! TREE_CONSTANT (DECL_SIZE (decl
)))
4526 if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
)
4527 constant_expression_warning (DECL_SIZE (decl
));
4530 error ("storage size of %qD isn't constant", decl
);
4531 TREE_TYPE (decl
) = error_mark_node
;
4536 /* If a local static variable is declared in an inline function, or if
4537 we have a weak definition, we must endeavor to create only one
4538 instance of the variable at link-time. */
4541 maybe_commonize_var (tree decl
)
4543 /* Static data in a function with comdat linkage also has comdat
4545 if (TREE_STATIC (decl
)
4546 /* Don't mess with __FUNCTION__. */
4547 && ! DECL_ARTIFICIAL (decl
)
4548 && DECL_FUNCTION_SCOPE_P (decl
)
4549 /* Unfortunately, import_export_decl has not always been called
4550 before the function is processed, so we cannot simply check
4552 && (DECL_COMDAT (DECL_CONTEXT (decl
))
4553 || ((DECL_DECLARED_INLINE_P (DECL_CONTEXT (decl
))
4554 || DECL_TEMPLATE_INSTANTIATION (DECL_CONTEXT (decl
)))
4555 && TREE_PUBLIC (DECL_CONTEXT (decl
)))))
4559 /* With weak symbols, we simply make the variable COMDAT;
4560 that will cause copies in multiple translations units to
4562 comdat_linkage (decl
);
4566 if (DECL_INITIAL (decl
) == NULL_TREE
4567 || DECL_INITIAL (decl
) == error_mark_node
)
4569 /* Without weak symbols, we can use COMMON to merge
4570 uninitialized variables. */
4571 TREE_PUBLIC (decl
) = 1;
4572 DECL_COMMON (decl
) = 1;
4576 /* While for initialized variables, we must use internal
4577 linkage -- which means that multiple copies will not
4579 TREE_PUBLIC (decl
) = 0;
4580 DECL_COMMON (decl
) = 0;
4581 warning (0, "sorry: semantics of inline function static "
4582 "data %q+#D are wrong (you'll wind up "
4583 "with multiple copies)", decl
);
4584 warning (0, "%J you can work around this by removing "
4590 else if (DECL_LANG_SPECIFIC (decl
) && DECL_COMDAT (decl
))
4591 /* Set it up again; we might have set DECL_INITIAL since the last
4593 comdat_linkage (decl
);
4596 /* Issue an error message if DECL is an uninitialized const variable. */
4599 check_for_uninitialized_const_var (tree decl
)
4601 tree type
= TREE_TYPE (decl
);
4603 /* ``Unless explicitly declared extern, a const object does not have
4604 external linkage and must be initialized. ($8.4; $12.1)'' ARM
4606 if (TREE_CODE (decl
) == VAR_DECL
4607 && TREE_CODE (type
) != REFERENCE_TYPE
4608 && CP_TYPE_CONST_P (type
)
4609 && !TYPE_NEEDS_CONSTRUCTING (type
)
4610 && !DECL_INITIAL (decl
))
4611 error ("uninitialized const %qD", decl
);
4615 /* Structure holding the current initializer being processed by reshape_init.
4616 CUR is a pointer to the current element being processed, END is a pointer
4617 after the last element present in the initializer. */
4618 typedef struct reshape_iterator_t
4620 constructor_elt
*cur
;
4621 constructor_elt
*end
;
4624 static tree
reshape_init_r (tree
, reshape_iter
*, bool);
4626 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
4627 returned is the next FIELD_DECL (possibly FIELD itself) that can be
4628 initialized. If there are no more such fields, the return value
4632 next_initializable_field (tree field
)
4635 && (TREE_CODE (field
) != FIELD_DECL
4636 || (DECL_C_BIT_FIELD (field
) && !DECL_NAME (field
))
4637 || DECL_ARTIFICIAL (field
)))
4638 field
= TREE_CHAIN (field
);
4643 /* Subroutine of reshape_init_array and reshape_init_vector, which does
4644 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
4645 INTEGER_CST representing the size of the array minus one (the maximum index),
4646 or NULL_TREE if the array was declared without specifying the size. D is
4647 the iterator within the constructor. */
4650 reshape_init_array_1 (tree elt_type
, tree max_index
, reshape_iter
*d
)
4653 bool sized_array_p
= (max_index
!= NULL_TREE
);
4654 unsigned HOST_WIDE_INT max_index_cst
= 0;
4655 unsigned HOST_WIDE_INT index
;
4657 /* The initializer for an array is always a CONSTRUCTOR. */
4658 new_init
= build_constructor (init_list_type_node
, NULL
);
4662 /* Minus 1 is used for zero sized arrays. */
4663 if (integer_all_onesp (max_index
))
4666 if (host_integerp (max_index
, 1))
4667 max_index_cst
= tree_low_cst (max_index
, 1);
4668 /* sizetype is sign extended, not zero extended. */
4670 max_index_cst
= tree_low_cst (fold_convert (size_type_node
, max_index
),
4674 /* Loop until there are no more initializers. */
4676 d
->cur
!= d
->end
&& (!sized_array_p
|| index
<= max_index_cst
);
4681 check_array_designated_initializer (d
->cur
);
4682 elt_init
= reshape_init_r (elt_type
, d
, /*first_initializer_p=*/false);
4683 if (elt_init
== error_mark_node
)
4684 return error_mark_node
;
4685 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
), NULL_TREE
, elt_init
);
4691 /* Subroutine of reshape_init_r, processes the initializers for arrays.
4692 Parameters are the same of reshape_init_r. */
4695 reshape_init_array (tree type
, reshape_iter
*d
)
4697 tree max_index
= NULL_TREE
;
4699 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
4701 if (TYPE_DOMAIN (type
))
4702 max_index
= array_type_nelts (type
);
4704 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
);
4707 /* Subroutine of reshape_init_r, processes the initializers for vectors.
4708 Parameters are the same of reshape_init_r. */
4711 reshape_init_vector (tree type
, reshape_iter
*d
)
4713 tree max_index
= NULL_TREE
;
4716 gcc_assert (TREE_CODE (type
) == VECTOR_TYPE
);
4718 if (COMPOUND_LITERAL_P (d
->cur
->value
))
4720 tree value
= d
->cur
->value
;
4721 if (!same_type_p (TREE_TYPE (value
), type
))
4723 error ("invalid type %qT as initializer for a vector of type %qT",
4724 TREE_TYPE (d
->cur
->value
), type
);
4725 value
= error_mark_node
;
4731 /* For a vector, the representation type is a struct
4732 containing a single member which is an array of the
4733 appropriate size. */
4734 rtype
= TYPE_DEBUG_REPRESENTATION_TYPE (type
);
4735 if (rtype
&& TYPE_DOMAIN (TREE_TYPE (TYPE_FIELDS (rtype
))))
4736 max_index
= array_type_nelts (TREE_TYPE (TYPE_FIELDS (rtype
)));
4738 return reshape_init_array_1 (TREE_TYPE (type
), max_index
, d
);
4741 /* Subroutine of reshape_init_r, processes the initializers for classes
4742 or union. Parameters are the same of reshape_init_r. */
4745 reshape_init_class (tree type
, reshape_iter
*d
, bool first_initializer_p
)
4750 gcc_assert (CLASS_TYPE_P (type
));
4752 /* The initializer for a class is always a CONSTRUCTOR. */
4753 new_init
= build_constructor (init_list_type_node
, NULL
);
4754 field
= next_initializable_field (TYPE_FIELDS (type
));
4760 An initializer for an aggregate member that is an
4761 empty class shall have the form of an empty
4762 initializer-list {}. */
4763 if (!first_initializer_p
)
4765 error ("initializer for %qT must be brace-enclosed", type
);
4766 return error_mark_node
;
4771 /* Loop through the initializable fields, gathering initializers. */
4772 while (d
->cur
!= d
->end
)
4776 /* Handle designated initializers, as an extension. */
4779 field
= lookup_field_1 (type
, d
->cur
->index
, /*want_type=*/false);
4781 if (!field
|| TREE_CODE (field
) != FIELD_DECL
)
4783 error ("%qT has no non-static data member named %qD", type
,
4785 return error_mark_node
;
4789 /* If we processed all the member of the class, we are done. */
4793 field_init
= reshape_init_r (TREE_TYPE (field
), d
,
4794 /*first_initializer_p=*/false);
4795 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init
), field
, field_init
);
4799 When a union is initialized with a brace-enclosed
4800 initializer, the braces shall only contain an
4801 initializer for the first member of the union. */
4802 if (TREE_CODE (type
) == UNION_TYPE
)
4805 field
= next_initializable_field (TREE_CHAIN (field
));
4811 /* Subroutine of reshape_init, which processes a single initializer (part of
4812 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
4813 iterator within the CONSTRUCTOR which points to the initializer to process.
4814 FIRST_INITIALIZER_P is true if this is the first initializer of the
4815 CONSTRUCTOR node. */
4818 reshape_init_r (tree type
, reshape_iter
*d
, bool first_initializer_p
)
4820 tree init
= d
->cur
->value
;
4822 if (error_operand_p (init
))
4823 return error_mark_node
;
4825 /* A non-aggregate type is always initialized with a single
4827 if (!CP_AGGREGATE_TYPE_P (type
))
4829 /* It is invalid to initialize a non-aggregate type with a
4830 brace-enclosed initializer before C++0x.
4831 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
4832 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
4833 a CONSTRUCTOR (with a record type). */
4834 if (TREE_CODE (init
) == CONSTRUCTOR
4835 && BRACE_ENCLOSED_INITIALIZER_P (init
)) /* p7626.C */
4837 if (SCALAR_TYPE_P (type
))
4839 error ("braces around scalar initializer for type %qT", type
);
4840 init
= error_mark_node
;
4843 maybe_warn_cpp0x ("extended initializer lists");
4852 All implicit type conversions (clause _conv_) are considered when
4853 initializing the aggregate member with an initializer from an
4854 initializer-list. If the initializer can initialize a member,
4855 the member is initialized. Otherwise, if the member is itself a
4856 non-empty subaggregate, brace elision is assumed and the
4857 initializer is considered for the initialization of the first
4858 member of the subaggregate. */
4859 if (TREE_CODE (init
) != CONSTRUCTOR
4860 && can_convert_arg (type
, TREE_TYPE (init
), init
, LOOKUP_NORMAL
))
4866 /* [dcl.init.string]
4868 A char array (whether plain char, signed char, or unsigned char)
4869 can be initialized by a string-literal (optionally enclosed in
4870 braces); a wchar_t array can be initialized by a wide
4871 string-literal (optionally enclosed in braces). */
4872 if (TREE_CODE (type
) == ARRAY_TYPE
4873 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type
))))
4875 tree str_init
= init
;
4877 /* Strip one level of braces if and only if they enclose a single
4878 element (as allowed by [dcl.init.string]). */
4879 if (!first_initializer_p
4880 && TREE_CODE (str_init
) == CONSTRUCTOR
4881 && VEC_length (constructor_elt
, CONSTRUCTOR_ELTS (str_init
)) == 1)
4883 str_init
= VEC_index (constructor_elt
,
4884 CONSTRUCTOR_ELTS (str_init
), 0)->value
;
4887 /* If it's a string literal, then it's the initializer for the array
4888 as a whole. Otherwise, continue with normal initialization for
4889 array types (one value per array element). */
4890 if (TREE_CODE (str_init
) == STRING_CST
)
4897 /* The following cases are about aggregates. If we are not within a full
4898 initializer already, and there is not a CONSTRUCTOR, it means that there
4899 is a missing set of braces (that is, we are processing the case for
4900 which reshape_init exists). */
4901 if (!first_initializer_p
)
4903 if (TREE_CODE (init
) == CONSTRUCTOR
)
4905 if (TREE_TYPE (init
) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init
)))
4906 /* There is no need to reshape pointer-to-member function
4907 initializers, as they are always constructed correctly
4908 by the front end. */
4910 else if (COMPOUND_LITERAL_P (init
))
4911 /* For a nested compound literal, there is no need to reshape since
4912 brace elision is not allowed. Even if we decided to allow it,
4913 we should add a call to reshape_init in finish_compound_literal,
4914 before calling digest_init, so changing this code would still
4915 not be necessary. */
4916 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init
));
4920 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
4921 return reshape_init (type
, init
);
4925 warning (OPT_Wmissing_braces
, "missing braces around initializer for %qT",
4929 /* Dispatch to specialized routines. */
4930 if (CLASS_TYPE_P (type
))
4931 return reshape_init_class (type
, d
, first_initializer_p
);
4932 else if (TREE_CODE (type
) == ARRAY_TYPE
)
4933 return reshape_init_array (type
, d
);
4934 else if (TREE_CODE (type
) == VECTOR_TYPE
)
4935 return reshape_init_vector (type
, d
);
4940 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
4941 brace-enclosed aggregate initializer.
4943 INIT is the CONSTRUCTOR containing the list of initializers describing
4944 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
4945 It may not presently match the shape of the TYPE; for example:
4947 struct S { int a; int b; };
4948 struct S a[] = { 1, 2, 3, 4 };
4950 Here INIT will hold a VEC of four elements, rather than a
4951 VEC of two elements, each itself a VEC of two elements. This
4952 routine transforms INIT from the former form into the latter. The
4953 revised CONSTRUCTOR node is returned. */
4956 reshape_init (tree type
, tree init
)
4958 VEC(constructor_elt
, gc
) *v
;
4962 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init
));
4964 v
= CONSTRUCTOR_ELTS (init
);
4966 /* An empty constructor does not need reshaping, and it is always a valid
4968 if (VEC_empty (constructor_elt
, v
))
4971 /* Recurse on this CONSTRUCTOR. */
4972 d
.cur
= VEC_index (constructor_elt
, v
, 0);
4973 d
.end
= d
.cur
+ VEC_length (constructor_elt
, v
);
4975 new_init
= reshape_init_r (type
, &d
, true);
4976 if (new_init
== error_mark_node
)
4977 return error_mark_node
;
4979 /* Make sure all the element of the constructor were used. Otherwise,
4980 issue an error about exceeding initializers. */
4982 error ("too many initializers for %qT", type
);
4987 /* Verify array initializer. Returns true if errors have been reported. */
4990 check_array_initializer (tree decl
, tree type
, tree init
)
4992 tree element_type
= TREE_TYPE (type
);
4994 /* The array type itself need not be complete, because the
4995 initializer may tell us how many elements are in the array.
4996 But, the elements of the array must be complete. */
4997 if (!COMPLETE_TYPE_P (complete_type (element_type
)))
5000 error ("elements of array %q#D have incomplete type", decl
);
5002 error ("elements of array %q#T have incomplete type", type
);
5005 /* It is not valid to initialize a VLA. */
5007 && ((COMPLETE_TYPE_P (type
) && !TREE_CONSTANT (TYPE_SIZE (type
)))
5008 || !TREE_CONSTANT (TYPE_SIZE (element_type
))))
5011 error ("variable-sized object %qD may not be initialized", decl
);
5013 error ("variable-sized compound literal");
5019 /* Subroutine of check_initializer; args are passed down from that function.
5020 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
5023 build_aggr_init_full_exprs (tree decl
, tree init
, int flags
)
5026 int saved_stmts_are_full_exprs_p
= 0;
5027 if (building_stmt_tree ())
5029 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
5030 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
5032 init
= build_aggr_init (decl
, init
, flags
, tf_warning_or_error
);
5033 if (building_stmt_tree ())
5034 current_stmt_tree ()->stmts_are_full_exprs_p
=
5035 saved_stmts_are_full_exprs_p
;
5039 /* Verify INIT (the initializer for DECL), and record the
5040 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
5041 grok_reference_init.
5043 If the return value is non-NULL, it is an expression that must be
5044 evaluated dynamically to initialize DECL. */
5047 check_initializer (tree decl
, tree init
, int flags
, tree
*cleanup
)
5049 tree type
= TREE_TYPE (decl
);
5050 tree init_code
= NULL
;
5052 /* Things that are going to be initialized need to have complete
5054 TREE_TYPE (decl
) = type
= complete_type (TREE_TYPE (decl
));
5056 if (type
== error_mark_node
)
5057 /* We will have already complained. */
5060 if (TREE_CODE (type
) == ARRAY_TYPE
)
5062 if (check_array_initializer (decl
, type
, init
))
5065 else if (!COMPLETE_TYPE_P (type
))
5067 error ("%qD has incomplete type", decl
);
5068 TREE_TYPE (decl
) = error_mark_node
;
5072 /* There is no way to make a variable-sized class type in GNU C++. */
5073 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type
)));
5075 if (init
&& BRACE_ENCLOSED_INITIALIZER_P (init
))
5077 int init_len
= VEC_length (constructor_elt
, CONSTRUCTOR_ELTS (init
));
5078 if (SCALAR_TYPE_P (type
))
5082 maybe_warn_cpp0x ("extended initializer lists");
5083 init
= build_zero_init (type
, NULL_TREE
, false);
5085 else if (init_len
!= 1)
5087 error ("scalar object %qD requires one element in initializer",
5089 TREE_TYPE (decl
) = error_mark_node
;
5095 if (TREE_CODE (decl
) == CONST_DECL
)
5097 gcc_assert (TREE_CODE (type
) != REFERENCE_TYPE
);
5099 DECL_INITIAL (decl
) = init
;
5101 gcc_assert (init
!= NULL_TREE
);
5104 else if (!DECL_EXTERNAL (decl
) && TREE_CODE (type
) == REFERENCE_TYPE
)
5105 init
= grok_reference_init (decl
, type
, init
, cleanup
);
5108 /* Do not reshape constructors of vectors (they don't need to be
5110 if (BRACE_ENCLOSED_INITIALIZER_P (init
))
5112 if (is_std_init_list (type
))
5113 return build_init_list_var_init (decl
, type
, init
, cleanup
);
5114 else if (TYPE_NON_AGGREGATE_CLASS (type
))
5116 /* Don't reshape if the class has constructors. */
5117 if (cxx_dialect
== cxx98
)
5118 error ("in C++98 %qD must be initialized by constructor, "
5121 init
= build_tree_list (NULL_TREE
, init
);
5123 else if ((*targetm
.vector_opaque_p
) (type
))
5125 error ("opaque vector types cannot be initialized");
5126 init
= error_mark_node
;
5129 init
= reshape_init (type
, init
);
5132 /* If DECL has an array type without a specific bound, deduce the
5133 array size from the initializer. */
5134 maybe_deduce_size_from_array_init (decl
, init
);
5135 type
= TREE_TYPE (decl
);
5136 if (type
== error_mark_node
)
5139 if (TYPE_NEEDS_CONSTRUCTING (type
)
5140 || (CLASS_TYPE_P (type
)
5141 && !BRACE_ENCLOSED_INITIALIZER_P (init
)))
5142 return build_aggr_init_full_exprs (decl
, init
, flags
);
5143 else if (TREE_CODE (init
) != TREE_VEC
)
5145 init_code
= store_init_value (decl
, init
);
5146 if (pedantic
&& TREE_CODE (type
) == ARRAY_TYPE
5147 && DECL_INITIAL (decl
)
5148 && TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
5149 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl
)))
5150 warning (0, "array %qD initialized by parenthesized string literal %qE",
5151 decl
, DECL_INITIAL (decl
));
5155 else if (DECL_EXTERNAL (decl
))
5157 else if (TYPE_P (type
) && TYPE_NEEDS_CONSTRUCTING (type
))
5158 return build_aggr_init_full_exprs (decl
, init
, flags
);
5159 else if (MAYBE_CLASS_TYPE_P (type
))
5161 tree core_type
= strip_array_types (type
);
5163 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type
))
5164 error ("structure %qD with uninitialized const members", decl
);
5165 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type
))
5166 error ("structure %qD with uninitialized reference members", decl
);
5168 check_for_uninitialized_const_var (decl
);
5171 check_for_uninitialized_const_var (decl
);
5173 if (init
&& init
!= error_mark_node
)
5174 init_code
= build2 (INIT_EXPR
, type
, decl
, init
);
5179 /* If DECL is not a local variable, give it RTL. */
5182 make_rtl_for_nonlocal_decl (tree decl
, tree init
, const char* asmspec
)
5184 int toplev
= toplevel_bindings_p ();
5186 const char *filename
;
5188 /* Set the DECL_ASSEMBLER_NAME for the object. */
5191 /* The `register' keyword, when used together with an
5192 asm-specification, indicates that the variable should be
5193 placed in a particular register. */
5194 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_REGISTER (decl
))
5196 set_user_assembler_name (decl
, asmspec
);
5197 DECL_HARD_REGISTER (decl
) = 1;
5201 if (TREE_CODE (decl
) == FUNCTION_DECL
5202 && DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
)
5203 set_builtin_user_assembler_name (decl
, asmspec
);
5204 set_user_assembler_name (decl
, asmspec
);
5208 /* Handle non-variables up front. */
5209 if (TREE_CODE (decl
) != VAR_DECL
)
5211 rest_of_decl_compilation (decl
, toplev
, at_eof
);
5215 /* If we see a class member here, it should be a static data
5217 if (DECL_LANG_SPECIFIC (decl
) && DECL_IN_AGGR_P (decl
))
5219 gcc_assert (TREE_STATIC (decl
));
5220 /* An in-class declaration of a static data member should be
5221 external; it is only a declaration, and not a definition. */
5222 if (init
== NULL_TREE
)
5223 gcc_assert (DECL_EXTERNAL (decl
) || !TREE_PUBLIC (decl
));
5226 /* We don't create any RTL for local variables. */
5227 if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
5230 /* We defer emission of local statics until the corresponding
5231 DECL_EXPR is expanded. */
5232 defer_p
= DECL_FUNCTION_SCOPE_P (decl
) || DECL_VIRTUAL_P (decl
);
5234 /* We try to defer namespace-scope static constants so that they are
5235 not emitted into the object file unnecessarily. */
5236 filename
= input_filename
;
5237 if (!DECL_VIRTUAL_P (decl
)
5238 && TREE_READONLY (decl
)
5239 && DECL_INITIAL (decl
) != NULL_TREE
5240 && DECL_INITIAL (decl
) != error_mark_node
5242 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl
))
5244 && !TREE_PUBLIC (decl
))
5246 /* Fool with the linkage of static consts according to #pragma
5248 struct c_fileinfo
*finfo
= get_fileinfo (filename
);
5249 if (!finfo
->interface_unknown
&& !TREE_PUBLIC (decl
))
5251 TREE_PUBLIC (decl
) = 1;
5252 DECL_EXTERNAL (decl
) = finfo
->interface_only
;
5257 /* Likewise for template instantiations. */
5258 else if (DECL_LANG_SPECIFIC (decl
)
5259 && DECL_IMPLICIT_INSTANTIATION (decl
))
5262 /* If we're not deferring, go ahead and assemble the variable. */
5264 rest_of_decl_compilation (decl
, toplev
, at_eof
);
5267 /* walk_tree helper for wrap_temporary_cleanups, below. */
5270 wrap_cleanups_r (tree
*stmt_p
, int *walk_subtrees
, void *data
)
5272 if (TYPE_P (*stmt_p
))
5278 if (TREE_CODE (*stmt_p
) == TARGET_EXPR
)
5280 tree guard
= (tree
)data
;
5281 tree tcleanup
= TARGET_EXPR_CLEANUP (*stmt_p
);
5283 tcleanup
= build2 (TRY_CATCH_EXPR
, void_type_node
, tcleanup
, guard
);
5284 /* Tell honor_protect_cleanup_actions to handle this as a separate
5286 TRY_CATCH_IS_CLEANUP (tcleanup
) = 1;
5288 TARGET_EXPR_CLEANUP (*stmt_p
) = tcleanup
;
5294 /* We're initializing a local variable which has a cleanup GUARD. If there
5295 are any temporaries used in the initializer INIT of this variable, we
5296 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
5297 variable will be cleaned up properly if one of them throws.
5299 Unfortunately, there's no way to express this properly in terms of
5300 nesting, as the regions for the temporaries overlap the region for the
5301 variable itself; if there are two temporaries, the variable needs to be
5302 the first thing destroyed if either of them throws. However, we only
5303 want to run the variable's cleanup if it actually got constructed. So
5304 we need to guard the temporary cleanups with the variable's cleanup if
5305 they are run on the normal path, but not if they are run on the
5306 exceptional path. We implement this by telling
5307 honor_protect_cleanup_actions to strip the variable cleanup from the
5308 exceptional path. */
5311 wrap_temporary_cleanups (tree init
, tree guard
)
5313 cp_walk_tree_without_duplicates (&init
, wrap_cleanups_r
, (void *)guard
);
5316 /* Generate code to initialize DECL (a local variable). */
5319 initialize_local_var (tree decl
, tree init
)
5321 tree type
= TREE_TYPE (decl
);
5325 gcc_assert (TREE_CODE (decl
) == VAR_DECL
5326 || TREE_CODE (decl
) == RESULT_DECL
);
5327 gcc_assert (!TREE_STATIC (decl
));
5329 if (DECL_SIZE (decl
) == NULL_TREE
)
5331 /* If we used it already as memory, it must stay in memory. */
5332 DECL_INITIAL (decl
) = NULL_TREE
;
5333 TREE_ADDRESSABLE (decl
) = TREE_USED (decl
);
5337 if (type
== error_mark_node
)
5340 /* Compute and store the initial value. */
5341 already_used
= TREE_USED (decl
) || TREE_USED (type
);
5343 /* Generate a cleanup, if necessary. */
5344 cleanup
= cxx_maybe_build_cleanup (decl
);
5346 /* Perform the initialization. */
5349 int saved_stmts_are_full_exprs_p
;
5351 /* If we're only initializing a single object, guard the destructors
5352 of any temporaries used in its initializer with its destructor.
5353 This isn't right for arrays because each element initialization is
5354 a full-expression. */
5355 if (cleanup
&& TREE_CODE (type
) != ARRAY_TYPE
)
5356 wrap_temporary_cleanups (init
, cleanup
);
5358 gcc_assert (building_stmt_tree ());
5359 saved_stmts_are_full_exprs_p
= stmts_are_full_exprs_p ();
5360 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
5361 finish_expr_stmt (init
);
5362 current_stmt_tree ()->stmts_are_full_exprs_p
=
5363 saved_stmts_are_full_exprs_p
;
5366 /* Set this to 0 so we can tell whether an aggregate which was
5367 initialized was ever used. Don't do this if it has a
5368 destructor, so we don't complain about the 'resource
5369 allocation is initialization' idiom. Now set
5370 attribute((unused)) on types so decls of that type will be
5371 marked used. (see TREE_USED, above.) */
5372 if (TYPE_NEEDS_CONSTRUCTING (type
)
5374 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type
)
5375 && DECL_NAME (decl
))
5376 TREE_USED (decl
) = 0;
5377 else if (already_used
)
5378 TREE_USED (decl
) = 1;
5381 finish_decl_cleanup (decl
, cleanup
);
5384 /* DECL is a VAR_DECL for a compiler-generated variable with static
5385 storage duration (like a virtual table) whose initializer is a
5386 compile-time constant. INIT must be either a TREE_LIST of values,
5387 or a CONSTRUCTOR. Initialize the variable and provide it to the
5391 initialize_artificial_var (tree decl
, tree init
)
5393 gcc_assert (DECL_ARTIFICIAL (decl
));
5394 if (TREE_CODE (init
) == TREE_LIST
)
5395 init
= build_constructor_from_list (TREE_TYPE (decl
), init
);
5396 gcc_assert (TREE_CODE (init
) == CONSTRUCTOR
);
5397 DECL_INITIAL (decl
) = init
;
5398 DECL_INITIALIZED_P (decl
) = 1;
5399 determine_visibility (decl
);
5400 layout_var_decl (decl
);
5401 maybe_commonize_var (decl
);
5402 make_rtl_for_nonlocal_decl (decl
, init
, /*asmspec=*/NULL
);
5405 /* INIT is the initializer for a variable, as represented by the
5406 parser. Returns true iff INIT is value-dependent. */
5409 value_dependent_init_p (tree init
)
5411 if (TREE_CODE (init
) == TREE_LIST
)
5412 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
5413 return any_value_dependent_elements_p (init
);
5414 else if (TREE_CODE (init
) == CONSTRUCTOR
)
5415 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
5417 VEC(constructor_elt
, gc
) *elts
;
5421 elts
= CONSTRUCTOR_ELTS (init
);
5422 nelts
= VEC_length (constructor_elt
, elts
);
5423 for (i
= 0; i
< nelts
; ++i
)
5424 if (value_dependent_init_p (VEC_index (constructor_elt
,
5429 /* It must be a simple expression, e.g., int i = 3; */
5430 return value_dependent_expression_p (init
);
5435 /* Finish processing of a declaration;
5436 install its line number and initial value.
5437 If the length of an array type is not known before,
5438 it must be determined now, from the initial value, or it is an error.
5440 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
5441 true, then INIT is an integral constant expression.
5443 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
5444 if the (init) syntax was used. */
5447 cp_finish_decl (tree decl
, tree init
, bool init_const_expr_p
,
5448 tree asmspec_tree
, int flags
)
5452 const char *asmspec
= NULL
;
5453 int was_readonly
= 0;
5454 bool var_definition_p
= false;
5455 int saved_processing_template_decl
;
5458 if (decl
== error_mark_node
)
5463 error ("assignment (not initialization) in declaration");
5467 gcc_assert (TREE_CODE (decl
) != RESULT_DECL
);
5468 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
5469 gcc_assert (TREE_CODE (decl
) != PARM_DECL
);
5471 type
= TREE_TYPE (decl
);
5472 if (type
== error_mark_node
)
5475 /* Assume no cleanup is required. */
5476 cleanup
= NULL_TREE
;
5477 saved_processing_template_decl
= processing_template_decl
;
5479 /* If a name was specified, get the string. */
5480 if (global_scope_p (current_binding_level
))
5481 asmspec_tree
= maybe_apply_renaming_pragma (decl
, asmspec_tree
);
5482 if (asmspec_tree
&& asmspec_tree
!= error_mark_node
)
5483 asmspec
= TREE_STRING_POINTER (asmspec_tree
);
5485 if (current_class_type
5486 && CP_DECL_CONTEXT (decl
) == current_class_type
5487 && TYPE_BEING_DEFINED (current_class_type
)
5488 && (DECL_INITIAL (decl
) || init
))
5489 DECL_INITIALIZED_IN_CLASS_P (decl
) = 1;
5491 auto_node
= type_uses_auto (type
);
5492 if (auto_node
&& !type_dependent_expression_p (init
))
5494 type
= TREE_TYPE (decl
) = do_auto_deduction (type
, init
, auto_node
);
5495 if (type
== error_mark_node
)
5499 if (processing_template_decl
)
5501 bool type_dependent_p
;
5503 /* Add this declaration to the statement-tree. */
5504 if (at_function_scope_p ())
5505 add_decl_expr (decl
);
5507 type_dependent_p
= dependent_type_p (type
);
5509 if (check_for_bare_parameter_packs (init
))
5512 DECL_INITIAL (decl
) = NULL_TREE
;
5515 if (init
&& init_const_expr_p
)
5517 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = 1;
5518 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl
))
5519 TREE_CONSTANT (decl
) = 1;
5522 /* Generally, initializers in templates are expanded when the
5523 template is instantiated. But, if DECL is an integral
5524 constant static data member, then it can be used in future
5525 integral constant expressions, and its value must be
5528 && DECL_CLASS_SCOPE_P (decl
)
5529 && DECL_INTEGRAL_CONSTANT_VAR_P (decl
)
5530 && !type_dependent_p
5531 && !value_dependent_init_p (init
)))
5534 DECL_INITIAL (decl
) = init
;
5535 if (TREE_CODE (decl
) == VAR_DECL
5536 && !DECL_PRETTY_FUNCTION_P (decl
)
5537 && !type_dependent_p
)
5538 maybe_deduce_size_from_array_init (decl
, init
);
5542 if (TREE_CODE (init
) == TREE_LIST
)
5544 /* If the parenthesized-initializer form was used (e.g.,
5545 "int A<N>::i(X)"), then INIT will be a TREE_LIST of initializer
5546 arguments. (There is generally only one.) We convert them
5549 for (; list
; list
= TREE_CHAIN (list
))
5551 tree elt
= TREE_VALUE (list
);
5552 TREE_VALUE (list
) = fold_non_dependent_expr (elt
);
5556 init
= fold_non_dependent_expr (init
);
5557 processing_template_decl
= 0;
5560 /* Take care of TYPE_DECLs up front. */
5561 if (TREE_CODE (decl
) == TYPE_DECL
)
5563 if (type
!= error_mark_node
5564 && MAYBE_CLASS_TYPE_P (type
) && DECL_NAME (decl
))
5566 if (TREE_TYPE (DECL_NAME (decl
)) && TREE_TYPE (decl
) != type
)
5567 warning (0, "shadowing previous type declaration of %q#D", decl
);
5568 set_identifier_type_value (DECL_NAME (decl
), decl
);
5571 /* If we have installed this as the canonical typedef for this
5572 type, and that type has not been defined yet, delay emitting
5573 the debug information for it, as we will emit it later. */
5574 if (TYPE_MAIN_DECL (TREE_TYPE (decl
)) == decl
5575 && !COMPLETE_TYPE_P (TREE_TYPE (decl
)))
5576 TYPE_DECL_SUPPRESS_DEBUG (decl
) = 1;
5578 rest_of_decl_compilation (decl
, DECL_CONTEXT (decl
) == NULL_TREE
,
5583 /* A reference will be modified here, as it is initialized. */
5584 if (! DECL_EXTERNAL (decl
)
5585 && TREE_READONLY (decl
)
5586 && TREE_CODE (type
) == REFERENCE_TYPE
)
5589 TREE_READONLY (decl
) = 0;
5592 if (TREE_CODE (decl
) == VAR_DECL
)
5594 /* Only PODs can have thread-local storage. Other types may require
5595 various kinds of non-trivial initialization. */
5596 if (DECL_THREAD_LOCAL_P (decl
) && !pod_type_p (TREE_TYPE (decl
)))
5597 error ("%qD cannot be thread-local because it has non-POD type %qT",
5598 decl
, TREE_TYPE (decl
));
5599 /* If this is a local variable that will need a mangled name,
5600 register it now. We must do this before processing the
5601 initializer for the variable, since the initialization might
5602 require a guard variable, and since the mangled name of the
5603 guard variable will depend on the mangled name of this
5605 if (DECL_FUNCTION_SCOPE_P (decl
)
5606 && TREE_STATIC (decl
)
5607 && !DECL_ARTIFICIAL (decl
))
5608 push_local_name (decl
);
5609 /* Convert the initializer to the type of DECL, if we have not
5610 already initialized DECL. */
5611 if (!DECL_INITIALIZED_P (decl
)
5612 /* If !DECL_EXTERNAL then DECL is being defined. In the
5613 case of a static data member initialized inside the
5614 class-specifier, there can be an initializer even if DECL
5615 is *not* defined. */
5616 && (!DECL_EXTERNAL (decl
) || init
))
5618 if (TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
5621 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
5622 /* Allow libjava/prims.cc define primitive classes. */
5623 if (init
!= NULL_TREE
5624 || jclass
== NULL_TREE
5625 || TREE_CODE (jclass
) != TYPE_DECL
5626 || !POINTER_TYPE_P (TREE_TYPE (jclass
))
5627 || !same_type_ignoring_top_level_qualifiers_p
5628 (type
, TREE_TYPE (TREE_TYPE (jclass
))))
5629 error ("Java object %qD not allocated with %<new%>", decl
);
5634 DECL_NONTRIVIALLY_INITIALIZED_P (decl
) = 1;
5635 if (init_const_expr_p
)
5637 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl
) = 1;
5638 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl
))
5639 TREE_CONSTANT (decl
) = 1;
5642 init
= check_initializer (decl
, init
, flags
, &cleanup
);
5643 /* Thread-local storage cannot be dynamically initialized. */
5644 if (DECL_THREAD_LOCAL_P (decl
) && init
)
5646 error ("%qD is thread-local and so cannot be dynamically "
5647 "initialized", decl
);
5651 /* Check that the initializer for a static data member was a
5652 constant. Although we check in the parser that the
5653 initializer is an integral constant expression, we do not
5654 simplify division-by-zero at the point at which it
5655 occurs. Therefore, in:
5657 struct S { static const int i = 7 / 0; };
5659 we issue an error at this point. It would
5660 probably be better to forbid division by zero in
5661 integral constant expressions. */
5662 if (DECL_EXTERNAL (decl
) && init
)
5664 error ("%qD cannot be initialized by a non-constant expression"
5665 " when being declared", decl
);
5666 DECL_INITIALIZED_IN_CLASS_P (decl
) = 0;
5674 The memory occupied by any object of static storage
5675 duration is zero-initialized at program startup before
5676 any other initialization takes place.
5678 We cannot create an appropriate initializer until after
5679 the type of DECL is finalized. If DECL_INITIAL is set,
5680 then the DECL is statically initialized, and any
5681 necessary zero-initialization has already been performed. */
5682 if (TREE_STATIC (decl
) && !DECL_INITIAL (decl
))
5683 DECL_INITIAL (decl
) = build_zero_init (TREE_TYPE (decl
),
5684 /*nelts=*/NULL_TREE
,
5685 /*static_storage_p=*/true);
5686 /* Remember that the initialization for this variable has
5688 DECL_INITIALIZED_P (decl
) = 1;
5689 /* This declaration is the definition of this variable,
5690 unless we are initializing a static data member within
5691 the class specifier. */
5692 if (!DECL_EXTERNAL (decl
))
5693 var_definition_p
= true;
5695 /* If the variable has an array type, lay out the type, even if
5696 there is no initializer. It is valid to index through the
5697 array, and we must get TYPE_ALIGN set correctly on the array
5699 else if (TREE_CODE (type
) == ARRAY_TYPE
)
5702 else if (TREE_CODE (decl
) == FIELD_DECL
5703 && TYPE_FOR_JAVA (type
) && MAYBE_CLASS_TYPE_P (type
))
5704 error ("non-static data member %qD has Java class type", decl
);
5706 /* Add this declaration to the statement-tree. This needs to happen
5707 after the call to check_initializer so that the DECL_EXPR for a
5708 reference temp is added before the DECL_EXPR for the reference itself. */
5709 if (at_function_scope_p ())
5710 add_decl_expr (decl
);
5712 /* Let the middle end know about variables and functions -- but not
5713 static data members in uninstantiated class templates. */
5714 if (!saved_processing_template_decl
5715 && (TREE_CODE (decl
) == VAR_DECL
5716 || TREE_CODE (decl
) == FUNCTION_DECL
))
5718 if (TREE_CODE (decl
) == VAR_DECL
)
5720 layout_var_decl (decl
);
5721 maybe_commonize_var (decl
);
5724 /* This needs to happen after the linkage is set. */
5725 determine_visibility (decl
);
5727 if (var_definition_p
&& TREE_STATIC (decl
))
5729 /* If a TREE_READONLY variable needs initialization
5730 at runtime, it is no longer readonly and we need to
5731 avoid MEM_READONLY_P being set on RTL created for it. */
5734 if (TREE_READONLY (decl
))
5735 TREE_READONLY (decl
) = 0;
5738 else if (was_readonly
)
5739 TREE_READONLY (decl
) = 1;
5742 make_rtl_for_nonlocal_decl (decl
, init
, asmspec
);
5744 /* Check for abstractness of the type. Notice that there is no
5745 need to strip array types here since the check for those types
5746 is already done within create_array_type_for_decl. */
5747 if (TREE_CODE (type
) == FUNCTION_TYPE
5748 || TREE_CODE (type
) == METHOD_TYPE
)
5749 abstract_virtuals_error (decl
, TREE_TYPE (type
));
5751 abstract_virtuals_error (decl
, type
);
5753 if (TREE_TYPE (decl
) == error_mark_node
)
5754 /* No initialization required. */
5756 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
5760 if (init
== ridpointers
[(int)RID_DELETE
])
5762 /* fixme check this is 1st decl */
5763 DECL_DELETED_FN (decl
) = 1;
5764 DECL_DECLARED_INLINE_P (decl
) = 1;
5765 DECL_INITIAL (decl
) = error_mark_node
;
5767 else if (init
== ridpointers
[(int)RID_DEFAULT
])
5769 if (!defaultable_fn_p (decl
))
5770 error ("%qD cannot be defaulted", decl
);
5773 /* An out-of-class default definition is defined at
5774 the point where it is explicitly defaulted. */
5775 DECL_DEFAULTED_FN (decl
) = 1;
5776 if (DECL_INITIAL (decl
) == error_mark_node
)
5777 synthesize_method (decl
);
5781 error ("function %q#D is initialized like a variable", decl
);
5783 /* else no initialization required. */
5785 else if (DECL_EXTERNAL (decl
)
5786 && ! (DECL_LANG_SPECIFIC (decl
)
5787 && DECL_NOT_REALLY_EXTERN (decl
)))
5790 DECL_INITIAL (decl
) = init
;
5792 /* A variable definition. */
5793 else if (DECL_FUNCTION_SCOPE_P (decl
) && !TREE_STATIC (decl
))
5794 /* Initialize the local variable. */
5795 initialize_local_var (decl
, init
);
5797 /* If a variable is defined, and then a subsequent
5798 definition with external linkage is encountered, we will
5799 get here twice for the same variable. We want to avoid
5800 calling expand_static_init more than once. For variables
5801 that are not static data members, we can call
5802 expand_static_init only when we actually process the
5803 initializer. It is not legal to redeclare a static data
5804 member, so this issue does not arise in that case. */
5805 else if (var_definition_p
&& TREE_STATIC (decl
))
5806 expand_static_init (decl
, init
);
5809 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
5810 reference, insert it in the statement-tree now. */
5812 push_cleanup (decl
, cleanup
, false);
5815 processing_template_decl
= saved_processing_template_decl
;
5818 TREE_READONLY (decl
) = 1;
5820 /* If this was marked 'used', be sure it will be output. */
5821 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl
)))
5822 mark_decl_referenced (decl
);
5825 /* This is here for a midend callback from c-common.c. */
5828 finish_decl (tree decl
, tree init
, tree asmspec_tree
)
5830 cp_finish_decl (decl
, init
, /*init_const_expr_p=*/false, asmspec_tree
, 0);
5833 /* Returns a declaration for a VAR_DECL as if:
5835 extern "C" TYPE NAME;
5837 had been seen. Used to create compiler-generated global
5841 declare_global_var (tree name
, tree type
)
5845 push_to_top_level ();
5846 decl
= build_decl (VAR_DECL
, name
, type
);
5847 TREE_PUBLIC (decl
) = 1;
5848 DECL_EXTERNAL (decl
) = 1;
5849 DECL_ARTIFICIAL (decl
) = 1;
5850 /* If the user has explicitly declared this variable (perhaps
5851 because the code we are compiling is part of a low-level runtime
5852 library), then it is possible that our declaration will be merged
5853 with theirs by pushdecl. */
5854 decl
= pushdecl (decl
);
5855 finish_decl (decl
, NULL_TREE
, NULL_TREE
);
5856 pop_from_top_level ();
5861 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
5862 if "__cxa_atexit" is not being used) corresponding to the function
5863 to be called when the program exits. */
5866 get_atexit_fn_ptr_type (void)
5871 if (!atexit_fn_ptr_type_node
)
5873 if (flag_use_cxa_atexit
5874 && !targetm
.cxx
.use_atexit_for_cxa_atexit ())
5875 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
5876 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, void_list_node
);
5878 /* The parameter to "atexit" is "void (*)(void)". */
5879 arg_types
= void_list_node
;
5881 fn_type
= build_function_type (void_type_node
, arg_types
);
5882 atexit_fn_ptr_type_node
= build_pointer_type (fn_type
);
5885 return atexit_fn_ptr_type_node
;
5888 /* Returns a pointer to the `atexit' function. Note that if
5889 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
5890 `__cxa_atexit' function specified in the IA64 C++ ABI. */
5893 get_atexit_node (void)
5900 bool use_aeabi_atexit
;
5905 if (flag_use_cxa_atexit
&& !targetm
.cxx
.use_atexit_for_cxa_atexit ())
5907 /* The declaration for `__cxa_atexit' is:
5909 int __cxa_atexit (void (*)(void *), void *, void *)
5911 We build up the argument types and then then function type
5914 use_aeabi_atexit
= targetm
.cxx
.use_aeabi_atexit ();
5915 /* First, build the pointer-to-function type for the first
5917 fn_ptr_type
= get_atexit_fn_ptr_type ();
5918 /* Then, build the rest of the argument types. */
5919 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, void_list_node
);
5920 if (use_aeabi_atexit
)
5922 arg_types
= tree_cons (NULL_TREE
, fn_ptr_type
, arg_types
);
5923 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, arg_types
);
5927 arg_types
= tree_cons (NULL_TREE
, ptr_type_node
, arg_types
);
5928 arg_types
= tree_cons (NULL_TREE
, fn_ptr_type
, arg_types
);
5930 /* And the final __cxa_atexit type. */
5931 fn_type
= build_function_type (integer_type_node
, arg_types
);
5932 fn_ptr_type
= build_pointer_type (fn_type
);
5933 if (use_aeabi_atexit
)
5934 name
= "__aeabi_atexit";
5936 name
= "__cxa_atexit";
5940 /* The declaration for `atexit' is:
5942 int atexit (void (*)());
5944 We build up the argument types and then then function type
5946 fn_ptr_type
= get_atexit_fn_ptr_type ();
5947 arg_types
= tree_cons (NULL_TREE
, fn_ptr_type
, void_list_node
);
5948 /* Build the final atexit type. */
5949 fn_type
= build_function_type (integer_type_node
, arg_types
);
5953 /* Now, build the function declaration. */
5954 push_lang_context (lang_name_c
);
5955 atexit_fndecl
= build_library_fn_ptr (name
, fn_type
);
5956 mark_used (atexit_fndecl
);
5957 pop_lang_context ();
5958 atexit_node
= decay_conversion (atexit_fndecl
);
5963 /* Returns the __dso_handle VAR_DECL. */
5966 get_dso_handle_node (void)
5968 if (dso_handle_node
)
5969 return dso_handle_node
;
5971 /* Declare the variable. */
5972 dso_handle_node
= declare_global_var (get_identifier ("__dso_handle"),
5975 return dso_handle_node
;
5978 /* Begin a new function with internal linkage whose job will be simply
5979 to destroy some particular variable. */
5981 static GTY(()) int start_cleanup_cnt
;
5984 start_cleanup_fn (void)
5989 bool use_cxa_atexit
= flag_use_cxa_atexit
5990 && !targetm
.cxx
.use_atexit_for_cxa_atexit ();
5992 push_to_top_level ();
5994 /* No need to mangle this. */
5995 push_lang_context (lang_name_c
);
5997 /* Build the name of the function. */
5998 sprintf (name
, "__tcf_%d", start_cleanup_cnt
++);
5999 /* Build the function declaration. */
6000 fntype
= TREE_TYPE (get_atexit_fn_ptr_type ());
6001 fndecl
= build_lang_decl (FUNCTION_DECL
, get_identifier (name
), fntype
);
6002 /* It's a function with internal linkage, generated by the
6004 TREE_PUBLIC (fndecl
) = 0;
6005 DECL_ARTIFICIAL (fndecl
) = 1;
6006 /* Make the function `inline' so that it is only emitted if it is
6007 actually needed. It is unlikely that it will be inlined, since
6008 it is only called via a function pointer, but we avoid unnecessary
6009 emissions this way. */
6010 DECL_INTERFACE_KNOWN (fndecl
) = 1;
6011 /* Build the parameter. */
6016 parmdecl
= cp_build_parm_decl (NULL_TREE
, ptr_type_node
);
6017 DECL_CONTEXT (parmdecl
) = fndecl
;
6018 TREE_USED (parmdecl
) = 1;
6019 DECL_ARGUMENTS (fndecl
) = parmdecl
;
6023 start_preparsed_function (fndecl
, NULL_TREE
, SF_PRE_PARSED
);
6025 pop_lang_context ();
6027 return current_function_decl
;
6030 /* Finish the cleanup function begun by start_cleanup_fn. */
6033 end_cleanup_fn (void)
6035 expand_or_defer_fn (finish_function (0));
6037 pop_from_top_level ();
6040 /* Generate code to handle the destruction of DECL, an object with
6041 static storage duration. */
6044 register_dtor_fn (tree decl
)
6053 type
= TREE_TYPE (decl
);
6054 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type
))
6055 return void_zero_node
;
6057 /* If we're using "__cxa_atexit" (or "__aeabi_atexit"), and DECL is
6058 a class object, we can just pass the destructor to
6059 "__cxa_atexit"; we don't have to build a temporary function to do
6061 use_dtor
= (flag_use_cxa_atexit
6062 && !targetm
.cxx
.use_atexit_for_cxa_atexit ()
6063 && CLASS_TYPE_P (type
));
6068 /* Find the destructor. */
6069 idx
= lookup_fnfields_1 (type
, complete_dtor_identifier
);
6070 gcc_assert (idx
>= 0);
6071 cleanup
= VEC_index (tree
, CLASSTYPE_METHOD_VEC (type
), idx
);
6072 /* Make sure it is accessible. */
6073 perform_or_defer_access_check (TYPE_BINFO (type
), cleanup
, cleanup
);
6077 /* Call build_cleanup before we enter the anonymous function so
6078 that any access checks will be done relative to the current
6079 scope, rather than the scope of the anonymous function. */
6080 build_cleanup (decl
);
6082 /* Now start the function. */
6083 cleanup
= start_cleanup_fn ();
6085 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
6086 to the original function, rather than the anonymous one. That
6087 will make the back end think that nested functions are in use,
6088 which causes confusion. */
6089 push_deferring_access_checks (dk_no_check
);
6090 fcall
= build_cleanup (decl
);
6091 pop_deferring_access_checks ();
6093 /* Create the body of the anonymous function. */
6094 compound_stmt
= begin_compound_stmt (BCS_FN_BODY
);
6095 finish_expr_stmt (fcall
);
6096 finish_compound_stmt (compound_stmt
);
6100 /* Call atexit with the cleanup function. */
6101 mark_used (cleanup
);
6102 cleanup
= build_address (cleanup
);
6103 if (flag_use_cxa_atexit
&& !targetm
.cxx
.use_atexit_for_cxa_atexit ())
6109 /* We must convert CLEANUP to the type that "__cxa_atexit"
6111 cleanup
= build_nop (get_atexit_fn_ptr_type (), cleanup
);
6112 /* "__cxa_atexit" will pass the address of DECL to the
6113 cleanup function. */
6115 addr
= build_address (decl
);
6116 /* The declared type of the parameter to "__cxa_atexit" is
6117 "void *". For plain "T*", we could just let the
6118 machinery in cp_build_function_call convert it -- but if the
6119 type is "cv-qualified T *", then we need to convert it
6120 before passing it in, to avoid spurious errors. */
6121 addr
= build_nop (ptr_type_node
, addr
);
6124 /* Since the cleanup functions we build ignore the address
6125 they're given, there's no reason to pass the actual address
6126 in, and, in general, it's cheaper to pass NULL than any
6128 addr
= null_pointer_node
;
6129 args
= tree_cons (NULL_TREE
,
6130 cp_build_unary_op (ADDR_EXPR
, get_dso_handle_node (), 0,
6131 tf_warning_or_error
),
6133 if (targetm
.cxx
.use_aeabi_atexit ())
6135 args
= tree_cons (NULL_TREE
, cleanup
, args
);
6136 args
= tree_cons (NULL_TREE
, addr
, args
);
6140 args
= tree_cons (NULL_TREE
, addr
, args
);
6141 args
= tree_cons (NULL_TREE
, cleanup
, args
);
6145 args
= tree_cons (NULL_TREE
, cleanup
, NULL_TREE
);
6146 return cp_build_function_call (get_atexit_node (), args
,
6147 tf_warning_or_error
);
6150 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
6151 is its initializer. Generate code to handle the construction
6152 and destruction of DECL. */
6155 expand_static_init (tree decl
, tree init
)
6157 gcc_assert (TREE_CODE (decl
) == VAR_DECL
);
6158 gcc_assert (TREE_STATIC (decl
));
6160 /* Some variables require no initialization. */
6162 && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl
))
6163 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl
)))
6166 if (DECL_FUNCTION_SCOPE_P (decl
))
6168 /* Emit code to perform this initialization but once. */
6169 tree if_stmt
= NULL_TREE
, inner_if_stmt
= NULL_TREE
;
6170 tree then_clause
= NULL_TREE
, inner_then_clause
= NULL_TREE
;
6171 tree guard
, guard_addr
;
6172 tree acquire_fn
, release_fn
, abort_fn
;
6175 /* Emit code to perform this initialization but once. This code
6178 static <type> guard;
6179 if (!guard.first_byte) {
6180 if (__cxa_guard_acquire (&guard)) {
6183 // Do initialization.
6184 flag = true; __cxa_guard_release (&guard);
6185 // Register variable for destruction at end of program.
6187 if (!flag) __cxa_guard_abort (&guard);
6191 Note that the `flag' variable is only set to 1 *after* the
6192 initialization is complete. This ensures that an exception,
6193 thrown during the construction, will cause the variable to
6194 reinitialized when we pass through this code again, as per:
6198 If the initialization exits by throwing an exception, the
6199 initialization is not complete, so it will be tried again
6200 the next time control enters the declaration.
6202 This process should be thread-safe, too; multiple threads
6203 should not be able to initialize the variable more than
6206 /* Create the guard variable. */
6207 guard
= get_guard (decl
);
6209 /* This optimization isn't safe on targets with relaxed memory
6210 consistency. On such targets we force synchronization in
6211 __cxa_guard_acquire. */
6212 if (!targetm
.relaxed_ordering
|| !flag_threadsafe_statics
)
6214 /* Begin the conditional initialization. */
6215 if_stmt
= begin_if_stmt ();
6216 finish_if_stmt_cond (get_guard_cond (guard
), if_stmt
);
6217 then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
6220 if (flag_threadsafe_statics
)
6222 guard_addr
= build_address (guard
);
6224 acquire_fn
= get_identifier ("__cxa_guard_acquire");
6225 release_fn
= get_identifier ("__cxa_guard_release");
6226 abort_fn
= get_identifier ("__cxa_guard_abort");
6227 if (!get_global_value_if_present (acquire_fn
, &acquire_fn
))
6229 tree argtypes
= tree_cons (NULL_TREE
, TREE_TYPE (guard_addr
),
6231 tree vfntype
= build_function_type (void_type_node
, argtypes
);
6232 acquire_fn
= push_library_fn
6233 (acquire_fn
, build_function_type (integer_type_node
, argtypes
),
6235 release_fn
= push_library_fn (release_fn
, vfntype
, NULL_TREE
);
6236 abort_fn
= push_library_fn (abort_fn
, vfntype
, NULL_TREE
);
6240 release_fn
= identifier_global_value (release_fn
);
6241 abort_fn
= identifier_global_value (abort_fn
);
6244 inner_if_stmt
= begin_if_stmt ();
6245 finish_if_stmt_cond (build_call_n (acquire_fn
, 1, guard_addr
),
6248 inner_then_clause
= begin_compound_stmt (BCS_NO_SCOPE
);
6249 begin
= get_target_expr (boolean_false_node
);
6250 flag
= TARGET_EXPR_SLOT (begin
);
6252 TARGET_EXPR_CLEANUP (begin
)
6253 = build3 (COND_EXPR
, void_type_node
, flag
,
6255 build_call_n (abort_fn
, 1, guard_addr
));
6256 CLEANUP_EH_ONLY (begin
) = 1;
6258 /* Do the initialization itself. */
6259 init
= add_stmt_to_compound (begin
, init
);
6260 init
= add_stmt_to_compound
6261 (init
, build2 (MODIFY_EXPR
, void_type_node
, flag
, boolean_true_node
));
6262 init
= add_stmt_to_compound
6263 (init
, build_call_n (release_fn
, 1, guard_addr
));
6266 init
= add_stmt_to_compound (init
, set_guard (guard
));
6268 /* Use atexit to register a function for destroying this static
6270 init
= add_stmt_to_compound (init
, register_dtor_fn (decl
));
6272 finish_expr_stmt (init
);
6274 if (flag_threadsafe_statics
)
6276 finish_compound_stmt (inner_then_clause
);
6277 finish_then_clause (inner_if_stmt
);
6278 finish_if_stmt (inner_if_stmt
);
6281 if (!targetm
.relaxed_ordering
|| !flag_threadsafe_statics
)
6283 finish_compound_stmt (then_clause
);
6284 finish_then_clause (if_stmt
);
6285 finish_if_stmt (if_stmt
);
6289 static_aggregates
= tree_cons (init
, decl
, static_aggregates
);
6293 /* Make TYPE a complete type based on INITIAL_VALUE.
6294 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6295 2 if there was no information (in which case assume 0 if DO_DEFAULT),
6296 3 if the initializer list is empty (in pedantic mode). */
6299 cp_complete_array_type (tree
*ptype
, tree initial_value
, bool do_default
)
6302 tree type
, elt_type
;
6306 unsigned HOST_WIDE_INT i
;
6309 /* An array of character type can be initialized from a
6310 brace-enclosed string constant.
6312 FIXME: this code is duplicated from reshape_init. Probably
6313 we should just call reshape_init here? */
6314 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype
)))
6315 && TREE_CODE (initial_value
) == CONSTRUCTOR
6316 && !VEC_empty (constructor_elt
, CONSTRUCTOR_ELTS (initial_value
)))
6318 VEC(constructor_elt
,gc
) *v
= CONSTRUCTOR_ELTS (initial_value
);
6319 tree value
= VEC_index (constructor_elt
, v
, 0)->value
;
6321 if (TREE_CODE (value
) == STRING_CST
6322 && VEC_length (constructor_elt
, v
) == 1)
6323 initial_value
= value
;
6326 /* If any of the elements are parameter packs, we can't actually
6327 complete this type now because the array size is dependent. */
6328 if (TREE_CODE (initial_value
) == CONSTRUCTOR
)
6330 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value
),
6333 if (PACK_EXPANSION_P (value
))
6339 failure
= complete_array_type (ptype
, initial_value
, do_default
);
6341 /* We can create the array before the element type is complete, which
6342 means that we didn't have these two bits set in the original type
6343 either. In completing the type, we are expected to propagate these
6344 bits. See also complete_type which does the same thing for arrays
6347 if (TYPE_DOMAIN (type
))
6349 elt_type
= TREE_TYPE (type
);
6350 TYPE_NEEDS_CONSTRUCTING (type
) = TYPE_NEEDS_CONSTRUCTING (elt_type
);
6351 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
6352 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type
);
6358 /* Return zero if something is declared to be a member of type
6359 CTYPE when in the context of CUR_TYPE. STRING is the error
6360 message to print in that case. Otherwise, quietly return 1. */
6363 member_function_or_else (tree ctype
, tree cur_type
, enum overload_flags flags
)
6365 if (ctype
&& ctype
!= cur_type
)
6367 if (flags
== DTOR_FLAG
)
6368 error ("destructor for alien class %qT cannot be a member", ctype
);
6370 error ("constructor for alien class %qT cannot be a member", ctype
);
6376 /* Subroutine of `grokdeclarator'. */
6378 /* Generate errors possibly applicable for a given set of specifiers.
6379 This is for ARM $7.1.2. */
6382 bad_specifiers (tree object
,
6391 error ("%qD declared as a %<virtual%> %s", object
, type
);
6393 error ("%qD declared as an %<inline%> %s", object
, type
);
6395 error ("%<const%> and %<volatile%> function specifiers on "
6396 "%qD invalid in %s declaration",
6399 error ("%q+D declared as a friend", object
);
6401 && (TREE_CODE (object
) == TYPE_DECL
6402 || (!TYPE_PTRFN_P (TREE_TYPE (object
))
6403 && !TYPE_REFFN_P (TREE_TYPE (object
))
6404 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object
)))))
6405 error ("%q+D declared with an exception specification", object
);
6408 /* DECL is a member function or static data member and is presently
6409 being defined. Check that the definition is taking place in a
6413 check_class_member_definition_namespace (tree decl
)
6415 /* These checks only apply to member functions and static data
6417 gcc_assert (TREE_CODE (decl
) == FUNCTION_DECL
6418 || TREE_CODE (decl
) == VAR_DECL
);
6419 /* We check for problems with specializations in pt.c in
6420 check_specialization_namespace, where we can issue better
6422 if (processing_specialization
)
6424 /* There are no restrictions on the placement of
6425 explicit instantiations. */
6426 if (processing_explicit_instantiation
)
6430 A member function definition that appears outside of the
6431 class definition shall appear in a namespace scope enclosing
6432 the class definition.
6436 The definition for a static data member shall appear in a
6437 namespace scope enclosing the member's class definition. */
6438 if (!is_ancestor (current_namespace
, DECL_CONTEXT (decl
)))
6439 permerror (input_location
, "definition of %qD is not in namespace enclosing %qT",
6440 decl
, DECL_CONTEXT (decl
));
6443 /* Build a PARM_DECL for the "this" parameter. TYPE is the
6444 METHOD_TYPE for a non-static member function; QUALS are the
6445 cv-qualifiers that apply to the function. */
6448 build_this_parm (tree type
, cp_cv_quals quals
)
6453 cp_cv_quals this_quals
;
6455 this_type
= TREE_VALUE (TYPE_ARG_TYPES (type
));
6456 /* The `this' parameter is implicitly `const'; it cannot be
6458 this_quals
= (quals
& TYPE_QUAL_RESTRICT
) | TYPE_QUAL_CONST
;
6459 qual_type
= cp_build_qualified_type (this_type
, this_quals
);
6460 parm
= build_artificial_parm (this_identifier
, qual_type
);
6461 cp_apply_type_quals_to_decl (this_quals
, parm
);
6465 /* CTYPE is class type, or null if non-class.
6466 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
6468 DECLARATOR is the function's name.
6469 PARMS is a chain of PARM_DECLs for the function.
6470 VIRTUALP is truthvalue of whether the function is virtual or not.
6471 FLAGS are to be passed through to `grokclassfn'.
6472 QUALS are qualifiers indicating whether the function is `const'
6474 RAISES is a list of exceptions that this function can raise.
6475 CHECK is 1 if we must find this method in CTYPE, 0 if we should
6476 not look, and -1 if we should not call `grokclassfn' at all.
6478 SFK is the kind of special function (if any) for the new function.
6480 Returns `NULL_TREE' if something goes wrong, after issuing
6481 applicable error messages. */
6484 grokfndecl (tree ctype
,
6488 tree orig_declarator
,
6490 enum overload_flags flags
,
6497 special_function_kind sfk
,
6504 int staticp
= ctype
&& TREE_CODE (type
) == FUNCTION_TYPE
;
6508 type
= build_exception_variant (type
, raises
);
6510 decl
= build_lang_decl (FUNCTION_DECL
, declarator
, type
);
6511 if (TREE_CODE (type
) == METHOD_TYPE
)
6514 parm
= build_this_parm (type
, quals
);
6515 TREE_CHAIN (parm
) = parms
;
6518 DECL_ARGUMENTS (decl
) = parms
;
6519 /* Propagate volatile out from type to decl. */
6520 if (TYPE_VOLATILE (type
))
6521 TREE_THIS_VOLATILE (decl
) = 1;
6523 /* Setup decl according to sfk. */
6526 case sfk_constructor
:
6527 case sfk_copy_constructor
:
6528 DECL_CONSTRUCTOR_P (decl
) = 1;
6530 case sfk_destructor
:
6531 DECL_DESTRUCTOR_P (decl
) = 1;
6537 /* If pointers to member functions use the least significant bit to
6538 indicate whether a function is virtual, ensure a pointer
6539 to this function will have that bit clear. */
6540 if (TARGET_PTRMEMFUNC_VBIT_LOCATION
== ptrmemfunc_vbit_in_pfn
6541 && TREE_CODE (type
) == METHOD_TYPE
6542 && DECL_ALIGN (decl
) < 2 * BITS_PER_UNIT
)
6543 DECL_ALIGN (decl
) = 2 * BITS_PER_UNIT
;
6546 && TREE_CODE (orig_declarator
) == TEMPLATE_ID_EXPR
)
6550 ("defining explicit specialization %qD in friend declaration",
6554 tree fns
= TREE_OPERAND (orig_declarator
, 0);
6555 tree args
= TREE_OPERAND (orig_declarator
, 1);
6557 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
6559 /* Something like `template <class T> friend void f<T>()'. */
6560 error ("invalid use of template-id %qD in declaration "
6561 "of primary template",
6567 /* A friend declaration of the form friend void f<>(). Record
6568 the information in the TEMPLATE_ID_EXPR. */
6569 SET_DECL_IMPLICIT_INSTANTIATION (decl
);
6571 if (TREE_CODE (fns
) == COMPONENT_REF
)
6573 /* Due to bison parser ickiness, we will have already looked
6574 up an operator_name or PFUNCNAME within the current class
6575 (see template_id in parse.y). If the current class contains
6576 such a name, we'll get a COMPONENT_REF here. Undo that. */
6578 gcc_assert (TREE_TYPE (TREE_OPERAND (fns
, 0))
6579 == current_class_type
);
6580 fns
= TREE_OPERAND (fns
, 1);
6582 gcc_assert (TREE_CODE (fns
) == IDENTIFIER_NODE
6583 || TREE_CODE (fns
) == OVERLOAD
);
6584 DECL_TEMPLATE_INFO (decl
) = tree_cons (fns
, args
, NULL_TREE
);
6586 for (t
= TYPE_ARG_TYPES (TREE_TYPE (decl
)); t
; t
= TREE_CHAIN (t
))
6587 if (TREE_PURPOSE (t
)
6588 && TREE_CODE (TREE_PURPOSE (t
)) == DEFAULT_ARG
)
6590 error ("default arguments are not allowed in declaration "
6591 "of friend template specialization %qD",
6598 error ("%<inline%> is not allowed in declaration of friend "
6599 "template specialization %qD",
6606 /* If this decl has namespace scope, set that up. */
6608 set_decl_namespace (decl
, in_namespace
, friendp
);
6610 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
6612 /* `main' and builtins have implicit 'C' linkage. */
6613 if ((MAIN_NAME_P (declarator
)
6614 || (IDENTIFIER_LENGTH (declarator
) > 10
6615 && IDENTIFIER_POINTER (declarator
)[0] == '_'
6616 && IDENTIFIER_POINTER (declarator
)[1] == '_'
6617 && strncmp (IDENTIFIER_POINTER (declarator
)+2, "builtin_", 8) == 0))
6618 && current_lang_name
== lang_name_cplusplus
6619 && ctype
== NULL_TREE
6620 /* NULL_TREE means global namespace. */
6621 && DECL_CONTEXT (decl
) == NULL_TREE
)
6622 SET_DECL_LANGUAGE (decl
, lang_c
);
6624 /* Should probably propagate const out from type to decl I bet (mrs). */
6627 DECL_STATIC_FUNCTION_P (decl
) = 1;
6628 DECL_CONTEXT (decl
) = ctype
;
6633 DECL_CONTEXT (decl
) = ctype
;
6635 check_class_member_definition_namespace (decl
);
6638 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
6640 if (processing_template_decl
)
6641 error ("cannot declare %<::main%> to be a template");
6643 error ("cannot declare %<::main%> to be inline");
6645 error ("cannot declare %<::main%> to be static");
6650 /* Members of anonymous types and local classes have no linkage; make
6651 them internal. If a typedef is made later, this will be changed. */
6652 if (ctype
&& (TYPE_ANONYMOUS_P (ctype
)
6653 || decl_function_context (TYPE_MAIN_DECL (ctype
))))
6658 /* [basic.link]: A name with no linkage (notably, the name of a class
6659 or enumeration declared in a local scope) shall not be used to
6660 declare an entity with linkage.
6662 Only check this for public decls for now. See core 319, 389. */
6663 t
= no_linkage_check (TREE_TYPE (decl
),
6664 /*relaxed_p=*/false);
6667 if (TYPE_ANONYMOUS_P (t
))
6669 if (DECL_EXTERN_C_P (decl
))
6670 /* Allow this; it's pretty common in C. */;
6673 permerror (input_location
, "non-local function %q#D uses anonymous type",
6675 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
6676 permerror (input_location
, "%q+#D does not refer to the unqualified "
6677 "type, so it is not used for linkage",
6682 permerror (input_location
, "non-local function %q#D uses local type %qT", decl
, t
);
6686 TREE_PUBLIC (decl
) = publicp
;
6689 DECL_INTERFACE_KNOWN (decl
) = 1;
6690 DECL_NOT_REALLY_EXTERN (decl
) = 1;
6693 /* If the declaration was declared inline, mark it as such. */
6695 DECL_DECLARED_INLINE_P (decl
) = 1;
6697 DECL_EXTERNAL (decl
) = 1;
6698 if (quals
&& TREE_CODE (type
) == FUNCTION_TYPE
)
6701 ? G_("static member function %qD cannot have cv-qualifier")
6702 : G_("non-member function %qD cannot have cv-qualifier"),
6704 quals
= TYPE_UNQUALIFIED
;
6707 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl
))
6708 && !grok_op_properties (decl
, /*complain=*/true))
6711 if (ctype
&& decl_function_context (decl
))
6712 DECL_NO_STATIC_CHAIN (decl
) = 1;
6715 /* Make the init_value nonzero so pushdecl knows this is not
6716 tentative. error_mark_node is replaced later with the BLOCK. */
6717 DECL_INITIAL (decl
) = error_mark_node
;
6719 if (TYPE_NOTHROW_P (type
) || nothrow_libfn_p (decl
))
6720 TREE_NOTHROW (decl
) = 1;
6722 /* Caller will do the rest of this. */
6726 if (ctype
!= NULL_TREE
)
6727 grokclassfn (ctype
, decl
, flags
);
6729 decl
= check_explicit_specialization (orig_declarator
, decl
,
6732 4 * (friendp
!= 0));
6733 if (decl
== error_mark_node
)
6738 cplus_decl_attributes (&decl
, *attrlist
, 0);
6739 *attrlist
= NULL_TREE
;
6742 /* Check main's type after attributes have been applied. */
6743 if (ctype
== NULL_TREE
&& DECL_MAIN_P (decl
))
6745 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl
)),
6748 tree oldtypeargs
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
6750 error ("%<::main%> must return %<int%>");
6751 newtype
= build_function_type (integer_type_node
, oldtypeargs
);
6752 TREE_TYPE (decl
) = newtype
;
6755 check_main_parameter_types (decl
);
6758 if (ctype
!= NULL_TREE
6759 && (! TYPE_FOR_JAVA (ctype
) || check_java_method (decl
))
6762 tree old_decl
= check_classfn (ctype
, decl
,
6763 (processing_template_decl
6764 > template_class_depth (ctype
))
6765 ? current_template_parms
6768 if (old_decl
== error_mark_node
)
6776 if (TREE_CODE (old_decl
) == TEMPLATE_DECL
)
6777 /* Because grokfndecl is always supposed to return a
6778 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
6779 here. We depend on our callers to figure out that its
6780 really a template that's being returned. */
6781 old_decl
= DECL_TEMPLATE_RESULT (old_decl
);
6783 if (DECL_STATIC_FUNCTION_P (old_decl
)
6784 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
)
6785 /* Remove the `this' parm added by grokclassfn.
6786 XXX Isn't this done in start_function, too? */
6787 revert_static_member_fn (decl
);
6788 if (DECL_ARTIFICIAL (old_decl
))
6790 error ("definition of implicitly-declared %qD", old_decl
);
6794 /* Since we've smashed OLD_DECL to its
6795 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
6796 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
6797 decl
= DECL_TEMPLATE_RESULT (decl
);
6799 /* Attempt to merge the declarations. This can fail, in
6800 the case of some invalid specialization declarations. */
6801 pushed_scope
= push_scope (ctype
);
6802 ok
= duplicate_decls (decl
, old_decl
, friendp
);
6804 pop_scope (pushed_scope
);
6807 error ("no %q#D member function declared in class %qT",
6815 if (DECL_CONSTRUCTOR_P (decl
) && !grok_ctor_properties (ctype
, decl
))
6818 if (ctype
== NULL_TREE
|| check
)
6822 DECL_VIRTUAL_P (decl
) = 1;
6827 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
6828 the linkage that DECL will receive in the object file. */
6831 set_linkage_for_static_data_member (tree decl
)
6833 /* A static data member always has static storage duration and
6834 external linkage. Note that static data members are forbidden in
6835 local classes -- the only situation in which a class has
6836 non-external linkage. */
6837 TREE_PUBLIC (decl
) = 1;
6838 TREE_STATIC (decl
) = 1;
6839 /* For non-template classes, static data members are always put
6840 out in exactly those files where they are defined, just as
6841 with ordinary namespace-scope variables. */
6842 if (!processing_template_decl
)
6843 DECL_INTERFACE_KNOWN (decl
) = 1;
6846 /* Create a VAR_DECL named NAME with the indicated TYPE.
6848 If SCOPE is non-NULL, it is the class type or namespace containing
6849 the variable. If SCOPE is NULL, the variable should is created in
6850 the innermost enclosings scope. */
6853 grokvardecl (tree type
,
6855 const cp_decl_specifier_seq
*declspecs
,
6861 tree explicit_scope
;
6863 gcc_assert (!name
|| TREE_CODE (name
) == IDENTIFIER_NODE
);
6865 /* Compute the scope in which to place the variable, but remember
6866 whether or not that scope was explicitly specified by the user. */
6867 explicit_scope
= scope
;
6870 /* An explicit "extern" specifier indicates a namespace-scope
6872 if (declspecs
->storage_class
== sc_extern
)
6873 scope
= current_namespace
;
6874 else if (!at_function_scope_p ())
6875 scope
= current_scope ();
6879 && (/* If the variable is a namespace-scope variable declared in a
6880 template, we need DECL_LANG_SPECIFIC. */
6881 (TREE_CODE (scope
) == NAMESPACE_DECL
&& processing_template_decl
)
6882 /* Similarly for namespace-scope variables with language linkage
6884 || (TREE_CODE (scope
) == NAMESPACE_DECL
6885 && current_lang_name
!= lang_name_cplusplus
)
6886 /* Similarly for static data members. */
6888 decl
= build_lang_decl (VAR_DECL
, name
, type
);
6890 decl
= build_decl (VAR_DECL
, name
, type
);
6892 if (explicit_scope
&& TREE_CODE (explicit_scope
) == NAMESPACE_DECL
)
6893 set_decl_namespace (decl
, explicit_scope
, 0);
6895 DECL_CONTEXT (decl
) = FROB_CONTEXT (scope
);
6897 if (declspecs
->storage_class
== sc_extern
)
6899 DECL_THIS_EXTERN (decl
) = 1;
6900 DECL_EXTERNAL (decl
) = !initialized
;
6903 if (DECL_CLASS_SCOPE_P (decl
))
6905 set_linkage_for_static_data_member (decl
);
6906 /* This function is only called with out-of-class definitions. */
6907 DECL_EXTERNAL (decl
) = 0;
6908 check_class_member_definition_namespace (decl
);
6910 /* At top level, either `static' or no s.c. makes a definition
6911 (perhaps tentative), and absence of `static' makes it public. */
6912 else if (toplevel_bindings_p ())
6914 TREE_PUBLIC (decl
) = (declspecs
->storage_class
!= sc_static
6915 && (DECL_THIS_EXTERN (decl
) || ! constp
));
6916 TREE_STATIC (decl
) = ! DECL_EXTERNAL (decl
);
6918 /* Not at top level, only `static' makes a static definition. */
6921 TREE_STATIC (decl
) = declspecs
->storage_class
== sc_static
;
6922 TREE_PUBLIC (decl
) = DECL_EXTERNAL (decl
);
6925 if (declspecs
->specs
[(int)ds_thread
])
6926 DECL_TLS_MODEL (decl
) = decl_default_tls_model (decl
);
6928 if (TREE_PUBLIC (decl
))
6930 /* [basic.link]: A name with no linkage (notably, the name of a class
6931 or enumeration declared in a local scope) shall not be used to
6932 declare an entity with linkage.
6934 Only check this for public decls for now. */
6935 tree t
= no_linkage_check (TREE_TYPE (decl
), /*relaxed_p=*/false);
6938 if (TYPE_ANONYMOUS_P (t
))
6940 if (DECL_EXTERN_C_P (decl
))
6941 /* Allow this; it's pretty common in C. */
6945 /* DRs 132, 319 and 389 seem to indicate types with
6946 no linkage can only be used to declare extern "C"
6947 entities. Since it's not always an error in the
6948 ISO C++ 90 Standard, we only issue a warning. */
6949 warning (0, "non-local variable %q#D uses anonymous type",
6951 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t
)))
6952 warning (0, "%q+#D does not refer to the unqualified "
6953 "type, so it is not used for linkage",
6958 warning (0, "non-local variable %q#D uses local type %qT", decl
, t
);
6962 DECL_INTERFACE_KNOWN (decl
) = 1;
6967 /* Create and return a canonical pointer to member function type, for
6968 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
6971 build_ptrmemfunc_type (tree type
)
6975 tree unqualified_variant
= NULL_TREE
;
6977 if (type
== error_mark_node
)
6980 /* If a canonical type already exists for this type, use it. We use
6981 this method instead of type_hash_canon, because it only does a
6982 simple equality check on the list of field members. */
6984 if ((t
= TYPE_GET_PTRMEMFUNC_TYPE (type
)))
6987 /* Make sure that we always have the unqualified pointer-to-member
6989 if (cp_type_quals (type
) != TYPE_UNQUALIFIED
)
6991 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type
));
6993 t
= make_class_type (RECORD_TYPE
);
6994 xref_basetypes (t
, NULL_TREE
);
6996 /* Let the front end know this is a pointer to member function... */
6997 TYPE_PTRMEMFUNC_FLAG (t
) = 1;
6998 /* ... and not really a class type. */
6999 SET_CLASS_TYPE_P (t
, 0);
7001 field
= build_decl (FIELD_DECL
, pfn_identifier
, type
);
7004 field
= build_decl (FIELD_DECL
, delta_identifier
, delta_type_node
);
7005 TREE_CHAIN (field
) = fields
;
7008 finish_builtin_struct (t
, "__ptrmemfunc_type", fields
, ptr_type_node
);
7010 /* Zap out the name so that the back end will give us the debugging
7011 information for this anonymous RECORD_TYPE. */
7012 TYPE_NAME (t
) = NULL_TREE
;
7014 /* If this is not the unqualified form of this pointer-to-member
7015 type, set the TYPE_MAIN_VARIANT for this type to be the
7016 unqualified type. Since they are actually RECORD_TYPEs that are
7017 not variants of each other, we must do this manually. */
7018 if (cp_type_quals (type
) != TYPE_UNQUALIFIED
)
7020 t
= build_qualified_type (t
, cp_type_quals (type
));
7021 TYPE_MAIN_VARIANT (t
) = unqualified_variant
;
7022 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (unqualified_variant
);
7023 TYPE_NEXT_VARIANT (unqualified_variant
) = t
;
7024 TREE_TYPE (TYPE_BINFO (t
)) = t
;
7027 /* Cache this pointer-to-member type so that we can find it again
7029 TYPE_SET_PTRMEMFUNC_TYPE (type
, t
);
7031 if (TYPE_STRUCTURAL_EQUALITY_P (type
))
7032 SET_TYPE_STRUCTURAL_EQUALITY (t
);
7033 else if (TYPE_CANONICAL (type
) != type
)
7034 TYPE_CANONICAL (t
) = build_ptrmemfunc_type (TYPE_CANONICAL (type
));
7039 /* Create and return a pointer to data member type. */
7042 build_ptrmem_type (tree class_type
, tree member_type
)
7044 if (TREE_CODE (member_type
) == METHOD_TYPE
)
7048 arg_types
= TYPE_ARG_TYPES (member_type
);
7049 class_type
= (cp_build_qualified_type
7051 cp_type_quals (TREE_TYPE (TREE_VALUE (arg_types
)))));
7053 = build_method_type_directly (class_type
,
7054 TREE_TYPE (member_type
),
7055 TREE_CHAIN (arg_types
));
7056 return build_ptrmemfunc_type (build_pointer_type (member_type
));
7060 gcc_assert (TREE_CODE (member_type
) != FUNCTION_TYPE
);
7061 return build_offset_type (class_type
, member_type
);
7065 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
7066 Check to see that the definition is valid. Issue appropriate error
7067 messages. Return 1 if the definition is particularly bad, or 0
7071 check_static_variable_definition (tree decl
, tree type
)
7073 /* Motion 10 at San Diego: If a static const integral data member is
7074 initialized with an integral constant expression, the initializer
7075 may appear either in the declaration (within the class), or in
7076 the definition, but not both. If it appears in the class, the
7077 member is a member constant. The file-scope definition is always
7079 if (!ARITHMETIC_TYPE_P (type
) && TREE_CODE (type
) != ENUMERAL_TYPE
)
7081 error ("invalid in-class initialization of static data member "
7082 "of non-integral type %qT",
7084 /* If we just return the declaration, crashes will sometimes
7085 occur. We therefore return void_type_node, as if this were a
7086 friend declaration, to cause callers to completely ignore
7087 this declaration. */
7090 else if (!CP_TYPE_CONST_P (type
))
7091 error ("ISO C++ forbids in-class initialization of non-const "
7092 "static member %qD",
7094 else if (!INTEGRAL_TYPE_P (type
))
7095 pedwarn (input_location
, OPT_pedantic
, "ISO C++ forbids initialization of member constant "
7096 "%qD of non-integral type %qT", decl
, type
);
7101 /* Given the SIZE (i.e., number of elements) in an array, compute an
7102 appropriate index type for the array. If non-NULL, NAME is the
7103 name of the thing being declared. */
7106 compute_array_index_type (tree name
, tree size
)
7110 tree abi_1_itype
= NULL_TREE
;
7112 if (error_operand_p (size
))
7113 return error_mark_node
;
7115 type
= TREE_TYPE (size
);
7116 /* The array bound must be an integer type. */
7117 if (!dependent_type_p (type
) && !INTEGRAL_TYPE_P (type
))
7120 error ("size of array %qD has non-integral type %qT", name
, type
);
7122 error ("size of array has non-integral type %qT", type
);
7123 size
= integer_one_node
;
7124 type
= TREE_TYPE (size
);
7127 if (value_dependent_expression_p (size
))
7129 /* We cannot do any checking for a value-dependent SIZE. Just
7130 build the index type and mark that it requires structural
7132 itype
= build_index_type (build_min (MINUS_EXPR
, sizetype
,
7133 size
, integer_one_node
));
7134 SET_TYPE_STRUCTURAL_EQUALITY (itype
);
7138 if (!abi_version_at_least (2) && processing_template_decl
)
7139 /* For abi-1, we handled all instances in templates the same way,
7140 even when they were non-dependent. This affects the manglings
7141 produced. So, we do the normal checking for non-dependent
7142 sizes, but at the end we'll return the same type that abi-1
7143 would have, but with TYPE_CANONICAL set to the "right"
7144 value that the current ABI would provide. */
7145 abi_1_itype
= build_index_type (build_min (MINUS_EXPR
, sizetype
,
7146 size
, integer_one_node
));
7148 /* The size might be the result of a cast. */
7149 STRIP_TYPE_NOPS (size
);
7151 /* It might be a const variable or enumeration constant. */
7152 size
= integral_constant_value (size
);
7154 /* Normally, the array-bound will be a constant. */
7155 if (TREE_CODE (size
) == INTEGER_CST
)
7157 /* Check to see if the array bound overflowed. Make that an
7158 error, no matter how generous we're being. */
7159 constant_expression_error (size
);
7161 /* An array must have a positive number of elements. */
7162 if (INT_CST_LT (size
, integer_zero_node
))
7165 error ("size of array %qD is negative", name
);
7167 error ("size of array is negative");
7168 size
= integer_one_node
;
7170 /* As an extension we allow zero-sized arrays. We always allow
7171 them in system headers because glibc uses them. */
7172 else if (integer_zerop (size
) && !in_system_header
)
7175 pedwarn (input_location
, OPT_pedantic
, "ISO C++ forbids zero-size array %qD", name
);
7177 pedwarn (input_location
, OPT_pedantic
, "ISO C++ forbids zero-size array");
7180 else if (TREE_CONSTANT (size
))
7182 /* `(int) &fn' is not a valid array bound. */
7184 error ("size of array %qD is not an integral constant-expression",
7187 error ("size of array is not an integral constant-expression");
7188 size
= integer_one_node
;
7190 else if (pedantic
&& warn_vla
!= 0)
7193 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array %qD", name
);
7195 pedwarn (input_location
, OPT_Wvla
, "ISO C++ forbids variable length array");
7197 else if (warn_vla
> 0)
7201 "variable length array %qD is used", name
);
7204 "variable length array is used");
7207 if (processing_template_decl
&& !TREE_CONSTANT (size
))
7208 /* A variable sized array. */
7209 itype
= build_min (MINUS_EXPR
, sizetype
, size
, integer_one_node
);
7212 HOST_WIDE_INT saved_processing_template_decl
;
7214 /* Compute the index of the largest element in the array. It is
7215 one less than the number of elements in the array. We save
7216 and restore PROCESSING_TEMPLATE_DECL so that computations in
7217 cp_build_binary_op will be appropriately folded. */
7218 saved_processing_template_decl
= processing_template_decl
;
7219 processing_template_decl
= 0;
7220 itype
= cp_build_binary_op (MINUS_EXPR
,
7221 cp_convert (ssizetype
, size
),
7222 cp_convert (ssizetype
, integer_one_node
),
7223 tf_warning_or_error
);
7224 itype
= fold (itype
);
7225 processing_template_decl
= saved_processing_template_decl
;
7227 if (!TREE_CONSTANT (itype
))
7228 /* A variable sized array. */
7229 itype
= variable_size (itype
);
7230 /* Make sure that there was no overflow when creating to a signed
7231 index type. (For example, on a 32-bit machine, an array with
7232 size 2^32 - 1 is too big.) */
7233 else if (TREE_CODE (itype
) == INTEGER_CST
7234 && TREE_OVERFLOW (itype
))
7236 error ("overflow in array dimension");
7237 TREE_OVERFLOW (itype
) = 0;
7241 /* Create and return the appropriate index type. */
7244 tree t
= build_index_type (itype
);
7245 TYPE_CANONICAL (abi_1_itype
) = TYPE_CANONICAL (t
);
7249 return build_index_type (itype
);
7252 /* Returns the scope (if any) in which the entity declared by
7253 DECLARATOR will be located. If the entity was declared with an
7254 unqualified name, NULL_TREE is returned. */
7257 get_scope_of_declarator (const cp_declarator
*declarator
)
7259 while (declarator
&& declarator
->kind
!= cdk_id
)
7260 declarator
= declarator
->declarator
;
7262 /* If the declarator-id is a SCOPE_REF, the scope in which the
7263 declaration occurs is the first operand. */
7265 && declarator
->u
.id
.qualifying_scope
)
7266 return declarator
->u
.id
.qualifying_scope
;
7268 /* Otherwise, the declarator is not a qualified name; the entity will
7269 be declared in the current scope. */
7273 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
7274 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
7278 create_array_type_for_decl (tree name
, tree type
, tree size
)
7280 tree itype
= NULL_TREE
;
7281 const char* error_msg
;
7283 /* If things have already gone awry, bail now. */
7284 if (type
== error_mark_node
|| size
== error_mark_node
)
7285 return error_mark_node
;
7287 /* Assume that everything will go OK. */
7290 /* There are some types which cannot be array elements. */
7291 switch (TREE_CODE (type
))
7294 error_msg
= "array of void";
7298 error_msg
= "array of functions";
7301 case REFERENCE_TYPE
:
7302 error_msg
= "array of references";
7306 error_msg
= "array of function members";
7313 /* If something went wrong, issue an error-message and return. */
7317 error ("declaration of %qD as %s", name
, error_msg
);
7319 error ("creating %s", error_msg
);
7321 return error_mark_node
;
7326 The constant expressions that specify the bounds of the arrays
7327 can be omitted only for the first member of the sequence. */
7328 if (TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
))
7331 error ("declaration of %qD as multidimensional array must "
7332 "have bounds for all dimensions except the first",
7335 error ("multidimensional array must have bounds for all "
7336 "dimensions except the first");
7338 return error_mark_node
;
7341 /* Figure out the index type for the array. */
7343 itype
= compute_array_index_type (name
, size
);
7346 T is called the array element type; this type shall not be [...] an
7347 abstract class type. */
7348 abstract_virtuals_error (name
, type
);
7350 return build_cplus_array_type (type
, itype
);
7353 /* Check that it's OK to declare a function with the indicated TYPE.
7354 SFK indicates the kind of special function (if any) that this
7355 function is. OPTYPE is the type given in a conversion operator
7356 declaration, or the class type for a constructor/destructor.
7357 Returns the actual return type of the function; that
7358 may be different than TYPE if an error occurs, or for certain
7359 special functions. */
7362 check_special_function_return_type (special_function_kind sfk
,
7368 case sfk_constructor
:
7370 error ("return type specification for constructor invalid");
7372 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
7373 type
= build_pointer_type (optype
);
7375 type
= void_type_node
;
7378 case sfk_destructor
:
7380 error ("return type specification for destructor invalid");
7381 /* We can't use the proper return type here because we run into
7382 problems with ambiguous bases and covariant returns.
7383 Java classes are left unchanged because (void *) isn't a valid
7384 Java type, and we don't want to change the Java ABI. */
7385 if (targetm
.cxx
.cdtor_returns_this () && !TYPE_FOR_JAVA (optype
))
7386 type
= build_pointer_type (void_type_node
);
7388 type
= void_type_node
;
7391 case sfk_conversion
:
7393 error ("return type specified for %<operator %T%>", optype
);
7404 /* A variable or data member (whose unqualified name is IDENTIFIER)
7405 has been declared with the indicated TYPE. If the TYPE is not
7406 acceptable, issue an error message and return a type to use for
7407 error-recovery purposes. */
7410 check_var_type (tree identifier
, tree type
)
7412 if (VOID_TYPE_P (type
))
7415 error ("unnamed variable or field declared void");
7416 else if (TREE_CODE (identifier
) == IDENTIFIER_NODE
)
7418 gcc_assert (!IDENTIFIER_OPNAME_P (identifier
));
7419 error ("variable or field %qE declared void", identifier
);
7422 error ("variable or field declared void");
7423 type
= error_mark_node
;
7429 /* Given declspecs and a declarator (abstract or otherwise), determine
7430 the name and type of the object declared and construct a DECL node
7433 DECLSPECS points to the representation of declaration-specifier
7434 sequence that precedes declarator.
7436 DECL_CONTEXT says which syntactic context this declaration is in:
7437 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
7438 FUNCDEF for a function definition. Like NORMAL but a few different
7439 error messages in each case. Return value may be zero meaning
7440 this definition is too screwy to try to parse.
7441 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
7442 handle member functions (which have FIELD context).
7443 Return value may be zero meaning this definition is too screwy to
7445 PARM for a parameter declaration (either within a function prototype
7446 or before a function body). Make a PARM_DECL, or return void_type_node.
7447 CATCHPARM for a parameter declaration before a catch clause.
7448 TYPENAME if for a typename (in a cast or sizeof).
7449 Don't make a DECL node; just return the ..._TYPE node.
7450 FIELD for a struct or union field; make a FIELD_DECL.
7451 BITFIELD for a field with specified width.
7452 INITIALIZED is as for start_decl.
7454 ATTRLIST is a pointer to the list of attributes, which may be NULL
7455 if there are none; *ATTRLIST may be modified if attributes from inside
7456 the declarator should be applied to the declaration.
7458 When this function is called, scoping variables (such as
7459 CURRENT_CLASS_TYPE) should reflect the scope in which the
7460 declaration occurs, not the scope in which the new declaration will
7461 be placed. For example, on:
7465 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
7468 Returns a DECL (if a declarator is present), a TYPE (if there is no
7469 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
7473 grokdeclarator (const cp_declarator
*declarator
,
7474 const cp_decl_specifier_seq
*declspecs
,
7475 enum decl_context decl_context
,
7479 tree type
= NULL_TREE
;
7481 int virtualp
, explicitp
, friendp
, inlinep
, staticp
;
7482 int explicit_int
= 0;
7483 int explicit_char
= 0;
7484 int defaulted_int
= 0;
7485 tree dependent_name
= NULL_TREE
;
7487 tree typedef_decl
= NULL_TREE
;
7488 const char *name
= NULL
;
7489 tree typedef_type
= NULL_TREE
;
7490 /* True if this declarator is a function definition. */
7491 bool funcdef_flag
= false;
7492 cp_declarator_kind innermost_code
= cdk_error
;
7495 /* See the code below that used this. */
7496 tree decl_attr
= NULL_TREE
;
7499 /* Keep track of what sort of function is being processed
7500 so that we can warn about default return values, or explicit
7501 return values which do not match prescribed defaults. */
7502 special_function_kind sfk
= sfk_none
;
7504 tree dname
= NULL_TREE
;
7505 tree ctor_return_type
= NULL_TREE
;
7506 enum overload_flags flags
= NO_SPECIAL
;
7507 /* cv-qualifiers that apply to the declarator, for a declaration of
7508 a member function. */
7509 cp_cv_quals memfn_quals
= TYPE_UNQUALIFIED
;
7510 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
7512 tree raises
= NULL_TREE
;
7513 int template_count
= 0;
7514 tree returned_attrs
= NULL_TREE
;
7515 tree parms
= NULL_TREE
;
7516 const cp_declarator
*id_declarator
;
7517 /* The unqualified name of the declarator; either an
7518 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
7519 tree unqualified_id
;
7520 /* The class type, if any, in which this entity is located,
7521 or NULL_TREE if none. Note that this value may be different from
7522 the current class type; for example if an attempt is made to declare
7523 "A::f" inside "B", this value will be "A". */
7524 tree ctype
= current_class_type
;
7525 /* The NAMESPACE_DECL for the namespace in which this entity is
7526 located. If an unqualified name is used to declare the entity,
7527 this value will be NULL_TREE, even if the entity is located at
7529 tree in_namespace
= NULL_TREE
;
7530 cp_storage_class storage_class
;
7531 bool unsigned_p
, signed_p
, short_p
, long_p
, thread_p
;
7532 bool type_was_error_mark_node
= false;
7533 bool parameter_pack_p
= declarator
? declarator
->parameter_pack_p
: false;
7534 bool set_no_warning
= false;
7536 signed_p
= declspecs
->specs
[(int)ds_signed
];
7537 unsigned_p
= declspecs
->specs
[(int)ds_unsigned
];
7538 short_p
= declspecs
->specs
[(int)ds_short
];
7539 long_p
= declspecs
->specs
[(int)ds_long
];
7540 longlong
= declspecs
->specs
[(int)ds_long
] >= 2;
7541 thread_p
= declspecs
->specs
[(int)ds_thread
];
7543 if (decl_context
== FUNCDEF
)
7544 funcdef_flag
= true, decl_context
= NORMAL
;
7545 else if (decl_context
== MEMFUNCDEF
)
7546 funcdef_flag
= true, decl_context
= FIELD
;
7547 else if (decl_context
== BITFIELD
)
7548 bitfield
= 1, decl_context
= FIELD
;
7550 if (initialized
> 1)
7551 funcdef_flag
= true;
7553 /* Look inside a declarator for the name being declared
7554 and get it as a string, for an error message. */
7555 for (id_declarator
= declarator
;
7557 id_declarator
= id_declarator
->declarator
)
7559 if (id_declarator
->kind
!= cdk_id
)
7560 innermost_code
= id_declarator
->kind
;
7562 switch (id_declarator
->kind
)
7565 if (id_declarator
->declarator
7566 && id_declarator
->declarator
->kind
== cdk_id
)
7568 sfk
= id_declarator
->declarator
->u
.id
.sfk
;
7569 if (sfk
== sfk_destructor
)
7576 tree qualifying_scope
= id_declarator
->u
.id
.qualifying_scope
;
7577 tree decl
= id_declarator
->u
.id
.unqualified_name
;
7580 if (qualifying_scope
)
7582 if (at_function_scope_p ())
7586 A declarator-id shall not be qualified except
7589 None of the cases are permitted in block
7591 if (qualifying_scope
== global_namespace
)
7592 error ("invalid use of qualified-name %<::%D%>",
7594 else if (TYPE_P (qualifying_scope
))
7595 error ("invalid use of qualified-name %<%T::%D%>",
7596 qualifying_scope
, decl
);
7598 error ("invalid use of qualified-name %<%D::%D%>",
7599 qualifying_scope
, decl
);
7600 return error_mark_node
;
7602 else if (TYPE_P (qualifying_scope
))
7604 ctype
= qualifying_scope
;
7605 if (innermost_code
!= cdk_function
7606 && current_class_type
7607 && !UNIQUELY_DERIVED_FROM_P (ctype
,
7608 current_class_type
))
7610 error ("type %qT is not derived from type %qT",
7611 ctype
, current_class_type
);
7612 return error_mark_node
;
7615 else if (TREE_CODE (qualifying_scope
) == NAMESPACE_DECL
)
7616 in_namespace
= qualifying_scope
;
7618 switch (TREE_CODE (decl
))
7624 if (innermost_code
!= cdk_function
)
7626 error ("declaration of %qD as non-function", decl
);
7627 return error_mark_node
;
7629 else if (!qualifying_scope
7630 && !(current_class_type
&& at_class_scope_p ()))
7632 error ("declaration of %qD as non-member", decl
);
7633 return error_mark_node
;
7636 type
= TREE_OPERAND (decl
, 0);
7637 name
= IDENTIFIER_POINTER (constructor_name (type
));
7642 case TEMPLATE_ID_EXPR
:
7644 tree fns
= TREE_OPERAND (decl
, 0);
7647 if (TREE_CODE (dname
) != IDENTIFIER_NODE
)
7649 gcc_assert (is_overloaded_fn (dname
));
7650 dname
= DECL_NAME (get_first_fn (dname
));
7655 case IDENTIFIER_NODE
:
7656 if (TREE_CODE (decl
) == IDENTIFIER_NODE
)
7659 if (C_IS_RESERVED_WORD (dname
))
7661 error ("declarator-id missing; using reserved word %qD",
7663 name
= IDENTIFIER_POINTER (dname
);
7665 else if (!IDENTIFIER_TYPENAME_P (dname
))
7666 name
= IDENTIFIER_POINTER (dname
);
7669 gcc_assert (flags
== NO_SPECIAL
);
7670 flags
= TYPENAME_FLAG
;
7671 ctor_return_type
= TREE_TYPE (dname
);
7672 sfk
= sfk_conversion
;
7673 if (is_typename_at_global_scope (dname
))
7674 name
= IDENTIFIER_POINTER (dname
);
7676 name
= "<invalid operator>";
7693 return error_mark_node
;
7698 if (id_declarator
->kind
== cdk_id
)
7704 The declarator in a function-definition shall have the form
7705 D1 ( parameter-declaration-clause) ... */
7706 if (funcdef_flag
&& innermost_code
!= cdk_function
)
7708 error ("function definition does not declare parameters");
7709 return error_mark_node
;
7712 if (((dname
&& IDENTIFIER_OPNAME_P (dname
)) || flags
== TYPENAME_FLAG
)
7713 && innermost_code
!= cdk_function
7714 && ! (ctype
&& !declspecs
->any_specifiers_p
))
7716 error ("declaration of %qD as non-function", dname
);
7717 return error_mark_node
;
7720 /* Anything declared one level down from the top level
7721 must be one of the parameters of a function
7722 (because the body is at least two levels down). */
7724 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
7725 by not allowing C++ class definitions to specify their parameters
7726 with xdecls (must be spec.d in the parmlist).
7728 Since we now wait to push a class scope until we are sure that
7729 we are in a legitimate method context, we must set oldcname
7730 explicitly (since current_class_name is not yet alive).
7732 We also want to avoid calling this a PARM if it is in a namespace. */
7734 if (decl_context
== NORMAL
&& !toplevel_bindings_p ())
7736 struct cp_binding_level
*b
= current_binding_level
;
7737 current_binding_level
= b
->level_chain
;
7738 if (current_binding_level
!= 0 && toplevel_bindings_p ())
7739 decl_context
= PARM
;
7740 current_binding_level
= b
;
7744 name
= decl_context
== PARM
? "parameter" : "type name";
7746 /* If there were multiple types specified in the decl-specifier-seq,
7747 issue an error message. */
7748 if (declspecs
->multiple_types_p
)
7750 error ("two or more data types in declaration of %qs", name
);
7751 return error_mark_node
;
7754 if (declspecs
->conflicting_specifiers_p
)
7756 error ("conflicting specifiers in declaration of %qs", name
);
7757 return error_mark_node
;
7760 /* Extract the basic type from the decl-specifier-seq. */
7761 type
= declspecs
->type
;
7762 if (type
== error_mark_node
)
7765 type_was_error_mark_node
= true;
7767 /* If the entire declaration is itself tagged as deprecated then
7768 suppress reports of deprecated items. */
7769 if (type
&& TREE_DEPRECATED (type
)
7770 && deprecated_state
!= DEPRECATED_SUPPRESS
)
7771 warn_deprecated_use (type
);
7772 if (type
&& TREE_CODE (type
) == TYPE_DECL
)
7774 typedef_decl
= type
;
7775 type
= TREE_TYPE (typedef_decl
);
7776 if (TREE_DEPRECATED (type
)
7777 && DECL_ARTIFICIAL (typedef_decl
)
7778 && deprecated_state
!= DEPRECATED_SUPPRESS
)
7779 warn_deprecated_use (type
);
7781 /* No type at all: default to `int', and set DEFAULTED_INT
7782 because it was not a user-defined typedef. */
7783 if (type
== NULL_TREE
&& (signed_p
|| unsigned_p
|| long_p
|| short_p
))
7785 /* These imply 'int'. */
7786 type
= integer_type_node
;
7790 explicit_int
= declspecs
->explicit_int_p
;
7791 explicit_char
= declspecs
->explicit_char_p
;
7794 /* See the code below that used this. */
7796 decl_attr
= DECL_ATTRIBUTES (typedef_decl
);
7798 typedef_type
= type
;
7801 if (sfk
!= sfk_conversion
)
7802 ctor_return_type
= ctype
;
7804 if (sfk
!= sfk_none
)
7805 type
= check_special_function_return_type (sfk
, type
,
7807 else if (type
== NULL_TREE
)
7813 /* We handle `main' specially here, because 'main () { }' is so
7814 common. With no options, it is allowed. With -Wreturn-type,
7815 it is a warning. It is only an error with -pedantic-errors. */
7816 is_main
= (funcdef_flag
7817 && dname
&& MAIN_NAME_P (dname
)
7818 && ctype
== NULL_TREE
7819 && in_namespace
== NULL_TREE
7820 && current_namespace
== global_namespace
);
7822 if (type_was_error_mark_node
)
7823 /* We've already issued an error, don't complain more. */;
7824 else if (in_system_header
|| flag_ms_extensions
)
7825 /* Allow it, sigh. */;
7827 permerror (input_location
, "ISO C++ forbids declaration of %qs with no type", name
);
7829 pedwarn (input_location
, OPT_pedantic
,
7830 "ISO C++ forbids declaration of %qs with no type", name
);
7832 warning (OPT_Wreturn_type
,
7833 "ISO C++ forbids declaration of %qs with no type", name
);
7835 type
= integer_type_node
;
7840 /* Now process the modifiers that were specified
7841 and check for invalid combinations. */
7843 /* Long double is a special combination. */
7844 if (long_p
&& !longlong
&& TYPE_MAIN_VARIANT (type
) == double_type_node
)
7847 type
= build_qualified_type (long_double_type_node
,
7848 cp_type_quals (type
));
7851 /* Check all other uses of type modifiers. */
7853 if (unsigned_p
|| signed_p
|| long_p
|| short_p
)
7857 if ((signed_p
|| unsigned_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
7858 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
7859 else if (signed_p
&& unsigned_p
)
7860 error ("%<signed%> and %<unsigned%> specified together for %qs", name
);
7861 else if (longlong
&& TREE_CODE (type
) != INTEGER_TYPE
)
7862 error ("%<long long%> invalid for %qs", name
);
7863 else if (long_p
&& TREE_CODE (type
) == REAL_TYPE
)
7864 error ("%<long%> invalid for %qs", name
);
7865 else if (short_p
&& TREE_CODE (type
) == REAL_TYPE
)
7866 error ("%<short%> invalid for %qs", name
);
7867 else if ((long_p
|| short_p
) && TREE_CODE (type
) != INTEGER_TYPE
)
7868 error ("%<long%> or %<short%> invalid for %qs", name
);
7869 else if ((long_p
|| short_p
) && explicit_char
)
7870 error ("%<long%> or %<short%> specified with char for %qs", name
);
7871 else if (long_p
&& short_p
)
7872 error ("%<long%> and %<short%> specified together for %qs", name
);
7873 else if (type
== char16_type_node
|| type
== char32_type_node
)
7875 if (signed_p
|| unsigned_p
)
7876 error ("%<signed%> or %<unsigned%> invalid for %qs", name
);
7877 else if (short_p
|| long_p
)
7878 error ("%<short%> or %<long%> invalid for %qs", name
);
7883 if (!explicit_int
&& !defaulted_int
&& !explicit_char
&& pedantic
)
7885 pedwarn (input_location
, OPT_pedantic
,
7886 "long, short, signed or unsigned used invalidly for %qs",
7888 if (flag_pedantic_errors
)
7893 /* Discard the type modifiers if they are invalid. */
7904 /* Decide whether an integer type is signed or not.
7905 Optionally treat bitfields as signed by default. */
7909 It is implementation-defined whether a plain (neither
7910 explicitly signed or unsigned) char, short, int, or long
7911 bit-field is signed or unsigned.
7913 Naturally, we extend this to long long as well. Note that
7914 this does not include wchar_t. */
7915 || (bitfield
&& !flag_signed_bitfields
7917 /* A typedef for plain `int' without `signed' can be
7918 controlled just like plain `int', but a typedef for
7919 `signed int' cannot be so controlled. */
7921 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
))
7922 && TREE_CODE (type
) == INTEGER_TYPE
7923 && !same_type_p (TYPE_MAIN_VARIANT (type
), wchar_type_node
)))
7926 type
= long_long_unsigned_type_node
;
7928 type
= long_unsigned_type_node
;
7930 type
= short_unsigned_type_node
;
7931 else if (type
== char_type_node
)
7932 type
= unsigned_char_type_node
;
7933 else if (typedef_decl
)
7934 type
= unsigned_type_for (type
);
7936 type
= unsigned_type_node
;
7938 else if (signed_p
&& type
== char_type_node
)
7939 type
= signed_char_type_node
;
7941 type
= long_long_integer_type_node
;
7943 type
= long_integer_type_node
;
7945 type
= short_integer_type_node
;
7947 if (declspecs
->specs
[(int)ds_complex
])
7949 if (TREE_CODE (type
) != INTEGER_TYPE
&& TREE_CODE (type
) != REAL_TYPE
)
7950 error ("complex invalid for %qs", name
);
7951 /* If we just have "complex", it is equivalent to
7952 "complex double", but if any modifiers at all are specified it is
7953 the complex form of TYPE. E.g, "complex short" is
7954 "complex short int". */
7956 else if (defaulted_int
&& ! longlong
7957 && ! (long_p
|| short_p
|| signed_p
|| unsigned_p
))
7958 type
= complex_double_type_node
;
7959 else if (type
== integer_type_node
)
7960 type
= complex_integer_type_node
;
7961 else if (type
== float_type_node
)
7962 type
= complex_float_type_node
;
7963 else if (type
== double_type_node
)
7964 type
= complex_double_type_node
;
7965 else if (type
== long_double_type_node
)
7966 type
= complex_long_double_type_node
;
7968 type
= build_complex_type (type
);
7971 type_quals
= TYPE_UNQUALIFIED
;
7972 if (declspecs
->specs
[(int)ds_const
])
7973 type_quals
|= TYPE_QUAL_CONST
;
7974 if (declspecs
->specs
[(int)ds_volatile
])
7975 type_quals
|= TYPE_QUAL_VOLATILE
;
7976 if (declspecs
->specs
[(int)ds_restrict
])
7977 type_quals
|= TYPE_QUAL_RESTRICT
;
7978 if (sfk
== sfk_conversion
&& type_quals
!= TYPE_UNQUALIFIED
)
7979 error ("qualifiers are not allowed on declaration of %<operator %T%>",
7982 if (TREE_CODE (type
) == FUNCTION_TYPE
7983 && type_quals
!= TYPE_UNQUALIFIED
)
7985 /* This was an error in C++98 (cv-qualifiers cannot be added to
7986 a function type), but DR 295 makes the code well-formed by
7987 dropping the extra qualifiers. */
7990 tree bad_type
= build_qualified_type (type
, type_quals
);
7991 pedwarn (input_location
, OPT_pedantic
,
7992 "ignoring %qV qualifiers added to function type %qT",
7995 type_quals
= TYPE_UNQUALIFIED
;
7997 type_quals
|= cp_type_quals (type
);
7998 type
= cp_build_qualified_type_real
7999 (type
, type_quals
, ((typedef_decl
&& !DECL_ARTIFICIAL (typedef_decl
)
8000 ? tf_ignore_bad_quals
: 0) | tf_warning_or_error
));
8001 /* We might have ignored or rejected some of the qualifiers. */
8002 type_quals
= cp_type_quals (type
);
8005 inlinep
= !! declspecs
->specs
[(int)ds_inline
];
8006 virtualp
= !! declspecs
->specs
[(int)ds_virtual
];
8007 explicitp
= !! declspecs
->specs
[(int)ds_explicit
];
8009 storage_class
= declspecs
->storage_class
;
8010 if (storage_class
== sc_static
)
8011 staticp
= 1 + (decl_context
== FIELD
);
8013 if (virtualp
&& staticp
== 2)
8015 error ("member %qD cannot be declared both virtual and static", dname
);
8016 storage_class
= sc_none
;
8019 friendp
= !! declspecs
->specs
[(int)ds_friend
];
8021 if (dependent_name
&& !friendp
)
8023 error ("%<%T::%D%> is not a valid declarator", ctype
, dependent_name
);
8024 return error_mark_node
;
8027 /* Issue errors about use of storage classes for parameters. */
8028 if (decl_context
== PARM
)
8030 if (declspecs
->specs
[(int)ds_typedef
])
8032 error ("typedef declaration invalid in parameter declaration");
8033 return error_mark_node
;
8035 else if (storage_class
== sc_static
8036 || storage_class
== sc_extern
8038 error ("storage class specifiers invalid in parameter declarations");
8041 /* Give error if `virtual' is used outside of class declaration. */
8043 && (current_class_name
== NULL_TREE
|| decl_context
!= FIELD
))
8045 error ("%<virtual%> outside class declaration");
8049 /* Static anonymous unions are dealt with here. */
8050 if (staticp
&& decl_context
== TYPENAME
8052 && ANON_AGGR_TYPE_P (declspecs
->type
))
8053 decl_context
= FIELD
;
8055 /* Warn about storage classes that are invalid for certain
8056 kinds of declarations (parameters, typenames, etc.). */
8059 && storage_class
!= sc_extern
8060 && storage_class
!= sc_static
)
8061 || declspecs
->specs
[(int)ds_typedef
]))
8063 error ("multiple storage classes in declaration of %qs", name
);
8066 if (decl_context
!= NORMAL
8067 && ((storage_class
!= sc_none
8068 && storage_class
!= sc_mutable
)
8071 if ((decl_context
== PARM
|| decl_context
== CATCHPARM
)
8072 && (storage_class
== sc_register
8073 || storage_class
== sc_auto
))
8075 else if (declspecs
->specs
[(int)ds_typedef
])
8077 else if (decl_context
== FIELD
8078 /* C++ allows static class elements. */
8079 && storage_class
== sc_static
)
8080 /* C++ also allows inlines and signed and unsigned elements,
8081 but in those cases we don't come in here. */
8085 if (decl_context
== FIELD
)
8086 error ("storage class specified for %qs", name
);
8089 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
8090 error ("storage class specified for parameter %qs", name
);
8092 error ("storage class specified for typename");
8094 if (storage_class
== sc_register
8095 || storage_class
== sc_auto
8096 || storage_class
== sc_extern
8098 storage_class
= sc_none
;
8101 else if (storage_class
== sc_extern
&& funcdef_flag
8102 && ! toplevel_bindings_p ())
8103 error ("nested function %qs declared %<extern%>", name
);
8104 else if (toplevel_bindings_p ())
8106 if (storage_class
== sc_auto
)
8107 error ("top-level declaration of %qs specifies %<auto%>", name
);
8110 && storage_class
!= sc_extern
8111 && storage_class
!= sc_static
)
8113 error ("function-scope %qs implicitly auto and declared %<__thread%>",
8118 if (storage_class
&& friendp
)
8120 error ("storage class specifiers invalid in friend function declarations");
8121 storage_class
= sc_none
;
8126 unqualified_id
= NULL_TREE
;
8129 unqualified_id
= id_declarator
->u
.id
.unqualified_name
;
8130 switch (TREE_CODE (unqualified_id
))
8134 = constructor_name (TREE_OPERAND (unqualified_id
, 0));
8137 case IDENTIFIER_NODE
:
8138 case TEMPLATE_ID_EXPR
:
8146 /* Determine the type of the entity declared by recurring on the
8148 for (; declarator
; declarator
= declarator
->declarator
)
8150 const cp_declarator
*inner_declarator
;
8153 if (type
== error_mark_node
)
8154 return error_mark_node
;
8156 attrs
= declarator
->attributes
;
8162 if (declarator
== NULL
|| declarator
->kind
== cdk_id
)
8163 attr_flags
|= (int) ATTR_FLAG_DECL_NEXT
;
8164 if (declarator
->kind
== cdk_function
)
8165 attr_flags
|= (int) ATTR_FLAG_FUNCTION_NEXT
;
8166 if (declarator
->kind
== cdk_array
)
8167 attr_flags
|= (int) ATTR_FLAG_ARRAY_NEXT
;
8168 returned_attrs
= decl_attributes (&type
,
8169 chainon (returned_attrs
, attrs
),
8173 if (declarator
->kind
== cdk_id
)
8176 inner_declarator
= declarator
->declarator
;
8178 switch (declarator
->kind
)
8181 type
= create_array_type_for_decl (dname
, type
,
8182 declarator
->u
.array
.bounds
);
8190 /* Declaring a function type.
8191 Make sure we have a valid type for the function to return. */
8193 if (type_quals
!= TYPE_UNQUALIFIED
)
8195 if (SCALAR_TYPE_P (type
) || VOID_TYPE_P (type
))
8196 warning (OPT_Wignored_qualifiers
,
8197 "type qualifiers ignored on function return type");
8198 /* We now know that the TYPE_QUALS don't apply to the
8199 decl, but to its return type. */
8200 type_quals
= TYPE_UNQUALIFIED
;
8201 set_no_warning
= true;
8204 /* Error about some types functions can't return. */
8206 if (TREE_CODE (type
) == FUNCTION_TYPE
)
8208 error ("%qs declared as function returning a function", name
);
8209 return error_mark_node
;
8211 if (TREE_CODE (type
) == ARRAY_TYPE
)
8213 error ("%qs declared as function returning an array", name
);
8214 return error_mark_node
;
8217 /* Pick up type qualifiers which should be applied to `this'. */
8218 memfn_quals
= declarator
->u
.function
.qualifiers
;
8220 /* Pick up the exception specifications. */
8221 raises
= declarator
->u
.function
.exception_specification
;
8223 /* Handle a late-specified return type. */
8224 type
= splice_late_return_type
8225 (type
, declarator
->u
.function
.late_return_type
);
8226 if (type
== error_mark_node
)
8227 return error_mark_node
;
8229 /* Say it's a definition only for the CALL_EXPR
8230 closest to the identifier. */
8231 funcdecl_p
= inner_declarator
&& inner_declarator
->kind
== cdk_id
;
8233 if (ctype
== NULL_TREE
8234 && decl_context
== FIELD
8236 && (friendp
== 0 || dname
== current_class_name
))
8237 ctype
= current_class_type
;
8239 if (ctype
&& (sfk
== sfk_constructor
8240 || sfk
== sfk_destructor
))
8242 /* We are within a class's scope. If our declarator name
8243 is the same as the class name, and we are defining
8244 a function, then it is a constructor/destructor, and
8245 therefore returns a void type. */
8247 /* ISO C++ 12.4/2. A destructor may not be declared
8248 const or volatile. A destructor may not be
8251 ISO C++ 12.1. A constructor may not be declared
8252 const or volatile. A constructor may not be
8253 virtual. A constructor may not be static. */
8255 error ((flags
== DTOR_FLAG
)
8256 ? "destructor cannot be static member function"
8257 : "constructor cannot be static member function");
8260 error ((flags
== DTOR_FLAG
)
8261 ? "destructors may not be cv-qualified"
8262 : "constructors may not be cv-qualified");
8263 memfn_quals
= TYPE_UNQUALIFIED
;
8266 if (decl_context
== FIELD
8267 && !member_function_or_else (ctype
,
8270 return error_mark_node
;
8272 if (flags
!= DTOR_FLAG
)
8274 /* It's a constructor. */
8279 permerror (input_location
, "constructors cannot be declared virtual");
8282 if (decl_context
== FIELD
8283 && sfk
!= sfk_constructor
)
8284 return error_mark_node
;
8286 if (decl_context
== FIELD
)
8292 error ("can't initialize friend function %qs", name
);
8295 /* Cannot be both friend and virtual. */
8296 error ("virtual functions cannot be friends");
8299 if (decl_context
== NORMAL
)
8300 error ("friend declaration not in class definition");
8301 if (current_function_decl
&& funcdef_flag
)
8302 error ("can't define friend function %qs in a local "
8307 arg_types
= grokparms (declarator
->u
.function
.parameters
,
8310 if (inner_declarator
8311 && inner_declarator
->kind
== cdk_id
8312 && inner_declarator
->u
.id
.sfk
== sfk_destructor
8313 && arg_types
!= void_list_node
)
8315 error ("destructors may not have parameters");
8316 arg_types
= void_list_node
;
8320 type
= build_function_type (type
, arg_types
);
8327 /* Filter out pointers-to-references and references-to-references.
8328 We can get these if a TYPE_DECL is used. */
8330 if (TREE_CODE (type
) == REFERENCE_TYPE
)
8332 if (declarator
->kind
!= cdk_reference
)
8334 error ("cannot declare pointer to %q#T", type
);
8335 type
= TREE_TYPE (type
);
8338 /* In C++0x, we allow reference to reference declarations
8339 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
8340 and template type arguments [14.3.1/4 temp.arg.type]. The
8341 check for direct reference to reference declarations, which
8342 are still forbidden, occurs below. Reasoning behind the change
8343 can be found in DR106, DR540, and the rvalue reference
8345 else if (cxx_dialect
== cxx98
)
8347 error ("cannot declare reference to %q#T", type
);
8348 type
= TREE_TYPE (type
);
8351 else if (VOID_TYPE_P (type
))
8353 if (declarator
->kind
== cdk_reference
)
8354 error ("cannot declare reference to %q#T", type
);
8355 else if (declarator
->kind
== cdk_ptrmem
)
8356 error ("cannot declare pointer to %q#T member", type
);
8359 /* We now know that the TYPE_QUALS don't apply to the decl,
8360 but to the target of the pointer. */
8361 type_quals
= TYPE_UNQUALIFIED
;
8363 if (declarator
->kind
== cdk_ptrmem
8364 && (TREE_CODE (type
) == FUNCTION_TYPE
8365 || (memfn_quals
&& TREE_CODE (type
) == METHOD_TYPE
)))
8367 memfn_quals
|= cp_type_quals (type
);
8368 type
= build_memfn_type (type
,
8369 declarator
->u
.pointer
.class_type
,
8371 memfn_quals
= TYPE_UNQUALIFIED
;
8374 if (declarator
->kind
== cdk_reference
)
8376 /* In C++0x, the type we are creating a reference to might be
8377 a typedef which is itself a reference type. In that case,
8378 we follow the reference collapsing rules in
8379 [7.1.3/8 dcl.typedef] to create the final reference type:
8381 "If a typedef TD names a type that is a reference to a type
8382 T, an attempt to create the type 'lvalue reference to cv TD'
8383 creates the type 'lvalue reference to T,' while an attempt
8384 to create the type "rvalue reference to cv TD' creates the
8387 if (!VOID_TYPE_P (type
))
8388 type
= cp_build_reference_type
8389 ((TREE_CODE (type
) == REFERENCE_TYPE
8390 ? TREE_TYPE (type
) : type
),
8391 (declarator
->u
.reference
.rvalue_ref
8392 && (TREE_CODE(type
) != REFERENCE_TYPE
8393 || TYPE_REF_IS_RVALUE (type
))));
8395 /* In C++0x, we need this check for direct reference to
8396 reference declarations, which are forbidden by
8397 [8.3.2/5 dcl.ref]. Reference to reference declarations
8398 are only allowed indirectly through typedefs and template
8399 type arguments. Example:
8401 void foo(int & &); // invalid ref-to-ref decl
8403 typedef int & int_ref;
8404 void foo(int_ref &); // valid ref-to-ref decl
8406 if (inner_declarator
&& inner_declarator
->kind
== cdk_reference
)
8407 error ("cannot declare reference to %q#T, which is not "
8408 "a typedef or a template type argument", type
);
8410 else if (TREE_CODE (type
) == METHOD_TYPE
)
8411 type
= build_ptrmemfunc_type (build_pointer_type (type
));
8412 else if (declarator
->kind
== cdk_ptrmem
)
8414 gcc_assert (TREE_CODE (declarator
->u
.pointer
.class_type
)
8416 if (declarator
->u
.pointer
.class_type
== error_mark_node
)
8417 /* We will already have complained. */
8418 type
= error_mark_node
;
8420 type
= build_ptrmem_type (declarator
->u
.pointer
.class_type
,
8424 type
= build_pointer_type (type
);
8426 /* Process a list of type modifier keywords (such as
8427 const or volatile) that were given inside the `*' or `&'. */
8429 if (declarator
->u
.pointer
.qualifiers
)
8432 = cp_build_qualified_type (type
,
8433 declarator
->u
.pointer
.qualifiers
);
8434 type_quals
= cp_type_quals (type
);
8447 if (unqualified_id
&& TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
8448 && TREE_CODE (type
) != FUNCTION_TYPE
8449 && TREE_CODE (type
) != METHOD_TYPE
)
8451 error ("template-id %qD used as a declarator",
8453 unqualified_id
= dname
;
8456 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
8457 qualified with a class-name, turn it into a METHOD_TYPE, unless
8458 we know that the function is static. We take advantage of this
8459 opportunity to do other processing that pertains to entities
8460 explicitly declared to be class members. Note that if DECLARATOR
8461 is non-NULL, we know it is a cdk_id declarator; otherwise, we
8462 would not have exited the loop above. */
8464 && declarator
->u
.id
.qualifying_scope
8465 && TYPE_P (declarator
->u
.id
.qualifying_scope
))
8469 ctype
= declarator
->u
.id
.qualifying_scope
;
8470 ctype
= TYPE_MAIN_VARIANT (ctype
);
8472 while (t
!= NULL_TREE
&& CLASS_TYPE_P (t
))
8474 /* You're supposed to have one `template <...>' for every
8475 template class, but you don't need one for a full
8476 specialization. For example:
8478 template <class T> struct S{};
8479 template <> struct S<int> { void f(); };
8480 void S<int>::f () {}
8482 is correct; there shouldn't be a `template <>' for the
8483 definition of `S<int>::f'. */
8484 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t
)
8485 && !any_dependent_template_arguments_p (CLASSTYPE_TI_ARGS (t
)))
8486 /* T is an explicit (not partial) specialization. All
8487 containing classes must therefore also be explicitly
8490 if ((CLASSTYPE_USE_TEMPLATE (t
) || CLASSTYPE_IS_TEMPLATE (t
))
8491 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t
)))
8492 template_count
+= 1;
8494 t
= TYPE_MAIN_DECL (t
);
8495 t
= DECL_CONTEXT (t
);
8498 if (ctype
== current_class_type
)
8502 permerror (input_location
, "member functions are implicitly friends of their class");
8506 permerror (declarator
->id_loc
,
8507 "extra qualification %<%T::%> on member %qs",
8510 else if (/* If the qualifying type is already complete, then we
8511 can skip the following checks. */
8512 !COMPLETE_TYPE_P (ctype
)
8513 && (/* If the function is being defined, then
8514 qualifying type must certainly be complete. */
8516 /* A friend declaration of "T::f" is OK, even if
8517 "T" is a template parameter. But, if this
8518 function is not a friend, the qualifying type
8520 || (!friendp
&& !CLASS_TYPE_P (ctype
))
8521 /* For a declaration, the type need not be
8522 complete, if either it is dependent (since there
8523 is no meaningful definition of complete in that
8524 case) or the qualifying class is currently being
8526 || !(dependent_type_p (ctype
)
8527 || currently_open_class (ctype
)))
8528 /* Check that the qualifying type is complete. */
8529 && !complete_type_or_else (ctype
, NULL_TREE
))
8530 return error_mark_node
;
8531 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
8533 tree sname
= declarator
->u
.id
.unqualified_name
;
8535 if (current_class_type
8536 && (!friendp
|| funcdef_flag
))
8539 ? "cannot define member function %<%T::%s%> within %<%T%>"
8540 : "cannot declare member function %<%T::%s%> within %<%T%>",
8541 ctype
, name
, current_class_type
);
8542 return error_mark_node
;
8545 if (TREE_CODE (sname
) == IDENTIFIER_NODE
8546 && NEW_DELETE_OPNAME_P (sname
))
8547 /* Overloaded operator new and operator delete
8548 are always static functions. */
8551 type
= build_memfn_type (type
, ctype
, memfn_quals
);
8553 else if (declspecs
->specs
[(int)ds_typedef
]
8554 && current_class_type
)
8556 error ("cannot declare member %<%T::%s%> within %qT",
8557 ctype
, name
, current_class_type
);
8558 return error_mark_node
;
8562 /* Now TYPE has the actual type. */
8567 *attrlist
= chainon (returned_attrs
, *attrlist
);
8569 attrlist
= &returned_attrs
;
8572 /* Handle parameter packs. */
8573 if (parameter_pack_p
)
8575 if (decl_context
== PARM
)
8576 /* Turn the type into a pack expansion.*/
8577 type
= make_pack_expansion (type
);
8579 error ("non-parameter %qs cannot be a parameter pack", name
);
8582 /* Did array size calculations overflow? */
8584 if (TREE_CODE (type
) == ARRAY_TYPE
8585 && COMPLETE_TYPE_P (type
)
8586 && TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
8587 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type
)))
8589 error ("size of array %qs is too large", name
);
8590 /* If we proceed with the array type as it is, we'll eventually
8591 crash in tree_low_cst(). */
8592 type
= error_mark_node
;
8595 if ((decl_context
== FIELD
|| decl_context
== PARM
)
8596 && !processing_template_decl
8597 && variably_modified_type_p (type
, NULL_TREE
))
8599 if (decl_context
== FIELD
)
8600 error ("data member may not have variably modified type %qT", type
);
8602 error ("parameter may not have variably modified type %qT", type
);
8603 type
= error_mark_node
;
8606 if (explicitp
== 1 || (explicitp
&& friendp
))
8608 /* [dcl.fct.spec] The explicit specifier shall only be used in
8609 declarations of constructors within a class definition. */
8610 error ("only declarations of constructors can be %<explicit%>");
8614 if (storage_class
== sc_mutable
)
8616 if (decl_context
!= FIELD
|| friendp
)
8618 error ("non-member %qs cannot be declared %<mutable%>", name
);
8619 storage_class
= sc_none
;
8621 else if (decl_context
== TYPENAME
|| declspecs
->specs
[(int)ds_typedef
])
8623 error ("non-object member %qs cannot be declared %<mutable%>", name
);
8624 storage_class
= sc_none
;
8626 else if (TREE_CODE (type
) == FUNCTION_TYPE
8627 || TREE_CODE (type
) == METHOD_TYPE
)
8629 error ("function %qs cannot be declared %<mutable%>", name
);
8630 storage_class
= sc_none
;
8634 error ("static %qs cannot be declared %<mutable%>", name
);
8635 storage_class
= sc_none
;
8637 else if (type_quals
& TYPE_QUAL_CONST
)
8639 error ("const %qs cannot be declared %<mutable%>", name
);
8640 storage_class
= sc_none
;
8644 /* If this is declaring a typedef name, return a TYPE_DECL. */
8645 if (declspecs
->specs
[(int)ds_typedef
] && decl_context
!= TYPENAME
)
8649 /* Note that the grammar rejects storage classes
8650 in typenames, fields or parameters. */
8651 if (current_lang_name
== lang_name_java
)
8652 TYPE_FOR_JAVA (type
) = 1;
8654 /* This declaration:
8656 typedef void f(int) const;
8658 declares a function type which is not a member of any
8659 particular class, but which is cv-qualified; for
8660 example "f S::*" declares a pointer to a const-qualified
8661 member function of S. We record the cv-qualification in the
8663 if (memfn_quals
&& TREE_CODE (type
) == FUNCTION_TYPE
)
8665 type
= cp_build_qualified_type (type
, memfn_quals
);
8667 /* We have now dealt with these qualifiers. */
8668 memfn_quals
= TYPE_UNQUALIFIED
;
8671 if (decl_context
== FIELD
)
8672 decl
= build_lang_decl (TYPE_DECL
, unqualified_id
, type
);
8674 decl
= build_decl (TYPE_DECL
, unqualified_id
, type
);
8675 if (id_declarator
&& declarator
->u
.id
.qualifying_scope
)
8676 error ("%Jtypedef name may not be a nested-name-specifier", decl
);
8678 if (decl_context
!= FIELD
)
8680 if (!current_function_decl
)
8681 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_namespace
);
8682 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl
)
8683 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
8684 (current_function_decl
)))
8685 /* The TYPE_DECL is "abstract" because there will be
8686 clones of this constructor/destructor, and there will
8687 be copies of this TYPE_DECL generated in those
8689 DECL_ABSTRACT (decl
) = 1;
8691 else if (constructor_name_p (unqualified_id
, current_class_type
))
8692 permerror (input_location
, "ISO C++ forbids nested type %qD with same name "
8693 "as enclosing class",
8696 /* If the user declares "typedef struct {...} foo" then the
8697 struct will have an anonymous name. Fill that name in now.
8698 Nothing can refer to it, so nothing needs know about the name
8700 if (type
!= error_mark_node
8703 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
8704 && TYPE_ANONYMOUS_P (type
)
8705 && cp_type_quals (type
) == TYPE_UNQUALIFIED
)
8707 tree oldname
= TYPE_NAME (type
);
8710 /* Replace the anonymous name with the real name everywhere. */
8711 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
8712 if (TYPE_NAME (t
) == oldname
)
8713 TYPE_NAME (t
) = decl
;
8715 if (TYPE_LANG_SPECIFIC (type
))
8716 TYPE_WAS_ANONYMOUS (type
) = 1;
8718 /* If this is a typedef within a template class, the nested
8719 type is a (non-primary) template. The name for the
8720 template needs updating as well. */
8721 if (TYPE_LANG_SPECIFIC (type
) && CLASSTYPE_TEMPLATE_INFO (type
))
8722 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
))
8723 = TYPE_IDENTIFIER (type
);
8725 /* FIXME remangle member functions; member functions of a
8726 type with external linkage have external linkage. */
8730 || (typedef_decl
&& C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl
)))
8731 C_TYPEDEF_EXPLICITLY_SIGNED (decl
) = 1;
8733 bad_specifiers (decl
, "type", virtualp
,
8734 memfn_quals
!= TYPE_UNQUALIFIED
,
8735 inlinep
, friendp
, raises
!= NULL_TREE
);
8740 /* Detect the case of an array type of unspecified size
8741 which came, as such, direct from a typedef name.
8742 We must copy the type, so that the array's domain can be
8743 individually set by the object's initializer. */
8745 if (type
&& typedef_type
8746 && TREE_CODE (type
) == ARRAY_TYPE
&& !TYPE_DOMAIN (type
)
8747 && TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (typedef_type
))
8748 type
= build_cplus_array_type (TREE_TYPE (type
), NULL_TREE
);
8750 /* Detect where we're using a typedef of function type to declare a
8751 function. PARMS will not be set, so we must create it now. */
8753 if (type
== typedef_type
&& TREE_CODE (type
) == FUNCTION_TYPE
)
8755 tree decls
= NULL_TREE
;
8758 for (args
= TYPE_ARG_TYPES (type
); args
; args
= TREE_CHAIN (args
))
8760 tree decl
= cp_build_parm_decl (NULL_TREE
, TREE_VALUE (args
));
8762 TREE_CHAIN (decl
) = decls
;
8766 parms
= nreverse (decls
);
8768 if (decl_context
!= TYPENAME
)
8770 /* A cv-qualifier-seq shall only be part of the function type
8771 for a non-static member function. [8.3.5/4 dcl.fct] */
8772 if (cp_type_quals (type
) != TYPE_UNQUALIFIED
8773 && (current_class_type
== NULL_TREE
|| staticp
) )
8776 ? G_("qualified function types cannot be used to "
8777 "declare static member functions")
8778 : G_("qualified function types cannot be used to "
8779 "declare free functions"));
8780 type
= TYPE_MAIN_VARIANT (type
);
8783 /* The qualifiers on the function type become the qualifiers on
8784 the non-static member function. */
8785 memfn_quals
|= cp_type_quals (type
);
8789 /* If this is a type name (such as, in a cast or sizeof),
8790 compute the type and return it now. */
8792 if (decl_context
== TYPENAME
)
8794 /* Note that the grammar rejects storage classes
8795 in typenames, fields or parameters. */
8796 if (type_quals
!= TYPE_UNQUALIFIED
)
8797 type_quals
= TYPE_UNQUALIFIED
;
8799 /* Special case: "friend class foo" looks like a TYPENAME context. */
8802 if (type_quals
!= TYPE_UNQUALIFIED
)
8804 error ("type qualifiers specified for friend class declaration");
8805 type_quals
= TYPE_UNQUALIFIED
;
8809 error ("%<inline%> specified for friend class declaration");
8815 /* Don't allow friend declaration without a class-key. */
8816 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
8817 permerror (input_location
, "template parameters cannot be friends");
8818 else if (TREE_CODE (type
) == TYPENAME_TYPE
)
8819 permerror (input_location
, "friend declaration requires class-key, "
8820 "i.e. %<friend class %T::%D%>",
8821 TYPE_CONTEXT (type
), TYPENAME_TYPE_FULLNAME (type
));
8823 permerror (input_location
, "friend declaration requires class-key, "
8824 "i.e. %<friend %#T%>",
8828 /* Only try to do this stuff if we didn't already give up. */
8829 if (type
!= integer_type_node
)
8831 /* A friendly class? */
8832 if (current_class_type
)
8833 make_friend_class (current_class_type
, TYPE_MAIN_VARIANT (type
),
8836 error ("trying to make class %qT a friend of global scope",
8839 type
= void_type_node
;
8842 else if (memfn_quals
)
8844 if (ctype
== NULL_TREE
)
8846 if (TREE_CODE (type
) != METHOD_TYPE
)
8847 error ("invalid qualifiers on non-member function type");
8849 ctype
= TYPE_METHOD_BASETYPE (type
);
8852 type
= build_memfn_type (type
, ctype
, memfn_quals
);
8857 else if (unqualified_id
== NULL_TREE
&& decl_context
!= PARM
8858 && decl_context
!= CATCHPARM
8859 && TREE_CODE (type
) != UNION_TYPE
8862 error ("abstract declarator %qT used as declaration", type
);
8863 return error_mark_node
;
8866 /* Only functions may be declared using an operator-function-id. */
8868 && IDENTIFIER_OPNAME_P (unqualified_id
)
8869 && TREE_CODE (type
) != FUNCTION_TYPE
8870 && TREE_CODE (type
) != METHOD_TYPE
)
8872 error ("declaration of %qD as non-function", unqualified_id
);
8873 return error_mark_node
;
8876 /* We don't check parameter types here because we can emit a better
8877 error message later. */
8878 if (decl_context
!= PARM
)
8880 type
= check_var_type (unqualified_id
, type
);
8881 if (type
== error_mark_node
)
8882 return error_mark_node
;
8885 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
8886 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
8888 if (decl_context
== PARM
|| decl_context
== CATCHPARM
)
8890 if (ctype
|| in_namespace
)
8891 error ("cannot use %<::%> in parameter declaration");
8893 /* A parameter declared as an array of T is really a pointer to T.
8894 One declared as a function is really a pointer to a function.
8895 One declared as a member is really a pointer to member. */
8897 if (TREE_CODE (type
) == ARRAY_TYPE
)
8899 /* Transfer const-ness of array into that of type pointed to. */
8900 type
= build_pointer_type (TREE_TYPE (type
));
8901 type_quals
= TYPE_UNQUALIFIED
;
8903 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
8904 type
= build_pointer_type (type
);
8910 if (decl_context
== PARM
)
8912 decl
= cp_build_parm_decl (unqualified_id
, type
);
8914 bad_specifiers (decl
, "parameter", virtualp
,
8915 memfn_quals
!= TYPE_UNQUALIFIED
,
8916 inlinep
, friendp
, raises
!= NULL_TREE
);
8918 else if (decl_context
== FIELD
)
8920 /* The C99 flexible array extension. */
8921 if (!staticp
&& TREE_CODE (type
) == ARRAY_TYPE
8922 && TYPE_DOMAIN (type
) == NULL_TREE
)
8924 tree itype
= compute_array_index_type (dname
, integer_zero_node
);
8925 type
= build_cplus_array_type (TREE_TYPE (type
), itype
);
8928 if (type
== error_mark_node
)
8930 /* Happens when declaring arrays of sizes which
8931 are error_mark_node, for example. */
8934 else if (in_namespace
&& !friendp
)
8936 /* Something like struct S { int N::j; }; */
8937 error ("invalid use of %<::%>");
8938 return error_mark_node
;
8940 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
8943 tree function_context
;
8947 if (ctype
== NULL_TREE
)
8948 ctype
= current_class_type
;
8950 if (ctype
== NULL_TREE
)
8952 error ("can't make %qD into a method -- not in a class",
8954 return error_mark_node
;
8957 /* ``A union may [ ... ] not [ have ] virtual functions.''
8959 if (virtualp
&& TREE_CODE (ctype
) == UNION_TYPE
)
8961 error ("function %qD declared virtual inside a union",
8963 return error_mark_node
;
8966 if (NEW_DELETE_OPNAME_P (unqualified_id
))
8970 error ("%qD cannot be declared virtual, since it "
8976 else if (staticp
< 2)
8977 type
= build_memfn_type (type
, ctype
, memfn_quals
);
8980 /* Check that the name used for a destructor makes sense. */
8981 if (sfk
== sfk_destructor
)
8985 gcc_assert (friendp
);
8986 error ("expected qualified name in friend declaration "
8987 "for destructor %qD",
8988 id_declarator
->u
.id
.unqualified_name
);
8989 return error_mark_node
;
8992 if (!same_type_p (TREE_OPERAND
8993 (id_declarator
->u
.id
.unqualified_name
, 0),
8996 error ("declaration of %qD as member of %qT",
8997 id_declarator
->u
.id
.unqualified_name
, ctype
);
8998 return error_mark_node
;
9001 else if (sfk
== sfk_constructor
&& friendp
)
9003 error ("expected qualified name in friend declaration "
9004 "for constructor %qD",
9005 id_declarator
->u
.id
.unqualified_name
);
9006 return error_mark_node
;
9009 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
9010 function_context
= (ctype
!= NULL_TREE
) ?
9011 decl_function_context (TYPE_MAIN_DECL (ctype
)) : NULL_TREE
;
9012 publicp
= (! friendp
|| ! staticp
)
9013 && function_context
== NULL_TREE
;
9014 decl
= grokfndecl (ctype
, type
,
9015 TREE_CODE (unqualified_id
) != TEMPLATE_ID_EXPR
9016 ? unqualified_id
: dname
,
9019 virtualp
, flags
, memfn_quals
, raises
,
9020 friendp
? -1 : 0, friendp
, publicp
, inlinep
,
9022 funcdef_flag
, template_count
, in_namespace
, attrlist
);
9023 if (decl
== NULL_TREE
)
9024 return error_mark_node
;
9026 /* This clobbers the attrs stored in `decl' from `attrlist'. */
9027 /* The decl and setting of decl_attr is also turned off. */
9028 decl
= build_decl_attribute_variant (decl
, decl_attr
);
9031 /* [class.conv.ctor]
9033 A constructor declared without the function-specifier
9034 explicit that can be called with a single parameter
9035 specifies a conversion from the type of its first
9036 parameter to the type of its class. Such a constructor
9037 is called a converting constructor. */
9039 DECL_NONCONVERTING_P (decl
) = 1;
9040 else if (DECL_CONSTRUCTOR_P (decl
))
9042 /* A constructor with no parms is not a conversion.
9043 Ignore any compiler-added parms. */
9044 tree arg_types
= FUNCTION_FIRST_USER_PARMTYPE (decl
);
9046 if (arg_types
== void_list_node
)
9047 DECL_NONCONVERTING_P (decl
) = 1;
9050 else if (TREE_CODE (type
) == METHOD_TYPE
)
9052 /* We only get here for friend declarations of
9053 members of other classes. */
9054 /* All method decls are public, so tell grokfndecl to set
9055 TREE_PUBLIC, also. */
9056 decl
= grokfndecl (ctype
, type
,
9057 TREE_CODE (unqualified_id
) != TEMPLATE_ID_EXPR
9058 ? unqualified_id
: dname
,
9061 virtualp
, flags
, memfn_quals
, raises
,
9062 friendp
? -1 : 0, friendp
, 1, 0, sfk
,
9063 funcdef_flag
, template_count
, in_namespace
,
9065 if (decl
== NULL_TREE
)
9066 return error_mark_node
;
9068 else if (!staticp
&& !dependent_type_p (type
)
9069 && !COMPLETE_TYPE_P (complete_type (type
))
9070 && (TREE_CODE (type
) != ARRAY_TYPE
|| initialized
== 0))
9073 error ("field %qD has incomplete type", unqualified_id
);
9075 error ("name %qT has incomplete type", type
);
9077 /* If we're instantiating a template, tell them which
9078 instantiation made the field's type be incomplete. */
9079 if (current_class_type
9080 && TYPE_NAME (current_class_type
)
9081 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type
))
9083 && declspecs
->type
== type
)
9084 error (" in instantiation of template %qT",
9085 current_class_type
);
9087 return error_mark_node
;
9093 error ("%qE is neither function nor member function; "
9094 "cannot be declared friend", unqualified_id
);
9102 /* Friends are treated specially. */
9103 if (ctype
== current_class_type
)
9104 ; /* We already issued a permerror. */
9105 else if (decl
&& DECL_NAME (decl
))
9107 if (template_class_depth (current_class_type
) == 0)
9109 decl
= check_explicit_specialization
9110 (unqualified_id
, decl
, template_count
,
9111 2 * funcdef_flag
+ 4);
9112 if (decl
== error_mark_node
)
9113 return error_mark_node
;
9116 decl
= do_friend (ctype
, unqualified_id
, decl
,
9122 return error_mark_node
;
9125 /* Structure field. It may not be a function, except for C++. */
9127 if (decl
== NULL_TREE
)
9133 /* An attempt is being made to initialize a non-static
9134 member. But, from [class.mem]:
9136 4 A member-declarator can contain a
9137 constant-initializer only if it declares a static
9138 member (_class.static_) of integral or enumeration
9139 type, see _class.static.data_.
9141 This used to be relatively common practice, but
9142 the rest of the compiler does not correctly
9143 handle the initialization unless the member is
9144 static so we make it static below. */
9145 permerror (input_location
, "ISO C++ forbids initialization of member %qD",
9147 permerror (input_location
, "making %qD static", unqualified_id
);
9151 if (uses_template_parms (type
))
9152 /* We'll check at instantiation time. */
9154 else if (check_static_variable_definition (unqualified_id
,
9156 /* If we just return the declaration, crashes
9157 will sometimes occur. We therefore return
9158 void_type_node, as if this was a friend
9159 declaration, to cause callers to completely
9160 ignore this declaration. */
9161 return error_mark_node
;
9166 /* C++ allows static class members. All other work
9167 for this is done by grokfield. */
9168 decl
= build_lang_decl (VAR_DECL
, unqualified_id
, type
);
9169 set_linkage_for_static_data_member (decl
);
9170 /* Even if there is an in-class initialization, DECL
9171 is considered undefined until an out-of-class
9172 definition is provided. */
9173 DECL_EXTERNAL (decl
) = 1;
9176 DECL_TLS_MODEL (decl
) = decl_default_tls_model (decl
);
9180 decl
= build_decl (FIELD_DECL
, unqualified_id
, type
);
9181 DECL_NONADDRESSABLE_P (decl
) = bitfield
;
9182 if (bitfield
&& !unqualified_id
)
9183 TREE_NO_WARNING (decl
) = 1;
9185 if (storage_class
== sc_mutable
)
9187 DECL_MUTABLE_P (decl
) = 1;
9188 storage_class
= sc_none
;
9192 bad_specifiers (decl
, "field", virtualp
,
9193 memfn_quals
!= TYPE_UNQUALIFIED
,
9194 inlinep
, friendp
, raises
!= NULL_TREE
);
9197 else if (TREE_CODE (type
) == FUNCTION_TYPE
9198 || TREE_CODE (type
) == METHOD_TYPE
)
9203 if (!unqualified_id
)
9204 return error_mark_node
;
9206 if (TREE_CODE (unqualified_id
) == TEMPLATE_ID_EXPR
)
9207 original_name
= dname
;
9209 original_name
= unqualified_id
;
9211 if (storage_class
== sc_auto
)
9212 error ("storage class %<auto%> invalid for function %qs", name
);
9213 else if (storage_class
== sc_register
)
9214 error ("storage class %<register%> invalid for function %qs", name
);
9216 error ("storage class %<__thread%> invalid for function %qs", name
);
9218 /* Function declaration not at top level.
9219 Storage classes other than `extern' are not allowed
9220 and `extern' makes no difference. */
9221 if (! toplevel_bindings_p ()
9222 && (storage_class
== sc_static
9223 || declspecs
->specs
[(int)ds_inline
])
9226 if (storage_class
== sc_static
)
9227 pedwarn (input_location
, OPT_pedantic
,
9228 "%<static%> specified invalid for function %qs "
9229 "declared out of global scope", name
);
9231 pedwarn (input_location
, OPT_pedantic
,
9232 "%<inline%> specifier invalid for function %qs "
9233 "declared out of global scope", name
);
9236 if (ctype
== NULL_TREE
)
9240 error ("virtual non-class function %qs", name
);
9244 else if (TREE_CODE (type
) == FUNCTION_TYPE
&& staticp
< 2
9245 && !NEW_DELETE_OPNAME_P (original_name
))
9246 type
= build_method_type_directly (ctype
,
9248 TYPE_ARG_TYPES (type
));
9250 /* Record presence of `static'. */
9251 publicp
= (ctype
!= NULL_TREE
9252 || storage_class
== sc_extern
9253 || storage_class
!= sc_static
);
9255 decl
= grokfndecl (ctype
, type
, original_name
, parms
, unqualified_id
,
9256 virtualp
, flags
, memfn_quals
, raises
,
9258 publicp
, inlinep
, sfk
, funcdef_flag
,
9259 template_count
, in_namespace
, attrlist
);
9260 if (decl
== NULL_TREE
)
9261 return error_mark_node
;
9265 int invalid_static
= 0;
9267 /* Don't allow a static member function in a class, and forbid
9268 declaring main to be static. */
9269 if (TREE_CODE (type
) == METHOD_TYPE
)
9271 permerror (input_location
, "cannot declare member function %qD to have "
9272 "static linkage", decl
);
9275 else if (current_function_decl
)
9277 /* FIXME need arm citation */
9278 error ("cannot declare static function inside another function");
9285 storage_class
= sc_none
;
9291 /* It's a variable. */
9293 /* An uninitialized decl with `extern' is a reference. */
9294 decl
= grokvardecl (type
, unqualified_id
,
9297 (type_quals
& TYPE_QUAL_CONST
) != 0,
9298 ctype
? ctype
: in_namespace
);
9299 bad_specifiers (decl
, "variable", virtualp
,
9300 memfn_quals
!= TYPE_UNQUALIFIED
,
9301 inlinep
, friendp
, raises
!= NULL_TREE
);
9305 DECL_CONTEXT (decl
) = ctype
;
9308 permerror (input_location
, "%<static%> may not be used when defining "
9309 "(as opposed to declaring) a static data member");
9311 storage_class
= sc_none
;
9313 if (storage_class
== sc_register
&& TREE_STATIC (decl
))
9315 error ("static member %qD declared %<register%>", decl
);
9316 storage_class
= sc_none
;
9318 if (storage_class
== sc_extern
&& pedantic
)
9320 pedwarn (input_location
, OPT_pedantic
,
9321 "cannot explicitly declare member %q#D to have "
9322 "extern linkage", decl
);
9323 storage_class
= sc_none
;
9328 if (storage_class
== sc_extern
&& initialized
&& !funcdef_flag
)
9330 if (toplevel_bindings_p ())
9332 /* It's common practice (and completely valid) to have a const
9333 be initialized and declared extern. */
9334 if (!(type_quals
& TYPE_QUAL_CONST
))
9335 warning (0, "%qs initialized and declared %<extern%>", name
);
9339 error ("%qs has both %<extern%> and initializer", name
);
9340 return error_mark_node
;
9344 /* Record `register' declaration for warnings on &
9345 and in case doing stupid register allocation. */
9347 if (storage_class
== sc_register
)
9348 DECL_REGISTER (decl
) = 1;
9349 else if (storage_class
== sc_extern
)
9350 DECL_THIS_EXTERN (decl
) = 1;
9351 else if (storage_class
== sc_static
)
9352 DECL_THIS_STATIC (decl
) = 1;
9354 /* Record constancy and volatility on the DECL itself . There's
9355 no need to do this when processing a template; we'll do this
9356 for the instantiated declaration based on the type of DECL. */
9357 if (!processing_template_decl
)
9358 cp_apply_type_quals_to_decl (type_quals
, decl
);
9361 TREE_NO_WARNING (decl
) = 1;
9367 /* Subroutine of start_function. Ensure that each of the parameter
9368 types (as listed in PARMS) is complete, as is required for a
9369 function definition. */
9372 require_complete_types_for_parms (tree parms
)
9374 for (; parms
; parms
= TREE_CHAIN (parms
))
9376 if (dependent_type_p (TREE_TYPE (parms
)))
9378 if (!VOID_TYPE_P (TREE_TYPE (parms
))
9379 && complete_type_or_else (TREE_TYPE (parms
), parms
))
9381 relayout_decl (parms
);
9382 DECL_ARG_TYPE (parms
) = type_passed_as (TREE_TYPE (parms
));
9385 /* grokparms or complete_type_or_else will have already issued
9387 TREE_TYPE (parms
) = error_mark_node
;
9391 /* Returns nonzero if T is a local variable. */
9394 local_variable_p (const_tree t
)
9396 if ((TREE_CODE (t
) == VAR_DECL
9397 /* A VAR_DECL with a context that is a _TYPE is a static data
9399 && !TYPE_P (CP_DECL_CONTEXT (t
))
9400 /* Any other non-local variable must be at namespace scope. */
9401 && !DECL_NAMESPACE_SCOPE_P (t
))
9402 || (TREE_CODE (t
) == PARM_DECL
))
9408 /* Like local_variable_p, but suitable for use as a tree-walking
9412 local_variable_p_walkfn (tree
*tp
, int *walk_subtrees
,
9413 void *data ATTRIBUTE_UNUSED
)
9415 if (local_variable_p (*tp
) && !DECL_ARTIFICIAL (*tp
))
9417 else if (TYPE_P (*tp
))
9424 /* Check that ARG, which is a default-argument expression for a
9425 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
9426 something goes wrong. DECL may also be a _TYPE node, rather than a
9427 DECL, if there is no DECL available. */
9430 check_default_argument (tree decl
, tree arg
)
9435 if (TREE_CODE (arg
) == DEFAULT_ARG
)
9436 /* We get a DEFAULT_ARG when looking at an in-class declaration
9437 with a default argument. Ignore the argument for now; we'll
9438 deal with it after the class is complete. */
9447 decl_type
= TREE_TYPE (decl
);
9449 if (arg
== error_mark_node
9450 || decl
== error_mark_node
9451 || TREE_TYPE (arg
) == error_mark_node
9452 || decl_type
== error_mark_node
)
9453 /* Something already went wrong. There's no need to check
9455 return error_mark_node
;
9457 /* [dcl.fct.default]
9459 A default argument expression is implicitly converted to the
9461 if (!TREE_TYPE (arg
)
9462 || !can_convert_arg (decl_type
, TREE_TYPE (arg
), arg
, LOOKUP_NORMAL
))
9465 error ("default argument for %q#D has type %qT",
9466 decl
, TREE_TYPE (arg
));
9468 error ("default argument for parameter of type %qT has type %qT",
9469 decl_type
, TREE_TYPE (arg
));
9471 return error_mark_node
;
9474 /* [dcl.fct.default]
9476 Local variables shall not be used in default argument
9479 The keyword `this' shall not be used in a default argument of a
9481 var
= cp_walk_tree_without_duplicates (&arg
, local_variable_p_walkfn
, NULL
);
9484 error ("default argument %qE uses local variable %qD", arg
, var
);
9485 return error_mark_node
;
9492 /* Decode the list of parameter types for a function type.
9493 Given the list of things declared inside the parens,
9494 return a list of types.
9496 If this parameter does not end with an ellipsis, we append
9499 *PARMS is set to the chain of PARM_DECLs created. */
9502 grokparms (cp_parameter_declarator
*first_parm
, tree
*parms
)
9504 tree result
= NULL_TREE
;
9505 tree decls
= NULL_TREE
;
9506 int ellipsis
= !first_parm
|| first_parm
->ellipsis_p
;
9507 cp_parameter_declarator
*parm
;
9509 struct pointer_set_t
*unique_decls
= pointer_set_create ();
9511 for (parm
= first_parm
; parm
!= NULL
; parm
= parm
->next
)
9513 tree type
= NULL_TREE
;
9514 tree init
= parm
->default_argument
;
9518 if (parm
== no_parameters
)
9521 attrs
= parm
->decl_specifiers
.attributes
;
9522 parm
->decl_specifiers
.attributes
= NULL_TREE
;
9523 decl
= grokdeclarator (parm
->declarator
, &parm
->decl_specifiers
,
9524 PARM
, init
!= NULL_TREE
, &attrs
);
9525 if (! decl
|| TREE_TYPE (decl
) == error_mark_node
)
9529 cplus_decl_attributes (&decl
, attrs
, 0);
9531 type
= TREE_TYPE (decl
);
9532 if (VOID_TYPE_P (type
))
9534 if (same_type_p (type
, void_type_node
)
9535 && DECL_SELF_REFERENCE_P (type
)
9536 && !DECL_NAME (decl
) && !result
&& !parm
->next
&& !ellipsis
)
9537 /* this is a parmlist of `(void)', which is ok. */
9539 cxx_incomplete_type_error (decl
, type
);
9540 /* It's not a good idea to actually create parameters of
9541 type `void'; other parts of the compiler assume that a
9542 void type terminates the parameter list. */
9543 type
= error_mark_node
;
9544 TREE_TYPE (decl
) = error_mark_node
;
9547 if (type
!= error_mark_node
9548 && TYPE_FOR_JAVA (type
)
9549 && MAYBE_CLASS_TYPE_P (type
))
9551 error ("parameter %qD has Java class type", decl
);
9552 type
= error_mark_node
;
9553 TREE_TYPE (decl
) = error_mark_node
;
9557 if (type
!= error_mark_node
)
9559 /* Top-level qualifiers on the parameters are
9560 ignored for function types. */
9561 type
= cp_build_qualified_type (type
, 0);
9562 if (TREE_CODE (type
) == METHOD_TYPE
)
9564 error ("parameter %qD invalidly declared method type", decl
);
9565 type
= build_pointer_type (type
);
9566 TREE_TYPE (decl
) = type
;
9568 else if (abstract_virtuals_error (decl
, type
))
9569 any_error
= 1; /* Seems like a good idea. */
9570 else if (POINTER_TYPE_P (type
))
9572 /* [dcl.fct]/6, parameter types cannot contain pointers
9573 (references) to arrays of unknown bound. */
9574 tree t
= TREE_TYPE (type
);
9575 int ptr
= TYPE_PTR_P (type
);
9581 else if (TREE_CODE (t
) != ARRAY_TYPE
)
9583 else if (!TYPE_DOMAIN (t
))
9587 if (TREE_CODE (t
) == ARRAY_TYPE
)
9588 error ("parameter %qD includes %s to array of unknown "
9590 decl
, ptr
? "pointer" : "reference", t
);
9595 else if (init
&& !processing_template_decl
)
9596 init
= check_default_argument (decl
, init
);
9599 if (TREE_CODE (decl
) == PARM_DECL
9600 && FUNCTION_PARAMETER_PACK_P (decl
)
9602 error ("parameter packs must be at the end of the parameter list");
9604 if (DECL_NAME (decl
))
9606 if (pointer_set_contains (unique_decls
, DECL_NAME (decl
)))
9607 error ("multiple parameters named %qE", DECL_NAME (decl
));
9609 pointer_set_insert (unique_decls
, DECL_NAME (decl
));
9612 TREE_CHAIN (decl
) = decls
;
9614 result
= tree_cons (init
, type
, result
);
9616 decls
= nreverse (decls
);
9617 result
= nreverse (result
);
9619 result
= chainon (result
, void_list_node
);
9622 pointer_set_destroy (unique_decls
);
9627 /* D is a constructor or overloaded `operator='.
9629 Let T be the class in which D is declared. Then, this function
9632 -1 if D's is an ill-formed constructor or copy assignment operator
9633 whose first parameter is of type `T'.
9634 0 if D is not a copy constructor or copy assignment
9636 1 if D is a copy constructor or copy assignment operator whose
9637 first parameter is a reference to const qualified T.
9638 2 if D is a copy constructor or copy assignment operator whose
9639 first parameter is a reference to non-const qualified T.
9641 This function can be used as a predicate. Positive values indicate
9642 a copy constructor and nonzero values indicate a copy assignment
9646 copy_fn_p (const_tree d
)
9652 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
9654 if (TREE_CODE (d
) == TEMPLATE_DECL
9655 || (DECL_TEMPLATE_INFO (d
)
9656 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
9657 /* Instantiations of template member functions are never copy
9658 functions. Note that member functions of templated classes are
9659 represented as template functions internally, and we must
9660 accept those as copy functions. */
9663 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
9667 arg_type
= TREE_VALUE (args
);
9668 if (arg_type
== error_mark_node
)
9671 if (TYPE_MAIN_VARIANT (arg_type
) == DECL_CONTEXT (d
))
9673 /* Pass by value copy assignment operator. */
9676 else if (TREE_CODE (arg_type
) == REFERENCE_TYPE
9677 && !TYPE_REF_IS_RVALUE (arg_type
)
9678 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)) == DECL_CONTEXT (d
))
9680 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type
)))
9686 args
= TREE_CHAIN (args
);
9688 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
9689 /* There are more non-optional args. */
9695 /* D is a constructor or overloaded `operator='.
9697 Let T be the class in which D is declared. Then, this function
9698 returns true when D is a move constructor or move assignment
9699 operator, false otherwise. */
9702 move_fn_p (const_tree d
)
9706 bool result
= false;
9708 gcc_assert (DECL_FUNCTION_MEMBER_P (d
));
9710 if (cxx_dialect
== cxx98
)
9711 /* There are no move constructors if we are in C++98 mode. */
9714 if (TREE_CODE (d
) == TEMPLATE_DECL
9715 || (DECL_TEMPLATE_INFO (d
)
9716 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d
))))
9717 /* Instantiations of template member functions are never copy
9718 functions. Note that member functions of templated classes are
9719 represented as template functions internally, and we must
9720 accept those as copy functions. */
9723 args
= FUNCTION_FIRST_USER_PARMTYPE (d
);
9727 arg_type
= TREE_VALUE (args
);
9728 if (arg_type
== error_mark_node
)
9731 if (TREE_CODE (arg_type
) == REFERENCE_TYPE
9732 && TYPE_REF_IS_RVALUE (arg_type
)
9733 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type
)),
9737 args
= TREE_CHAIN (args
);
9739 if (args
&& args
!= void_list_node
&& !TREE_PURPOSE (args
))
9740 /* There are more non-optional args. */
9746 /* Remember any special properties of member function DECL. */
9749 grok_special_member_properties (tree decl
)
9753 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl
))
9756 class_type
= DECL_CONTEXT (decl
);
9757 if (DECL_CONSTRUCTOR_P (decl
))
9759 int ctor
= copy_fn_p (decl
);
9761 if (!DECL_ARTIFICIAL (decl
))
9762 TYPE_HAS_USER_CONSTRUCTOR (class_type
) = 1;
9768 A non-template constructor for class X is a copy
9769 constructor if its first parameter is of type X&, const
9770 X&, volatile X& or const volatile X&, and either there
9771 are no other parameters or else all other parameters have
9772 default arguments. */
9773 TYPE_HAS_INIT_REF (class_type
) = 1;
9774 if (!DECL_DEFAULTED_FN (decl
))
9775 TYPE_HAS_COMPLEX_INIT_REF (class_type
) = 1;
9777 TYPE_HAS_CONST_INIT_REF (class_type
) = 1;
9779 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl
)))
9780 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type
) = 1;
9781 else if (is_list_ctor (decl
))
9782 TYPE_HAS_LIST_CTOR (class_type
) = 1;
9784 else if (DECL_OVERLOADED_OPERATOR_P (decl
) == NOP_EXPR
)
9788 A non-template assignment operator for class X is a copy
9789 assignment operator if its parameter is of type X, X&, const
9790 X&, volatile X& or const volatile X&. */
9792 int assop
= copy_fn_p (decl
);
9796 TYPE_HAS_ASSIGN_REF (class_type
) = 1;
9797 if (!DECL_DEFAULTED_FN (decl
))
9798 TYPE_HAS_COMPLEX_ASSIGN_REF (class_type
) = 1;
9800 TYPE_HAS_CONST_ASSIGN_REF (class_type
) = 1;
9805 /* Check a constructor DECL has the correct form. Complains
9806 if the class has a constructor of the form X(X). */
9809 grok_ctor_properties (const_tree ctype
, const_tree decl
)
9811 int ctor_parm
= copy_fn_p (decl
);
9817 A declaration of a constructor for a class X is ill-formed if
9818 its first parameter is of type (optionally cv-qualified) X
9819 and either there are no other parameters or else all other
9820 parameters have default arguments.
9822 We *don't* complain about member template instantiations that
9823 have this form, though; they can occur as we try to decide
9824 what constructor to use during overload resolution. Since
9825 overload resolution will never prefer such a constructor to
9826 the non-template copy constructor (which is either explicitly
9827 or implicitly defined), there's no need to worry about their
9828 existence. Theoretically, they should never even be
9829 instantiated, but that's hard to forestall. */
9830 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
9838 /* An operator with this code is unary, but can also be binary. */
9841 ambi_op_p (enum tree_code code
)
9843 return (code
== INDIRECT_REF
9844 || code
== ADDR_EXPR
9845 || code
== UNARY_PLUS_EXPR
9846 || code
== NEGATE_EXPR
9847 || code
== PREINCREMENT_EXPR
9848 || code
== PREDECREMENT_EXPR
);
9851 /* An operator with this name can only be unary. */
9854 unary_op_p (enum tree_code code
)
9856 return (code
== TRUTH_NOT_EXPR
9857 || code
== BIT_NOT_EXPR
9858 || code
== COMPONENT_REF
9859 || code
== TYPE_EXPR
);
9862 /* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
9863 errors are issued for invalid declarations. */
9866 grok_op_properties (tree decl
, bool complain
)
9868 tree argtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
9870 int methodp
= (TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
9871 tree name
= DECL_NAME (decl
);
9872 enum tree_code operator_code
;
9877 /* Count the number of arguments and check for ellipsis. */
9878 for (argtype
= argtypes
, arity
= 0;
9879 argtype
&& argtype
!= void_list_node
;
9880 argtype
= TREE_CHAIN (argtype
))
9882 ellipsis_p
= !argtype
;
9884 class_type
= DECL_CONTEXT (decl
);
9885 if (class_type
&& !CLASS_TYPE_P (class_type
))
9886 class_type
= NULL_TREE
;
9888 if (DECL_CONV_FN_P (decl
))
9889 operator_code
= TYPE_EXPR
;
9893 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
9894 if (ansi_opname (CODE) == name) \
9896 operator_code = (CODE); \
9899 else if (ansi_assopname (CODE) == name) \
9901 operator_code = (CODE); \
9902 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
9906 #include "operators.def"
9912 gcc_assert (operator_code
!= MAX_TREE_CODES
);
9913 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
9916 switch (operator_code
)
9919 TYPE_HAS_NEW_OPERATOR (class_type
) = 1;
9923 TYPE_GETS_DELETE (class_type
) |= 1;
9927 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type
) = 1;
9930 case VEC_DELETE_EXPR
:
9931 TYPE_GETS_DELETE (class_type
) |= 2;
9938 /* [basic.std.dynamic.allocation]/1:
9940 A program is ill-formed if an allocation function is declared
9941 in a namespace scope other than global scope or declared static
9944 The same also holds true for deallocation functions. */
9945 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
9946 || operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
9948 if (DECL_NAMESPACE_SCOPE_P (decl
))
9950 if (CP_DECL_CONTEXT (decl
) != global_namespace
)
9952 error ("%qD may not be declared within a namespace", decl
);
9955 else if (!TREE_PUBLIC (decl
))
9957 error ("%qD may not be declared as static", decl
);
9963 if (operator_code
== NEW_EXPR
|| operator_code
== VEC_NEW_EXPR
)
9965 TREE_TYPE (decl
) = coerce_new_type (TREE_TYPE (decl
));
9966 DECL_IS_OPERATOR_NEW (decl
) = 1;
9968 else if (operator_code
== DELETE_EXPR
|| operator_code
== VEC_DELETE_EXPR
)
9969 TREE_TYPE (decl
) = coerce_delete_type (TREE_TYPE (decl
));
9972 /* An operator function must either be a non-static member function
9973 or have at least one parameter of a class, a reference to a class,
9974 an enumeration, or a reference to an enumeration. 13.4.0.6 */
9975 if (! methodp
|| DECL_STATIC_FUNCTION_P (decl
))
9977 if (operator_code
== TYPE_EXPR
9978 || operator_code
== CALL_EXPR
9979 || operator_code
== COMPONENT_REF
9980 || operator_code
== ARRAY_REF
9981 || operator_code
== NOP_EXPR
)
9983 error ("%qD must be a nonstatic member function", decl
);
9990 if (DECL_STATIC_FUNCTION_P (decl
))
9992 error ("%qD must be either a non-static member "
9993 "function or a non-member function", decl
);
9997 for (p
= argtypes
; p
&& p
!= void_list_node
; p
= TREE_CHAIN (p
))
9999 tree arg
= non_reference (TREE_VALUE (p
));
10000 if (arg
== error_mark_node
)
10003 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
10004 because these checks are performed even on
10005 template functions. */
10006 if (MAYBE_CLASS_TYPE_P (arg
)
10007 || TREE_CODE (arg
) == ENUMERAL_TYPE
)
10011 if (!p
|| p
== void_list_node
)
10014 error ("%qD must have an argument of class or "
10015 "enumerated type", decl
);
10021 /* There are no restrictions on the arguments to an overloaded
10023 if (operator_code
== CALL_EXPR
)
10026 /* Warn about conversion operators that will never be used. */
10027 if (IDENTIFIER_TYPENAME_P (name
)
10028 && ! DECL_TEMPLATE_INFO (decl
)
10030 /* Warn only declaring the function; there is no need to
10031 warn again about out-of-class definitions. */
10032 && class_type
== current_class_type
)
10034 tree t
= TREE_TYPE (name
);
10035 int ref
= (TREE_CODE (t
) == REFERENCE_TYPE
);
10036 const char *what
= 0;
10039 t
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
10041 if (TREE_CODE (t
) == VOID_TYPE
)
10043 else if (class_type
)
10045 if (t
== class_type
)
10046 what
= "the same type";
10047 /* Don't force t to be complete here. */
10048 else if (MAYBE_CLASS_TYPE_P (t
)
10049 && COMPLETE_TYPE_P (t
)
10050 && DERIVED_FROM_P (t
, class_type
))
10051 what
= "a base class";
10055 warning (OPT_Wconversion
, "conversion to %s%s will never use a type "
10056 "conversion operator",
10057 ref
? "a reference to " : "", what
);
10060 if (operator_code
== COND_EXPR
)
10063 error ("ISO C++ prohibits overloading operator ?:");
10066 else if (ellipsis_p
)
10068 error ("%qD must not have variable number of arguments", decl
);
10071 else if (ambi_op_p (operator_code
))
10074 /* We pick the one-argument operator codes by default, so
10075 we don't have to change anything. */
10077 else if (arity
== 2)
10079 /* If we thought this was a unary operator, we now know
10080 it to be a binary operator. */
10081 switch (operator_code
)
10084 operator_code
= MULT_EXPR
;
10088 operator_code
= BIT_AND_EXPR
;
10091 case UNARY_PLUS_EXPR
:
10092 operator_code
= PLUS_EXPR
;
10096 operator_code
= MINUS_EXPR
;
10099 case PREINCREMENT_EXPR
:
10100 operator_code
= POSTINCREMENT_EXPR
;
10103 case PREDECREMENT_EXPR
:
10104 operator_code
= POSTDECREMENT_EXPR
;
10108 gcc_unreachable ();
10111 SET_OVERLOADED_OPERATOR_CODE (decl
, operator_code
);
10113 if ((operator_code
== POSTINCREMENT_EXPR
10114 || operator_code
== POSTDECREMENT_EXPR
)
10115 && ! processing_template_decl
10116 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes
)), integer_type_node
))
10119 error ("postfix %qD must take %<int%> as its argument",
10122 error ("postfix %qD must take %<int%> as its second "
10130 error ("%qD must take either zero or one argument", decl
);
10132 error ("%qD must take either one or two arguments", decl
);
10136 /* More Effective C++ rule 6. */
10138 && (operator_code
== POSTINCREMENT_EXPR
10139 || operator_code
== POSTDECREMENT_EXPR
10140 || operator_code
== PREINCREMENT_EXPR
10141 || operator_code
== PREDECREMENT_EXPR
))
10143 tree arg
= TREE_VALUE (argtypes
);
10144 tree ret
= TREE_TYPE (TREE_TYPE (decl
));
10145 if (methodp
|| TREE_CODE (arg
) == REFERENCE_TYPE
)
10146 arg
= TREE_TYPE (arg
);
10147 arg
= TYPE_MAIN_VARIANT (arg
);
10148 if (operator_code
== PREINCREMENT_EXPR
10149 || operator_code
== PREDECREMENT_EXPR
)
10151 if (TREE_CODE (ret
) != REFERENCE_TYPE
10152 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret
)),
10154 warning (OPT_Weffc__
, "prefix %qD should return %qT", decl
,
10155 build_reference_type (arg
));
10159 if (!same_type_p (TYPE_MAIN_VARIANT (ret
), arg
))
10160 warning (OPT_Weffc__
, "postfix %qD should return %qT", decl
, arg
);
10164 else if (unary_op_p (operator_code
))
10169 error ("%qD must take %<void%>", decl
);
10171 error ("%qD must take exactly one argument", decl
);
10175 else /* if (binary_op_p (operator_code)) */
10180 error ("%qD must take exactly one argument", decl
);
10182 error ("%qD must take exactly two arguments", decl
);
10186 /* More Effective C++ rule 7. */
10188 && (operator_code
== TRUTH_ANDIF_EXPR
10189 || operator_code
== TRUTH_ORIF_EXPR
10190 || operator_code
== COMPOUND_EXPR
))
10191 warning (OPT_Weffc__
, "user-defined %qD always evaluates both arguments",
10195 /* Effective C++ rule 23. */
10198 && !DECL_ASSIGNMENT_OPERATOR_P (decl
)
10199 && (operator_code
== PLUS_EXPR
10200 || operator_code
== MINUS_EXPR
10201 || operator_code
== TRUNC_DIV_EXPR
10202 || operator_code
== MULT_EXPR
10203 || operator_code
== TRUNC_MOD_EXPR
)
10204 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) == REFERENCE_TYPE
)
10205 warning (OPT_Weffc__
, "%qD should return by value", decl
);
10207 /* [over.oper]/8 */
10208 for (; argtypes
&& argtypes
!= void_list_node
;
10209 argtypes
= TREE_CHAIN (argtypes
))
10210 if (TREE_PURPOSE (argtypes
))
10212 TREE_PURPOSE (argtypes
) = NULL_TREE
;
10213 if (operator_code
== POSTINCREMENT_EXPR
10214 || operator_code
== POSTDECREMENT_EXPR
)
10216 pedwarn (input_location
, OPT_pedantic
, "%qD cannot have default arguments",
10221 error ("%qD cannot have default arguments", decl
);
10229 /* Return a string giving the keyword associate with CODE. */
10231 static const char *
10232 tag_name (enum tag_types code
)
10244 case typename_type
:
10247 gcc_unreachable ();
10251 /* Name lookup in an elaborated-type-specifier (after the keyword
10252 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
10253 elaborated-type-specifier is invalid, issue a diagnostic and return
10254 error_mark_node; otherwise, return the *_TYPE to which it referred.
10255 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
10258 check_elaborated_type_specifier (enum tag_types tag_code
,
10260 bool allow_template_p
)
10266 struct S { struct S *p; };
10268 name lookup will find the TYPE_DECL for the implicit "S::S"
10269 typedef. Adjust for that here. */
10270 if (DECL_SELF_REFERENCE_P (decl
))
10271 decl
= TYPE_NAME (TREE_TYPE (decl
));
10273 type
= TREE_TYPE (decl
);
10275 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
10276 is false for this case as well. */
10277 if (TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
10279 error ("using template type parameter %qT after %qs",
10280 type
, tag_name (tag_code
));
10281 return error_mark_node
;
10285 If the identifier resolves to a typedef-name or a template
10286 type-parameter, the elaborated-type-specifier is ill-formed.
10288 In other words, the only legitimate declaration to use in the
10289 elaborated type specifier is the implicit typedef created when
10290 the type is declared. */
10291 else if (!DECL_IMPLICIT_TYPEDEF_P (decl
)
10292 && tag_code
!= typename_type
)
10294 error ("using typedef-name %qD after %qs", decl
, tag_name (tag_code
));
10295 error ("%q+D has a previous declaration here", decl
);
10296 return error_mark_node
;
10298 else if (TREE_CODE (type
) != RECORD_TYPE
10299 && TREE_CODE (type
) != UNION_TYPE
10300 && tag_code
!= enum_type
10301 && tag_code
!= typename_type
)
10303 error ("%qT referred to as %qs", type
, tag_name (tag_code
));
10304 error ("%q+T has a previous declaration here", type
);
10305 return error_mark_node
;
10307 else if (TREE_CODE (type
) != ENUMERAL_TYPE
10308 && tag_code
== enum_type
)
10310 error ("%qT referred to as enum", type
);
10311 error ("%q+T has a previous declaration here", type
);
10312 return error_mark_node
;
10314 else if (!allow_template_p
10315 && TREE_CODE (type
) == RECORD_TYPE
10316 && CLASSTYPE_IS_TEMPLATE (type
))
10318 /* If a class template appears as elaborated type specifier
10319 without a template header such as:
10321 template <class T> class C {};
10322 void f(class C); // No template header here
10324 then the required template argument is missing. */
10325 error ("template argument required for %<%s %T%>",
10326 tag_name (tag_code
),
10327 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type
)));
10328 return error_mark_node
;
10334 /* Lookup NAME in elaborate type specifier in scope according to
10335 SCOPE and issue diagnostics if necessary.
10336 Return *_TYPE node upon success, NULL_TREE when the NAME is not
10337 found, and ERROR_MARK_NODE for type error. */
10340 lookup_and_check_tag (enum tag_types tag_code
, tree name
,
10341 tag_scope scope
, bool template_header_p
)
10345 if (scope
== ts_global
)
10347 /* First try ordinary name lookup, ignoring hidden class name
10348 injected via friend declaration. */
10349 decl
= lookup_name_prefer_type (name
, 2);
10350 /* If that fails, the name will be placed in the smallest
10351 non-class, non-function-prototype scope according to 3.3.1/5.
10352 We may already have a hidden name declared as friend in this
10353 scope. So lookup again but not ignoring hidden names.
10354 If we find one, that name will be made visible rather than
10355 creating a new tag. */
10357 decl
= lookup_type_scope (name
, ts_within_enclosing_non_class
);
10360 decl
= lookup_type_scope (name
, scope
);
10362 if (decl
&& DECL_CLASS_TEMPLATE_P (decl
))
10363 decl
= DECL_TEMPLATE_RESULT (decl
);
10365 if (decl
&& TREE_CODE (decl
) == TYPE_DECL
)
10367 /* Look for invalid nested type:
10371 if (scope
== ts_current
&& DECL_SELF_REFERENCE_P (decl
))
10373 error ("%qD has the same name as the class in which it is "
10376 return error_mark_node
;
10379 /* Two cases we need to consider when deciding if a class
10380 template is allowed as an elaborated type specifier:
10381 1. It is a self reference to its own class.
10382 2. It comes with a template header.
10386 template <class T> class C {
10387 class C *c1; // DECL_SELF_REFERENCE_P is true
10390 template <class U> class C; // template_header_p is true
10391 template <class T> class C<T>::D {
10392 class C *c2; // DECL_SELF_REFERENCE_P is true
10395 t
= check_elaborated_type_specifier (tag_code
,
10398 | DECL_SELF_REFERENCE_P (decl
));
10401 else if (decl
&& TREE_CODE (decl
) == TREE_LIST
)
10403 error ("reference to %qD is ambiguous", name
);
10404 print_candidates (decl
);
10405 return error_mark_node
;
10411 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
10412 Define the tag as a forward-reference if it is not defined.
10414 If a declaration is given, process it here, and report an error if
10415 multiple declarations are not identical.
10417 SCOPE is TS_CURRENT when this is also a definition. Only look in
10418 the current frame for the name (since C++ allows new names in any
10419 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
10420 declaration. Only look beginning from the current scope outward up
10421 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
10423 TEMPLATE_HEADER_P is true when this declaration is preceded by
10424 a set of template parameters. */
10427 xref_tag (enum tag_types tag_code
, tree name
,
10428 tag_scope scope
, bool template_header_p
)
10430 enum tree_code code
;
10432 tree context
= NULL_TREE
;
10434 timevar_push (TV_NAME_LOOKUP
);
10436 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
10442 code
= RECORD_TYPE
;
10448 code
= ENUMERAL_TYPE
;
10451 gcc_unreachable ();
10454 /* In case of anonymous name, xref_tag is only called to
10455 make type node and push name. Name lookup is not required. */
10456 if (ANON_AGGRNAME_P (name
))
10459 t
= lookup_and_check_tag (tag_code
, name
,
10460 scope
, template_header_p
);
10462 if (t
== error_mark_node
)
10463 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
10465 if (scope
!= ts_current
&& t
&& current_class_type
10466 && template_class_depth (current_class_type
)
10467 && template_header_p
)
10469 /* Since SCOPE is not TS_CURRENT, we are not looking at a
10470 definition of this tag. Since, in addition, we are currently
10471 processing a (member) template declaration of a template
10472 class, we must be very careful; consider:
10479 { template <class V>
10480 friend struct S1; };
10482 Here, the S2::S1 declaration should not be confused with the
10483 outer declaration. In particular, the inner version should
10484 have a template parameter of level 2, not level 1. This
10485 would be particularly important if the member declaration
10488 template <class V = U> friend struct S1;
10490 say, when we should tsubst into `U' when instantiating
10491 S2. On the other hand, when presented with:
10501 we must find the inner binding eventually. We
10502 accomplish this by making sure that the new type we
10503 create to represent this declaration has the right
10505 context
= TYPE_CONTEXT (t
);
10511 /* If no such tag is yet defined, create a forward-reference node
10512 and record it as the "definition".
10513 When a real declaration of this type is found,
10514 the forward-reference will be altered into a real type. */
10515 if (code
== ENUMERAL_TYPE
)
10517 error ("use of enum %q#D without previous declaration", name
);
10518 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
10522 t
= make_class_type (code
);
10523 TYPE_CONTEXT (t
) = context
;
10524 t
= pushtag (name
, t
, scope
);
10529 if (template_header_p
&& MAYBE_CLASS_TYPE_P (t
))
10531 if (!redeclare_class_template (t
, current_template_parms
))
10532 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
10534 else if (!processing_template_decl
10535 && CLASS_TYPE_P (t
)
10536 && CLASSTYPE_IS_TEMPLATE (t
))
10538 error ("redeclaration of %qT as a non-template", t
);
10539 error ("previous declaration %q+D", t
);
10540 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, error_mark_node
);
10543 /* Make injected friend class visible. */
10544 if (scope
!= ts_within_enclosing_non_class
10545 && hidden_name_p (TYPE_NAME (t
)))
10547 DECL_ANTICIPATED (TYPE_NAME (t
)) = 0;
10548 DECL_FRIEND_P (TYPE_NAME (t
)) = 0;
10550 if (TYPE_TEMPLATE_INFO (t
))
10552 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t
)) = 0;
10553 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t
)) = 0;
10558 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP
, t
);
10562 xref_tag_from_type (tree old
, tree id
, tag_scope scope
)
10564 enum tag_types tag_kind
;
10566 if (TREE_CODE (old
) == RECORD_TYPE
)
10567 tag_kind
= (CLASSTYPE_DECLARED_CLASS (old
) ? class_type
: record_type
);
10569 tag_kind
= union_type
;
10571 if (id
== NULL_TREE
)
10572 id
= TYPE_IDENTIFIER (old
);
10574 return xref_tag (tag_kind
, id
, scope
, false);
10577 /* Create the binfo hierarchy for REF with (possibly NULL) base list
10578 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
10579 access_* node, and the TREE_VALUE is the type of the base-class.
10580 Non-NULL TREE_TYPE indicates virtual inheritance.
10582 Returns true if the binfo hierarchy was successfully created,
10583 false if an error was detected. */
10586 xref_basetypes (tree ref
, tree base_list
)
10589 tree binfo
, base_binfo
;
10590 unsigned max_vbases
= 0; /* Maximum direct & indirect virtual bases. */
10591 unsigned max_bases
= 0; /* Maximum direct bases. */
10593 tree default_access
;
10594 tree igo_prev
; /* Track Inheritance Graph Order. */
10596 if (ref
== error_mark_node
)
10599 /* The base of a derived class is private by default, all others are
10601 default_access
= (TREE_CODE (ref
) == RECORD_TYPE
10602 && CLASSTYPE_DECLARED_CLASS (ref
)
10603 ? access_private_node
: access_public_node
);
10605 /* First, make sure that any templates in base-classes are
10606 instantiated. This ensures that if we call ourselves recursively
10607 we do not get confused about which classes are marked and which
10609 basep
= &base_list
;
10612 tree basetype
= TREE_VALUE (*basep
);
10614 if (!(processing_template_decl
&& uses_template_parms (basetype
))
10615 && !complete_type_or_else (basetype
, NULL
))
10616 /* An incomplete type. Remove it from the list. */
10617 *basep
= TREE_CHAIN (*basep
);
10621 if (TREE_TYPE (*basep
))
10623 if (CLASS_TYPE_P (basetype
))
10624 max_vbases
+= VEC_length (tree
, CLASSTYPE_VBASECLASSES (basetype
));
10625 basep
= &TREE_CHAIN (*basep
);
10629 TYPE_MARKED_P (ref
) = 1;
10631 /* The binfo slot should be empty, unless this is an (ill-formed)
10633 gcc_assert (!TYPE_BINFO (ref
) || TYPE_SIZE (ref
));
10634 gcc_assert (TYPE_MAIN_VARIANT (ref
) == ref
);
10636 binfo
= make_tree_binfo (max_bases
);
10638 TYPE_BINFO (ref
) = binfo
;
10639 BINFO_OFFSET (binfo
) = size_zero_node
;
10640 BINFO_TYPE (binfo
) = ref
;
10644 BINFO_BASE_ACCESSES (binfo
) = VEC_alloc (tree
, gc
, max_bases
);
10645 /* An aggregate cannot have baseclasses. */
10646 CLASSTYPE_NON_AGGREGATE (ref
) = 1;
10648 if (TREE_CODE (ref
) == UNION_TYPE
)
10650 error ("derived union %qT invalid", ref
);
10657 if (TYPE_FOR_JAVA (ref
))
10659 error ("Java class %qT cannot have multiple bases", ref
);
10666 CLASSTYPE_VBASECLASSES (ref
) = VEC_alloc (tree
, gc
, max_vbases
);
10668 if (TYPE_FOR_JAVA (ref
))
10670 error ("Java class %qT cannot have virtual bases", ref
);
10675 for (igo_prev
= binfo
; base_list
; base_list
= TREE_CHAIN (base_list
))
10677 tree access
= TREE_PURPOSE (base_list
);
10678 int via_virtual
= TREE_TYPE (base_list
) != NULL_TREE
;
10679 tree basetype
= TREE_VALUE (base_list
);
10681 if (access
== access_default_node
)
10682 access
= default_access
;
10684 if (PACK_EXPANSION_P (basetype
))
10685 basetype
= PACK_EXPANSION_PATTERN (basetype
);
10686 if (TREE_CODE (basetype
) == TYPE_DECL
)
10687 basetype
= TREE_TYPE (basetype
);
10688 if (!MAYBE_CLASS_TYPE_P (basetype
) || TREE_CODE (basetype
) == UNION_TYPE
)
10690 error ("base type %qT fails to be a struct or class type",
10695 if (TYPE_FOR_JAVA (basetype
) && (current_lang_depth () == 0))
10696 TYPE_FOR_JAVA (ref
) = 1;
10698 base_binfo
= NULL_TREE
;
10699 if (CLASS_TYPE_P (basetype
) && !dependent_type_p (basetype
))
10701 base_binfo
= TYPE_BINFO (basetype
);
10702 /* The original basetype could have been a typedef'd type. */
10703 basetype
= BINFO_TYPE (base_binfo
);
10705 /* Inherit flags from the base. */
10706 TYPE_HAS_NEW_OPERATOR (ref
)
10707 |= TYPE_HAS_NEW_OPERATOR (basetype
);
10708 TYPE_HAS_ARRAY_NEW_OPERATOR (ref
)
10709 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype
);
10710 TYPE_GETS_DELETE (ref
) |= TYPE_GETS_DELETE (basetype
);
10711 TYPE_HAS_CONVERSION (ref
) |= TYPE_HAS_CONVERSION (basetype
);
10712 CLASSTYPE_DIAMOND_SHAPED_P (ref
)
10713 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype
);
10714 CLASSTYPE_REPEATED_BASE_P (ref
)
10715 |= CLASSTYPE_REPEATED_BASE_P (basetype
);
10718 /* We must do this test after we've seen through a typedef
10720 if (TYPE_MARKED_P (basetype
))
10722 if (basetype
== ref
)
10723 error ("recursive type %qT undefined", basetype
);
10725 error ("duplicate base type %qT invalid", basetype
);
10729 if (PACK_EXPANSION_P (TREE_VALUE (base_list
)))
10730 /* Regenerate the pack expansion for the bases. */
10731 basetype
= make_pack_expansion (basetype
);
10733 TYPE_MARKED_P (basetype
) = 1;
10735 base_binfo
= copy_binfo (base_binfo
, basetype
, ref
,
10736 &igo_prev
, via_virtual
);
10737 if (!BINFO_INHERITANCE_CHAIN (base_binfo
))
10738 BINFO_INHERITANCE_CHAIN (base_binfo
) = binfo
;
10740 BINFO_BASE_APPEND (binfo
, base_binfo
);
10741 BINFO_BASE_ACCESS_APPEND (binfo
, access
);
10744 if (VEC_space (tree
, CLASSTYPE_VBASECLASSES (ref
), 1))
10745 /* If we have space in the vbase vector, we must have shared at
10746 least one of them, and are therefore diamond shaped. */
10747 CLASSTYPE_DIAMOND_SHAPED_P (ref
) = 1;
10749 /* Unmark all the types. */
10750 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
10751 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
10752 TYPE_MARKED_P (ref
) = 0;
10754 /* Now see if we have a repeated base type. */
10755 if (!CLASSTYPE_REPEATED_BASE_P (ref
))
10757 for (base_binfo
= binfo
; base_binfo
;
10758 base_binfo
= TREE_CHAIN (base_binfo
))
10760 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
10762 CLASSTYPE_REPEATED_BASE_P (ref
) = 1;
10765 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 1;
10767 for (base_binfo
= binfo
; base_binfo
;
10768 base_binfo
= TREE_CHAIN (base_binfo
))
10769 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo
)))
10770 TYPE_MARKED_P (BINFO_TYPE (base_binfo
)) = 0;
10779 /* Begin compiling the definition of an enumeration type.
10782 UNDERLYING_TYPE is the type that will be used as the storage for
10783 the enumeration type. This should be NULL_TREE if no storage type
10786 SCOPED_ENUM_P is true if this is a scoped enumeration type.
10788 Returns the type object, as yet incomplete.
10789 Also records info about it so that build_enumerator
10790 may be used to declare the individual values as they are read. */
10793 start_enum (tree name
, tree underlying_type
, bool scoped_enum_p
)
10797 gcc_assert (TREE_CODE (name
) == IDENTIFIER_NODE
);
10799 /* If this is the real definition for a previous forward reference,
10800 fill in the contents in the same object that used to be the
10801 forward reference. */
10803 enumtype
= lookup_and_check_tag (enum_type
, name
,
10804 /*tag_scope=*/ts_current
,
10805 /*template_header_p=*/false);
10807 if (enumtype
!= NULL_TREE
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
)
10809 error ("multiple definition of %q#T", enumtype
);
10810 error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype
));
10811 /* Clear out TYPE_VALUES, and start again. */
10812 TYPE_VALUES (enumtype
) = NULL_TREE
;
10816 /* In case of error, make a dummy enum to allow parsing to
10818 if (enumtype
== error_mark_node
)
10819 name
= make_anon_name ();
10821 enumtype
= make_node (ENUMERAL_TYPE
);
10822 enumtype
= pushtag (name
, enumtype
, /*tag_scope=*/ts_current
);
10827 SET_SCOPED_ENUM_P (enumtype
, 1);
10828 begin_scope (sk_scoped_enum
, enumtype
);
10830 /* [C++0x dcl.enum]p5:
10832 If not explicitly specified, the underlying type of a scoped
10833 enumeration type is int. */
10834 if (!underlying_type
)
10835 underlying_type
= integer_type_node
;
10838 if (underlying_type
)
10840 if (CP_INTEGRAL_TYPE_P (underlying_type
))
10842 TYPE_MIN_VALUE (enumtype
) = TYPE_MIN_VALUE (underlying_type
);
10843 TYPE_MAX_VALUE (enumtype
) = TYPE_MAX_VALUE (underlying_type
);
10844 TYPE_SIZE (enumtype
) = TYPE_SIZE (underlying_type
);
10845 TYPE_SIZE_UNIT (enumtype
) = TYPE_SIZE_UNIT (underlying_type
);
10846 TYPE_MODE (enumtype
) = TYPE_MODE (underlying_type
);
10847 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (underlying_type
);
10848 TYPE_ALIGN (enumtype
) = TYPE_ALIGN (underlying_type
);
10849 TYPE_USER_ALIGN (enumtype
) = TYPE_USER_ALIGN (underlying_type
);
10850 TYPE_UNSIGNED (enumtype
) = TYPE_UNSIGNED (underlying_type
);
10851 ENUM_UNDERLYING_TYPE (enumtype
) = underlying_type
;
10854 error ("underlying type %<%T%> of %<%T%> must be an integral type",
10855 underlying_type
, enumtype
);
10861 /* After processing and defining all the values of an enumeration type,
10862 install their decls in the enumeration type and finish it off.
10863 ENUMTYPE is the type object and VALUES a list of name-value pairs. */
10866 finish_enum (tree enumtype
)
10875 bool use_short_enum
;
10879 integer_type_kind itk
;
10880 tree underlying_type
= NULL_TREE
;
10881 bool fixed_underlying_type_p
10882 = ENUM_UNDERLYING_TYPE (enumtype
) != NULL_TREE
;
10884 /* We built up the VALUES in reverse order. */
10885 TYPE_VALUES (enumtype
) = nreverse (TYPE_VALUES (enumtype
));
10887 /* For an enum defined in a template, just set the type of the values;
10888 all further processing is postponed until the template is
10889 instantiated. We need to set the type so that tsubst of a CONST_DECL
10891 if (processing_template_decl
)
10893 for (values
= TYPE_VALUES (enumtype
);
10895 values
= TREE_CHAIN (values
))
10896 TREE_TYPE (TREE_VALUE (values
)) = enumtype
;
10897 if (at_function_scope_p ())
10898 add_stmt (build_min (TAG_DEFN
, enumtype
));
10902 /* Determine the minimum and maximum values of the enumerators. */
10903 if (TYPE_VALUES (enumtype
))
10905 minnode
= maxnode
= NULL_TREE
;
10907 for (values
= TYPE_VALUES (enumtype
);
10909 values
= TREE_CHAIN (values
))
10911 decl
= TREE_VALUE (values
);
10913 /* [dcl.enum]: Following the closing brace of an enum-specifier,
10914 each enumerator has the type of its enumeration. Prior to the
10915 closing brace, the type of each enumerator is the type of its
10916 initializing value. */
10917 TREE_TYPE (decl
) = enumtype
;
10919 /* Update the minimum and maximum values, if appropriate. */
10920 value
= DECL_INITIAL (decl
);
10921 if (value
== error_mark_node
)
10922 value
= integer_zero_node
;
10923 /* Figure out what the minimum and maximum values of the
10924 enumerators are. */
10926 minnode
= maxnode
= value
;
10927 else if (tree_int_cst_lt (maxnode
, value
))
10929 else if (tree_int_cst_lt (value
, minnode
))
10936 If the enumerator-list is empty, the underlying type is as if
10937 the enumeration had a single enumerator with value 0. */
10938 minnode
= maxnode
= integer_zero_node
;
10940 /* Compute the number of bits require to represent all values of the
10941 enumeration. We must do this before the type of MINNODE and
10942 MAXNODE are transformed, since min_precision relies on the
10943 TREE_TYPE of the value it is passed. */
10944 unsignedp
= tree_int_cst_sgn (minnode
) >= 0;
10945 lowprec
= min_precision (minnode
, unsignedp
);
10946 highprec
= min_precision (maxnode
, unsignedp
);
10947 precision
= MAX (lowprec
, highprec
);
10949 if (!fixed_underlying_type_p
)
10951 /* Determine the underlying type of the enumeration.
10955 The underlying type of an enumeration is an integral type that
10956 can represent all the enumerator values defined in the
10957 enumeration. It is implementation-defined which integral type is
10958 used as the underlying type for an enumeration except that the
10959 underlying type shall not be larger than int unless the value of
10960 an enumerator cannot fit in an int or unsigned int.
10962 We use "int" or an "unsigned int" as the underlying type, even if
10963 a smaller integral type would work, unless the user has
10964 explicitly requested that we use the smallest possible type. The
10965 user can request that for all enumerations with a command line
10966 flag, or for just one enumeration with an attribute. */
10968 use_short_enum
= flag_short_enums
10969 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype
));
10971 for (itk
= (use_short_enum
? itk_char
: itk_int
);
10975 underlying_type
= integer_types
[itk
];
10976 if (TYPE_PRECISION (underlying_type
) >= precision
10977 && TYPE_UNSIGNED (underlying_type
) == unsignedp
)
10980 if (itk
== itk_none
)
10984 IF no integral type can represent all the enumerator values, the
10985 enumeration is ill-formed. */
10986 error ("no integral type can represent all of the enumerator values "
10987 "for %qT", enumtype
);
10988 precision
= TYPE_PRECISION (long_long_integer_type_node
);
10989 underlying_type
= integer_types
[itk_unsigned_long_long
];
10994 The value of sizeof() applied to an enumeration type, an object
10995 of an enumeration type, or an enumerator, is the value of sizeof()
10996 applied to the underlying type. */
10997 TYPE_SIZE (enumtype
) = TYPE_SIZE (underlying_type
);
10998 TYPE_SIZE_UNIT (enumtype
) = TYPE_SIZE_UNIT (underlying_type
);
10999 TYPE_MODE (enumtype
) = TYPE_MODE (underlying_type
);
11000 TYPE_ALIGN (enumtype
) = TYPE_ALIGN (underlying_type
);
11001 TYPE_USER_ALIGN (enumtype
) = TYPE_USER_ALIGN (underlying_type
);
11002 TYPE_UNSIGNED (enumtype
) = TYPE_UNSIGNED (underlying_type
);
11004 /* Set the underlying type of the enumeration type to the
11005 computed enumeration type, restricted to the enumerator
11007 ENUM_UNDERLYING_TYPE (enumtype
) = copy_node (underlying_type
);
11008 set_min_and_max_values_for_integral_type
11009 (ENUM_UNDERLYING_TYPE (enumtype
), precision
, unsignedp
);
11012 underlying_type
= ENUM_UNDERLYING_TYPE (enumtype
);
11014 /* Compute the minimum and maximum values for the type.
11018 For an enumeration where emin is the smallest enumerator and emax
11019 is the largest, the values of the enumeration are the values of the
11020 underlying type in the range bmin to bmax, where bmin and bmax are,
11021 respectively, the smallest and largest values of the smallest bit-
11022 field that can store emin and emax. */
11024 /* The middle-end currently assumes that types with TYPE_PRECISION
11025 narrower than their underlying type are suitably zero or sign
11026 extended to fill their mode. g++ doesn't make these guarantees.
11027 Until the middle-end can represent such paradoxical types, we
11028 set the TYPE_PRECISION to the width of the underlying type. */
11029 TYPE_PRECISION (enumtype
) = TYPE_PRECISION (underlying_type
);
11031 set_min_and_max_values_for_integral_type (enumtype
, precision
, unsignedp
);
11033 /* Convert each of the enumerators to the type of the underlying
11034 type of the enumeration. */
11035 for (values
= TYPE_VALUES (enumtype
); values
; values
= TREE_CHAIN (values
))
11037 location_t saved_location
;
11039 decl
= TREE_VALUE (values
);
11040 saved_location
= input_location
;
11041 input_location
= DECL_SOURCE_LOCATION (decl
);
11042 if (fixed_underlying_type_p
)
11043 /* If the enumeration type has a fixed underlying type, we
11044 already checked all of the enumerator values. */
11045 value
= DECL_INITIAL (decl
);
11047 value
= perform_implicit_conversion (underlying_type
,
11048 DECL_INITIAL (decl
),
11049 tf_warning_or_error
);
11050 input_location
= saved_location
;
11052 /* Do not clobber shared ints. */
11053 value
= copy_node (value
);
11055 TREE_TYPE (value
) = enumtype
;
11056 DECL_INITIAL (decl
) = value
;
11059 /* Fix up all variant types of this enum type. */
11060 for (t
= TYPE_MAIN_VARIANT (enumtype
); t
; t
= TYPE_NEXT_VARIANT (t
))
11062 TYPE_VALUES (t
) = TYPE_VALUES (enumtype
);
11063 TYPE_MIN_VALUE (t
) = TYPE_MIN_VALUE (enumtype
);
11064 TYPE_MAX_VALUE (t
) = TYPE_MAX_VALUE (enumtype
);
11065 TYPE_SIZE (t
) = TYPE_SIZE (enumtype
);
11066 TYPE_SIZE_UNIT (t
) = TYPE_SIZE_UNIT (enumtype
);
11067 TYPE_MODE (t
) = TYPE_MODE (enumtype
);
11068 TYPE_PRECISION (t
) = TYPE_PRECISION (enumtype
);
11069 TYPE_ALIGN (t
) = TYPE_ALIGN (enumtype
);
11070 TYPE_USER_ALIGN (t
) = TYPE_USER_ALIGN (enumtype
);
11071 TYPE_UNSIGNED (t
) = TYPE_UNSIGNED (enumtype
);
11072 ENUM_UNDERLYING_TYPE (t
) = ENUM_UNDERLYING_TYPE (enumtype
);
11075 /* Finish up the scope of a scoped enumeration. */
11076 if (SCOPED_ENUM_P (enumtype
))
11079 /* Finish debugging output for this type. */
11080 rest_of_type_compilation (enumtype
, namespace_bindings_p ());
11083 /* Build and install a CONST_DECL for an enumeration constant of the
11084 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
11085 Assignment of sequential values by default is handled here. */
11088 build_enumerator (tree name
, tree value
, tree enumtype
)
11094 /* If the VALUE was erroneous, pretend it wasn't there; that will
11095 result in the enum being assigned the next value in sequence. */
11096 if (value
== error_mark_node
)
11099 /* Remove no-op casts from the value. */
11101 STRIP_TYPE_NOPS (value
);
11103 if (! processing_template_decl
)
11105 /* Validate and default VALUE. */
11106 if (value
!= NULL_TREE
)
11108 value
= integral_constant_value (value
);
11110 if (TREE_CODE (value
) == INTEGER_CST
)
11112 value
= perform_integral_promotions (value
);
11113 constant_expression_warning (value
);
11117 error ("enumerator value for %qD is not an integer constant", name
);
11122 /* Default based on previous value. */
11123 if (value
== NULL_TREE
)
11125 if (TYPE_VALUES (enumtype
))
11128 unsigned HOST_WIDE_INT lo
;
11132 /* The next value is the previous value plus one. We can
11133 safely assume that the previous value is an INTEGER_CST.
11134 add_double doesn't know the type of the target expression,
11135 so we must check with int_fits_type_p as well. */
11136 prev_value
= DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype
)));
11137 overflowed
= add_double (TREE_INT_CST_LOW (prev_value
),
11138 TREE_INT_CST_HIGH (prev_value
),
11140 value
= build_int_cst_wide (TREE_TYPE (prev_value
), lo
, hi
);
11141 overflowed
|= !int_fits_type_p (value
, TREE_TYPE (prev_value
));
11145 error ("overflow in enumeration values at %qD", name
);
11146 value
= error_mark_node
;
11150 value
= integer_zero_node
;
11153 /* Remove no-op casts from the value. */
11154 STRIP_TYPE_NOPS (value
);
11156 /* If the underlying type of the enum is fixed, check whether
11157 the enumerator values fits in the underlying type. If it
11158 does not fit, the program is ill-formed [C++0x dcl.enum]. */
11159 if (ENUM_UNDERLYING_TYPE (enumtype
)
11161 && TREE_CODE (value
) == INTEGER_CST
11162 && !int_fits_type_p (value
, ENUM_UNDERLYING_TYPE (enumtype
)))
11164 error ("enumerator value %E is too large for underlying type %<%T%>",
11165 value
, ENUM_UNDERLYING_TYPE (enumtype
));
11167 /* Silently convert the value so that we can continue. */
11168 value
= perform_implicit_conversion (ENUM_UNDERLYING_TYPE (enumtype
),
11170 if (value
== error_mark_node
)
11175 /* C++ associates enums with global, function, or class declarations. */
11176 context
= current_scope ();
11178 /* Build the actual enumeration constant. Note that the enumeration
11179 constants have the underlying type of the enum (if it is fixed)
11180 or the type of their initializer (if the underlying type of the
11181 enum is not fixed):
11185 If the underlying type is fixed, the type of each enumerator
11186 prior to the closing brace is the underlying type; if the
11187 initializing value of an enumerator cannot be represented by
11188 the underlying type, the program is ill-formed. If the
11189 underlying type is not fixed, the type of each enumerator is
11190 the type of its initializing value.
11192 If the underlying type is not fixed, it will be computed by
11193 finish_enum and we will reset the type of this enumerator. Of
11194 course, if we're processing a template, there may be no value. */
11195 type
= value
? TREE_TYPE (value
) : NULL_TREE
;
11197 if (context
&& context
== current_class_type
)
11198 /* This enum declaration is local to the class. We need the full
11199 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
11200 decl
= build_lang_decl (CONST_DECL
, name
, type
);
11202 /* It's a global enum, or it's local to a function. (Note local to
11203 a function could mean local to a class method. */
11204 decl
= build_decl (CONST_DECL
, name
, type
);
11206 DECL_CONTEXT (decl
) = FROB_CONTEXT (context
);
11207 TREE_CONSTANT (decl
) = 1;
11208 TREE_READONLY (decl
) = 1;
11209 DECL_INITIAL (decl
) = value
;
11211 if (context
&& context
== current_class_type
)
11212 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
11213 on the TYPE_FIELDS list for `S'. (That's so that you can say
11214 things like `S::i' later.) */
11215 finish_member_declaration (decl
);
11219 /* Add this enumeration constant to the list for this type. */
11220 TYPE_VALUES (enumtype
) = tree_cons (name
, decl
, TYPE_VALUES (enumtype
));
11223 /* Look for an enumerator with the given NAME within the enumeration
11224 type ENUMTYPE. This routine is used primarily for qualified name
11225 lookup into an enumerator in C++0x, e.g.,
11227 enum class Color { Red, Green, Blue };
11229 Color color = Color::Red;
11231 Returns the value corresponding to the enumerator, or
11232 NULL_TREE if no such enumerator was found. */
11234 lookup_enumerator (tree enumtype
, tree name
)
11237 gcc_assert (enumtype
&& TREE_CODE (enumtype
) == ENUMERAL_TYPE
);
11239 e
= purpose_member (name
, TYPE_VALUES (enumtype
));
11240 return e
? TREE_VALUE (e
) : NULL_TREE
;
11244 /* We're defining DECL. Make sure that it's type is OK. */
11247 check_function_type (tree decl
, tree current_function_parms
)
11249 tree fntype
= TREE_TYPE (decl
);
11250 tree return_type
= complete_type (TREE_TYPE (fntype
));
11252 /* In a function definition, arg types must be complete. */
11253 require_complete_types_for_parms (current_function_parms
);
11255 if (dependent_type_p (return_type
))
11257 if (!COMPLETE_OR_VOID_TYPE_P (return_type
)
11258 || (TYPE_FOR_JAVA (return_type
) && MAYBE_CLASS_TYPE_P (return_type
)))
11260 tree args
= TYPE_ARG_TYPES (fntype
);
11262 if (!COMPLETE_OR_VOID_TYPE_P (return_type
))
11263 error ("return type %q#T is incomplete", return_type
);
11265 error ("return type has Java class type %q#T", return_type
);
11267 /* Make it return void instead. */
11268 if (TREE_CODE (fntype
) == METHOD_TYPE
)
11269 fntype
= build_method_type_directly (TREE_TYPE (TREE_VALUE (args
)),
11271 TREE_CHAIN (args
));
11273 fntype
= build_function_type (void_type_node
, args
);
11275 = build_exception_variant (fntype
,
11276 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl
)));
11279 abstract_virtuals_error (decl
, TREE_TYPE (fntype
));
11282 /* Create the FUNCTION_DECL for a function definition.
11283 DECLSPECS and DECLARATOR are the parts of the declaration;
11284 they describe the function's name and the type it returns,
11285 but twisted together in a fashion that parallels the syntax of C.
11287 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
11288 DECLARATOR is really the DECL for the function we are about to
11289 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
11290 indicating that the function is an inline defined in-class.
11292 This function creates a binding context for the function body
11293 as well as setting up the FUNCTION_DECL in current_function_decl.
11295 For C++, we must first check whether that datum makes any sense.
11296 For example, "class A local_a(1,2);" means that variable local_a
11297 is an aggregate of type A, which should have a constructor
11298 applied to it with the argument list [1, 2].
11300 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
11301 or may be a BLOCK if the function has been defined previously
11302 in this translation unit. On exit, DECL_INITIAL (decl1) will be
11303 error_mark_node if the function has never been defined, or
11304 a BLOCK if the function has been defined somewhere. */
11307 start_preparsed_function (tree decl1
, tree attrs
, int flags
)
11309 tree ctype
= NULL_TREE
;
11312 int doing_friend
= 0;
11313 struct cp_binding_level
*bl
;
11314 tree current_function_parms
;
11315 struct c_fileinfo
*finfo
11316 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1
)));
11317 bool honor_interface
;
11319 /* Sanity check. */
11320 gcc_assert (TREE_CODE (TREE_VALUE (void_list_node
)) == VOID_TYPE
);
11321 gcc_assert (TREE_CHAIN (void_list_node
) == NULL_TREE
);
11323 fntype
= TREE_TYPE (decl1
);
11324 if (TREE_CODE (fntype
) == METHOD_TYPE
)
11325 ctype
= TYPE_METHOD_BASETYPE (fntype
);
11327 /* ISO C++ 11.4/5. A friend function defined in a class is in
11328 the (lexical) scope of the class in which it is defined. */
11329 if (!ctype
&& DECL_FRIEND_P (decl1
))
11331 ctype
= DECL_FRIEND_CONTEXT (decl1
);
11333 /* CTYPE could be null here if we're dealing with a template;
11334 for example, `inline friend float foo()' inside a template
11335 will have no CTYPE set. */
11336 if (ctype
&& TREE_CODE (ctype
) != RECORD_TYPE
)
11342 if (DECL_DECLARED_INLINE_P (decl1
)
11343 && lookup_attribute ("noinline", attrs
))
11344 warning (0, "inline function %q+D given attribute noinline", decl1
);
11346 /* Handle gnu_inline attribute. */
11347 if (GNU_INLINE_P (decl1
))
11349 DECL_EXTERNAL (decl1
) = 1;
11350 DECL_NOT_REALLY_EXTERN (decl1
) = 0;
11351 DECL_INTERFACE_KNOWN (decl1
) = 1;
11352 DECL_DISREGARD_INLINE_LIMITS (decl1
) = 1;
11355 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1
))
11356 /* This is a constructor, we must ensure that any default args
11357 introduced by this definition are propagated to the clones
11358 now. The clones are used directly in overload resolution. */
11359 adjust_clone_args (decl1
);
11361 /* Sometimes we don't notice that a function is a static member, and
11362 build a METHOD_TYPE for it. Fix that up now. */
11363 if (ctype
!= NULL_TREE
&& DECL_STATIC_FUNCTION_P (decl1
)
11364 && TREE_CODE (TREE_TYPE (decl1
)) == METHOD_TYPE
)
11366 revert_static_member_fn (decl1
);
11370 /* Set up current_class_type, and enter the scope of the class, if
11373 push_nested_class (ctype
);
11374 else if (DECL_STATIC_FUNCTION_P (decl1
))
11375 push_nested_class (DECL_CONTEXT (decl1
));
11377 /* Now that we have entered the scope of the class, we must restore
11378 the bindings for any template parameters surrounding DECL1, if it
11379 is an inline member template. (Order is important; consider the
11380 case where a template parameter has the same name as a field of
11381 the class.) It is not until after this point that
11382 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
11383 if (flags
& SF_INCLASS_INLINE
)
11384 maybe_begin_member_template_processing (decl1
);
11386 /* Effective C++ rule 15. */
11388 && DECL_OVERLOADED_OPERATOR_P (decl1
) == NOP_EXPR
11389 && TREE_CODE (TREE_TYPE (fntype
)) == VOID_TYPE
)
11390 warning (OPT_Weffc__
, "%<operator=%> should return a reference to %<*this%>");
11392 /* Make the init_value nonzero so pushdecl knows this is not tentative.
11393 error_mark_node is replaced below (in poplevel) with the BLOCK. */
11394 if (!DECL_INITIAL (decl1
))
11395 DECL_INITIAL (decl1
) = error_mark_node
;
11397 /* This function exists in static storage.
11398 (This does not mean `static' in the C sense!) */
11399 TREE_STATIC (decl1
) = 1;
11401 /* We must call push_template_decl after current_class_type is set
11402 up. (If we are processing inline definitions after exiting a
11403 class scope, current_class_type will be NULL_TREE until set above
11404 by push_nested_class.) */
11405 if (processing_template_decl
)
11407 /* FIXME: Handle error_mark_node more gracefully. */
11408 tree newdecl1
= push_template_decl (decl1
);
11409 if (newdecl1
!= error_mark_node
)
11413 /* We are now in the scope of the function being defined. */
11414 current_function_decl
= decl1
;
11416 /* Save the parm names or decls from this function's declarator
11417 where store_parm_decls will find them. */
11418 current_function_parms
= DECL_ARGUMENTS (decl1
);
11420 /* Make sure the parameter and return types are reasonable. When
11421 you declare a function, these types can be incomplete, but they
11422 must be complete when you define the function. */
11423 check_function_type (decl1
, current_function_parms
);
11425 /* Build the return declaration for the function. */
11426 restype
= TREE_TYPE (fntype
);
11427 if (DECL_RESULT (decl1
) == NULL_TREE
)
11431 resdecl
= build_decl (RESULT_DECL
, 0, TYPE_MAIN_VARIANT (restype
));
11432 DECL_ARTIFICIAL (resdecl
) = 1;
11433 DECL_IGNORED_P (resdecl
) = 1;
11434 DECL_RESULT (decl1
) = resdecl
;
11436 cp_apply_type_quals_to_decl (cp_type_quals (restype
), resdecl
);
11439 /* Let the user know we're compiling this function. */
11440 announce_function (decl1
);
11442 /* Record the decl so that the function name is defined.
11443 If we already have a decl for this name, and it is a FUNCTION_DECL,
11444 use the old decl. */
11445 if (!processing_template_decl
&& !(flags
& SF_PRE_PARSED
))
11447 /* A specialization is not used to guide overload resolution. */
11448 if (!DECL_FUNCTION_MEMBER_P (decl1
)
11449 && !(DECL_USE_TEMPLATE (decl1
) &&
11450 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1
))))
11452 tree olddecl
= pushdecl (decl1
);
11454 if (olddecl
== error_mark_node
)
11455 /* If something went wrong when registering the declaration,
11456 use DECL1; we have to have a FUNCTION_DECL to use when
11457 parsing the body of the function. */
11461 /* Otherwise, OLDDECL is either a previous declaration
11462 of the same function or DECL1 itself. */
11464 if (warn_missing_declarations
11465 && olddecl
== decl1
11466 && !DECL_MAIN_P (decl1
)
11467 && TREE_PUBLIC (decl1
)
11468 && !DECL_DECLARED_INLINE_P (decl1
))
11472 /* Check whether DECL1 is in an anonymous
11474 for (context
= DECL_CONTEXT (decl1
);
11476 context
= DECL_CONTEXT (context
))
11478 if (TREE_CODE (context
) == NAMESPACE_DECL
11479 && DECL_NAME (context
) == NULL_TREE
)
11483 if (context
== NULL
)
11484 warning (OPT_Wmissing_declarations
,
11485 "no previous declaration for %q+D", decl1
);
11493 /* We need to set the DECL_CONTEXT. */
11494 if (!DECL_CONTEXT (decl1
) && DECL_TEMPLATE_INFO (decl1
))
11495 DECL_CONTEXT (decl1
) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1
));
11497 fntype
= TREE_TYPE (decl1
);
11499 /* If #pragma weak applies, mark the decl appropriately now.
11500 The pragma only applies to global functions. Because
11501 determining whether or not the #pragma applies involves
11502 computing the mangled name for the declaration, we cannot
11503 apply the pragma until after we have merged this declaration
11504 with any previous declarations; if the original declaration
11505 has a linkage specification, that specification applies to
11506 the definition as well, and may affect the mangled name. */
11507 if (!DECL_CONTEXT (decl1
))
11508 maybe_apply_pragma_weak (decl1
);
11511 /* Reset this in case the call to pushdecl changed it. */
11512 current_function_decl
= decl1
;
11514 gcc_assert (DECL_INITIAL (decl1
));
11516 /* This function may already have been parsed, in which case just
11517 return; our caller will skip over the body without parsing. */
11518 if (DECL_INITIAL (decl1
) != error_mark_node
)
11521 /* Initialize RTL machinery. We cannot do this until
11522 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
11523 even when processing a template; this is how we get
11524 CFUN set up, and our per-function variables initialized.
11525 FIXME factor out the non-RTL stuff. */
11526 bl
= current_binding_level
;
11527 allocate_struct_function (decl1
, processing_template_decl
);
11529 /* Initialize the language data structures. Whenever we start
11530 a new function, we destroy temporaries in the usual way. */
11531 cfun
->language
= GGC_CNEW (struct language_function
);
11532 current_stmt_tree ()->stmts_are_full_exprs_p
= 1;
11533 current_binding_level
= bl
;
11535 /* Even though we're inside a function body, we still don't want to
11536 call expand_expr to calculate the size of a variable-sized array.
11537 We haven't necessarily assigned RTL to all variables yet, so it's
11538 not safe to try to expand expressions involving them. */
11539 cfun
->dont_save_pending_sizes_p
= 1;
11541 /* Start the statement-tree, start the tree now. */
11542 DECL_SAVED_TREE (decl1
) = push_stmt_list ();
11544 /* If we are (erroneously) defining a function that we have already
11545 defined before, wipe out what we knew before. */
11546 if (!DECL_PENDING_INLINE_P (decl1
))
11547 DECL_SAVED_FUNCTION_DATA (decl1
) = NULL
;
11549 if (ctype
&& !doing_friend
&& !DECL_STATIC_FUNCTION_P (decl1
))
11551 /* We know that this was set up by `grokclassfn'. We do not
11552 wait until `store_parm_decls', since evil parse errors may
11553 never get us to that point. Here we keep the consistency
11554 between `current_class_type' and `current_class_ptr'. */
11555 tree t
= DECL_ARGUMENTS (decl1
);
11557 gcc_assert (t
!= NULL_TREE
&& TREE_CODE (t
) == PARM_DECL
);
11558 gcc_assert (TREE_CODE (TREE_TYPE (t
)) == POINTER_TYPE
);
11560 cp_function_chain
->x_current_class_ref
11561 = cp_build_indirect_ref (t
, NULL
, tf_warning_or_error
);
11562 cp_function_chain
->x_current_class_ptr
= t
;
11564 /* Constructors and destructors need to know whether they're "in
11565 charge" of initializing virtual base classes. */
11566 t
= TREE_CHAIN (t
);
11567 if (DECL_HAS_IN_CHARGE_PARM_P (decl1
))
11569 current_in_charge_parm
= t
;
11570 t
= TREE_CHAIN (t
);
11572 if (DECL_HAS_VTT_PARM_P (decl1
))
11574 gcc_assert (DECL_NAME (t
) == vtt_parm_identifier
);
11575 current_vtt_parm
= t
;
11579 honor_interface
= (!DECL_TEMPLATE_INSTANTIATION (decl1
)
11580 /* Implicitly-defined methods (like the
11581 destructor for a class in which no destructor
11582 is explicitly declared) must not be defined
11583 until their definition is needed. So, we
11584 ignore interface specifications for
11585 compiler-generated functions. */
11586 && !DECL_ARTIFICIAL (decl1
));
11588 if (DECL_INTERFACE_KNOWN (decl1
))
11590 tree ctx
= decl_function_context (decl1
);
11592 if (DECL_NOT_REALLY_EXTERN (decl1
))
11593 DECL_EXTERNAL (decl1
) = 0;
11595 if (ctx
!= NULL_TREE
&& DECL_DECLARED_INLINE_P (ctx
)
11596 && TREE_PUBLIC (ctx
))
11597 /* This is a function in a local class in an extern inline
11599 comdat_linkage (decl1
);
11601 /* If this function belongs to an interface, it is public.
11602 If it belongs to someone else's interface, it is also external.
11603 This only affects inlines and template instantiations. */
11604 else if (!finfo
->interface_unknown
&& honor_interface
)
11606 if (DECL_DECLARED_INLINE_P (decl1
)
11607 || DECL_TEMPLATE_INSTANTIATION (decl1
)
11608 || processing_template_decl
)
11610 DECL_EXTERNAL (decl1
)
11611 = (finfo
->interface_only
11612 || (DECL_DECLARED_INLINE_P (decl1
)
11613 && ! flag_implement_inlines
11614 && !DECL_VINDEX (decl1
)));
11616 /* For WIN32 we also want to put these in linkonce sections. */
11617 maybe_make_one_only (decl1
);
11620 DECL_EXTERNAL (decl1
) = 0;
11621 DECL_INTERFACE_KNOWN (decl1
) = 1;
11622 /* If this function is in an interface implemented in this file,
11623 make sure that the back end knows to emit this function
11625 if (!DECL_EXTERNAL (decl1
))
11626 mark_needed (decl1
);
11628 else if (finfo
->interface_unknown
&& finfo
->interface_only
11629 && honor_interface
)
11631 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
11632 interface, we will have both finfo->interface_unknown and
11633 finfo->interface_only set. In that case, we don't want to
11634 use the normal heuristics because someone will supply a
11635 #pragma implementation elsewhere, and deducing it here would
11636 produce a conflict. */
11637 comdat_linkage (decl1
);
11638 DECL_EXTERNAL (decl1
) = 0;
11639 DECL_INTERFACE_KNOWN (decl1
) = 1;
11640 DECL_DEFER_OUTPUT (decl1
) = 1;
11644 /* This is a definition, not a reference.
11645 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
11646 if (!GNU_INLINE_P (decl1
))
11647 DECL_EXTERNAL (decl1
) = 0;
11649 if ((DECL_DECLARED_INLINE_P (decl1
)
11650 || DECL_TEMPLATE_INSTANTIATION (decl1
))
11651 && ! DECL_INTERFACE_KNOWN (decl1
)
11652 /* Don't try to defer nested functions for now. */
11653 && ! decl_function_context (decl1
))
11654 DECL_DEFER_OUTPUT (decl1
) = 1;
11656 DECL_INTERFACE_KNOWN (decl1
) = 1;
11659 /* Determine the ELF visibility attribute for the function. We must not
11660 do this before calling "pushdecl", as we must allow "duplicate_decls"
11661 to merge any attributes appropriately. We also need to wait until
11663 if (!DECL_CLONED_FUNCTION_P (decl1
))
11664 determine_visibility (decl1
);
11666 begin_scope (sk_function_parms
, decl1
);
11670 if (DECL_DESTRUCTOR_P (decl1
)
11671 || (DECL_CONSTRUCTOR_P (decl1
)
11672 && targetm
.cxx
.cdtor_returns_this ()))
11674 cdtor_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
11675 DECL_CONTEXT (cdtor_label
) = current_function_decl
;
11678 start_fname_decls ();
11680 store_parm_decls (current_function_parms
);
11684 /* Like start_preparsed_function, except that instead of a
11685 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
11687 Returns 1 on success. If the DECLARATOR is not suitable for a function
11688 (it defines a datum instead), we return 0, which tells
11689 yyparse to report a parse error. */
11692 start_function (cp_decl_specifier_seq
*declspecs
,
11693 const cp_declarator
*declarator
,
11698 decl1
= grokdeclarator (declarator
, declspecs
, FUNCDEF
, 1, &attrs
);
11699 /* If the declarator is not suitable for a function definition,
11700 cause a syntax error. */
11701 if (decl1
== NULL_TREE
|| TREE_CODE (decl1
) != FUNCTION_DECL
)
11704 if (DECL_MAIN_P (decl1
))
11705 /* main must return int. grokfndecl should have corrected it
11706 (and issued a diagnostic) if the user got it wrong. */
11707 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1
)),
11708 integer_type_node
));
11710 start_preparsed_function (decl1
, attrs
, /*flags=*/SF_DEFAULT
);
11715 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
11719 use_eh_spec_block (tree fn
)
11721 return (flag_exceptions
&& flag_enforce_eh_specs
11722 && !processing_template_decl
11723 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn
))
11724 /* We insert the EH_SPEC_BLOCK only in the original
11725 function; then, it is copied automatically to the
11727 && !DECL_CLONED_FUNCTION_P (fn
)
11728 /* Implicitly-generated constructors and destructors have
11729 exception specifications. However, those specifications
11730 are the union of the possible exceptions specified by the
11731 constructors/destructors for bases and members, so no
11732 unallowed exception will ever reach this function. By
11733 not creating the EH_SPEC_BLOCK we save a little memory,
11734 and we avoid spurious warnings about unreachable
11736 && !DECL_ARTIFICIAL (fn
));
11739 /* Store the parameter declarations into the current function declaration.
11740 This is called after parsing the parameter declarations, before
11741 digesting the body of the function.
11743 Also install to binding contour return value identifier, if any. */
11746 store_parm_decls (tree current_function_parms
)
11748 tree fndecl
= current_function_decl
;
11751 /* This is a chain of any other decls that came in among the parm
11752 declarations. If a parm is declared with enum {foo, bar} x;
11753 then CONST_DECLs for foo and bar are put here. */
11754 tree nonparms
= NULL_TREE
;
11756 if (current_function_parms
)
11758 /* This case is when the function was defined with an ANSI prototype.
11759 The parms already have decls, so we need not do anything here
11760 except record them as in effect
11761 and complain if any redundant old-style parm decls were written. */
11763 tree specparms
= current_function_parms
;
11766 /* Must clear this because it might contain TYPE_DECLs declared
11768 current_binding_level
->names
= NULL
;
11770 /* If we're doing semantic analysis, then we'll call pushdecl
11771 for each of these. We must do them in reverse order so that
11772 they end in the correct forward order. */
11773 specparms
= nreverse (specparms
);
11775 for (parm
= specparms
; parm
; parm
= next
)
11777 next
= TREE_CHAIN (parm
);
11778 if (TREE_CODE (parm
) == PARM_DECL
)
11780 if (DECL_NAME (parm
) == NULL_TREE
11781 || TREE_CODE (parm
) != VOID_TYPE
)
11784 error ("parameter %qD declared void", parm
);
11788 /* If we find an enum constant or a type tag,
11789 put it aside for the moment. */
11790 TREE_CHAIN (parm
) = NULL_TREE
;
11791 nonparms
= chainon (nonparms
, parm
);
11795 /* Get the decls in their original chain order and record in the
11796 function. This is all and only the PARM_DECLs that were
11797 pushed into scope by the loop above. */
11798 DECL_ARGUMENTS (fndecl
) = getdecls ();
11801 DECL_ARGUMENTS (fndecl
) = NULL_TREE
;
11803 /* Now store the final chain of decls for the arguments
11804 as the decl-chain of the current lexical scope.
11805 Put the enumerators in as well, at the front so that
11806 DECL_ARGUMENTS is not modified. */
11807 current_binding_level
->names
= chainon (nonparms
, DECL_ARGUMENTS (fndecl
));
11809 if (use_eh_spec_block (current_function_decl
))
11810 current_eh_spec_block
= begin_eh_spec_block ();
11814 /* We have finished doing semantic analysis on DECL, but have not yet
11815 generated RTL for its body. Save away our current state, so that
11816 when we want to generate RTL later we know what to do. */
11819 save_function_data (tree decl
)
11821 struct language_function
*f
;
11823 /* Save the language-specific per-function data so that we can
11824 get it back when we really expand this function. */
11825 gcc_assert (!DECL_PENDING_INLINE_P (decl
));
11828 f
= GGC_NEW (struct language_function
);
11829 memcpy (f
, cp_function_chain
, sizeof (struct language_function
));
11830 DECL_SAVED_FUNCTION_DATA (decl
) = f
;
11832 /* Clear out the bits we don't need. */
11833 f
->base
.x_stmt_tree
.x_cur_stmt_list
= NULL_TREE
;
11834 f
->bindings
= NULL
;
11835 f
->x_local_names
= NULL
;
11839 /* Set the return value of the constructor (if present). */
11842 finish_constructor_body (void)
11847 if (targetm
.cxx
.cdtor_returns_this ()
11848 && (! TYPE_FOR_JAVA (current_class_type
)))
11850 /* Any return from a constructor will end up here. */
11851 add_stmt (build_stmt (LABEL_EXPR
, cdtor_label
));
11853 val
= DECL_ARGUMENTS (current_function_decl
);
11854 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
11855 DECL_RESULT (current_function_decl
), val
);
11856 /* Return the address of the object. */
11857 exprstmt
= build_stmt (RETURN_EXPR
, val
);
11858 add_stmt (exprstmt
);
11862 /* Do all the processing for the beginning of a destructor; set up the
11863 vtable pointers and cleanups for bases and members. */
11866 begin_destructor_body (void)
11868 tree compound_stmt
;
11870 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
11871 issued an error message. We still want to try to process the
11872 body of the function, but initialize_vtbl_ptrs will crash if
11873 TYPE_BINFO is NULL. */
11874 if (COMPLETE_TYPE_P (current_class_type
))
11876 compound_stmt
= begin_compound_stmt (0);
11877 /* Make all virtual function table pointers in non-virtual base
11878 classes point to CURRENT_CLASS_TYPE's virtual function
11880 initialize_vtbl_ptrs (current_class_ptr
);
11881 finish_compound_stmt (compound_stmt
);
11883 /* And insert cleanups for our bases and members so that they
11884 will be properly destroyed if we throw. */
11885 push_base_cleanups ();
11889 /* At the end of every destructor we generate code to delete the object if
11890 necessary. Do that now. */
11893 finish_destructor_body (void)
11897 /* Any return from a destructor will end up here; that way all base
11898 and member cleanups will be run when the function returns. */
11899 add_stmt (build_stmt (LABEL_EXPR
, cdtor_label
));
11901 /* In a virtual destructor, we must call delete. */
11902 if (DECL_VIRTUAL_P (current_function_decl
))
11905 tree virtual_size
= cxx_sizeof (current_class_type
);
11909 At the point of definition of a virtual destructor (including
11910 an implicit definition), non-placement operator delete shall
11911 be looked up in the scope of the destructor's class and if
11912 found shall be accessible and unambiguous. */
11913 exprstmt
= build_op_delete_call(DELETE_EXPR
, current_class_ptr
,
11915 /*global_p=*/false,
11916 /*placement=*/NULL_TREE
,
11917 /*alloc_fn=*/NULL_TREE
);
11919 if_stmt
= begin_if_stmt ();
11920 finish_if_stmt_cond (build2 (BIT_AND_EXPR
, integer_type_node
,
11921 current_in_charge_parm
,
11924 finish_expr_stmt (exprstmt
);
11925 finish_then_clause (if_stmt
);
11926 finish_if_stmt (if_stmt
);
11929 if (targetm
.cxx
.cdtor_returns_this ())
11933 val
= DECL_ARGUMENTS (current_function_decl
);
11934 val
= build2 (MODIFY_EXPR
, TREE_TYPE (val
),
11935 DECL_RESULT (current_function_decl
), val
);
11936 /* Return the address of the object. */
11937 exprstmt
= build_stmt (RETURN_EXPR
, val
);
11938 add_stmt (exprstmt
);
11942 /* Do the necessary processing for the beginning of a function body, which
11943 in this case includes member-initializers, but not the catch clauses of
11944 a function-try-block. Currently, this means opening a binding level
11945 for the member-initializers (in a ctor) and member cleanups (in a dtor). */
11948 begin_function_body (void)
11952 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
11955 if (processing_template_decl
)
11956 /* Do nothing now. */;
11958 /* Always keep the BLOCK node associated with the outermost pair of
11959 curly braces of a function. These are needed for correct
11960 operation of dwarfout.c. */
11961 keep_next_level (true);
11963 stmt
= begin_compound_stmt (BCS_FN_BODY
);
11965 if (processing_template_decl
)
11966 /* Do nothing now. */;
11967 else if (DECL_DESTRUCTOR_P (current_function_decl
))
11968 begin_destructor_body ();
11973 /* Do the processing for the end of a function body. Currently, this means
11974 closing out the cleanups for fully-constructed bases and members, and in
11975 the case of the destructor, deleting the object if desired. Again, this
11976 is only meaningful for [cd]tors, since they are the only functions where
11977 there is a significant distinction between the main body and any
11978 function catch clauses. Handling, say, main() return semantics here
11979 would be wrong, as flowing off the end of a function catch clause for
11980 main() would also need to return 0. */
11983 finish_function_body (tree compstmt
)
11985 if (compstmt
== NULL_TREE
)
11988 /* Close the block. */
11989 finish_compound_stmt (compstmt
);
11991 if (processing_template_decl
)
11992 /* Do nothing now. */;
11993 else if (DECL_CONSTRUCTOR_P (current_function_decl
))
11994 finish_constructor_body ();
11995 else if (DECL_DESTRUCTOR_P (current_function_decl
))
11996 finish_destructor_body ();
11999 /* Given a function, returns the BLOCK corresponding to the outermost level
12000 of curly braces, skipping the artificial block created for constructor
12004 outer_curly_brace_block (tree fndecl
)
12006 tree block
= BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl
));
12007 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl
))
12008 /* Skip the artificial function body block. */
12009 block
= BLOCK_SUBBLOCKS (block
);
12013 /* Finish up a function declaration and compile that function
12014 all the way to assembler language output. The free the storage
12015 for the function definition.
12017 FLAGS is a bitwise or of the following values:
12019 We just finished processing the body of an in-class inline
12020 function definition. (This processing will have taken place
12021 after the class definition is complete.) */
12024 finish_function (int flags
)
12026 tree fndecl
= current_function_decl
;
12027 tree fntype
, ctype
= NULL_TREE
;
12028 int inclass_inline
= (flags
& 2) != 0;
12031 /* When we get some parse errors, we can end up without a
12032 current_function_decl, so cope. */
12033 if (fndecl
== NULL_TREE
)
12034 return error_mark_node
;
12036 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl
)
12037 && DECL_VIRTUAL_P (fndecl
)
12038 && !processing_template_decl
)
12040 tree fnclass
= DECL_CONTEXT (fndecl
);
12041 if (fndecl
== CLASSTYPE_KEY_METHOD (fnclass
))
12042 keyed_classes
= tree_cons (NULL_TREE
, fnclass
, keyed_classes
);
12045 nested
= function_depth
> 1;
12046 fntype
= TREE_TYPE (fndecl
);
12048 /* TREE_READONLY (fndecl) = 1;
12049 This caused &foo to be of type ptr-to-const-function
12050 which then got a warning when stored in a ptr-to-function variable. */
12052 gcc_assert (building_stmt_tree ());
12053 /* The current function is being defined, so its DECL_INITIAL should
12054 be set, and unless there's a multiple definition, it should be
12055 error_mark_node. */
12056 gcc_assert (DECL_INITIAL (fndecl
) == error_mark_node
);
12058 /* For a cloned function, we've already got all the code we need;
12059 there's no need to add any extra bits. */
12060 if (!DECL_CLONED_FUNCTION_P (fndecl
))
12062 if (DECL_MAIN_P (current_function_decl
))
12066 /* Make it so that `main' always returns 0 by default (or
12069 stmt
= finish_return_stmt (integer_one_node
);
12071 stmt
= finish_return_stmt (integer_zero_node
);
12073 /* Hack. We don't want the middle-end to warn that this
12074 return is unreachable, so put the statement on the
12077 location_t linezero
= linemap_line_start (line_table
, 0, 1);
12078 SET_EXPR_LOCATION (stmt
, linezero
);
12082 if (use_eh_spec_block (current_function_decl
))
12083 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
12084 (TREE_TYPE (current_function_decl
)),
12085 current_eh_spec_block
);
12088 /* If we're saving up tree structure, tie off the function now. */
12089 DECL_SAVED_TREE (fndecl
) = pop_stmt_list (DECL_SAVED_TREE (fndecl
));
12091 finish_fname_decls ();
12093 /* If this function can't throw any exceptions, remember that. */
12094 if (!processing_template_decl
12095 && !cp_function_chain
->can_throw
12096 && !flag_non_call_exceptions
12097 && !DECL_REPLACEABLE_P (fndecl
))
12098 TREE_NOTHROW (fndecl
) = 1;
12100 /* This must come after expand_function_end because cleanups might
12101 have declarations (from inline functions) that need to go into
12102 this function's blocks. */
12104 /* If the current binding level isn't the outermost binding level
12105 for this function, either there is a bug, or we have experienced
12106 syntax errors and the statement tree is malformed. */
12107 if (current_binding_level
->kind
!= sk_function_parms
)
12109 /* Make sure we have already experienced errors. */
12110 gcc_assert (errorcount
);
12112 /* Throw away the broken statement tree and extra binding
12114 DECL_SAVED_TREE (fndecl
) = alloc_stmt_list ();
12116 while (current_binding_level
->kind
!= sk_function_parms
)
12118 if (current_binding_level
->kind
== sk_class
)
12119 pop_nested_class ();
12121 poplevel (0, 0, 0);
12124 poplevel (1, 0, 1);
12126 /* Statements should always be full-expressions at the outermost set
12127 of curly braces for a function. */
12128 gcc_assert (stmts_are_full_exprs_p ());
12130 /* Set up the named return value optimization, if we can. Candidate
12131 variables are selected in check_return_expr. */
12132 if (current_function_return_value
)
12134 tree r
= current_function_return_value
;
12137 if (r
!= error_mark_node
12138 /* This is only worth doing for fns that return in memory--and
12139 simpler, since we don't have to worry about promoted modes. */
12140 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl
)), fndecl
)
12141 /* Only allow this for variables declared in the outer scope of
12142 the function so we know that their lifetime always ends with a
12143 return; see g++.dg/opt/nrv6.C. We could be more flexible if
12144 we were to do this optimization in tree-ssa. */
12145 && (outer
= outer_curly_brace_block (fndecl
))
12146 && chain_member (r
, BLOCK_VARS (outer
)))
12147 finalize_nrv (&DECL_SAVED_TREE (fndecl
), r
, DECL_RESULT (fndecl
));
12149 current_function_return_value
= NULL_TREE
;
12152 /* Remember that we were in class scope. */
12153 if (current_class_name
)
12154 ctype
= current_class_type
;
12156 /* Must mark the RESULT_DECL as being in this function. */
12157 DECL_CONTEXT (DECL_RESULT (fndecl
)) = fndecl
;
12159 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
12160 to the FUNCTION_DECL node itself. */
12161 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl
)) = fndecl
;
12163 /* Save away current state, if appropriate. */
12164 if (!processing_template_decl
)
12165 save_function_data (fndecl
);
12167 /* Complain if there's just no return statement. */
12168 if (warn_return_type
12169 && TREE_CODE (TREE_TYPE (fntype
)) != VOID_TYPE
12170 && !dependent_type_p (TREE_TYPE (fntype
))
12171 && !current_function_returns_value
&& !current_function_returns_null
12172 /* Don't complain if we abort or throw. */
12173 && !current_function_returns_abnormally
12174 && !DECL_NAME (DECL_RESULT (fndecl
))
12175 && !TREE_NO_WARNING (fndecl
)
12176 /* Structor return values (if any) are set by the compiler. */
12177 && !DECL_CONSTRUCTOR_P (fndecl
)
12178 && !DECL_DESTRUCTOR_P (fndecl
))
12180 warning (OPT_Wreturn_type
,
12181 "no return statement in function returning non-void");
12182 TREE_NO_WARNING (fndecl
) = 1;
12185 /* Store the end of the function, so that we get good line number
12186 info for the epilogue. */
12187 cfun
->function_end_locus
= input_location
;
12189 /* Genericize before inlining. */
12190 if (!processing_template_decl
)
12192 struct language_function
*f
= DECL_SAVED_FUNCTION_DATA (fndecl
);
12193 cp_genericize (fndecl
);
12194 /* Clear out the bits we don't need. */
12195 f
->x_current_class_ptr
= NULL
;
12196 f
->x_current_class_ref
= NULL
;
12197 f
->x_eh_spec_block
= NULL
;
12198 f
->x_in_charge_parm
= NULL
;
12199 f
->x_vtt_parm
= NULL
;
12200 f
->x_return_value
= NULL
;
12201 f
->bindings
= NULL
;
12202 f
->extern_decl_map
= NULL
;
12204 /* Handle attribute((warn_unused_result)). Relies on gimple input. */
12205 c_warn_unused_result (gimple_body (fndecl
));
12207 /* Clear out the bits we don't need. */
12208 local_names
= NULL
;
12210 /* We're leaving the context of this function, so zap cfun. It's still in
12211 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
12213 current_function_decl
= NULL
;
12215 /* If this is an in-class inline definition, we may have to pop the
12216 bindings for the template parameters that we added in
12217 maybe_begin_member_template_processing when start_function was
12219 if (inclass_inline
)
12220 maybe_end_member_template_processing ();
12222 /* Leave the scope of the class. */
12224 pop_nested_class ();
12230 /* Let the error reporting routines know that we're outside a
12231 function. For a nested function, this value is used in
12232 cxx_pop_function_context and then reset via pop_function_context. */
12233 current_function_decl
= NULL_TREE
;
12238 /* Create the FUNCTION_DECL for a function definition.
12239 DECLSPECS and DECLARATOR are the parts of the declaration;
12240 they describe the return type and the name of the function,
12241 but twisted together in a fashion that parallels the syntax of C.
12243 This function creates a binding context for the function body
12244 as well as setting up the FUNCTION_DECL in current_function_decl.
12246 Returns a FUNCTION_DECL on success.
12248 If the DECLARATOR is not suitable for a function (it defines a datum
12249 instead), we return 0, which tells yyparse to report a parse error.
12251 May return void_type_node indicating that this method is actually
12252 a friend. See grokfield for more details.
12254 Came here with a `.pushlevel' .
12256 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
12257 CHANGES TO CODE IN `grokfield'. */
12260 start_method (cp_decl_specifier_seq
*declspecs
,
12261 const cp_declarator
*declarator
, tree attrlist
)
12263 tree fndecl
= grokdeclarator (declarator
, declspecs
, MEMFUNCDEF
, 0,
12266 if (fndecl
== error_mark_node
)
12267 return error_mark_node
;
12269 if (fndecl
== NULL
|| TREE_CODE (fndecl
) != FUNCTION_DECL
)
12271 error ("invalid member function declaration");
12272 return error_mark_node
;
12276 cplus_decl_attributes (&fndecl
, attrlist
, 0);
12278 /* Pass friends other than inline friend functions back. */
12279 if (fndecl
== void_type_node
)
12282 if (DECL_IN_AGGR_P (fndecl
))
12284 if (DECL_CONTEXT (fndecl
)
12285 && TREE_CODE (DECL_CONTEXT (fndecl
)) != NAMESPACE_DECL
)
12286 error ("%qD is already defined in class %qT", fndecl
,
12287 DECL_CONTEXT (fndecl
));
12288 return error_mark_node
;
12291 check_template_shadow (fndecl
);
12293 DECL_DECLARED_INLINE_P (fndecl
) = 1;
12295 /* We process method specializations in finish_struct_1. */
12296 if (processing_template_decl
&& !DECL_TEMPLATE_SPECIALIZATION (fndecl
))
12298 fndecl
= push_template_decl (fndecl
);
12299 if (fndecl
== error_mark_node
)
12303 if (! DECL_FRIEND_P (fndecl
))
12305 if (TREE_CHAIN (fndecl
))
12307 fndecl
= copy_node (fndecl
);
12308 TREE_CHAIN (fndecl
) = NULL_TREE
;
12312 finish_decl (fndecl
, NULL_TREE
, NULL_TREE
);
12314 /* Make a place for the parms. */
12315 begin_scope (sk_function_parms
, fndecl
);
12317 DECL_IN_AGGR_P (fndecl
) = 1;
12321 /* Go through the motions of finishing a function definition.
12322 We don't compile this method until after the whole class has
12325 FINISH_METHOD must return something that looks as though it
12326 came from GROKFIELD (since we are defining a method, after all).
12328 This is called after parsing the body of the function definition.
12329 STMTS is the chain of statements that makes up the function body.
12331 DECL is the ..._DECL that `start_method' provided. */
12334 finish_method (tree decl
)
12336 tree fndecl
= decl
;
12341 if (decl
== void_type_node
)
12344 old_initial
= DECL_INITIAL (fndecl
);
12346 /* Undo the level for the parms (from start_method).
12347 This is like poplevel, but it causes nothing to be
12348 saved. Saving information here confuses symbol-table
12349 output routines. Besides, this information will
12350 be correctly output when this method is actually
12353 /* Clear out the meanings of the local variables of this level;
12354 also record in each decl which block it belongs to. */
12356 for (link
= current_binding_level
->names
; link
; link
= TREE_CHAIN (link
))
12358 if (DECL_NAME (link
) != NULL_TREE
)
12359 pop_binding (DECL_NAME (link
), link
);
12360 gcc_assert (TREE_CODE (link
) != FUNCTION_DECL
);
12361 DECL_CONTEXT (link
) = NULL_TREE
;
12364 poplevel (0, 0, 0);
12366 DECL_INITIAL (fndecl
) = old_initial
;
12368 /* We used to check if the context of FNDECL was different from
12369 current_class_type as another way to get inside here. This didn't work
12370 for String.cc in libg++. */
12371 if (DECL_FRIEND_P (fndecl
))
12373 VEC_safe_push (tree
, gc
, CLASSTYPE_INLINE_FRIENDS (current_class_type
),
12375 decl
= void_type_node
;
12382 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
12383 we can lay it out later, when and if its type becomes complete. */
12386 maybe_register_incomplete_var (tree var
)
12388 gcc_assert (TREE_CODE (var
) == VAR_DECL
);
12390 /* Keep track of variables with incomplete types. */
12391 if (!processing_template_decl
&& TREE_TYPE (var
) != error_mark_node
12392 && DECL_EXTERNAL (var
))
12394 tree inner_type
= TREE_TYPE (var
);
12396 while (TREE_CODE (inner_type
) == ARRAY_TYPE
)
12397 inner_type
= TREE_TYPE (inner_type
);
12398 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
12400 if ((!COMPLETE_TYPE_P (inner_type
) && CLASS_TYPE_P (inner_type
))
12401 /* RTTI TD entries are created while defining the type_info. */
12402 || (TYPE_LANG_SPECIFIC (inner_type
)
12403 && TYPE_BEING_DEFINED (inner_type
)))
12404 incomplete_vars
= tree_cons (inner_type
, var
, incomplete_vars
);
12408 /* Called when a class type (given by TYPE) is defined. If there are
12409 any existing VAR_DECLs whose type has been completed by this
12410 declaration, update them now. */
12413 complete_vars (tree type
)
12415 tree
*list
= &incomplete_vars
;
12417 gcc_assert (CLASS_TYPE_P (type
));
12420 if (same_type_p (type
, TREE_PURPOSE (*list
)))
12422 tree var
= TREE_VALUE (*list
);
12423 tree type
= TREE_TYPE (var
);
12424 /* Complete the type of the variable. The VAR_DECL itself
12425 will be laid out in expand_expr. */
12426 complete_type (type
);
12427 cp_apply_type_quals_to_decl (cp_type_quals (type
), var
);
12428 /* Remove this entry from the list. */
12429 *list
= TREE_CHAIN (*list
);
12432 list
= &TREE_CHAIN (*list
);
12435 /* Check for pending declarations which may have abstract type. */
12436 complete_type_check_abstract (type
);
12439 /* If DECL is of a type which needs a cleanup, build and return an
12440 expression to perform that cleanup here. Return NULL_TREE if no
12441 cleanup need be done. */
12444 cxx_maybe_build_cleanup (tree decl
)
12450 /* Assume no cleanup is required. */
12451 cleanup
= NULL_TREE
;
12453 if (error_operand_p (decl
))
12456 /* Handle "__attribute__((cleanup))". We run the cleanup function
12457 before the destructor since the destructor is what actually
12458 terminates the lifetime of the object. */
12459 attr
= lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl
));
12466 /* Get the name specified by the user for the cleanup function. */
12467 id
= TREE_VALUE (TREE_VALUE (attr
));
12468 /* Look up the name to find the cleanup function to call. It is
12469 important to use lookup_name here because that is what is
12470 used in c-common.c:handle_cleanup_attribute when performing
12471 initial checks on the attribute. Note that those checks
12472 include ensuring that the function found is not an overloaded
12473 function, or an object with an overloaded call operator,
12474 etc.; we can rely on the fact that the function found is an
12475 ordinary FUNCTION_DECL. */
12476 fn
= lookup_name (id
);
12477 arg
= build_address (decl
);
12479 cleanup
= cp_build_function_call (fn
, build_tree_list (NULL_TREE
,
12481 tf_warning_or_error
);
12483 /* Handle ordinary C++ destructors. */
12484 type
= TREE_TYPE (decl
);
12485 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
))
12487 int flags
= LOOKUP_NORMAL
|LOOKUP_DESTRUCTOR
;
12488 bool has_vbases
= (TREE_CODE (type
) == RECORD_TYPE
12489 && CLASSTYPE_VBASECLASSES (type
));
12493 if (TREE_CODE (type
) == ARRAY_TYPE
)
12496 addr
= build_address (decl
);
12498 /* Optimize for space over speed here. */
12499 if (!has_vbases
|| flag_expensive_optimizations
)
12500 flags
|= LOOKUP_NONVIRTUAL
;
12502 call
= build_delete (TREE_TYPE (addr
), addr
,
12503 sfk_complete_destructor
, flags
, 0);
12505 cleanup
= build_compound_expr (cleanup
, call
);
12513 /* When a stmt has been parsed, this function is called. */
12520 /* DECL was originally constructed as a non-static member function,
12521 but turned out to be static. Update it accordingly. */
12524 revert_static_member_fn (tree decl
)
12527 tree function
= TREE_TYPE (decl
);
12528 tree args
= TYPE_ARG_TYPES (function
);
12530 if (cp_type_quals (TREE_TYPE (TREE_VALUE (args
)))
12531 != TYPE_UNQUALIFIED
)
12532 error ("static member function %q#D declared with type qualifiers", decl
);
12534 args
= TREE_CHAIN (args
);
12535 tmp
= build_function_type (TREE_TYPE (function
), args
);
12536 tmp
= build_qualified_type (tmp
, cp_type_quals (function
));
12537 tmp
= build_exception_variant (tmp
,
12538 TYPE_RAISES_EXCEPTIONS (function
));
12539 TREE_TYPE (decl
) = tmp
;
12540 if (DECL_ARGUMENTS (decl
))
12541 DECL_ARGUMENTS (decl
) = TREE_CHAIN (DECL_ARGUMENTS (decl
));
12542 DECL_STATIC_FUNCTION_P (decl
) = 1;
12545 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
12546 one of the language-independent trees. */
12548 enum cp_tree_node_structure_enum
12549 cp_tree_node_structure (union lang_tree_node
* t
)
12551 switch (TREE_CODE (&t
->generic
))
12553 case DEFAULT_ARG
: return TS_CP_DEFAULT_ARG
;
12554 case IDENTIFIER_NODE
: return TS_CP_IDENTIFIER
;
12555 case OVERLOAD
: return TS_CP_OVERLOAD
;
12556 case TEMPLATE_PARM_INDEX
: return TS_CP_TPI
;
12557 case PTRMEM_CST
: return TS_CP_PTRMEM
;
12558 case BASELINK
: return TS_CP_BASELINK
;
12559 case STATIC_ASSERT
: return TS_CP_STATIC_ASSERT
;
12560 case ARGUMENT_PACK_SELECT
: return TS_CP_ARGUMENT_PACK_SELECT
;
12561 case TRAIT_EXPR
: return TS_CP_TRAIT_EXPR
;
12562 default: return TS_CP_GENERIC
;
12566 /* Build the void_list_node (void_type_node having been created). */
12568 build_void_list_node (void)
12570 tree t
= build_tree_list (NULL_TREE
, void_type_node
);
12575 cp_missing_noreturn_ok_p (tree decl
)
12577 /* A missing noreturn is ok for the `main' function. */
12578 return DECL_MAIN_P (decl
);
12581 /* Return the COMDAT group into which DECL should be placed. */
12584 cxx_comdat_group (tree decl
)
12588 /* Virtual tables, construction virtual tables, and virtual table
12589 tables all go in a single COMDAT group, named after the primary
12591 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_VTABLE_OR_VTT_P (decl
))
12592 name
= DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl
)));
12593 /* For all other DECLs, the COMDAT group is the mangled name of the
12594 declaration itself. */
12597 while (DECL_THUNK_P (decl
))
12599 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
12600 into the same section as the target function. In that case
12601 we must return target's name. */
12602 tree target
= THUNK_TARGET (decl
);
12603 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target
)
12604 && DECL_SECTION_NAME (target
) != NULL
12605 && DECL_ONE_ONLY (target
))
12610 name
= DECL_ASSEMBLER_NAME (decl
);
12613 return IDENTIFIER_POINTER (name
);
12616 #include "gt-cp-decl.h"