]> git.ipfire.org Git - thirdparty/gcc.git/blame - gcc/cp/decl.c
backport: ChangeLog.tuples: ChangeLog from gimple-tuples-branch.
[thirdparty/gcc.git] / gcc / cp / decl.c
CommitLineData
3fd5abcf 1/* Process declarations and variables for C++ compiler.
d363e7bf 2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
1ea193c2
ILT
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 Free Software Foundation, Inc.
e5e809f4 5 Contributed by Michael Tiemann (tiemann@cygnus.com)
8d08fdba 6
1c313945 7This file is part of GCC.
8d08fdba 8
1c313945 9GCC is free software; you can redistribute it and/or modify
8d08fdba 10it under the terms of the GNU General Public License as published by
e77f031d 11the Free Software Foundation; either version 3, or (at your option)
8d08fdba
MS
12any later version.
13
1c313945 14GCC is distributed in the hope that it will be useful,
8d08fdba
MS
15but WITHOUT ANY WARRANTY; without even the implied warranty of
16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17GNU General Public License for more details.
18
19You should have received a copy of the GNU General Public License
e77f031d
NC
20along with GCC; see the file COPYING3. If not see
21<http://www.gnu.org/licenses/>. */
8d08fdba
MS
22
23
1c313945 24/* Process declarations and symbol lookup for C++ front end.
8d08fdba
MS
25 Also constructs types; the standard scalar types at initialization,
26 and structure, union, array and enum types when they are declared. */
27
28/* ??? not all decl nodes are given the most useful possible
29 line numbers. For example, the CONST_DECLs for enum values. */
30
8d08fdba 31#include "config.h"
8d052bc7 32#include "system.h"
4977bab6
ZW
33#include "coretypes.h"
34#include "tm.h"
8d08fdba
MS
35#include "tree.h"
36#include "rtl.h"
3bdf5ad1 37#include "expr.h"
8d08fdba
MS
38#include "flags.h"
39#include "cp-tree.h"
25af8512 40#include "tree-inline.h"
8d08fdba 41#include "decl.h"
49c249e1
JM
42#include "output.h"
43#include "except.h"
54f92bfb 44#include "toplev.h"
e2500fed 45#include "hashtab.h"
0e9295cf 46#include "tm_p.h"
672a6f42 47#include "target.h"
26f943fd 48#include "c-common.h"
ecb0eece 49#include "c-pragma.h"
7437519c 50#include "diagnostic.h"
e7c41c99 51#include "intl.h"
e2500fed 52#include "debug.h"
22ffcc6f 53#include "timevar.h"
6de9cd9a 54#include "tree-flow.h"
0d83bf5a 55#include "pointer-set.h"
8d08fdba 56
62d1db17 57static tree grokparms (cp_parameter_declarator *, tree *);
11f6b451
NN
58static const char *redeclaration_error_message (tree, tree);
59
11f6b451 60static int decl_jump_unsafe (tree);
11f6b451
NN
61static void require_complete_types_for_parms (tree);
62static int ambi_op_p (enum tree_code);
63static int unary_op_p (enum tree_code);
11f6b451 64static void push_local_name (tree);
7e99327d 65static tree grok_reference_init (tree, tree, tree, tree *);
caf93cb0 66static tree grokvardecl (tree, tree, const cp_decl_specifier_seq *,
1ff3c076 67 int, int, tree);
11f6b451 68static void record_unknown_type (tree, const char *);
c79efc4d 69static tree builtin_function_1 (tree, tree);
11f6b451
NN
70static tree build_library_fn_1 (tree, enum tree_code, tree);
71static int member_function_or_else (tree, tree, enum overload_flags);
72static void bad_specifiers (tree, const char *, int, int, int, int,
73 int);
11f6b451
NN
74static void check_for_uninitialized_const_var (tree);
75static hashval_t typename_hash (const void *);
76static int typename_compare (const void *, const void *);
11f6b451 77static tree local_variable_p_walkfn (tree *, int *, void *);
11f6b451 78static tree record_builtin_java_type (const char *, int);
461c6fce 79static const char *tag_name (enum tag_types);
29ef83de 80static tree lookup_and_check_tag (enum tag_types, tree, tag_scope, bool);
11f6b451 81static int walk_namespaces_r (tree, walk_namespaces_fn, void *);
11f6b451
NN
82static void maybe_deduce_size_from_array_init (tree, tree);
83static void layout_var_decl (tree);
84static void maybe_commonize_var (tree);
7e99327d 85static tree check_initializer (tree, tree, int, tree *);
11f6b451
NN
86static void make_rtl_for_nonlocal_decl (tree, tree, const char *);
87static void save_function_data (tree);
88static void check_function_type (tree, tree);
11f6b451
NN
89static void finish_constructor_body (void);
90static void begin_destructor_body (void);
91static void finish_destructor_body (void);
92static tree create_array_type_for_decl (tree, tree, tree);
93static tree get_atexit_node (void);
94static tree get_dso_handle_node (void);
95static tree start_cleanup_fn (void);
96static void end_cleanup_fn (void);
97static tree cp_make_fname_decl (tree, int);
98static void initialize_predefined_identifiers (void);
caf93cb0 99static tree check_special_function_return_type
11f6b451
NN
100 (special_function_kind, tree, tree);
101static tree push_cp_library_fn (enum tree_code, tree);
102static tree build_cp_library_fn (tree, enum tree_code, tree);
103static void store_parm_decls (tree);
8e3df2de
MM
104static void initialize_local_var (tree, tree);
105static void expand_static_init (tree, tree);
106static tree next_initializable_field (tree);
8d08fdba 107
7f4edbcb 108/* The following symbols are subsumed in the cp_global_trees array, and
68642fb6 109 listed here individually for documentation purposes.
8d08fdba 110
7f4edbcb
BS
111 C++ extensions
112 tree wchar_decl_node;
37c46b43 113
7f4edbcb
BS
114 tree vtable_entry_type;
115 tree delta_type_node;
7f4edbcb 116 tree __t_desc_type_node;
8d08fdba 117
9e62871e 118 tree class_type_node;
7f4edbcb 119 tree unknown_type_node;
8d08fdba 120
7f4edbcb 121 Array type `vtable_entry_type[]'
8d08fdba 122
7f4edbcb
BS
123 tree vtbl_type_node;
124 tree vtbl_ptr_type_node;
8d08fdba 125
2854d3c6 126 Namespaces,
8d08fdba 127
7f4edbcb 128 tree std_node;
2854d3c6 129 tree abi_node;
8d08fdba 130
7f4edbcb
BS
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.
8d08fdba 134
7f4edbcb 135 tree abort_fndecl;
8d08fdba 136
7f4edbcb 137 The FUNCTION_DECL for the default `::operator delete'.
2986ae00 138
7f4edbcb 139 tree global_delete_fndecl;
8d08fdba 140
7f4edbcb 141 Used by RTTI
669ec2b4 142 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
3db45ab5 143 tree tinfo_var_id; */
8d08fdba 144
7f4edbcb 145tree cp_global_trees[CPTI_MAX];
8d08fdba 146
2c73f9f5 147/* Indicates that there is a type value in some namespace, although
7f4edbcb 148 that is not necessarily in scope at the moment. */
2c73f9f5 149
00e8de68 150tree global_type_node;
2c73f9f5 151
82a2669e 152/* The node that holds the "name" of the global scope. */
00e8de68 153tree global_scope_name;
82a2669e 154
8e4ce833
JJ
155#define local_names cp_function_chain->x_local_names
156
8d08fdba
MS
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. */
161tree static_aggregates;
162
8d08fdba
MS
163/* -- end of C++ */
164
81b3411c 165/* A node for the integer constants 2, and 3. */
d11ad92e 166
81b3411c 167tree integer_two_node, integer_three_node;
8d08fdba 168
1799e5d5
RH
169/* Used only for jumps to as-yet undefined labels, since jumps to
170 defined labels can have their validity checked immediately. */
171
172struct named_label_use_entry GTY(())
173{
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. */
182 tree names_in_scope;
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. */
188 bool in_omp_scope;
189};
190
6625cdb5
JM
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. */
194
1799e5d5 195struct named_label_entry GTY(())
6625cdb5 196{
1799e5d5
RH
197 /* The decl itself. */
198 tree label_decl;
199
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. */
e2500fed 203 struct cp_binding_level *binding_level;
3db45ab5 204 /* The head of the names list that was current when the label was
1799e5d5
RH
205 defined, or the inner scope popped. These are the decls that will
206 be skipped when jumping to the label. */
6625cdb5 207 tree names_in_scope;
1799e5d5
RH
208 /* A tree list of all decls from all binding levels that would be
209 crossed by a backward branch to the label. */
6625cdb5 210 tree bad_decls;
1799e5d5
RH
211
212 /* A list of uses of the label, before the label is defined. */
213 struct named_label_use_entry *uses;
214
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
ddd0b831 217 to the label will illegally enter a scope of the given flavor. */
1799e5d5
RH
218 bool in_try_scope;
219 bool in_catch_scope;
220 bool in_omp_scope;
6625cdb5 221};
8d08fdba 222
4519c0a8 223#define named_labels cp_function_chain->x_named_labels
8d08fdba 224\f
b2244c65
MM
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.) */
228int function_depth;
e23bd218
IR
229
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
233 deprecated items. */
caf93cb0 234
e23bd218
IR
235enum deprecated_states {
236 DEPRECATED_NORMAL,
237 DEPRECATED_SUPPRESS
238};
239
240static enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
241
8d08fdba 242\f
0154eaa8
MM
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. */
246
e2500fed 247static GTY(()) tree incomplete_vars;
8d08fdba 248\f
74b846e0
MM
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. */
252
253tmpl_spec_kind
11f6b451 254current_tmpl_spec_kind (int n_class_scopes)
74b846e0
MM
255{
256 int n_template_parm_scopes = 0;
257 int seen_specialization_p = 0;
258 int innermost_specialization_p = 0;
e2500fed 259 struct cp_binding_level *b;
74b846e0
MM
260
261 /* Scan through the template parameter scopes. */
caf93cb0
EC
262 for (b = current_binding_level;
263 b->kind == sk_template_parms;
a7e8c268 264 b = b->level_chain)
74b846e0
MM
265 {
266 /* If we see a specialization scope inside a parameter scope,
267 then something is wrong. That corresponds to a declaration
268 like:
269
270 template <class T> template <> ...
271
0e339752 272 which is always invalid since [temp.expl.spec] forbids the
74b846e0
MM
273 specialization of a class member template if the enclosing
274 class templates are not explicitly specialized as well. */
a7e8c268 275 if (b->explicit_spec_p)
74b846e0
MM
276 {
277 if (n_template_parm_scopes == 0)
278 innermost_specialization_p = 1;
279 else
280 seen_specialization_p = 1;
281 }
282 else if (seen_specialization_p == 1)
283 return tsk_invalid_member_spec;
284
285 ++n_template_parm_scopes;
286 }
287
288 /* Handle explicit instantiations. */
289 if (processing_explicit_instantiation)
290 {
291 if (n_template_parm_scopes != 0)
292 /* We've seen a template parameter list during an explicit
293 instantiation. For example:
294
295 template <class T> template void f(int);
296
297 This is erroneous. */
298 return tsk_invalid_expl_inst;
299 else
300 return tsk_expl_inst;
301 }
302
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:
306
0cbd7506 307 template <class T> void R<T>::S<T>::f(int);
74b846e0 308
0e339752 309 This is invalid; there needs to be one set of template
74b846e0
MM
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:
315
0cbd7506 316 template <class T> void S<T>::f(int);
74b846e0 317
39a13be5 318 The `class T' matches the `S<T>', leaving no template headers
74b846e0
MM
319 corresponding to the `f'. */
320 return tsk_none;
321 else if (n_template_parm_scopes > n_class_scopes + 1)
322 /* We've got too many template headers. For example:
323
0cbd7506 324 template <> template <class T> void f (T);
74b846e0
MM
325
326 There need to be more enclosing classes. */
327 return tsk_excessive_parms;
328 else
329 /* This must be a template. It's of the form:
330
0cbd7506 331 template <class T> template <class U> void S<T>::f(U);
74b846e0
MM
332
333 This is a specialization if the innermost level was a
334 specialization; otherwise it's just a definition of the
335 template. */
336 return innermost_specialization_p ? tsk_expl_spec : tsk_template;
8d08fdba
MS
337}
338
74b846e0
MM
339/* Exit the current scope. */
340
341void
11f6b451 342finish_scope (void)
74b846e0
MM
343{
344 poplevel (0, 0, 0);
345}
346
acef433b
MM
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. */
349
350static void
11f6b451 351pop_label (tree label, tree old_value)
acef433b 352{
a7e8c268 353 if (!processing_template_decl)
acef433b 354 {
88848bde
MM
355 if (DECL_INITIAL (label) == NULL_TREE)
356 {
5b030314
NS
357 location_t location;
358
dee15844 359 error ("label %q+D used but not defined", label);
93409b8c 360 location = input_location; /* FIXME want (input_filename, (line)0) */
88848bde 361 /* Avoid crashing later. */
5b030314 362 define_label (location, DECL_NAME (label));
88848bde 363 }
c616e51b
MLI
364 else
365 warn_for_unused_label (label);
acef433b 366 }
acef433b 367
6625cdb5 368 SET_IDENTIFIER_LABEL_VALUE (DECL_NAME (label), old_value);
acef433b
MM
369}
370
0811ea8f 371/* At the end of a function, all labels declared within the function
68642fb6 372 go out of scope. BLOCK is the top-level block for the
acef433b
MM
373 function. */
374
1799e5d5
RH
375static int
376pop_labels_1 (void **slot, void *data)
377{
378 struct named_label_entry *ent = (struct named_label_entry *) *slot;
379 tree block = (tree) data;
380
381 pop_label (ent->label_decl, NULL_TREE);
382
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;
387
388 htab_clear_slot (named_labels, slot);
389
390 return 1;
391}
392
acef433b 393static void
11f6b451 394pop_labels (tree block)
acef433b 395{
1799e5d5 396 if (named_labels)
acef433b 397 {
1799e5d5
RH
398 htab_traverse (named_labels, pop_labels_1, block);
399 named_labels = NULL;
acef433b 400 }
1799e5d5
RH
401}
402
403/* At the end of a block with local labels, restore the outer definition. */
acef433b 404
1799e5d5
RH
405static void
406pop_local_label (tree label, tree old_value)
407{
408 struct named_label_entry dummy;
409 void **slot;
410
411 pop_label (label, old_value);
412
413 dummy.label_decl = label;
414 slot = htab_find_slot (named_labels, &dummy, NO_INSERT);
415 htab_clear_slot (named_labels, slot);
acef433b
MM
416}
417
80aa8340
ZL
418/* The following two routines are used to interface to Objective-C++.
419 The binding level is purposely treated as an opaque type. */
420
421void *
422objc_get_current_scope (void)
423{
424 return current_binding_level;
425}
426
427/* The following routine is used by the NeXT-style SJLJ exceptions;
428 variables get marked 'volatile' so as to not be clobbered by
f749f3c2
ZL
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. */
80aa8340
ZL
432
433void
434objc_mark_locals_volatile (void *enclosing_blk)
435{
436 struct cp_binding_level *scope;
437
438 for (scope = current_binding_level;
e58a9aa1 439 scope && scope != enclosing_blk;
80aa8340
ZL
440 scope = scope->level_chain)
441 {
442 tree decl;
443
444 for (decl = scope->names; decl; decl = TREE_CHAIN (decl))
660845bf 445 objc_volatilize_decl (decl);
e58a9aa1
ZL
446
447 /* Do not climb up past the current function. */
448 if (scope->kind == sk_function_parms)
449 break;
80aa8340
ZL
450 }
451}
452
1799e5d5
RH
453/* Update data for defined and undefined labels when leaving a scope. */
454
455static int
456poplevel_named_label_1 (void **slot, void *data)
457{
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;
461
462 if (ent->binding_level == bl)
463 {
464 tree decl;
465
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);
469
470 ent->binding_level = obl;
471 ent->names_in_scope = obl->names;
472 switch (bl->kind)
473 {
474 case sk_try:
475 ent->in_try_scope = true;
476 break;
477 case sk_catch:
478 ent->in_catch_scope = true;
479 break;
480 case sk_omp:
481 ent->in_omp_scope = true;
482 break;
483 default:
484 break;
485 }
486 }
487 else if (ent->uses)
488 {
489 struct named_label_use_entry *use;
490
491 for (use = ent->uses; use ; use = use->next)
492 if (use->binding_level == bl)
493 {
494 use->binding_level = obl;
495 use->names_in_scope = obl->names;
496 if (bl->kind == sk_omp)
497 use->in_omp_scope = true;
498 }
499 }
500
501 return 1;
502}
503
8d08fdba
MS
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.
507
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.
511
8d08fdba
MS
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
514 label names.
515
516 If REVERSE is nonzero, reverse the order of decls before putting
517 them into the BLOCK. */
518
519tree
11f6b451 520poplevel (int keep, int reverse, int functionbody)
8d08fdba 521{
926ce8bd 522 tree link;
8d08fdba
MS
523 /* The chain of decls was accumulated in reverse order.
524 Put it into forward order, just for cleanliness. */
525 tree decls;
526 int tmp = functionbody;
b35d4555 527 int real_functionbody;
b35d4555 528 tree subblocks;
325c3691 529 tree block;
8d08fdba 530 tree decl;
f181d4ae 531 int leaving_for_scope;
ac20c67a 532 scope_kind kind;
f181d4ae 533
22ffcc6f 534 timevar_push (TV_NAME_LOOKUP);
325c3691
RH
535 restart:
536
537 block = NULL_TREE;
b35d4555 538
50bc768d 539 gcc_assert (current_binding_level->kind != sk_class);
b74a0560 540
ac20c67a 541 real_functionbody = (current_binding_level->kind == sk_cleanup
b35d4555 542 ? ((functionbody = 0), tmp) : functionbody);
b35d4555
MM
543 subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
544
50bc768d
NS
545 gcc_assert (!VEC_length(cp_class_binding,
546 current_binding_level->class_shadowed));
8d08fdba 547
536333d4
MM
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. */
50bc768d 551 gcc_assert (keep == 0 || keep == 1);
536333d4 552
ac20c67a 553 if (current_binding_level->keep)
8d08fdba
MS
554 keep = 1;
555
6625cdb5
JM
556 /* Any uses of undefined labels, and any defined labels, now operate
557 under constraints of next binding contour. */
1799e5d5
RH
558 if (cfun && !functionbody && named_labels)
559 htab_traverse (named_labels, poplevel_named_label_1,
560 current_binding_level);
6625cdb5 561
8d08fdba
MS
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. */
565
566 if (reverse)
567 current_binding_level->names
568 = decls = nreverse (current_binding_level->names);
569 else
570 decls = current_binding_level->names;
571
8d08fdba
MS
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. */
8d08fdba 575 block = NULL_TREE;
f444e36b 576 if (keep == 1 || functionbody)
8d08fdba
MS
577 block = make_node (BLOCK);
578 if (block != NULL_TREE)
579 {
f444e36b
MM
580 BLOCK_VARS (block) = decls;
581 BLOCK_SUBBLOCKS (block) = subblocks;
8d08fdba
MS
582 }
583
584 /* In each subblock, record that this is its superior. */
8d08fdba 585 if (keep >= 0)
87caf699 586 for (link = subblocks; link; link = BLOCK_CHAIN (link))
8d08fdba
MS
587 BLOCK_SUPERCONTEXT (link) = block;
588
f181d4ae
MM
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
92bc1323 591 ended. We only use the new rules if flag_new_for_scope is
f181d4ae 592 nonzero. */
68642fb6 593 leaving_for_scope
a7e8c268 594 = current_binding_level->kind == sk_for && flag_new_for_scope == 1;
f181d4ae 595
caf93cb0
EC
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))
b323323f 604 warning (OPT_Wunused_variable, "unused variable %q+D", decl);
caf93cb0 605
f181d4ae
MM
606 /* Remove declarations for all the DECLs in this level. */
607 for (link = decls; link; link = TREE_CHAIN (link))
608 {
c3783399 609 if (leaving_for_scope && TREE_CODE (link) == VAR_DECL
0cbd7506 610 && DECL_NAME (link))
f181d4ae 611 {
90ea9897
MM
612 tree name = DECL_NAME (link);
613 cxx_binding *ob;
f181d4ae
MM
614 tree ns_binding;
615
90ea9897
MM
616 ob = outer_binding (name,
617 IDENTIFIER_BINDING (name),
618 /*class_p=*/true);
619 if (!ob)
620 ns_binding = IDENTIFIER_NAMESPACE_VALUE (name);
c7dda1e3
MM
621 else
622 ns_binding = NULL_TREE;
623
90ea9897 624 if (ob && ob->scope == current_binding_level->level_chain)
f181d4ae 625 /* We have something like:
68642fb6 626
0cbd7506
MS
627 int i;
628 for (int i; ;);
68642fb6 629
f181d4ae
MM
630 and we are leaving the `for' scope. There's no reason to
631 keep the binding of the inner `i' in this case. */
90ea9897
MM
632 pop_binding (name, link);
633 else if ((ob && (TREE_CODE (ob->value) == TYPE_DECL))
147135cc 634 || (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL))
f181d4ae
MM
635 /* Here, we have something like:
636
637 typedef int I;
638
639 void f () {
640 for (int I; ;);
641 }
642
643 We must pop the for-scope binding so we know what's a
644 type and what isn't. */
90ea9897 645 pop_binding (name, link);
e76a2646 646 else
e76a2646 647 {
f181d4ae
MM
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;
68642fb6 651
517f3315 652 /* Keep track of what should have happened when we
f181d4ae 653 popped the binding. */
90ea9897 654 if (ob && ob->value)
820cc88f
DB
655 {
656 SET_DECL_SHADOWED_FOR_VAR (link, ob->value);
657 DECL_HAS_SHADOWED_FOR_VAR_P (link) = 1;
658 }
f181d4ae
MM
659
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->
666 dead_vars_from_for);
667
af6fd53f 668 /* Although we don't pop the cxx_binding, we do clear
147135cc 669 its SCOPE since the scope is going away now. */
caf93cb0 670 IDENTIFIER_BINDING (name)->scope
90ea9897 671 = current_binding_level->level_chain;
e76a2646 672 }
2ee887f2 673 }
68642fb6 674 else
8d6e462b 675 {
8dc2b103 676 tree name;
c8094d83 677
f181d4ae 678 /* Remove the binding. */
0034cf72 679 decl = link;
caf93cb0 680
0034cf72
JM
681 if (TREE_CODE (decl) == TREE_LIST)
682 decl = TREE_VALUE (decl);
8dc2b103 683 name = decl;
c8094d83 684
8dc2b103
NS
685 if (TREE_CODE (name) == OVERLOAD)
686 name = OVL_FUNCTION (name);
caf93cb0 687
8dc2b103
NS
688 gcc_assert (DECL_P (name));
689 pop_binding (DECL_NAME (name), decl);
8d08fdba 690 }
f181d4ae 691 }
8d08fdba 692
f181d4ae
MM
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))
d8f8dca1 697 pop_binding (DECL_NAME (TREE_VALUE (link)), TREE_VALUE (link));
2ee887f2 698
f181d4ae
MM
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));
acef433b
MM
703
704 /* Restore the IDENTIFIER_LABEL_VALUEs for local labels. */
705 for (link = current_binding_level->shadowed_labels;
68642fb6 706 link;
acef433b 707 link = TREE_CHAIN (link))
1799e5d5 708 pop_local_label (TREE_VALUE (link), TREE_PURPOSE (link));
acef433b 709
f181d4ae
MM
710 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
711 list if a `using' declaration put them there. The debugging
3b426391 712 back ends won't understand OVERLOAD, so we remove them here.
f181d4ae
MM
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. */
716 if (block)
717 {
718 tree* d;
8d6e462b 719
a06d48ef
JM
720 for (d = &BLOCK_VARS (block); *d; )
721 {
722 if (TREE_CODE (*d) == TREE_LIST)
723 *d = TREE_CHAIN (*d);
724 else
725 d = &TREE_CHAIN (*d);
726 }
8d6e462b 727 }
8d08fdba
MS
728
729 /* If the level being exited is the top level of a function,
730 check over all the labels. */
8d08fdba
MS
731 if (functionbody)
732 {
acef433b
MM
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. */
8d08fdba 736 BLOCK_VARS (block) = 0;
acef433b 737 pop_labels (block);
8d08fdba
MS
738 }
739
ac20c67a 740 kind = current_binding_level->kind;
325c3691
RH
741 if (kind == sk_cleanup)
742 {
743 tree stmt;
744
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);
750 add_stmt (stmt);
751 }
8d08fdba 752
1a6daf15 753 leave_scope ();
8d08fdba 754 if (functionbody)
72c4a4ca
GK
755 {
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;
760 }
8d08fdba 761 else if (block)
f444e36b
MM
762 current_binding_level->blocks
763 = chainon (current_binding_level->blocks, block);
764
8d08fdba
MS
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. */
770 else if (subblocks)
536333d4
MM
771 current_binding_level->blocks
772 = chainon (current_binding_level->blocks, subblocks);
8d08fdba 773
d9b2d9da
MM
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". */
777 if (block)
778 TREE_USED (block) = 1;
779
325c3691 780 /* All temporary bindings created for cleanups are popped silently. */
ac20c67a 781 if (kind == sk_cleanup)
325c3691 782 goto restart;
8d08fdba 783
22ffcc6f 784 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, block);
8d08fdba
MS
785}
786
8d08fdba
MS
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. */
790
791void
11f6b451 792insert_block (tree block)
8d08fdba
MS
793{
794 TREE_USED (block) = 1;
795 current_binding_level->blocks
796 = chainon (current_binding_level->blocks, block);
797}
798
0aafb128
MM
799/* Walk all the namespaces contained NAMESPACE, including NAMESPACE
800 itself, calling F for each. The DATA is passed to F as well. */
801
00e8de68 802static int
be93747e 803walk_namespaces_r (tree name_space, walk_namespaces_fn f, void* data)
00e8de68
GDR
804{
805 int result = 0;
be93747e 806 tree current = NAMESPACE_LEVEL (name_space)->namespaces;
8d08fdba 807
be93747e 808 result |= (*f) (name_space, data);
8d08fdba 809
00e8de68
GDR
810 for (; current; current = TREE_CHAIN (current))
811 result |= walk_namespaces_r (current, f, data);
fc0e7bf5 812
00e8de68 813 return result;
5566b478
MS
814}
815
00e8de68
GDR
816/* Walk all the namespaces, calling F for each. The DATA is passed to
817 F as well. */
818
819int
820walk_namespaces (walk_namespaces_fn f, void* data)
5566b478 821{
00e8de68 822 return walk_namespaces_r (global_namespace, f, data);
8d08fdba
MS
823}
824
00e8de68
GDR
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. */
39c01e4c 828
00e8de68 829int
be93747e 830wrapup_globals_for_namespace (tree name_space, void* data)
39c01e4c 831{
be93747e 832 struct cp_binding_level *level = NAMESPACE_LEVEL (name_space);
9857866d
KH
833 VEC(tree,gc) *statics = level->static_decls;
834 tree *vec = VEC_address (tree, statics);
835 int len = VEC_length (tree, statics);
00e8de68 836 int last_time = (data != 0);
68642fb6 837
00e8de68 838 if (last_time)
39c01e4c 839 {
00e8de68 840 check_global_declarations (vec, len);
db5f8b93 841 emit_debug_global_declarations (vec, len);
00e8de68 842 return 0;
39c01e4c
MM
843 }
844
00e8de68
GDR
845 /* Write out any globals that need to be output. */
846 return wrapup_global_declarations (vec, len);
39c01e4c
MM
847}
848
00e8de68 849\f
9188c363
MM
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. */
854
855tree
11f6b451 856create_implicit_typedef (tree name, tree type)
9188c363
MM
857{
858 tree decl;
859
860 decl = build_decl (TYPE_DECL, name, type);
c727aa5e 861 DECL_ARTIFICIAL (decl) = 1;
9188c363
MM
862 /* There are other implicit type declarations, like the one *within*
863 a class that allows you to write `S::S'. We must distinguish
864 amongst these. */
865 SET_DECL_IMPLICIT_TYPEDEF_P (decl);
866 TYPE_NAME (type) = decl;
867
868 return decl;
869}
870
8e4ce833
JJ
871/* Remember a local name for name-mangling purposes. */
872
873static void
11f6b451 874push_local_name (tree decl)
8e4ce833
JJ
875{
876 size_t i, nelts;
877 tree t, name;
878
22ffcc6f 879 timevar_push (TV_NAME_LOOKUP);
8e4ce833
JJ
880
881 name = DECL_NAME (decl);
882
9acaf84a 883 nelts = VEC_length (tree, local_names);
8e4ce833
JJ
884 for (i = 0; i < nelts; i++)
885 {
9acaf84a 886 t = VEC_index (tree, local_names, i);
8e4ce833
JJ
887 if (DECL_NAME (t) == name)
888 {
889 if (!DECL_LANG_SPECIFIC (decl))
890 retrofit_lang_decl (decl);
e2500fed 891 DECL_LANG_SPECIFIC (decl)->decl_flags.u2sel = 1;
8e4ce833
JJ
892 if (DECL_LANG_SPECIFIC (t))
893 DECL_DISCRIMINATOR (decl) = DECL_DISCRIMINATOR (t) + 1;
894 else
895 DECL_DISCRIMINATOR (decl) = 1;
896
9acaf84a 897 VEC_replace (tree, local_names, i, decl);
de94b46c
KG
898 timevar_pop (TV_NAME_LOOKUP);
899 return;
8e4ce833
JJ
900 }
901 }
902
9acaf84a 903 VEC_safe_push (tree, gc, local_names, decl);
22ffcc6f 904 timevar_pop (TV_NAME_LOOKUP);
8e4ce833 905}
8d08fdba
MS
906\f
907/* Subroutine of duplicate_decls: return truthvalue of whether
908 or not types of these decls match.
909
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
912 `const int&'. */
e92cc029 913
6060a796 914int
11f6b451 915decls_match (tree newdecl, tree olddecl)
8d08fdba
MS
916{
917 int types_match;
918
347d73d7
ML
919 if (newdecl == olddecl)
920 return 1;
921
6b4b3deb
MM
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. */
925 return 0;
926
927 if (TREE_CODE (newdecl) == FUNCTION_DECL)
8d08fdba
MS
928 {
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);
933
4f1c5b7d 934 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
eb68cb58
MM
935 && ! (DECL_EXTERN_C_P (newdecl)
936 && DECL_EXTERN_C_P (olddecl)))
c5a6fc45
JM
937 return 0;
938
8d08fdba 939 if (TREE_CODE (f1) != TREE_CODE (f2))
0cbd7506 940 return 0;
8d08fdba 941
3bfdc719 942 if (same_type_p (TREE_TYPE (f1), TREE_TYPE (f2)))
8926095f 943 {
8b27e9ef
NS
944 if (p2 == NULL_TREE && DECL_EXTERN_C_P (olddecl)
945 && (DECL_BUILT_IN (olddecl)
946#ifndef NO_IMPLICIT_EXTERN_C
0cbd7506
MS
947 || (DECL_IN_SYSTEM_HEADER (newdecl) && !DECL_CLASS_SCOPE_P (newdecl))
948 || (DECL_IN_SYSTEM_HEADER (olddecl) && !DECL_CLASS_SCOPE_P (olddecl))
8b27e9ef
NS
949#endif
950 ))
a28e3c7f
MS
951 {
952 types_match = self_promoting_args_p (p1);
953 if (p1 == void_list_node)
954 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
955 }
8b27e9ef
NS
956#ifndef NO_IMPLICIT_EXTERN_C
957 else if (p1 == NULL_TREE
958 && (DECL_EXTERN_C_P (olddecl)
0cbd7506
MS
959 && DECL_IN_SYSTEM_HEADER (olddecl)
960 && !DECL_CLASS_SCOPE_P (olddecl))
8b27e9ef 961 && (DECL_EXTERN_C_P (newdecl)
0cbd7506
MS
962 && DECL_IN_SYSTEM_HEADER (newdecl)
963 && !DECL_CLASS_SCOPE_P (newdecl)))
a28e3c7f
MS
964 {
965 types_match = self_promoting_args_p (p2);
966 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
967 }
8b27e9ef 968#endif
8926095f 969 else
91063b51 970 types_match = compparms (p1, p2);
8926095f 971 }
8d08fdba
MS
972 else
973 types_match = 0;
974 }
6b4b3deb 975 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
51c184be 976 {
2bb5d995
JM
977 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl))
978 != TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)))
979 return 0;
980
ee935db4
MM
981 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
982 DECL_TEMPLATE_PARMS (olddecl)))
983 return 0;
984
f84b4be9 985 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
ee935db4
MM
986 types_match = same_type_p (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl)),
987 TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl)));
f84b4be9
JM
988 else
989 types_match = decls_match (DECL_TEMPLATE_RESULT (olddecl),
990 DECL_TEMPLATE_RESULT (newdecl));
51c184be 991 }
8d08fdba
MS
992 else
993 {
91a5bc9f
KL
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
ace4831d
MM
997 && CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
998 /* [dcl.link]
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
1002 the same object. */
1003 && !(DECL_EXTERN_C_P (olddecl) && DECL_EXTERN_C_P (newdecl)))
91a5bc9f
KL
1004 return 0;
1005
8d08fdba
MS
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;
a0a33927
MS
1010 else if (TREE_TYPE (newdecl) == NULL_TREE)
1011 types_match = 0;
8d08fdba 1012 else
96d84882
PB
1013 types_match = comptypes (TREE_TYPE (newdecl),
1014 TREE_TYPE (olddecl),
1015 COMPARE_REDECLARATION);
8d08fdba
MS
1016 }
1017
1018 return types_match;
1019}
1020
1021/* If NEWDECL is `static' and an `extern' was seen previously,
24f30ed4 1022 warn about it. OLDDECL is the previous declaration.
8d08fdba
MS
1023
1024 Note that this does not apply to the C++ case of declaring
1025 a variable `extern const' and then later `const'.
1026
8d08fdba
MS
1027 Don't complain about built-in functions, since they are beyond
1028 the user's control. */
1029
a5e6b29b 1030void
11f6b451 1031warn_extern_redeclared_static (tree newdecl, tree olddecl)
8d08fdba 1032{
24f30ed4
MM
1033 tree name;
1034
68642fb6 1035 if (TREE_CODE (newdecl) == TYPE_DECL
655dc6ee 1036 || TREE_CODE (newdecl) == TEMPLATE_DECL
a2a9e21c
GDR
1037 || TREE_CODE (newdecl) == CONST_DECL
1038 || TREE_CODE (newdecl) == NAMESPACE_DECL)
8d08fdba 1039 return;
68642fb6 1040
963d5758
MM
1041 /* Don't get confused by static member functions; that's a different
1042 use of `static'. */
1043 if (TREE_CODE (newdecl) == FUNCTION_DECL
1044 && DECL_STATIC_FUNCTION_P (newdecl))
1045 return;
8d08fdba 1046
24f30ed4
MM
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))
1050 return;
1051
1052 /* It's OK to declare a builtin function as `static'. */
1053 if (TREE_CODE (olddecl) == FUNCTION_DECL
1054 && DECL_ARTIFICIAL (olddecl))
1055 return;
1056
8d08fdba 1057 name = DECL_ASSEMBLER_NAME (newdecl);
37ec60ed
JW
1058 permerror ("%qD was declared %<extern%> and later %<static%>", newdecl);
1059 permerror ("previous declaration of %q+D", olddecl);
8d08fdba
MS
1060}
1061
e1f0e7a6
MM
1062/* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1063 function templates. If their exception specifications do not
b9704fc5 1064 match, issue a diagnostic. */
e1f0e7a6
MM
1065
1066static void
1067check_redeclaration_exception_specification (tree new_decl,
1068 tree old_decl)
1069{
1070 tree new_type;
1071 tree old_type;
1072 tree new_exceptions;
1073 tree old_exceptions;
1074
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);
1079
1080 /* [except.spec]
1081
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)
1088 && flag_exceptions
3db45ab5 1089 && !comp_except_specs (new_exceptions, old_exceptions,
e1f0e7a6
MM
1090 /*exact=*/true))
1091 {
1092 error ("declaration of %qF throws different exceptions", new_decl);
1093 error ("from previous declaration %q+F", old_decl);
1094 }
1095}
1096
3a47c4e4
AO
1097#define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1098 && lookup_attribute ("gnu_inline", \
1099 DECL_ATTRIBUTES (fn)))
1100
b1a19c7c
MM
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.
8d08fdba 1104
b1a19c7c 1105 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
d63d5d0c
ILT
1106 returned.
1107
1108 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
8d08fdba 1109
b1a19c7c 1110tree
d63d5d0c 1111duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend)
8d08fdba 1112{
8d08fdba 1113 unsigned olddecl_uid = DECL_UID (olddecl);
d63d5d0c 1114 int olddecl_friend = 0, types_match = 0, hidden_friend = 0;
0b60dfe3 1115 int new_defines_function = 0;
50b56799 1116 tree new_template;
5566b478
MS
1117
1118 if (newdecl == olddecl)
b1a19c7c 1119 return olddecl;
8d08fdba 1120
8926095f 1121 types_match = decls_match (newdecl, olddecl);
8d08fdba 1122
8d08fdba
MS
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
0b60dfe3 1127 about the same declaration, so just pretend the types match here. */
bd6dd845
MS
1128 if (TREE_TYPE (newdecl) == error_mark_node
1129 || TREE_TYPE (olddecl) == error_mark_node)
dc5395cc 1130 return error_mark_node;
68642fb6 1131
97055d5c
AO
1132 if (DECL_P (olddecl)
1133 && TREE_CODE (newdecl) == FUNCTION_DECL
1134 && TREE_CODE (olddecl) == FUNCTION_DECL
1135 && (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl)))
1136 {
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)))
1148 {
dee15844
JM
1149 warning (OPT_Wattributes, "function %q+D redeclared as inline",
1150 newdecl);
1151 warning (OPT_Wattributes, "previous declaration of %q+D "
1152 "with attribute noinline", olddecl);
97055d5c
AO
1153 }
1154 else if (DECL_DECLARED_INLINE_P (olddecl)
1155 && DECL_UNINLINABLE (newdecl)
1156 && lookup_attribute ("noinline", DECL_ATTRIBUTES (newdecl)))
1157 {
dee15844
JM
1158 warning (OPT_Wattributes, "function %q+D redeclared with "
1159 "attribute noinline", newdecl);
1160 warning (OPT_Wattributes, "previous declaration of %q+D was inline",
1161 olddecl);
97055d5c
AO
1162 }
1163 }
1164
a1c65f9f 1165 /* Check for redeclaration and other discrepancies. */
d22c8596 1166 if (TREE_CODE (olddecl) == FUNCTION_DECL
9f33663b
JM
1167 && DECL_ARTIFICIAL (olddecl))
1168 {
d63d5d0c 1169 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl));
9f33663b
JM
1170 if (TREE_CODE (newdecl) != FUNCTION_DECL)
1171 {
d63d5d0c
ILT
1172 /* Avoid warnings redeclaring built-ins which have not been
1173 explicitly declared. */
0cbd7506
MS
1174 if (DECL_ANTICIPATED (olddecl))
1175 return NULL_TREE;
d52e4867 1176
9f33663b
JM
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))
1181 {
b323323f
LM
1182 warning (OPT_Wshadow, "shadowing %s function %q#D",
1183 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
1184 olddecl);
9f33663b 1185 /* Discard the old built-in function. */
b1a19c7c 1186 return NULL_TREE;
9f33663b
JM
1187 }
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))
d4ee4d25 1191 warning (0, "library function %q#D redeclared as non-function %q#D",
0cbd7506 1192 olddecl, newdecl);
9f33663b
JM
1193 else
1194 {
2d01edd7
GDR
1195 error ("declaration of %q#D", newdecl);
1196 error ("conflicts with built-in declaration %q#D",
0cbd7506 1197 olddecl);
9f33663b 1198 }
b1a19c7c 1199 return NULL_TREE;
a4443a08 1200 }
9f33663b 1201 else if (!types_match)
8d08fdba 1202 {
d63d5d0c
ILT
1203 /* Avoid warnings redeclaring built-ins which have not been
1204 explicitly declared. */
0cbd7506 1205 if (DECL_ANTICIPATED (olddecl))
498c0f27
JJ
1206 {
1207 /* Deal with fileptr_type_node. FILE type is not known
1208 at the time we create the builtins. */
1209 tree t1, t2;
1210
1211 for (t1 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1212 t2 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1213 t1 || t2;
1214 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1215 if (!t1 || !t2)
1216 break;
1217 else if (TREE_VALUE (t2) == fileptr_type_node)
1218 {
1219 tree t = TREE_VALUE (t1);
1220
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)))
1226 {
1227 tree oldargs = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1228
1229 TYPE_ARG_TYPES (TREE_TYPE (olddecl))
1230 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1231 types_match = decls_match (newdecl, olddecl);
1232 if (types_match)
d63d5d0c
ILT
1233 return duplicate_decls (newdecl, olddecl,
1234 newdecl_is_friend);
498c0f27
JJ
1235 TYPE_ARG_TYPES (TREE_TYPE (olddecl)) = oldargs;
1236 }
1237 }
1238 else if (! same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1239 break;
1240 }
d52e4867 1241 else if ((DECL_EXTERN_C_P (newdecl)
7e99327d
MM
1242 && DECL_EXTERN_C_P (olddecl))
1243 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1244 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
a4443a08 1245 {
9f33663b
JM
1246 /* A near match; override the builtin. */
1247
1248 if (TREE_PUBLIC (newdecl))
a4443a08 1249 {
d4ee4d25
DD
1250 warning (0, "new declaration %q#D", newdecl);
1251 warning (0, "ambiguates built-in declaration %q#D",
0cbd7506 1252 olddecl);
a4443a08 1253 }
b323323f
LM
1254 else
1255 warning (OPT_Wshadow, "shadowing %s function %q#D",
0cbd7506
MS
1256 DECL_BUILT_IN (olddecl) ? "built-in" : "library",
1257 olddecl);
a4443a08 1258 }
9f33663b
JM
1259 else
1260 /* Discard the old built-in function. */
b1a19c7c 1261 return NULL_TREE;
04a9d080
RS
1262
1263 /* Replace the old RTL to avoid problems with inlining. */
84b8b0e0 1264 COPY_DECL_RTL (newdecl, olddecl);
8d08fdba 1265 }
d63d5d0c
ILT
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... */
10326855 1269 else if (DECL_ANTICIPATED (olddecl))
7072018e 1270 {
74869a85
NS
1271 tree type = TREE_TYPE (newdecl);
1272 tree attribs = (*targetm.merge_type_attributes)
1273 (TREE_TYPE (olddecl), type);
1274
e9525111 1275 type = cp_build_type_attribute_variant (type, attribs);
74869a85 1276 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = type;
7072018e 1277 }
68642fb6 1278
62bedd31
JJ
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
1287 && types_match)
1288 TREE_NOTHROW (built_in_decls [DECL_FUNCTION_CODE (olddecl)]) = 1;
1289
7e99327d
MM
1290 /* Whether or not the builtin can throw exceptions has no
1291 bearing on this declarator. */
1292 TREE_NOTHROW (olddecl) = 0;
1293
24f30ed4
MM
1294 if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
1295 {
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;
9bfadf57 1300
421844e7
MM
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. */
5d2ed28c 1304 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
84b8b0e0 1305 COPY_DECL_RTL (newdecl, olddecl);
24f30ed4 1306 }
39211cd5
MS
1307 }
1308 else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1309 {
6936461f
OW
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))
9ed182dc 1319 {
6936461f
OW
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))
1324 {
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. */
1330 return NULL_TREE;
1331 }
1332
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)))
1337 return NULL_TREE;
9ed182dc
JM
1338 }
1339
2d01edd7 1340 error ("%q#D redeclared as different kind of symbol", newdecl);
39211cd5
MS
1341 if (TREE_CODE (olddecl) == TREE_LIST)
1342 olddecl = TREE_VALUE (olddecl);
dee15844 1343 error ("previous declaration of %q+#D", olddecl);
39211cd5 1344
c0694c4b 1345 return error_mark_node;
8d08fdba 1346 }
8d08fdba
MS
1347 else if (!types_match)
1348 {
4f1c5b7d 1349 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
7bdbfa05
MM
1350 /* These are certainly not duplicate declarations; they're
1351 from different scopes. */
b1a19c7c 1352 return NULL_TREE;
7bdbfa05 1353
8926095f 1354 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
f0e01782
MS
1355 {
1356 /* The name of a class template may not be declared to refer to
1357 any other template, class, function, object, namespace, value,
e92cc029 1358 or type in the same scope. */
5566b478
MS
1359 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
1360 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
f0e01782 1361 {
2d01edd7 1362 error ("declaration of template %q#D", newdecl);
dee15844 1363 error ("conflicts with previous declaration %q+#D", olddecl);
f0e01782 1364 }
ec255269
MS
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))),
91063b51 1368 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
75650646 1369 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
b9201622
NS
1370 DECL_TEMPLATE_PARMS (olddecl))
1371 /* Template functions can be disambiguated by
1372 return type. */
1373 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
1374 TREE_TYPE (TREE_TYPE (olddecl))))
ec255269 1375 {
2d01edd7 1376 error ("new declaration %q#D", newdecl);
dee15844 1377 error ("ambiguates old declaration %q+#D", olddecl);
ec255269 1378 }
b1a19c7c 1379 return NULL_TREE;
f0e01782 1380 }
8926095f
MS
1381 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1382 {
eb68cb58 1383 if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
8926095f 1384 {
2d01edd7 1385 error ("declaration of C function %q#D conflicts with",
0cbd7506 1386 newdecl);
dee15844 1387 error ("previous declaration %q+#D here", olddecl);
8926095f 1388 }
00595019 1389 else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
91063b51 1390 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
700f8a87 1391 {
2d01edd7 1392 error ("new declaration %q#D", newdecl);
dee15844 1393 error ("ambiguates old declaration %q+#D", olddecl);
492b73bd 1394 return error_mark_node;
700f8a87
MS
1395 }
1396 else
b1a19c7c 1397 return NULL_TREE;
8926095f 1398 }
58ec3cc5 1399 else
8d08fdba 1400 {
2d01edd7 1401 error ("conflicting declaration %q#D", newdecl);
dee15844 1402 error ("%q+D has a previous declaration as %q#D", olddecl, olddecl);
0cbd7506 1403 return error_mark_node;
8d08fdba
MS
1404 }
1405 }
68642fb6 1406 else if (TREE_CODE (newdecl) == FUNCTION_DECL
75650646
MM
1407 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
1408 && (!DECL_TEMPLATE_INFO (newdecl)
68642fb6 1409 || (DECL_TI_TEMPLATE (newdecl)
75650646
MM
1410 != DECL_TI_TEMPLATE (olddecl))))
1411 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
1412 && (!DECL_TEMPLATE_INFO (olddecl)
68642fb6 1413 || (DECL_TI_TEMPLATE (olddecl)
75650646 1414 != DECL_TI_TEMPLATE (newdecl))))))
386b8a85
JM
1415 /* It's OK to have a template specialization and a non-template
1416 with the same type, or to have specializations of two
75650646
MM
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
0e339752 1421 specialize one of its methods. This situation is valid, but
75650646 1422 the declarations must be merged in the usual way. */
b1a19c7c 1423 return NULL_TREE;
68642fb6
UD
1424 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1425 && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
75650646
MM
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. */
b1a19c7c 1431 return NULL_TREE;
c30b4add
MM
1432 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1433 {
1434 /* In [namespace.alias] we have:
c8094d83 1435
0cbd7506 1436 In a declarative region, a namespace-alias-definition can be
c30b4add
MM
1437 used to redefine a namespace-alias declared in that declarative
1438 region to refer only to the namespace to which it already
1439 refers.
c8094d83 1440
c30b4add
MM
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)
c8094d83 1444 && (DECL_NAMESPACE_ALIAS (newdecl)
c30b4add
MM
1445 == DECL_NAMESPACE_ALIAS (olddecl)))
1446 return olddecl;
1447 /* [namespace.alias]
1448
0cbd7506 1449 A namespace-name or namespace-alias shall not be declared as
c30b4add
MM
1450 the name of any other entity in the same declarative region.
1451 A namespace-name defined at global scope shall not be
77880ae4 1452 declared as the name of any other entity in any global scope
c30b4add 1453 of the program. */
2d01edd7 1454 error ("declaration of namespace %qD conflicts with", newdecl);
dee15844 1455 error ("previous declaration of namespace %q+D here", olddecl);
c30b4add
MM
1456 return error_mark_node;
1457 }
8d08fdba
MS
1458 else
1459 {
d8e178a0 1460 const char *errmsg = redeclaration_error_message (newdecl, olddecl);
8251199e 1461 if (errmsg)
8d08fdba 1462 {
33bd39a2 1463 error (errmsg, newdecl);
8d08fdba 1464 if (DECL_NAME (olddecl) != NULL_TREE)
dee15844
JM
1465 error ((DECL_INITIAL (olddecl) && namespace_bindings_p ())
1466 ? "%q+#D previously defined here"
1467 : "%q+#D previously declared here", olddecl);
b1a19c7c 1468 return error_mark_node;
8d08fdba
MS
1469 }
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)
1474 {
1475 /* Prototype decl follows defn w/o prototype. */
dee15844 1476 warning (0, "prototype for %q+#D", newdecl);
d4ee4d25 1477 warning (0, "%Jfollows non-prototype definition here", olddecl);
8d08fdba 1478 }
ace4831d
MM
1479 else if ((TREE_CODE (olddecl) == FUNCTION_DECL
1480 || TREE_CODE (olddecl) == VAR_DECL)
8d08fdba 1481 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
8926095f 1482 {
ace4831d
MM
1483 /* [dcl.link]
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.
1494
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
1498 for this example:
1499
1500 namespace N {
1501 extern int i;
1502 extern "C" int i;
1503 }
1504
1505 which is clearly wrong. Therefore, we now treat objects
1506 like functions. */
46ccf50a 1507 if (current_lang_depth () == 0)
ace4831d
MM
1508 {
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));
1514 }
8926095f
MS
1515 else
1516 {
dee15844
JM
1517 error ("previous declaration of %q+#D with %qL linkage",
1518 olddecl, DECL_LANGUAGE (olddecl));
2d01edd7 1519 error ("conflicts with new declaration with %qL linkage",
0cbd7506 1520 DECL_LANGUAGE (newdecl));
8926095f
MS
1521 }
1522 }
e1cd6e56 1523
a6f02587 1524 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
c32381b1
JM
1525 ;
1526 else if (TREE_CODE (olddecl) == FUNCTION_DECL)
e1cd6e56
MS
1527 {
1528 tree t1 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1529 tree t2 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1530 int i = 1;
1531
1532 if (TREE_CODE (TREE_TYPE (newdecl)) == METHOD_TYPE)
1533 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2);
68642fb6 1534
e1cd6e56
MS
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))
1538 {
2507f3b5
RK
1539 if (1 == simple_cst_equal (TREE_PURPOSE (t1),
1540 TREE_PURPOSE (t2)))
e1cd6e56 1541 {
37ec60ed
JW
1542 permerror ("default argument given for parameter %d of %q#D",
1543 i, newdecl);
1544 permerror ("after previous specification in %q+#D", olddecl);
e1cd6e56
MS
1545 }
1546 else
1547 {
2d01edd7 1548 error ("default argument given for parameter %d of %q#D",
0cbd7506 1549 i, newdecl);
dee15844 1550 error ("after previous specification in %q+#D",
e1cd6e56
MS
1551 olddecl);
1552 }
1553 }
1554 }
8d08fdba
MS
1555 }
1556
4782bd5b
RS
1557 /* Do not merge an implicit typedef with an explicit one. In:
1558
1559 class A;
1560 ...
1561 typedef class A A __attribute__ ((foo));
1562
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)))
b1a19c7c 1567 return NULL_TREE;
4782bd5b 1568
8d08fdba
MS
1569 /* If new decl is `static' and an `extern' was seen previously,
1570 warn about it. */
1571 warn_extern_redeclared_static (newdecl, olddecl);
1572
e92cc029 1573 /* We have committed to returning 1 at this point. */
8d08fdba
MS
1574 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1575 {
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
1579 definition. */
1580 if (DECL_VINDEX (olddecl))
1581 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
1582 if (DECL_CONTEXT (olddecl))
1583 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
e1cd6e56
MS
1584 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
1585 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
fee7654e 1586 DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
864b83b9 1587 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
815951d8 1588 DECL_INVALID_OVERRIDER_P (newdecl) |= DECL_INVALID_OVERRIDER_P (olddecl);
963d5758 1589 DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
e0fff4b3
JM
1590 if (DECL_OVERLOADED_OPERATOR_P (olddecl) != ERROR_MARK)
1591 SET_OVERLOADED_OPERATOR_CODE
1592 (newdecl, DECL_OVERLOADED_OPERATOR_P (olddecl));
0b60dfe3 1593 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
68642fb6 1594
0b60dfe3 1595 /* Optionally warn about more than one declaration for the same
0cbd7506
MS
1596 name, but don't warn about a function declaration followed by a
1597 definition. */
0b60dfe3
BK
1598 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
1599 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
a1c65f9f 1600 /* Don't warn about extern decl followed by definition. */
0b60dfe3 1601 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
a1c65f9f 1602 /* Don't warn about friends, let add_friend take care of it. */
d63d5d0c 1603 && ! (newdecl_is_friend || DECL_FRIEND_P (olddecl)))
0b60dfe3 1604 {
b323323f
LM
1605 warning (OPT_Wredundant_decls, "redundant redeclaration of %qD in same scope", newdecl);
1606 warning (OPT_Wredundant_decls, "previous declaration of %q+D", olddecl);
0b60dfe3 1607 }
b87d79e6
JM
1608
1609 if (DECL_DELETED_FN (newdecl))
1610 {
1611 error ("deleted definition of %qD", newdecl);
1612 error ("after previous declaration %q+D", olddecl);
1613 }
8d08fdba
MS
1614 }
1615
1616 /* Deal with C++: must preserve virtual function table size. */
1617 if (TREE_CODE (olddecl) == TYPE_DECL)
1618 {
926ce8bd
KH
1619 tree newtype = TREE_TYPE (newdecl);
1620 tree oldtype = TREE_TYPE (olddecl);
8d08fdba
MS
1621
1622 if (newtype != error_mark_node && oldtype != error_mark_node
1623 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
e93ee644
MM
1624 CLASSTYPE_FRIEND_CLASSES (newtype)
1625 = CLASSTYPE_FRIEND_CLASSES (oldtype);
7df87825 1626
970d6386 1627 DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
8d08fdba
MS
1628 }
1629
8d08fdba
MS
1630 /* Copy all the DECL_... slots specified in the new decl
1631 except for any that we copy here from the old type. */
91d231cb 1632 DECL_ATTRIBUTES (newdecl)
f6897b10 1633 = (*targetm.merge_decl_attributes) (olddecl, newdecl);
8d08fdba 1634
5566b478
MS
1635 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1636 {
e1f0e7a6
MM
1637 tree old_result;
1638 tree new_result;
1639 old_result = DECL_TEMPLATE_RESULT (olddecl);
1640 new_result = DECL_TEMPLATE_RESULT (newdecl);
1641 TREE_TYPE (olddecl) = TREE_TYPE (old_result);
68642fb6 1642 DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
4d85e00e
MM
1643 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
1644 DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
68642fb6 1645
3a47c4e4
AO
1646 DECL_ATTRIBUTES (old_result)
1647 = (*targetm.merge_decl_attributes) (old_result, new_result);
1648
e1f0e7a6
MM
1649 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
1650 {
3a47c4e4
AO
1651 if (GNU_INLINE_P (old_result) != GNU_INLINE_P (new_result)
1652 && DECL_INITIAL (new_result))
1653 {
1654 if (DECL_INITIAL (old_result))
1655 {
1656 DECL_INLINE (old_result) = 0;
1657 DECL_UNINLINABLE (old_result) = 1;
1658 }
1659 else
1660 {
1661 DECL_INLINE (old_result) = DECL_INLINE (new_result);
1662 DECL_UNINLINABLE (old_result) = DECL_UNINLINABLE (new_result);
1663 }
1664 DECL_EXTERNAL (old_result) = DECL_EXTERNAL (new_result);
1665 DECL_NOT_REALLY_EXTERN (old_result)
1666 = DECL_NOT_REALLY_EXTERN (new_result);
1667 DECL_INTERFACE_KNOWN (old_result)
1668 = DECL_INTERFACE_KNOWN (new_result);
1669 DECL_DECLARED_INLINE_P (old_result)
1670 = DECL_DECLARED_INLINE_P (new_result);
1eea53df
AP
1671 DECL_DISREGARD_INLINE_LIMITS (old_result)
1672 |= DECL_DISREGARD_INLINE_LIMITS (new_result);
1673
3a47c4e4
AO
1674 }
1675 else
1676 {
1677 DECL_INLINE (old_result)
1678 |= DECL_INLINE (new_result);
1679 DECL_DECLARED_INLINE_P (old_result)
1680 |= DECL_DECLARED_INLINE_P (new_result);
1eea53df
AP
1681 DECL_DISREGARD_INLINE_LIMITS (old_result)
1682 |= DECL_DISREGARD_INLINE_LIMITS (new_result);
3a47c4e4
AO
1683 check_redeclaration_exception_specification (newdecl, olddecl);
1684 }
e1f0e7a6
MM
1685 }
1686
daa8df65 1687 /* If the new declaration is a definition, update the file and
72c4a4ca
GK
1688 line information on the declaration, and also make
1689 the old declaration the same definition. */
3a47c4e4 1690 if (DECL_INITIAL (new_result) != NULL_TREE)
daa8df65 1691 {
caf93cb0 1692 DECL_SOURCE_LOCATION (olddecl)
e1f0e7a6 1693 = DECL_SOURCE_LOCATION (old_result)
f31686a3 1694 = DECL_SOURCE_LOCATION (newdecl);
72c4a4ca 1695 DECL_INITIAL (old_result) = DECL_INITIAL (new_result);
26bcf8fc 1696 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
e1f0e7a6
MM
1697 DECL_ARGUMENTS (old_result)
1698 = DECL_ARGUMENTS (new_result);
c11889ce
MM
1699 }
1700
b1a19c7c 1701 return olddecl;
5566b478 1702 }
68642fb6 1703
8d08fdba
MS
1704 if (types_match)
1705 {
1706 /* Automatically handles default parameters. */
1707 tree oldtype = TREE_TYPE (olddecl);
e1cd6e56 1708 tree newtype;
8d08fdba 1709
e1cd6e56 1710 /* Merge the data types specified in the two decls. */
6da794e8 1711 newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
e1cd6e56 1712
6da794e8 1713 /* If merge_types produces a non-typedef type, just use the old type. */
9076e292
JM
1714 if (TREE_CODE (newdecl) == TYPE_DECL
1715 && newtype == DECL_ORIGINAL_TYPE (newdecl))
1716 newtype = oldtype;
1717
8d08fdba 1718 if (TREE_CODE (newdecl) == VAR_DECL)
17bbb839
MM
1719 {
1720 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
1721 DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
3db45ab5 1722 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl)
6c06fbce 1723 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl);
39703eb9
MM
1724 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl)
1725 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl);
1799e5d5
RH
1726
1727 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
1728 if (DECL_LANG_SPECIFIC (olddecl)
1729 && CP_DECL_THREADPRIVATE_P (olddecl))
1730 {
1731 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
1732 if (!DECL_LANG_SPECIFIC (newdecl))
1733 retrofit_lang_decl (newdecl);
1734
1735 DECL_TLS_MODEL (newdecl) = DECL_TLS_MODEL (olddecl);
1736 CP_DECL_THREADPRIVATE_P (newdecl) = 1;
1737 }
17bbb839
MM
1738 }
1739
6da794e8 1740 /* Do this after calling `merge_types' so that default
8d08fdba 1741 parameters don't confuse us. */
e1f0e7a6
MM
1742 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
1743 check_redeclaration_exception_specification (newdecl, olddecl);
8d08fdba
MS
1744 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
1745
4a2f6dc0
VR
1746 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1747 check_default_args (newdecl);
1748
8d08fdba 1749 /* Lay the type out, unless already done. */
407f03b8 1750 if (! same_type_p (newtype, oldtype)
5566b478 1751 && TREE_TYPE (newdecl) != error_mark_node
5156628f 1752 && !(processing_template_decl && uses_template_parms (newdecl)))
b7484fbe
MS
1753 layout_type (TREE_TYPE (newdecl));
1754
5566b478
MS
1755 if ((TREE_CODE (newdecl) == VAR_DECL
1756 || TREE_CODE (newdecl) == PARM_DECL
1757 || TREE_CODE (newdecl) == RESULT_DECL
1758 || TREE_CODE (newdecl) == FIELD_DECL
1759 || TREE_CODE (newdecl) == TYPE_DECL)
5156628f 1760 && !(processing_template_decl && uses_template_parms (newdecl)))
b7484fbe 1761 layout_decl (newdecl, 0);
8d08fdba
MS
1762
1763 /* Merge the type qualifiers. */
1764 if (TREE_READONLY (newdecl))
1765 TREE_READONLY (olddecl) = 1;
1766 if (TREE_THIS_VOLATILE (newdecl))
1767 TREE_THIS_VOLATILE (olddecl) = 1;
5cefa0d9
JM
1768 if (TREE_NOTHROW (newdecl))
1769 TREE_NOTHROW (olddecl) = 1;
8d08fdba 1770
302a2cc5
JM
1771 /* Merge deprecatedness. */
1772 if (TREE_DEPRECATED (newdecl))
1773 TREE_DEPRECATED (olddecl) = 1;
1774
8d08fdba 1775 /* Merge the initialization information. */
8926095f
MS
1776 if (DECL_INITIAL (newdecl) == NULL_TREE
1777 && DECL_INITIAL (olddecl) != NULL_TREE)
1778 {
1779 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
f31686a3 1780 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
b0d06515
MM
1781 if (CAN_HAVE_FULL_LANG_DECL_P (newdecl)
1782 && DECL_LANG_SPECIFIC (newdecl)
4d85e00e 1783 && DECL_LANG_SPECIFIC (olddecl))
69ee8086
RH
1784 {
1785 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
1da326c3 1786 DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
69ee8086 1787 }
8926095f 1788 }
39211cd5
MS
1789
1790 /* Merge the section attribute.
0cbd7506 1791 We want to issue an error if the sections conflict but that must be
39211cd5
MS
1792 done later in decl_attributes since we are called before attributes
1793 are assigned. */
1794 if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
1795 DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
1796
a157febd
GK
1797 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1798 {
1799 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
1800 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
1331d16f 1801 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
220a35cc 1802 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
220a35cc 1803 TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl);
1331d16f 1804 DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
1ea193c2 1805 DECL_IS_OPERATOR_NEW (newdecl) |= DECL_IS_OPERATOR_NEW (olddecl);
becfd6e5
KZ
1806 DECL_PURE_P (newdecl) |= DECL_PURE_P (olddecl);
1807 TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
1808 DECL_LOOPING_CONST_OR_PURE_P (newdecl)
1809 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl);
c740732f
MM
1810 /* Keep the old RTL. */
1811 COPY_DECL_RTL (olddecl, newdecl);
1812 }
caf93cb0 1813 else if (TREE_CODE (newdecl) == VAR_DECL
c740732f
MM
1814 && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
1815 {
1816 /* Keep the old RTL. We cannot keep the old RTL if the old
1817 declaration was for an incomplete object and the new
1818 declaration is not since many attributes of the RTL will
1819 change. */
1820 COPY_DECL_RTL (olddecl, newdecl);
a157febd 1821 }
8d08fdba
MS
1822 }
1823 /* If cannot merge, then use the new type and qualifiers,
1824 and don't preserve the old rtl. */
1825 else
1826 {
1827 /* Clean out any memory we had of the old declaration. */
1828 tree oldstatic = value_member (olddecl, static_aggregates);
1829 if (oldstatic)
1830 TREE_VALUE (oldstatic) = error_mark_node;
1831
1832 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
1833 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
1834 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
1835 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
1836 }
1837
1838 /* Merge the storage class information. */
45806a3f
FS
1839 merge_weak (newdecl, olddecl);
1840
e92cc029 1841 DECL_ONE_ONLY (newdecl) |= DECL_ONE_ONLY (olddecl);
794d4a61 1842 DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
a9aedbc2
MS
1843 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
1844 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
1845 if (! DECL_EXTERNAL (olddecl))
1846 DECL_EXTERNAL (newdecl) = 0;
68642fb6 1847
50b56799 1848 new_template = NULL_TREE;
0b60dfe3 1849 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
8d08fdba 1850 {
fea10e36
AO
1851 bool new_redefines_gnu_inline = false;
1852
1853 if (new_defines_function
1854 && ((DECL_INTERFACE_KNOWN (olddecl)
1855 && TREE_CODE (olddecl) == FUNCTION_DECL)
1856 || (TREE_CODE (olddecl) == TEMPLATE_DECL
1857 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
1858 == FUNCTION_DECL))))
3a47c4e4
AO
1859 {
1860 tree fn = olddecl;
1861
1862 if (TREE_CODE (fn) == TEMPLATE_DECL)
1863 fn = DECL_TEMPLATE_RESULT (olddecl);
1864
fea10e36 1865 new_redefines_gnu_inline = GNU_INLINE_P (fn) && DECL_INITIAL (fn);
3a47c4e4 1866 }
3a47c4e4 1867
fea10e36 1868 if (!new_redefines_gnu_inline)
3a47c4e4 1869 {
3a47c4e4
AO
1870 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
1871 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
1872 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
1873 }
68642fb6 1874 DECL_TEMPLATE_INSTANTIATED (newdecl)
2b0a63a3 1875 |= DECL_TEMPLATE_INSTANTIATED (olddecl);
c8094d83 1876
58fb06b4
NS
1877 /* If the OLDDECL is an instantiation and/or specialization,
1878 then the NEWDECL must be too. But, it may not yet be marked
1879 as such if the caller has created NEWDECL, but has not yet
1880 figured out that it is a redeclaration. */
1881 if (!DECL_USE_TEMPLATE (newdecl))
1882 DECL_USE_TEMPLATE (newdecl) = DECL_USE_TEMPLATE (olddecl);
c8094d83 1883
0b60dfe3
BK
1884 /* Don't really know how much of the language-specific
1885 values we should copy from old to new. */
1886 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
caf93cb0 1887 DECL_LANG_SPECIFIC (newdecl)->decl_flags.u2 =
e2500fed 1888 DECL_LANG_SPECIFIC (olddecl)->decl_flags.u2;
0b60dfe3 1889 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
4684cd27 1890 DECL_REPO_AVAILABLE_P (newdecl) = DECL_REPO_AVAILABLE_P (olddecl);
50b56799
MM
1891 if (DECL_TEMPLATE_INFO (newdecl))
1892 new_template = DECL_TI_TEMPLATE (newdecl);
fbf1c34b 1893 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
3febd123 1894 DECL_INITIALIZED_IN_CLASS_P (newdecl)
0cbd7506 1895 |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
0b60dfe3 1896 olddecl_friend = DECL_FRIEND_P (olddecl);
d63d5d0c
ILT
1897 hidden_friend = (DECL_ANTICIPATED (olddecl)
1898 && DECL_HIDDEN_FRIEND_P (olddecl)
1899 && newdecl_is_friend);
6a629cac
MM
1900
1901 /* Only functions have DECL_BEFRIENDING_CLASSES. */
1902 if (TREE_CODE (newdecl) == FUNCTION_DECL
1903 || DECL_FUNCTION_TEMPLATE_P (newdecl))
bb5e8a7f
MM
1904 {
1905 DECL_BEFRIENDING_CLASSES (newdecl)
1906 = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
1907 DECL_BEFRIENDING_CLASSES (olddecl));
ca9e1382
KL
1908 /* DECL_THUNKS is only valid for virtual functions,
1909 otherwise it is a DECL_FRIEND_CONTEXT. */
1910 if (DECL_VIRTUAL_P (newdecl))
1911 DECL_THUNKS (newdecl) = DECL_THUNKS (olddecl);
bb5e8a7f 1912 }
8d08fdba
MS
1913 }
1914
8d08fdba
MS
1915 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1916 {
68642fb6
UD
1917 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
1918 && !DECL_TEMPLATE_INSTANTIATION (newdecl))
75650646
MM
1919 {
1920 /* If newdecl is not a specialization, then it is not a
1921 template-related function at all. And that means that we
bf7c02dd 1922 should have exited above, returning 0. */
50bc768d 1923 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl));
75650646 1924
68642fb6 1925 if (TREE_USED (olddecl))
75650646 1926 /* From [temp.expl.spec]:
68642fb6 1927
75650646
MM
1928 If a template, a member template or the member of a class
1929 template is explicitly specialized then that
1930 specialization shall be declared before the first use of
1931 that specialization that would cause an implicit
1932 instantiation to take place, in every translation unit in
1933 which such a use occurs. */
9e637a26 1934 error ("explicit specialization of %qD after first use",
75650646
MM
1935 olddecl);
1936
1937 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
d03d18e8 1938
b9e75696
JM
1939 /* Don't propagate visibility from the template to the
1940 specialization here. We'll do that in determine_visibility if
1941 appropriate. */
1942 DECL_VISIBILITY_SPECIFIED (olddecl) = 0;
1943
d03d18e8
KL
1944 /* [temp.expl.spec/14] We don't inline explicit specialization
1945 just because the primary template says so. */
75650646 1946 }
3a47c4e4
AO
1947 else if (new_defines_function && DECL_INITIAL (olddecl))
1948 {
7e8b322a
JH
1949 /* Never inline re-defined extern inline functions.
1950 FIXME: this could be better handled by keeping both
1951 function as separate declarations. */
3a47c4e4
AO
1952 DECL_INLINE (newdecl) = 0;
1953 DECL_UNINLINABLE (newdecl) = 1;
1954 }
d03d18e8
KL
1955 else
1956 {
1957 if (DECL_PENDING_INLINE_INFO (newdecl) == 0)
1958 DECL_PENDING_INLINE_INFO (newdecl) = DECL_PENDING_INLINE_INFO (olddecl);
faae18ab 1959
d03d18e8 1960 DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
faae18ab 1961
caf93cb0 1962 /* If either decl says `inline', this fn is inline, unless
d03d18e8
KL
1963 its definition was passed already. */
1964 if (DECL_INLINE (newdecl) && DECL_INITIAL (olddecl) == NULL_TREE)
1965 DECL_INLINE (olddecl) = 1;
1966 DECL_INLINE (newdecl) = DECL_INLINE (olddecl);
1967
1968 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
1969 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
c536a6a7
RG
1970
1971 DECL_DISREGARD_INLINE_LIMITS (newdecl)
1972 = DECL_DISREGARD_INLINE_LIMITS (olddecl)
1973 = (DECL_DISREGARD_INLINE_LIMITS (newdecl)
1974 || DECL_DISREGARD_INLINE_LIMITS (olddecl));
d03d18e8 1975 }
97055d5c 1976
5daf7c0a
JM
1977 /* Preserve abstractness on cloned [cd]tors. */
1978 DECL_ABSTRACT (newdecl) = DECL_ABSTRACT (olddecl);
1979
700f8a87
MS
1980 if (! types_match)
1981 {
5d2ed28c 1982 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
92643fea 1983 COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
84b8b0e0 1984 COPY_DECL_RTL (newdecl, olddecl);
5566b478
MS
1985 }
1986 if (! types_match || new_defines_function)
1987 {
6f1b4c42
JM
1988 /* These need to be copied so that the names are available.
1989 Note that if the types do match, we'll preserve inline
1990 info and other bits, but if not, we won't. */
700f8a87
MS
1991 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
1992 DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
700f8a87 1993 }
8d08fdba
MS
1994 if (new_defines_function)
1995 /* If defining a function declared with other language
1996 linkage, use the previously declared language linkage. */
5d2ed28c 1997 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
6f1b4c42 1998 else if (types_match)
8d08fdba
MS
1999 {
2000 /* If redeclaring a builtin function, and not a definition,
2001 it stays built in. */
2002 if (DECL_BUILT_IN (olddecl))
2003 {
26db82d8 2004 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
39211cd5 2005 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
8d08fdba
MS
2006 /* If we're keeping the built-in definition, keep the rtl,
2007 regardless of declaration matches. */
84b8b0e0 2008 COPY_DECL_RTL (olddecl, newdecl);
8d08fdba 2009 }
8d08fdba
MS
2010
2011 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
8d08fdba
MS
2012 /* Don't clear out the arguments if we're redefining a function. */
2013 if (DECL_ARGUMENTS (olddecl))
2014 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
2015 }
2016 }
0b1161fc
MM
2017 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
2018 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
a9aedbc2 2019
8d08fdba
MS
2020 /* Now preserve various other info from the definition. */
2021 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
2022 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
2023 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
92643fea 2024 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
8d08fdba 2025
d7afec4b 2026 /* Warn about conflicting visibility specifications. */
c8094d83 2027 if (DECL_VISIBILITY_SPECIFIED (olddecl)
73a8adb6 2028 && DECL_VISIBILITY_SPECIFIED (newdecl)
d7afec4b
ND
2029 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
2030 {
dee15844
JM
2031 warning (OPT_Wattributes, "%q+D: visibility attribute ignored "
2032 "because it", newdecl);
5c498b10
DD
2033 warning (OPT_Wattributes, "%Jconflicts with previous "
2034 "declaration here", olddecl);
d7afec4b
ND
2035 }
2036 /* Choose the declaration which specified visibility. */
2037 if (DECL_VISIBILITY_SPECIFIED (olddecl))
facef326 2038 {
facef326 2039 DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
d7afec4b
ND
2040 DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
2041 }
3db45ab5 2042 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
820cc88f
DB
2043 so keep this behavior. */
2044 if (TREE_CODE (newdecl) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (newdecl))
2045 {
2046 SET_DECL_INIT_PRIORITY (olddecl, DECL_INIT_PRIORITY (newdecl));
2047 DECL_HAS_INIT_PRIORITY_P (olddecl) = 1;
2048 }
facef326 2049
1d786913
MM
2050 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2051 with that from NEWDECL below. */
2052 if (DECL_LANG_SPECIFIC (olddecl))
2053 {
c8094d83 2054 gcc_assert (DECL_LANG_SPECIFIC (olddecl)
1d786913
MM
2055 != DECL_LANG_SPECIFIC (newdecl));
2056 ggc_free (DECL_LANG_SPECIFIC (olddecl));
2057 }
2058
8d08fdba
MS
2059 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2060 {
2061 int function_size;
8d08fdba 2062
820cc88f 2063 function_size = sizeof (struct tree_decl_common);
8d08fdba 2064
730e1556
KG
2065 memcpy ((char *) olddecl + sizeof (struct tree_common),
2066 (char *) newdecl + sizeof (struct tree_common),
2067 function_size - sizeof (struct tree_common));
8d08fdba 2068
820cc88f
DB
2069 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2070 (char *) newdecl + sizeof (struct tree_decl_common),
2071 sizeof (struct tree_function_decl) - sizeof (struct tree_decl_common));
50b56799 2072 if (new_template)
b3445994
MM
2073 /* If newdecl is a template instantiation, it is possible that
2074 the following sequence of events has occurred:
2075
2076 o A friend function was declared in a class template. The
2077 class template was instantiated.
2078
2079 o The instantiation of the friend declaration was
2080 recorded on the instantiation list, and is newdecl.
2081
2082 o Later, however, instantiate_class_template called pushdecl
2083 on the newdecl to perform name injection. But, pushdecl in
2084 turn called duplicate_decls when it discovered that another
2085 declaration of a global function with the same name already
2086 existed.
2087
2088 o Here, in duplicate_decls, we decided to clobber newdecl.
2089
2090 If we're going to do that, we'd better make sure that
2091 olddecl, and not newdecl, is on the list of
2092 instantiations so that if we try to do the instantiation
2093 again we won't get the clobbered declaration. */
caf93cb0 2094 reregister_specialization (newdecl,
50b56799 2095 new_template,
b3445994 2096 olddecl);
8d08fdba
MS
2097 }
2098 else
2099 {
820cc88f 2100 size_t size = tree_code_size (TREE_CODE (olddecl));
730e1556
KG
2101 memcpy ((char *) olddecl + sizeof (struct tree_common),
2102 (char *) newdecl + sizeof (struct tree_common),
820cc88f 2103 sizeof (struct tree_decl_common) - sizeof (struct tree_common));
3db45ab5 2104 switch (TREE_CODE (olddecl))
820cc88f
DB
2105 {
2106 case LABEL_DECL:
2107 case VAR_DECL:
2108 case RESULT_DECL:
2109 case PARM_DECL:
2110 case FIELD_DECL:
2111 case TYPE_DECL:
2112 case CONST_DECL:
2113 {
2114 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2115 (char *) newdecl + sizeof (struct tree_decl_common),
2116 size - sizeof (struct tree_decl_common)
2117 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2118 }
2119 break;
2120 default:
2121 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2122 (char *) newdecl + sizeof (struct tree_decl_common),
2123 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common)
2124 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2125 break;
2126 }
8d08fdba 2127 }
8d08fdba
MS
2128 DECL_UID (olddecl) = olddecl_uid;
2129 if (olddecl_friend)
2130 DECL_FRIEND_P (olddecl) = 1;
d63d5d0c
ILT
2131 if (hidden_friend)
2132 {
2133 DECL_ANTICIPATED (olddecl) = 1;
2134 DECL_HIDDEN_FRIEND_P (olddecl) = 1;
2135 }
8d08fdba 2136
d9525bec
BK
2137 /* NEWDECL contains the merged attribute lists.
2138 Update OLDDECL to be the same. */
91d231cb 2139 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
d9525bec 2140
16e31964
DS
2141 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2142 so that encode_section_info has a chance to look at the new decl
2143 flags and attributes. */
caf93cb0 2144 if (DECL_RTL_SET_P (olddecl)
16e31964
DS
2145 && (TREE_CODE (olddecl) == FUNCTION_DECL
2146 || (TREE_CODE (olddecl) == VAR_DECL
2147 && TREE_STATIC (olddecl))))
0e6df31e 2148 make_decl_rtl (olddecl);
16e31964 2149
1d786913
MM
2150 /* The NEWDECL will no longer be needed. Because every out-of-class
2151 declaration of a member results in a call to duplicate_decls,
2152 freeing these nodes represents in a significant savings. */
2153 ggc_free (newdecl);
2154
b1a19c7c 2155 return olddecl;
8d08fdba 2156}
8d08fdba 2157\f
8251199e 2158/* Return zero if the declaration NEWDECL is valid
8d08fdba
MS
2159 when the declaration OLDDECL (assumed to be for the same name)
2160 has already been seen.
2161 Otherwise return an error message format string with a %s
2162 where the identifier should go. */
2163
d8e178a0 2164static const char *
11f6b451 2165redeclaration_error_message (tree newdecl, tree olddecl)
8d08fdba
MS
2166{
2167 if (TREE_CODE (newdecl) == TYPE_DECL)
2168 {
2169 /* Because C++ can put things into name space for free,
2170 constructs like "typedef struct foo { ... } foo"
2171 would look like an erroneous redeclaration. */
3bfdc719 2172 if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
6aed477a 2173 return NULL;
8d08fdba 2174 else
2d01edd7 2175 return "redefinition of %q#D";
8d08fdba
MS
2176 }
2177 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
2178 {
2179 /* If this is a pure function, its olddecl will actually be
2180 the original initialization to `0' (which we force to call
2181 abort()). Don't complain about redefinition in this case. */
d1fc3bbd
AO
2182 if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl)
2183 && DECL_INITIAL (olddecl) == NULL_TREE)
6aed477a 2184 return NULL;
8d08fdba 2185
2c73f9f5 2186 /* If both functions come from different namespaces, this is not
a1c65f9f 2187 a redeclaration - this is a conflict with a used function. */
6eb3bb27 2188 if (DECL_NAMESPACE_SCOPE_P (olddecl)
713101a6
AO
2189 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl)
2190 && ! decls_match (olddecl, newdecl))
2d01edd7 2191 return "%qD conflicts with used function";
2c73f9f5 2192
db5ae43f 2193 /* We'll complain about linkage mismatches in
0cbd7506 2194 warn_extern_redeclared_static. */
db5ae43f 2195
2c73f9f5 2196 /* Defining the same name twice is no good. */
8d08fdba 2197 if (DECL_INITIAL (olddecl) != NULL_TREE
faae18ab 2198 && DECL_INITIAL (newdecl) != NULL_TREE)
8d08fdba
MS
2199 {
2200 if (DECL_NAME (olddecl) == NULL_TREE)
2d01edd7 2201 return "%q#D not declared in class";
3a47c4e4
AO
2202 else if (!GNU_INLINE_P (olddecl)
2203 || GNU_INLINE_P (newdecl))
2d01edd7 2204 return "redefinition of %q#D";
8d08fdba 2205 }
3a47c4e4
AO
2206
2207 if (DECL_DECLARED_INLINE_P (olddecl) && DECL_DECLARED_INLINE_P (newdecl))
2208 {
2209 bool olda = GNU_INLINE_P (olddecl);
2210 bool newa = GNU_INLINE_P (newdecl);
2211
2212 if (olda != newa)
2213 {
2214 if (newa)
2215 return "%q+D redeclared inline with %<gnu_inline%> attribute";
2216 else
2217 return "%q+D redeclared inline without %<gnu_inline%> attribute";
2218 }
2219 }
2220
6aed477a 2221 return NULL;
8d08fdba 2222 }
51c184be
MS
2223 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2224 {
5bd61841
MM
2225 tree nt, ot;
2226
2227 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2228 {
2229 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl))
2230 && COMPLETE_TYPE_P (TREE_TYPE (olddecl)))
2d01edd7 2231 return "redefinition of %q#D";
5bd61841
MM
2232 return NULL;
2233 }
2234
2235 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL
caf93cb0 2236 || (DECL_TEMPLATE_RESULT (newdecl)
5bd61841
MM
2237 == DECL_TEMPLATE_RESULT (olddecl)))
2238 return NULL;
2239
2240 nt = DECL_TEMPLATE_RESULT (newdecl);
2241 if (DECL_TEMPLATE_INFO (nt))
2242 nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt));
2243 ot = DECL_TEMPLATE_RESULT (olddecl);
2244 if (DECL_TEMPLATE_INFO (ot))
2245 ot = DECL_TEMPLATE_RESULT (template_for_substitution (ot));
3a47c4e4
AO
2246 if (DECL_INITIAL (nt) && DECL_INITIAL (ot)
2247 && (!GNU_INLINE_P (ot) || GNU_INLINE_P (nt)))
2d01edd7 2248 return "redefinition of %q#D";
5bd61841 2249
3a47c4e4
AO
2250 if (DECL_DECLARED_INLINE_P (ot) && DECL_DECLARED_INLINE_P (nt))
2251 {
2252 bool olda = GNU_INLINE_P (ot);
2253 bool newa = GNU_INLINE_P (nt);
2254
2255 if (olda != newa)
2256 {
2257 if (newa)
2258 return "%q+D redeclared inline with %<gnu_inline%> attribute";
2259 else
2260 return "%q+D redeclared inline without %<gnu_inline%> attribute";
2261 }
2262 }
2263
9b7dd5e8
DG
2264 /* Core issue #226 (C++0x):
2265
2266 If a friend function template declaration specifies a
2267 default template-argument, that declaration shall be a
2268 definition and shall be the only declaration of the
2269 function template in the translation unit. */
c1ae8be5 2270 if ((cxx_dialect != cxx98)
9b7dd5e8
DG
2271 && TREE_CODE (ot) == FUNCTION_DECL && DECL_FRIEND_P (ot)
2272 && !check_default_tmpl_args (nt, DECL_TEMPLATE_PARMS (newdecl),
2273 /*is_primary=*/1, /*is_partial=*/0,
2274 /*is_friend_decl=*/2))
2275 return "redeclaration of friend %q#D may not have default template arguments";
2276
5bd61841 2277 return NULL;
51c184be 2278 }
31a79236 2279 else if (TREE_CODE (newdecl) == VAR_DECL
1799e5d5
RH
2280 && DECL_THREAD_LOCAL_P (newdecl) != DECL_THREAD_LOCAL_P (olddecl)
2281 && (! DECL_LANG_SPECIFIC (olddecl)
2282 || ! CP_DECL_THREADPRIVATE_P (olddecl)
2283 || DECL_THREAD_LOCAL_P (newdecl)))
31a79236
JJ
2284 {
2285 /* Only variables can be thread-local, and all declarations must
2286 agree on this property. */
2287 if (DECL_THREAD_LOCAL_P (newdecl))
2288 return "thread-local declaration of %q#D follows "
2289 "non-thread-local declaration";
2290 else
2291 return "non-thread-local declaration of %q#D follows "
2292 "thread-local declaration";
2293 }
1f51a992 2294 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
8d08fdba 2295 {
555551c2
MM
2296 /* The objects have been declared at namespace scope. If either
2297 is a member of an anonymous union, then this is an invalid
2298 redeclaration. For example:
2299
2300 int i;
2301 union { int i; };
2302
2303 is invalid. */
aedfac0e
PC
2304 if ((TREE_CODE (newdecl) == VAR_DECL && DECL_ANON_UNION_VAR_P (newdecl))
2305 || (TREE_CODE (olddecl) == VAR_DECL && DECL_ANON_UNION_VAR_P (olddecl)))
555551c2
MM
2306 return "redeclaration of %q#D";
2307 /* If at least one declaration is a reference, there is no
2308 conflict. For example:
2309
2310 int i = 3;
2311 extern int i;
2312
2313 is valid. */
8d08fdba 2314 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
6aed477a 2315 return NULL;
8926095f 2316 /* Reject two definitions. */
2d01edd7 2317 return "redefinition of %q#D";
8d08fdba
MS
2318 }
2319 else
2320 {
2321 /* Objects declared with block scope: */
2322 /* Reject two definitions, and reject a definition
2323 together with an external reference. */
2324 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
2d01edd7 2325 return "redeclaration of %q#D";
6aed477a 2326 return NULL;
8d08fdba
MS
2327 }
2328}
2329\f
1799e5d5
RH
2330/* Hash and equality functions for the named_label table. */
2331
2332static hashval_t
2333named_label_entry_hash (const void *data)
2334{
2335 const struct named_label_entry *ent = (const struct named_label_entry *) data;
2336 return DECL_UID (ent->label_decl);
2337}
2338
2339static int
2340named_label_entry_eq (const void *a, const void *b)
2341{
2342 const struct named_label_entry *ent_a = (const struct named_label_entry *) a;
2343 const struct named_label_entry *ent_b = (const struct named_label_entry *) b;
2344 return ent_a->label_decl == ent_b->label_decl;
2345}
2346
acef433b 2347/* Create a new label, named ID. */
8d08fdba 2348
acef433b 2349static tree
11f6b451 2350make_label_decl (tree id, int local_p)
8d08fdba 2351{
1799e5d5
RH
2352 struct named_label_entry *ent;
2353 void **slot;
acef433b 2354 tree decl;
8d08fdba 2355
acef433b 2356 decl = build_decl (LABEL_DECL, id, void_type_node);
acef433b
MM
2357
2358 DECL_CONTEXT (decl) = current_function_decl;
2359 DECL_MODE (decl) = VOIDmode;
2360 C_DECLARED_LABEL_FLAG (decl) = local_p;
8d08fdba 2361
acef433b
MM
2362 /* Say where one reference is to the label, for the sake of the
2363 error if it is not defined. */
f31686a3 2364 DECL_SOURCE_LOCATION (decl) = input_location;
acef433b
MM
2365
2366 /* Record the fact that this identifier is bound to this label. */
2367 SET_IDENTIFIER_LABEL_VALUE (id, decl);
2368
1799e5d5
RH
2369 /* Create the label htab for the function on demand. */
2370 if (!named_labels)
2371 named_labels = htab_create_ggc (13, named_label_entry_hash,
2372 named_label_entry_eq, NULL);
6625cdb5 2373
1799e5d5
RH
2374 /* Record this label on the list of labels used in this function.
2375 We do this before calling make_label_decl so that we get the
2376 IDENTIFIER_LABEL_VALUE before the new label is declared. */
2377 ent = GGC_CNEW (struct named_label_entry);
2378 ent->label_decl = decl;
6625cdb5 2379
1799e5d5
RH
2380 slot = htab_find_slot (named_labels, ent, INSERT);
2381 gcc_assert (*slot == NULL);
2382 *slot = ent;
2383
2384 return decl;
acef433b 2385}
8d08fdba 2386
acef433b
MM
2387/* Look for a label named ID in the current function. If one cannot
2388 be found, create one. (We keep track of used, but undefined,
2389 labels, and complain about them at the end of a function.) */
8d08fdba 2390
68642fb6 2391tree
11f6b451 2392lookup_label (tree id)
acef433b
MM
2393{
2394 tree decl;
8d08fdba 2395
22ffcc6f 2396 timevar_push (TV_NAME_LOOKUP);
acef433b
MM
2397 /* You can't use labels at global scope. */
2398 if (current_function_decl == NULL_TREE)
2399 {
2d01edd7 2400 error ("label %qE referenced outside of any function", id);
22ffcc6f 2401 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
acef433b 2402 }
68642fb6 2403
acef433b
MM
2404 /* See if we've already got this label. */
2405 decl = IDENTIFIER_LABEL_VALUE (id);
2406 if (decl != NULL_TREE && DECL_CONTEXT (decl) == current_function_decl)
22ffcc6f 2407 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
8d08fdba 2408
acef433b 2409 decl = make_label_decl (id, /*local_p=*/0);
22ffcc6f 2410 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
8d08fdba
MS
2411}
2412
acef433b 2413/* Declare a local label named ID. */
8d08fdba
MS
2414
2415tree
11f6b451 2416declare_local_label (tree id)
8d08fdba 2417{
1799e5d5 2418 tree decl, shadow;
8d08fdba 2419
acef433b 2420 /* Add a new entry to the SHADOWED_LABELS list so that when we leave
1799e5d5
RH
2421 this scope we can restore the old value of IDENTIFIER_TYPE_VALUE. */
2422 shadow = tree_cons (IDENTIFIER_LABEL_VALUE (id), NULL_TREE,
2423 current_binding_level->shadowed_labels);
2424 current_binding_level->shadowed_labels = shadow;
2425
acef433b 2426 decl = make_label_decl (id, /*local_p=*/1);
1799e5d5 2427 TREE_VALUE (shadow) = decl;
68642fb6 2428
acef433b 2429 return decl;
8d08fdba
MS
2430}
2431
6625cdb5
JM
2432/* Returns nonzero if it is ill-formed to jump past the declaration of
2433 DECL. Returns 2 if it's also a real problem. */
2434
2435static int
11f6b451 2436decl_jump_unsafe (tree decl)
6625cdb5 2437{
b88b7ced
AP
2438 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl)
2439 || TREE_TYPE (decl) == error_mark_node)
6625cdb5
JM
2440 return 0;
2441
6c06fbce
MM
2442 if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
2443 || DECL_NONTRIVIALLY_INITIALIZED_P (decl))
2444 return 2;
2445
2446 if (pod_type_p (TREE_TYPE (decl)))
6625cdb5
JM
2447 return 0;
2448
6c06fbce 2449 /* The POD stuff is just pedantry; why should it matter if the class
6625cdb5 2450 contains a field of pointer to member type? */
6625cdb5
JM
2451 return 1;
2452}
2453
1799e5d5
RH
2454/* A subroutine of check_previous_goto_1 to identify a branch to the user. */
2455
2456static void
2457identify_goto (tree decl, const location_t *locus)
2458{
2459 if (decl)
37ec60ed 2460 permerror ("jump to label %qD", decl);
1799e5d5 2461 else
37ec60ed 2462 permerror ("jump to case label");
1799e5d5 2463 if (locus)
37ec60ed 2464 permerror ("%H from here", locus);
1799e5d5
RH
2465}
2466
6625cdb5
JM
2467/* Check that a single previously seen jump to a newly defined label
2468 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
2469 the jump context; NAMES are the names in scope in LEVEL at the jump
3db45ab5 2470 context; LOCUS is the source position of the jump or 0. Returns
1799e5d5 2471 true if all is well. */
6625cdb5 2472
1799e5d5
RH
2473static bool
2474check_previous_goto_1 (tree decl, struct cp_binding_level* level, tree names,
2475 bool exited_omp, const location_t *locus)
2476{
2477 struct cp_binding_level *b;
2478 bool identified = false, saw_eh = false, saw_omp = false;
2479
2480 if (exited_omp)
2481 {
2482 identify_goto (decl, locus);
2483 error (" exits OpenMP structured block");
2484 identified = saw_omp = true;
2485 }
2486
2487 for (b = current_binding_level; b ; b = b->level_chain)
2488 {
2489 tree new_decls, old_decls = (b == level ? names : NULL_TREE);
2490
2491 for (new_decls = b->names; new_decls != old_decls;
6625cdb5
JM
2492 new_decls = TREE_CHAIN (new_decls))
2493 {
2494 int problem = decl_jump_unsafe (new_decls);
2495 if (! problem)
2496 continue;
2497
1799e5d5 2498 if (!identified)
6625cdb5 2499 {
1799e5d5
RH
2500 identify_goto (decl, locus);
2501 identified = true;
6625cdb5 2502 }
826840d9 2503 if (problem > 1)
dee15844 2504 error (" crosses initialization of %q+#D", new_decls);
6625cdb5 2505 else
37ec60ed 2506 permerror (" enters scope of non-POD %q+#D", new_decls);
6625cdb5
JM
2507 }
2508
2509 if (b == level)
2510 break;
1799e5d5 2511 if ((b->kind == sk_try || b->kind == sk_catch) && !saw_eh)
6625cdb5 2512 {
1799e5d5 2513 if (!identified)
6625cdb5 2514 {
1799e5d5
RH
2515 identify_goto (decl, locus);
2516 identified = true;
6625cdb5 2517 }
a7e8c268 2518 if (b->kind == sk_try)
826840d9
RH
2519 error (" enters try block");
2520 else
2521 error (" enters catch block");
1799e5d5
RH
2522 saw_eh = true;
2523 }
2524 if (b->kind == sk_omp && !saw_omp)
2525 {
2526 if (!identified)
2527 {
2528 identify_goto (decl, locus);
2529 identified = true;
2530 }
2531 error (" enters OpenMP structured block");
2532 saw_omp = true;
6625cdb5
JM
2533 }
2534 }
6625cdb5 2535
1799e5d5 2536 return !identified;
6625cdb5
JM
2537}
2538
2539static void
1799e5d5 2540check_previous_goto (tree decl, struct named_label_use_entry *use)
6625cdb5 2541{
1799e5d5
RH
2542 check_previous_goto_1 (decl, use->binding_level,
2543 use->names_in_scope, use->in_omp_scope,
2544 &use->o_goto_locus);
6625cdb5
JM
2545}
2546
1799e5d5
RH
2547static bool
2548check_switch_goto (struct cp_binding_level* level)
6625cdb5 2549{
1799e5d5 2550 return check_previous_goto_1 (NULL_TREE, level, level->names, false, NULL);
6625cdb5
JM
2551}
2552
2553/* Check that a new jump to a label DECL is OK. Called by
2554 finish_goto_stmt. */
2555
2556void
11f6b451 2557check_goto (tree decl)
6625cdb5 2558{
1799e5d5
RH
2559 struct named_label_entry *ent, dummy;
2560 bool saw_catch = false, identified = false;
6625cdb5 2561 tree bad;
6625cdb5 2562
1799e5d5
RH
2563 /* We can't know where a computed goto is jumping.
2564 So we assume that it's OK. */
2565 if (TREE_CODE (decl) != LABEL_DECL)
2566 return;
2567
2568 /* We didn't record any information about this label when we created it,
2569 and there's not much point since it's trivial to analyze as a return. */
2570 if (decl == cdtor_label)
e3cd9945
APB
2571 return;
2572
1799e5d5
RH
2573 dummy.label_decl = decl;
2574 ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2575 gcc_assert (ent != NULL);
2576
6625cdb5
JM
2577 /* If the label hasn't been defined yet, defer checking. */
2578 if (! DECL_INITIAL (decl))
2579 {
1799e5d5 2580 struct named_label_use_entry *new_use;
6625cdb5 2581
1799e5d5
RH
2582 /* Don't bother creating another use if the last goto had the
2583 same data, and will therefore create the same set of errors. */
2584 if (ent->uses
2585 && ent->uses->names_in_scope == current_binding_level->names)
2586 return;
6625cdb5 2587
1799e5d5
RH
2588 new_use = GGC_NEW (struct named_label_use_entry);
2589 new_use->binding_level = current_binding_level;
2590 new_use->names_in_scope = current_binding_level->names;
2591 new_use->o_goto_locus = input_location;
2592 new_use->in_omp_scope = false;
2593
2594 new_use->next = ent->uses;
2595 ent->uses = new_use;
2596 return;
2597 }
6625cdb5 2598
1799e5d5
RH
2599 if (ent->in_try_scope || ent->in_catch_scope
2600 || ent->in_omp_scope || ent->bad_decls)
6625cdb5 2601 {
37ec60ed
JW
2602 permerror ("jump to label %q+D", decl);
2603 permerror (" from here");
1799e5d5 2604 identified = true;
6625cdb5
JM
2605 }
2606
1799e5d5 2607 for (bad = ent->bad_decls; bad; bad = TREE_CHAIN (bad))
6625cdb5
JM
2608 {
2609 tree b = TREE_VALUE (bad);
2610 int u = decl_jump_unsafe (b);
2611
2612 if (u > 1 && DECL_ARTIFICIAL (b))
1799e5d5
RH
2613 {
2614 /* Can't skip init of __exception_info. */
2615 error ("%J enters catch block", b);
2616 saw_catch = true;
2617 }
6625cdb5 2618 else if (u > 1)
dee15844 2619 error (" skips initialization of %q+#D", b);
6625cdb5 2620 else
37ec60ed 2621 permerror (" enters scope of non-POD %q+#D", b);
6625cdb5
JM
2622 }
2623
1799e5d5 2624 if (ent->in_try_scope)
6625cdb5 2625 error (" enters try block");
1799e5d5 2626 else if (ent->in_catch_scope && !saw_catch)
826840d9 2627 error (" enters catch block");
1799e5d5
RH
2628
2629 if (ent->in_omp_scope)
2630 error (" enters OpenMP structured block");
2631 else if (flag_openmp)
2632 {
2633 struct cp_binding_level *b;
2634 for (b = current_binding_level; b ; b = b->level_chain)
2635 {
2636 if (b == ent->binding_level)
2637 break;
2638 if (b->kind == sk_omp)
2639 {
2640 if (!identified)
2641 {
37ec60ed
JW
2642 permerror ("jump to label %q+D", decl);
2643 permerror (" from here");
1799e5d5
RH
2644 identified = true;
2645 }
2646 error (" exits OpenMP structured block");
2647 break;
2648 }
2649 }
2650 }
2651}
2652
2653/* Check that a return is ok wrt OpenMP structured blocks.
2654 Called by finish_return_stmt. Returns true if all is well. */
2655
2656bool
2657check_omp_return (void)
2658{
2659 struct cp_binding_level *b;
2660 for (b = current_binding_level; b ; b = b->level_chain)
2661 if (b->kind == sk_omp)
2662 {
2663 error ("invalid exit from OpenMP structured block");
2664 return false;
2665 }
2666 return true;
6625cdb5
JM
2667}
2668
8d08fdba 2669/* Define a label, specifying the location in the source file.
b9c87401 2670 Return the LABEL_DECL node for the label. */
8d08fdba
MS
2671
2672tree
5b030314 2673define_label (location_t location, tree name)
8d08fdba 2674{
1799e5d5 2675 struct named_label_entry *ent, dummy;
926ce8bd 2676 struct cp_binding_level *p;
1799e5d5 2677 tree decl;
6625cdb5 2678
22ffcc6f 2679 timevar_push (TV_NAME_LOOKUP);
1799e5d5
RH
2680
2681 decl = lookup_label (name);
2682
2683 dummy.label_decl = decl;
2684 ent = (struct named_label_entry *) htab_find (named_labels, &dummy);
2685 gcc_assert (ent != NULL);
8d08fdba 2686
3dc9aec6 2687 /* After labels, make any new cleanups in the function go into their
8d08fdba 2688 own new (temporary) binding contour. */
caf93cb0
EC
2689 for (p = current_binding_level;
2690 p->kind != sk_function_parms;
a7e8c268 2691 p = p->level_chain)
3dc9aec6 2692 p->more_cleanups_ok = 0;
8d08fdba 2693
e1cd6e56 2694 if (name == get_identifier ("wchar_t"))
37ec60ed 2695 permerror ("label named wchar_t");
e1cd6e56 2696
8d08fdba 2697 if (DECL_INITIAL (decl) != NULL_TREE)
417fa55b
LM
2698 {
2699 error ("duplicate label %qD", decl);
2700 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
2701 }
8d08fdba
MS
2702 else
2703 {
1799e5d5
RH
2704 struct named_label_use_entry *use;
2705
8d08fdba
MS
2706 /* Mark label as having been defined. */
2707 DECL_INITIAL (decl) = error_mark_node;
2708 /* Say where in the source. */
f31686a3 2709 DECL_SOURCE_LOCATION (decl) = location;
1799e5d5
RH
2710
2711 ent->binding_level = current_binding_level;
2712 ent->names_in_scope = current_binding_level->names;
2713
2714 for (use = ent->uses; use ; use = use->next)
2715 check_previous_goto (decl, use);
2716 ent->uses = NULL;
8d08fdba 2717 }
b9c87401 2718
be99edf8 2719 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
8d08fdba
MS
2720}
2721
a5894242
MS
2722struct cp_switch
2723{
e2500fed 2724 struct cp_binding_level *level;
a5894242 2725 struct cp_switch *next;
56cb9733
MM
2726 /* The SWITCH_STMT being built. */
2727 tree switch_stmt;
2728 /* A splay-tree mapping the low element of a case range to the high
2729 element, or NULL_TREE if there is no high element. Used to
2730 determine whether or not a new case label duplicates an old case
2731 label. We need a tree, rather than simply a hash table, because
2732 of the GNU case range extension. */
2733 splay_tree cases;
a5894242
MS
2734};
2735
56cb9733
MM
2736/* A stack of the currently active switch statements. The innermost
2737 switch statement is on the top of the stack. There is no need to
2738 mark the stack for garbage collection because it is only active
2739 during the processing of the body of a function, and we never
2740 collect at that point. */
5362b086 2741
a5894242
MS
2742static struct cp_switch *switch_stack;
2743
56cb9733
MM
2744/* Called right after a switch-statement condition is parsed.
2745 SWITCH_STMT is the switch statement being parsed. */
2746
a5894242 2747void
11f6b451 2748push_switch (tree switch_stmt)
a5894242 2749{
0ac1b889 2750 struct cp_switch *p = XNEW (struct cp_switch);
a5894242
MS
2751 p->level = current_binding_level;
2752 p->next = switch_stack;
56cb9733
MM
2753 p->switch_stmt = switch_stmt;
2754 p->cases = splay_tree_new (case_compare, NULL, NULL);
a5894242
MS
2755 switch_stack = p;
2756}
2757
2758void
11f6b451 2759pop_switch (void)
a5894242 2760{
6de9cd9a 2761 struct cp_switch *cs = switch_stack;
fbc315db 2762 location_t switch_location;
6de9cd9a
DN
2763
2764 /* Emit warnings as needed. */
fbc315db
ILT
2765 if (EXPR_HAS_LOCATION (cs->switch_stmt))
2766 switch_location = EXPR_LOCATION (cs->switch_stmt);
2767 else
2768 switch_location = input_location;
dddf9a0a
AP
2769 if (!processing_template_decl)
2770 c_do_switch_warnings (cs->cases, switch_location,
2771 SWITCH_STMT_TYPE (cs->switch_stmt),
2772 SWITCH_STMT_COND (cs->switch_stmt));
5362b086 2773
56cb9733 2774 splay_tree_delete (cs->cases);
a5894242 2775 switch_stack = switch_stack->next;
bedda2da 2776 free (cs);
a5894242
MS
2777}
2778
b0a1da19
JM
2779/* Note that we've seen a definition of a case label, and complain if this
2780 is a bad place for one. */
e92cc029 2781
3e4d04a1 2782tree
11f6b451 2783finish_case_label (tree low_value, tree high_value)
8d08fdba 2784{
3e4d04a1 2785 tree cond, r;
926ce8bd 2786 struct cp_binding_level *p;
a5894242 2787
56cb9733
MM
2788 if (processing_template_decl)
2789 {
8f17b5c5
MM
2790 tree label;
2791
56cb9733
MM
2792 /* For templates, just add the case label; we'll do semantic
2793 analysis at instantiation-time. */
8f17b5c5 2794 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
3e4d04a1 2795 return add_stmt (build_case_label (low_value, high_value, label));
56cb9733
MM
2796 }
2797
2798 /* Find the condition on which this switch statement depends. */
ebaae582 2799 cond = SWITCH_STMT_COND (switch_stack->switch_stmt);
56cb9733
MM
2800 if (cond && TREE_CODE (cond) == TREE_LIST)
2801 cond = TREE_VALUE (cond);
56cb9733 2802
1799e5d5
RH
2803 if (!check_switch_goto (switch_stack->level))
2804 return error_mark_node;
2805
a6c0a76c
SB
2806 r = c_add_case_label (switch_stack->cases, cond, TREE_TYPE (cond),
2807 low_value, high_value);
8d08fdba 2808
3dc9aec6 2809 /* After labels, make any new cleanups in the function go into their
8d08fdba 2810 own new (temporary) binding contour. */
caf93cb0
EC
2811 for (p = current_binding_level;
2812 p->kind != sk_function_parms;
a7e8c268 2813 p = p->level_chain)
3dc9aec6 2814 p->more_cleanups_ok = 0;
3e4d04a1
RH
2815
2816 return r;
8d08fdba
MS
2817}
2818\f
7ddedda4
MM
2819/* Hash a TYPENAME_TYPE. K is really of type `tree'. */
2820
e2500fed 2821static hashval_t
11f6b451 2822typename_hash (const void* k)
7ddedda4 2823{
e2500fed 2824 hashval_t hash;
741ac903 2825 const_tree const t = (const_tree) k;
7ddedda4 2826
7bdfd72e
KG
2827 hash = (htab_hash_pointer (TYPE_CONTEXT (t))
2828 ^ htab_hash_pointer (DECL_NAME (TYPE_NAME (t))));
7ddedda4
MM
2829
2830 return hash;
2831}
2832
fc6a28d7
MM
2833typedef struct typename_info {
2834 tree scope;
2835 tree name;
2836 tree template_id;
2837 bool enum_p;
2838 bool class_p;
2839} typename_info;
2840
06d40de8
DG
2841/* Compare two TYPENAME_TYPEs. K1 is really of type `tree', K2 is
2842 really of type `typename_info*' */
7ddedda4 2843
e2500fed 2844static int
11f6b451 2845typename_compare (const void * k1, const void * k2)
7ddedda4 2846{
741ac903
KG
2847 const_tree const t1 = (const_tree) k1;
2848 const typename_info *const t2 = (const typename_info *) k2;
fc6a28d7
MM
2849
2850 return (DECL_NAME (TYPE_NAME (t1)) == t2->name
2851 && TYPE_CONTEXT (t1) == t2->scope
2852 && TYPENAME_TYPE_FULLNAME (t1) == t2->template_id
2853 && TYPENAME_IS_ENUM_P (t1) == t2->enum_p
2854 && TYPENAME_IS_CLASS_P (t1) == t2->class_p);
7ddedda4
MM
2855}
2856
45869a6c 2857/* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
fc6a28d7 2858 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
c8094d83 2859
45869a6c
MM
2860 Returns the new TYPENAME_TYPE. */
2861
e2500fed
GK
2862static GTY ((param_is (union tree_node))) htab_t typename_htab;
2863
8ce33230 2864static tree
fc6a28d7
MM
2865build_typename_type (tree context, tree name, tree fullname,
2866 enum tag_types tag_type)
45869a6c
MM
2867{
2868 tree t;
2869 tree d;
fc6a28d7 2870 typename_info ti;
fad205ff 2871 void **e;
fc6a28d7 2872 hashval_t hash;
45869a6c 2873
e2500fed 2874 if (typename_htab == NULL)
fc6a28d7
MM
2875 typename_htab = htab_create_ggc (61, &typename_hash,
2876 &typename_compare, NULL);
2877
c8094d83 2878 ti.scope = FROB_CONTEXT (context);
fc6a28d7
MM
2879 ti.name = name;
2880 ti.template_id = fullname;
2881 ti.enum_p = tag_type == enum_type;
2882 ti.class_p = (tag_type == class_type
2883 || tag_type == record_type
2884 || tag_type == union_type);
2885 hash = (htab_hash_pointer (ti.scope)
2886 ^ htab_hash_pointer (ti.name));
45869a6c 2887
7ddedda4 2888 /* See if we already have this type. */
fc6a28d7 2889 e = htab_find_slot_with_hash (typename_htab, &ti, hash, INSERT);
e2500fed
GK
2890 if (*e)
2891 t = (tree) *e;
7ddedda4 2892 else
fc6a28d7
MM
2893 {
2894 /* Build the TYPENAME_TYPE. */
9e1e64ec 2895 t = cxx_make_type (TYPENAME_TYPE);
fc6a28d7
MM
2896 TYPE_CONTEXT (t) = ti.scope;
2897 TYPENAME_TYPE_FULLNAME (t) = ti.template_id;
2898 TYPENAME_IS_ENUM_P (t) = ti.enum_p;
2899 TYPENAME_IS_CLASS_P (t) = ti.class_p;
c8094d83 2900
fc6a28d7
MM
2901 /* Build the corresponding TYPE_DECL. */
2902 d = build_decl (TYPE_DECL, name, t);
2903 TYPE_NAME (TREE_TYPE (d)) = d;
2904 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
2905 DECL_CONTEXT (d) = FROB_CONTEXT (context);
2906 DECL_ARTIFICIAL (d) = 1;
2907
2908 /* Store it in the hash table. */
2909 *e = t;
06d40de8
DG
2910
2911 /* TYPENAME_TYPEs must always be compared structurally, because
2912 they may or may not resolve down to another type depending on
2913 the currently open classes. */
2914 SET_TYPE_STRUCTURAL_EQUALITY (t);
fc6a28d7 2915 }
c8094d83 2916
45869a6c
MM
2917 return t;
2918}
2919
fc6a28d7
MM
2920/* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
2921 provided to name the type. Returns an appropriate type, unless an
2922 error occurs, in which case error_mark_node is returned. If we
2923 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
2924 return that, rather than the _TYPE it corresponds to, in other
2925 cases we look through the type decl. If TF_ERROR is set, complain
2926 about errors, otherwise be quiet. */
3baa501d 2927
5566b478 2928tree
fc6a28d7
MM
2929make_typename_type (tree context, tree name, enum tag_types tag_type,
2930 tsubst_flags_t complain)
5566b478 2931{
b2b7d40a 2932 tree fullname;
7d3bec9d
NS
2933 tree t;
2934 bool want_template;
a80e4195 2935
5dc5d13c
KL
2936 if (name == error_mark_node
2937 || context == NULL_TREE
2938 || context == error_mark_node)
2939 return error_mark_node;
2940
2f939d94 2941 if (TYPE_P (name))
78638e24 2942 {
68642fb6
UD
2943 if (!(TYPE_LANG_SPECIFIC (name)
2944 && (CLASSTYPE_IS_TEMPLATE (name)
78638e24
MM
2945 || CLASSTYPE_USE_TEMPLATE (name))))
2946 name = TYPE_IDENTIFIER (name);
2947 else
2948 /* Create a TEMPLATE_ID_EXPR for the type. */
2949 name = build_nt (TEMPLATE_ID_EXPR,
2950 CLASSTYPE_TI_TEMPLATE (name),
2951 CLASSTYPE_TI_ARGS (name));
2952 }
653cc74a 2953 else if (TREE_CODE (name) == TYPE_DECL)
a80e4195 2954 name = DECL_NAME (name);
b2b7d40a
JM
2955
2956 fullname = name;
2957
2958 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
11686454
JM
2959 {
2960 name = TREE_OPERAND (name, 0);
2961 if (TREE_CODE (name) == TEMPLATE_DECL)
2962 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
50ef2c18
MM
2963 else if (TREE_CODE (name) == OVERLOAD)
2964 {
2965 error ("%qD is not a type", name);
2966 return error_mark_node;
2967 }
11686454 2968 }
8a2b77e7
JM
2969 if (TREE_CODE (name) == TEMPLATE_DECL)
2970 {
2d01edd7 2971 error ("%qD used without template parameters", name);
8a2b77e7
JM
2972 return error_mark_node;
2973 }
50bc768d 2974 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
0c88d886 2975 gcc_assert (TYPE_P (context));
04ddee1b 2976
7d3bec9d
NS
2977 /* When the CONTEXT is a dependent type, NAME could refer to a
2978 dependent base class of CONTEXT. So we cannot peek inside it,
2979 even if CONTEXT is a currently open scope. */
2980 if (dependent_type_p (context))
2981 return build_typename_type (context, name, fullname, tag_type);
caf93cb0 2982
9e1e64ec 2983 if (!MAYBE_CLASS_TYPE_P (context))
7d3bec9d
NS
2984 {
2985 if (complain & tf_error)
2986 error ("%q#T is not a class", context);
2987 return error_mark_node;
5566b478 2988 }
7d3bec9d
NS
2989
2990 want_template = TREE_CODE (fullname) == TEMPLATE_ID_EXPR;
2991
2992 /* We should only set WANT_TYPE when we're a nested typename type.
2993 Then we can give better diagnostics if we find a non-type. */
2994 t = lookup_field (context, name, 0, /*want_type=*/true);
2995 if (!t)
11249cf0 2996 {
4f2b0fb2 2997 if (complain & tf_error)
7d3bec9d
NS
2998 error (want_template ? "no class template named %q#T in %q#T"
2999 : "no type named %q#T in %q#T", name, context);
11249cf0
MM
3000 return error_mark_node;
3001 }
7d3bec9d
NS
3002
3003 if (want_template && !DECL_CLASS_TEMPLATE_P (t))
3004 {
3005 if (complain & tf_error)
3006 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3007 context, name, t);
3008 return error_mark_node;
3009 }
3010 if (!want_template && TREE_CODE (t) != TYPE_DECL)
3011 {
3012 if (complain & tf_error)
3013 error ("%<typename %T::%D%> names %q#T, which is not a type",
3014 context, name, t);
3015 return error_mark_node;
3016 }
3017
3018 if (complain & tf_error)
02022f3a 3019 perform_or_defer_access_check (TYPE_BINFO (context), t, t);
7d3bec9d
NS
3020
3021 if (want_template)
3022 return lookup_template_class (t, TREE_OPERAND (fullname, 1),
3023 NULL_TREE, context,
3024 /*entering_scope=*/0,
3025 tf_warning_or_error | tf_user);
3026
3027 if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
3028 t = TREE_TYPE (t);
3029
3030 return t;
5566b478
MS
3031}
3032
b939a023 3033/* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
c8094d83 3034 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
b939a023
KL
3035 in which case error_mark_node is returned.
3036
3037 If PARM_LIST is non-NULL, also make sure that the template parameter
3038 list of TEMPLATE_DECL matches.
3039
3040 If COMPLAIN zero, don't complain about any errors that occur. */
b8c6534b
KL
3041
3042tree
b939a023
KL
3043make_unbound_class_template (tree context, tree name, tree parm_list,
3044 tsubst_flags_t complain)
b8c6534b
KL
3045{
3046 tree t;
3047 tree d;
3048
3049 if (TYPE_P (name))
3050 name = TYPE_IDENTIFIER (name);
3051 else if (DECL_P (name))
3052 name = DECL_NAME (name);
8dc2b103 3053 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
b8c6534b 3054
9579624e 3055 if (!dependent_type_p (context)
b8c6534b
KL
3056 || currently_open_class (context))
3057 {
3058 tree tmpl = NULL_TREE;
3059
9e1e64ec 3060 if (MAYBE_CLASS_TYPE_P (context))
86ac0575 3061 tmpl = lookup_field (context, name, 0, false);
b8c6534b
KL
3062
3063 if (!tmpl || !DECL_CLASS_TEMPLATE_P (tmpl))
3064 {
4f09be91 3065 if (complain & tf_error)
2d01edd7 3066 error ("no class template named %q#T in %q#T", name, context);
b8c6534b
KL
3067 return error_mark_node;
3068 }
caf93cb0 3069
b939a023
KL
3070 if (parm_list
3071 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl), parm_list))
3072 {
3073 if (complain & tf_error)
3074 {
3075 error ("template parameters do not match template");
dee15844 3076 error ("%q+D declared here", tmpl);
b939a023
KL
3077 }
3078 return error_mark_node;
3079 }
3080
2b59fc25 3081 if (complain & tf_error)
02022f3a 3082 perform_or_defer_access_check (TYPE_BINFO (context), tmpl, tmpl);
b8c6534b
KL
3083
3084 return tmpl;
3085 }
3086
3087 /* Build the UNBOUND_CLASS_TEMPLATE. */
9e1e64ec 3088 t = cxx_make_type (UNBOUND_CLASS_TEMPLATE);
b8c6534b
KL
3089 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
3090 TREE_TYPE (t) = NULL_TREE;
06d40de8 3091 SET_TYPE_STRUCTURAL_EQUALITY (t);
b8c6534b
KL
3092
3093 /* Build the corresponding TEMPLATE_DECL. */
3094 d = build_decl (TEMPLATE_DECL, name, t);
3095 TYPE_NAME (TREE_TYPE (d)) = d;
3096 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
3097 DECL_CONTEXT (d) = FROB_CONTEXT (context);
3098 DECL_ARTIFICIAL (d) = 1;
b939a023 3099 DECL_TEMPLATE_PARMS (d) = parm_list;
b8c6534b
KL
3100
3101 return t;
3102}
3103
8d08fdba 3104\f
47aa0df4 3105
8d08fdba 3106/* Push the declarations of builtin types into the namespace.
4b0d3cbe
MM
3107 RID_INDEX is the index of the builtin type in the array
3108 RID_POINTERS. NAME is the name used when looking up the builtin
3109 type. TYPE is the _TYPE node for the builtin type. */
8d08fdba 3110
eaa7c03f 3111void
caf93cb0 3112record_builtin_type (enum rid rid_index,
0cbd7506
MS
3113 const char* name,
3114 tree type)
8d08fdba
MS
3115{
3116 tree rname = NULL_TREE, tname = NULL_TREE;
a703fb38 3117 tree tdecl = NULL_TREE;
8d08fdba 3118
0e5921e8 3119 if ((int) rid_index < (int) RID_MAX)
8d08fdba
MS
3120 rname = ridpointers[(int) rid_index];
3121 if (name)
3122 tname = get_identifier (name);
3123
4b0d3cbe
MM
3124 /* The calls to SET_IDENTIFIER_GLOBAL_VALUE below should be
3125 eliminated. Built-in types should not be looked up name; their
3126 names are keywords that the parser can recognize. However, there
3127 is code in c-common.c that uses identifier_global_value to look
3128 up built-in types by name. */
8d08fdba
MS
3129 if (tname)
3130 {
4b0d3cbe
MM
3131 tdecl = build_decl (TYPE_DECL, tname, type);
3132 DECL_ARTIFICIAL (tdecl) = 1;
a7e8c268 3133 SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
8d08fdba 3134 }
4b0d3cbe 3135 if (rname)
8d08fdba 3136 {
4b0d3cbe 3137 if (!tdecl)
8d08fdba 3138 {
4b0d3cbe
MM
3139 tdecl = build_decl (TYPE_DECL, rname, type);
3140 DECL_ARTIFICIAL (tdecl) = 1;
8d08fdba 3141 }
4b0d3cbe 3142 SET_IDENTIFIER_GLOBAL_VALUE (rname, tdecl);
8d08fdba 3143 }
4b0d3cbe
MM
3144
3145 if (!TYPE_NAME (type))
3146 TYPE_NAME (type) = tdecl;
47aa0df4
MM
3147
3148 if (tdecl)
21d13d83 3149 debug_hooks->type_decl (tdecl, 0);
8d08fdba
MS
3150}
3151
eff71ab0 3152/* Record one of the standard Java types.
4d8a1dd6
MM
3153 * Declare it as having the given NAME.
3154 * If SIZE > 0, it is the size of one of the integral types;
3155 * otherwise it is the negative of the size of one of the other types. */
eff71ab0
PB
3156
3157static tree
11f6b451 3158record_builtin_java_type (const char* name, int size)
eff71ab0
PB
3159{
3160 tree type, decl;
3161 if (size > 0)
3162 type = make_signed_type (size);
3163 else if (size > -32)
70fef63a 3164 { /* "__java_char" or ""__java_boolean". */
eff71ab0 3165 type = make_unsigned_type (-size);
70fef63a 3166 /*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
eff71ab0
PB
3167 }
3168 else
a1c65f9f 3169 { /* "__java_float" or ""__java_double". */
eff71ab0
PB
3170 type = make_node (REAL_TYPE);
3171 TYPE_PRECISION (type) = - size;
3172 layout_type (type);
3173 }
0e5921e8 3174 record_builtin_type (RID_MAX, name, type);
eff71ab0 3175 decl = TYPE_NAME (type);
e229f2cd
PB
3176
3177 /* Suppress generate debug symbol entries for these types,
3178 since for normal C++ they are just clutter.
a1c65f9f 3179 However, push_lang_context undoes this if extern "Java" is seen. */
eff71ab0 3180 DECL_IGNORED_P (decl) = 1;
e229f2cd 3181
eff71ab0
PB
3182 TYPE_FOR_JAVA (type) = 1;
3183 return type;
3184}
3185
3b426391 3186/* Push a type into the namespace so that the back ends ignore it. */
036407f7
ML
3187
3188static void
11f6b451 3189record_unknown_type (tree type, const char* name)
036407f7
ML
3190{
3191 tree decl = pushdecl (build_decl (TYPE_DECL, get_identifier (name), type));
3192 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
3193 DECL_IGNORED_P (decl) = 1;
3194 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
3195 TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
3196 TYPE_ALIGN (type) = 1;
11cf4d18 3197 TYPE_USER_ALIGN (type) = 0;
036407f7 3198 TYPE_MODE (type) = TYPE_MODE (void_type_node);
68642fb6 3199}
036407f7 3200
13a44ee0 3201/* A string for which we should create an IDENTIFIER_NODE at
d43829f9
MM
3202 startup. */
3203
3204typedef struct predefined_identifier
3205{
3206 /* The name of the identifier. */
8b60264b 3207 const char *const name;
d43829f9 3208 /* The place where the IDENTIFIER_NODE should be stored. */
8b60264b 3209 tree *const node;
838dfd8a 3210 /* Nonzero if this is the name of a constructor or destructor. */
8b60264b 3211 const int ctor_or_dtor_p;
d43829f9
MM
3212} predefined_identifier;
3213
3214/* Create all the predefined identifiers. */
3215
3216static void
11f6b451 3217initialize_predefined_identifiers (void)
d43829f9 3218{
8b60264b 3219 const predefined_identifier *pid;
d43829f9
MM
3220
3221 /* A table of identifiers to create at startup. */
8b60264b 3222 static const predefined_identifier predefined_identifiers[] = {
298d6f60
MM
3223 { "C++", &lang_name_cplusplus, 0 },
3224 { "C", &lang_name_c, 0 },
3225 { "Java", &lang_name_java, 0 },
d6eec208
MM
3226 /* Some of these names have a trailing space so that it is
3227 impossible for them to conflict with names written by users. */
3228 { "__ct ", &ctor_identifier, 1 },
3229 { "__base_ctor ", &base_ctor_identifier, 1 },
3230 { "__comp_ctor ", &complete_ctor_identifier, 1 },
3231 { "__dt ", &dtor_identifier, 1 },
3232 { "__comp_dtor ", &complete_dtor_identifier, 1 },
3233 { "__base_dtor ", &base_dtor_identifier, 1 },
3234 { "__deleting_dtor ", &deleting_dtor_identifier, 1 },
298d6f60 3235 { IN_CHARGE_NAME, &in_charge_identifier, 0 },
298d6f60
MM
3236 { "nelts", &nelts_identifier, 0 },
3237 { THIS_NAME, &this_identifier, 0 },
c4372ef4 3238 { VTABLE_DELTA_NAME, &delta_identifier, 0 },
298d6f60 3239 { VTABLE_PFN_NAME, &pfn_identifier, 0 },
298d6f60 3240 { "_vptr", &vptr_identifier, 0 },
3ec6bad3 3241 { "__vtt_parm", &vtt_parm_identifier, 0 },
82a2669e 3242 { "::", &global_scope_name, 0 },
1f6e1acc 3243 { "std", &std_identifier, 0 },
298d6f60 3244 { NULL, NULL, 0 }
d43829f9
MM
3245 };
3246
3247 for (pid = predefined_identifiers; pid->name; ++pid)
298d6f60
MM
3248 {
3249 *pid->node = get_identifier (pid->name);
3250 if (pid->ctor_or_dtor_p)
3251 IDENTIFIER_CTOR_OR_DTOR_P (*pid->node) = 1;
3252 }
d43829f9
MM
3253}
3254
8d08fdba
MS
3255/* Create the predefined scalar types of C,
3256 and some nodes representing standard constants (0, 1, (void *)0).
3257 Initialize the global binding level.
3258 Make definitions for built-in primitive functions. */
3259
3260void
11f6b451 3261cxx_init_decl_processing (void)
8d08fdba 3262{
10841285
MM
3263 tree void_ftype;
3264 tree void_ftype_ptr;
8d08fdba 3265
8c1d6d62 3266 build_common_tree_nodes (flag_signed_char, false);
6de66680 3267
d43829f9
MM
3268 /* Create all the identifiers we need. */
3269 initialize_predefined_identifiers ();
8d08fdba 3270
9cd64686
MM
3271 /* Create the global variables. */
3272 push_to_top_level ();
8012c983 3273
82a2669e 3274 current_function_decl = NULL_TREE;
1ec57cf0 3275 current_binding_level = NULL;
a1c65f9f 3276 /* Enter the global namespace. */
50bc768d 3277 gcc_assert (global_namespace == NULL_TREE);
82a2669e 3278 global_namespace = build_lang_decl (NAMESPACE_DECL, global_scope_name,
0cbd7506 3279 void_type_node);
b9e75696 3280 TREE_PUBLIC (global_namespace) = 1;
ac20c67a 3281 begin_scope (sk_namespace, global_namespace);
82a2669e 3282
30394414
JM
3283 current_lang_name = NULL_TREE;
3284
ddbfd28d
GK
3285 if (flag_visibility_ms_compat)
3286 default_visibility = VISIBILITY_HIDDEN;
3287
8d08fdba
MS
3288 /* Initially, C. */
3289 current_lang_name = lang_name_c;
3290
6bcedb4e 3291 /* Create the `std' namespace. */
1dbb6023
NS
3292 push_namespace (std_identifier);
3293 std_node = current_namespace;
3294 pop_namespace ();
5362b086 3295
eaa7c03f 3296 c_common_nodes_and_builtins ();
37c46b43 3297
4d8a1dd6
MM
3298 java_byte_type_node = record_builtin_java_type ("__java_byte", 8);
3299 java_short_type_node = record_builtin_java_type ("__java_short", 16);
3300 java_int_type_node = record_builtin_java_type ("__java_int", 32);
3301 java_long_type_node = record_builtin_java_type ("__java_long", 64);
3302 java_float_type_node = record_builtin_java_type ("__java_float", -32);
3303 java_double_type_node = record_builtin_java_type ("__java_double", -64);
3304 java_char_type_node = record_builtin_java_type ("__java_char", -16);
3305 java_boolean_type_node = record_builtin_java_type ("__java_boolean", -1);
eff71ab0 3306
7d60be94
NS
3307 integer_two_node = build_int_cst (NULL_TREE, 2);
3308 integer_three_node = build_int_cst (NULL_TREE, 3);
8d08fdba 3309
255512c1 3310 record_builtin_type (RID_BOOL, "bool", boolean_type_node);
de7df9eb
JM
3311 truthvalue_type_node = boolean_type_node;
3312 truthvalue_false_node = boolean_false_node;
3313 truthvalue_true_node = boolean_true_node;
2986ae00 3314
4cc1d462 3315 empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
5fd8e536
JM
3316
3317#if 0
3e411c3f 3318 record_builtin_type (RID_MAX, NULL, string_type_node);
5fd8e536
JM
3319#endif
3320
1f84ec23
MM
3321 delta_type_node = ptrdiff_type_node;
3322 vtable_index_type = ptrdiff_type_node;
c7e266a6 3323
3ec6bad3 3324 vtt_parm_type = build_pointer_type (const_ptr_type_node);
10841285
MM
3325 void_ftype = build_function_type (void_type_node, void_list_node);
3326 void_ftype_ptr = build_function_type (void_type_node,
3327 tree_cons (NULL_TREE,
caf93cb0 3328 ptr_type_node,
10841285 3329 void_list_node));
824b9a4c 3330 void_ftype_ptr
4cc1d462 3331 = build_exception_variant (void_ftype_ptr, empty_except_spec);
8d08fdba 3332
8d08fdba
MS
3333 /* C++ extensions */
3334
3335 unknown_type_node = make_node (UNKNOWN_TYPE);
036407f7
ML
3336 record_unknown_type (unknown_type_node, "unknown type");
3337
8d08fdba
MS
3338 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
3339 TREE_TYPE (unknown_type_node) = unknown_type_node;
a6967cc0 3340
a6967cc0
JM
3341 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
3342 result. */
8d08fdba
MS
3343 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
3344 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
3345
09357846
JM
3346 init_list_type_node = make_node (UNKNOWN_TYPE);
3347 record_unknown_type (init_list_type_node, "init list");
3348
c4372ef4
NS
3349 {
3350 /* Make sure we get a unique function type, so we can give
3351 its pointer type a name. (This wins for gdb.) */
3352 tree vfunc_type = make_node (FUNCTION_TYPE);
3353 TREE_TYPE (vfunc_type) = integer_type_node;
3354 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
3355 layout_type (vfunc_type);
3356
3357 vtable_entry_type = build_pointer_type (vfunc_type);
3358 }
0e5921e8 3359 record_builtin_type (RID_MAX, VTBL_PTR_TYPE, vtable_entry_type);
8d08fdba 3360
8d08fdba 3361 vtbl_type_node
52bf7d5d 3362 = build_cplus_array_type (vtable_entry_type, NULL_TREE);
8d08fdba 3363 layout_type (vtbl_type_node);
91063b51 3364 vtbl_type_node = build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
3e411c3f 3365 record_builtin_type (RID_MAX, NULL, vtbl_type_node);
849da744
MM
3366 vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
3367 layout_type (vtbl_ptr_type_node);
3e411c3f 3368 record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
8d08fdba 3369
1f84ec23
MM
3370 push_namespace (get_identifier ("__cxxabiv1"));
3371 abi_node = current_namespace;
3372 pop_namespace ();
6633d636 3373
2c73f9f5 3374 global_type_node = make_node (LANG_TYPE);
036407f7 3375 record_unknown_type (global_type_node, "global type");
2c73f9f5 3376
db5ae43f
MS
3377 /* Now, C++. */
3378 current_lang_name = lang_name_cplusplus;
8d08fdba 3379
ced78d8b 3380 {
4b0d3cbe
MM
3381 tree bad_alloc_id;
3382 tree bad_alloc_type_node;
3383 tree bad_alloc_decl;
3384 tree newtype, deltype;
10841285
MM
3385 tree ptr_ftype_sizetype;
3386
1dbb6023 3387 push_namespace (std_identifier);
4b0d3cbe 3388 bad_alloc_id = get_identifier ("bad_alloc");
9e1e64ec 3389 bad_alloc_type_node = make_class_type (RECORD_TYPE);
4b0d3cbe 3390 TYPE_CONTEXT (bad_alloc_type_node) = current_namespace;
caf93cb0 3391 bad_alloc_decl
4b0d3cbe
MM
3392 = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node);
3393 DECL_CONTEXT (bad_alloc_decl) = current_namespace;
3394 TYPE_STUB_DECL (bad_alloc_type_node) = bad_alloc_decl;
1dbb6023 3395 pop_namespace ();
caf93cb0
EC
3396
3397 ptr_ftype_sizetype
10841285
MM
3398 = build_function_type (ptr_type_node,
3399 tree_cons (NULL_TREE,
c9f8536c 3400 size_type_node,
10841285 3401 void_list_node));
2c73f9f5 3402 newtype = build_exception_variant
0ba8a114
NS
3403 (ptr_ftype_sizetype, add_exception_specifier
3404 (NULL_TREE, bad_alloc_type_node, -1));
4cc1d462 3405 deltype = build_exception_variant (void_ftype_ptr, empty_except_spec);
596ea4e5
AS
3406 push_cp_library_fn (NEW_EXPR, newtype);
3407 push_cp_library_fn (VEC_NEW_EXPR, newtype);
3408 global_delete_fndecl = push_cp_library_fn (DELETE_EXPR, deltype);
3409 push_cp_library_fn (VEC_DELETE_EXPR, deltype);
ced78d8b 3410 }
8d08fdba
MS
3411
3412 abort_fndecl
1f84ec23 3413 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype);
8d08fdba 3414
8d08fdba
MS
3415 /* Perform other language dependent initializations. */
3416 init_class_processing ();
db48b831 3417 init_rtti_processing ();
8d08fdba 3418
6467930b 3419 if (flag_exceptions)
8d2733ca 3420 init_exception_processing ();
9e9ff709 3421
7fcdf4c2 3422 if (! supports_one_only ())
72b7eeff 3423 flag_weak = 0;
8d08fdba 3424
2ce07e2d 3425 make_fname_decl = cp_make_fname_decl;
0ba8a114 3426 start_fname_decls ();
8d08fdba 3427
e9a25f70 3428 /* Show we use EH for cleanups. */
6de9cd9a
DN
3429 if (flag_exceptions)
3430 using_eh_for_cleanups ();
62c154ed
JM
3431}
3432
0ba8a114 3433/* Generate an initializer for a function naming variable from
bb885938 3434 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
f4f206f4 3435 filled in with the type of the init. */
0ba8a114
NS
3436
3437tree
bb885938 3438cp_fname_init (const char* name, tree *type_p)
0ba8a114
NS
3439{
3440 tree domain = NULL_TREE;
3441 tree type;
3442 tree init = NULL_TREE;
3443 size_t length = 0;
3444
3445 if (name)
3446 {
3447 length = strlen (name);
3448 domain = build_index_type (size_int (length));
3449 init = build_string (length + 1, name);
3450 }
caf93cb0 3451
0ba8a114
NS
3452 type = build_qualified_type (char_type_node, TYPE_QUAL_CONST);
3453 type = build_cplus_array_type (type, domain);
3454
bb885938 3455 *type_p = type;
caf93cb0 3456
0ba8a114
NS
3457 if (init)
3458 TREE_TYPE (init) = type;
3459 else
bb885938 3460 init = error_mark_node;
caf93cb0 3461
0ba8a114
NS
3462 return init;
3463}
3464
2ce07e2d
NS
3465/* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give the
3466 decl, NAME is the initialization string and TYPE_DEP indicates whether
3467 NAME depended on the type of the function. We make use of that to detect
0ba8a114 3468 __PRETTY_FUNCTION__ inside a template fn. This is being done
a692ad2e 3469 lazily at the point of first use, so we mustn't push the decl now. */
2ce07e2d
NS
3470
3471static tree
11f6b451 3472cp_make_fname_decl (tree id, int type_dep)
2ce07e2d 3473{
83182544 3474 const char *const name = (type_dep && processing_template_decl
e913996d 3475 ? NULL : fname_as_string (type_dep));
bb885938
NS
3476 tree type;
3477 tree init = cp_fname_init (name, &type);
3478 tree decl = build_decl (VAR_DECL, id, type);
2ce07e2d 3479
9e6f2e7d 3480 if (name)
b1d5455a 3481 free (CONST_CAST (char *, name));
9e6f2e7d 3482
6cce57b0 3483 /* As we're using pushdecl_with_scope, we must set the context. */
0ba8a114
NS
3484 DECL_CONTEXT (decl) = current_function_decl;
3485 DECL_PRETTY_FUNCTION_P (decl) = type_dep;
caf93cb0 3486
2ce07e2d
NS
3487 TREE_STATIC (decl) = 1;
3488 TREE_READONLY (decl) = 1;
2ce07e2d 3489 DECL_ARTIFICIAL (decl) = 1;
caf93cb0 3490
0ba8a114 3491 TREE_USED (decl) = 1;
5362b086 3492
6cce57b0
JM
3493 if (current_function_decl)
3494 {
3495 struct cp_binding_level *b = current_binding_level;
a7e8c268 3496 while (b->level_chain->kind != sk_function_parms)
6cce57b0 3497 b = b->level_chain;
d63d5d0c 3498 pushdecl_with_scope (decl, b, /*is_friend=*/false);
3db45ab5 3499 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE,
d174af6c 3500 LOOKUP_ONLYCONVERTING);
e913996d 3501 }
ad16ae7f
MM
3502 else
3503 pushdecl_top_level_and_finish (decl, init);
caf93cb0 3504
2ce07e2d
NS
3505 return decl;
3506}
3507
c79efc4d
RÁE
3508static tree
3509builtin_function_1 (tree decl, tree context)
3510{
3511 tree id = DECL_NAME (decl);
3512 const char *name = IDENTIFIER_POINTER (id);
8d08fdba 3513
c79efc4d 3514 retrofit_lang_decl (decl);
0c11ada6 3515
c79efc4d
RÁE
3516 /* All nesting of C++ functions is lexical; there is never a "static
3517 chain" in the sense of GNU C nested functions. */
3518 DECL_NO_STATIC_CHAIN (decl) = 1;
3519
3520 DECL_ARTIFICIAL (decl) = 1;
3521 SET_OVERLOADED_OPERATOR_CODE (decl, ERROR_MARK);
3522 SET_DECL_LANGUAGE (decl, lang_c);
3523 /* Runtime library routines are, by definition, available in an
3524 external shared object. */
3525 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
3526 DECL_VISIBILITY_SPECIFIED (decl) = 1;
8d08fdba 3527
d52e4867 3528 DECL_CONTEXT (decl) = context;
12a22e76 3529
6bcedb4e 3530 pushdecl (decl);
6bcedb4e 3531
d63d5d0c
ILT
3532 /* A function in the user's namespace should have an explicit
3533 declaration before it is used. Mark the built-in function as
3534 anticipated but not actually declared. */
935d1834
ZW
3535 if (name[0] != '_' || name[1] != '_')
3536 DECL_ANTICIPATED (decl) = 1;
012c4da9
JJ
3537 else if (strncmp (name + 2, "builtin_", strlen ("builtin_")) != 0)
3538 {
3539 size_t len = strlen (name);
3540
3541 /* Treat __*_chk fortification functions as anticipated as well,
3542 unless they are __builtin_*. */
3543 if (len > strlen ("___chk")
3544 && memcmp (name + len - strlen ("_chk"),
3545 "_chk", strlen ("_chk") + 1) == 0)
3546 DECL_ANTICIPATED (decl) = 1;
3547 }
935d1834 3548
8d08fdba
MS
3549 return decl;
3550}
7f4edbcb 3551
d52e4867 3552tree
c79efc4d 3553cxx_builtin_function (tree decl)
d52e4867 3554{
c79efc4d
RÁE
3555 tree id = DECL_NAME (decl);
3556 const char *name = IDENTIFIER_POINTER (id);
d52e4867
RS
3557 /* All builtins that don't begin with an '_' should additionally
3558 go in the 'std' namespace. */
3559 if (name[0] != '_')
3560 {
e5b44dfb 3561 tree decl2 = copy_node(decl);
d52e4867 3562 push_namespace (std_identifier);
e5b44dfb 3563 builtin_function_1 (decl2, std_node);
d52e4867
RS
3564 pop_namespace ();
3565 }
3566
e5b44dfb 3567 return builtin_function_1 (decl, NULL_TREE);
d52e4867
RS
3568}
3569
0c11ada6
JM
3570/* Generate a FUNCTION_DECL with the typical flags for a runtime library
3571 function. Not called directly. */
3572
3573static tree
11f6b451 3574build_library_fn_1 (tree name, enum tree_code operator_code, tree type)
0c11ada6
JM
3575{
3576 tree fn = build_lang_decl (FUNCTION_DECL, name, type);
3577 DECL_EXTERNAL (fn) = 1;
3578 TREE_PUBLIC (fn) = 1;
3579 DECL_ARTIFICIAL (fn) = 1;
596ea4e5 3580 SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
5d2ed28c 3581 SET_DECL_LANGUAGE (fn, lang_c);
73a8adb6
MM
3582 /* Runtime library routines are, by definition, available in an
3583 external shared object. */
3584 DECL_VISIBILITY (fn) = VISIBILITY_DEFAULT;
3585 DECL_VISIBILITY_SPECIFIED (fn) = 1;
0c11ada6
JM
3586 return fn;
3587}
c2a37c55 3588
0c11ada6
JM
3589/* Returns the _DECL for a library function with C linkage.
3590 We assume that such functions never throw; if this is incorrect,
3591 callers should unset TREE_NOTHROW. */
c2a37c55 3592
448083e5 3593static tree
11f6b451 3594build_library_fn (tree name, tree type)
0c11ada6 3595{
f59d2aad
RH
3596 tree fn = build_library_fn_1 (name, ERROR_MARK, type);
3597 TREE_NOTHROW (fn) = 1;
3598 return fn;
0c11ada6
JM
3599}
3600
3601/* Returns the _DECL for a library function with C++ linkage. */
3602
596ea4e5 3603static tree
11f6b451 3604build_cp_library_fn (tree name, enum tree_code operator_code, tree type)
0c11ada6 3605{
596ea4e5 3606 tree fn = build_library_fn_1 (name, operator_code, type);
0c11ada6 3607 TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
6bbf1598 3608 DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
5d2ed28c 3609 SET_DECL_LANGUAGE (fn, lang_cplusplus);
0c11ada6
JM
3610 return fn;
3611}
3612
3613/* Like build_library_fn, but takes a C string instead of an
3614 IDENTIFIER_NODE. */
3615
3616tree
11f6b451 3617build_library_fn_ptr (const char* name, tree type)
7f4edbcb 3618{
0c11ada6
JM
3619 return build_library_fn (get_identifier (name), type);
3620}
3621
3622/* Like build_cp_library_fn, but takes a C string instead of an
3623 IDENTIFIER_NODE. */
3624
3625tree
11f6b451 3626build_cp_library_fn_ptr (const char* name, tree type)
0c11ada6 3627{
596ea4e5 3628 return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);
0c11ada6
JM
3629}
3630
3631/* Like build_library_fn, but also pushes the function so that we will
448083e5
PC
3632 be able to find it via IDENTIFIER_GLOBAL_VALUE. Also, the function
3633 may throw exceptions listed in RAISES. */
0c11ada6
JM
3634
3635tree
448083e5 3636push_library_fn (tree name, tree type, tree raises)
0c11ada6 3637{
448083e5
PC
3638 tree fn;
3639
3640 if (raises)
3641 type = build_exception_variant (type, raises);
3642
3643 fn = build_library_fn (name, type);
0c11ada6
JM
3644 pushdecl_top_level (fn);
3645 return fn;
3646}
3647
3648/* Like build_cp_library_fn, but also pushes the function so that it
3649 will be found by normal lookup. */
3650
596ea4e5 3651static tree
11f6b451 3652push_cp_library_fn (enum tree_code operator_code, tree type)
0c11ada6 3653{
5362b086 3654 tree fn = build_cp_library_fn (ansi_opname (operator_code),
596ea4e5
AS
3655 operator_code,
3656 type);
0c11ada6
JM
3657 pushdecl (fn);
3658 return fn;
3659}
3660
3661/* Like push_library_fn, but takes a TREE_LIST of parm types rather than
3662 a FUNCTION_TYPE. */
3663
3664tree
11f6b451 3665push_void_library_fn (tree name, tree parmtypes)
0c11ada6
JM
3666{
3667 tree type = build_function_type (void_type_node, parmtypes);
448083e5 3668 return push_library_fn (name, type, NULL_TREE);
0c11ada6
JM
3669}
3670
cf74fb86 3671/* Like push_library_fn, but also note that this function throws
0c11ada6
JM
3672 and does not return. Used for __throw_foo and the like. */
3673
3674tree
11f6b451 3675push_throw_library_fn (tree name, tree type)
0c11ada6 3676{
448083e5 3677 tree fn = push_library_fn (name, type, NULL_TREE);
0c11ada6
JM
3678 TREE_THIS_VOLATILE (fn) = 1;
3679 TREE_NOTHROW (fn) = 0;
3680 return fn;
7f4edbcb 3681}
8d08fdba 3682\f
61a127b3
MM
3683/* When we call finish_struct for an anonymous union, we create
3684 default copy constructors and such. But, an anonymous union
3685 shouldn't have such things; this function undoes the damage to the
3686 anonymous union type T.
3687
3688 (The reason that we create the synthesized methods is that we don't
3689 distinguish `union { int i; }' from `typedef union { int i; } U'.
3690 The first is an anonymous union; the second is just an ordinary
3691 union type.) */
3692
3693void
11f6b451 3694fixup_anonymous_aggr (tree t)
61a127b3
MM
3695{
3696 tree *q;
3697
f4f206f4 3698 /* Wipe out memory of synthesized methods. */
0fcedd9c 3699 TYPE_HAS_USER_CONSTRUCTOR (t) = 0;
61a127b3
MM
3700 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
3701 TYPE_HAS_INIT_REF (t) = 0;
3702 TYPE_HAS_CONST_INIT_REF (t) = 0;
3703 TYPE_HAS_ASSIGN_REF (t) = 0;
61a127b3
MM
3704 TYPE_HAS_CONST_ASSIGN_REF (t) = 0;
3705
3706 /* Splice the implicitly generated functions out of the TYPE_METHODS
3707 list. */
3708 q = &TYPE_METHODS (t);
3709 while (*q)
3710 {
3711 if (DECL_ARTIFICIAL (*q))
3712 *q = TREE_CHAIN (*q);
3713 else
3714 q = &TREE_CHAIN (*q);
3715 }
3716
cab1f180 3717 /* ISO C++ 9.5.3. Anonymous unions may not have function members. */
61a127b3 3718 if (TYPE_METHODS (t))
24f58e74
PC
3719 {
3720 tree decl = TYPE_MAIN_DECL (t);
3721
3722 if (TREE_CODE (t) != UNION_TYPE)
3723 error ("%Jan anonymous struct cannot have function members", decl);
3724 else
3725 error ("%Jan anonymous union cannot have function members", decl);
3726 }
a1c2b86d
JJ
3727
3728 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
3729 assignment operators (because they cannot have these methods themselves).
3730 For anonymous unions this is already checked because they are not allowed
3731 in any union, otherwise we have to check it. */
3732 if (TREE_CODE (t) != UNION_TYPE)
3733 {
3734 tree field, type;
3735
3736 for (field = TYPE_FIELDS (t); field; field = TREE_CHAIN (field))
3737 if (TREE_CODE (field) == FIELD_DECL)
3738 {
3739 type = TREE_TYPE (field);
3740 if (CLASS_TYPE_P (type))
3741 {
0cbd7506 3742 if (TYPE_NEEDS_CONSTRUCTING (type))
dee15844
JM
3743 error ("member %q+#D with constructor not allowed "
3744 "in anonymous aggregate", field);
a1c2b86d 3745 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
dee15844
JM
3746 error ("member %q+#D with destructor not allowed "
3747 "in anonymous aggregate", field);
a1c2b86d 3748 if (TYPE_HAS_COMPLEX_ASSIGN_REF (type))
dee15844
JM
3749 error ("member %q+#D with copy assignment operator "
3750 "not allowed in anonymous aggregate", field);
a1c2b86d
JJ
3751 }
3752 }
3753 }
61a127b3
MM
3754}
3755
72a93143 3756/* Make sure that a declaration with no declarator is well-formed, i.e.
a723baf1 3757 just declares a tagged type or anonymous union.
8d08fdba 3758
a723baf1 3759 Returns the type declared; or NULL_TREE if none. */
8d08fdba 3760
72a93143 3761tree
62d1db17 3762check_tag_decl (cp_decl_specifier_seq *declspecs)
8d08fdba 3763{
62d1db17
MM
3764 int saw_friend = declspecs->specs[(int)ds_friend] != 0;
3765 int saw_typedef = declspecs->specs[(int)ds_typedef] != 0;
a723baf1
MM
3766 /* If a class, struct, or enum type is declared by the DECLSPECS
3767 (i.e, if a class-specifier, enum-specifier, or non-typename
3768 elaborated-type-specifier appears in the DECLSPECS),
3769 DECLARED_TYPE is set to the corresponding type. */
3770 tree declared_type = NULL_TREE;
3771 bool error_p = false;
8d08fdba 3772
62d1db17 3773 if (declspecs->multiple_types_p)
72a93143 3774 error ("multiple types in one declaration");
62d1db17
MM
3775 else if (declspecs->redefined_builtin_type)
3776 {
3777 if (!in_system_header)
37ec60ed
JW
3778 permerror ("redeclaration of C++ built-in type %qT",
3779 declspecs->redefined_builtin_type);
62d1db17
MM
3780 return NULL_TREE;
3781 }
7e2067ca 3782
c827f22f
MM
3783 if (declspecs->type
3784 && TYPE_P (declspecs->type)
caf93cb0 3785 && ((TREE_CODE (declspecs->type) != TYPENAME_TYPE
9e1e64ec 3786 && MAYBE_CLASS_TYPE_P (declspecs->type))
62d1db17
MM
3787 || TREE_CODE (declspecs->type) == ENUMERAL_TYPE))
3788 declared_type = declspecs->type;
3789 else if (declspecs->type == error_mark_node)
3790 error_p = true;
a723baf1 3791 if (declared_type == NULL_TREE && ! saw_friend && !error_p)
37ec60ed 3792 permerror ("declaration does not declare anything");
1951a1b6 3793 /* Check for an anonymous union. */
9e1e64ec 3794 else if (declared_type && RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type))
a723baf1 3795 && TYPE_ANONYMOUS_P (declared_type))
0dd3962d 3796 {
e8186ecf 3797 /* 7/3 In a simple-declaration, the optional init-declarator-list
0cbd7506
MS
3798 can be omitted only when declaring a class (clause 9) or
3799 enumeration (7.2), that is, when the decl-specifier-seq contains
3800 either a class-specifier, an elaborated-type-specifier with
3801 a class-key (9.1), or an enum-specifier. In these cases and
3802 whenever a class-specifier or enum-specifier is present in the
3803 decl-specifier-seq, the identifiers in these specifiers are among
3804 the names being declared by the declaration (as class-name,
3805 enum-names, or enumerators, depending on the syntax). In such
3806 cases, and except for the declaration of an unnamed bit-field (9.6),
3807 the decl-specifier-seq shall introduce one or more names into the
3808 program, or shall redeclare a name introduced by a previous
3809 declaration. [Example:
3810 enum { }; // ill-formed
3811 typedef class { }; // ill-formed
3812 --end example] */
e8186ecf 3813 if (saw_typedef)
0cbd7506
MS
3814 {
3815 error ("missing type-name in typedef-declaration");
3816 return NULL_TREE;
3817 }
0dd3962d 3818 /* Anonymous unions are objects, so they can have specifiers. */;
a723baf1 3819 SET_ANON_AGGR_TYPE_P (declared_type);
6bdb8141 3820
fcf73884
MLI
3821 if (TREE_CODE (declared_type) != UNION_TYPE && !in_system_header)
3822 pedwarn (OPT_pedantic, "ISO C++ prohibits anonymous structs");
0dd3962d
JM
3823 }
3824
62d1db17 3825 else
8d08fdba 3826 {
62d1db17
MM
3827 if (declspecs->specs[(int)ds_inline]
3828 || declspecs->specs[(int)ds_virtual])
2d01edd7 3829 error ("%qs can only be specified for functions",
caf93cb0 3830 declspecs->specs[(int)ds_inline]
62d1db17
MM
3831 ? "inline" : "virtual");
3832 else if (saw_friend
caf93cb0 3833 && (!current_class_type
62d1db17 3834 || current_scope () != current_class_type))
2d01edd7 3835 error ("%<friend%> can only be specified inside a class");
62d1db17 3836 else if (declspecs->specs[(int)ds_explicit])
2d01edd7 3837 error ("%<explicit%> can only be specified for constructors");
62d1db17
MM
3838 else if (declspecs->storage_class)
3839 error ("a storage class can only be specified for objects "
3840 "and functions");
3841 else if (declspecs->specs[(int)ds_const]
3842 || declspecs->specs[(int)ds_volatile]
3843 || declspecs->specs[(int)ds_restrict]
3844 || declspecs->specs[(int)ds_thread])
3845 error ("qualifiers can only be specified for objects "
3846 "and functions");
41dc91a8
SB
3847 else if (saw_typedef)
3848 warning (0, "%<typedef%> was ignored in this declaration");
72a93143 3849 }
8d08fdba 3850
a723baf1 3851 return declared_type;
72a93143
JM
3852}
3853
3854/* Called when a declaration is seen that contains no names to declare.
3855 If its type is a reference to a structure, union or enum inherited
3856 from a containing scope, shadow that tag name for the current scope
3857 with a forward reference.
3858 If its type defines a new named structure or union
3859 or defines an enum, it is valid but we need not do anything here.
3860 Otherwise, it is an error.
3861
3862 C++: may have to grok the declspecs to learn about static,
caf93cb0 3863 complain for anonymous unions.
72a93143 3864
a723baf1
MM
3865 Returns the TYPE declared -- or NULL_TREE if none. */
3866
3867tree
62d1db17 3868shadow_tag (cp_decl_specifier_seq *declspecs)
72a93143
JM
3869{
3870 tree t = check_tag_decl (declspecs);
3871
a723baf1
MM
3872 if (!t)
3873 return NULL_TREE;
3874
3cabd8f9
MA
3875 if (declspecs->attributes)
3876 {
dee15844
JM
3877 warning (0, "attribute ignored in declaration of %q+#T", t);
3878 warning (0, "attribute for %q+#T must follow the %qs keyword",
3879 t, class_key_or_enum_as_string (t));
3cabd8f9
MA
3880
3881 }
3882
d2a8ac2c
LM
3883 if (maybe_process_partial_specialization (t) == error_mark_node)
3884 return NULL_TREE;
72a93143
JM
3885
3886 /* This is where the variables in an anonymous union are
3887 declared. An anonymous union declaration looks like:
3888 union { ... } ;
3889 because there is no declarator after the union, the parser
3890 sends that declaration here. */
a723baf1 3891 if (ANON_AGGR_TYPE_P (t))
72a93143 3892 {
6bdb8141 3893 fixup_anonymous_aggr (t);
72a93143
JM
3894
3895 if (TYPE_FIELDS (t))
3896 {
caf93cb0 3897 tree decl = grokdeclarator (/*declarator=*/NULL,
058b15c1 3898 declspecs, NORMAL, 0, NULL);
72a93143
JM
3899 finish_anon_union (decl);
3900 }
8d08fdba 3901 }
a723baf1
MM
3902
3903 return t;
8d08fdba
MS
3904}
3905\f
3906/* Decode a "typename", such as "int **", returning a ..._TYPE node. */
3907
3908tree
caf93cb0 3909groktypename (cp_decl_specifier_seq *type_specifiers,
62d1db17 3910 const cp_declarator *declarator)
8d08fdba 3911{
62d1db17 3912 tree attrs;
98884b26 3913 tree type;
62d1db17
MM
3914 attrs = type_specifiers->attributes;
3915 type_specifiers->attributes = NULL_TREE;
3916 type = grokdeclarator (declarator, type_specifiers, TYPENAME, 0, &attrs);
ba19e12f 3917 if (attrs && type != error_mark_node)
c206a697
JM
3918 {
3919 if (CLASS_TYPE_P (type))
b2a7def5
JM
3920 warning (OPT_Wattributes, "ignoring attributes applied to class type %qT "
3921 "outside of definition", type);
9e1e64ec 3922 else if (MAYBE_CLASS_TYPE_P (type))
b2a7def5
JM
3923 /* A template type parameter or other dependent type. */
3924 warning (OPT_Wattributes, "ignoring attributes applied to dependent "
3925 "type %qT without an associated declaration", type);
c206a697
JM
3926 else
3927 cplus_decl_attributes (&type, attrs, 0);
3928 }
98884b26 3929 return type;
8d08fdba
MS
3930}
3931
15896502
MM
3932/* Process a DECLARATOR for a function-scope variable declaration,
3933 namespace-scope variable declaration, or function declaration.
3934 (Function definitions go through start_function; class member
3935 declarations appearing in the body of the class go through
3936 grokfield.) The DECL corresponding to the DECLARATOR is returned.
3937 If an error occurs, the error_mark_node is returned instead.
3938
b87d79e6
JM
3939 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is 1
3940 if an explicit initializer is present, or 2 for an explicitly defaulted
3941 function, or 3 for an explicitly deleted function, but 0 if this is a
3942 variable implicitly initialized via a default constructor. ATTRIBUTES
3943 and PREFIX_ATTRIBUTES are GNU attributes associated with this
3944 declaration. *PUSHED_SCOPE_P is set to the scope entered in this
3945 function, if any; if set, the caller is responsible for calling
3946 pop_scope. */
8d08fdba 3947
8d08fdba 3948tree
caf93cb0 3949start_decl (const cp_declarator *declarator,
62d1db17 3950 cp_decl_specifier_seq *declspecs,
0cbd7506
MS
3951 int initialized,
3952 tree attributes,
3953 tree prefix_attributes,
4514aa8c 3954 tree *pushed_scope_p)
8d08fdba 3955{
59387d2e 3956 tree decl;
15896502 3957 tree type;
8d08fdba 3958 tree context;
c3b7031d 3959 bool was_public;
317c435f 3960 int flags;
8d08fdba 3961
4514aa8c 3962 *pushed_scope_p = NULL_TREE;
c8094d83 3963
e23bd218
IR
3964 /* An object declared as __attribute__((deprecated)) suppresses
3965 warnings of uses of other deprecated items. */
3966 if (lookup_attribute ("deprecated", attributes))
3967 deprecated_state = DEPRECATED_SUPPRESS;
3968
91d231cb 3969 attributes = chainon (attributes, prefix_attributes);
b17e2870 3970
c11b6f21 3971 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
91d231cb 3972 &attributes);
68642fb6 3973
e23bd218
IR
3974 deprecated_state = DEPRECATED_NORMAL;
3975
2d00b4f2
AP
3976 if (decl == NULL_TREE || TREE_CODE (decl) == VOID_TYPE
3977 || decl == error_mark_node)
44370687 3978 return error_mark_node;
8d08fdba
MS
3979
3980 type = TREE_TYPE (decl);
3981
4f1c5b7d 3982 context = DECL_CONTEXT (decl);
8d08fdba 3983
73a8adb6 3984 if (context)
4514aa8c
NS
3985 {
3986 *pushed_scope_p = push_scope (context);
c8094d83 3987
4514aa8c
NS
3988 /* We are only interested in class contexts, later. */
3989 if (TREE_CODE (context) == NAMESPACE_DECL)
3990 context = NULL_TREE;
3991 }
2c73f9f5 3992
8d08fdba
MS
3993 if (initialized)
3994 /* Is it valid for this decl to have an initializer at all?
3995 If not, set INITIALIZED to zero, which will indirectly
82580166 3996 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
8d08fdba
MS
3997 switch (TREE_CODE (decl))
3998 {
3999 case TYPE_DECL:
b87d79e6 4000 error ("typedef %qD is initialized (use decltype instead)", decl);
cc011e7f 4001 return error_mark_node;
8d08fdba
MS
4002
4003 case FUNCTION_DECL:
b87d79e6
JM
4004 if (initialized == 3)
4005 /* We'll handle the rest of the semantics later, but we need to
4006 set this now so it's visible to duplicate_decls. */
4007 DECL_DELETED_FN (decl) = 1;
4008 break;
8d08fdba
MS
4009
4010 default:
3e41d13b 4011 break;
8d08fdba
MS
4012 }
4013
8d08fdba
MS
4014 if (initialized)
4015 {
a9aedbc2 4016 if (! toplevel_bindings_p ()
8d08fdba 4017 && DECL_EXTERNAL (decl))
d4ee4d25 4018 warning (0, "declaration of %q#D has %<extern%> and is initialized",
0cbd7506 4019 decl);
8d08fdba 4020 DECL_EXTERNAL (decl) = 0;
5566b478 4021 if (toplevel_bindings_p ())
8d08fdba 4022 TREE_STATIC (decl) = 1;
8d08fdba
MS
4023 }
4024
317c435f
JM
4025 /* If this is a typedef that names the class for linkage purposes
4026 (7.1.3p8), apply any attributes directly to the type. */
4027 if (TREE_CODE (decl) == TYPE_DECL
4028 && TAGGED_TYPE_P (TREE_TYPE (decl))
4029 && decl == TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl))))
4030 flags = ATTR_FLAG_TYPE_IN_PLACE;
4031 else
4032 flags = 0;
4033
fa20888b 4034 /* Set attributes here so if duplicate decl, will have proper attributes. */
317c435f 4035 cplus_decl_attributes (&decl, attributes, flags);
fa20888b 4036
4e2bb0a4
DS
4037 /* Dllimported symbols cannot be defined. Static data members (which
4038 can be initialized in-class and dllimported) go through grokfield,
4039 not here, so we don't need to exclude those decls when checking for
4040 a definition. */
4041 if (initialized && DECL_DLLIMPORT_P (decl))
4042 {
4043 error ("definition of %q#D is marked %<dllimport%>", decl);
4044 DECL_DLLIMPORT_P (decl) = 0;
4045 }
4046
ecb0eece 4047 /* If #pragma weak was used, mark the decl weak now. */
3693d46c 4048 maybe_apply_pragma_weak (decl);
ecb0eece 4049
97055d5c
AO
4050 if (TREE_CODE (decl) == FUNCTION_DECL
4051 && DECL_DECLARED_INLINE_P (decl)
4052 && DECL_UNINLINABLE (decl)
4053 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
dee15844 4054 warning (0, "inline function %q+D given attribute noinline", decl);
97055d5c 4055
d0f062fb 4056 if (context && COMPLETE_TYPE_P (complete_type (context)))
5b605f68
MS
4057 {
4058 if (TREE_CODE (decl) == VAR_DECL)
4059 {
86ac0575 4060 tree field = lookup_field (context, DECL_NAME (decl), 0, false);
5b605f68 4061 if (field == NULL_TREE || TREE_CODE (field) != VAR_DECL)
2d01edd7 4062 error ("%q#D is not a static member of %q#T", decl, context);
e349ee73
MS
4063 else
4064 {
4065 if (DECL_CONTEXT (field) != context)
f2d773a2 4066 {
a723baf1 4067 if (!same_type_p (DECL_CONTEXT (field), context))
37ec60ed
JW
4068 permerror ("ISO C++ does not permit %<%T::%D%> "
4069 "to be defined as %<%T::%D%>",
4070 DECL_CONTEXT (field), DECL_NAME (decl),
4071 context, DECL_NAME (decl));
f2d773a2
JM
4072 DECL_CONTEXT (decl) = DECL_CONTEXT (field);
4073 }
91146169
GB
4074 if (processing_specialization
4075 && template_class_depth (context) == 0
4076 && CLASSTYPE_TEMPLATE_SPECIALIZATION (context))
4077 error ("template header not allowed in member definition "
4078 "of explicitly specialized class");
75650646
MM
4079 /* Static data member are tricky; an in-class initialization
4080 still doesn't provide a definition, so the in-class
4081 declaration will have DECL_EXTERNAL set, but will have an
4082 initialization. Thus, duplicate_decls won't warn
4083 about this situation, and so we check here. */
e92fb501 4084 if (initialized && DECL_INITIALIZED_IN_CLASS_P (field))
9e637a26 4085 error ("duplicate initialization of %qD", decl);
d63d5d0c 4086 if (duplicate_decls (decl, field, /*newdecl_is_friend=*/false))
e349ee73
MS
4087 decl = field;
4088 }
5b605f68 4089 }
f30432d7
MS
4090 else
4091 {
d43f603d 4092 tree field = check_classfn (context, decl,
44021471
GB
4093 (processing_template_decl
4094 > template_class_depth (context))
4095 ? current_template_parms
4096 : NULL_TREE);
f8c3b097
PC
4097 if (field && field != error_mark_node
4098 && duplicate_decls (decl, field,
4099 /*newdecl_is_friend=*/false))
f30432d7
MS
4100 decl = field;
4101 }
4102
4103 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
dff3e828 4104 DECL_IN_AGGR_P (decl) = 0;
9267ee62
NS
4105 /* Do not mark DECL as an explicit specialization if it was not
4106 already marked as an instantiation; a declaration should
4107 never be marked as a specialization unless we know what
c8094d83 4108 template is being specialized. */
9267ee62 4109 if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
84e6233f 4110 {
9267ee62 4111 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
c8094d83 4112
84e6233f
JM
4113 /* [temp.expl.spec] An explicit specialization of a static data
4114 member of a template is a definition if the declaration
4115 includes an initializer; otherwise, it is a declaration.
c8094d83 4116
84e6233f
JM
4117 We check for processing_specialization so this only applies
4118 to the new specialization syntax. */
e92fb501 4119 if (!initialized && processing_specialization)
84e6233f
JM
4120 DECL_EXTERNAL (decl) = 1;
4121 }
f30432d7 4122
b7698cf0 4123 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl))
37ec60ed
JW
4124 permerror ("declaration of %q#D outside of class is not definition",
4125 decl);
5b605f68
MS
4126 }
4127
c3b7031d
JM
4128 was_public = TREE_PUBLIC (decl);
4129
9188c363 4130 /* Enter this declaration into the symbol table. */
15896502 4131 decl = maybe_push_decl (decl);
2ee887f2 4132
5156628f 4133 if (processing_template_decl)
15896502
MM
4134 decl = push_template_decl (decl);
4135 if (decl == error_mark_node)
156fc2bb 4136 return error_mark_node;
5566b478 4137
3b426391 4138 /* Tell the back end to use or not use .common as appropriate. If we say
a50f0918
MS
4139 -fconserve-space, we want this to save .data space, at the expense of
4140 wrong semantics. If we say -fno-conserve-space, we want this to
4141 produce errors about redefs; to do this we force variables into the
4142 data segment. */
434aeebb 4143 if (flag_conserve_space
15896502
MM
4144 && TREE_CODE (decl) == VAR_DECL
4145 && TREE_PUBLIC (decl)
4146 && !DECL_THREAD_LOCAL_P (decl)
434aeebb 4147 && !have_global_bss_p ())
15896502 4148 DECL_COMMON (decl) = 1;
68642fb6 4149
15896502
MM
4150 if (TREE_CODE (decl) == VAR_DECL
4151 && DECL_NAMESPACE_SCOPE_P (decl) && !TREE_PUBLIC (decl) && !was_public
4152 && !DECL_THIS_STATIC (decl) && !DECL_ARTIFICIAL (decl))
c3b7031d
JM
4153 {
4154 /* This is a const variable with implicit 'static'. Set
4155 DECL_THIS_STATIC so we can tell it from variables that are
4156 !TREE_PUBLIC because of the anonymous namespace. */
15896502
MM
4157 gcc_assert (cp_type_readonly (TREE_TYPE (decl)));
4158 DECL_THIS_STATIC (decl) = 1;
c3b7031d
JM
4159 }
4160
15896502
MM
4161 if (!processing_template_decl && TREE_CODE (decl) == VAR_DECL)
4162 start_decl_1 (decl, initialized);
8d08fdba 4163
15896502 4164 return decl;
8d08fdba
MS
4165}
4166
15896502
MM
4167/* Process the declaration of a variable DECL. INITIALIZED is true
4168 iff DECL is explicitly initialized. (INITIALIZED is false if the
4169 variable is initialized via an implicitly-called constructor.)
4170 This function must be called for ordinary variables (including, for
4171 example, implicit instantiations of templates), but must not be
4172 called for template declarations. */
4173
5566b478 4174void
e92fb501 4175start_decl_1 (tree decl, bool initialized)
8d08fdba 4176{
e92fb501 4177 tree type;
15896502
MM
4178 bool complete_p;
4179 bool aggregate_definition_p;
8d08fdba 4180
e92fb501
MM
4181 gcc_assert (!processing_template_decl);
4182
4183 if (error_operand_p (decl))
44689c12
ML
4184 return;
4185
e92fb501 4186 gcc_assert (TREE_CODE (decl) == VAR_DECL);
15896502 4187
e92fb501 4188 type = TREE_TYPE (decl);
15896502 4189 complete_p = COMPLETE_TYPE_P (type);
9e1e64ec 4190 aggregate_definition_p = MAYBE_CLASS_TYPE_P (type) && !DECL_EXTERNAL (decl);
15896502
MM
4191
4192 /* If an explicit initializer is present, or if this is a definition
4193 of an aggregate, then we need a complete type at this point.
4194 (Scalars are always complete types, so there is nothing to
4195 check.) This code just sets COMPLETE_P; errors (if necessary)
4196 are issued below. */
4197 if ((initialized || aggregate_definition_p)
4198 && !complete_p
4199 && COMPLETE_TYPE_P (complete_type (type)))
4200 {
4201 complete_p = true;
4202 /* We will not yet have set TREE_READONLY on DECL if the type
4203 was "const", but incomplete, before this point. But, now, we
4204 have a complete type, so we can try again. */
4205 cp_apply_type_quals_to_decl (cp_type_quals (type), decl);
4206 }
e92fb501 4207
5566b478 4208 if (initialized)
15896502 4209 /* Is it valid for this decl to have an initializer at all? */
8d08fdba 4210 {
5566b478
MS
4211 /* Don't allow initializations for incomplete types except for
4212 arrays which might be completed by the initialization. */
15896502 4213 if (complete_p)
5566b478
MS
4214 ; /* A complete type is ok. */
4215 else if (TREE_CODE (type) != ARRAY_TYPE)
8d08fdba 4216 {
2d01edd7 4217 error ("variable %q#D has initializer but incomplete type", decl);
25eb19ff 4218 type = TREE_TYPE (decl) = error_mark_node;
5566b478 4219 }
d0f062fb 4220 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
5566b478
MS
4221 {
4222 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
2d01edd7 4223 error ("elements of array %q#D have incomplete type", decl);
5566b478 4224 /* else we already gave an error in start_decl. */
8d08fdba 4225 }
8d08fdba 4226 }
15896502 4227 else if (aggregate_definition_p && !complete_p)
8d08fdba 4228 {
15896502
MM
4229 error ("aggregate %q#D has incomplete type and cannot be defined",
4230 decl);
4231 /* Change the type so that assemble_variable will give
4232 DECL an rtl we can live with: (mem (const_int 0)). */
4233 type = TREE_TYPE (decl) = error_mark_node;
5566b478
MS
4234 }
4235
c6671cbb
MM
4236 /* Create a new scope to hold this declaration if necessary.
4237 Whether or not a new scope is necessary cannot be determined
4238 until after the type has been completed; if the type is a
4239 specialization of a class template it is not until after
4240 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
4241 will be set correctly. */
4242 maybe_push_cleanup_level (type);
5566b478
MS
4243}
4244
7e99327d
MM
4245/* Handle initialization of references. DECL, TYPE, and INIT have the
4246 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
4247 but will be set to a new CLEANUP_STMT if a temporary is created
cd0be382 4248 that must be destroyed subsequently.
7e99327d
MM
4249
4250 Returns an initializer expression to use to initialize DECL, or
4251 NULL if the initialization can be performed statically.
e92cc029
MS
4252
4253 Quotes on semantics can be found in ARM 8.4.3. */
4254
8e4ce833 4255static tree
7e99327d 4256grok_reference_init (tree decl, tree type, tree init, tree *cleanup)
5566b478
MS
4257{
4258 tree tmp;
4259
4260 if (init == NULL_TREE)
4261 {
4262 if ((DECL_LANG_SPECIFIC (decl) == 0
4263 || DECL_IN_AGGR_P (decl) == 0)
4264 && ! DECL_THIS_EXTERN (decl))
c4f73174 4265 error ("%qD declared as reference but not initialized", decl);
8e4ce833 4266 return NULL_TREE;
5566b478
MS
4267 }
4268
ed5511d9 4269 if (TREE_CODE (init) == CONSTRUCTOR)
5566b478 4270 {
2d01edd7 4271 error ("ISO C++ forbids use of initializer list to "
0cbd7506 4272 "initialize reference %qD", decl);
8e4ce833 4273 return NULL_TREE;
8d08fdba
MS
4274 }
4275
4276 if (TREE_CODE (init) == TREE_LIST)
c7b62f14 4277 init = build_x_compound_expr_from_list (init, "initializer");
8d08fdba
MS
4278
4279 if (TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE
4280 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
0a72704b
MM
4281 /* Note: default conversion is only called in very special cases. */
4282 init = decay_conversion (init);
68642fb6 4283
24bef158
MM
4284 /* Convert INIT to the reference type TYPE. This may involve the
4285 creation of a temporary, whose lifetime must be the same as that
350fae66
RK
4286 of the reference. If so, a DECL_EXPR for the temporary will be
4287 added just after the DECL_EXPR for DECL. That's why we don't set
24bef158
MM
4288 DECL_INITIAL for local references (instead assigning to them
4289 explicitly); we need to allow the temporary to be initialized
4290 first. */
7e99327d 4291 tmp = initialize_reference (type, init, decl, cleanup);
8d08fdba 4292
a3203465 4293 if (tmp == error_mark_node)
8e4ce833
JJ
4294 return NULL_TREE;
4295 else if (tmp == NULL_TREE)
8d08fdba 4296 {
2d01edd7 4297 error ("cannot initialize %qT from %qT", type, TREE_TYPE (init));
8e4ce833 4298 return NULL_TREE;
8d08fdba 4299 }
8d08fdba 4300
8e4ce833
JJ
4301 if (TREE_STATIC (decl) && !TREE_CONSTANT (tmp))
4302 return tmp;
4303
08ac397c 4304 DECL_INITIAL (decl) = tmp;
8e4ce833
JJ
4305
4306 return NULL_TREE;
8d08fdba
MS
4307}
4308
09357846
JM
4309/* Subroutine of check_initializer. We're initializing a DECL of
4310 std::initializer_list<T> TYPE from a braced-init-list INIT, and need to
4311 extend the lifetime of the underlying array to match that of the decl,
4312 just like for reference initialization. CLEANUP is as for
4313 grok_reference_init. */
4314
4315static tree
4316build_init_list_var_init (tree decl, tree type, tree init, tree *cleanup)
4317{
4318 tree aggr_init, array, arrtype;
4319 init = perform_implicit_conversion (type, init, tf_warning_or_error);
4320 aggr_init = TARGET_EXPR_INITIAL (init);
4321 init = build2 (INIT_EXPR, type, decl, init);
4322
4323 array = AGGR_INIT_EXPR_ARG (aggr_init, 1);
4324 arrtype = TREE_TYPE (array);
4325 STRIP_NOPS (array);
4326 gcc_assert (TREE_CODE (array) == ADDR_EXPR);
4327 array = TREE_OPERAND (array, 0);
4328 /* If the array is constant, finish_compound_literal already made it a
4329 static variable and we don't need to do anything here. */
4330 if (decl && TREE_CODE (array) == TARGET_EXPR)
4331 {
4332 tree subinit;
4333 tree var = set_up_extended_ref_temp (decl, array, cleanup, &subinit);
4334 var = build_address (var);
4335 var = convert (arrtype, var);
4336 AGGR_INIT_EXPR_ARG (aggr_init, 1) = var;
4337 init = build2 (COMPOUND_EXPR, TREE_TYPE (init), subinit, init);
4338 }
4339 return init;
4340}
4341
76239779
MM
4342/* Designated initializers in arrays are not supported in GNU C++.
4343 The parser cannot detect this error since it does not know whether
4344 a given brace-enclosed initializer is for a class type or for an
4345 array. This function checks that CE does not use a designated
4346 initializer. If it does, an error is issued. Returns true if CE
4347 is valid, i.e., does not have a designated initializer. */
4348
4349static bool
4350check_array_designated_initializer (const constructor_elt *ce)
4351{
48c9a7f0 4352 /* Designated initializers for array elements are not supported. */
76239779
MM
4353 if (ce->index)
4354 {
4355 /* The parser only allows identifiers as designated
39a13be5 4356 initializers. */
76239779
MM
4357 gcc_assert (TREE_CODE (ce->index) == IDENTIFIER_NODE);
4358 error ("name %qD used in a GNU-style designated "
4359 "initializer for an array", ce->index);
4360 return false;
4361 }
4362
4363 return true;
4364}
4365
27778b73
MM
4366/* When parsing `int a[] = {1, 2};' we don't know the size of the
4367 array until we finish parsing the initializer. If that's the
4368 situation we're in, update DECL accordingly. */
4369
4370static void
11f6b451 4371maybe_deduce_size_from_array_init (tree decl, tree init)
27778b73
MM
4372{
4373 tree type = TREE_TYPE (decl);
4374
4375 if (TREE_CODE (type) == ARRAY_TYPE
4376 && TYPE_DOMAIN (type) == NULL_TREE
4377 && TREE_CODE (decl) != TYPE_DECL)
4378 {
f2ae0c45
JM
4379 /* do_default is really a C-ism to deal with tentative definitions.
4380 But let's leave it here to ease the eventual merge. */
4381 int do_default = !DECL_EXTERNAL (decl);
27778b73 4382 tree initializer = init ? init : DECL_INITIAL (decl);
76239779 4383 int failure = 0;
27778b73 4384
76239779
MM
4385 /* Check that there are no designated initializers in INIT, as
4386 those are not supported in GNU C++, and as the middle-end
4387 will crash if presented with a non-numeric designated
4388 initializer. */
4389 if (initializer && TREE_CODE (initializer) == CONSTRUCTOR)
2b643eda 4390 {
76239779
MM
4391 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initializer);
4392 constructor_elt *ce;
4393 HOST_WIDE_INT i;
4394 for (i = 0;
4395 VEC_iterate (constructor_elt, v, i, ce);
49b5e2f6 4396 ++i)
76239779
MM
4397 if (!check_array_designated_initializer (ce))
4398 failure = 1;
2b643eda 4399 }
76239779
MM
4400
4401 if (!failure)
27778b73 4402 {
76239779
MM
4403 failure = cp_complete_array_type (&TREE_TYPE (decl), initializer,
4404 do_default);
4405 if (failure == 1)
2b643eda 4406 {
76239779
MM
4407 error ("initializer fails to determine size of %qD", decl);
4408 TREE_TYPE (decl) = error_mark_node;
4409 }
4410 else if (failure == 2)
4411 {
4412 if (do_default)
4413 {
4414 error ("array size missing in %qD", decl);
4415 TREE_TYPE (decl) = error_mark_node;
4416 }
4417 /* If a `static' var's size isn't known, make it extern as
4418 well as static, so it does not get allocated. If it's not
4419 `static', then don't mark it extern; finish_incomplete_decl
4420 will give it a default size and it will get allocated. */
4421 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
4422 DECL_EXTERNAL (decl) = 1;
4423 }
4424 else if (failure == 3)
4425 {
4426 error ("zero-size array %qD", decl);
2b643eda
MM
4427 TREE_TYPE (decl) = error_mark_node;
4428 }
2b643eda 4429 }
27778b73 4430
f23b8501
JJ
4431 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl)), decl);
4432
27778b73
MM
4433 layout_decl (decl, 0);
4434 }
4435}
4436
4437/* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
57b52417 4438 any appropriate error messages regarding the layout. */
27778b73 4439
57b52417 4440static void
11f6b451 4441layout_var_decl (tree decl)
27778b73 4442{
2b643eda
MM
4443 tree type;
4444
2b643eda
MM
4445 type = TREE_TYPE (decl);
4446 if (type == error_mark_node)
4447 return;
57b52417
MM
4448
4449 /* If we haven't already layed out this declaration, do so now.
4450 Note that we must not call complete type for an external object
4451 because it's type might involve templates that we are not
34cd5ae7 4452 supposed to instantiate yet. (And it's perfectly valid to say
57b52417
MM
4453 `extern X x' for some incomplete type `X'.) */
4454 if (!DECL_EXTERNAL (decl))
4455 complete_type (type);
caf93cb0 4456 if (!DECL_SIZE (decl)
328de7c2 4457 && TREE_TYPE (decl) != error_mark_node
7de85f7e 4458 && (COMPLETE_TYPE_P (type)
caf93cb0 4459 || (TREE_CODE (type) == ARRAY_TYPE
7de85f7e
MM
4460 && !TYPE_DOMAIN (type)
4461 && COMPLETE_TYPE_P (TREE_TYPE (type)))))
27778b73
MM
4462 layout_decl (decl, 0);
4463
c82dbd95 4464 if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
27778b73
MM
4465 {
4466 /* An automatic variable with an incomplete type: that is an error.
4467 Don't talk about array types here, since we took care of that
4468 message in grokdeclarator. */
2d01edd7 4469 error ("storage size of %qD isn't known", decl);
27778b73
MM
4470 TREE_TYPE (decl) = error_mark_node;
4471 }
ae673f14
JM
4472#if 0
4473 /* Keep this code around in case we later want to control debug info
4474 based on whether a type is "used". (jason 1999-11-11) */
4475
9e1e64ec 4476 else if (!DECL_EXTERNAL (decl) && MAYBE_CLASS_TYPE_P (ttype))
27778b73
MM
4477 /* Let debugger know it should output info for this type. */
4478 note_debug_info_needed (ttype);
4479
4480 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
4481 note_debug_info_needed (DECL_CONTEXT (decl));
ae673f14 4482#endif
27778b73
MM
4483
4484 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
4485 && DECL_SIZE (decl) != NULL_TREE
4486 && ! TREE_CONSTANT (DECL_SIZE (decl)))
4487 {
4488 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
4489 constant_expression_warning (DECL_SIZE (decl));
4490 else
b97d8153
JJ
4491 {
4492 error ("storage size of %qD isn't constant", decl);
4493 TREE_TYPE (decl) = error_mark_node;
4494 }
27778b73
MM
4495 }
4496}
4497
27778b73
MM
4498/* If a local static variable is declared in an inline function, or if
4499 we have a weak definition, we must endeavor to create only one
4500 instance of the variable at link-time. */
4501
4502static void
11f6b451 4503maybe_commonize_var (tree decl)
27778b73
MM
4504{
4505 /* Static data in a function with comdat linkage also has comdat
4506 linkage. */
4507 if (TREE_STATIC (decl)
4508 /* Don't mess with __FUNCTION__. */
cf74fb86 4509 && ! DECL_ARTIFICIAL (decl)
0b50d7f1
MM
4510 && DECL_FUNCTION_SCOPE_P (decl)
4511 /* Unfortunately, import_export_decl has not always been called
4512 before the function is processed, so we cannot simply check
caf93cb0 4513 DECL_COMDAT. */
9e6aaf5e 4514 && (DECL_COMDAT (DECL_CONTEXT (decl))
0b50d7f1
MM
4515 || ((DECL_DECLARED_INLINE_P (DECL_CONTEXT (decl))
4516 || DECL_TEMPLATE_INSTANTIATION (DECL_CONTEXT (decl)))
4517 && TREE_PUBLIC (DECL_CONTEXT (decl)))))
27778b73 4518 {
0dbc5cd3 4519 if (flag_weak)
27778b73 4520 {
0dbc5cd3
MM
4521 /* With weak symbols, we simply make the variable COMDAT;
4522 that will cause copies in multiple translations units to
4523 be merged. */
4524 comdat_linkage (decl);
4525 }
4526 else
4527 {
4528 if (DECL_INITIAL (decl) == NULL_TREE
4529 || DECL_INITIAL (decl) == error_mark_node)
27778b73 4530 {
0dbc5cd3
MM
4531 /* Without weak symbols, we can use COMMON to merge
4532 uninitialized variables. */
27778b73
MM
4533 TREE_PUBLIC (decl) = 1;
4534 DECL_COMMON (decl) = 1;
4535 }
0dbc5cd3 4536 else
27778b73 4537 {
0dbc5cd3
MM
4538 /* While for initialized variables, we must use internal
4539 linkage -- which means that multiple copies will not
4540 be merged. */
4541 TREE_PUBLIC (decl) = 0;
4542 DECL_COMMON (decl) = 0;
dee15844
JM
4543 warning (0, "sorry: semantics of inline function static "
4544 "data %q+#D are wrong (you'll wind up "
4545 "with multiple copies)", decl);
d4ee4d25 4546 warning (0, "%J you can work around this by removing "
0cbd7506 4547 "the initializer",
ddd2d57e 4548 decl);
27778b73
MM
4549 }
4550 }
4551 }
4552 else if (DECL_LANG_SPECIFIC (decl) && DECL_COMDAT (decl))
4553 /* Set it up again; we might have set DECL_INITIAL since the last
4554 time. */
4555 comdat_linkage (decl);
4556}
4557
91063b51
MM
4558/* Issue an error message if DECL is an uninitialized const variable. */
4559
4560static void
11f6b451 4561check_for_uninitialized_const_var (tree decl)
91063b51
MM
4562{
4563 tree type = TREE_TYPE (decl);
4564
4565 /* ``Unless explicitly declared extern, a const object does not have
4566 external linkage and must be initialized. ($8.4; $12.1)'' ARM
4567 7.1.6 */
4568 if (TREE_CODE (decl) == VAR_DECL
4569 && TREE_CODE (type) != REFERENCE_TYPE
4570 && CP_TYPE_CONST_P (type)
4571 && !TYPE_NEEDS_CONSTRUCTING (type)
4572 && !DECL_INITIAL (decl))
2d01edd7 4573 error ("uninitialized const %qD", decl);
91063b51
MM
4574}
4575
4038c495
GB
4576\f
4577/* Structure holding the current initializer being processed by reshape_init.
4578 CUR is a pointer to the current element being processed, END is a pointer
4579 after the last element present in the initializer. */
4580typedef struct reshape_iterator_t
4581{
4582 constructor_elt *cur;
4583 constructor_elt *end;
4584} reshape_iter;
4585
4586static tree reshape_init_r (tree, reshape_iter *, bool);
4587
8e3df2de
MM
4588/* FIELD is a FIELD_DECL or NULL. In the former case, the value
4589 returned is the next FIELD_DECL (possibly FIELD itself) that can be
4590 initialized. If there are no more such fields, the return value
4591 will be NULL. */
4592
4593static tree
4594next_initializable_field (tree field)
4595{
4596 while (field
4597 && (TREE_CODE (field) != FIELD_DECL
4598 || (DECL_C_BIT_FIELD (field) && !DECL_NAME (field))
4599 || DECL_ARTIFICIAL (field)))
4600 field = TREE_CHAIN (field);
4601
4602 return field;
4603}
4604
4038c495
GB
4605/* Subroutine of reshape_init_array and reshape_init_vector, which does
4606 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
4607 INTEGER_CST representing the size of the array minus one (the maximum index),
4608 or NULL_TREE if the array was declared without specifying the size. D is
4609 the iterator within the constructor. */
4610
4611static tree
4612reshape_init_array_1 (tree elt_type, tree max_index, reshape_iter *d)
3d142be2 4613{
4038c495 4614 tree new_init;
3d142be2 4615 bool sized_array_p = (max_index != NULL_TREE);
004c400a
JJ
4616 unsigned HOST_WIDE_INT max_index_cst = 0;
4617 unsigned HOST_WIDE_INT index;
3d142be2 4618
4038c495 4619 /* The initializer for an array is always a CONSTRUCTOR. */
09357846 4620 new_init = build_constructor (init_list_type_node, NULL);
4038c495 4621
3d142be2 4622 if (sized_array_p)
004c400a 4623 {
d7d93837
AH
4624 /* Minus 1 is used for zero sized arrays. */
4625 if (integer_all_onesp (max_index))
4626 return new_init;
4627
004c400a
JJ
4628 if (host_integerp (max_index, 1))
4629 max_index_cst = tree_low_cst (max_index, 1);
4630 /* sizetype is sign extended, not zero extended. */
4631 else
4632 max_index_cst = tree_low_cst (fold_convert (size_type_node, max_index),
4633 1);
4634 }
3d142be2
GB
4635
4636 /* Loop until there are no more initializers. */
4637 for (index = 0;
4038c495 4638 d->cur != d->end && (!sized_array_p || index <= max_index_cst);
3d142be2
GB
4639 ++index)
4640 {
4038c495
GB
4641 tree elt_init;
4642
76239779 4643 check_array_designated_initializer (d->cur);
4038c495 4644 elt_init = reshape_init_r (elt_type, d, /*first_initializer_p=*/false);
07471dfb
MM
4645 if (elt_init == error_mark_node)
4646 return error_mark_node;
4038c495 4647 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), NULL_TREE, elt_init);
3d142be2
GB
4648 }
4649
4038c495 4650 return new_init;
3d142be2
GB
4651}
4652
4038c495
GB
4653/* Subroutine of reshape_init_r, processes the initializers for arrays.
4654 Parameters are the same of reshape_init_r. */
8e3df2de 4655
4038c495
GB
4656static tree
4657reshape_init_array (tree type, reshape_iter *d)
4658{
4659 tree max_index = NULL_TREE;
caf93cb0 4660
4038c495 4661 gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
8e3df2de 4662
4038c495
GB
4663 if (TYPE_DOMAIN (type))
4664 max_index = array_type_nelts (type);
4665
4666 return reshape_init_array_1 (TREE_TYPE (type), max_index, d);
4667}
4668
4669/* Subroutine of reshape_init_r, processes the initializers for vectors.
4670 Parameters are the same of reshape_init_r. */
8e3df2de
MM
4671
4672static tree
4038c495 4673reshape_init_vector (tree type, reshape_iter *d)
8e3df2de 4674{
4038c495
GB
4675 tree max_index = NULL_TREE;
4676 tree rtype;
4677
4678 gcc_assert (TREE_CODE (type) == VECTOR_TYPE);
4679
3b2db49f 4680 if (COMPOUND_LITERAL_P (d->cur->value))
4038c495
GB
4681 {
4682 tree value = d->cur->value;
4683 if (!same_type_p (TREE_TYPE (value), type))
4684 {
4685 error ("invalid type %qT as initializer for a vector of type %qT",
4686 TREE_TYPE (d->cur->value), type);
3db45ab5 4687 value = error_mark_node;
4038c495
GB
4688 }
4689 ++d->cur;
4690 return value;
4691 }
4692
4693 /* For a vector, the representation type is a struct
4694 containing a single member which is an array of the
4695 appropriate size. */
4696 rtype = TYPE_DEBUG_REPRESENTATION_TYPE (type);
4697 if (rtype && TYPE_DOMAIN (TREE_TYPE (TYPE_FIELDS (rtype))))
4698 max_index = array_type_nelts (TREE_TYPE (TYPE_FIELDS (rtype)));
4699
4700 return reshape_init_array_1 (TREE_TYPE (type), max_index, d);
4701}
4702
4703/* Subroutine of reshape_init_r, processes the initializers for classes
4704 or union. Parameters are the same of reshape_init_r. */
4705
4706static tree
4707reshape_init_class (tree type, reshape_iter *d, bool first_initializer_p)
4708{
4709 tree field;
8e3df2de 4710 tree new_init;
8e3df2de 4711
4038c495 4712 gcc_assert (CLASS_TYPE_P (type));
8e3df2de 4713
4038c495 4714 /* The initializer for a class is always a CONSTRUCTOR. */
09357846 4715 new_init = build_constructor (init_list_type_node, NULL);
4038c495 4716 field = next_initializable_field (TYPE_FIELDS (type));
ee7ecb29 4717
4038c495 4718 if (!field)
8e3df2de 4719 {
4038c495
GB
4720 /* [dcl.init.aggr]
4721
4722 An initializer for an aggregate member that is an
4723 empty class shall have the form of an empty
4724 initializer-list {}. */
4725 if (!first_initializer_p)
4726 {
4727 error ("initializer for %qT must be brace-enclosed", type);
4728 return error_mark_node;
4729 }
4730 return new_init;
8e3df2de 4731 }
4038c495
GB
4732
4733 /* Loop through the initializable fields, gathering initializers. */
4734 while (d->cur != d->end)
8e3df2de 4735 {
4038c495
GB
4736 tree field_init;
4737
4738 /* Handle designated initializers, as an extension. */
4739 if (d->cur->index)
4740 {
4038c495
GB
4741 field = lookup_field_1 (type, d->cur->index, /*want_type=*/false);
4742
4743 if (!field || TREE_CODE (field) != FIELD_DECL)
77bffd4c
SE
4744 {
4745 error ("%qT has no non-static data member named %qD", type,
4746 d->cur->index);
4747 return error_mark_node;
4748 }
4038c495
GB
4749 }
4750
4751 /* If we processed all the member of the class, we are done. */
4752 if (!field)
4753 break;
4754
4755 field_init = reshape_init_r (TREE_TYPE (field), d,
4756 /*first_initializer_p=*/false);
4757 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), field, field_init);
4758
4759 /* [dcl.init.aggr]
4760
4761 When a union is initialized with a brace-enclosed
4762 initializer, the braces shall only contain an
4763 initializer for the first member of the union. */
4764 if (TREE_CODE (type) == UNION_TYPE)
4765 break;
4766
4767 field = next_initializable_field (TREE_CHAIN (field));
8e3df2de
MM
4768 }
4769
4038c495
GB
4770 return new_init;
4771}
4772
4773/* Subroutine of reshape_init, which processes a single initializer (part of
4774 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
4775 iterator within the CONSTRUCTOR which points to the initializer to process.
4776 FIRST_INITIALIZER_P is true if this is the first initializer of the
4777 CONSTRUCTOR node. */
4778
4779static tree
4780reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p)
4781{
4782 tree init = d->cur->value;
4783
8e3df2de
MM
4784 /* A non-aggregate type is always initialized with a single
4785 initializer. */
4786 if (!CP_AGGREGATE_TYPE_P (type))
4038c495
GB
4787 {
4788 /* It is invalid to initialize a non-aggregate type with a
4789 brace-enclosed initializer.
4790 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
4791 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
4792 a CONSTRUCTOR (with a record type). */
4793 if (TREE_CODE (init) == CONSTRUCTOR
4794 && BRACE_ENCLOSED_INITIALIZER_P (init)) /* p7626.C */
4795 {
4796 error ("braces around scalar initializer for type %qT", type);
4797 init = error_mark_node;
4798 }
3db45ab5 4799
4038c495
GB
4800 d->cur++;
4801 return init;
4802 }
8e3df2de
MM
4803
4804 /* [dcl.init.aggr]
4805
4806 All implicit type conversions (clause _conv_) are considered when
4807 initializing the aggregate member with an initializer from an
4808 initializer-list. If the initializer can initialize a member,
4809 the member is initialized. Otherwise, if the member is itself a
4810 non-empty subaggregate, brace elision is assumed and the
4811 initializer is considered for the initialization of the first
4812 member of the subaggregate. */
4038c495 4813 if (TREE_CODE (init) != CONSTRUCTOR
30f86ec3 4814 && can_convert_arg (type, TREE_TYPE (init), init, LOOKUP_NORMAL))
8e3df2de 4815 {
4038c495
GB
4816 d->cur++;
4817 return init;
8e3df2de
MM
4818 }
4819
4038c495
GB
4820 /* [dcl.init.string]
4821
4822 A char array (whether plain char, signed char, or unsigned char)
4823 can be initialized by a string-literal (optionally enclosed in
4824 braces); a wchar_t array can be initialized by a wide
4825 string-literal (optionally enclosed in braces). */
4826 if (TREE_CODE (type) == ARRAY_TYPE
42328048 4827 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
8e3df2de 4828 {
4038c495 4829 tree str_init = init;
8e3df2de 4830
4038c495 4831 /* Strip one level of braces if and only if they enclose a single
3db45ab5 4832 element (as allowed by [dcl.init.string]). */
4038c495
GB
4833 if (!first_initializer_p
4834 && TREE_CODE (str_init) == CONSTRUCTOR
4835 && VEC_length (constructor_elt, CONSTRUCTOR_ELTS (str_init)) == 1)
8e3df2de 4836 {
4038c495
GB
4837 str_init = VEC_index (constructor_elt,
4838 CONSTRUCTOR_ELTS (str_init), 0)->value;
4839 }
3db45ab5 4840
4038c495 4841 /* If it's a string literal, then it's the initializer for the array
3db45ab5 4842 as a whole. Otherwise, continue with normal initialization for
4038c495
GB
4843 array types (one value per array element). */
4844 if (TREE_CODE (str_init) == STRING_CST)
4845 {
4846 d->cur++;
4847 return str_init;
4848 }
4849 }
8e3df2de 4850
4038c495
GB
4851 /* The following cases are about aggregates. If we are not within a full
4852 initializer already, and there is not a CONSTRUCTOR, it means that there
4853 is a missing set of braces (that is, we are processing the case for
4854 which reshape_init exists). */
4855 if (!first_initializer_p)
4856 {
4857 if (TREE_CODE (init) == CONSTRUCTOR)
4858 {
70ec16f7
AP
4859 if (TREE_TYPE (init) && TYPE_PTRMEMFUNC_P (TREE_TYPE (init)))
4860 /* There is no need to reshape pointer-to-member function
4861 initializers, as they are always constructed correctly
4862 by the front end. */
4863 ;
4864 else if (COMPOUND_LITERAL_P (init))
4038c495
GB
4865 /* For a nested compound literal, there is no need to reshape since
4866 brace elision is not allowed. Even if we decided to allow it,
4867 we should add a call to reshape_init in finish_compound_literal,
4868 before calling digest_init, so changing this code would still
4869 not be necessary. */
70ec16f7
AP
4870 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (init));
4871 else
8e3df2de 4872 {
4038c495
GB
4873 ++d->cur;
4874 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
4875 return reshape_init (type, init);
8e3df2de 4876 }
8e3df2de 4877 }
f8e7a389 4878
4038c495
GB
4879 warning (OPT_Wmissing_braces, "missing braces around initializer for %qT",
4880 type);
4881 }
8e3df2de 4882
4038c495
GB
4883 /* Dispatch to specialized routines. */
4884 if (CLASS_TYPE_P (type))
4885 return reshape_init_class (type, d, first_initializer_p);
4886 else if (TREE_CODE (type) == ARRAY_TYPE)
4887 return reshape_init_array (type, d);
4888 else if (TREE_CODE (type) == VECTOR_TYPE)
4889 return reshape_init_vector (type, d);
4890 else
4891 gcc_unreachable();
4892}
8e3df2de 4893
4038c495
GB
4894/* Undo the brace-elision allowed by [dcl.init.aggr] in a
4895 brace-enclosed aggregate initializer.
8e3df2de 4896
4038c495
GB
4897 INIT is the CONSTRUCTOR containing the list of initializers describing
4898 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
4899 It may not presently match the shape of the TYPE; for example:
4900
4901 struct S { int a; int b; };
4902 struct S a[] = { 1, 2, 3, 4 };
4903
4904 Here INIT will hold a VEC of four elements, rather than a
4905 VEC of two elements, each itself a VEC of two elements. This
4906 routine transforms INIT from the former form into the latter. The
4907 revised CONSTRUCTOR node is returned. */
4908
3b2db49f 4909tree
4038c495
GB
4910reshape_init (tree type, tree init)
4911{
4912 VEC(constructor_elt, gc) *v;
4913 reshape_iter d;
4914 tree new_init;
4915
4038c495
GB
4916 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
4917
4918 v = CONSTRUCTOR_ELTS (init);
4919
4920 /* An empty constructor does not need reshaping, and it is always a valid
4921 initializer. */
4922 if (VEC_empty (constructor_elt, v))
4923 return init;
4924
4925 /* Recurse on this CONSTRUCTOR. */
4926 d.cur = VEC_index (constructor_elt, v, 0);
4927 d.end = d.cur + VEC_length (constructor_elt, v);
4928
4929 new_init = reshape_init_r (type, &d, true);
07471dfb
MM
4930 if (new_init == error_mark_node)
4931 return error_mark_node;
4038c495
GB
4932
4933 /* Make sure all the element of the constructor were used. Otherwise,
4934 issue an error about exceeding initializers. */
4935 if (d.cur != d.end)
4936 error ("too many initializers for %qT", type);
8e3df2de
MM
4937
4938 return new_init;
4939}
4940
23bee8f4
JJ
4941/* Verify array initializer. Returns true if errors have been reported. */
4942
4943bool
4944check_array_initializer (tree decl, tree type, tree init)
4945{
4946 tree element_type = TREE_TYPE (type);
4947
4948 /* The array type itself need not be complete, because the
4949 initializer may tell us how many elements are in the array.
4950 But, the elements of the array must be complete. */
4951 if (!COMPLETE_TYPE_P (complete_type (element_type)))
4952 {
4953 if (decl)
4954 error ("elements of array %q#D have incomplete type", decl);
4955 else
4956 error ("elements of array %q#T have incomplete type", type);
4957 return true;
4958 }
4959 /* It is not valid to initialize a VLA. */
4960 if (init
4961 && ((COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
4962 || !TREE_CONSTANT (TYPE_SIZE (element_type))))
4963 {
4964 if (decl)
4965 error ("variable-sized object %qD may not be initialized", decl);
4966 else
4967 error ("variable-sized compound literal");
4968 return true;
4969 }
4970 return false;
4971}
4972
09357846
JM
4973/* Subroutine of check_initializer; args are passed down from that function.
4974 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
4975
4976static tree
4977build_aggr_init_full_exprs (tree decl, tree init, int flags)
4978
4979{
4980 int saved_stmts_are_full_exprs_p = 0;
4981 if (building_stmt_tree ())
4982 {
4983 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
4984 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
4985 }
4986 init = build_aggr_init (decl, init, flags, tf_warning_or_error);
4987 if (building_stmt_tree ())
4988 current_stmt_tree ()->stmts_are_full_exprs_p =
4989 saved_stmts_are_full_exprs_p;
4990 return init;
4991}
4992
c82dbd95 4993/* Verify INIT (the initializer for DECL), and record the
7e99327d
MM
4994 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
4995 grok_reference_init.
8e3df2de
MM
4996
4997 If the return value is non-NULL, it is an expression that must be
4998 evaluated dynamically to initialize DECL. */
27778b73 4999
c82dbd95 5000static tree
7e99327d 5001check_initializer (tree decl, tree init, int flags, tree *cleanup)
27778b73 5002{
17bbb839 5003 tree type = TREE_TYPE (decl);
25ebb82a 5004 tree init_code = NULL;
fc0e7bf5 5005
328de7c2
MM
5006 /* Things that are going to be initialized need to have complete
5007 type. */
5008 TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
c82dbd95 5009
328de7c2
MM
5010 if (type == error_mark_node)
5011 /* We will have already complained. */
f724eac4
MM
5012 return NULL_TREE;
5013
5014 if (TREE_CODE (type) == ARRAY_TYPE)
328de7c2 5015 {
23bee8f4
JJ
5016 if (check_array_initializer (decl, type, init))
5017 return NULL_TREE;
328de7c2 5018 }
f724eac4 5019 else if (!COMPLETE_TYPE_P (type))
328de7c2 5020 {
2d01edd7 5021 error ("%qD has incomplete type", decl);
328de7c2 5022 TREE_TYPE (decl) = error_mark_node;
f724eac4 5023 return NULL_TREE;
27778b73 5024 }
f724eac4
MM
5025 else
5026 /* There is no way to make a variable-sized class type in GNU C++. */
5027 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type)));
c1ae8be5
SM
5028
5029 if (init && BRACE_ENCLOSED_INITIALIZER_P (init))
f47165c9 5030 {
c1ae8be5
SM
5031 int init_len = VEC_length (constructor_elt, CONSTRUCTOR_ELTS (init));
5032 if (SCALAR_TYPE_P (type))
5033 {
09357846
JM
5034 if (init_len == 0)
5035 {
5036 maybe_warn_cpp0x ("extended initializer lists");
5037 init = build_zero_init (type, NULL_TREE, false);
5038 }
5039 else if (init_len != 1)
c1ae8be5
SM
5040 {
5041 error ("scalar object %qD requires one element in initializer",
5042 decl);
5043 TREE_TYPE (decl) = error_mark_node;
5044 return NULL_TREE;
5045 }
5046 }
f47165c9 5047 }
27778b73
MM
5048
5049 if (TREE_CODE (decl) == CONST_DECL)
5050 {
7525db03 5051 gcc_assert (TREE_CODE (type) != REFERENCE_TYPE);
27778b73
MM
5052
5053 DECL_INITIAL (decl) = init;
5054
50bc768d 5055 gcc_assert (init != NULL_TREE);
27778b73
MM
5056 init = NULL_TREE;
5057 }
c82dbd95 5058 else if (!DECL_EXTERNAL (decl) && TREE_CODE (type) == REFERENCE_TYPE)
7e99327d 5059 init = grok_reference_init (decl, type, init, cleanup);
27778b73
MM
5060 else if (init)
5061 {
4038c495 5062 /* Do not reshape constructors of vectors (they don't need to be
3db45ab5 5063 reshaped. */
09357846 5064 if (BRACE_ENCLOSED_INITIALIZER_P (init))
a16f2357 5065 {
09357846
JM
5066 if (is_std_init_list (type))
5067 return build_init_list_var_init (decl, type, init, cleanup);
5068 else if (TYPE_NON_AGGREGATE_CLASS (type))
5069 {
5070 /* Don't reshape if the class has constructors. */
5071 if (cxx_dialect == cxx98)
5072 error ("in C++98 %qD must be initialized by constructor, "
5073 "not by %<{...}%>",
5074 decl);
5075 init = build_tree_list (NULL_TREE, init);
5076 }
5077 else if ((*targetm.vector_opaque_p) (type))
6e1b3a7c
AH
5078 {
5079 error ("opaque vector types cannot be initialized");
5080 init = error_mark_node;
5081 }
09357846
JM
5082 else
5083 init = reshape_init (type, init);
a16f2357 5084 }
8e3df2de
MM
5085
5086 /* If DECL has an array type without a specific bound, deduce the
5087 array size from the initializer. */
5088 maybe_deduce_size_from_array_init (decl, init);
5089 type = TREE_TYPE (decl);
2b643eda
MM
5090 if (type == error_mark_node)
5091 return NULL_TREE;
8e3df2de 5092
09357846
JM
5093 if (TYPE_NEEDS_CONSTRUCTING (type)
5094 || (CLASS_TYPE_P (type)
5095 && !BRACE_ENCLOSED_INITIALIZER_P (init)))
5096 return build_aggr_init_full_exprs (decl, init, flags);
5097 else if (TREE_CODE (init) != TREE_VEC)
27778b73 5098 {
09357846
JM
5099 init_code = store_init_value (decl, init);
5100 if (pedantic && TREE_CODE (type) == ARRAY_TYPE
5101 && DECL_INITIAL (decl)
5102 && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST
5103 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl)))
5104 warning (0, "array %qD initialized by parenthesized string literal %qE",
5105 decl, DECL_INITIAL (decl));
5106 init = NULL;
27778b73 5107 }
27778b73
MM
5108 }
5109 else if (DECL_EXTERNAL (decl))
5110 ;
8e3df2de 5111 else if (TYPE_P (type) && TYPE_NEEDS_CONSTRUCTING (type))
09357846 5112 return build_aggr_init_full_exprs (decl, init, flags);
9e1e64ec 5113 else if (MAYBE_CLASS_TYPE_P (type))
27778b73
MM
5114 {
5115 tree core_type = strip_array_types (type);
5116
8e3df2de 5117 if (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type))
2d01edd7 5118 error ("structure %qD with uninitialized const members", decl);
8e3df2de 5119 if (CLASSTYPE_REF_FIELDS_NEED_INIT (core_type))
2d01edd7 5120 error ("structure %qD with uninitialized reference members", decl);
27778b73
MM
5121
5122 check_for_uninitialized_const_var (decl);
27778b73
MM
5123 }
5124 else
5125 check_for_uninitialized_const_var (decl);
68642fb6 5126
8e3df2de 5127 if (init && init != error_mark_node)
f293ce4b 5128 init_code = build2 (INIT_EXPR, type, decl, init);
8e3df2de 5129
25ebb82a 5130 return init_code;
27778b73
MM
5131}
5132
5133/* If DECL is not a local variable, give it RTL. */
5134
5135static void
11f6b451 5136make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
27778b73 5137{
95ee998c
MM
5138 int toplev = toplevel_bindings_p ();
5139 int defer_p;
9f12b095 5140 const char *filename;
27778b73 5141
0e6df31e
GK
5142 /* Set the DECL_ASSEMBLER_NAME for the object. */
5143 if (asmspec)
5144 {
5145 /* The `register' keyword, when used together with an
5146 asm-specification, indicates that the variable should be
5147 placed in a particular register. */
5148 if (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl))
5149 {
11e3f4b6 5150 set_user_assembler_name (decl, asmspec);
0e6df31e
GK
5151 DECL_HARD_REGISTER (decl) = 1;
5152 }
5153 else
b482789c
MA
5154 {
5155 if (TREE_CODE (decl) == FUNCTION_DECL
5156 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
5157 set_builtin_user_assembler_name (decl, asmspec);
5158 set_user_assembler_name (decl, asmspec);
5159 }
0e6df31e
GK
5160 }
5161
f39ee884
MM
5162 /* Handle non-variables up front. */
5163 if (TREE_CODE (decl) != VAR_DECL)
5164 {
0e6df31e 5165 rest_of_decl_compilation (decl, toplev, at_eof);
f39ee884
MM
5166 return;
5167 }
5168
95ee998c
MM
5169 /* If we see a class member here, it should be a static data
5170 member. */
5171 if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
5172 {
50bc768d 5173 gcc_assert (TREE_STATIC (decl));
95ee998c
MM
5174 /* An in-class declaration of a static data member should be
5175 external; it is only a declaration, and not a definition. */
5176 if (init == NULL_TREE)
dc472c59 5177 gcc_assert (DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl));
95ee998c
MM
5178 }
5179
95ee998c
MM
5180 /* We don't create any RTL for local variables. */
5181 if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
5182 return;
27778b73 5183
95ee998c 5184 /* We defer emission of local statics until the corresponding
350fae66 5185 DECL_EXPR is expanded. */
95ee998c
MM
5186 defer_p = DECL_FUNCTION_SCOPE_P (decl) || DECL_VIRTUAL_P (decl);
5187
b602511f
JM
5188 /* We try to defer namespace-scope static constants so that they are
5189 not emitted into the object file unnecessarily. */
9f12b095 5190 filename = input_filename;
b602511f
JM
5191 if (!DECL_VIRTUAL_P (decl)
5192 && TREE_READONLY (decl)
5193 && DECL_INITIAL (decl) != NULL_TREE
5194 && DECL_INITIAL (decl) != error_mark_node
9f12b095 5195 && filename != NULL
b602511f
JM
5196 && ! EMPTY_CONSTRUCTOR_P (DECL_INITIAL (decl))
5197 && toplev
5198 && !TREE_PUBLIC (decl))
5cc90635
JM
5199 {
5200 /* Fool with the linkage of static consts according to #pragma
5201 interface. */
c533e34d 5202 struct c_fileinfo *finfo = get_fileinfo (filename);
5d709b00 5203 if (!finfo->interface_unknown && !TREE_PUBLIC (decl))
27778b73 5204 {
95ee998c 5205 TREE_PUBLIC (decl) = 1;
5d709b00 5206 DECL_EXTERNAL (decl) = finfo->interface_only;
27778b73 5207 }
27778b73 5208
95ee998c 5209 defer_p = 1;
27778b73 5210 }
b602511f 5211 /* Likewise for template instantiations. */
4684cd27
MM
5212 else if (DECL_LANG_SPECIFIC (decl)
5213 && DECL_IMPLICIT_INSTANTIATION (decl))
b602511f 5214 defer_p = 1;
95ee998c 5215
95ee998c 5216 /* If we're not deferring, go ahead and assemble the variable. */
0e6df31e
GK
5217 if (!defer_p)
5218 rest_of_decl_compilation (decl, toplev, at_eof);
27778b73
MM
5219}
5220
a24549d4
JM
5221/* walk_tree helper for wrap_temporary_cleanups, below. */
5222
5223static tree
5224wrap_cleanups_r (tree *stmt_p, int *walk_subtrees, void *data)
5225{
5226 if (TYPE_P (*stmt_p))
5227 {
5228 *walk_subtrees = 0;
5229 return NULL_TREE;
5230 }
5231
5232 if (TREE_CODE (*stmt_p) == TARGET_EXPR)
5233 {
5234 tree guard = (tree)data;
5235 tree tcleanup = TARGET_EXPR_CLEANUP (*stmt_p);
5236
5237 tcleanup = build2 (TRY_CATCH_EXPR, void_type_node, tcleanup, guard);
33b45227
JM
5238 /* Tell honor_protect_cleanup_actions to handle this as a separate
5239 cleanup. */
5240 TRY_CATCH_IS_CLEANUP (tcleanup) = 1;
5241
a24549d4
JM
5242 TARGET_EXPR_CLEANUP (*stmt_p) = tcleanup;
5243 }
5244
5245 return NULL_TREE;
5246}
5247
5248/* We're initializing a local variable which has a cleanup GUARD. If there
5249 are any temporaries used in the initializer INIT of this variable, we
5250 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
33b45227
JM
5251 variable will be cleaned up properly if one of them throws.
5252
5253 Unfortunately, there's no way to express this properly in terms of
5254 nesting, as the regions for the temporaries overlap the region for the
5255 variable itself; if there are two temporaries, the variable needs to be
5256 the first thing destroyed if either of them throws. However, we only
5257 want to run the variable's cleanup if it actually got constructed. So
5258 we need to guard the temporary cleanups with the variable's cleanup if
5259 they are run on the normal path, but not if they are run on the
5260 exceptional path. We implement this by telling
5261 honor_protect_cleanup_actions to strip the variable cleanup from the
5262 exceptional path. */
a24549d4
JM
5263
5264static void
5265wrap_temporary_cleanups (tree init, tree guard)
5266{
5267 cp_walk_tree_without_duplicates (&init, wrap_cleanups_r, (void *)guard);
5268}
5269
ed5511d9 5270/* Generate code to initialize DECL (a local variable). */
27778b73 5271
8e3df2de 5272static void
11f6b451 5273initialize_local_var (tree decl, tree init)
27778b73 5274{
9ed9e79a 5275 tree type = TREE_TYPE (decl);
170b020f 5276 tree cleanup;
a24549d4 5277 int already_used;
27778b73 5278
50bc768d
NS
5279 gcc_assert (TREE_CODE (decl) == VAR_DECL
5280 || TREE_CODE (decl) == RESULT_DECL);
5281 gcc_assert (!TREE_STATIC (decl));
b7b8bcd2 5282
8e3df2de 5283 if (DECL_SIZE (decl) == NULL_TREE)
b7b8bcd2
MM
5284 {
5285 /* If we used it already as memory, it must stay in memory. */
5286 DECL_INITIAL (decl) = NULL_TREE;
5287 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
a24549d4 5288 return;
b7b8bcd2
MM
5289 }
5290
a24549d4
JM
5291 if (type == error_mark_node)
5292 return;
68642fb6 5293
a24549d4
JM
5294 /* Compute and store the initial value. */
5295 already_used = TREE_USED (decl) || TREE_USED (type);
27778b73 5296
a24549d4
JM
5297 /* Generate a cleanup, if necessary. */
5298 cleanup = cxx_maybe_build_cleanup (decl);
27778b73 5299
a24549d4
JM
5300 /* Perform the initialization. */
5301 if (init)
5302 {
5303 int saved_stmts_are_full_exprs_p;
5304
5305 /* If we're only initializing a single object, guard the destructors
5306 of any temporaries used in its initializer with its destructor.
5307 This isn't right for arrays because each element initialization is
5308 a full-expression. */
5309 if (cleanup && TREE_CODE (type) != ARRAY_TYPE)
5310 wrap_temporary_cleanups (init, cleanup);
5311
5312 gcc_assert (building_stmt_tree ());
5313 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
5314 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
5315 finish_expr_stmt (init);
5316 current_stmt_tree ()->stmts_are_full_exprs_p =
5317 saved_stmts_are_full_exprs_p;
27778b73 5318 }
24bef158 5319
a24549d4
JM
5320 /* Set this to 0 so we can tell whether an aggregate which was
5321 initialized was ever used. Don't do this if it has a
5322 destructor, so we don't complain about the 'resource
5323 allocation is initialization' idiom. Now set
5324 attribute((unused)) on types so decls of that type will be
5325 marked used. (see TREE_USED, above.) */
5326 if (TYPE_NEEDS_CONSTRUCTING (type)
5327 && ! already_used
5328 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
5329 && DECL_NAME (decl))
5330 TREE_USED (decl) = 0;
5331 else if (already_used)
5332 TREE_USED (decl) = 1;
5333
5334 if (cleanup)
170b020f 5335 finish_decl_cleanup (decl, cleanup);
24bef158
MM
5336}
5337
19c29b2f
MM
5338/* DECL is a VAR_DECL for a compiler-generated variable with static
5339 storage duration (like a virtual table) whose initializer is a
3b2db49f
MM
5340 compile-time constant. INIT must be either a TREE_LIST of values,
5341 or a CONSTRUCTOR. Initialize the variable and provide it to the
5342 back end. */
19c29b2f
MM
5343
5344void
5345initialize_artificial_var (tree decl, tree init)
5346{
d23f3d60 5347 gcc_assert (DECL_ARTIFICIAL (decl));
3b2db49f 5348 if (TREE_CODE (init) == TREE_LIST)
09357846 5349 init = build_constructor_from_list (TREE_TYPE (decl), init);
3b2db49f
MM
5350 gcc_assert (TREE_CODE (init) == CONSTRUCTOR);
5351 DECL_INITIAL (decl) = init;
19c29b2f
MM
5352 DECL_INITIALIZED_P (decl) = 1;
5353 determine_visibility (decl);
5354 layout_var_decl (decl);
5355 maybe_commonize_var (decl);
5356 make_rtl_for_nonlocal_decl (decl, init, /*asmspec=*/NULL);
5357}
5358
32a11c08
MM
5359/* INIT is the initializer for a variable, as represented by the
5360 parser. Returns true iff INIT is value-dependent. */
5361
5362static bool
5363value_dependent_init_p (tree init)
5364{
5365 if (TREE_CODE (init) == TREE_LIST)
5366 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
5367 return any_value_dependent_elements_p (init);
5368 else if (TREE_CODE (init) == CONSTRUCTOR)
5369 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
5370 {
5371 VEC(constructor_elt, gc) *elts;
5372 size_t nelts;
5373 size_t i;
5374
5375 elts = CONSTRUCTOR_ELTS (init);
5376 nelts = VEC_length (constructor_elt, elts);
5377 for (i = 0; i < nelts; ++i)
5378 if (value_dependent_init_p (VEC_index (constructor_elt,
5379 elts, i)->value))
5380 return true;
5381 }
5382 else
5383 /* It must be a simple expression, e.g., int i = 3; */
5384 return value_dependent_expression_p (init);
5385
5386 return false;
5387}
5388
8d08fdba
MS
5389/* Finish processing of a declaration;
5390 install its line number and initial value.
5391 If the length of an array type is not known before,
5392 it must be determined now, from the initial value, or it is an error.
5393
d174af6c
MM
5394 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
5395 true, then INIT is an integral constant expression.
8d08fdba 5396
920f9474 5397 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
f78c7bc6 5398 if the (init) syntax was used. */
8d08fdba
MS
5399
5400void
3db45ab5 5401cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
d174af6c 5402 tree asmspec_tree, int flags)
8d08fdba 5403{
7e99327d 5404 tree type;
7e99327d 5405 tree cleanup;
9c0758dd 5406 const char *asmspec = NULL;
8d08fdba 5407 int was_readonly = 0;
745d26d9 5408 bool var_definition_p = false;
2b643eda 5409 int saved_processing_template_decl;
8d08fdba 5410
11325dcd
KL
5411 if (decl == error_mark_node)
5412 return;
5413 else if (! decl)
8d08fdba
MS
5414 {
5415 if (init)
8251199e 5416 error ("assignment (not initialization) in declaration");
8d08fdba
MS
5417 return;
5418 }
5419
50bc768d 5420 gcc_assert (TREE_CODE (decl) != RESULT_DECL);
2b643eda
MM
5421 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
5422 gcc_assert (TREE_CODE (decl) != PARM_DECL);
5423
5424 type = TREE_TYPE (decl);
5425 if (type == error_mark_node)
5426 return;
170b020f 5427
7e99327d
MM
5428 /* Assume no cleanup is required. */
5429 cleanup = NULL_TREE;
2b643eda 5430 saved_processing_template_decl = processing_template_decl;
7e99327d 5431
a4443a08 5432 /* If a name was specified, get the string. */
5f52c0e0 5433 if (global_scope_p (current_binding_level))
41c64394 5434 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
4f543d15 5435 if (asmspec_tree && asmspec_tree != error_mark_node)
5cc90635 5436 asmspec = TREE_STRING_POINTER (asmspec_tree);
8d08fdba 5437
6ba89f8e 5438 if (current_class_type
4f1c5b7d 5439 && CP_DECL_CONTEXT (decl) == current_class_type
6ba89f8e
MM
5440 && TYPE_BEING_DEFINED (current_class_type)
5441 && (DECL_INITIAL (decl) || init))
3febd123 5442 DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
6ba89f8e 5443
5156628f 5444 if (processing_template_decl)
5566b478 5445 {
2b643eda
MM
5446 bool type_dependent_p;
5447
08ac397c 5448 /* Add this declaration to the statement-tree. */
170b020f 5449 if (at_function_scope_p ())
350fae66 5450 add_decl_expr (decl);
08ac397c 5451
2b643eda
MM
5452 type_dependent_p = dependent_type_p (type);
5453
7b3e2d46
DG
5454 if (check_for_bare_parameter_packs (init))
5455 {
5456 init = NULL_TREE;
5457 DECL_INITIAL (decl) = NULL_TREE;
5458 }
5459
2b643eda 5460 if (init && init_const_expr_p)
d174af6c 5461 {
2b643eda
MM
5462 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
5463 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl))
5464 TREE_CONSTANT (decl) = 1;
d174af6c
MM
5465 }
5466
32a11c08
MM
5467 /* Generally, initializers in templates are expanded when the
5468 template is instantiated. But, if DECL is an integral
5469 constant static data member, then it can be used in future
5470 integral constant expressions, and its value must be
5471 available. */
5472 if (!(init
5473 && DECL_CLASS_SCOPE_P (decl)
5474 && DECL_INTEGRAL_CONSTANT_VAR_P (decl)
5475 && !type_dependent_p
5476 && !value_dependent_init_p (init)))
2b643eda
MM
5477 {
5478 if (init)
5479 DECL_INITIAL (decl) = init;
5480 if (TREE_CODE (decl) == VAR_DECL
5481 && !DECL_PRETTY_FUNCTION_P (decl)
5482 && !type_dependent_p)
5483 maybe_deduce_size_from_array_init (decl, init);
5484 goto finish_end;
5485 }
c8094d83 5486
a125de0c
PC
5487 if (TREE_CODE (init) == TREE_LIST)
5488 {
5489 /* If the parenthesized-initializer form was used (e.g.,
5490 "int A<N>::i(X)"), then INIT will be a TREE_LIST of initializer
5491 arguments. (There is generally only one.) We convert them
5492 individually. */
5493 tree list = init;
5494 for (; list; list = TREE_CHAIN (list))
5495 {
5496 tree elt = TREE_VALUE (list);
5497 TREE_VALUE (list) = fold_non_dependent_expr (elt);
5498 }
5499 }
5500 else
5501 init = fold_non_dependent_expr (init);
2b643eda 5502 processing_template_decl = 0;
5566b478 5503 }
3e41d13b 5504
8d08fdba
MS
5505 /* Take care of TYPE_DECLs up front. */
5506 if (TREE_CODE (decl) == TYPE_DECL)
5507 {
a0a33927 5508 if (type != error_mark_node
9e1e64ec 5509 && MAYBE_CLASS_TYPE_P (type) && DECL_NAME (decl))
8d08fdba
MS
5510 {
5511 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
d4ee4d25 5512 warning (0, "shadowing previous type declaration of %q#D", decl);
4b0d3cbe 5513 set_identifier_type_value (DECL_NAME (decl), decl);
8d08fdba 5514 }
cffa8729
MS
5515
5516 /* If we have installed this as the canonical typedef for this
5517 type, and that type has not been defined yet, delay emitting
956d6950 5518 the debug information for it, as we will emit it later. */
d2e5ee5c 5519 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
d0f062fb 5520 && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
cffa8729
MS
5521 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
5522
0e6df31e
GK
5523 rest_of_decl_compilation (decl, DECL_CONTEXT (decl) == NULL_TREE,
5524 at_eof);
8d08fdba
MS
5525 goto finish_end;
5526 }
3e41d13b 5527
67935995 5528 /* A reference will be modified here, as it is initialized. */
c8094d83 5529 if (! DECL_EXTERNAL (decl)
67935995
MM
5530 && TREE_READONLY (decl)
5531 && TREE_CODE (type) == REFERENCE_TYPE)
8d08fdba 5532 {
8d08fdba 5533 was_readonly = 1;
67935995 5534 TREE_READONLY (decl) = 0;
8d08fdba
MS
5535 }
5536
437081d7 5537 if (TREE_CODE (decl) == VAR_DECL)
17bbb839
MM
5538 {
5539 /* Only PODs can have thread-local storage. Other types may require
5540 various kinds of non-trivial initialization. */
c2f7fa15 5541 if (DECL_THREAD_LOCAL_P (decl) && !pod_type_p (TREE_TYPE (decl)))
2d01edd7 5542 error ("%qD cannot be thread-local because it has non-POD type %qT",
17bbb839 5543 decl, TREE_TYPE (decl));
d23f3d60
MM
5544 /* If this is a local variable that will need a mangled name,
5545 register it now. We must do this before processing the
5546 initializer for the variable, since the initialization might
5547 require a guard variable, and since the mangled name of the
5548 guard variable will depend on the mangled name of this
5549 variable. */
b0eb6a8f 5550 if (DECL_FUNCTION_SCOPE_P (decl)
d23f3d60
MM
5551 && TREE_STATIC (decl)
5552 && !DECL_ARTIFICIAL (decl))
5553 push_local_name (decl);
17bbb839
MM
5554 /* Convert the initializer to the type of DECL, if we have not
5555 already initialized DECL. */
5556 if (!DECL_INITIALIZED_P (decl)
5557 /* If !DECL_EXTERNAL then DECL is being defined. In the
8e3df2de 5558 case of a static data member initialized inside the
17bbb839
MM
5559 class-specifier, there can be an initializer even if DECL
5560 is *not* defined. */
5561 && (!DECL_EXTERNAL (decl) || init))
5562 {
9e1e64ec 5563 if (TYPE_FOR_JAVA (type) && MAYBE_CLASS_TYPE_P (type))
360f866c
JJ
5564 {
5565 tree jclass
5566 = IDENTIFIER_GLOBAL_VALUE (get_identifier ("jclass"));
5567 /* Allow libjava/prims.cc define primitive classes. */
5568 if (init != NULL_TREE
5569 || jclass == NULL_TREE
5570 || TREE_CODE (jclass) != TYPE_DECL
5571 || !POINTER_TYPE_P (TREE_TYPE (jclass))
5572 || !same_type_ignoring_top_level_qualifiers_p
5573 (type, TREE_TYPE (TREE_TYPE (jclass))))
5574 error ("Java object %qD not allocated with %<new%>", decl);
5575 init = NULL_TREE;
5576 }
6c06fbce 5577 if (init)
d174af6c
MM
5578 {
5579 DECL_NONTRIVIALLY_INITIALIZED_P (decl) = 1;
5580 if (init_const_expr_p)
5581 {
5582 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
5583 if (DECL_INTEGRAL_CONSTANT_VAR_P (decl))
5584 TREE_CONSTANT (decl) = 1;
5585 }
5586 }
7e99327d 5587 init = check_initializer (decl, init, flags, &cleanup);
b4c20e52 5588 /* Thread-local storage cannot be dynamically initialized. */
c2f7fa15 5589 if (DECL_THREAD_LOCAL_P (decl) && init)
b4c20e52 5590 {
2d01edd7 5591 error ("%qD is thread-local and so cannot be dynamically "
b4c20e52
MM
5592 "initialized", decl);
5593 init = NULL_TREE;
5594 }
b794e321
MM
5595
5596 /* Check that the initializer for a static data member was a
1634705d 5597 constant. Although we check in the parser that the
b794e321
MM
5598 initializer is an integral constant expression, we do not
5599 simplify division-by-zero at the point at which it
5600 occurs. Therefore, in:
5601
5602 struct S { static const int i = 7 / 0; };
3db45ab5 5603
b794e321
MM
5604 we issue an error at this point. It would
5605 probably be better to forbid division by zero in
5606 integral constant expressions. */
8fe4d24b
NS
5607 if (DECL_EXTERNAL (decl) && init)
5608 {
8fe4d24b
NS
5609 error ("%qD cannot be initialized by a non-constant expression"
5610 " when being declared", decl);
5611 DECL_INITIALIZED_IN_CLASS_P (decl) = 0;
5612 init = NULL_TREE;
5613 }
c8094d83 5614
17bbb839 5615 /* Handle:
caf93cb0 5616
17bbb839 5617 [dcl.init]
caf93cb0 5618
17bbb839
MM
5619 The memory occupied by any object of static storage
5620 duration is zero-initialized at program startup before
5621 any other initialization takes place.
caf93cb0 5622
17bbb839
MM
5623 We cannot create an appropriate initializer until after
5624 the type of DECL is finalized. If DECL_INITIAL is set,
5625 then the DECL is statically initialized, and any
5626 necessary zero-initialization has already been performed. */
5627 if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
5628 DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
1cb8292f 5629 /*nelts=*/NULL_TREE,
17bbb839
MM
5630 /*static_storage_p=*/true);
5631 /* Remember that the initialization for this variable has
5632 taken place. */
5633 DECL_INITIALIZED_P (decl) = 1;
745d26d9
MM
5634 /* This declaration is the definition of this variable,
5635 unless we are initializing a static data member within
5636 the class specifier. */
5637 if (!DECL_EXTERNAL (decl))
5638 var_definition_p = true;
17bbb839 5639 }
d881ff25
MM
5640 /* If the variable has an array type, lay out the type, even if
5641 there is no initializer. It is valid to index through the
5642 array, and we must get TYPE_ALIGN set correctly on the array
5643 type. */
5644 else if (TREE_CODE (type) == ARRAY_TYPE)
5645 layout_type (type);
17bbb839 5646 }
360f866c 5647 else if (TREE_CODE (decl) == FIELD_DECL
9e1e64ec 5648 && TYPE_FOR_JAVA (type) && MAYBE_CLASS_TYPE_P (type))
360f866c 5649 error ("non-static data member %qD has Java class type", decl);
3e41d13b 5650
57cf57fb 5651 /* Add this declaration to the statement-tree. This needs to happen
350fae66
RK
5652 after the call to check_initializer so that the DECL_EXPR for a
5653 reference temp is added before the DECL_EXPR for the reference itself. */
170b020f 5654 if (at_function_scope_p ())
350fae66 5655 add_decl_expr (decl);
08ac397c 5656
da71e18c
MM
5657 /* Let the middle end know about variables and functions -- but not
5658 static data members in uninstantiated class templates. */
5659 if (!saved_processing_template_decl
5660 && (TREE_CODE (decl) == VAR_DECL
5661 || TREE_CODE (decl) == FUNCTION_DECL))
8d08fdba 5662 {
27778b73 5663 if (TREE_CODE (decl) == VAR_DECL)
da71e18c
MM
5664 {
5665 layout_var_decl (decl);
5666 maybe_commonize_var (decl);
5667 }
8d08fdba 5668
4c5bae34
RS
5669 /* This needs to happen after the linkage is set. */
5670 determine_visibility (decl);
5671
b0eb6a8f
JJ
5672 if (var_definition_p && TREE_STATIC (decl))
5673 {
5674 /* If a TREE_READONLY variable needs initialization
5675 at runtime, it is no longer readonly and we need to
5676 avoid MEM_READONLY_P being set on RTL created for it. */
5677 if (init)
5678 {
5679 if (TREE_READONLY (decl))
5680 TREE_READONLY (decl) = 0;
5681 was_readonly = 0;
5682 }
5683 else if (was_readonly)
5684 TREE_READONLY (decl) = 1;
5685 }
5686
27778b73 5687 make_rtl_for_nonlocal_decl (decl, init, asmspec);
8d08fdba 5688
7fb213d8
GB
5689 /* Check for abstractness of the type. Notice that there is no
5690 need to strip array types here since the check for those types
5691 is already done within create_array_type_for_decl. */
68642fb6 5692 if (TREE_CODE (type) == FUNCTION_TYPE
27778b73 5693 || TREE_CODE (type) == METHOD_TYPE)
7fb213d8 5694 abstract_virtuals_error (decl, TREE_TYPE (type));
68642fb6 5695 else
cfb91b67 5696 abstract_virtuals_error (decl, type);
8d08fdba 5697
b87d79e6 5698 if (TREE_TYPE (decl) == error_mark_node)
8e3df2de 5699 /* No initialization required. */
faae18ab 5700 ;
b87d79e6
JM
5701 else if (TREE_CODE (decl) == FUNCTION_DECL)
5702 {
5703 if (init)
5704 {
5705 if (init == ridpointers[(int)RID_DELETE])
5706 {
5707 /* fixme check this is 1st decl */
5708 DECL_DELETED_FN (decl) = 1;
5709 DECL_DECLARED_INLINE_P (decl) = 1;
5710 DECL_INITIAL (decl) = error_mark_node;
5711 }
5712 else if (init == ridpointers[(int)RID_DEFAULT])
5713 {
5714 if (!defaultable_fn_p (decl))
5715 error ("%qD cannot be defaulted", decl);
5716 else
5717 {
5718 /* An out-of-class default definition is defined at
5719 the point where it is explicitly defaulted. */
5720 DECL_DEFAULTED_FN (decl) = 1;
5721 if (DECL_INITIAL (decl) == error_mark_node)
5722 synthesize_method (decl);
5723 }
5724 }
5725 else
5726 error ("function %q#D is initialized like a variable", decl);
5727 }
5728 /* else no initialization required. */
5729 }
67d743fe
MS
5730 else if (DECL_EXTERNAL (decl)
5731 && ! (DECL_LANG_SPECIFIC (decl)
5732 && DECL_NOT_REALLY_EXTERN (decl)))
5566b478
MS
5733 {
5734 if (init)
5735 DECL_INITIAL (decl) = init;
5736 }
b0eb6a8f
JJ
5737 /* A variable definition. */
5738 else if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
5739 /* Initialize the local variable. */
5740 initialize_local_var (decl, init);
5741
5742 /* If a variable is defined, and then a subsequent
5743 definition with external linkage is encountered, we will
5744 get here twice for the same variable. We want to avoid
5745 calling expand_static_init more than once. For variables
5746 that are not static data members, we can call
5747 expand_static_init only when we actually process the
5748 initializer. It is not legal to redeclare a static data
5749 member, so this issue does not arise in that case. */
5750 else if (var_definition_p && TREE_STATIC (decl))
5751 expand_static_init (decl, init);
8d08fdba
MS
5752 }
5753
7e99327d
MM
5754 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
5755 reference, insert it in the statement-tree now. */
5756 if (cleanup)
325c3691 5757 push_cleanup (decl, cleanup, false);
7e99327d 5758
8d08fdba 5759 finish_end:
2b643eda 5760 processing_template_decl = saved_processing_template_decl;
8d08fdba 5761
8d08fdba
MS
5762 if (was_readonly)
5763 TREE_READONLY (decl) = 1;
d1bd0ded
GK
5764
5765 /* If this was marked 'used', be sure it will be output. */
5766 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
bb9a388d 5767 mark_decl_referenced (decl);
8d08fdba
MS
5768}
5769
f4f206f4 5770/* This is here for a midend callback from c-common.c. */
e92cc029 5771
82580166 5772void
11f6b451 5773finish_decl (tree decl, tree init, tree asmspec_tree)
82580166 5774{
d174af6c 5775 cp_finish_decl (decl, init, /*init_const_expr_p=*/false, asmspec_tree, 0);
82580166
MS
5776}
5777
db4283a0
MM
5778/* Returns a declaration for a VAR_DECL as if:
5779
5780 extern "C" TYPE NAME;
5781
5782 had been seen. Used to create compiler-generated global
5783 variables. */
5784
993acaec 5785static tree
11f6b451 5786declare_global_var (tree name, tree type)
db4283a0
MM
5787{
5788 tree decl;
5789
5790 push_to_top_level ();
5791 decl = build_decl (VAR_DECL, name, type);
5792 TREE_PUBLIC (decl) = 1;
5793 DECL_EXTERNAL (decl) = 1;
5794 DECL_ARTIFICIAL (decl) = 1;
de3fe73c
MM
5795 /* If the user has explicitly declared this variable (perhaps
5796 because the code we are compiling is part of a low-level runtime
5797 library), then it is possible that our declaration will be merged
5798 with theirs by pushdecl. */
5799 decl = pushdecl (decl);
d174af6c 5800 finish_decl (decl, NULL_TREE, NULL_TREE);
db4283a0
MM
5801 pop_from_top_level ();
5802
5803 return decl;
5804}
5805
46a9e521
MM
5806/* Returns the type for the argument to "__cxa_atexit" (or "atexit",
5807 if "__cxa_atexit" is not being used) corresponding to the function
5808 to be called when the program exits. */
5809
5810static tree
5811get_atexit_fn_ptr_type (void)
5812{
5813 tree arg_types;
5814 tree fn_type;
5815
5816 if (!atexit_fn_ptr_type_node)
5817 {
5818 if (flag_use_cxa_atexit
5819 && !targetm.cxx.use_atexit_for_cxa_atexit ())
5820 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
5821 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
5822 else
5823 /* The parameter to "atexit" is "void (*)(void)". */
5824 arg_types = void_list_node;
5825
5826 fn_type = build_function_type (void_type_node, arg_types);
5827 atexit_fn_ptr_type_node = build_pointer_type (fn_type);
5828 }
5829
5830 return atexit_fn_ptr_type_node;
5831}
5832
db4283a0 5833/* Returns a pointer to the `atexit' function. Note that if
838dfd8a 5834 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
db4283a0
MM
5835 `__cxa_atexit' function specified in the IA64 C++ ABI. */
5836
5837static tree
11f6b451 5838get_atexit_node (void)
db4283a0
MM
5839{
5840 tree atexit_fndecl;
5841 tree arg_types;
5842 tree fn_type;
5843 tree fn_ptr_type;
5844 const char *name;
9f62c3e3 5845 bool use_aeabi_atexit;
db4283a0
MM
5846
5847 if (atexit_node)
5848 return atexit_node;
5849
97388150 5850 if (flag_use_cxa_atexit && !targetm.cxx.use_atexit_for_cxa_atexit ())
db4283a0
MM
5851 {
5852 /* The declaration for `__cxa_atexit' is:
5853
5854 int __cxa_atexit (void (*)(void *), void *, void *)
5855
5856 We build up the argument types and then then function type
5857 itself. */
68642fb6 5858
9f62c3e3 5859 use_aeabi_atexit = targetm.cxx.use_aeabi_atexit ();
db4283a0
MM
5860 /* First, build the pointer-to-function type for the first
5861 argument. */
46a9e521 5862 fn_ptr_type = get_atexit_fn_ptr_type ();
db4283a0
MM
5863 /* Then, build the rest of the argument types. */
5864 arg_types = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9f62c3e3
PB
5865 if (use_aeabi_atexit)
5866 {
5867 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
5868 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
5869 }
5870 else
5871 {
5872 arg_types = tree_cons (NULL_TREE, ptr_type_node, arg_types);
5873 arg_types = tree_cons (NULL_TREE, fn_ptr_type, arg_types);
5874 }
db4283a0
MM
5875 /* And the final __cxa_atexit type. */
5876 fn_type = build_function_type (integer_type_node, arg_types);
5877 fn_ptr_type = build_pointer_type (fn_type);
9f62c3e3
PB
5878 if (use_aeabi_atexit)
5879 name = "__aeabi_atexit";
5880 else
5881 name = "__cxa_atexit";
db4283a0
MM
5882 }
5883 else
5884 {
5885 /* The declaration for `atexit' is:
68642fb6 5886
0cbd7506 5887 int atexit (void (*)());
db4283a0
MM
5888
5889 We build up the argument types and then then function type
5890 itself. */
46a9e521 5891 fn_ptr_type = get_atexit_fn_ptr_type ();
db4283a0
MM
5892 arg_types = tree_cons (NULL_TREE, fn_ptr_type, void_list_node);
5893 /* Build the final atexit type. */
5894 fn_type = build_function_type (integer_type_node, arg_types);
5895 name = "atexit";
5896 }
5897
5898 /* Now, build the function declaration. */
5899 push_lang_context (lang_name_c);
0c11ada6 5900 atexit_fndecl = build_library_fn_ptr (name, fn_type);
db4283a0
MM
5901 mark_used (atexit_fndecl);
5902 pop_lang_context ();
0a72704b 5903 atexit_node = decay_conversion (atexit_fndecl);
db4283a0
MM
5904
5905 return atexit_node;
5906}
5907
5908/* Returns the __dso_handle VAR_DECL. */
5909
5910static tree
11f6b451 5911get_dso_handle_node (void)
db4283a0
MM
5912{
5913 if (dso_handle_node)
5914 return dso_handle_node;
5915
5916 /* Declare the variable. */
5917 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
5918 ptr_type_node);
5919
5920 return dso_handle_node;
5921}
5922
5923/* Begin a new function with internal linkage whose job will be simply
5924 to destroy some particular variable. */
5925
d192828a
GK
5926static GTY(()) int start_cleanup_cnt;
5927
db4283a0 5928static tree
11f6b451 5929start_cleanup_fn (void)
db4283a0 5930{
db4283a0 5931 char name[32];
db4283a0
MM
5932 tree fntype;
5933 tree fndecl;
97388150
DS
5934 bool use_cxa_atexit = flag_use_cxa_atexit
5935 && !targetm.cxx.use_atexit_for_cxa_atexit ();
db4283a0
MM
5936
5937 push_to_top_level ();
5938
5939 /* No need to mangle this. */
5940 push_lang_context (lang_name_c);
5941
db4283a0 5942 /* Build the name of the function. */
d192828a 5943 sprintf (name, "__tcf_%d", start_cleanup_cnt++);
db4283a0 5944 /* Build the function declaration. */
46a9e521 5945 fntype = TREE_TYPE (get_atexit_fn_ptr_type ());
db4283a0
MM
5946 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
5947 /* It's a function with internal linkage, generated by the
5948 compiler. */
5949 TREE_PUBLIC (fndecl) = 0;
5950 DECL_ARTIFICIAL (fndecl) = 1;
5a728aca
MM
5951 /* Make the function `inline' so that it is only emitted if it is
5952 actually needed. It is unlikely that it will be inlined, since
aba649ba 5953 it is only called via a function pointer, but we avoid unnecessary
5a728aca 5954 emissions this way. */
d4d1ebc1 5955 DECL_INTERFACE_KNOWN (fndecl) = 1;
db4283a0 5956 /* Build the parameter. */
97388150 5957 if (use_cxa_atexit)
db4283a0
MM
5958 {
5959 tree parmdecl;
5960
8e51619a 5961 parmdecl = cp_build_parm_decl (NULL_TREE, ptr_type_node);
db4283a0 5962 DECL_CONTEXT (parmdecl) = fndecl;
db4283a0
MM
5963 TREE_USED (parmdecl) = 1;
5964 DECL_ARGUMENTS (fndecl) = parmdecl;
5965 }
5966
09ed39ad 5967 pushdecl (fndecl);
058b15c1 5968 start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED);
db4283a0 5969
db4283a0
MM
5970 pop_lang_context ();
5971
5972 return current_function_decl;
5973}
5974
5975/* Finish the cleanup function begun by start_cleanup_fn. */
5976
5977static void
11f6b451 5978end_cleanup_fn (void)
db4283a0 5979{
8cd2462c 5980 expand_or_defer_fn (finish_function (0));
db4283a0
MM
5981
5982 pop_from_top_level ();
5983}
5984
bf419747
MM
5985/* Generate code to handle the destruction of DECL, an object with
5986 static storage duration. */
f0105ed3 5987
40aac948 5988tree
11f6b451 5989register_dtor_fn (tree decl)
f0105ed3 5990{
db4283a0 5991 tree cleanup;
f0105ed3 5992 tree compound_stmt;
db4283a0
MM
5993 tree args;
5994 tree fcall;
46a9e521
MM
5995 tree type;
5996 bool use_dtor;
f0105ed3 5997
46a9e521
MM
5998 type = TREE_TYPE (decl);
5999 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
40aac948 6000 return void_zero_node;
bf419747 6001
46a9e521
MM
6002 /* If we're using "__cxa_atexit" (or "__aeabi_atexit"), and DECL is
6003 a class object, we can just pass the destructor to
6004 "__cxa_atexit"; we don't have to build a temporary function to do
6005 the cleanup. */
6006 use_dtor = (flag_use_cxa_atexit
6007 && !targetm.cxx.use_atexit_for_cxa_atexit ()
6008 && CLASS_TYPE_P (type));
6009 if (use_dtor)
6010 {
6011 int idx;
6012
6013 /* Find the destructor. */
6014 idx = lookup_fnfields_1 (type, complete_dtor_identifier);
6015 gcc_assert (idx >= 0);
6016 cleanup = VEC_index (tree, CLASSTYPE_METHOD_VEC (type), idx);
6017 /* Make sure it is accessible. */
6018 perform_or_defer_access_check (TYPE_BINFO (type), cleanup, cleanup);
6019 }
6020 else
6021 {
6022 /* Call build_cleanup before we enter the anonymous function so
6023 that any access checks will be done relative to the current
6024 scope, rather than the scope of the anonymous function. */
6025 build_cleanup (decl);
6026
6027 /* Now start the function. */
6028 cleanup = start_cleanup_fn ();
6029
6030 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
6031 to the original function, rather than the anonymous one. That
6032 will make the back end think that nested functions are in use,
6033 which causes confusion. */
6034 push_deferring_access_checks (dk_no_check);
6035 fcall = build_cleanup (decl);
6036 pop_deferring_access_checks ();
6037
6038 /* Create the body of the anonymous function. */
6039 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
6040 finish_expr_stmt (fcall);
6041 finish_compound_stmt (compound_stmt);
6042 end_cleanup_fn ();
6043 }
f0105ed3
MM
6044
6045 /* Call atexit with the cleanup function. */
bb4f6e6b 6046 mark_used (cleanup);
46a9e521 6047 cleanup = build_address (cleanup);
97388150 6048 if (flag_use_cxa_atexit && !targetm.cxx.use_atexit_for_cxa_atexit ())
db4283a0 6049 {
46a9e521
MM
6050 tree addr;
6051
6052 if (use_dtor)
6053 {
6054 /* We must convert CLEANUP to the type that "__cxa_atexit"
6055 expects. */
6056 cleanup = build_nop (get_atexit_fn_ptr_type (), cleanup);
6057 /* "__cxa_atexit" will pass the address of DECL to the
6058 cleanup function. */
6059 mark_used (decl);
6060 addr = build_address (decl);
6061 /* The declared type of the parameter to "__cxa_atexit" is
6062 "void *". For plain "T*", we could just let the
5ade1ed2 6063 machinery in cp_build_function_call convert it -- but if the
46a9e521
MM
6064 type is "cv-qualified T *", then we need to convert it
6065 before passing it in, to avoid spurious errors. */
6066 addr = build_nop (ptr_type_node, addr);
6067 }
6068 else
6069 /* Since the cleanup functions we build ignore the address
6070 they're given, there's no reason to pass the actual address
6071 in, and, in general, it's cheaper to pass NULL than any
6072 other value. */
6073 addr = null_pointer_node;
caf93cb0 6074 args = tree_cons (NULL_TREE,
5ade1ed2
DG
6075 cp_build_unary_op (ADDR_EXPR, get_dso_handle_node (), 0,
6076 tf_warning_or_error),
0f268005 6077 NULL_TREE);
9f62c3e3
PB
6078 if (targetm.cxx.use_aeabi_atexit ())
6079 {
6080 args = tree_cons (NULL_TREE, cleanup, args);
46a9e521 6081 args = tree_cons (NULL_TREE, addr, args);
9f62c3e3
PB
6082 }
6083 else
6084 {
46a9e521 6085 args = tree_cons (NULL_TREE, addr, args);
9f62c3e3
PB
6086 args = tree_cons (NULL_TREE, cleanup, args);
6087 }
db4283a0
MM
6088 }
6089 else
6090 args = tree_cons (NULL_TREE, cleanup, NULL_TREE);
5ade1ed2
DG
6091 return cp_build_function_call (get_atexit_node (), args,
6092 tf_warning_or_error);
f0105ed3
MM
6093}
6094
8e3df2de
MM
6095/* DECL is a VAR_DECL with static storage duration. INIT, if present,
6096 is its initializer. Generate code to handle the construction
6097 and destruction of DECL. */
6098
6099static void
11f6b451 6100expand_static_init (tree decl, tree init)
8d08fdba 6101{
50bc768d
NS
6102 gcc_assert (TREE_CODE (decl) == VAR_DECL);
6103 gcc_assert (TREE_STATIC (decl));
8e3df2de
MM
6104
6105 /* Some variables require no initialization. */
caf93cb0 6106 if (!init
8e3df2de
MM
6107 && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))
6108 && TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
6109 return;
6110
eba6cfb6 6111 if (DECL_FUNCTION_SCOPE_P (decl))
8d08fdba
MS
6112 {
6113 /* Emit code to perform this initialization but once. */
445cf5eb
JM
6114 tree if_stmt = NULL_TREE, inner_if_stmt = NULL_TREE;
6115 tree then_clause = NULL_TREE, inner_then_clause = NULL_TREE;
94a0dd7b 6116 tree guard, guard_addr;
40aac948
JM
6117 tree acquire_fn, release_fn, abort_fn;
6118 tree flag, begin;
8d08fdba 6119
2036a15c
MM
6120 /* Emit code to perform this initialization but once. This code
6121 looks like:
6122
0cbd7506
MS
6123 static <type> guard;
6124 if (!guard.first_byte) {
40aac948
JM
6125 if (__cxa_guard_acquire (&guard)) {
6126 bool flag = false;
6127 try {
0cbd7506
MS
6128 // Do initialization.
6129 flag = true; __cxa_guard_release (&guard);
6130 // Register variable for destruction at end of program.
40aac948 6131 } catch {
0cbd7506 6132 if (!flag) __cxa_guard_abort (&guard);
40aac948 6133 }
2036a15c
MM
6134 }
6135
40aac948 6136 Note that the `flag' variable is only set to 1 *after* the
2036a15c
MM
6137 initialization is complete. This ensures that an exception,
6138 thrown during the construction, will cause the variable to
6139 reinitialized when we pass through this code again, as per:
68642fb6 6140
2036a15c
MM
6141 [stmt.dcl]
6142
c8094d83 6143 If the initialization exits by throwing an exception, the
2036a15c
MM
6144 initialization is not complete, so it will be tried again
6145 the next time control enters the declaration.
6146
0cbd7506 6147 This process should be thread-safe, too; multiple threads
40aac948
JM
6148 should not be able to initialize the variable more than
6149 once. */
c395453c
MM
6150
6151 /* Create the guard variable. */
6152 guard = get_guard (decl);
2036a15c 6153
445cf5eb
JM
6154 /* This optimization isn't safe on targets with relaxed memory
6155 consistency. On such targets we force synchronization in
6156 __cxa_guard_acquire. */
6157 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
6158 {
6159 /* Begin the conditional initialization. */
6160 if_stmt = begin_if_stmt ();
6161 finish_if_stmt_cond (get_guard_cond (guard), if_stmt);
6162 then_clause = begin_compound_stmt (BCS_NO_SCOPE);
6163 }
40aac948
JM
6164
6165 if (flag_threadsafe_statics)
6166 {
6167 guard_addr = build_address (guard);
40aac948
JM
6168
6169 acquire_fn = get_identifier ("__cxa_guard_acquire");
6170 release_fn = get_identifier ("__cxa_guard_release");
6171 abort_fn = get_identifier ("__cxa_guard_abort");
6172 if (!get_global_value_if_present (acquire_fn, &acquire_fn))
6173 {
6174 tree argtypes = tree_cons (NULL_TREE, TREE_TYPE (guard_addr),
6175 void_list_node);
6176 tree vfntype = build_function_type (void_type_node, argtypes);
6177 acquire_fn = push_library_fn
448083e5
PC
6178 (acquire_fn, build_function_type (integer_type_node, argtypes),
6179 NULL_TREE);
6180 release_fn = push_library_fn (release_fn, vfntype, NULL_TREE);
6181 abort_fn = push_library_fn (abort_fn, vfntype, NULL_TREE);
40aac948
JM
6182 }
6183 else
6184 {
6185 release_fn = identifier_global_value (release_fn);
6186 abort_fn = identifier_global_value (abort_fn);
6187 }
6188
6189 inner_if_stmt = begin_if_stmt ();
94a0dd7b 6190 finish_if_stmt_cond (build_call_n (acquire_fn, 1, guard_addr),
40aac948
JM
6191 inner_if_stmt);
6192
6193 inner_then_clause = begin_compound_stmt (BCS_NO_SCOPE);
6194 begin = get_target_expr (boolean_false_node);
6195 flag = TARGET_EXPR_SLOT (begin);
6196
6197 TARGET_EXPR_CLEANUP (begin)
81eba3a8
KH
6198 = build3 (COND_EXPR, void_type_node, flag,
6199 void_zero_node,
94a0dd7b 6200 build_call_n (abort_fn, 1, guard_addr));
40aac948
JM
6201 CLEANUP_EH_ONLY (begin) = 1;
6202
6203 /* Do the initialization itself. */
6204 init = add_stmt_to_compound (begin, init);
6205 init = add_stmt_to_compound
81eba3a8 6206 (init, build2 (MODIFY_EXPR, void_type_node, flag, boolean_true_node));
40aac948 6207 init = add_stmt_to_compound
94a0dd7b 6208 (init, build_call_n (release_fn, 1, guard_addr));
40aac948 6209 }
f1dedc31 6210 else
40aac948 6211 init = add_stmt_to_compound (init, set_guard (guard));
72b7eeff 6212
2036a15c
MM
6213 /* Use atexit to register a function for destroying this static
6214 variable. */
40aac948
JM
6215 init = add_stmt_to_compound (init, register_dtor_fn (decl));
6216
6217 finish_expr_stmt (init);
6218
6219 if (flag_threadsafe_statics)
6220 {
6221 finish_compound_stmt (inner_then_clause);
6222 finish_then_clause (inner_if_stmt);
6223 finish_if_stmt (inner_if_stmt);
6224 }
72b7eeff 6225
445cf5eb
JM
6226 if (!targetm.relaxed_ordering || !flag_threadsafe_statics)
6227 {
6228 finish_compound_stmt (then_clause);
6229 finish_then_clause (if_stmt);
6230 finish_if_stmt (if_stmt);
6231 }
8d08fdba
MS
6232 }
6233 else
bbd15aac 6234 static_aggregates = tree_cons (init, decl, static_aggregates);
8d08fdba 6235}
3c5c0849 6236
8d08fdba
MS
6237\f
6238/* Make TYPE a complete type based on INITIAL_VALUE.
6239 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
07900878
PC
6240 2 if there was no information (in which case assume 0 if DO_DEFAULT),
6241 3 if the initializer list is empty (in pedantic mode). */
8d08fdba
MS
6242
6243int
aab038d5 6244cp_complete_array_type (tree *ptype, tree initial_value, bool do_default)
8d08fdba 6245{
aab038d5
RH
6246 int failure;
6247 tree type, elt_type;
68642fb6 6248
8d08fdba
MS
6249 if (initial_value)
6250 {
49b5e2f6
DG
6251 unsigned HOST_WIDE_INT i;
6252 tree value;
6253
7b019c19 6254 /* An array of character type can be initialized from a
4038c495
GB
6255 brace-enclosed string constant.
6256
6257 FIXME: this code is duplicated from reshape_init. Probably
6258 we should just call reshape_init here? */
aab038d5 6259 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype)))
7b019c19 6260 && TREE_CODE (initial_value) == CONSTRUCTOR
4038c495
GB
6261 && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (initial_value)))
6262 {
6263 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
6264 tree value = VEC_index (constructor_elt, v, 0)->value;
6265
6266 if (TREE_CODE (value) == STRING_CST
6267 && VEC_length (constructor_elt, v) == 1)
6268 initial_value = value;
6269 }
49b5e2f6
DG
6270
6271 /* If any of the elements are parameter packs, we can't actually
6272 complete this type now because the array size is dependent. */
6273 if (TREE_CODE (initial_value) == CONSTRUCTOR)
6274 {
6275 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value),
6276 i, value)
6277 {
6278 if (PACK_EXPANSION_P (value))
6279 return 0;
6280 }
6281 }
8d08fdba
MS
6282 }
6283
aab038d5 6284 failure = complete_array_type (ptype, initial_value, do_default);
8d08fdba 6285
aab038d5
RH
6286 /* We can create the array before the element type is complete, which
6287 means that we didn't have these two bits set in the original type
6288 either. In completing the type, we are expected to propagate these
6289 bits. See also complete_type which does the same thing for arrays
6290 of fixed size. */
6291 type = *ptype;
6292 if (TYPE_DOMAIN (type))
8d08fdba 6293 {
81b4398d 6294 elt_type = TREE_TYPE (type);
aab038d5 6295 TYPE_NEEDS_CONSTRUCTING (type) = TYPE_NEEDS_CONSTRUCTING (elt_type);
81b4398d 6296 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
aab038d5 6297 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type);
8d08fdba
MS
6298 }
6299
aab038d5 6300 return failure;
8d08fdba
MS
6301}
6302\f
6303/* Return zero if something is declared to be a member of type
6304 CTYPE when in the context of CUR_TYPE. STRING is the error
6305 message to print in that case. Otherwise, quietly return 1. */
e92cc029 6306
8d08fdba 6307static int
11f6b451 6308member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
8d08fdba
MS
6309{
6310 if (ctype && ctype != cur_type)
6311 {
4dacf5bd 6312 if (flags == DTOR_FLAG)
2d01edd7 6313 error ("destructor for alien class %qT cannot be a member", ctype);
4dacf5bd 6314 else
2d01edd7 6315 error ("constructor for alien class %qT cannot be a member", ctype);
8d08fdba
MS
6316 return 0;
6317 }
6318 return 1;
6319}
6320\f
6321/* Subroutine of `grokdeclarator'. */
6322
6323/* Generate errors possibly applicable for a given set of specifiers.
6324 This is for ARM $7.1.2. */
e92cc029 6325
8d08fdba 6326static void
11f6b451 6327bad_specifiers (tree object,
0cbd7506
MS
6328 const char* type,
6329 int virtualp,
6330 int quals,
6331 int inlinep,
6332 int friendp,
6333 int raises)
8d08fdba
MS
6334{
6335 if (virtualp)
2d01edd7 6336 error ("%qD declared as a %<virtual%> %s", object, type);
8d08fdba 6337 if (inlinep)
2d01edd7 6338 error ("%qD declared as an %<inline%> %s", object, type);
8d08fdba 6339 if (quals)
2d01edd7 6340 error ("%<const%> and %<volatile%> function specifiers on "
0cbd7506
MS
6341 "%qD invalid in %s declaration",
6342 object, type);
8d08fdba 6343 if (friendp)
dee15844 6344 error ("%q+D declared as a friend", object);
e1be26f4
RS
6345 if (raises
6346 && (TREE_CODE (object) == TYPE_DECL
6347 || (!TYPE_PTRFN_P (TREE_TYPE (object))
742a37d5 6348 && !TYPE_REFFN_P (TREE_TYPE (object))
e1be26f4 6349 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
dee15844 6350 error ("%q+D declared with an exception specification", object);
8d08fdba
MS
6351}
6352
9c12301f
MM
6353/* DECL is a member function or static data member and is presently
6354 being defined. Check that the definition is taking place in a
6355 valid namespace. */
6356
6357static void
6358check_class_member_definition_namespace (tree decl)
6359{
6360 /* These checks only apply to member functions and static data
6361 members. */
6362 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
6363 || TREE_CODE (decl) == VAR_DECL);
6364 /* We check for problems with specializations in pt.c in
6365 check_specialization_namespace, where we can issue better
6366 diagnostics. */
6367 if (processing_specialization)
6368 return;
6369 /* There are no restrictions on the placement of
6370 explicit instantiations. */
6371 if (processing_explicit_instantiation)
6372 return;
6373 /* [class.mfct]
6374
6375 A member function definition that appears outside of the
6376 class definition shall appear in a namespace scope enclosing
6377 the class definition.
6378
6379 [class.static.data]
6380
6381 The definition for a static data member shall appear in a
6382 namespace scope enclosing the member's class definition. */
6383 if (!is_ancestor (current_namespace, DECL_CONTEXT (decl)))
37ec60ed
JW
6384 permerror ("definition of %qD is not in namespace enclosing %qT",
6385 decl, DECL_CONTEXT (decl));
9c12301f
MM
6386}
6387
e2537f2c
MM
6388/* Build a PARM_DECL for the "this" parameter. TYPE is the
6389 METHOD_TYPE for a non-static member function; QUALS are the
6390 cv-qualifiers that apply to the function. */
3db45ab5 6391
e2537f2c
MM
6392tree
6393build_this_parm (tree type, cp_cv_quals quals)
6394{
6395 tree this_type;
6396 tree qual_type;
6397 tree parm;
6398 cp_cv_quals this_quals;
6399
6400 this_type = TREE_VALUE (TYPE_ARG_TYPES (type));
6401 /* The `this' parameter is implicitly `const'; it cannot be
6402 assigned to. */
6403 this_quals = (quals & TYPE_QUAL_RESTRICT) | TYPE_QUAL_CONST;
6404 qual_type = cp_build_qualified_type (this_type, this_quals);
6405 parm = build_artificial_parm (this_identifier, qual_type);
6406 cp_apply_type_quals_to_decl (this_quals, parm);
6407 return parm;
3db45ab5 6408}
e2537f2c 6409
8d08fdba
MS
6410/* CTYPE is class type, or null if non-class.
6411 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
6412 or METHOD_TYPE.
6413 DECLARATOR is the function's name.
4546865e 6414 PARMS is a chain of PARM_DECLs for the function.
8d08fdba
MS
6415 VIRTUALP is truthvalue of whether the function is virtual or not.
6416 FLAGS are to be passed through to `grokclassfn'.
6417 QUALS are qualifiers indicating whether the function is `const'
6418 or `volatile'.
6419 RAISES is a list of exceptions that this function can raise.
6420 CHECK is 1 if we must find this method in CTYPE, 0 if we should
68642fb6 6421 not look, and -1 if we should not call `grokclassfn' at all.
3ddfb0e6 6422
27d6592c
MM
6423 SFK is the kind of special function (if any) for the new function.
6424
20496fa2 6425 Returns `NULL_TREE' if something goes wrong, after issuing
3ddfb0e6 6426 applicable error messages. */
e92cc029 6427
8d08fdba 6428static tree
caf93cb0 6429grokfndecl (tree ctype,
0cbd7506
MS
6430 tree type,
6431 tree declarator,
4546865e 6432 tree parms,
0cbd7506
MS
6433 tree orig_declarator,
6434 int virtualp,
6435 enum overload_flags flags,
3c01e5df 6436 cp_cv_quals quals,
0cbd7506
MS
6437 tree raises,
6438 int check,
6439 int friendp,
6440 int publicp,
6441 int inlinep,
27d6592c 6442 special_function_kind sfk,
357d956e 6443 bool funcdef_flag,
0cbd7506
MS
6444 int template_count,
6445 tree in_namespace,
037cc9c5 6446 tree* attrlist)
8d08fdba 6447{
1951a1b6 6448 tree decl;
8d08fdba 6449 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
42976354 6450 tree t;
8d08fdba 6451
8d08fdba 6452 if (raises)
271e6f02 6453 type = build_exception_variant (type, raises);
c11b6f21 6454
8d08fdba 6455 decl = build_lang_decl (FUNCTION_DECL, declarator, type);
e2537f2c
MM
6456 if (TREE_CODE (type) == METHOD_TYPE)
6457 {
6458 tree parm;
6459 parm = build_this_parm (type, quals);
6460 TREE_CHAIN (parm) = parms;
6461 parms = parm;
6462 }
4546865e 6463 DECL_ARGUMENTS (decl) = parms;
a1c65f9f 6464 /* Propagate volatile out from type to decl. */
8d08fdba 6465 if (TYPE_VOLATILE (type))
893de33c 6466 TREE_THIS_VOLATILE (decl) = 1;
8d08fdba 6467
71aea5f2
SM
6468 /* Setup decl according to sfk. */
6469 switch (sfk)
6470 {
6471 case sfk_constructor:
6472 case sfk_copy_constructor:
6473 DECL_CONSTRUCTOR_P (decl) = 1;
6474 break;
6475 case sfk_destructor:
6476 DECL_DESTRUCTOR_P (decl) = 1;
6477 break;
6478 default:
6479 break;
6480 }
6481
837edd5f
GK
6482 /* If pointers to member functions use the least significant bit to
6483 indicate whether a function is virtual, ensure a pointer
6484 to this function will have that bit clear. */
6485 if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
6486 && TREE_CODE (type) == METHOD_TYPE
6487 && DECL_ALIGN (decl) < 2 * BITS_PER_UNIT)
6488 DECL_ALIGN (decl) = 2 * BITS_PER_UNIT;
6489
abc088aa
MM
6490 if (friendp
6491 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
6492 {
6493 if (funcdef_flag)
6494 error
6495 ("defining explicit specialization %qD in friend declaration",
6496 orig_declarator);
6497 else
6498 {
6499 tree fns = TREE_OPERAND (orig_declarator, 0);
6500 tree args = TREE_OPERAND (orig_declarator, 1);
6501
6502 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
6503 {
6504 /* Something like `template <class T> friend void f<T>()'. */
6505 error ("invalid use of template-id %qD in declaration "
6506 "of primary template",
6507 orig_declarator);
6508 return NULL_TREE;
6509 }
6510
6511
6512 /* A friend declaration of the form friend void f<>(). Record
6513 the information in the TEMPLATE_ID_EXPR. */
6514 SET_DECL_IMPLICIT_INSTANTIATION (decl);
6515
6516 if (TREE_CODE (fns) == COMPONENT_REF)
6517 {
6518 /* Due to bison parser ickiness, we will have already looked
6519 up an operator_name or PFUNCNAME within the current class
6520 (see template_id in parse.y). If the current class contains
6521 such a name, we'll get a COMPONENT_REF here. Undo that. */
6522
6523 gcc_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
6524 == current_class_type);
6525 fns = TREE_OPERAND (fns, 1);
6526 }
6527 gcc_assert (TREE_CODE (fns) == IDENTIFIER_NODE
6528 || TREE_CODE (fns) == OVERLOAD);
6529 DECL_TEMPLATE_INFO (decl) = tree_cons (fns, args, NULL_TREE);
6530
6531 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
6532 if (TREE_PURPOSE (t)
6533 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
6534 {
6535 error ("default arguments are not allowed in declaration "
6536 "of friend template specialization %qD",
6537 decl);
6538 return NULL_TREE;
6539 }
6540
6541 if (inlinep)
6542 {
6543 error ("%<inline%> is not allowed in declaration of friend "
6544 "template specialization %qD",
6545 decl);
6546 return NULL_TREE;
6547 }
6548 }
6549 }
6550
79c4d4b7 6551 /* If this decl has namespace scope, set that up. */
2c73f9f5 6552 if (in_namespace)
b262d64c 6553 set_decl_namespace (decl, in_namespace, friendp);
adae082f 6554 else if (!ctype)
79c4d4b7 6555 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
2c73f9f5 6556
0f8766b8
JM
6557 /* `main' and builtins have implicit 'C' linkage. */
6558 if ((MAIN_NAME_P (declarator)
6559 || (IDENTIFIER_LENGTH (declarator) > 10
6560 && IDENTIFIER_POINTER (declarator)[0] == '_'
6561 && IDENTIFIER_POINTER (declarator)[1] == '_'
6562 && strncmp (IDENTIFIER_POINTER (declarator)+2, "builtin_", 8) == 0))
6563 && current_lang_name == lang_name_cplusplus
94706a5c 6564 && ctype == NULL_TREE
79c4d4b7
JM
6565 /* NULL_TREE means global namespace. */
6566 && DECL_CONTEXT (decl) == NULL_TREE)
5d2ed28c 6567 SET_DECL_LANGUAGE (decl, lang_c);
0f8766b8 6568
8d08fdba
MS
6569 /* Should probably propagate const out from type to decl I bet (mrs). */
6570 if (staticp)
6571 {
6572 DECL_STATIC_FUNCTION_P (decl) = 1;
6573 DECL_CONTEXT (decl) = ctype;
8d08fdba
MS
6574 }
6575
e76a2646 6576 if (ctype)
9c12301f
MM
6577 {
6578 DECL_CONTEXT (decl) = ctype;
6579 if (funcdef_flag)
6580 check_class_member_definition_namespace (decl);
6581 }
e76a2646 6582
0f8766b8 6583 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
faae18ab 6584 {
848b92e1 6585 if (processing_template_decl)
2d01edd7 6586 error ("cannot declare %<::main%> to be a template");
faae18ab 6587 if (inlinep)
2d01edd7 6588 error ("cannot declare %<::main%> to be inline");
f22967f3 6589 if (!publicp)
2d01edd7 6590 error ("cannot declare %<::main%> to be static");
faae18ab
MS
6591 inlinep = 0;
6592 publicp = 1;
6593 }
50a6dbd7 6594
59e76fc6 6595 /* Members of anonymous types and local classes have no linkage; make
9fc444cc 6596 them internal. If a typedef is made later, this will be changed. */
1951a1b6 6597 if (ctype && (TYPE_ANONYMOUS_P (ctype)
4f1c5b7d 6598 || decl_function_context (TYPE_MAIN_DECL (ctype))))
50a6dbd7
JM
6599 publicp = 0;
6600
6601 if (publicp)
6602 {
6603 /* [basic.link]: A name with no linkage (notably, the name of a class
6604 or enumeration declared in a local scope) shall not be used to
6605 declare an entity with linkage.
6606
50b97e0f 6607 Only check this for public decls for now. See core 319, 389. */
4684cd27
MM
6608 t = no_linkage_check (TREE_TYPE (decl),
6609 /*relaxed_p=*/false);
50a6dbd7
JM
6610 if (t)
6611 {
1951a1b6 6612 if (TYPE_ANONYMOUS_P (t))
7f7c930e 6613 {
eb68cb58 6614 if (DECL_EXTERN_C_P (decl))
7f7c930e
JM
6615 /* Allow this; it's pretty common in C. */;
6616 else
1951a1b6 6617 {
37ec60ed 6618 permerror ("non-local function %q#D uses anonymous type",
1951a1b6
JM
6619 decl);
6620 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
37ec60ed
JW
6621 permerror ("%q+#D does not refer to the unqualified "
6622 "type, so it is not used for linkage",
6623 TYPE_NAME (t));
1951a1b6 6624 }
7f7c930e 6625 }
50a6dbd7 6626 else
37ec60ed 6627 permerror ("non-local function %q#D uses local type %qT", decl, t);
50a6dbd7
JM
6628 }
6629 }
6630
893de33c 6631 TREE_PUBLIC (decl) = publicp;
faae18ab 6632 if (! publicp)
893de33c
JM
6633 {
6634 DECL_INTERFACE_KNOWN (decl) = 1;
6635 DECL_NOT_REALLY_EXTERN (decl) = 1;
6636 }
faae18ab 6637
acc72c37 6638 /* If the declaration was declared inline, mark it as such. */
faae18ab 6639 if (inlinep)
acc72c37
MM
6640 DECL_DECLARED_INLINE_P (decl) = 1;
6641 /* We inline functions that are explicitly declared inline, or, when
6642 the user explicitly asks us to, all functions. */
b3c3af2f 6643 if (DECL_DECLARED_INLINE_P (decl)
7e8b322a 6644 || (!DECL_INLINE (decl) && funcdef_flag))
acc72c37 6645 DECL_INLINE (decl) = 1;
8d08fdba
MS
6646
6647 DECL_EXTERNAL (decl) = 1;
3c01e5df 6648 if (quals && TREE_CODE (type) == FUNCTION_TYPE)
8d08fdba 6649 {
e7c41c99
DM
6650 error (ctype
6651 ? G_("static member function %qD cannot have cv-qualifier")
32b1d579 6652 : G_("non-member function %qD cannot have cv-qualifier"),
e7c41c99 6653 decl);
3c01e5df 6654 quals = TYPE_UNQUALIFIED;
8d08fdba
MS
6655 }
6656
398cd199
VR
6657 if (IDENTIFIER_OPNAME_P (DECL_NAME (decl))
6658 && !grok_op_properties (decl, /*complain=*/true))
6659 return NULL_TREE;
8d08fdba 6660
4f1c5b7d 6661 if (ctype && decl_function_context (decl))
893de33c 6662 DECL_NO_STATIC_CHAIN (decl) = 1;
e76a2646 6663
1eb0072d
JM
6664 if (funcdef_flag)
6665 /* Make the init_value nonzero so pushdecl knows this is not
6666 tentative. error_mark_node is replaced later with the BLOCK. */
6667 DECL_INITIAL (decl) = error_mark_node;
6668
93ca4ba7 6669 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
1660cb3a
JM
6670 TREE_NOTHROW (decl) = 1;
6671
75650646 6672 /* Caller will do the rest of this. */
8d08fdba
MS
6673 if (check < 0)
6674 return decl;
6675
74b846e0 6676 if (ctype != NULL_TREE)
71aea5f2 6677 grokclassfn (ctype, decl, flags);
74b846e0
MM
6678
6679 decl = check_explicit_specialization (orig_declarator, decl,
6680 template_count,
357d956e 6681 2 * funcdef_flag +
74b846e0
MM
6682 4 * (friendp != 0));
6683 if (decl == error_mark_node)
6684 return NULL_TREE;
98c1c668 6685
037cc9c5
FJ
6686 if (attrlist)
6687 {
6688 cplus_decl_attributes (&decl, *attrlist, 0);
6689 *attrlist = NULL_TREE;
6690 }
6691
da337784
JJ
6692 /* Check main's type after attributes have been applied. */
6693 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
6694 {
6695 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
6696 integer_type_node))
6697 {
6698 tree oldtypeargs = TYPE_ARG_TYPES (TREE_TYPE (decl));
6699 tree newtype;
6700 error ("%<::main%> must return %<int%>");
6701 newtype = build_function_type (integer_type_node, oldtypeargs);
6702 TREE_TYPE (decl) = newtype;
6703 }
6704 check_main_parameter_types (decl);
6705 }
6706
74b846e0
MM
6707 if (ctype != NULL_TREE
6708 && (! TYPE_FOR_JAVA (ctype) || check_java_method (decl))
6709 && check)
8d08fdba 6710 {
f8c3b097
PC
6711 tree old_decl = check_classfn (ctype, decl,
6712 (processing_template_decl
6713 > template_class_depth (ctype))
6714 ? current_template_parms
6715 : NULL_TREE);
6716
6717 if (old_decl == error_mark_node)
6718 return NULL_TREE;
8d08fdba 6719
74b846e0 6720 if (old_decl)
8d08fdba 6721 {
79ae853c 6722 tree ok;
4514aa8c 6723 tree pushed_scope;
316a2456 6724
357d956e
MM
6725 if (TREE_CODE (old_decl) == TEMPLATE_DECL)
6726 /* Because grokfndecl is always supposed to return a
6727 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
6728 here. We depend on our callers to figure out that its
6729 really a template that's being returned. */
6730 old_decl = DECL_TEMPLATE_RESULT (old_decl);
6731
6732 if (DECL_STATIC_FUNCTION_P (old_decl)
6733 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
6734 /* Remove the `this' parm added by grokclassfn.
6735 XXX Isn't this done in start_function, too? */
6736 revert_static_member_fn (decl);
6737 if (DECL_ARTIFICIAL (old_decl))
db160137
AP
6738 {
6739 error ("definition of implicitly-declared %qD", old_decl);
6740 return NULL_TREE;
6741 }
357d956e 6742
74b846e0
MM
6743 /* Since we've smashed OLD_DECL to its
6744 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
6745 if (TREE_CODE (decl) == TEMPLATE_DECL)
6746 decl = DECL_TEMPLATE_RESULT (decl);
6747
6748 /* Attempt to merge the declarations. This can fail, in
0e339752 6749 the case of some invalid specialization declarations. */
4514aa8c 6750 pushed_scope = push_scope (ctype);
d63d5d0c 6751 ok = duplicate_decls (decl, old_decl, friendp);
4514aa8c
NS
6752 if (pushed_scope)
6753 pop_scope (pushed_scope);
316a2456
MM
6754 if (!ok)
6755 {
2d01edd7 6756 error ("no %q#D member function declared in class %qT",
316a2456
MM
6757 decl, ctype);
6758 return NULL_TREE;
6759 }
74b846e0 6760 return old_decl;
8d08fdba
MS
6761 }
6762 }
74b846e0
MM
6763
6764 if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
6765 return NULL_TREE;
6766
6767 if (ctype == NULL_TREE || check)
6768 return decl;
6769
6770 if (virtualp)
cbb40945 6771 DECL_VIRTUAL_P (decl) = 1;
74b846e0 6772
8d08fdba
MS
6773 return decl;
6774}
6775
4684cd27
MM
6776/* DECL is a VAR_DECL for a static data member. Set flags to reflect
6777 the linkage that DECL will receive in the object file. */
6778
6779static void
6780set_linkage_for_static_data_member (tree decl)
6781{
6782 /* A static data member always has static storage duration and
6783 external linkage. Note that static data members are forbidden in
6784 local classes -- the only situation in which a class has
6785 non-external linkage. */
6786 TREE_PUBLIC (decl) = 1;
6787 TREE_STATIC (decl) = 1;
6788 /* For non-template classes, static data members are always put
6789 out in exactly those files where they are defined, just as
77880ae4 6790 with ordinary namespace-scope variables. */
4684cd27
MM
6791 if (!processing_template_decl)
6792 DECL_INTERFACE_KNOWN (decl) = 1;
6793}
6794
caf93cb0 6795/* Create a VAR_DECL named NAME with the indicated TYPE.
9e259dd1
MM
6796
6797 If SCOPE is non-NULL, it is the class type or namespace containing
6798 the variable. If SCOPE is NULL, the variable should is created in
6799 the innermost enclosings scope. */
6800
8d08fdba 6801static tree
11f6b451 6802grokvardecl (tree type,
0cbd7506 6803 tree name,
1ff3c076 6804 const cp_decl_specifier_seq *declspecs,
0cbd7506
MS
6805 int initialized,
6806 int constp,
6807 tree scope)
8d08fdba
MS
6808{
6809 tree decl;
5ae9ba3e 6810 tree explicit_scope;
f7da6097 6811
50bc768d 6812 gcc_assert (!name || TREE_CODE (name) == IDENTIFIER_NODE);
9e259dd1 6813
5ae9ba3e
MM
6814 /* Compute the scope in which to place the variable, but remember
6815 whether or not that scope was explicitly specified by the user. */
6816 explicit_scope = scope;
9e259dd1 6817 if (!scope)
8d08fdba 6818 {
9e259dd1
MM
6819 /* An explicit "extern" specifier indicates a namespace-scope
6820 variable. */
62d1db17 6821 if (declspecs->storage_class == sc_extern)
9e259dd1
MM
6822 scope = current_namespace;
6823 else if (!at_function_scope_p ())
a5201a91 6824 scope = current_scope ();
9e259dd1
MM
6825 }
6826
6827 if (scope
6828 && (/* If the variable is a namespace-scope variable declared in a
6829 template, we need DECL_LANG_SPECIFIC. */
6830 (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
6831 /* Similarly for namespace-scope variables with language linkage
6832 other than C++. */
caf93cb0 6833 || (TREE_CODE (scope) == NAMESPACE_DECL
9e259dd1
MM
6834 && current_lang_name != lang_name_cplusplus)
6835 /* Similarly for static data members. */
6836 || TYPE_P (scope)))
6837 decl = build_lang_decl (VAR_DECL, name, type);
8d08fdba 6838 else
9e259dd1 6839 decl = build_decl (VAR_DECL, name, type);
79c4d4b7 6840
5ae9ba3e
MM
6841 if (explicit_scope && TREE_CODE (explicit_scope) == NAMESPACE_DECL)
6842 set_decl_namespace (decl, explicit_scope, 0);
9e259dd1 6843 else
74b0d490 6844 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
6060a796 6845
62d1db17 6846 if (declspecs->storage_class == sc_extern)
8d08fdba
MS
6847 {
6848 DECL_THIS_EXTERN (decl) = 1;
6849 DECL_EXTERNAL (decl) = !initialized;
6850 }
6851
2b9dc906 6852 if (DECL_CLASS_SCOPE_P (decl))
8d08fdba 6853 {
4684cd27
MM
6854 set_linkage_for_static_data_member (decl);
6855 /* This function is only called with out-of-class definitions. */
5b605f68 6856 DECL_EXTERNAL (decl) = 0;
9c12301f 6857 check_class_member_definition_namespace (decl);
8d08fdba
MS
6858 }
6859 /* At top level, either `static' or no s.c. makes a definition
6860 (perhaps tentative), and absence of `static' makes it public. */
a9aedbc2 6861 else if (toplevel_bindings_p ())
8d08fdba 6862 {
62d1db17 6863 TREE_PUBLIC (decl) = (declspecs->storage_class != sc_static
9fffd093 6864 && (DECL_THIS_EXTERN (decl) || ! constp));
8d08fdba
MS
6865 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
6866 }
6867 /* Not at top level, only `static' makes a static definition. */
6868 else
6869 {
62d1db17 6870 TREE_STATIC (decl) = declspecs->storage_class == sc_static;
8d08fdba
MS
6871 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
6872 }
50a6dbd7 6873
62d1db17 6874 if (declspecs->specs[(int)ds_thread])
8893239d 6875 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
7a1f3f5f 6876
50a6dbd7
JM
6877 if (TREE_PUBLIC (decl))
6878 {
6879 /* [basic.link]: A name with no linkage (notably, the name of a class
6880 or enumeration declared in a local scope) shall not be used to
6881 declare an entity with linkage.
6882
03fd3f84 6883 Only check this for public decls for now. */
6b211746 6884 tree t = no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false);
50a6dbd7
JM
6885 if (t)
6886 {
1951a1b6 6887 if (TYPE_ANONYMOUS_P (t))
9fc444cc
GK
6888 {
6889 if (DECL_EXTERN_C_P (decl))
6bdb98d1
MA
6890 /* Allow this; it's pretty common in C. */
6891 ;
9fc444cc
GK
6892 else
6893 {
6b211746
AO
6894 /* DRs 132, 319 and 389 seem to indicate types with
6895 no linkage can only be used to declare extern "C"
6896 entities. Since it's not always an error in the
6897 ISO C++ 90 Standard, we only issue a warning. */
d4ee4d25 6898 warning (0, "non-local variable %q#D uses anonymous type",
9fc444cc
GK
6899 decl);
6900 if (DECL_ORIGINAL_TYPE (TYPE_NAME (t)))
dee15844
JM
6901 warning (0, "%q+#D does not refer to the unqualified "
6902 "type, so it is not used for linkage",
6903 TYPE_NAME (t));
9fc444cc
GK
6904 }
6905 }
50a6dbd7 6906 else
d4ee4d25 6907 warning (0, "non-local variable %q#D uses local type %qT", decl, t);
50a6dbd7
JM
6908 }
6909 }
1ceb02be
MM
6910 else
6911 DECL_INTERFACE_KNOWN (decl) = 1;
50a6dbd7 6912
8d08fdba
MS
6913 return decl;
6914}
6915
d8f8dca1
MM
6916/* Create and return a canonical pointer to member function type, for
6917 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
8d08fdba
MS
6918
6919tree
11f6b451 6920build_ptrmemfunc_type (tree type)
8d08fdba 6921{
4977bab6 6922 tree field, fields;
8d08fdba 6923 tree t;
46cbda4a 6924 tree unqualified_variant = NULL_TREE;
8d08fdba 6925
d48ebde1
NS
6926 if (type == error_mark_node)
6927 return type;
d363e7bf 6928
8d08fdba
MS
6929 /* If a canonical type already exists for this type, use it. We use
6930 this method instead of type_hash_canon, because it only does a
6931 simple equality check on the list of field members. */
6932
6933 if ((t = TYPE_GET_PTRMEMFUNC_TYPE (type)))
6934 return t;
6935
46cbda4a
MM
6936 /* Make sure that we always have the unqualified pointer-to-member
6937 type first. */
89d684bb 6938 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
68642fb6 6939 unqualified_variant
46cbda4a
MM
6940 = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
6941
9e1e64ec 6942 t = make_class_type (RECORD_TYPE);
cad7e87b 6943 xref_basetypes (t, NULL_TREE);
caf93cb0 6944
3b426391 6945 /* Let the front end know this is a pointer to member function... */
db5ae43f 6946 TYPE_PTRMEMFUNC_FLAG (t) = 1;
9e1e64ec
PC
6947 /* ... and not really a class type. */
6948 SET_CLASS_TYPE_P (t, 0);
8d08fdba 6949
4977bab6
ZW
6950 field = build_decl (FIELD_DECL, pfn_identifier, type);
6951 fields = field;
caf93cb0 6952
4977bab6
ZW
6953 field = build_decl (FIELD_DECL, delta_identifier, delta_type_node);
6954 TREE_CHAIN (field) = fields;
6955 fields = field;
caf93cb0 6956
4977bab6 6957 finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
8d08fdba 6958
3b426391 6959 /* Zap out the name so that the back end will give us the debugging
8d08fdba
MS
6960 information for this anonymous RECORD_TYPE. */
6961 TYPE_NAME (t) = NULL_TREE;
6962
46cbda4a
MM
6963 /* If this is not the unqualified form of this pointer-to-member
6964 type, set the TYPE_MAIN_VARIANT for this type to be the
6965 unqualified type. Since they are actually RECORD_TYPEs that are
6966 not variants of each other, we must do this manually. */
89d684bb 6967 if (cp_type_quals (type) != TYPE_UNQUALIFIED)
46cbda4a 6968 {
89d684bb 6969 t = build_qualified_type (t, cp_type_quals (type));
46cbda4a
MM
6970 TYPE_MAIN_VARIANT (t) = unqualified_variant;
6971 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (unqualified_variant);
6972 TYPE_NEXT_VARIANT (unqualified_variant) = t;
6973 }
6974
6975 /* Cache this pointer-to-member type so that we can find it again
6976 later. */
8d08fdba
MS
6977 TYPE_SET_PTRMEMFUNC_TYPE (type, t);
6978
8de08f4c
DG
6979 /* Managing canonical types for the RECORD_TYPE behind a
6980 pointer-to-member function is a nightmare, so use structural
6981 equality for now. */
6982 SET_TYPE_STRUCTURAL_EQUALITY (t);
06d40de8 6983
8d08fdba
MS
6984 return t;
6985}
6986
9e259dd1
MM
6987/* Create and return a pointer to data member type. */
6988
6989tree
6990build_ptrmem_type (tree class_type, tree member_type)
6991{
a5ac359a
MM
6992 if (TREE_CODE (member_type) == METHOD_TYPE)
6993 {
6994 tree arg_types;
6995
6996 arg_types = TYPE_ARG_TYPES (member_type);
caf93cb0 6997 class_type = (cp_build_qualified_type
a5ac359a
MM
6998 (class_type,
6999 cp_type_quals (TREE_TYPE (TREE_VALUE (arg_types)))));
caf93cb0
EC
7000 member_type
7001 = build_method_type_directly (class_type,
43dc123f
MM
7002 TREE_TYPE (member_type),
7003 TREE_CHAIN (arg_types));
a5ac359a
MM
7004 return build_ptrmemfunc_type (build_pointer_type (member_type));
7005 }
7006 else
7007 {
50bc768d 7008 gcc_assert (TREE_CODE (member_type) != FUNCTION_TYPE);
a5ac359a
MM
7009 return build_offset_type (class_type, member_type);
7010 }
9e259dd1
MM
7011}
7012
b17e2870
JM
7013/* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
7014 Check to see that the definition is valid. Issue appropriate error
7015 messages. Return 1 if the definition is particularly bad, or 0
7016 otherwise. */
7017
7018int
11f6b451 7019check_static_variable_definition (tree decl, tree type)
b17e2870
JM
7020{
7021 /* Motion 10 at San Diego: If a static const integral data member is
7022 initialized with an integral constant expression, the initializer
7023 may appear either in the declaration (within the class), or in
7024 the definition, but not both. If it appears in the class, the
7025 member is a member constant. The file-scope definition is always
7026 required. */
dcba9b0f 7027 if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
b17e2870 7028 {
2d01edd7 7029 error ("invalid in-class initialization of static data member "
0cbd7506 7030 "of non-integral type %qT",
dcba9b0f 7031 type);
b17e2870 7032 /* If we just return the declaration, crashes will sometimes
852dcbdd 7033 occur. We therefore return void_type_node, as if this were a
b17e2870
JM
7034 friend declaration, to cause callers to completely ignore
7035 this declaration. */
7036 return 1;
7037 }
7038 else if (!CP_TYPE_CONST_P (type))
2d01edd7 7039 error ("ISO C++ forbids in-class initialization of non-const "
0cbd7506
MS
7040 "static member %qD",
7041 decl);
fcf73884
MLI
7042 else if (!INTEGRAL_TYPE_P (type))
7043 pedwarn (OPT_pedantic, "ISO C++ forbids initialization of member constant "
0cbd7506 7044 "%qD of non-integral type %qT", decl, type);
b17e2870
JM
7045
7046 return 0;
7047}
7048
2848ad0f
MM
7049/* Given the SIZE (i.e., number of elements) in an array, compute an
7050 appropriate index type for the array. If non-NULL, NAME is the
7051 name of the thing being declared. */
7052
c95cd22e 7053tree
11f6b451 7054compute_array_index_type (tree name, tree size)
2848ad0f 7055{
d174af6c 7056 tree type;
2848ad0f 7057 tree itype;
06d40de8 7058 tree abi_1_itype = NULL_TREE;
2848ad0f 7059
d174af6c
MM
7060 if (error_operand_p (size))
7061 return error_mark_node;
7062
7063 type = TREE_TYPE (size);
d63b5e9f
NS
7064 /* The array bound must be an integer type. */
7065 if (!dependent_type_p (type) && !INTEGRAL_TYPE_P (type))
2848ad0f 7066 {
d63b5e9f 7067 if (name)
2d01edd7 7068 error ("size of array %qD has non-integral type %qT", name, type);
d63b5e9f 7069 else
2d01edd7 7070 error ("size of array has non-integral type %qT", type);
d63b5e9f
NS
7071 size = integer_one_node;
7072 type = TREE_TYPE (size);
2848ad0f
MM
7073 }
7074
06d40de8
DG
7075 if (value_dependent_expression_p (size))
7076 {
7077 /* We cannot do any checking for a value-dependent SIZE. Just
7078 build the index type and mark that it requires structural
7079 equality checks. */
7080 itype = build_index_type (build_min (MINUS_EXPR, sizetype,
7081 size, integer_one_node));
7082 SET_TYPE_STRUCTURAL_EQUALITY (itype);
7083 return itype;
7084 }
7085
7086 if (!abi_version_at_least (2) && processing_template_decl)
7087 /* For abi-1, we handled all instances in templates the same way,
39a13be5 7088 even when they were non-dependent. This affects the manglings
06d40de8
DG
7089 produced. So, we do the normal checking for non-dependent
7090 sizes, but at the end we'll return the same type that abi-1
7091 would have, but with TYPE_CANONICAL set to the "right"
7092 value that the current ABI would provide. */
7093 abi_1_itype = build_index_type (build_min (MINUS_EXPR, sizetype,
7094 size, integer_one_node));
d63b5e9f 7095
a1c65f9f 7096 /* The size might be the result of a cast. */
80f5bb34
MM
7097 STRIP_TYPE_NOPS (size);
7098
7099 /* It might be a const variable or enumeration constant. */
8a784e4a 7100 size = integral_constant_value (size);
80f5bb34 7101
2848ad0f 7102 /* Normally, the array-bound will be a constant. */
2bb5d995 7103 if (TREE_CODE (size) == INTEGER_CST)
2848ad0f
MM
7104 {
7105 /* Check to see if the array bound overflowed. Make that an
7106 error, no matter how generous we're being. */
393eda6a 7107 constant_expression_error (size);
2848ad0f
MM
7108
7109 /* An array must have a positive number of elements. */
7110 if (INT_CST_LT (size, integer_zero_node))
7111 {
d67cdbc3 7112 if (name)
2d01edd7 7113 error ("size of array %qD is negative", name);
d67cdbc3 7114 else
33bd39a2 7115 error ("size of array is negative");
2848ad0f
MM
7116 size = integer_one_node;
7117 }
a8e6c82a
MM
7118 /* As an extension we allow zero-sized arrays. We always allow
7119 them in system headers because glibc uses them. */
fcf73884 7120 else if (integer_zerop (size) && !in_system_header)
d67cdbc3
JM
7121 {
7122 if (name)
fcf73884 7123 pedwarn (OPT_pedantic, "ISO C++ forbids zero-size array %qD", name);
d67cdbc3 7124 else
fcf73884 7125 pedwarn (OPT_pedantic, "ISO C++ forbids zero-size array");
d67cdbc3 7126 }
2848ad0f 7127 }
2bb5d995
JM
7128 else if (TREE_CONSTANT (size))
7129 {
7130 /* `(int) &fn' is not a valid array bound. */
7131 if (name)
2d01edd7 7132 error ("size of array %qD is not an integral constant-expression",
0cbd7506 7133 name);
2bb5d995 7134 else
33bd39a2 7135 error ("size of array is not an integral constant-expression");
3aa2ddb8 7136 size = integer_one_node;
2bb5d995 7137 }
50d50fc7 7138 else if (pedantic && warn_vla != 0)
d63b5e9f
NS
7139 {
7140 if (name)
fcf73884 7141 pedwarn (OPT_Wvla, "ISO C++ forbids variable length array %qD", name);
d63b5e9f 7142 else
fcf73884 7143 pedwarn (OPT_Wvla, "ISO C++ forbids variable length array");
50d50fc7
SP
7144 }
7145 else if (warn_vla > 0)
7146 {
7147 if (name)
7148 warning (OPT_Wvla,
7149 "variable length array %qD is used", name);
7150 else
7151 warning (OPT_Wvla,
7152 "variable length array is used");
d63b5e9f 7153 }
2848ad0f 7154
d63b5e9f
NS
7155 if (processing_template_decl && !TREE_CONSTANT (size))
7156 /* A variable sized array. */
7157 itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node);
7158 else
2848ad0f 7159 {
455f19cb
MM
7160 HOST_WIDE_INT saved_processing_template_decl;
7161
d63b5e9f 7162 /* Compute the index of the largest element in the array. It is
0cbd7506
MS
7163 one less than the number of elements in the array. We save
7164 and restore PROCESSING_TEMPLATE_DECL so that computations in
7165 cp_build_binary_op will be appropriately folded. */
455f19cb
MM
7166 saved_processing_template_decl = processing_template_decl;
7167 processing_template_decl = 0;
7168 itype = cp_build_binary_op (MINUS_EXPR,
7169 cp_convert (ssizetype, size),
5ade1ed2
DG
7170 cp_convert (ssizetype, integer_one_node),
7171 tf_warning_or_error);
455f19cb
MM
7172 itype = fold (itype);
7173 processing_template_decl = saved_processing_template_decl;
7174
d63b5e9f 7175 if (!TREE_CONSTANT (itype))
f4f206f4 7176 /* A variable sized array. */
d63b5e9f
NS
7177 itype = variable_size (itype);
7178 /* Make sure that there was no overflow when creating to a signed
0cbd7506
MS
7179 index type. (For example, on a 32-bit machine, an array with
7180 size 2^32 - 1 is too big.) */
9116d529
RS
7181 else if (TREE_CODE (itype) == INTEGER_CST
7182 && TREE_OVERFLOW (itype))
2848ad0f 7183 {
d63b5e9f
NS
7184 error ("overflow in array dimension");
7185 TREE_OVERFLOW (itype) = 0;
2848ad0f 7186 }
2848ad0f 7187 }
68642fb6 7188
2848ad0f 7189 /* Create and return the appropriate index type. */
06d40de8
DG
7190 if (abi_1_itype)
7191 {
7192 tree t = build_index_type (itype);
7193 TYPE_CANONICAL (abi_1_itype) = TYPE_CANONICAL (t);
7194 return abi_1_itype;
7195 }
7196 else
7197 return build_index_type (itype);
2848ad0f
MM
7198}
7199
a723baf1
MM
7200/* Returns the scope (if any) in which the entity declared by
7201 DECLARATOR will be located. If the entity was declared with an
7202 unqualified name, NULL_TREE is returned. */
7203
7204tree
058b15c1 7205get_scope_of_declarator (const cp_declarator *declarator)
a723baf1 7206{
058b15c1
MM
7207 while (declarator && declarator->kind != cdk_id)
7208 declarator = declarator->declarator;
7209
7210 /* If the declarator-id is a SCOPE_REF, the scope in which the
7211 declaration occurs is the first operand. */
7212 if (declarator
1d786913
MM
7213 && declarator->u.id.qualifying_scope)
7214 return declarator->u.id.qualifying_scope;
058b15c1 7215
77880ae4 7216 /* Otherwise, the declarator is not a qualified name; the entity will
058b15c1
MM
7217 be declared in the current scope. */
7218 return NULL_TREE;
a723baf1
MM
7219}
7220
2848ad0f
MM
7221/* Returns an ARRAY_TYPE for an array with SIZE elements of the
7222 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
7223 with this type. */
7224
7225static tree
11f6b451 7226create_array_type_for_decl (tree name, tree type, tree size)
2848ad0f
MM
7227{
7228 tree itype = NULL_TREE;
7229 const char* error_msg;
7230
7231 /* If things have already gone awry, bail now. */
7232 if (type == error_mark_node || size == error_mark_node)
7233 return error_mark_node;
7234
7235 /* Assume that everything will go OK. */
7236 error_msg = NULL;
7237
7238 /* There are some types which cannot be array elements. */
7239 switch (TREE_CODE (type))
7240 {
7241 case VOID_TYPE:
7242 error_msg = "array of void";
7243 break;
7244
7245 case FUNCTION_TYPE:
7246 error_msg = "array of functions";
7247 break;
7248
7249 case REFERENCE_TYPE:
7250 error_msg = "array of references";
7251 break;
7252
2848ad0f
MM
7253 case METHOD_TYPE:
7254 error_msg = "array of function members";
7255 break;
7256
7257 default:
7258 break;
7259 }
7260
7261 /* If something went wrong, issue an error-message and return. */
7262 if (error_msg)
7263 {
7264 if (name)
2d01edd7 7265 error ("declaration of %qD as %s", name, error_msg);
2848ad0f 7266 else
33bd39a2 7267 error ("creating %s", error_msg);
2848ad0f
MM
7268
7269 return error_mark_node;
7270 }
7271
7272 /* [dcl.array]
68642fb6 7273
2848ad0f
MM
7274 The constant expressions that specify the bounds of the arrays
7275 can be omitted only for the first member of the sequence. */
7276 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
7277 {
b3faacfd 7278 if (name)
2d01edd7 7279 error ("declaration of %qD as multidimensional array must "
0cbd7506
MS
7280 "have bounds for all dimensions except the first",
7281 name);
b3faacfd 7282 else
2d01edd7 7283 error ("multidimensional array must have bounds for all "
0cbd7506 7284 "dimensions except the first");
2848ad0f
MM
7285
7286 return error_mark_node;
7287 }
7288
7289 /* Figure out the index type for the array. */
7290 if (size)
7291 itype = compute_array_index_type (name, size);
7292
7fb213d8
GB
7293 /* [dcl.array]
7294 T is called the array element type; this type shall not be [...] an
7295 abstract class type. */
7296 abstract_virtuals_error (name, type);
7297
2848ad0f
MM
7298 return build_cplus_array_type (type, itype);
7299}
7300
3dbc07b6
MM
7301/* Check that it's OK to declare a function with the indicated TYPE.
7302 SFK indicates the kind of special function (if any) that this
1f84ec23 7303 function is. OPTYPE is the type given in a conversion operator
44d10c10
PB
7304 declaration, or the class type for a constructor/destructor.
7305 Returns the actual return type of the function; that
3dbc07b6
MM
7306 may be different than TYPE if an error occurs, or for certain
7307 special functions. */
7308
7309static tree
11f6b451 7310check_special_function_return_type (special_function_kind sfk,
0cbd7506
MS
7311 tree type,
7312 tree optype)
3dbc07b6
MM
7313{
7314 switch (sfk)
7315 {
7316 case sfk_constructor:
7317 if (type)
33bd39a2 7318 error ("return type specification for constructor invalid");
5362b086 7319
44d10c10
PB
7320 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
7321 type = build_pointer_type (optype);
7322 else
7323 type = void_type_node;
3dbc07b6
MM
7324 break;
7325
7326 case sfk_destructor:
7327 if (type)
33bd39a2 7328 error ("return type specification for destructor invalid");
44d10c10 7329 /* We can't use the proper return type here because we run into
77880ae4 7330 problems with ambiguous bases and covariant returns.
44d10c10
PB
7331 Java classes are left unchanged because (void *) isn't a valid
7332 Java type, and we don't want to change the Java ABI. */
7333 if (targetm.cxx.cdtor_returns_this () && !TYPE_FOR_JAVA (optype))
7334 type = build_pointer_type (void_type_node);
7335 else
7336 type = void_type_node;
3dbc07b6
MM
7337 break;
7338
7339 case sfk_conversion:
caba2081
PC
7340 if (type)
7341 error ("return type specified for %<operator %T%>", optype);
3dbc07b6
MM
7342 type = optype;
7343 break;
7344
7345 default:
8dc2b103 7346 gcc_unreachable ();
3dbc07b6
MM
7347 }
7348
7349 return type;
7350}
7351
62e19030
MM
7352/* A variable or data member (whose unqualified name is IDENTIFIER)
7353 has been declared with the indicated TYPE. If the TYPE is not
7354 acceptable, issue an error message and return a type to use for
03fd3f84 7355 error-recovery purposes. */
62e19030
MM
7356
7357tree
7358check_var_type (tree identifier, tree type)
7359{
7360 if (VOID_TYPE_P (type))
7361 {
7362 if (!identifier)
7363 error ("unnamed variable or field declared void");
7364 else if (TREE_CODE (identifier) == IDENTIFIER_NODE)
7365 {
7366 gcc_assert (!IDENTIFIER_OPNAME_P (identifier));
7367 error ("variable or field %qE declared void", identifier);
7368 }
7369 else
7370 error ("variable or field declared void");
650fcd07 7371 type = error_mark_node;
62e19030 7372 }
c8094d83 7373
62e19030
MM
7374 return type;
7375}
7376
a723baf1
MM
7377/* Given declspecs and a declarator (abstract or otherwise), determine
7378 the name and type of the object declared and construct a DECL node
7379 for it.
8d08fdba 7380
5e32a5cf
GDR
7381 DECLSPECS points to the representation of declaration-specifier
7382 sequence that precedes declarator.
8d08fdba
MS
7383
7384 DECL_CONTEXT says which syntactic context this declaration is in:
7385 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
7386 FUNCDEF for a function definition. Like NORMAL but a few different
7387 error messages in each case. Return value may be zero meaning
7388 this definition is too screwy to try to parse.
7389 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
7390 handle member functions (which have FIELD context).
7391 Return value may be zero meaning this definition is too screwy to
7392 try to parse.
7393 PARM for a parameter declaration (either within a function prototype
7394 or before a function body). Make a PARM_DECL, or return void_type_node.
db5ae43f 7395 CATCHPARM for a parameter declaration before a catch clause.
8d08fdba
MS
7396 TYPENAME if for a typename (in a cast or sizeof).
7397 Don't make a DECL node; just return the ..._TYPE node.
7398 FIELD for a struct or union field; make a FIELD_DECL.
7399 BITFIELD for a field with specified width.
b87d79e6 7400 INITIALIZED is as for start_decl.
8d08fdba 7401
91d231cb
JM
7402 ATTRLIST is a pointer to the list of attributes, which may be NULL
7403 if there are none; *ATTRLIST may be modified if attributes from inside
7404 the declarator should be applied to the declaration.
b17e2870 7405
a723baf1
MM
7406 When this function is called, scoping variables (such as
7407 CURRENT_CLASS_TYPE) should reflect the scope in which the
7408 declaration occurs, not the scope in which the new declaration will
7409 be placed. For example, on:
8d08fdba 7410
a723baf1 7411 void S::f() { ... }
8d08fdba 7412
a723baf1 7413 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
344f237b
LM
7414 should not be `S'.
7415
7416 Returns a DECL (if a declarator is present), a TYPE (if there is no
7417 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
7418 error occurs. */
8d08fdba 7419
8d08fdba 7420tree
058b15c1 7421grokdeclarator (const cp_declarator *declarator,
1ff3c076 7422 const cp_decl_specifier_seq *declspecs,
0cbd7506
MS
7423 enum decl_context decl_context,
7424 int initialized,
7425 tree* attrlist)
8d08fdba 7426{
8d08fdba
MS
7427 tree type = NULL_TREE;
7428 int longlong = 0;
db5ae43f 7429 int virtualp, explicitp, friendp, inlinep, staticp;
8d08fdba
MS
7430 int explicit_int = 0;
7431 int explicit_char = 0;
37c46b43 7432 int defaulted_int = 0;
d1c78882 7433 tree dependent_name = NULL_TREE;
caf93cb0 7434
8d08fdba 7435 tree typedef_decl = NULL_TREE;
058b15c1 7436 const char *name = NULL;
8d08fdba 7437 tree typedef_type = NULL_TREE;
357d956e
MM
7438 /* True if this declarator is a function definition. */
7439 bool funcdef_flag = false;
058b15c1 7440 cp_declarator_kind innermost_code = cdk_error;
8d08fdba 7441 int bitfield = 0;
6125f3be
DE
7442#if 0
7443 /* See the code below that used this. */
91d231cb 7444 tree decl_attr = NULL_TREE;
6125f3be 7445#endif
8d08fdba
MS
7446
7447 /* Keep track of what sort of function is being processed
7448 so that we can warn about default return values, or explicit
7449 return values which do not match prescribed defaults. */
3dbc07b6 7450 special_function_kind sfk = sfk_none;
8d08fdba
MS
7451
7452 tree dname = NULL_TREE;
8d08fdba
MS
7453 tree ctor_return_type = NULL_TREE;
7454 enum overload_flags flags = NO_SPECIAL;
e2537f2c
MM
7455 /* cv-qualifiers that apply to the declarator, for a declaration of
7456 a member function. */
7457 cp_cv_quals memfn_quals = TYPE_UNQUALIFIED;
7458 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
7459 int type_quals;
c11b6f21 7460 tree raises = NULL_TREE;
386b8a85 7461 int template_count = 0;
91d231cb 7462 tree returned_attrs = NULL_TREE;
4546865e 7463 tree parms = NULL_TREE;
058b15c1
MM
7464 const cp_declarator *id_declarator;
7465 /* The unqualified name of the declarator; either an
7466 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
7467 tree unqualified_id;
7468 /* The class type, if any, in which this entity is located,
7469 or NULL_TREE if none. Note that this value may be different from
7470 the current class type; for example if an attempt is made to declare
7471 "A::f" inside "B", this value will be "A". */
7472 tree ctype = current_class_type;
7473 /* The NAMESPACE_DECL for the namespace in which this entity is
7474 located. If an unqualified name is used to declare the entity,
7475 this value will be NULL_TREE, even if the entity is located at
caf93cb0 7476 namespace scope. */
058b15c1 7477 tree in_namespace = NULL_TREE;
1ff3c076
MM
7478 cp_storage_class storage_class;
7479 bool unsigned_p, signed_p, short_p, long_p, thread_p;
2cfe82fe 7480 bool type_was_error_mark_node = false;
5d80a306 7481 bool parameter_pack_p = declarator? declarator->parameter_pack_p : false;
1891dec4 7482 bool set_no_warning = false;
1ff3c076
MM
7483
7484 signed_p = declspecs->specs[(int)ds_signed];
7485 unsigned_p = declspecs->specs[(int)ds_unsigned];
7486 short_p = declspecs->specs[(int)ds_short];
7487 long_p = declspecs->specs[(int)ds_long];
28c84d63 7488 longlong = declspecs->specs[(int)ds_long] >= 2;
1ff3c076 7489 thread_p = declspecs->specs[(int)ds_thread];
8d08fdba 7490
8d08fdba 7491 if (decl_context == FUNCDEF)
357d956e 7492 funcdef_flag = true, decl_context = NORMAL;
8d08fdba 7493 else if (decl_context == MEMFUNCDEF)
357d956e 7494 funcdef_flag = true, decl_context = FIELD;
8d08fdba
MS
7495 else if (decl_context == BITFIELD)
7496 bitfield = 1, decl_context = FIELD;
7497
b87d79e6
JM
7498 if (initialized > 1)
7499 funcdef_flag = true;
7500
8d08fdba
MS
7501 /* Look inside a declarator for the name being declared
7502 and get it as a string, for an error message. */
caf93cb0
EC
7503 for (id_declarator = declarator;
7504 id_declarator;
058b15c1
MM
7505 id_declarator = id_declarator->declarator)
7506 {
7507 if (id_declarator->kind != cdk_id)
7508 innermost_code = id_declarator->kind;
8d08fdba 7509
058b15c1
MM
7510 switch (id_declarator->kind)
7511 {
7512 case cdk_function:
7513 if (id_declarator->declarator
7514 && id_declarator->declarator->kind == cdk_id)
8d08fdba 7515 {
058b15c1
MM
7516 sfk = id_declarator->declarator->u.id.sfk;
7517 if (sfk == sfk_destructor)
7518 flags = DTOR_FLAG;
51c184be 7519 }
058b15c1 7520 break;
be99da77 7521
058b15c1
MM
7522 case cdk_id:
7523 {
1d786913
MM
7524 tree qualifying_scope = id_declarator->u.id.qualifying_scope;
7525 tree decl = id_declarator->u.id.unqualified_name;
058b15c1
MM
7526 if (!decl)
7527 break;
1d786913 7528 if (qualifying_scope)
8d08fdba 7529 {
2884e22c
MM
7530 if (at_function_scope_p ())
7531 {
7532 /* [dcl.meaning]
7533
7534 A declarator-id shall not be qualified except
7535 for ...
7536
7537 None of the cases are permitted in block
7538 scope. */
7539 if (qualifying_scope == global_namespace)
7540 error ("invalid use of qualified-name %<::%D%>",
7541 decl);
7542 else if (TYPE_P (qualifying_scope))
7543 error ("invalid use of qualified-name %<%T::%D%>",
7544 qualifying_scope, decl);
7545 else
7546 error ("invalid use of qualified-name %<%D::%D%>",
7547 qualifying_scope, decl);
7548 return error_mark_node;
7549 }
7550 else if (TYPE_P (qualifying_scope))
058b15c1 7551 {
1d786913 7552 ctype = qualifying_scope;
058b15c1
MM
7553 if (innermost_code != cdk_function
7554 && current_class_type
caf93cb0 7555 && !UNIQUELY_DERIVED_FROM_P (ctype,
058b15c1
MM
7556 current_class_type))
7557 {
2d01edd7 7558 error ("type %qT is not derived from type %qT",
058b15c1 7559 ctype, current_class_type);
1d786913 7560 return error_mark_node;
058b15c1 7561 }
058b15c1
MM
7562 }
7563 else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL)
7564 in_namespace = qualifying_scope;
058b15c1 7565 }
058b15c1
MM
7566 switch (TREE_CODE (decl))
7567 {
7568 case BIT_NOT_EXPR:
be99da77 7569 {
88e95ee3
MM
7570 tree type;
7571
7572 if (innermost_code != cdk_function)
7573 {
7574 error ("declaration of %qD as non-function", decl);
7575 return error_mark_node;
7576 }
c8094d83 7577 else if (!qualifying_scope
88e95ee3
MM
7578 && !(current_class_type && at_class_scope_p ()))
7579 {
7580 error ("declaration of %qD as non-member", decl);
7581 return error_mark_node;
7582 }
c8094d83 7583
88e95ee3
MM
7584 type = TREE_OPERAND (decl, 0);
7585 name = IDENTIFIER_POINTER (constructor_name (type));
af02935e 7586 dname = decl;
058b15c1
MM
7587 }
7588 break;
633221db 7589
058b15c1
MM
7590 case TEMPLATE_ID_EXPR:
7591 {
7592 tree fns = TREE_OPERAND (decl, 0);
633221db 7593
058b15c1 7594 dname = fns;
058b15c1 7595 if (TREE_CODE (dname) != IDENTIFIER_NODE)
be99da77 7596 {
50bc768d 7597 gcc_assert (is_overloaded_fn (dname));
058b15c1 7598 dname = DECL_NAME (get_first_fn (dname));
be99da77
MS
7599 }
7600 }
058b15c1 7601 /* Fall through. */
be99da77 7602
058b15c1
MM
7603 case IDENTIFIER_NODE:
7604 if (TREE_CODE (decl) == IDENTIFIER_NODE)
7605 dname = decl;
be99da77 7606
058b15c1
MM
7607 if (C_IS_RESERVED_WORD (dname))
7608 {
2d01edd7 7609 error ("declarator-id missing; using reserved word %qD",
058b15c1
MM
7610 dname);
7611 name = IDENTIFIER_POINTER (dname);
7612 }
7613 else if (!IDENTIFIER_TYPENAME_P (dname))
7614 name = IDENTIFIER_POINTER (dname);
7615 else
7616 {
50bc768d 7617 gcc_assert (flags == NO_SPECIAL);
058b15c1
MM
7618 flags = TYPENAME_FLAG;
7619 ctor_return_type = TREE_TYPE (dname);
7620 sfk = sfk_conversion;
7621 if (is_typename_at_global_scope (dname))
7622 name = IDENTIFIER_POINTER (dname);
7623 else
7624 name = "<invalid operator>";
7625 }
7626 break;
7627
058b15c1 7628 default:
8dc2b103 7629 gcc_unreachable ();
058b15c1 7630 }
45537677 7631 break;
b08f991d 7632 }
45537677 7633
b08f991d
SB
7634 case cdk_array:
7635 case cdk_pointer:
7636 case cdk_reference:
7637 case cdk_ptrmem:
7638 break;
2ee366b5 7639
b08f991d
SB
7640 case cdk_error:
7641 return error_mark_node;
058b15c1 7642
b08f991d
SB
7643 default:
7644 gcc_unreachable ();
058b15c1
MM
7645 }
7646 if (id_declarator->kind == cdk_id)
7647 break;
7648 }
8d08fdba 7649
fa6098f8 7650 /* [dcl.fct.edf]
3db45ab5 7651
fa6098f8
MM
7652 The declarator in a function-definition shall have the form
7653 D1 ( parameter-declaration-clause) ... */
058b15c1 7654 if (funcdef_flag && innermost_code != cdk_function)
fa6098f8
MM
7655 {
7656 error ("function definition does not declare parameters");
7657 return error_mark_node;
7658 }
8d08fdba 7659
e1cd6e56 7660 if (((dname && IDENTIFIER_OPNAME_P (dname)) || flags == TYPENAME_FLAG)
058b15c1 7661 && innermost_code != cdk_function
62d1db17 7662 && ! (ctype && !declspecs->any_specifiers_p))
e1cd6e56 7663 {
2d01edd7 7664 error ("declaration of %qD as non-function", dname);
943e3ede 7665 return error_mark_node;
e1cd6e56
MS
7666 }
7667
8d08fdba
MS
7668 /* Anything declared one level down from the top level
7669 must be one of the parameters of a function
7670 (because the body is at least two levels down). */
7671
7672 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
7673 by not allowing C++ class definitions to specify their parameters
7674 with xdecls (must be spec.d in the parmlist).
7675
7676 Since we now wait to push a class scope until we are sure that
7677 we are in a legitimate method context, we must set oldcname
a9aedbc2
MS
7678 explicitly (since current_class_name is not yet alive).
7679
7680 We also want to avoid calling this a PARM if it is in a namespace. */
8d08fdba 7681
9188c363 7682 if (decl_context == NORMAL && !toplevel_bindings_p ())
a9aedbc2 7683 {
e2500fed 7684 struct cp_binding_level *b = current_binding_level;
ff955512 7685 current_binding_level = b->level_chain;
a9aedbc2
MS
7686 if (current_binding_level != 0 && toplevel_bindings_p ())
7687 decl_context = PARM;
ff955512 7688 current_binding_level = b;
a9aedbc2 7689 }
8d08fdba 7690
34fc957d
NS
7691 if (name == NULL)
7692 name = decl_context == PARM ? "parameter" : "type name";
68642fb6 7693
62d1db17
MM
7694 /* If there were multiple types specified in the decl-specifier-seq,
7695 issue an error message. */
7696 if (declspecs->multiple_types_p)
32273f9f
LM
7697 {
7698 error ("two or more data types in declaration of %qs", name);
7699 return error_mark_node;
7700 }
7701
9b70c6b0
PC
7702 if (declspecs->conflicting_specifiers_p)
7703 {
7704 error ("conflicting specifiers in declaration of %qs", name);
7705 return error_mark_node;
7706 }
7707
62d1db17
MM
7708 /* Extract the basic type from the decl-specifier-seq. */
7709 type = declspecs->type;
7710 if (type == error_mark_node)
2cfe82fe
ZW
7711 {
7712 type = NULL_TREE;
7713 type_was_error_mark_node = true;
7714 }
62d1db17
MM
7715 /* If the entire declaration is itself tagged as deprecated then
7716 suppress reports of deprecated items. */
7717 if (type && TREE_DEPRECATED (type)
7718 && deprecated_state != DEPRECATED_SUPPRESS)
7719 warn_deprecated_use (type);
7720 if (type && TREE_CODE (type) == TYPE_DECL)
8d08fdba 7721 {
62d1db17
MM
7722 typedef_decl = type;
7723 type = TREE_TYPE (typedef_decl);
823dd937
JM
7724 if (TREE_DEPRECATED (type)
7725 && DECL_ARTIFICIAL (typedef_decl)
7726 && deprecated_state != DEPRECATED_SUPPRESS)
7727 warn_deprecated_use (type);
62d1db17
MM
7728 }
7729 /* No type at all: default to `int', and set DEFAULTED_INT
7730 because it was not a user-defined typedef. */
1ff3c076 7731 if (type == NULL_TREE && (signed_p || unsigned_p || long_p || short_p))
62d1db17
MM
7732 {
7733 /* These imply 'int'. */
7734 type = integer_type_node;
7735 defaulted_int = 1;
7736 }
7737 /* Gather flags. */
7738 explicit_int = declspecs->explicit_int_p;
7739 explicit_char = declspecs->explicit_char_p;
7a1f3f5f 7740
8d6e459d
NS
7741#if 0
7742 /* See the code below that used this. */
7743 if (typedef_decl)
7744 decl_attr = DECL_ATTRIBUTES (typedef_decl);
7745#endif
8d08fdba
MS
7746 typedef_type = type;
7747
a3203465 7748
44d10c10
PB
7749 if (sfk != sfk_conversion)
7750 ctor_return_type = ctype;
7751
3dbc07b6
MM
7752 if (sfk != sfk_none)
7753 type = check_special_function_return_type (sfk, type,
3dbc07b6
MM
7754 ctor_return_type);
7755 else if (type == NULL_TREE)
8d08fdba 7756 {
3dbc07b6
MM
7757 int is_main;
7758
8d08fdba 7759 explicit_int = -1;
3dbc07b6 7760
0fd0b7ee
JM
7761 /* We handle `main' specially here, because 'main () { }' is so
7762 common. With no options, it is allowed. With -Wreturn-type,
7763 it is a warning. It is only an error with -pedantic-errors. */
3dbc07b6 7764 is_main = (funcdef_flag
7437519c 7765 && dname && MAIN_NAME_P (dname)
3dbc07b6
MM
7766 && ctype == NULL_TREE
7767 && in_namespace == NULL_TREE
7768 && current_namespace == global_namespace);
7769
2cfe82fe
ZW
7770 if (type_was_error_mark_node)
7771 /* We've already issued an error, don't complain more. */;
7772 else if (in_system_header || flag_ms_extensions)
3dbc07b6 7773 /* Allow it, sigh. */;
37ec60ed
JW
7774 else if (! is_main)
7775 permerror ("ISO C++ forbids declaration of %qs with no type", name);
7776 else if (pedantic)
fcf73884
MLI
7777 pedwarn (OPT_pedantic,
7778 "ISO C++ forbids declaration of %qs with no type", name);
b10fc6f5
GDR
7779 else
7780 warning (OPT_Wreturn_type,
7781 "ISO C++ forbids declaration of %qs with no type", name);
41eff652 7782
3dbc07b6 7783 type = integer_type_node;
51c184be 7784 }
caf93cb0 7785
8d08fdba
MS
7786 ctype = NULL_TREE;
7787
7788 /* Now process the modifiers that were specified
7789 and check for invalid combinations. */
7790
7791 /* Long double is a special combination. */
3cc189f5 7792 if (long_p && !longlong && TYPE_MAIN_VARIANT (type) == double_type_node)
8d08fdba 7793 {
1ff3c076 7794 long_p = false;
68642fb6 7795 type = build_qualified_type (long_double_type_node,
89d684bb 7796 cp_type_quals (type));
8d08fdba
MS
7797 }
7798
7799 /* Check all other uses of type modifiers. */
7800
1ff3c076 7801 if (unsigned_p || signed_p || long_p || short_p)
8d08fdba
MS
7802 {
7803 int ok = 0;
7804
3cc189f5
VR
7805 if ((signed_p || unsigned_p) && TREE_CODE (type) != INTEGER_TYPE)
7806 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
1ff3c076 7807 else if (signed_p && unsigned_p)
3cc189f5
VR
7808 error ("%<signed%> and %<unsigned%> specified together for %qs", name);
7809 else if (longlong && TREE_CODE (type) != INTEGER_TYPE)
7810 error ("%<long long%> invalid for %qs", name);
7811 else if (long_p && TREE_CODE (type) == REAL_TYPE)
7812 error ("%<long%> invalid for %qs", name);
7813 else if (short_p && TREE_CODE (type) == REAL_TYPE)
7814 error ("%<short%> invalid for %qs", name);
5d48268f
VR
7815 else if ((long_p || short_p) && TREE_CODE (type) != INTEGER_TYPE)
7816 error ("%<long%> or %<short%> invalid for %qs", name);
3cc189f5
VR
7817 else if ((long_p || short_p) && explicit_char)
7818 error ("%<long%> or %<short%> specified with char for %qs", name);
7819 else if (long_p && short_p)
7820 error ("%<long%> and %<short%> specified together for %qs", name);
b6baa67d
KVH
7821 else if (type == char16_type_node || type == char32_type_node)
7822 {
7823 if (signed_p || unsigned_p)
7824 error ("%<signed%> or %<unsigned%> invalid for %qs", name);
7825 else if (short_p || long_p)
7826 error ("%<short%> or %<long%> invalid for %qs", name);
7827 }
8d08fdba
MS
7828 else
7829 {
7830 ok = 1;
37c46b43 7831 if (!explicit_int && !defaulted_int && !explicit_char && pedantic)
8d08fdba 7832 {
fcf73884
MLI
7833 pedwarn (OPT_pedantic,
7834 "long, short, signed or unsigned used invalidly for %qs",
8d08fdba
MS
7835 name);
7836 if (flag_pedantic_errors)
7837 ok = 0;
7838 }
7839 }
7840
7841 /* Discard the type modifiers if they are invalid. */
7842 if (! ok)
7843 {
1ff3c076
MM
7844 unsigned_p = false;
7845 signed_p = false;
7846 long_p = false;
7847 short_p = false;
8d08fdba
MS
7848 longlong = 0;
7849 }
7850 }
7851
7852 /* Decide whether an integer type is signed or not.
7853 Optionally treat bitfields as signed by default. */
1ff3c076 7854 if (unsigned_p
b89c5a7b
MM
7855 /* [class.bit]
7856
7857 It is implementation-defined whether a plain (neither
7858 explicitly signed or unsigned) char, short, int, or long
7859 bit-field is signed or unsigned.
68642fb6 7860
b89c5a7b
MM
7861 Naturally, we extend this to long long as well. Note that
7862 this does not include wchar_t. */
7863 || (bitfield && !flag_signed_bitfields
1ff3c076 7864 && !signed_p
b89c5a7b
MM
7865 /* A typedef for plain `int' without `signed' can be
7866 controlled just like plain `int', but a typedef for
7867 `signed int' cannot be so controlled. */
68642fb6 7868 && !(typedef_decl
29bbeb1c 7869 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
b38a05d0 7870 && TREE_CODE (type) == INTEGER_TYPE
29bbeb1c 7871 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
8d08fdba
MS
7872 {
7873 if (longlong)
7874 type = long_long_unsigned_type_node;
1ff3c076 7875 else if (long_p)
8d08fdba 7876 type = long_unsigned_type_node;
1ff3c076 7877 else if (short_p)
8d08fdba
MS
7878 type = short_unsigned_type_node;
7879 else if (type == char_type_node)
7880 type = unsigned_char_type_node;
7881 else if (typedef_decl)
ca5ba2a3 7882 type = unsigned_type_for (type);
8d08fdba
MS
7883 else
7884 type = unsigned_type_node;
7885 }
1ff3c076 7886 else if (signed_p && type == char_type_node)
8d08fdba
MS
7887 type = signed_char_type_node;
7888 else if (longlong)
7889 type = long_long_integer_type_node;
1ff3c076 7890 else if (long_p)
8d08fdba 7891 type = long_integer_type_node;
1ff3c076 7892 else if (short_p)
8d08fdba
MS
7893 type = short_integer_type_node;
7894
62d1db17 7895 if (declspecs->specs[(int)ds_complex])
37c46b43 7896 {
1ff3c076 7897 if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
2d01edd7 7898 error ("complex invalid for %qs", name);
37c46b43
MS
7899 /* If we just have "complex", it is equivalent to
7900 "complex double", but if any modifiers at all are specified it is
7901 the complex form of TYPE. E.g, "complex short" is
7902 "complex short int". */
7903
1ff3c076
MM
7904 else if (defaulted_int && ! longlong
7905 && ! (long_p || short_p || signed_p || unsigned_p))
37c46b43
MS
7906 type = complex_double_type_node;
7907 else if (type == integer_type_node)
7908 type = complex_integer_type_node;
7909 else if (type == float_type_node)
7910 type = complex_float_type_node;
7911 else if (type == double_type_node)
7912 type = complex_double_type_node;
7913 else if (type == long_double_type_node)
7914 type = complex_long_double_type_node;
7915 else
7916 type = build_complex_type (type);
7917 }
7918
4f2b0fb2 7919 type_quals = TYPE_UNQUALIFIED;
62d1db17 7920 if (declspecs->specs[(int)ds_const])
4f2b0fb2 7921 type_quals |= TYPE_QUAL_CONST;
62d1db17 7922 if (declspecs->specs[(int)ds_volatile])
4f2b0fb2 7923 type_quals |= TYPE_QUAL_VOLATILE;
62d1db17 7924 if (declspecs->specs[(int)ds_restrict])
4f2b0fb2
NS
7925 type_quals |= TYPE_QUAL_RESTRICT;
7926 if (sfk == sfk_conversion && type_quals != TYPE_UNQUALIFIED)
2d01edd7 7927 error ("qualifiers are not allowed on declaration of %<operator %T%>",
0cbd7506 7928 ctor_return_type);
3ac3d9ea 7929
c8094d83 7930 if (TREE_CODE (type) == FUNCTION_TYPE
9804209d
DG
7931 && type_quals != TYPE_UNQUALIFIED)
7932 {
7933 /* This was an error in C++98 (cv-qualifiers cannot be added to
0cbd7506
MS
7934 a function type), but DR 295 makes the code well-formed by
7935 dropping the extra qualifiers. */
9804209d 7936 if (pedantic)
0cbd7506
MS
7937 {
7938 tree bad_type = build_qualified_type (type, type_quals);
fcf73884
MLI
7939 pedwarn (OPT_pedantic,
7940 "ignoring %qV qualifiers added to function type %qT",
0cbd7506
MS
7941 bad_type, type);
7942 }
9804209d
DG
7943 type_quals = TYPE_UNQUALIFIED;
7944 }
4f2b0fb2
NS
7945 type_quals |= cp_type_quals (type);
7946 type = cp_build_qualified_type_real
7947 (type, type_quals, ((typedef_decl && !DECL_ARTIFICIAL (typedef_decl)
23fca1f5 7948 ? tf_ignore_bad_quals : 0) | tf_warning_or_error));
4f2b0fb2
NS
7949 /* We might have ignored or rejected some of the qualifiers. */
7950 type_quals = cp_type_quals (type);
caf93cb0 7951
8d08fdba 7952 staticp = 0;
62d1db17
MM
7953 inlinep = !! declspecs->specs[(int)ds_inline];
7954 virtualp = !! declspecs->specs[(int)ds_virtual];
7955 explicitp = !! declspecs->specs[(int)ds_explicit];
8d08fdba 7956
1ff3c076
MM
7957 storage_class = declspecs->storage_class;
7958 if (storage_class == sc_static)
8d08fdba
MS
7959 staticp = 1 + (decl_context == FIELD);
7960
7961 if (virtualp && staticp == 2)
7962 {
2d01edd7 7963 error ("member %qD cannot be declared both virtual and static", dname);
7e1e0765 7964 storage_class = sc_none;
8d08fdba
MS
7965 staticp = 0;
7966 }
62d1db17 7967 friendp = !! declspecs->specs[(int)ds_friend];
8d08fdba 7968
d1c78882 7969 if (dependent_name && !friendp)
d5614afb 7970 {
d1c78882 7971 error ("%<%T::%D%> is not a valid declarator", ctype, dependent_name);
13dbe691 7972 return error_mark_node;
d5614afb 7973 }
8d08fdba 7974
62d1db17
MM
7975 /* Issue errors about use of storage classes for parameters. */
7976 if (decl_context == PARM)
8d08fdba 7977 {
62d1db17 7978 if (declspecs->specs[(int)ds_typedef])
709f9dcf
VR
7979 {
7980 error ("typedef declaration invalid in parameter declaration");
7981 return error_mark_node;
7982 }
1ff3c076
MM
7983 else if (storage_class == sc_static
7984 || storage_class == sc_extern
7985 || thread_p)
8251199e 7986 error ("storage class specifiers invalid in parameter declarations");
8d08fdba
MS
7987 }
7988
7989 /* Give error if `virtual' is used outside of class declaration. */
b7484fbe
MS
7990 if (virtualp
7991 && (current_class_name == NULL_TREE || decl_context != FIELD))
8d08fdba 7992 {
bcac2b89 7993 error ("%<virtual%> outside class declaration");
8d08fdba
MS
7994 virtualp = 0;
7995 }
8d08fdba
MS
7996
7997 /* Static anonymous unions are dealt with here. */
7998 if (staticp && decl_context == TYPENAME
62d1db17
MM
7999 && declspecs->type
8000 && ANON_AGGR_TYPE_P (declspecs->type))
8d08fdba
MS
8001 decl_context = FIELD;
8002
8d08fdba
MS
8003 /* Warn about storage classes that are invalid for certain
8004 kinds of declarations (parameters, typenames, etc.). */
3e66d096
JJ
8005 if (thread_p
8006 && ((storage_class
8007 && storage_class != sc_extern
8008 && storage_class != sc_static)
8009 || declspecs->specs[(int)ds_typedef]))
8010 {
8011 error ("multiple storage classes in declaration of %qs", name);
8012 thread_p = false;
8013 }
9b70c6b0
PC
8014 if (decl_context != NORMAL
8015 && ((storage_class != sc_none
8016 && storage_class != sc_mutable)
8017 || thread_p))
8d08fdba 8018 {
db5ae43f 8019 if ((decl_context == PARM || decl_context == CATCHPARM)
1ff3c076
MM
8020 && (storage_class == sc_register
8021 || storage_class == sc_auto))
8d08fdba 8022 ;
62d1db17 8023 else if (declspecs->specs[(int)ds_typedef])
fc378698 8024 ;
8d08fdba 8025 else if (decl_context == FIELD
f4f206f4 8026 /* C++ allows static class elements. */
1ff3c076 8027 && storage_class == sc_static)
d363e7bf
AJ
8028 /* C++ also allows inlines and signed and unsigned elements,
8029 but in those cases we don't come in here. */
8d08fdba
MS
8030 ;
8031 else
8032 {
8033 if (decl_context == FIELD)
389c6c8b 8034 error ("storage class specified for %qs", name);
8d08fdba 8035 else
b9d12519
KG
8036 {
8037 if (decl_context == PARM || decl_context == CATCHPARM)
2d01edd7 8038 error ("storage class specified for parameter %qs", name);
b9d12519
KG
8039 else
8040 error ("storage class specified for typename");
8041 }
1ff3c076
MM
8042 if (storage_class == sc_register
8043 || storage_class == sc_auto
8044 || storage_class == sc_extern
8045 || thread_p)
8046 storage_class = sc_none;
8d08fdba
MS
8047 }
8048 }
1ff3c076 8049 else if (storage_class == sc_extern && funcdef_flag
a9aedbc2 8050 && ! toplevel_bindings_p ())
2d01edd7 8051 error ("nested function %qs declared %<extern%>", name);
a9aedbc2 8052 else if (toplevel_bindings_p ())
8d08fdba 8053 {
1ff3c076 8054 if (storage_class == sc_auto)
2d01edd7 8055 error ("top-level declaration of %qs specifies %<auto%>", name);
8d08fdba 8056 }
1ff3c076
MM
8057 else if (thread_p
8058 && storage_class != sc_extern
8059 && storage_class != sc_static)
7a1f3f5f 8060 {
2d01edd7 8061 error ("function-scope %qs implicitly auto and declared %<__thread%>",
7a1f3f5f 8062 name);
1ff3c076 8063 thread_p = false;
7a1f3f5f 8064 }
8d08fdba 8065
1ff3c076 8066 if (storage_class && friendp)
ff7437d0
SM
8067 {
8068 error ("storage class specifiers invalid in friend function declarations");
8069 storage_class = sc_none;
8070 staticp = 0;
8071 }
909e536a 8072
058b15c1
MM
8073 if (!id_declarator)
8074 unqualified_id = NULL_TREE;
8075 else
8d08fdba 8076 {
1d786913 8077 unqualified_id = id_declarator->u.id.unqualified_name;
058b15c1 8078 switch (TREE_CODE (unqualified_id))
8d08fdba 8079 {
058b15c1 8080 case BIT_NOT_EXPR:
caf93cb0 8081 unqualified_id
058b15c1
MM
8082 = constructor_name (TREE_OPERAND (unqualified_id, 0));
8083 break;
caf93cb0 8084
058b15c1
MM
8085 case IDENTIFIER_NODE:
8086 case TEMPLATE_ID_EXPR:
52fbc847 8087 break;
caf93cb0 8088
058b15c1 8089 default:
8dc2b103 8090 gcc_unreachable ();
058b15c1
MM
8091 }
8092 }
52fbc847 8093
058b15c1
MM
8094 /* Determine the type of the entity declared by recurring on the
8095 declarator. */
f4f18103 8096 for (; declarator; declarator = declarator->declarator)
058b15c1
MM
8097 {
8098 const cp_declarator *inner_declarator;
8099 tree attrs;
8d08fdba 8100
058b15c1
MM
8101 if (type == error_mark_node)
8102 return error_mark_node;
c1b177ec 8103
058b15c1
MM
8104 attrs = declarator->attributes;
8105 if (attrs)
8106 {
8107 int attr_flags;
caf93cb0 8108
058b15c1
MM
8109 attr_flags = 0;
8110 if (declarator == NULL || declarator->kind == cdk_id)
8111 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
8112 if (declarator->kind == cdk_function)
8113 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
8114 if (declarator->kind == cdk_array)
8115 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
8116 returned_attrs = decl_attributes (&type,
8117 chainon (returned_attrs, attrs),
8118 attr_flags);
8119 }
8120
f4f18103
MM
8121 if (declarator->kind == cdk_id)
8122 break;
8123
8124 inner_declarator = declarator->declarator;
8125
058b15c1
MM
8126 switch (declarator->kind)
8127 {
8128 case cdk_array:
caf93cb0 8129 type = create_array_type_for_decl (dname, type,
058b15c1 8130 declarator->u.array.bounds);
8d08fdba
MS
8131 break;
8132
058b15c1 8133 case cdk_function:
8d08fdba
MS
8134 {
8135 tree arg_types;
f376e137 8136 int funcdecl_p;
8d08fdba
MS
8137
8138 /* Declaring a function type.
8139 Make sure we have a valid type for the function to return. */
8d08fdba 8140
1891dec4
DM
8141 if (type_quals != TYPE_UNQUALIFIED)
8142 {
8143 if (SCALAR_TYPE_P (type) || VOID_TYPE_P (type))
5db2e9ca 8144 warning (OPT_Wignored_qualifiers,
1891dec4
DM
8145 "type qualifiers ignored on function return type");
8146 /* We now know that the TYPE_QUALS don't apply to the
8147 decl, but to its return type. */
8148 type_quals = TYPE_UNQUALIFIED;
8149 set_no_warning = true;
8150 }
8d08fdba 8151
e3276457 8152 /* Error about some types functions can't return. */
8d08fdba
MS
8153
8154 if (TREE_CODE (type) == FUNCTION_TYPE)
8155 {
2d01edd7 8156 error ("%qs declared as function returning a function", name);
e3276457 8157 return error_mark_node;
8d08fdba
MS
8158 }
8159 if (TREE_CODE (type) == ARRAY_TYPE)
8160 {
2d01edd7 8161 error ("%qs declared as function returning an array", name);
e3276457 8162 return error_mark_node;
8d08fdba
MS
8163 }
8164
b7484fbe 8165 /* Pick up type qualifiers which should be applied to `this'. */
e2537f2c 8166 memfn_quals = declarator->u.function.qualifiers;
b7484fbe 8167
c11b6f21 8168 /* Pick up the exception specifications. */
058b15c1 8169 raises = declarator->u.function.exception_specification;
c11b6f21 8170
f376e137
MS
8171 /* Say it's a definition only for the CALL_EXPR
8172 closest to the identifier. */
058b15c1 8173 funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id;
68642fb6 8174
8d08fdba
MS
8175 if (ctype == NULL_TREE
8176 && decl_context == FIELD
f376e137 8177 && funcdecl_p
8d08fdba
MS
8178 && (friendp == 0 || dname == current_class_name))
8179 ctype = current_class_type;
8180
058b15c1
MM
8181 if (ctype && (sfk == sfk_constructor
8182 || sfk == sfk_destructor))
8d08fdba
MS
8183 {
8184 /* We are within a class's scope. If our declarator name
8185 is the same as the class name, and we are defining
8186 a function, then it is a constructor/destructor, and
8187 therefore returns a void type. */
3db45ab5 8188
e2537f2c
MM
8189 /* ISO C++ 12.4/2. A destructor may not be declared
8190 const or volatile. A destructor may not be
8191 static.
3db45ab5 8192
e2537f2c
MM
8193 ISO C++ 12.1. A constructor may not be declared
8194 const or volatile. A constructor may not be
8195 virtual. A constructor may not be static. */
3db45ab5 8196 if (staticp == 2)
e2537f2c
MM
8197 error ((flags == DTOR_FLAG)
8198 ? "destructor cannot be static member function"
8199 : "constructor cannot be static member function");
8200 if (memfn_quals)
8d08fdba 8201 {
e2537f2c
MM
8202 error ((flags == DTOR_FLAG)
8203 ? "destructors may not be cv-qualified"
8204 : "constructors may not be cv-qualified");
8205 memfn_quals = TYPE_UNQUALIFIED;
8d08fdba 8206 }
e2537f2c
MM
8207
8208 if (decl_context == FIELD
8209 && !member_function_or_else (ctype,
8210 current_class_type,
8211 flags))
13dbe691 8212 return error_mark_node;
e2537f2c
MM
8213
8214 if (flags != DTOR_FLAG)
8d08fdba 8215 {
e2537f2c 8216 /* It's a constructor. */
db5ae43f
MS
8217 if (explicitp == 1)
8218 explicitp = 2;
8d08fdba
MS
8219 if (virtualp)
8220 {
37ec60ed 8221 permerror ("constructors cannot be declared virtual");
8d08fdba
MS
8222 virtualp = 0;
8223 }
7137605e
MM
8224 if (decl_context == FIELD
8225 && sfk != sfk_constructor)
13dbe691 8226 return error_mark_node;
8d08fdba
MS
8227 }
8228 if (decl_context == FIELD)
8229 staticp = 0;
8230 }
b7484fbe 8231 else if (friendp)
8d08fdba 8232 {
b7484fbe 8233 if (initialized)
2d01edd7 8234 error ("can't initialize friend function %qs", name);
b7484fbe
MS
8235 if (virtualp)
8236 {
8237 /* Cannot be both friend and virtual. */
8251199e 8238 error ("virtual functions cannot be friends");
b7484fbe
MS
8239 friendp = 0;
8240 }
28cbf42c 8241 if (decl_context == NORMAL)
8251199e 8242 error ("friend declaration not in class definition");
28cbf42c 8243 if (current_function_decl && funcdef_flag)
2d01edd7 8244 error ("can't define friend function %qs in a local "
0cbd7506
MS
8245 "class definition",
8246 name);
8d08fdba
MS
8247 }
8248
caf93cb0 8249 arg_types = grokparms (declarator->u.function.parameters,
058b15c1 8250 &parms);
8d08fdba 8251
058b15c1
MM
8252 if (inner_declarator
8253 && inner_declarator->kind == cdk_id
8254 && inner_declarator->u.id.sfk == sfk_destructor
8255 && arg_types != void_list_node)
8d08fdba 8256 {
058b15c1
MM
8257 error ("destructors may not have parameters");
8258 arg_types = void_list_node;
8259 parms = NULL_TREE;
8d08fdba 8260 }
caf93cb0 8261
d22c8596 8262 type = build_function_type (type, arg_types);
8d08fdba
MS
8263 }
8264 break;
8265
058b15c1
MM
8266 case cdk_pointer:
8267 case cdk_reference:
8268 case cdk_ptrmem:
8d08fdba
MS
8269 /* Filter out pointers-to-references and references-to-references.
8270 We can get these if a TYPE_DECL is used. */
8271
8272 if (TREE_CODE (type) == REFERENCE_TYPE)
8273 {
8af2fec4
RY
8274 if (declarator->kind != cdk_reference)
8275 {
8276 error ("cannot declare pointer to %q#T", type);
8277 type = TREE_TYPE (type);
8278 }
8279
8280 /* In C++0x, we allow reference to reference declarations
8281 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
8282 and template type arguments [14.3.1/4 temp.arg.type]. The
8283 check for direct reference to reference declarations, which
8284 are still forbidden, occurs below. Reasoning behind the change
8285 can be found in DR106, DR540, and the rvalue reference
8286 proposals. */
c1ae8be5 8287 else if (cxx_dialect == cxx98)
8af2fec4
RY
8288 {
8289 error ("cannot declare reference to %q#T", type);
8290 type = TREE_TYPE (type);
8291 }
a5894242 8292 }
058b15c1
MM
8293 else if (VOID_TYPE_P (type))
8294 {
8295 if (declarator->kind == cdk_reference)
2d01edd7 8296 error ("cannot declare reference to %q#T", type);
058b15c1 8297 else if (declarator->kind == cdk_ptrmem)
2d01edd7 8298 error ("cannot declare pointer to %q#T member", type);
058b15c1 8299 }
61a127b3 8300
91063b51
MM
8301 /* We now know that the TYPE_QUALS don't apply to the decl,
8302 but to the target of the pointer. */
8303 type_quals = TYPE_UNQUALIFIED;
8d08fdba 8304
058b15c1 8305 if (declarator->kind == cdk_ptrmem
1b021ff4
JJ
8306 && (TREE_CODE (type) == FUNCTION_TYPE
8307 || (memfn_quals && TREE_CODE (type) == METHOD_TYPE)))
058b15c1 8308 {
e2537f2c 8309 memfn_quals |= cp_type_quals (type);
3db45ab5 8310 type = build_memfn_type (type,
e2537f2c
MM
8311 declarator->u.pointer.class_type,
8312 memfn_quals);
8313 memfn_quals = TYPE_UNQUALIFIED;
058b15c1
MM
8314 }
8315
8316 if (declarator->kind == cdk_reference)
8d08fdba 8317 {
8af2fec4
RY
8318 /* In C++0x, the type we are creating a reference to might be
8319 a typedef which is itself a reference type. In that case,
8320 we follow the reference collapsing rules in
8321 [7.1.3/8 dcl.typedef] to create the final reference type:
8322
8323 "If a typedef TD names a type that is a reference to a type
8324 T, an attempt to create the type 'lvalue reference to cv TD'
8325 creates the type 'lvalue reference to T,' while an attempt
8326 to create the type "rvalue reference to cv TD' creates the
8327 type TD."
8328 */
dd29188b 8329 if (!VOID_TYPE_P (type))
8af2fec4
RY
8330 type = cp_build_reference_type
8331 ((TREE_CODE (type) == REFERENCE_TYPE
8332 ? TREE_TYPE (type) : type),
8333 (declarator->u.reference.rvalue_ref
8334 && (TREE_CODE(type) != REFERENCE_TYPE
8335 || TYPE_REF_IS_RVALUE (type))));
8336
8337 /* In C++0x, we need this check for direct reference to
8338 reference declarations, which are forbidden by
8339 [8.3.2/5 dcl.ref]. Reference to reference declarations
8340 are only allowed indirectly through typedefs and template
8341 type arguments. Example:
8342
8343 void foo(int & &); // invalid ref-to-ref decl
8344
8345 typedef int & int_ref;
8346 void foo(int_ref &); // valid ref-to-ref decl
8347 */
8348 if (inner_declarator && inner_declarator->kind == cdk_reference)
8349 error ("cannot declare reference to %q#T, which is not "
8350 "a typedef or a template type argument", type);
8d08fdba
MS
8351 }
8352 else if (TREE_CODE (type) == METHOD_TYPE)
d8f8dca1 8353 type = build_ptrmemfunc_type (build_pointer_type (type));
058b15c1 8354 else if (declarator->kind == cdk_ptrmem)
f4ed7d21 8355 {
63c9a190
MM
8356 gcc_assert (TREE_CODE (declarator->u.pointer.class_type)
8357 != NAMESPACE_DECL);
8358 if (declarator->u.pointer.class_type == error_mark_node)
4230cec2
NS
8359 /* We will already have complained. */
8360 type = error_mark_node;
f4ed7d21
NS
8361 else
8362 type = build_ptrmem_type (declarator->u.pointer.class_type,
8363 type);
8364 }
8d08fdba
MS
8365 else
8366 type = build_pointer_type (type);
8367
8368 /* Process a list of type modifier keywords (such as
8369 const or volatile) that were given inside the `*' or `&'. */
8370
058b15c1 8371 if (declarator->u.pointer.qualifiers)
8d08fdba 8372 {
caf93cb0
EC
8373 type
8374 = cp_build_qualified_type (type,
3c01e5df 8375 declarator->u.pointer.qualifiers);
4f2b0fb2 8376 type_quals = cp_type_quals (type);
8d08fdba 8377 }
8d08fdba
MS
8378 ctype = NULL_TREE;
8379 break;
8380
058b15c1
MM
8381 case cdk_error:
8382 break;
8d08fdba 8383
058b15c1 8384 default:
8dc2b103 8385 gcc_unreachable ();
058b15c1
MM
8386 }
8387 }
caf93cb0 8388
058b15c1
MM
8389 if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR
8390 && TREE_CODE (type) != FUNCTION_TYPE
8391 && TREE_CODE (type) != METHOD_TYPE)
8392 {
2d01edd7 8393 error ("template-id %qD used as a declarator",
058b15c1
MM
8394 unqualified_id);
8395 unqualified_id = dname;
8396 }
386b8a85 8397
9c12301f
MM
8398 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
8399 qualified with a class-name, turn it into a METHOD_TYPE, unless
8400 we know that the function is static. We take advantage of this
8401 opportunity to do other processing that pertains to entities
8402 explicitly declared to be class members. Note that if DECLARATOR
8403 is non-NULL, we know it is a cdk_id declarator; otherwise, we
8404 would not have exited the loop above. */
caf93cb0 8405 if (declarator
1d786913
MM
8406 && declarator->u.id.qualifying_scope
8407 && TYPE_P (declarator->u.id.qualifying_scope))
058b15c1
MM
8408 {
8409 tree t;
8d08fdba 8410
1d786913
MM
8411 ctype = declarator->u.id.qualifying_scope;
8412 ctype = TYPE_MAIN_VARIANT (ctype);
058b15c1
MM
8413 t = ctype;
8414 while (t != NULL_TREE && CLASS_TYPE_P (t))
8415 {
8416 /* You're supposed to have one `template <...>' for every
8417 template class, but you don't need one for a full
8418 specialization. For example:
8d08fdba 8419
058b15c1
MM
8420 template <class T> struct S{};
8421 template <> struct S<int> { void f(); };
8422 void S<int>::f () {}
28cbf42c 8423
058b15c1
MM
8424 is correct; there shouldn't be a `template <>' for the
8425 definition of `S<int>::f'. */
f0d60e22
MM
8426 if (CLASSTYPE_TEMPLATE_SPECIALIZATION (t)
8427 && !any_dependent_template_arguments_p (CLASSTYPE_TI_ARGS (t)))
8428 /* T is an explicit (not partial) specialization. All
8429 containing classes must therefore also be explicitly
8430 specialized. */
8431 break;
8432 if ((CLASSTYPE_USE_TEMPLATE (t) || CLASSTYPE_IS_TEMPLATE (t))
058b15c1
MM
8433 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))
8434 template_count += 1;
28cbf42c 8435
058b15c1
MM
8436 t = TYPE_MAIN_DECL (t);
8437 t = DECL_CONTEXT (t);
8438 }
8d08fdba 8439
058b15c1 8440 if (ctype == current_class_type)
59e7c84c
VR
8441 {
8442 if (friendp)
b46ce77f 8443 {
37ec60ed 8444 permerror ("member functions are implicitly friends of their class");
b46ce77f
SM
8445 friendp = 0;
8446 }
59e7c84c 8447 else
37ec60ed
JW
8448 permerror ("extra qualification %<%T::%> on member %qs",
8449 ctype, name);
59e7c84c 8450 }
fa6098f8
MM
8451 else if (/* If the qualifying type is already complete, then we
8452 can skip the following checks. */
8453 !COMPLETE_TYPE_P (ctype)
cc328145
MM
8454 && (/* If the function is being defined, then
8455 qualifying type must certainly be complete. */
3db45ab5 8456 funcdef_flag
cc328145
MM
8457 /* A friend declaration of "T::f" is OK, even if
8458 "T" is a template parameter. But, if this
8459 function is not a friend, the qualifying type
8460 must be a class. */
8461 || (!friendp && !CLASS_TYPE_P (ctype))
8462 /* For a declaration, the type need not be
8463 complete, if either it is dependent (since there
8464 is no meaningful definition of complete in that
8465 case) or the qualifying class is currently being
8466 defined. */
fa6098f8
MM
8467 || !(dependent_type_p (ctype)
8468 || currently_open_class (ctype)))
9f9a713e 8469 /* Check that the qualifying type is complete. */
fa6098f8
MM
8470 && !complete_type_or_else (ctype, NULL_TREE))
8471 return error_mark_node;
058b15c1
MM
8472 else if (TREE_CODE (type) == FUNCTION_TYPE)
8473 {
1d786913 8474 tree sname = declarator->u.id.unqualified_name;
50ad9642 8475
357d956e
MM
8476 if (current_class_type
8477 && (!friendp || funcdef_flag))
8478 {
8479 error (funcdef_flag
8480 ? "cannot define member function %<%T::%s%> within %<%T%>"
8481 : "cannot declare member function %<%T::%s%> within %<%T%>",
8482 ctype, name, current_class_type);
8483 return error_mark_node;
8484 }
8485
058b15c1
MM
8486 if (TREE_CODE (sname) == IDENTIFIER_NODE
8487 && NEW_DELETE_OPNAME_P (sname))
8488 /* Overloaded operator new and operator delete
8489 are always static functions. */
8490 ;
058b15c1 8491 else
e2537f2c 8492 type = build_memfn_type (type, ctype, memfn_quals);
058b15c1 8493 }
62d1db17 8494 else if (declspecs->specs[(int)ds_typedef]
fa6098f8 8495 && current_class_type)
058b15c1 8496 {
fa6098f8
MM
8497 error ("cannot declare member %<%T::%s%> within %qT",
8498 ctype, name, current_class_type);
058b15c1 8499 return error_mark_node;
8d08fdba
MS
8500 }
8501 }
8502
9c12301f
MM
8503 /* Now TYPE has the actual type. */
8504
91d231cb 8505 if (returned_attrs)
1eab9b56 8506 {
91d231cb
JM
8507 if (attrlist)
8508 *attrlist = chainon (returned_attrs, *attrlist);
1eab9b56 8509 else
91d231cb 8510 attrlist = &returned_attrs;
1eab9b56
JM
8511 }
8512
5d80a306
DG
8513 /* Handle parameter packs. */
8514 if (parameter_pack_p)
8515 {
8516 if (decl_context == PARM)
8517 /* Turn the type into a pack expansion.*/
8518 type = make_pack_expansion (type);
8519 else
8520 error ("non-parameter %qs cannot be a parameter pack", name);
8521 }
8522
55b3d665
JM
8523 /* Did array size calculations overflow? */
8524
8525 if (TREE_CODE (type) == ARRAY_TYPE
8526 && COMPLETE_TYPE_P (type)
96ce2ac9
JW
8527 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST
8528 && TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))
55b3d665 8529 {
2d01edd7 8530 error ("size of array %qs is too large", name);
aba649ba 8531 /* If we proceed with the array type as it is, we'll eventually
55b3d665
JM
8532 crash in tree_low_cst(). */
8533 type = error_mark_node;
8534 }
8535
2fff6d71 8536 if ((decl_context == FIELD || decl_context == PARM)
caf93cb0 8537 && !processing_template_decl
5377d5ba 8538 && variably_modified_type_p (type, NULL_TREE))
dac45b5c 8539 {
2fff6d71 8540 if (decl_context == FIELD)
2d01edd7 8541 error ("data member may not have variably modified type %qT", type);
2fff6d71 8542 else
2d01edd7 8543 error ("parameter may not have variably modified type %qT", type);
dac45b5c
MM
8544 type = error_mark_node;
8545 }
8546
34fc957d 8547 if (explicitp == 1 || (explicitp && friendp))
db5ae43f 8548 {
34fc957d 8549 /* [dcl.fct.spec] The explicit specifier shall only be used in
0cbd7506 8550 declarations of constructors within a class definition. */
2d01edd7 8551 error ("only declarations of constructors can be %<explicit%>");
db5ae43f
MS
8552 explicitp = 0;
8553 }
8554
1ff3c076 8555 if (storage_class == sc_mutable)
f30432d7 8556 {
4223f82f 8557 if (decl_context != FIELD || friendp)
0cbd7506 8558 {
2d01edd7 8559 error ("non-member %qs cannot be declared %<mutable%>", name);
1ff3c076 8560 storage_class = sc_none;
0cbd7506 8561 }
62d1db17 8562 else if (decl_context == TYPENAME || declspecs->specs[(int)ds_typedef])
f30432d7 8563 {
2d01edd7 8564 error ("non-object member %qs cannot be declared %<mutable%>", name);
1ff3c076 8565 storage_class = sc_none;
f30432d7 8566 }
34fc957d 8567 else if (TREE_CODE (type) == FUNCTION_TYPE
0cbd7506
MS
8568 || TREE_CODE (type) == METHOD_TYPE)
8569 {
2d01edd7 8570 error ("function %qs cannot be declared %<mutable%>", name);
1ff3c076 8571 storage_class = sc_none;
0cbd7506 8572 }
f30432d7
MS
8573 else if (staticp)
8574 {
2d01edd7 8575 error ("static %qs cannot be declared %<mutable%>", name);
1ff3c076 8576 storage_class = sc_none;
f30432d7 8577 }
34fc957d
NS
8578 else if (type_quals & TYPE_QUAL_CONST)
8579 {
2d01edd7 8580 error ("const %qs cannot be declared %<mutable%>", name);
1ff3c076 8581 storage_class = sc_none;
34fc957d 8582 }
f30432d7
MS
8583 }
8584
419c6212 8585 /* If this is declaring a typedef name, return a TYPE_DECL. */
62d1db17 8586 if (declspecs->specs[(int)ds_typedef] && decl_context != TYPENAME)
8d08fdba
MS
8587 {
8588 tree decl;
8589
8590 /* Note that the grammar rejects storage classes
8591 in typenames, fields or parameters. */
eff71ab0
PB
8592 if (current_lang_name == lang_name_java)
8593 TYPE_FOR_JAVA (type) = 1;
3db45ab5 8594
e2537f2c
MM
8595 /* This declaration:
8596
3db45ab5 8597 typedef void f(int) const;
e2537f2c 8598
3db45ab5 8599 declares a function type which is not a member of any
e2537f2c 8600 particular class, but which is cv-qualified; for
3db45ab5 8601 example "f S::*" declares a pointer to a const-qualified
e2537f2c
MM
8602 member function of S. We record the cv-qualification in the
8603 function type. */
8604 if (memfn_quals && TREE_CODE (type) == FUNCTION_TYPE)
771026dd
DG
8605 {
8606 type = cp_build_qualified_type (type, memfn_quals);
8607
8608 /* We have now dealt with these qualifiers. */
8609 memfn_quals = TYPE_UNQUALIFIED;
8610 }
8d08fdba 8611
d2e5ee5c 8612 if (decl_context == FIELD)
e3016344 8613 decl = build_lang_decl (TYPE_DECL, unqualified_id, type);
d2e5ee5c 8614 else
e3016344
MM
8615 decl = build_decl (TYPE_DECL, unqualified_id, type);
8616 if (id_declarator && declarator->u.id.qualifying_scope)
8617 error ("%Jtypedef name may not be a nested-name-specifier", decl);
8618
8619 if (decl_context != FIELD)
6bda7a5e 8620 {
6bda7a5e
NS
8621 if (!current_function_decl)
8622 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
1dc82a99 8623 else if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (current_function_decl)
c8094d83 8624 || (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P
1dc82a99
MM
8625 (current_function_decl)))
8626 /* The TYPE_DECL is "abstract" because there will be
8627 clones of this constructor/destructor, and there will
8628 be copies of this TYPE_DECL generated in those
8629 clones. */
8630 DECL_ABSTRACT (decl) = 1;
6bda7a5e 8631 }
e3016344 8632 else if (constructor_name_p (unqualified_id, current_class_type))
37ec60ed
JW
8633 permerror ("ISO C++ forbids nested type %qD with same name "
8634 "as enclosing class",
8635 unqualified_id);
caf93cb0 8636
9188c363
MM
8637 /* If the user declares "typedef struct {...} foo" then the
8638 struct will have an anonymous name. Fill that name in now.
8639 Nothing can refer to it, so nothing needs know about the name
8640 change. */
8d08fdba 8641 if (type != error_mark_node
058b15c1 8642 && unqualified_id
8d08fdba
MS
8643 && TYPE_NAME (type)
8644 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1951a1b6 8645 && TYPE_ANONYMOUS_P (type)
89d684bb 8646 && cp_type_quals (type) == TYPE_UNQUALIFIED)
8d08fdba 8647 {
dcd08efc
JM
8648 tree oldname = TYPE_NAME (type);
8649 tree t;
8650
2c73f9f5 8651 /* Replace the anonymous name with the real name everywhere. */
dcd08efc
JM
8652 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
8653 if (TYPE_NAME (t) == oldname)
8654 TYPE_NAME (t) = decl;
8d08fdba
MS
8655
8656 if (TYPE_LANG_SPECIFIC (type))
8657 TYPE_WAS_ANONYMOUS (type) = 1;
8658
33964bf4
MM
8659 /* If this is a typedef within a template class, the nested
8660 type is a (non-primary) template. The name for the
8661 template needs updating as well. */
8662 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
68642fb6 8663 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
33964bf4
MM
8664 = TYPE_IDENTIFIER (type);
8665
50a6dbd7
JM
8666 /* FIXME remangle member functions; member functions of a
8667 type with external linkage have external linkage. */
fc378698 8668 }
fc378698 8669
1ff3c076 8670 if (signed_p
8d08fdba
MS
8671 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
8672 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
8673
3db45ab5 8674 bad_specifiers (decl, "type", virtualp,
e2537f2c 8675 memfn_quals != TYPE_UNQUALIFIED,
c91a56d2
MS
8676 inlinep, friendp, raises != NULL_TREE);
8677
8d08fdba
MS
8678 return decl;
8679 }
8680
8681 /* Detect the case of an array type of unspecified size
8682 which came, as such, direct from a typedef name.
8d6e459d
NS
8683 We must copy the type, so that the array's domain can be
8684 individually set by the object's initializer. */
8d08fdba 8685
8d6e459d
NS
8686 if (type && typedef_type
8687 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
55b3d665 8688 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
8d6e459d 8689 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
8d08fdba 8690
969fd501 8691 /* Detect where we're using a typedef of function type to declare a
4546865e 8692 function. PARMS will not be set, so we must create it now. */
caf93cb0 8693
969fd501
NS
8694 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
8695 {
8696 tree decls = NULL_TREE;
8697 tree args;
8698
8699 for (args = TYPE_ARG_TYPES (type); args; args = TREE_CHAIN (args))
8700 {
8e51619a 8701 tree decl = cp_build_parm_decl (NULL_TREE, TREE_VALUE (args));
969fd501
NS
8702
8703 TREE_CHAIN (decl) = decls;
8704 decls = decl;
8705 }
caf93cb0 8706
4546865e 8707 parms = nreverse (decls);
9804209d
DG
8708
8709 if (decl_context != TYPENAME)
0cbd7506
MS
8710 {
8711 /* A cv-qualifier-seq shall only be part of the function type
8712 for a non-static member function. [8.3.5/4 dcl.fct] */
8713 if (cp_type_quals (type) != TYPE_UNQUALIFIED
8714 && (current_class_type == NULL_TREE || staticp) )
8715 {
ebbc3ce1 8716 error (staticp
f88d05c0
DM
8717 ? G_("qualified function types cannot be used to "
8718 "declare static member functions")
8719 : G_("qualified function types cannot be used to "
8720 "declare free functions"));
0cbd7506
MS
8721 type = TYPE_MAIN_VARIANT (type);
8722 }
8723
8724 /* The qualifiers on the function type become the qualifiers on
8725 the non-static member function. */
e2537f2c 8726 memfn_quals |= cp_type_quals (type);
0cbd7506 8727 }
969fd501
NS
8728 }
8729
8d08fdba
MS
8730 /* If this is a type name (such as, in a cast or sizeof),
8731 compute the type and return it now. */
8732
8733 if (decl_context == TYPENAME)
8734 {
8735 /* Note that the grammar rejects storage classes
8736 in typenames, fields or parameters. */
91063b51 8737 if (type_quals != TYPE_UNQUALIFIED)
6eabb241 8738 type_quals = TYPE_UNQUALIFIED;
8d08fdba
MS
8739
8740 /* Special case: "friend class foo" looks like a TYPENAME context. */
8741 if (friendp)
8742 {
91063b51 8743 if (type_quals != TYPE_UNQUALIFIED)
b7484fbe 8744 {
33bd39a2 8745 error ("type qualifiers specified for friend class declaration");
91063b51 8746 type_quals = TYPE_UNQUALIFIED;
b7484fbe
MS
8747 }
8748 if (inlinep)
8749 {
2d01edd7 8750 error ("%<inline%> specified for friend class declaration");
b7484fbe
MS
8751 inlinep = 0;
8752 }
f2ae0c45 8753
218e0eb6 8754 if (!current_aggr)
4b054b80 8755 {
218e0eb6 8756 /* Don't allow friend declaration without a class-key. */
4b054b80 8757 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
37ec60ed 8758 permerror ("template parameters cannot be friends");
f2ae0c45 8759 else if (TREE_CODE (type) == TYPENAME_TYPE)
37ec60ed
JW
8760 permerror ("friend declaration requires class-key, "
8761 "i.e. %<friend class %T::%D%>",
8762 TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
4b054b80 8763 else
37ec60ed
JW
8764 permerror ("friend declaration requires class-key, "
8765 "i.e. %<friend %#T%>",
8766 type);
4b054b80 8767 }
b7484fbe
MS
8768
8769 /* Only try to do this stuff if we didn't already give up. */
8770 if (type != integer_type_node)
8771 {
8772 /* A friendly class? */
8773 if (current_class_type)
19db77ce
KL
8774 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
8775 /*complain=*/true);
b7484fbe 8776 else
2d01edd7 8777 error ("trying to make class %qT a friend of global scope",
0cbd7506 8778 type);
d363e7bf 8779
b7484fbe
MS
8780 type = void_type_node;
8781 }
8d08fdba 8782 }
e2537f2c 8783 else if (memfn_quals)
8d08fdba 8784 {
8d08fdba
MS
8785 if (ctype == NULL_TREE)
8786 {
41cbc04c 8787 if (TREE_CODE (type) != METHOD_TYPE)
0cbd7506 8788 error ("invalid qualifiers on non-member function type");
41cbc04c 8789 else
0cbd7506 8790 ctype = TYPE_METHOD_BASETYPE (type);
41cbc04c
NS
8791 }
8792 if (ctype)
e2537f2c 8793 type = build_memfn_type (type, ctype, memfn_quals);
8d08fdba
MS
8794 }
8795
8796 return type;
8797 }
058b15c1 8798 else if (unqualified_id == NULL_TREE && decl_context != PARM
db5ae43f 8799 && decl_context != CATCHPARM
8d08fdba
MS
8800 && TREE_CODE (type) != UNION_TYPE
8801 && ! bitfield)
8802 {
2d01edd7 8803 error ("abstract declarator %qT used as declaration", type);
22ab714d 8804 return error_mark_node;
8d08fdba
MS
8805 }
8806
62e19030
MM
8807 /* Only functions may be declared using an operator-function-id. */
8808 if (unqualified_id
8809 && IDENTIFIER_OPNAME_P (unqualified_id)
8810 && TREE_CODE (type) != FUNCTION_TYPE
8811 && TREE_CODE (type) != METHOD_TYPE)
8d08fdba 8812 {
62e19030
MM
8813 error ("declaration of %qD as non-function", unqualified_id);
8814 return error_mark_node;
8d08fdba
MS
8815 }
8816
62e19030
MM
8817 /* We don't check parameter types here because we can emit a better
8818 error message later. */
8819 if (decl_context != PARM)
650fcd07
LM
8820 {
8821 type = check_var_type (unqualified_id, type);
8822 if (type == error_mark_node)
8823 return error_mark_node;
8824 }
62e19030 8825
8d08fdba
MS
8826 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
8827 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
8828
14ae7e7d
JM
8829 if (decl_context == PARM || decl_context == CATCHPARM)
8830 {
8831 if (ctype || in_namespace)
2d01edd7 8832 error ("cannot use %<::%> in parameter declaration");
14ae7e7d
JM
8833
8834 /* A parameter declared as an array of T is really a pointer to T.
8835 One declared as a function is really a pointer to a function.
8836 One declared as a member is really a pointer to member. */
8837
8838 if (TREE_CODE (type) == ARRAY_TYPE)
8839 {
8840 /* Transfer const-ness of array into that of type pointed to. */
8841 type = build_pointer_type (TREE_TYPE (type));
91063b51 8842 type_quals = TYPE_UNQUALIFIED;
14ae7e7d
JM
8843 }
8844 else if (TREE_CODE (type) == FUNCTION_TYPE)
8845 type = build_pointer_type (type);
14ae7e7d 8846 }
68642fb6 8847
8d08fdba 8848 {
926ce8bd 8849 tree decl;
8d08fdba
MS
8850
8851 if (decl_context == PARM)
8852 {
058b15c1 8853 decl = cp_build_parm_decl (unqualified_id, type);
8d08fdba 8854
3db45ab5 8855 bad_specifiers (decl, "parameter", virtualp,
e2537f2c 8856 memfn_quals != TYPE_UNQUALIFIED,
8d08fdba 8857 inlinep, friendp, raises != NULL_TREE);
8d08fdba
MS
8858 }
8859 else if (decl_context == FIELD)
8860 {
01bf0f3e
JM
8861 /* The C99 flexible array extension. */
8862 if (!staticp && TREE_CODE (type) == ARRAY_TYPE
8863 && TYPE_DOMAIN (type) == NULL_TREE)
8864 {
8865 tree itype = compute_array_index_type (dname, integer_zero_node);
8866 type = build_cplus_array_type (TREE_TYPE (type), itype);
8867 }
8868
8d08fdba
MS
8869 if (type == error_mark_node)
8870 {
8871 /* Happens when declaring arrays of sizes which
8872 are error_mark_node, for example. */
8873 decl = NULL_TREE;
8874 }
997a088c 8875 else if (in_namespace && !friendp)
05008fb9
MM
8876 {
8877 /* Something like struct S { int N::j; }; */
2d01edd7 8878 error ("invalid use of %<::%>");
9a171ca4 8879 return error_mark_node;
05008fb9 8880 }
8d08fdba
MS
8881 else if (TREE_CODE (type) == FUNCTION_TYPE)
8882 {
8883 int publicp = 0;
e1467ff2 8884 tree function_context;
8d08fdba
MS
8885
8886 if (friendp == 0)
8887 {
8888 if (ctype == NULL_TREE)
8889 ctype = current_class_type;
8890
8891 if (ctype == NULL_TREE)
8892 {
2d01edd7 8893 error ("can't make %qD into a method -- not in a class",
058b15c1 8894 unqualified_id);
13dbe691 8895 return error_mark_node;
8d08fdba
MS
8896 }
8897
8898 /* ``A union may [ ... ] not [ have ] virtual functions.''
8899 ARM 9.5 */
8900 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
8901 {
2d01edd7 8902 error ("function %qD declared virtual inside a union",
058b15c1 8903 unqualified_id);
13dbe691 8904 return error_mark_node;
8d08fdba
MS
8905 }
8906
058b15c1 8907 if (NEW_DELETE_OPNAME_P (unqualified_id))
8d08fdba
MS
8908 {
8909 if (virtualp)
8910 {
2d01edd7 8911 error ("%qD cannot be declared virtual, since it "
0cbd7506 8912 "is always static",
058b15c1 8913 unqualified_id);
8d08fdba
MS
8914 virtualp = 0;
8915 }
8916 }
8917 else if (staticp < 2)
e2537f2c 8918 type = build_memfn_type (type, ctype, memfn_quals);
8d08fdba
MS
8919 }
8920
88e95ee3 8921 /* Check that the name used for a destructor makes sense. */
6d2989e1 8922 if (sfk == sfk_destructor)
88e95ee3 8923 {
6d2989e1
VR
8924 if (!ctype)
8925 {
8926 gcc_assert (friendp);
8927 error ("expected qualified name in friend declaration "
8928 "for destructor %qD",
8929 id_declarator->u.id.unqualified_name);
8930 return error_mark_node;
8931 }
8932
8933 if (!same_type_p (TREE_OPERAND
8934 (id_declarator->u.id.unqualified_name, 0),
8935 ctype))
8936 {
8937 error ("declaration of %qD as member of %qT",
8938 id_declarator->u.id.unqualified_name, ctype);
8939 return error_mark_node;
8940 }
88e95ee3 8941 }
ac3b1156
JJ
8942 else if (sfk == sfk_constructor && friendp)
8943 {
8944 error ("expected qualified name in friend declaration "
8945 "for constructor %qD",
8946 id_declarator->u.id.unqualified_name);
8947 return error_mark_node;
8948 }
88e95ee3 8949
8d08fdba 8950 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
68642fb6 8951 function_context = (ctype != NULL_TREE) ?
4f1c5b7d 8952 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
e1467ff2
MM
8953 publicp = (! friendp || ! staticp)
8954 && function_context == NULL_TREE;
68642fb6 8955 decl = grokfndecl (ctype, type,
058b15c1
MM
8956 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
8957 ? unqualified_id : dname,
4546865e 8958 parms,
058b15c1 8959 unqualified_id,
e2537f2c 8960 virtualp, flags, memfn_quals, raises,
386b8a85 8961 friendp ? -1 : 0, friendp, publicp, inlinep,
27d6592c 8962 sfk,
037cc9c5 8963 funcdef_flag, template_count, in_namespace, attrlist);
20496fa2 8964 if (decl == NULL_TREE)
ba5719d9 8965 return error_mark_node;
6125f3be
DE
8966#if 0
8967 /* This clobbers the attrs stored in `decl' from `attrlist'. */
91d231cb
JM
8968 /* The decl and setting of decl_attr is also turned off. */
8969 decl = build_decl_attribute_variant (decl, decl_attr);
6125f3be 8970#endif
f0e01782 8971
cc804e51
MM
8972 /* [class.conv.ctor]
8973
8974 A constructor declared without the function-specifier
8975 explicit that can be called with a single parameter
8976 specifies a conversion from the type of its first
8977 parameter to the type of its class. Such a constructor
8978 is called a converting constructor. */
db5ae43f
MS
8979 if (explicitp == 2)
8980 DECL_NONCONVERTING_P (decl) = 1;
cc804e51
MM
8981 else if (DECL_CONSTRUCTOR_P (decl))
8982 {
09357846 8983 /* A constructor with no parms is not a conversion.
e0fff4b3
JM
8984 Ignore any compiler-added parms. */
8985 tree arg_types = FUNCTION_FIRST_USER_PARMTYPE (decl);
cc804e51 8986
09357846 8987 if (arg_types == void_list_node)
cc804e51
MM
8988 DECL_NONCONVERTING_P (decl) = 1;
8989 }
8d08fdba
MS
8990 }
8991 else if (TREE_CODE (type) == METHOD_TYPE)
8992 {
faae18ab
MS
8993 /* We only get here for friend declarations of
8994 members of other classes. */
8d08fdba
MS
8995 /* All method decls are public, so tell grokfndecl to set
8996 TREE_PUBLIC, also. */
866eb556 8997 decl = grokfndecl (ctype, type,
058b15c1
MM
8998 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
8999 ? unqualified_id : dname,
4546865e 9000 parms,
058b15c1 9001 unqualified_id,
e2537f2c 9002 virtualp, flags, memfn_quals, raises,
27d6592c 9003 friendp ? -1 : 0, friendp, 1, 0, sfk,
c8094d83
MS
9004 funcdef_flag, template_count, in_namespace,
9005 attrlist);
f0e01782 9006 if (decl == NULL_TREE)
13dbe691 9007 return error_mark_node;
8d08fdba 9008 }
a9f46cbb 9009 else if (!staticp && !dependent_type_p (type)
d0f062fb 9010 && !COMPLETE_TYPE_P (complete_type (type))
8d08fdba
MS
9011 && (TREE_CODE (type) != ARRAY_TYPE || initialized == 0))
9012 {
058b15c1 9013 if (unqualified_id)
2d01edd7 9014 error ("field %qD has incomplete type", unqualified_id);
b7484fbe 9015 else
2d01edd7 9016 error ("name %qT has incomplete type", type);
8d08fdba
MS
9017
9018 /* If we're instantiating a template, tell them which
9019 instantiation made the field's type be incomplete. */
9020 if (current_class_type
9021 && TYPE_NAME (current_class_type)
d2e5ee5c 9022 && IDENTIFIER_TEMPLATE (TYPE_IDENTIFIER (current_class_type))
62d1db17
MM
9023 && declspecs->type
9024 && declspecs->type == type)
2d01edd7 9025 error (" in instantiation of template %qT",
0cbd7506 9026 current_class_type);
db5ae43f 9027
623c65f1 9028 return error_mark_node;
8d08fdba
MS
9029 }
9030 else
9031 {
9032 if (friendp)
9033 {
2d01edd7 9034 error ("%qE is neither function nor member function; "
0cbd7506 9035 "cannot be declared friend", unqualified_id);
8d08fdba
MS
9036 friendp = 0;
9037 }
9038 decl = NULL_TREE;
9039 }
9040
9041 if (friendp)
9042 {
9043 /* Friends are treated specially. */
9044 if (ctype == current_class_type)
37ec60ed 9045 ; /* We already issued a permerror. */
0cbd7506 9046 else if (decl && DECL_NAME (decl))
8db1028e
NS
9047 {
9048 if (template_class_depth (current_class_type) == 0)
9049 {
9050 decl = check_explicit_specialization
058b15c1 9051 (unqualified_id, decl, template_count,
357d956e 9052 2 * funcdef_flag + 4);
8db1028e
NS
9053 if (decl == error_mark_node)
9054 return error_mark_node;
9055 }
caf93cb0 9056
058b15c1 9057 decl = do_friend (ctype, unqualified_id, decl,
3db45ab5 9058 *attrlist, flags,
e2537f2c 9059 funcdef_flag);
8db1028e
NS
9060 return decl;
9061 }
9062 else
13dbe691 9063 return error_mark_node;
8d08fdba
MS
9064 }
9065
f4f206f4 9066 /* Structure field. It may not be a function, except for C++. */
8d08fdba
MS
9067
9068 if (decl == NULL_TREE)
9069 {
8d08fdba
MS
9070 if (initialized)
9071 {
3ac3d9ea
MM
9072 if (!staticp)
9073 {
9074 /* An attempt is being made to initialize a non-static
9075 member. But, from [class.mem]:
68642fb6 9076
3ac3d9ea
MM
9077 4 A member-declarator can contain a
9078 constant-initializer only if it declares a static
9079 member (_class.static_) of integral or enumeration
68642fb6 9080 type, see _class.static.data_.
3ac3d9ea
MM
9081
9082 This used to be relatively common practice, but
9083 the rest of the compiler does not correctly
9084 handle the initialization unless the member is
9085 static so we make it static below. */
37ec60ed
JW
9086 permerror ("ISO C++ forbids initialization of member %qD",
9087 unqualified_id);
9088 permerror ("making %qD static", unqualified_id);
3ac3d9ea
MM
9089 staticp = 1;
9090 }
9091
6ba89f8e
MM
9092 if (uses_template_parms (type))
9093 /* We'll check at instantiation time. */
9094 ;
058b15c1 9095 else if (check_static_variable_definition (unqualified_id,
6ba89f8e
MM
9096 type))
9097 /* If we just return the declaration, crashes
9098 will sometimes occur. We therefore return
72a93143
JM
9099 void_type_node, as if this was a friend
9100 declaration, to cause callers to completely
9101 ignore this declaration. */
13dbe691 9102 return error_mark_node;
8d08fdba
MS
9103 }
9104
3ac3d9ea 9105 if (staticp)
8d08fdba 9106 {
f18a14bc
MM
9107 /* C++ allows static class members. All other work
9108 for this is done by grokfield. */
058b15c1 9109 decl = build_lang_decl (VAR_DECL, unqualified_id, type);
4684cd27
MM
9110 set_linkage_for_static_data_member (decl);
9111 /* Even if there is an in-class initialization, DECL
9112 is considered undefined until an out-of-class
9113 definition is provided. */
9114 DECL_EXTERNAL (decl) = 1;
31a79236
JJ
9115
9116 if (thread_p)
8893239d 9117 DECL_TLS_MODEL (decl) = decl_default_tls_model (decl);
8d08fdba
MS
9118 }
9119 else
9120 {
058b15c1 9121 decl = build_decl (FIELD_DECL, unqualified_id, type);
2bf105ab 9122 DECL_NONADDRESSABLE_P (decl) = bitfield;
ab53bae2
AO
9123 if (bitfield && !unqualified_id)
9124 TREE_NO_WARNING (decl) = 1;
9125
1ff3c076 9126 if (storage_class == sc_mutable)
8d08fdba
MS
9127 {
9128 DECL_MUTABLE_P (decl) = 1;
1ff3c076 9129 storage_class = sc_none;
8d08fdba
MS
9130 }
9131 }
9132
3db45ab5 9133 bad_specifiers (decl, "field", virtualp,
e2537f2c 9134 memfn_quals != TYPE_UNQUALIFIED,
8d08fdba
MS
9135 inlinep, friendp, raises != NULL_TREE);
9136 }
9137 }
fd9aef9d
NS
9138 else if (TREE_CODE (type) == FUNCTION_TYPE
9139 || TREE_CODE (type) == METHOD_TYPE)
8d08fdba 9140 {
386b8a85 9141 tree original_name;
8d08fdba
MS
9142 int publicp = 0;
9143
058b15c1 9144 if (!unqualified_id)
13dbe691 9145 return error_mark_node;
8d08fdba 9146
058b15c1 9147 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
386b8a85
JM
9148 original_name = dname;
9149 else
058b15c1 9150 original_name = unqualified_id;
386b8a85 9151
1ff3c076 9152 if (storage_class == sc_auto)
2d01edd7 9153 error ("storage class %<auto%> invalid for function %qs", name);
1ff3c076 9154 else if (storage_class == sc_register)
2d01edd7 9155 error ("storage class %<register%> invalid for function %qs", name);
1ff3c076 9156 else if (thread_p)
2d01edd7 9157 error ("storage class %<__thread%> invalid for function %qs", name);
8d08fdba
MS
9158
9159 /* Function declaration not at top level.
9160 Storage classes other than `extern' are not allowed
9161 and `extern' makes no difference. */
a9aedbc2 9162 if (! toplevel_bindings_p ()
1ff3c076 9163 && (storage_class == sc_static
62d1db17 9164 || declspecs->specs[(int)ds_inline])
8d08fdba 9165 && pedantic)
8926095f 9166 {
1ff3c076 9167 if (storage_class == sc_static)
fcf73884
MLI
9168 pedwarn (OPT_pedantic,
9169 "%<static%> specified invalid for function %qs "
0cbd7506 9170 "declared out of global scope", name);
8926095f 9171 else
fcf73884
MLI
9172 pedwarn (OPT_pedantic,
9173 "%<inline%> specifier invalid for function %qs "
0cbd7506 9174 "declared out of global scope", name);
8926095f 9175 }
68642fb6 9176
8d08fdba
MS
9177 if (ctype == NULL_TREE)
9178 {
9179 if (virtualp)
9180 {
2d01edd7 9181 error ("virtual non-class function %qs", name);
8d08fdba
MS
9182 virtualp = 0;
9183 }
8d08fdba 9184 }
4546865e
MM
9185 else if (TREE_CODE (type) == FUNCTION_TYPE && staticp < 2
9186 && !NEW_DELETE_OPNAME_P (original_name))
caf93cb0 9187 type = build_method_type_directly (ctype,
43dc123f
MM
9188 TREE_TYPE (type),
9189 TYPE_ARG_TYPES (type));
8d08fdba 9190
eb66be0e 9191 /* Record presence of `static'. */
faae18ab 9192 publicp = (ctype != NULL_TREE
1ff3c076
MM
9193 || storage_class == sc_extern
9194 || storage_class != sc_static);
8d08fdba 9195
058b15c1 9196 decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
e2537f2c 9197 virtualp, flags, memfn_quals, raises,
75650646 9198 1, friendp,
27d6592c 9199 publicp, inlinep, sfk, funcdef_flag,
037cc9c5 9200 template_count, in_namespace, attrlist);
f0e01782 9201 if (decl == NULL_TREE)
13dbe691 9202 return error_mark_node;
8d08fdba 9203
8d08fdba
MS
9204 if (staticp == 1)
9205 {
0e339752 9206 int invalid_static = 0;
8d08fdba
MS
9207
9208 /* Don't allow a static member function in a class, and forbid
9209 declaring main to be static. */
9210 if (TREE_CODE (type) == METHOD_TYPE)
9211 {
37ec60ed
JW
9212 permerror ("cannot declare member function %qD to have "
9213 "static linkage", decl);
0e339752 9214 invalid_static = 1;
8d08fdba 9215 }
8d08fdba
MS
9216 else if (current_function_decl)
9217 {
9218 /* FIXME need arm citation */
8251199e 9219 error ("cannot declare static function inside another function");
0e339752 9220 invalid_static = 1;
8d08fdba
MS
9221 }
9222
0e339752 9223 if (invalid_static)
8d08fdba
MS
9224 {
9225 staticp = 0;
1ff3c076 9226 storage_class = sc_none;
8d08fdba
MS
9227 }
9228 }
8d08fdba
MS
9229 }
9230 else
9231 {
9232 /* It's a variable. */
9233
9234 /* An uninitialized decl with `extern' is a reference. */
caf93cb0 9235 decl = grokvardecl (type, unqualified_id,
62d1db17 9236 declspecs,
68642fb6
UD
9237 initialized,
9238 (type_quals & TYPE_QUAL_CONST) != 0,
9e259dd1 9239 ctype ? ctype : in_namespace);
3db45ab5 9240 bad_specifiers (decl, "variable", virtualp,
e2537f2c 9241 memfn_quals != TYPE_UNQUALIFIED,
8d08fdba
MS
9242 inlinep, friendp, raises != NULL_TREE);
9243
9244 if (ctype)
9245 {
f0e01782 9246 DECL_CONTEXT (decl) = ctype;
8d08fdba
MS
9247 if (staticp == 1)
9248 {
37ec60ed
JW
9249 permerror ("%<static%> may not be used when defining "
9250 "(as opposed to declaring) a static data member");
0cbd7506 9251 staticp = 0;
1ff3c076 9252 storage_class = sc_none;
8d08fdba 9253 }
1ff3c076 9254 if (storage_class == sc_register && TREE_STATIC (decl))
b7484fbe 9255 {
2d01edd7 9256 error ("static member %qD declared %<register%>", decl);
1ff3c076 9257 storage_class = sc_none;
b7484fbe 9258 }
1ff3c076 9259 if (storage_class == sc_extern && pedantic)
8d08fdba 9260 {
fcf73884
MLI
9261 pedwarn (OPT_pedantic,
9262 "cannot explicitly declare member %q#D to have "
9263 "extern linkage", decl);
1ff3c076 9264 storage_class = sc_none;
8d08fdba
MS
9265 }
9266 }
9267 }
9268
94eeabbe
DS
9269 if (storage_class == sc_extern && initialized && !funcdef_flag)
9270 {
9271 if (toplevel_bindings_p ())
9272 {
9273 /* It's common practice (and completely valid) to have a const
9274 be initialized and declared extern. */
9275 if (!(type_quals & TYPE_QUAL_CONST))
9276 warning (0, "%qs initialized and declared %<extern%>", name);
9277 }
9278 else
9279 error ("%qs has both %<extern%> and initializer", name);
9280 }
9281
8d08fdba
MS
9282 /* Record `register' declaration for warnings on &
9283 and in case doing stupid register allocation. */
9284
1ff3c076 9285 if (storage_class == sc_register)
8d08fdba 9286 DECL_REGISTER (decl) = 1;
1ff3c076 9287 else if (storage_class == sc_extern)
8926095f 9288 DECL_THIS_EXTERN (decl) = 1;
1ff3c076 9289 else if (storage_class == sc_static)
faae18ab
MS
9290 DECL_THIS_STATIC (decl) = 1;
9291
15896502
MM
9292 /* Record constancy and volatility on the DECL itself . There's
9293 no need to do this when processing a template; we'll do this
9294 for the instantiated declaration based on the type of DECL. */
adecb3f4 9295 if (!processing_template_decl)
9804209d 9296 cp_apply_type_quals_to_decl (type_quals, decl);
8d08fdba 9297
1891dec4
DM
9298 if (set_no_warning)
9299 TREE_NO_WARNING (decl) = 1;
9300
8d08fdba
MS
9301 return decl;
9302 }
9303}
9304\f
f181d4ae
MM
9305/* Subroutine of start_function. Ensure that each of the parameter
9306 types (as listed in PARMS) is complete, as is required for a
9307 function definition. */
e92cc029 9308
8d08fdba 9309static void
11f6b451 9310require_complete_types_for_parms (tree parms)
8d08fdba 9311{
07c88314 9312 for (; parms; parms = TREE_CHAIN (parms))
8d08fdba 9313 {
c9387915
GB
9314 if (dependent_type_p (TREE_TYPE (parms)))
9315 continue;
dff1b563
VR
9316 if (!VOID_TYPE_P (TREE_TYPE (parms))
9317 && complete_type_or_else (TREE_TYPE (parms), parms))
753225c1 9318 {
7523dc31 9319 relayout_decl (parms);
753225c1
JM
9320 DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
9321 }
dff1b563
VR
9322 else
9323 /* grokparms or complete_type_or_else will have already issued
9324 an error. */
9325 TREE_TYPE (parms) = error_mark_node;
8d08fdba
MS
9326 }
9327}
9328
838dfd8a 9329/* Returns nonzero if T is a local variable. */
297e73d8 9330
46e8c075 9331int
ac7d7749 9332local_variable_p (const_tree t)
297e73d8 9333{
68642fb6 9334 if ((TREE_CODE (t) == VAR_DECL
297e73d8
MM
9335 /* A VAR_DECL with a context that is a _TYPE is a static data
9336 member. */
9337 && !TYPE_P (CP_DECL_CONTEXT (t))
9338 /* Any other non-local variable must be at namespace scope. */
46e8c075 9339 && !DECL_NAMESPACE_SCOPE_P (t))
297e73d8 9340 || (TREE_CODE (t) == PARM_DECL))
46e8c075 9341 return 1;
297e73d8 9342
46e8c075
MM
9343 return 0;
9344}
9345
46e8c075
MM
9346/* Like local_variable_p, but suitable for use as a tree-walking
9347 function. */
9348
9349static tree
44de5aeb
RK
9350local_variable_p_walkfn (tree *tp, int *walk_subtrees,
9351 void *data ATTRIBUTE_UNUSED)
46e8c075 9352{
44de5aeb
RK
9353 if (local_variable_p (*tp) && !DECL_ARTIFICIAL (*tp))
9354 return *tp;
9355 else if (TYPE_P (*tp))
9356 *walk_subtrees = 0;
9357
9358 return NULL_TREE;
297e73d8
MM
9359}
9360
44de5aeb 9361
297e73d8 9362/* Check that ARG, which is a default-argument expression for a
0e339752 9363 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
297e73d8
MM
9364 something goes wrong. DECL may also be a _TYPE node, rather than a
9365 DECL, if there is no DECL available. */
9366
9367tree
11f6b451 9368check_default_argument (tree decl, tree arg)
297e73d8
MM
9369{
9370 tree var;
9371 tree decl_type;
9372
9373 if (TREE_CODE (arg) == DEFAULT_ARG)
9374 /* We get a DEFAULT_ARG when looking at an in-class declaration
9375 with a default argument. Ignore the argument for now; we'll
9376 deal with it after the class is complete. */
9377 return arg;
9378
297e73d8
MM
9379 if (TYPE_P (decl))
9380 {
9381 decl_type = decl;
9382 decl = NULL_TREE;
9383 }
9384 else
9385 decl_type = TREE_TYPE (decl);
9386
68642fb6 9387 if (arg == error_mark_node
297e73d8
MM
9388 || decl == error_mark_node
9389 || TREE_TYPE (arg) == error_mark_node
9390 || decl_type == error_mark_node)
9391 /* Something already went wrong. There's no need to check
9392 further. */
9393 return error_mark_node;
9394
9395 /* [dcl.fct.default]
68642fb6 9396
297e73d8
MM
9397 A default argument expression is implicitly converted to the
9398 parameter type. */
9399 if (!TREE_TYPE (arg)
30f86ec3 9400 || !can_convert_arg (decl_type, TREE_TYPE (arg), arg, LOOKUP_NORMAL))
297e73d8
MM
9401 {
9402 if (decl)
2d01edd7 9403 error ("default argument for %q#D has type %qT",
0cbd7506 9404 decl, TREE_TYPE (arg));
297e73d8 9405 else
2d01edd7 9406 error ("default argument for parameter of type %qT has type %qT",
0cbd7506 9407 decl_type, TREE_TYPE (arg));
297e73d8
MM
9408
9409 return error_mark_node;
9410 }
9411
9412 /* [dcl.fct.default]
9413
9414 Local variables shall not be used in default argument
68642fb6 9415 expressions.
297e73d8
MM
9416
9417 The keyword `this' shall not be used in a default argument of a
9418 member function. */
14588106 9419 var = cp_walk_tree_without_duplicates (&arg, local_variable_p_walkfn, NULL);
297e73d8
MM
9420 if (var)
9421 {
2d01edd7 9422 error ("default argument %qE uses local variable %qD", arg, var);
297e73d8
MM
9423 return error_mark_node;
9424 }
9425
9426 /* All is well. */
9427 return arg;
9428}
9429
8d08fdba
MS
9430/* Decode the list of parameter types for a function type.
9431 Given the list of things declared inside the parens,
9432 return a list of types.
9433
058b15c1
MM
9434 If this parameter does not end with an ellipsis, we append
9435 void_list_node.
5cce22b6 9436
4546865e 9437 *PARMS is set to the chain of PARM_DECLs created. */
8d08fdba
MS
9438
9439static tree
62d1db17 9440grokparms (cp_parameter_declarator *first_parm, tree *parms)
8d08fdba
MS
9441{
9442 tree result = NULL_TREE;
9443 tree decls = NULL_TREE;
058b15c1 9444 int ellipsis = !first_parm || first_parm->ellipsis_p;
62d1db17 9445 cp_parameter_declarator *parm;
5cce22b6 9446 int any_error = 0;
0d83bf5a 9447 struct pointer_set_t *unique_decls = pointer_set_create ();
8d08fdba 9448
058b15c1 9449 for (parm = first_parm; parm != NULL; parm = parm->next)
8d08fdba 9450 {
0657c69c 9451 tree type = NULL_TREE;
058b15c1 9452 tree init = parm->default_argument;
62d1db17 9453 tree attrs;
058b15c1 9454 tree decl;
8d08fdba 9455
058b15c1 9456 if (parm == no_parameters)
0cbd7506 9457 break;
8d08fdba 9458
62d1db17
MM
9459 attrs = parm->decl_specifiers.attributes;
9460 parm->decl_specifiers.attributes = NULL_TREE;
9461 decl = grokdeclarator (parm->declarator, &parm->decl_specifiers,
98884b26 9462 PARM, init != NULL_TREE, &attrs);
5cce22b6 9463 if (! decl || TREE_TYPE (decl) == error_mark_node)
0cbd7506 9464 continue;
d363e7bf 9465
98884b26
JM
9466 if (attrs)
9467 cplus_decl_attributes (&decl, attrs, 0);
9468
5cce22b6
NS
9469 type = TREE_TYPE (decl);
9470 if (VOID_TYPE_P (type))
0cbd7506
MS
9471 {
9472 if (same_type_p (type, void_type_node)
e7e53192 9473 && DECL_SELF_REFERENCE_P (type)
0cbd7506
MS
9474 && !DECL_NAME (decl) && !result && !parm->next && !ellipsis)
9475 /* this is a parmlist of `(void)', which is ok. */
9476 break;
9477 cxx_incomplete_type_error (decl, type);
0657c69c
MM
9478 /* It's not a good idea to actually create parameters of
9479 type `void'; other parts of the compiler assume that a
9480 void type terminates the parameter list. */
04f3dc2b 9481 type = error_mark_node;
0657c69c 9482 TREE_TYPE (decl) = error_mark_node;
0cbd7506 9483 }
8d08fdba 9484
360f866c
JJ
9485 if (type != error_mark_node
9486 && TYPE_FOR_JAVA (type)
9e1e64ec 9487 && MAYBE_CLASS_TYPE_P (type))
360f866c
JJ
9488 {
9489 error ("parameter %qD has Java class type", decl);
9490 type = error_mark_node;
9491 TREE_TYPE (decl) = error_mark_node;
9492 init = NULL_TREE;
9493 }
9494
d363e7bf 9495 if (type != error_mark_node)
04f3dc2b
MM
9496 {
9497 /* Top-level qualifiers on the parameters are
9498 ignored for function types. */
79a1a736 9499 type = cp_build_qualified_type (type, 0);
04f3dc2b
MM
9500 if (TREE_CODE (type) == METHOD_TYPE)
9501 {
2d01edd7 9502 error ("parameter %qD invalidly declared method type", decl);
04f3dc2b
MM
9503 type = build_pointer_type (type);
9504 TREE_TYPE (decl) = type;
9505 }
04f3dc2b 9506 else if (abstract_virtuals_error (decl, type))
a1c65f9f 9507 any_error = 1; /* Seems like a good idea. */
04f3dc2b
MM
9508 else if (POINTER_TYPE_P (type))
9509 {
9510 /* [dcl.fct]/6, parameter types cannot contain pointers
9511 (references) to arrays of unknown bound. */
98979fe0
NS
9512 tree t = TREE_TYPE (type);
9513 int ptr = TYPE_PTR_P (type);
9514
0cbd7506
MS
9515 while (1)
9516 {
9517 if (TYPE_PTR_P (t))
9518 ptr = 1;
9519 else if (TREE_CODE (t) != ARRAY_TYPE)
9520 break;
9521 else if (!TYPE_DOMAIN (t))
9522 break;
9523 t = TREE_TYPE (t);
9524 }
04f3dc2b 9525 if (TREE_CODE (t) == ARRAY_TYPE)
2d01edd7 9526 error ("parameter %qD includes %s to array of unknown "
0cbd7506
MS
9527 "bound %qT",
9528 decl, ptr ? "pointer" : "reference", t);
04f3dc2b
MM
9529 }
9530
c3ee4651 9531 if (any_error)
04f3dc2b 9532 init = NULL_TREE;
c3ee4651
NS
9533 else if (init && !processing_template_decl)
9534 init = check_default_argument (decl, init);
04f3dc2b 9535 }
8d08fdba 9536
5d80a306
DG
9537 if (TREE_CODE (decl) == PARM_DECL
9538 && FUNCTION_PARAMETER_PACK_P (decl)
9539 && parm->next)
9540 error ("parameter packs must be at the end of the parameter list");
9541
0d83bf5a
SB
9542 if (DECL_NAME (decl))
9543 {
9544 if (pointer_set_contains (unique_decls, DECL_NAME (decl)))
631ee856 9545 error ("multiple parameters named %qE", DECL_NAME (decl));
0d83bf5a
SB
9546 else
9547 pointer_set_insert (unique_decls, DECL_NAME (decl));
9548 }
9549
5cce22b6
NS
9550 TREE_CHAIN (decl) = decls;
9551 decls = decl;
0657c69c 9552 result = tree_cons (init, type, result);
8d08fdba 9553 }
5cce22b6
NS
9554 decls = nreverse (decls);
9555 result = nreverse (result);
9556 if (!ellipsis)
9557 result = chainon (result, void_list_node);
4546865e 9558 *parms = decls;
8d08fdba 9559
0d83bf5a 9560 pointer_set_destroy (unique_decls);
8d08fdba
MS
9561 return result;
9562}
42976354 9563
8d08fdba 9564\f
271e6f02
NS
9565/* D is a constructor or overloaded `operator='.
9566
9567 Let T be the class in which D is declared. Then, this function
9568 returns:
9569
9570 -1 if D's is an ill-formed constructor or copy assignment operator
9571 whose first parameter is of type `T'.
9572 0 if D is not a copy constructor or copy assignment
9573 operator.
9574 1 if D is a copy constructor or copy assignment operator whose
9575 first parameter is a reference to const qualified T.
9576 2 if D is a copy constructor or copy assignment operator whose
9577 first parameter is a reference to non-const qualified T.
9578
9579 This function can be used as a predicate. Positive values indicate
838dfd8a 9580 a copy constructor and nonzero values indicate a copy assignment
4f1c5b7d
MM
9581 operator. */
9582
c11b6f21 9583int
58f9752a 9584copy_fn_p (const_tree d)
c11b6f21 9585{
271e6f02
NS
9586 tree args;
9587 tree arg_type;
9588 int result = 1;
caf93cb0 9589
398cd199 9590 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
4f1c5b7d 9591
7137605e
MM
9592 if (TREE_CODE (d) == TEMPLATE_DECL
9593 || (DECL_TEMPLATE_INFO (d)
9594 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
271e6f02
NS
9595 /* Instantiations of template member functions are never copy
9596 functions. Note that member functions of templated classes are
9597 represented as template functions internally, and we must
9598 accept those as copy functions. */
9599 return 0;
caf93cb0 9600
271e6f02
NS
9601 args = FUNCTION_FIRST_USER_PARMTYPE (d);
9602 if (!args)
4f1c5b7d
MM
9603 return 0;
9604
271e6f02 9605 arg_type = TREE_VALUE (args);
139a78c7
VR
9606 if (arg_type == error_mark_node)
9607 return 0;
271e6f02
NS
9608
9609 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
9610 {
9611 /* Pass by value copy assignment operator. */
9612 result = -1;
9613 }
9614 else if (TREE_CODE (arg_type) == REFERENCE_TYPE
8af2fec4 9615 && !TYPE_REF_IS_RVALUE (arg_type)
271e6f02
NS
9616 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
9617 {
9618 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
9619 result = 2;
9620 }
9621 else
9622 return 0;
caf93cb0 9623
271e6f02
NS
9624 args = TREE_CHAIN (args);
9625
9626 if (args && args != void_list_node && !TREE_PURPOSE (args))
9627 /* There are more non-optional args. */
9628 return 0;
9629
9630 return result;
9631}
9632
8af2fec4
RY
9633/* D is a constructor or overloaded `operator='.
9634
9635 Let T be the class in which D is declared. Then, this function
9636 returns true when D is a move constructor or move assignment
9637 operator, false otherwise. */
9638
9639bool
58f9752a 9640move_fn_p (const_tree d)
8af2fec4
RY
9641{
9642 tree args;
9643 tree arg_type;
9644 bool result = false;
9645
9646 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
9647
c1ae8be5
SM
9648 if (cxx_dialect == cxx98)
9649 /* There are no move constructors if we are in C++98 mode. */
8af2fec4
RY
9650 return false;
9651
9652 if (TREE_CODE (d) == TEMPLATE_DECL
9653 || (DECL_TEMPLATE_INFO (d)
9654 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
9655 /* Instantiations of template member functions are never copy
9656 functions. Note that member functions of templated classes are
9657 represented as template functions internally, and we must
9658 accept those as copy functions. */
9659 return 0;
9660
9661 args = FUNCTION_FIRST_USER_PARMTYPE (d);
9662 if (!args)
9663 return 0;
9664
9665 arg_type = TREE_VALUE (args);
9666 if (arg_type == error_mark_node)
9667 return 0;
9668
9669 if (TREE_CODE (arg_type) == REFERENCE_TYPE
9670 && TYPE_REF_IS_RVALUE (arg_type)
9671 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)),
9672 DECL_CONTEXT (d)))
9673 result = true;
9674
9675 args = TREE_CHAIN (args);
9676
9677 if (args && args != void_list_node && !TREE_PURPOSE (args))
9678 /* There are more non-optional args. */
9679 return false;
9680
9681 return result;
9682}
9683
271e6f02
NS
9684/* Remember any special properties of member function DECL. */
9685
0fcedd9c
JM
9686void
9687grok_special_member_properties (tree decl)
271e6f02 9688{
7137605e
MM
9689 tree class_type;
9690
6d69fe27 9691 if (!DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
7137605e
MM
9692 return;
9693
9694 class_type = DECL_CONTEXT (decl);
9695 if (DECL_CONSTRUCTOR_P (decl))
271e6f02
NS
9696 {
9697 int ctor = copy_fn_p (decl);
caf93cb0 9698
0fcedd9c
JM
9699 if (!DECL_ARTIFICIAL (decl))
9700 TYPE_HAS_USER_CONSTRUCTOR (class_type) = 1;
7137605e 9701
271e6f02
NS
9702 if (ctor > 0)
9703 {
9704 /* [class.copy]
caf93cb0 9705
0cbd7506
MS
9706 A non-template constructor for class X is a copy
9707 constructor if its first parameter is of type X&, const
9708 X&, volatile X& or const volatile X&, and either there
9709 are no other parameters or else all other parameters have
9710 default arguments. */
7137605e 9711 TYPE_HAS_INIT_REF (class_type) = 1;
b87d79e6
JM
9712 if (!DECL_DEFAULTED_FN (decl))
9713 TYPE_HAS_COMPLEX_INIT_REF (class_type) = 1;
271e6f02 9714 if (ctor > 1)
7137605e 9715 TYPE_HAS_CONST_INIT_REF (class_type) = 1;
271e6f02
NS
9716 }
9717 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
7137605e 9718 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type) = 1;
09357846
JM
9719 else if (is_list_ctor (decl))
9720 TYPE_HAS_LIST_CTOR (class_type) = 1;
271e6f02
NS
9721 }
9722 else if (DECL_OVERLOADED_OPERATOR_P (decl) == NOP_EXPR)
9723 {
9724 /* [class.copy]
caf93cb0 9725
0cbd7506
MS
9726 A non-template assignment operator for class X is a copy
9727 assignment operator if its parameter is of type X, X&, const
9728 X&, volatile X& or const volatile X&. */
caf93cb0 9729
271e6f02 9730 int assop = copy_fn_p (decl);
caf93cb0 9731
271e6f02
NS
9732 if (assop)
9733 {
7137605e 9734 TYPE_HAS_ASSIGN_REF (class_type) = 1;
b87d79e6
JM
9735 if (!DECL_DEFAULTED_FN (decl))
9736 TYPE_HAS_COMPLEX_ASSIGN_REF (class_type) = 1;
271e6f02 9737 if (assop != 1)
7137605e 9738 TYPE_HAS_CONST_ASSIGN_REF (class_type) = 1;
271e6f02
NS
9739 }
9740 }
c11b6f21
MS
9741}
9742
271e6f02
NS
9743/* Check a constructor DECL has the correct form. Complains
9744 if the class has a constructor of the form X(X). */
e92cc029 9745
a0a33927 9746int
58f9752a 9747grok_ctor_properties (const_tree ctype, const_tree decl)
8d08fdba 9748{
271e6f02
NS
9749 int ctor_parm = copy_fn_p (decl);
9750
9751 if (ctor_parm < 0)
9752 {
9753 /* [class.copy]
caf93cb0 9754
0cbd7506
MS
9755 A declaration of a constructor for a class X is ill-formed if
9756 its first parameter is of type (optionally cv-qualified) X
9757 and either there are no other parameters or else all other
9758 parameters have default arguments.
9759
9760 We *don't* complain about member template instantiations that
9761 have this form, though; they can occur as we try to decide
9762 what constructor to use during overload resolution. Since
9763 overload resolution will never prefer such a constructor to
9764 the non-template copy constructor (which is either explicitly
9765 or implicitly defined), there's no need to worry about their
9766 existence. Theoretically, they should never even be
9767 instantiated, but that's hard to forestall. */
2d01edd7 9768 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
0b41abe6 9769 ctype, ctype);
0b41abe6 9770 return 0;
8d08fdba 9771 }
caf93cb0 9772
a0a33927 9773 return 1;
8d08fdba
MS
9774}
9775
596ea4e5 9776/* An operator with this code is unary, but can also be binary. */
e92cc029 9777
a28e3c7f 9778static int
11f6b451 9779ambi_op_p (enum tree_code code)
8d08fdba 9780{
596ea4e5
AS
9781 return (code == INDIRECT_REF
9782 || code == ADDR_EXPR
392e3d51 9783 || code == UNARY_PLUS_EXPR
596ea4e5
AS
9784 || code == NEGATE_EXPR
9785 || code == PREINCREMENT_EXPR
9786 || code == PREDECREMENT_EXPR);
8d08fdba
MS
9787}
9788
9789/* An operator with this name can only be unary. */
e92cc029 9790
a28e3c7f 9791static int
11f6b451 9792unary_op_p (enum tree_code code)
8d08fdba 9793{
596ea4e5
AS
9794 return (code == TRUTH_NOT_EXPR
9795 || code == BIT_NOT_EXPR
9796 || code == COMPONENT_REF
9797 || code == TYPE_EXPR);
8d08fdba
MS
9798}
9799
f2a79152 9800/* DECL is a declaration for an overloaded operator. If COMPLAIN is true,
4b0d3cbe 9801 errors are issued for invalid declarations. */
e92cc029 9802
398cd199 9803bool
7e45bd18 9804grok_op_properties (tree decl, bool complain)
8d08fdba
MS
9805{
9806 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
596ea4e5 9807 tree argtype;
8d08fdba
MS
9808 int methodp = (TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
9809 tree name = DECL_NAME (decl);
596ea4e5
AS
9810 enum tree_code operator_code;
9811 int arity;
64844139 9812 bool ellipsis_p;
7e45bd18 9813 tree class_type;
596ea4e5 9814
64844139 9815 /* Count the number of arguments and check for ellipsis. */
596ea4e5
AS
9816 for (argtype = argtypes, arity = 0;
9817 argtype && argtype != void_list_node;
9818 argtype = TREE_CHAIN (argtype))
9819 ++arity;
64844139 9820 ellipsis_p = !argtype;
8d08fdba 9821
7e45bd18
MM
9822 class_type = DECL_CONTEXT (decl);
9823 if (class_type && !CLASS_TYPE_P (class_type))
9824 class_type = NULL_TREE;
8d08fdba 9825
596ea4e5
AS
9826 if (DECL_CONV_FN_P (decl))
9827 operator_code = TYPE_EXPR;
9828 else
9829 do
9830 {
0c918ce5
MM
9831#define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
9832 if (ansi_opname (CODE) == name) \
9833 { \
75ac8dec 9834 operator_code = (CODE); \
0c918ce5
MM
9835 break; \
9836 } \
9837 else if (ansi_assopname (CODE) == name) \
9838 { \
75ac8dec 9839 operator_code = (CODE); \
0c918ce5
MM
9840 DECL_ASSIGNMENT_OPERATOR_P (decl) = 1; \
9841 break; \
596ea4e5
AS
9842 }
9843
9844#include "operators.def"
9845#undef DEF_OPERATOR
9846
8dc2b103 9847 gcc_unreachable ();
596ea4e5
AS
9848 }
9849 while (0);
c0ed0531 9850 gcc_assert (operator_code != MAX_TREE_CODES);
596ea4e5
AS
9851 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
9852
7e45bd18
MM
9853 if (class_type)
9854 switch (operator_code)
9855 {
9856 case NEW_EXPR:
9857 TYPE_HAS_NEW_OPERATOR (class_type) = 1;
9858 break;
5362b086 9859
7e45bd18
MM
9860 case DELETE_EXPR:
9861 TYPE_GETS_DELETE (class_type) |= 1;
9862 break;
5362b086 9863
7e45bd18
MM
9864 case VEC_NEW_EXPR:
9865 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type) = 1;
9866 break;
5362b086 9867
7e45bd18
MM
9868 case VEC_DELETE_EXPR:
9869 TYPE_GETS_DELETE (class_type) |= 2;
9870 break;
596ea4e5 9871
7e45bd18
MM
9872 default:
9873 break;
9874 }
596ea4e5 9875
3143d517
GB
9876 /* [basic.std.dynamic.allocation]/1:
9877
9878 A program is ill-formed if an allocation function is declared
9879 in a namespace scope other than global scope or declared static
9880 in global scope.
9881
9882 The same also holds true for deallocation functions. */
9883 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR
9884 || operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
9885 {
9886 if (DECL_NAMESPACE_SCOPE_P (decl))
9887 {
9888 if (CP_DECL_CONTEXT (decl) != global_namespace)
398cd199
VR
9889 {
9890 error ("%qD may not be declared within a namespace", decl);
9891 return false;
9892 }
3143d517 9893 else if (!TREE_PUBLIC (decl))
398cd199
VR
9894 {
9895 error ("%qD may not be declared as static", decl);
9896 return false;
9897 }
3143d517
GB
9898 }
9899 }
9900
596ea4e5 9901 if (operator_code == NEW_EXPR || operator_code == VEC_NEW_EXPR)
1ea193c2
ILT
9902 {
9903 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl));
9904 DECL_IS_OPERATOR_NEW (decl) = 1;
9905 }
596ea4e5 9906 else if (operator_code == DELETE_EXPR || operator_code == VEC_DELETE_EXPR)
4546865e 9907 TREE_TYPE (decl) = coerce_delete_type (TREE_TYPE (decl));
8d08fdba
MS
9908 else
9909 {
9910 /* An operator function must either be a non-static member function
9911 or have at least one parameter of a class, a reference to a class,
9912 an enumeration, or a reference to an enumeration. 13.4.0.6 */
700f8a87 9913 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
8d08fdba 9914 {
596ea4e5
AS
9915 if (operator_code == TYPE_EXPR
9916 || operator_code == CALL_EXPR
9917 || operator_code == COMPONENT_REF
9918 || operator_code == ARRAY_REF
9919 || operator_code == NOP_EXPR)
f2a79152
PC
9920 {
9921 error ("%qD must be a nonstatic member function", decl);
398cd199 9922 return false;
f2a79152 9923 }
8d08fdba
MS
9924 else
9925 {
4b0d3cbe 9926 tree p;
8d08fdba 9927
700f8a87 9928 if (DECL_STATIC_FUNCTION_P (decl))
f2a79152
PC
9929 {
9930 error ("%qD must be either a non-static member "
9931 "function or a non-member function", decl);
398cd199 9932 return false;
f2a79152 9933 }
700f8a87 9934
4b0d3cbe
MM
9935 for (p = argtypes; p && p != void_list_node; p = TREE_CHAIN (p))
9936 {
9937 tree arg = non_reference (TREE_VALUE (p));
85990800 9938 if (arg == error_mark_node)
398cd199 9939 return false;
85990800 9940
9e1e64ec 9941 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
4b0d3cbe
MM
9942 because these checks are performed even on
9943 template functions. */
9e1e64ec
PC
9944 if (MAYBE_CLASS_TYPE_P (arg)
9945 || TREE_CODE (arg) == ENUMERAL_TYPE)
4b0d3cbe
MM
9946 break;
9947 }
9948
9949 if (!p || p == void_list_node)
9950 {
398cd199
VR
9951 if (complain)
9952 error ("%qD must have an argument of class or "
9953 "enumerated type", decl);
9954 return false;
4b0d3cbe 9955 }
8d08fdba
MS
9956 }
9957 }
68642fb6 9958
4b0d3cbe
MM
9959 /* There are no restrictions on the arguments to an overloaded
9960 "operator ()". */
596ea4e5 9961 if (operator_code == CALL_EXPR)
398cd199 9962 return true;
8d08fdba 9963
7e45bd18 9964 /* Warn about conversion operators that will never be used. */
c8094d83 9965 if (IDENTIFIER_TYPENAME_P (name)
7e45bd18
MM
9966 && ! DECL_TEMPLATE_INFO (decl)
9967 && warn_conversion
9968 /* Warn only declaring the function; there is no need to
9969 warn again about out-of-class definitions. */
9970 && class_type == current_class_type)
a0a33927
MS
9971 {
9972 tree t = TREE_TYPE (name);
7e45bd18
MM
9973 int ref = (TREE_CODE (t) == REFERENCE_TYPE);
9974 const char *what = 0;
5362b086 9975
7e45bd18
MM
9976 if (ref)
9977 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
a0a33927 9978
7e45bd18
MM
9979 if (TREE_CODE (t) == VOID_TYPE)
9980 what = "void";
9981 else if (class_type)
9982 {
9983 if (t == class_type)
a0a33927 9984 what = "the same type";
9a3b49ac 9985 /* Don't force t to be complete here. */
9e1e64ec 9986 else if (MAYBE_CLASS_TYPE_P (t)
d0f062fb 9987 && COMPLETE_TYPE_P (t)
7e45bd18 9988 && DERIVED_FROM_P (t, class_type))
a0a33927 9989 what = "a base class";
a0a33927 9990 }
7e45bd18
MM
9991
9992 if (what)
b323323f 9993 warning (OPT_Wconversion, "conversion to %s%s will never use a type "
7e45bd18
MM
9994 "conversion operator",
9995 ref ? "a reference to " : "", what);
a0a33927 9996 }
64844139 9997
271e6f02 9998 if (operator_code == COND_EXPR)
8d08fdba
MS
9999 {
10000 /* 13.4.0.3 */
33bd39a2 10001 error ("ISO C++ prohibits overloading operator ?:");
398cd199 10002 return false;
68642fb6 10003 }
64844139 10004 else if (ellipsis_p)
398cd199
VR
10005 {
10006 error ("%qD must not have variable number of arguments", decl);
10007 return false;
10008 }
596ea4e5 10009 else if (ambi_op_p (operator_code))
8d08fdba 10010 {
596ea4e5
AS
10011 if (arity == 1)
10012 /* We pick the one-argument operator codes by default, so
10013 we don't have to change anything. */
10014 ;
10015 else if (arity == 2)
8d08fdba 10016 {
596ea4e5
AS
10017 /* If we thought this was a unary operator, we now know
10018 it to be a binary operator. */
10019 switch (operator_code)
10020 {
10021 case INDIRECT_REF:
10022 operator_code = MULT_EXPR;
10023 break;
10024
10025 case ADDR_EXPR:
10026 operator_code = BIT_AND_EXPR;
10027 break;
10028
392e3d51 10029 case UNARY_PLUS_EXPR:
596ea4e5
AS
10030 operator_code = PLUS_EXPR;
10031 break;
10032
10033 case NEGATE_EXPR:
10034 operator_code = MINUS_EXPR;
10035 break;
10036
10037 case PREINCREMENT_EXPR:
10038 operator_code = POSTINCREMENT_EXPR;
10039 break;
10040
10041 case PREDECREMENT_EXPR:
655dc6ee 10042 operator_code = POSTDECREMENT_EXPR;
596ea4e5
AS
10043 break;
10044
10045 default:
8dc2b103 10046 gcc_unreachable ();
596ea4e5
AS
10047 }
10048
10049 SET_OVERLOADED_OPERATOR_CODE (decl, operator_code);
10050
10051 if ((operator_code == POSTINCREMENT_EXPR
10052 || operator_code == POSTDECREMENT_EXPR)
5156628f 10053 && ! processing_template_decl
007e5fea 10054 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)), integer_type_node))
8d08fdba
MS
10055 {
10056 if (methodp)
2d01edd7 10057 error ("postfix %qD must take %<int%> as its argument",
398cd199 10058 decl);
8d08fdba 10059 else
398cd199
VR
10060 error ("postfix %qD must take %<int%> as its second "
10061 "argument", decl);
10062 return false;
8d08fdba
MS
10063 }
10064 }
10065 else
10066 {
10067 if (methodp)
2d01edd7 10068 error ("%qD must take either zero or one argument", decl);
8d08fdba 10069 else
2d01edd7 10070 error ("%qD must take either one or two arguments", decl);
398cd199 10071 return false;
8d08fdba 10072 }
824b9a4c
MS
10073
10074 /* More Effective C++ rule 6. */
eb448459 10075 if (warn_ecpp
596ea4e5
AS
10076 && (operator_code == POSTINCREMENT_EXPR
10077 || operator_code == POSTDECREMENT_EXPR
10078 || operator_code == PREINCREMENT_EXPR
10079 || operator_code == PREDECREMENT_EXPR))
824b9a4c
MS
10080 {
10081 tree arg = TREE_VALUE (argtypes);
10082 tree ret = TREE_TYPE (TREE_TYPE (decl));
10083 if (methodp || TREE_CODE (arg) == REFERENCE_TYPE)
10084 arg = TREE_TYPE (arg);
10085 arg = TYPE_MAIN_VARIANT (arg);
596ea4e5
AS
10086 if (operator_code == PREINCREMENT_EXPR
10087 || operator_code == PREDECREMENT_EXPR)
824b9a4c
MS
10088 {
10089 if (TREE_CODE (ret) != REFERENCE_TYPE
3bfdc719
MM
10090 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)),
10091 arg))
b323323f 10092 warning (OPT_Weffc__, "prefix %qD should return %qT", decl,
0cbd7506 10093 build_reference_type (arg));
824b9a4c
MS
10094 }
10095 else
10096 {
3bfdc719 10097 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
b323323f 10098 warning (OPT_Weffc__, "postfix %qD should return %qT", decl, arg);
824b9a4c
MS
10099 }
10100 }
8d08fdba 10101 }
596ea4e5 10102 else if (unary_op_p (operator_code))
8d08fdba 10103 {
596ea4e5 10104 if (arity != 1)
8d08fdba
MS
10105 {
10106 if (methodp)
2d01edd7 10107 error ("%qD must take %<void%>", decl);
8d08fdba 10108 else
2d01edd7 10109 error ("%qD must take exactly one argument", decl);
398cd199 10110 return false;
8d08fdba
MS
10111 }
10112 }
596ea4e5 10113 else /* if (binary_op_p (operator_code)) */
8d08fdba 10114 {
596ea4e5 10115 if (arity != 2)
8d08fdba
MS
10116 {
10117 if (methodp)
2d01edd7 10118 error ("%qD must take exactly one argument", decl);
8d08fdba 10119 else
2d01edd7 10120 error ("%qD must take exactly two arguments", decl);
398cd199 10121 return false;
8d08fdba 10122 }
824b9a4c
MS
10123
10124 /* More Effective C++ rule 7. */
eb448459 10125 if (warn_ecpp
596ea4e5
AS
10126 && (operator_code == TRUTH_ANDIF_EXPR
10127 || operator_code == TRUTH_ORIF_EXPR
10128 || operator_code == COMPOUND_EXPR))
b323323f 10129 warning (OPT_Weffc__, "user-defined %qD always evaluates both arguments",
0cbd7506 10130 decl);
824b9a4c
MS
10131 }
10132
10133 /* Effective C++ rule 23. */
eb448459 10134 if (warn_ecpp
596ea4e5 10135 && arity == 2
4bd7c270 10136 && !DECL_ASSIGNMENT_OPERATOR_P (decl)
596ea4e5
AS
10137 && (operator_code == PLUS_EXPR
10138 || operator_code == MINUS_EXPR
10139 || operator_code == TRUNC_DIV_EXPR
4bd7c270
NS
10140 || operator_code == MULT_EXPR
10141 || operator_code == TRUNC_MOD_EXPR)
824b9a4c 10142 && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == REFERENCE_TYPE)
b323323f 10143 warning (OPT_Weffc__, "%qD should return by value", decl);
8d08fdba 10144
271e6f02 10145 /* [over.oper]/8 */
34332678 10146 for (; argtypes && argtypes != void_list_node;
0cbd7506
MS
10147 argtypes = TREE_CHAIN (argtypes))
10148 if (TREE_PURPOSE (argtypes))
10149 {
10150 TREE_PURPOSE (argtypes) = NULL_TREE;
10151 if (operator_code == POSTINCREMENT_EXPR
596ea4e5 10152 || operator_code == POSTDECREMENT_EXPR)
0cbd7506 10153 {
fcf73884
MLI
10154 pedwarn (OPT_pedantic, "%qD cannot have default arguments",
10155 decl);
0cbd7506
MS
10156 }
10157 else
398cd199
VR
10158 {
10159 error ("%qD cannot have default arguments", decl);
10160 return false;
10161 }
0cbd7506 10162 }
8d08fdba 10163 }
398cd199 10164 return true;
8d08fdba
MS
10165}
10166\f
0c88d886
MM
10167/* Return a string giving the keyword associate with CODE. */
10168
d8e178a0 10169static const char *
11f6b451 10170tag_name (enum tag_types code)
094fe153
JM
10171{
10172 switch (code)
10173 {
10174 case record_type:
10175 return "struct";
10176 case class_type:
10177 return "class";
10178 case union_type:
0c88d886 10179 return "union";
094fe153
JM
10180 case enum_type:
10181 return "enum";
0c88d886
MM
10182 case typename_type:
10183 return "typename";
094fe153 10184 default:
8dc2b103 10185 gcc_unreachable ();
094fe153
JM
10186 }
10187}
10188
befcd99b 10189/* Name lookup in an elaborated-type-specifier (after the keyword
4b0d3cbe 10190 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
befcd99b 10191 elaborated-type-specifier is invalid, issue a diagnostic and return
4b0d3cbe 10192 error_mark_node; otherwise, return the *_TYPE to which it referred.
cbd63935 10193 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
befcd99b 10194
560ad596 10195tree
befcd99b 10196check_elaborated_type_specifier (enum tag_types tag_code,
4b0d3cbe 10197 tree decl,
cbd63935 10198 bool allow_template_p)
befcd99b 10199{
4b0d3cbe 10200 tree type;
befcd99b 10201
4b0d3cbe
MM
10202 /* In the case of:
10203
10204 struct S { struct S *p; };
10205
10206 name lookup will find the TYPE_DECL for the implicit "S::S"
10207 typedef. Adjust for that here. */
10208 if (DECL_SELF_REFERENCE_P (decl))
10209 decl = TYPE_NAME (TREE_TYPE (decl));
10210
10211 type = TREE_TYPE (decl);
10212
461c6fce
KL
10213 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
10214 is false for this case as well. */
10215 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
10216 {
10217 error ("using template type parameter %qT after %qs",
10218 type, tag_name (tag_code));
10219 return error_mark_node;
10220 }
caf93cb0 10221 /* [dcl.type.elab]
4b0d3cbe
MM
10222
10223 If the identifier resolves to a typedef-name or a template
10224 type-parameter, the elaborated-type-specifier is ill-formed.
10225
10226 In other words, the only legitimate declaration to use in the
10227 elaborated type specifier is the implicit typedef created when
10228 the type is declared. */
0c88d886
MM
10229 else if (!DECL_IMPLICIT_TYPEDEF_P (decl)
10230 && tag_code != typename_type)
befcd99b 10231 {
2d01edd7 10232 error ("using typedef-name %qD after %qs", decl, tag_name (tag_code));
dee15844 10233 error ("%q+D has a previous declaration here", decl);
4b0d3cbe 10234 return error_mark_node;
befcd99b 10235 }
cbd63935
KL
10236 else if (TREE_CODE (type) != RECORD_TYPE
10237 && TREE_CODE (type) != UNION_TYPE
0c88d886
MM
10238 && tag_code != enum_type
10239 && tag_code != typename_type)
cbd63935 10240 {
2d01edd7 10241 error ("%qT referred to as %qs", type, tag_name (tag_code));
dee15844 10242 error ("%q+T has a previous declaration here", type);
4b0d3cbe 10243 return error_mark_node;
cbd63935
KL
10244 }
10245 else if (TREE_CODE (type) != ENUMERAL_TYPE
4fe8db68 10246 && tag_code == enum_type)
cbd63935 10247 {
2d01edd7 10248 error ("%qT referred to as enum", type);
dee15844 10249 error ("%q+T has a previous declaration here", type);
4b0d3cbe 10250 return error_mark_node;
cbd63935
KL
10251 }
10252 else if (!allow_template_p
10253 && TREE_CODE (type) == RECORD_TYPE
10254 && CLASSTYPE_IS_TEMPLATE (type))
10255 {
10256 /* If a class template appears as elaborated type specifier
10257 without a template header such as:
10258
10259 template <class T> class C {};
10260 void f(class C); // No template header here
10261
10262 then the required template argument is missing. */
2d01edd7 10263 error ("template argument required for %<%s %T%>",
cbd63935
KL
10264 tag_name (tag_code),
10265 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
4b0d3cbe 10266 return error_mark_node;
cbd63935 10267 }
befcd99b 10268
4b0d3cbe 10269 return type;
befcd99b
MM
10270}
10271
461c6fce 10272/* Lookup NAME in elaborate type specifier in scope according to
29ef83de 10273 SCOPE and issue diagnostics if necessary.
461c6fce
KL
10274 Return *_TYPE node upon success, NULL_TREE when the NAME is not
10275 found, and ERROR_MARK_NODE for type error. */
10276
10277static tree
10278lookup_and_check_tag (enum tag_types tag_code, tree name,
29ef83de 10279 tag_scope scope, bool template_header_p)
461c6fce
KL
10280{
10281 tree t;
10282 tree decl;
29ef83de 10283 if (scope == ts_global)
bd3d082e
KL
10284 {
10285 /* First try ordinary name lookup, ignoring hidden class name
10286 injected via friend declaration. */
10e6657a 10287 decl = lookup_name_prefer_type (name, 2);
bd3d082e
KL
10288 /* If that fails, the name will be placed in the smallest
10289 non-class, non-function-prototype scope according to 3.3.1/5.
10290 We may already have a hidden name declared as friend in this
105d72c5 10291 scope. So lookup again but not ignoring hidden names.
bd3d082e
KL
10292 If we find one, that name will be made visible rather than
10293 creating a new tag. */
10294 if (!decl)
10295 decl = lookup_type_scope (name, ts_within_enclosing_non_class);
10296 }
461c6fce 10297 else
29ef83de 10298 decl = lookup_type_scope (name, scope);
461c6fce
KL
10299
10300 if (decl && DECL_CLASS_TEMPLATE_P (decl))
10301 decl = DECL_TEMPLATE_RESULT (decl);
10302
10303 if (decl && TREE_CODE (decl) == TYPE_DECL)
10304 {
4104f0f4
KL
10305 /* Look for invalid nested type:
10306 class C {
10307 class C {};
10308 }; */
10309 if (scope == ts_current && DECL_SELF_REFERENCE_P (decl))
10310 {
10311 error ("%qD has the same name as the class in which it is "
10312 "declared",
10313 decl);
10314 return error_mark_node;
10315 }
10316
461c6fce
KL
10317 /* Two cases we need to consider when deciding if a class
10318 template is allowed as an elaborated type specifier:
10319 1. It is a self reference to its own class.
10320 2. It comes with a template header.
10321
10322 For example:
10323
10324 template <class T> class C {
10325 class C *c1; // DECL_SELF_REFERENCE_P is true
10326 class D;
10327 };
10328 template <class U> class C; // template_header_p is true
10329 template <class T> class C<T>::D {
10330 class C *c2; // DECL_SELF_REFERENCE_P is true
10331 }; */
10332
10333 t = check_elaborated_type_specifier (tag_code,
10334 decl,
10335 template_header_p
10336 | DECL_SELF_REFERENCE_P (decl));
10337 return t;
10338 }
af92ab36
OW
10339 else if (decl && TREE_CODE (decl) == TREE_LIST)
10340 {
10341 error ("reference to %qD is ambiguous", name);
10342 print_candidates (decl);
10343 return error_mark_node;
10344 }
461c6fce
KL
10345 else
10346 return NULL_TREE;
10347}
10348
cbd63935 10349/* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
8d08fdba
MS
10350 Define the tag as a forward-reference if it is not defined.
10351
cbd63935 10352 If a declaration is given, process it here, and report an error if
38b305d0 10353 multiple declarations are not identical.
8d08fdba 10354
29ef83de 10355 SCOPE is TS_CURRENT when this is also a definition. Only look in
8d08fdba 10356 the current frame for the name (since C++ allows new names in any
29ef83de
KL
10357 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
10358 declaration. Only look beginning from the current scope outward up
10359 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
cbd63935
KL
10360
10361 TEMPLATE_HEADER_P is true when this declaration is preceded by
10362 a set of template parameters. */
8d08fdba 10363
8d08fdba 10364tree
38b305d0 10365xref_tag (enum tag_types tag_code, tree name,
29ef83de 10366 tag_scope scope, bool template_header_p)
8d08fdba 10367{
8d08fdba 10368 enum tree_code code;
926ce8bd 10369 tree t;
25aab5d0 10370 tree context = NULL_TREE;
dc8263bc 10371
22ffcc6f 10372 timevar_push (TV_NAME_LOOKUP);
cbd63935 10373
50bc768d 10374 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
cbd63935 10375
8d08fdba
MS
10376 switch (tag_code)
10377 {
10378 case record_type:
10379 case class_type:
8d08fdba 10380 code = RECORD_TYPE;
8d08fdba
MS
10381 break;
10382 case union_type:
10383 code = UNION_TYPE;
8d08fdba
MS
10384 break;
10385 case enum_type:
10386 code = ENUMERAL_TYPE;
10387 break;
10388 default:
8dc2b103 10389 gcc_unreachable ();
8d08fdba
MS
10390 }
10391
461c6fce
KL
10392 /* In case of anonymous name, xref_tag is only called to
10393 make type node and push name. Name lookup is not required. */
10394 if (ANON_AGGRNAME_P (name))
10395 t = NULL_TREE;
8d08fdba 10396 else
461c6fce 10397 t = lookup_and_check_tag (tag_code, name,
29ef83de 10398 scope, template_header_p);
cbd63935 10399
461c6fce
KL
10400 if (t == error_mark_node)
10401 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
68642fb6 10402
29ef83de 10403 if (scope != ts_current && t && current_class_type
461c6fce
KL
10404 && template_class_depth (current_class_type)
10405 && template_header_p)
10406 {
29ef83de 10407 /* Since SCOPE is not TS_CURRENT, we are not looking at a
461c6fce
KL
10408 definition of this tag. Since, in addition, we are currently
10409 processing a (member) template declaration of a template
10410 class, we must be very careful; consider:
25aab5d0 10411
461c6fce
KL
10412 template <class X>
10413 struct S1
25aab5d0 10414
461c6fce
KL
10415 template <class U>
10416 struct S2
10417 { template <class V>
10418 friend struct S1; };
25aab5d0 10419
461c6fce
KL
10420 Here, the S2::S1 declaration should not be confused with the
10421 outer declaration. In particular, the inner version should
10422 have a template parameter of level 2, not level 1. This
10423 would be particularly important if the member declaration
10424 were instead:
25aab5d0 10425
461c6fce 10426 template <class V = U> friend struct S1;
25aab5d0 10427
461c6fce
KL
10428 say, when we should tsubst into `U' when instantiating
10429 S2. On the other hand, when presented with:
25aab5d0 10430
461c6fce
KL
10431 template <class T>
10432 struct S1 {
10433 template <class U>
10434 struct S2 {};
10435 template <class U>
10436 friend struct S2;
10437 };
25aab5d0 10438
461c6fce
KL
10439 we must find the inner binding eventually. We
10440 accomplish this by making sure that the new type we
10441 create to represent this declaration has the right
10442 TYPE_CONTEXT. */
10443 context = TYPE_CONTEXT (t);
10444 t = NULL_TREE;
8d08fdba
MS
10445 }
10446
cbd63935 10447 if (! t)
8d08fdba
MS
10448 {
10449 /* If no such tag is yet defined, create a forward-reference node
10450 and record it as the "definition".
10451 When a real declaration of this type is found,
10452 the forward-reference will be altered into a real type. */
8d08fdba
MS
10453 if (code == ENUMERAL_TYPE)
10454 {
2d01edd7 10455 error ("use of enum %q#D without previous declaration", name);
30fc3df7 10456 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
8d08fdba 10457 }
8d08fdba
MS
10458 else
10459 {
9e1e64ec 10460 t = make_class_type (code);
cbd63935 10461 TYPE_CONTEXT (t) = context;
bd3d082e 10462 t = pushtag (name, t, scope);
8d08fdba
MS
10463 }
10464 }
10465 else
10466 {
9e1e64ec 10467 if (template_header_p && MAYBE_CLASS_TYPE_P (t))
60feef2c
LM
10468 {
10469 if (!redeclare_class_template (t, current_template_parms))
10470 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
10471 }
caf93cb0 10472 else if (!processing_template_decl
9ce1594a
MM
10473 && CLASS_TYPE_P (t)
10474 && CLASSTYPE_IS_TEMPLATE (t))
10475 {
2d01edd7 10476 error ("redeclaration of %qT as a non-template", t);
b646edb8
VR
10477 error ("previous declaration %q+D", t);
10478 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
9ce1594a 10479 }
bd3d082e
KL
10480
10481 /* Make injected friend class visible. */
10482 if (scope != ts_within_enclosing_non_class
10483 && hidden_name_p (TYPE_NAME (t)))
10484 {
10485 DECL_ANTICIPATED (TYPE_NAME (t)) = 0;
10486 DECL_FRIEND_P (TYPE_NAME (t)) = 0;
10487
10488 if (TYPE_TEMPLATE_INFO (t))
10489 {
10490 DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t)) = 0;
10491 DECL_FRIEND_P (TYPE_TI_TEMPLATE (t)) = 0;
10492 }
0cbd7506 10493 }
8d08fdba
MS
10494 }
10495
cbd63935 10496 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
8d08fdba 10497}
8ccc31eb 10498
fc378698 10499tree
29ef83de 10500xref_tag_from_type (tree old, tree id, tag_scope scope)
fc378698 10501{
88e5899c 10502 enum tag_types tag_kind;
fc378698
MS
10503
10504 if (TREE_CODE (old) == RECORD_TYPE)
88e5899c 10505 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
fc378698 10506 else
88e5899c 10507 tag_kind = union_type;
fc378698
MS
10508
10509 if (id == NULL_TREE)
10510 id = TYPE_IDENTIFIER (old);
10511
29ef83de 10512 return xref_tag (tag_kind, id, scope, false);
fc378698
MS
10513}
10514
48b45647
NS
10515/* Create the binfo hierarchy for REF with (possibly NULL) base list
10516 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
10517 access_* node, and the TREE_VALUE is the type of the base-class.
72f8fc59
LM
10518 Non-NULL TREE_TYPE indicates virtual inheritance.
10519
bd6f7848 10520 Returns true if the binfo hierarchy was successfully created,
72f8fc59 10521 false if an error was detected. */
3fd71a52 10522
72f8fc59 10523bool
dbbf88d1 10524xref_basetypes (tree ref, tree base_list)
8ccc31eb 10525{
8fbc5ae7 10526 tree *basep;
fa743e8c 10527 tree binfo, base_binfo;
03fd3f84 10528 unsigned max_vbases = 0; /* Maximum direct & indirect virtual bases. */
77880ae4 10529 unsigned max_bases = 0; /* Maximum direct bases. */
8fbc5ae7 10530 int i;
48b45647
NS
10531 tree default_access;
10532 tree igo_prev; /* Track Inheritance Graph Order. */
a5d7c4a3 10533
bef89e9e 10534 if (ref == error_mark_node)
72f8fc59 10535 return false;
bef89e9e 10536
48b45647
NS
10537 /* The base of a derived class is private by default, all others are
10538 public. */
10539 default_access = (TREE_CODE (ref) == RECORD_TYPE
10540 && CLASSTYPE_DECLARED_CLASS (ref)
10541 ? access_private_node : access_public_node);
da15dae6 10542
d6479fe7
MM
10543 /* First, make sure that any templates in base-classes are
10544 instantiated. This ensures that if we call ourselves recursively
10545 we do not get confused about which classes are marked and which
10546 are not. */
caf93cb0
EC
10547 basep = &base_list;
10548 while (*basep)
8fbc5ae7
MM
10549 {
10550 tree basetype = TREE_VALUE (*basep);
caf93cb0 10551
8fbc5ae7
MM
10552 if (!(processing_template_decl && uses_template_parms (basetype))
10553 && !complete_type_or_else (basetype, NULL))
dbbf88d1 10554 /* An incomplete type. Remove it from the list. */
8fbc5ae7
MM
10555 *basep = TREE_CHAIN (*basep);
10556 else
48b45647
NS
10557 {
10558 max_bases++;
10559 if (TREE_TYPE (*basep))
10560 max_vbases++;
10561 if (CLASS_TYPE_P (basetype))
10562 max_vbases += VEC_length (tree, CLASSTYPE_VBASECLASSES (basetype));
10563 basep = &TREE_CHAIN (*basep);
10564 }
8fbc5ae7 10565 }
d6479fe7 10566
3543e114 10567 TYPE_MARKED_P (ref) = 1;
48b45647 10568
cad7e87b
NS
10569 /* The binfo slot should be empty, unless this is an (ill-formed)
10570 redefinition. */
50bc768d
NS
10571 gcc_assert (!TYPE_BINFO (ref) || TYPE_SIZE (ref));
10572 gcc_assert (TYPE_MAIN_VARIANT (ref) == ref);
caf93cb0 10573
fa743e8c 10574 binfo = make_tree_binfo (max_bases);
caf93cb0 10575
48b45647
NS
10576 TYPE_BINFO (ref) = binfo;
10577 BINFO_OFFSET (binfo) = size_zero_node;
10578 BINFO_TYPE (binfo) = ref;
caf93cb0 10579
48b45647
NS
10580 if (max_bases)
10581 {
d4e6fecb 10582 BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, gc, max_bases);
48b45647
NS
10583 /* An aggregate cannot have baseclasses. */
10584 CLASSTYPE_NON_AGGREGATE (ref) = 1;
caf93cb0 10585
48b45647 10586 if (TREE_CODE (ref) == UNION_TYPE)
72f8fc59
LM
10587 {
10588 error ("derived union %qT invalid", ref);
10589 return false;
10590 }
48b45647 10591 }
caf93cb0 10592
48b45647 10593 if (max_bases > 1)
dbbf88d1 10594 {
48b45647 10595 if (TYPE_FOR_JAVA (ref))
72f8fc59
LM
10596 {
10597 error ("Java class %qT cannot have multiple bases", ref);
10598 return false;
10599 }
48b45647 10600 }
caf93cb0 10601
48b45647
NS
10602 if (max_vbases)
10603 {
d4e6fecb 10604 CLASSTYPE_VBASECLASSES (ref) = VEC_alloc (tree, gc, max_vbases);
caf93cb0 10605
48b45647 10606 if (TYPE_FOR_JAVA (ref))
72f8fc59
LM
10607 {
10608 error ("Java class %qT cannot have virtual bases", ref);
10609 return false;
10610 }
48b45647 10611 }
cad7e87b 10612
48b45647
NS
10613 for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list))
10614 {
10615 tree access = TREE_PURPOSE (base_list);
10616 int via_virtual = TREE_TYPE (base_list) != NULL_TREE;
10617 tree basetype = TREE_VALUE (base_list);
caf93cb0 10618
48b45647
NS
10619 if (access == access_default_node)
10620 access = default_access;
caf93cb0 10621
5d80a306
DG
10622 if (PACK_EXPANSION_P (basetype))
10623 basetype = PACK_EXPANSION_PATTERN (basetype);
48b45647
NS
10624 if (TREE_CODE (basetype) == TYPE_DECL)
10625 basetype = TREE_TYPE (basetype);
10626 if (TREE_CODE (basetype) != RECORD_TYPE
10627 && TREE_CODE (basetype) != TYPENAME_TYPE
10628 && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM
10629 && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM)
10630 {
2d01edd7 10631 error ("base type %qT fails to be a struct or class type",
48b45647 10632 basetype);
72f8fc59 10633 return false;
8ccc31eb 10634 }
caf93cb0 10635
48b45647
NS
10636 if (TYPE_FOR_JAVA (basetype) && (current_lang_depth () == 0))
10637 TYPE_FOR_JAVA (ref) = 1;
10638
fa743e8c 10639 base_binfo = NULL_TREE;
48b45647 10640 if (CLASS_TYPE_P (basetype) && !dependent_type_p (basetype))
dbbf88d1 10641 {
48b45647 10642 base_binfo = TYPE_BINFO (basetype);
77880ae4 10643 /* The original basetype could have been a typedef'd type. */
48b45647 10644 basetype = BINFO_TYPE (base_binfo);
caf93cb0 10645
48b45647
NS
10646 /* Inherit flags from the base. */
10647 TYPE_HAS_NEW_OPERATOR (ref)
10648 |= TYPE_HAS_NEW_OPERATOR (basetype);
10649 TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
10650 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
10651 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
48b45647 10652 TYPE_HAS_CONVERSION (ref) |= TYPE_HAS_CONVERSION (basetype);
3543e114
NS
10653 CLASSTYPE_DIAMOND_SHAPED_P (ref)
10654 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype);
10655 CLASSTYPE_REPEATED_BASE_P (ref)
10656 |= CLASSTYPE_REPEATED_BASE_P (basetype);
8fbc5ae7 10657 }
c8094d83 10658
98d6e9af
NS
10659 /* We must do this test after we've seen through a typedef
10660 type. */
10661 if (TYPE_MARKED_P (basetype))
10662 {
10663 if (basetype == ref)
2d01edd7 10664 error ("recursive type %qT undefined", basetype);
98d6e9af 10665 else
2d01edd7 10666 error ("duplicate base type %qT invalid", basetype);
72f8fc59 10667 return false;
98d6e9af 10668 }
5d80a306
DG
10669
10670 if (PACK_EXPANSION_P (TREE_VALUE (base_list)))
10671 /* Regenerate the pack expansion for the bases. */
10672 basetype = make_pack_expansion (basetype);
10673
98d6e9af 10674 TYPE_MARKED_P (basetype) = 1;
caf93cb0 10675
48b45647
NS
10676 base_binfo = copy_binfo (base_binfo, basetype, ref,
10677 &igo_prev, via_virtual);
10678 if (!BINFO_INHERITANCE_CHAIN (base_binfo))
10679 BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
f5c28a15 10680
fa743e8c 10681 BINFO_BASE_APPEND (binfo, base_binfo);
63d1c7b3 10682 BINFO_BASE_ACCESS_APPEND (binfo, access);
cad7e87b
NS
10683 }
10684
3543e114
NS
10685 if (VEC_space (tree, CLASSTYPE_VBASECLASSES (ref), 1))
10686 /* If we have space in the vbase vector, we must have shared at
10687 least one of them, and are therefore diamond shaped. */
10688 CLASSTYPE_DIAMOND_SHAPED_P (ref) = 1;
10689
dbbf88d1 10690 /* Unmark all the types. */
fa743e8c 10691 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
3543e114
NS
10692 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
10693 TYPE_MARKED_P (ref) = 0;
10694
10695 /* Now see if we have a repeated base type. */
10696 if (!CLASSTYPE_REPEATED_BASE_P (ref))
10697 {
10698 for (base_binfo = binfo; base_binfo;
10699 base_binfo = TREE_CHAIN (base_binfo))
10700 {
10701 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
10702 {
10703 CLASSTYPE_REPEATED_BASE_P (ref) = 1;
10704 break;
10705 }
10706 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 1;
10707 }
10708 for (base_binfo = binfo; base_binfo;
10709 base_binfo = TREE_CHAIN (base_binfo))
10710 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
10711 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
10712 else
10713 break;
10714 }
72f8fc59
LM
10715
10716 return true;
8ccc31eb 10717}
68642fb6 10718
8d08fdba 10719\f
8d08fdba 10720/* Begin compiling the definition of an enumeration type.
29ef83de 10721 NAME is its name.
8d08fdba
MS
10722 Returns the type object, as yet incomplete.
10723 Also records info about it so that build_enumerator
10724 may be used to declare the individual values as they are read. */
10725
10726tree
11f6b451 10727start_enum (tree name)
8d08fdba 10728{
29ef83de
KL
10729 tree enumtype;
10730
10731 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
8d08fdba
MS
10732
10733 /* If this is the real definition for a previous forward reference,
10734 fill in the contents in the same object that used to be the
10735 forward reference. */
10736
29ef83de
KL
10737 enumtype = lookup_and_check_tag (enum_type, name,
10738 /*tag_scope=*/ts_current,
10739 /*template_header_p=*/false);
8d08fdba
MS
10740
10741 if (enumtype != NULL_TREE && TREE_CODE (enumtype) == ENUMERAL_TYPE)
30ff8252 10742 {
2d01edd7 10743 error ("multiple definition of %q#T", enumtype);
ddd2d57e 10744 error ("%Jprevious definition here", TYPE_MAIN_DECL (enumtype));
58595203
MM
10745 /* Clear out TYPE_VALUES, and start again. */
10746 TYPE_VALUES (enumtype) = NULL_TREE;
30ff8252 10747 }
8d08fdba
MS
10748 else
10749 {
29ef83de
KL
10750 /* In case of error, make a dummy enum to allow parsing to
10751 continue. */
10752 if (enumtype == error_mark_node)
10753 name = make_anon_name ();
10754
8d08fdba 10755 enumtype = make_node (ENUMERAL_TYPE);
bd3d082e 10756 enumtype = pushtag (name, enumtype, /*tag_scope=*/ts_current);
8d08fdba
MS
10757 }
10758
8d08fdba
MS
10759 return enumtype;
10760}
10761
10762/* After processing and defining all the values of an enumeration type,
10763 install their decls in the enumeration type and finish it off.
968b956a 10764 ENUMTYPE is the type object and VALUES a list of name-value pairs. */
8d08fdba 10765
968b956a 10766void
11f6b451 10767finish_enum (tree enumtype)
8d08fdba 10768{
7b6d72fc
MM
10769 tree values;
10770 tree decl;
10771 tree value;
968b956a
MM
10772 tree minnode;
10773 tree maxnode;
10774 tree t;
10775 bool unsignedp;
f6af9a15 10776 bool use_short_enum;
968b956a 10777 int lowprec;
caf93cb0 10778 int highprec;
968b956a 10779 int precision;
7b6d72fc 10780 integer_type_kind itk;
ad96995b 10781 tree underlying_type = NULL_TREE;
968b956a
MM
10782
10783 /* We built up the VALUES in reverse order. */
10784 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
10785
f5d70cc0
JM
10786 /* For an enum defined in a template, just set the type of the values;
10787 all further processing is postponed until the template is
10788 instantiated. We need to set the type so that tsubst of a CONST_DECL
10789 works. */
968b956a
MM
10790 if (processing_template_decl)
10791 {
caf93cb0
EC
10792 for (values = TYPE_VALUES (enumtype);
10793 values;
7b6d72fc
MM
10794 values = TREE_CHAIN (values))
10795 TREE_TYPE (TREE_VALUE (values)) = enumtype;
5f261ba9 10796 if (at_function_scope_p ())
968b956a 10797 add_stmt (build_min (TAG_DEFN, enumtype));
968b956a
MM
10798 return;
10799 }
10800
7b6d72fc 10801 /* Determine the minimum and maximum values of the enumerators. */
968b956a 10802 if (TYPE_VALUES (enumtype))
8d08fdba 10803 {
968b956a 10804 minnode = maxnode = NULL_TREE;
5566b478 10805
caf93cb0
EC
10806 for (values = TYPE_VALUES (enumtype);
10807 values;
7b6d72fc 10808 values = TREE_CHAIN (values))
8d08fdba 10809 {
7b6d72fc 10810 decl = TREE_VALUE (values);
f5d70cc0
JM
10811
10812 /* [dcl.enum]: Following the closing brace of an enum-specifier,
10813 each enumerator has the type of its enumeration. Prior to the
10814 closing brace, the type of each enumerator is the type of its
10815 initializing value. */
10816 TREE_TYPE (decl) = enumtype;
10817
7b6d72fc
MM
10818 /* Update the minimum and maximum values, if appropriate. */
10819 value = DECL_INITIAL (decl);
3c955a04
MM
10820 if (value == error_mark_node)
10821 value = integer_zero_node;
f5d70cc0
JM
10822 /* Figure out what the minimum and maximum values of the
10823 enumerators are. */
10824 if (!minnode)
10825 minnode = maxnode = value;
10826 else if (tree_int_cst_lt (maxnode, value))
10827 maxnode = value;
10828 else if (tree_int_cst_lt (value, minnode))
10829 minnode = value;
8d08fdba
MS
10830 }
10831 }
f376e137 10832 else
7b6d72fc
MM
10833 /* [dcl.enum]
10834
10835 If the enumerator-list is empty, the underlying type is as if
10836 the enumeration had a single enumerator with value 0. */
968b956a
MM
10837 minnode = maxnode = integer_zero_node;
10838
10839 /* Compute the number of bits require to represent all values of the
10840 enumeration. We must do this before the type of MINNODE and
10841 MAXNODE are transformed, since min_precision relies on the
10842 TREE_TYPE of the value it is passed. */
10843 unsignedp = tree_int_cst_sgn (minnode) >= 0;
10844 lowprec = min_precision (minnode, unsignedp);
10845 highprec = min_precision (maxnode, unsignedp);
10846 precision = MAX (lowprec, highprec);
10847
7b6d72fc
MM
10848 /* Determine the underlying type of the enumeration.
10849
10850 [dcl.enum]
10851
10852 The underlying type of an enumeration is an integral type that
10853 can represent all the enumerator values defined in the
10854 enumeration. It is implementation-defined which integral type is
10855 used as the underlying type for an enumeration except that the
10856 underlying type shall not be larger than int unless the value of
caf93cb0 10857 an enumerator cannot fit in an int or unsigned int.
7b6d72fc
MM
10858
10859 We use "int" or an "unsigned int" as the underlying type, even if
10860 a smaller integral type would work, unless the user has
f6af9a15
MA
10861 explicitly requested that we use the smallest possible type. The
10862 user can request that for all enumerations with a command line
03fd3f84 10863 flag, or for just one enumeration with an attribute. */
f6af9a15
MA
10864
10865 use_short_enum = flag_short_enums
10866 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype));
10867
10868 for (itk = (use_short_enum ? itk_char : itk_int);
caf93cb0 10869 itk != itk_none;
7b6d72fc 10870 itk++)
e455bc27 10871 {
7b6d72fc
MM
10872 underlying_type = integer_types[itk];
10873 if (TYPE_PRECISION (underlying_type) >= precision
8df83eae 10874 && TYPE_UNSIGNED (underlying_type) == unsignedp)
7b6d72fc
MM
10875 break;
10876 }
10877 if (itk == itk_none)
10878 {
10879 /* DR 377
10880
10881 IF no integral type can represent all the enumerator values, the
10882 enumeration is ill-formed. */
e455bc27 10883 error ("no integral type can represent all of the enumerator values "
2d01edd7 10884 "for %qT", enumtype);
e455bc27 10885 precision = TYPE_PRECISION (long_long_integer_type_node);
7b6d72fc 10886 underlying_type = integer_types[itk_unsigned_long_long];
e455bc27
MM
10887 }
10888
39a13be5 10889 /* Compute the minimum and maximum values for the type.
8d08fdba 10890
7b6d72fc
MM
10891 [dcl.enum]
10892
10893 For an enumeration where emin is the smallest enumerator and emax
10894 is the largest, the values of the enumeration are the values of the
10895 underlying type in the range bmin to bmax, where bmin and bmax are,
10896 respectively, the smallest and largest values of the smallest bit-
10897 field that can store emin and emax. */
d0c5c9b1
RS
10898
10899 /* The middle-end currently assumes that types with TYPE_PRECISION
10900 narrower than their underlying type are suitably zero or sign
10901 extended to fill their mode. g++ doesn't make these guarantees.
10902 Until the middle-end can represent such paradoxical types, we
77880ae4 10903 set the TYPE_PRECISION to the width of the underlying type. */
d0c5c9b1
RS
10904 TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type);
10905
7b6d72fc
MM
10906 set_min_and_max_values_for_integral_type (enumtype, precision, unsignedp);
10907
10908 /* [dcl.enum]
caf93cb0 10909
7b6d72fc
MM
10910 The value of sizeof() applied to an enumeration type, an object
10911 of an enumeration type, or an enumerator, is the value of sizeof()
10912 applied to the underlying type. */
10913 TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
10914 TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
10915 TYPE_MODE (enumtype) = TYPE_MODE (underlying_type);
10916 TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
10917 TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
8df83eae 10918 TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);
7b6d72fc
MM
10919
10920 /* Convert each of the enumerators to the type of the underlying
10921 type of the enumeration. */
10922 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
10923 {
3c955a04
MM
10924 location_t saved_location;
10925
7b6d72fc 10926 decl = TREE_VALUE (values);
3c955a04
MM
10927 saved_location = input_location;
10928 input_location = DECL_SOURCE_LOCATION (decl);
7b6d72fc 10929 value = perform_implicit_conversion (underlying_type,
5ade1ed2
DG
10930 DECL_INITIAL (decl),
10931 tf_warning_or_error);
3c955a04 10932 input_location = saved_location;
89b0433e
NS
10933
10934 /* Do not clobber shared ints. */
10935 value = copy_node (value);
c8094d83 10936
7b6d72fc
MM
10937 TREE_TYPE (value) = enumtype;
10938 DECL_INITIAL (decl) = value;
10939 TREE_VALUE (values) = value;
e455bc27 10940 }
8d08fdba 10941
968b956a
MM
10942 /* Fix up all variant types of this enum type. */
10943 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
10944 {
10945 TYPE_VALUES (t) = TYPE_VALUES (enumtype);
10946 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (enumtype);
10947 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
10948 TYPE_SIZE (t) = TYPE_SIZE (enumtype);
10949 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
10950 TYPE_MODE (t) = TYPE_MODE (enumtype);
10951 TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
10952 TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
10953 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);
8df83eae 10954 TYPE_UNSIGNED (t) = TYPE_UNSIGNED (enumtype);
cbf882af
MM
10955 }
10956
968b956a
MM
10957 /* Finish debugging output for this type. */
10958 rest_of_type_compilation (enumtype, namespace_bindings_p ());
8d08fdba
MS
10959}
10960
079e1098 10961/* Build and install a CONST_DECL for an enumeration constant of the
58595203 10962 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
8d08fdba
MS
10963 Assignment of sequential values by default is handled here. */
10964
58595203 10965void
11f6b451 10966build_enumerator (tree name, tree value, tree enumtype)
8d08fdba 10967{
58595203 10968 tree decl;
e8bd800e 10969 tree context;
58595203 10970 tree type;
8d08fdba 10971
93678513
MM
10972 /* If the VALUE was erroneous, pretend it wasn't there; that will
10973 result in the enum being assigned the next value in sequence. */
10974 if (value == error_mark_node)
10975 value = NULL_TREE;
10976
8d08fdba
MS
10977 /* Remove no-op casts from the value. */
10978 if (value)
10979 STRIP_TYPE_NOPS (value);
10980
58595203
MM
10981 if (! processing_template_decl)
10982 {
10983 /* Validate and default VALUE. */
10984 if (value != NULL_TREE)
10985 {
8a784e4a 10986 value = integral_constant_value (value);
58595203
MM
10987
10988 if (TREE_CODE (value) == INTEGER_CST)
10989 {
0a72704b 10990 value = perform_integral_promotions (value);
58595203
MM
10991 constant_expression_warning (value);
10992 }
10993 else
10994 {
253e0d15 10995 error ("enumerator value for %qD is not an integer constant", name);
58595203
MM
10996 value = NULL_TREE;
10997 }
10998 }
10999
11000 /* Default based on previous value. */
6a540f3c 11001 if (value == NULL_TREE)
58595203 11002 {
58595203
MM
11003 if (TYPE_VALUES (enumtype))
11004 {
ff4eb0b5
ZW
11005 HOST_WIDE_INT hi;
11006 unsigned HOST_WIDE_INT lo;
11007 tree prev_value;
11008 bool overflowed;
11009
11010 /* The next value is the previous value plus one. We can
0cbd7506 11011 safely assume that the previous value is an INTEGER_CST.
ff4eb0b5
ZW
11012 add_double doesn't know the type of the target expression,
11013 so we must check with int_fits_type_p as well. */
58595203 11014 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
ff4eb0b5
ZW
11015 overflowed = add_double (TREE_INT_CST_LOW (prev_value),
11016 TREE_INT_CST_HIGH (prev_value),
11017 1, 0, &lo, &hi);
11018 value = build_int_cst_wide (TREE_TYPE (prev_value), lo, hi);
11019 overflowed |= !int_fits_type_p (value, TREE_TYPE (prev_value));
68642fb6 11020
ff4eb0b5 11021 if (overflowed)
3c955a04
MM
11022 {
11023 error ("overflow in enumeration values at %qD", name);
11024 value = error_mark_node;
11025 }
58595203
MM
11026 }
11027 else
11028 value = integer_zero_node;
11029 }
11030
11031 /* Remove no-op casts from the value. */
f5d70cc0 11032 STRIP_TYPE_NOPS (value);
58595203 11033 }
8d08fdba 11034
8d08fdba 11035 /* C++ associates enums with global, function, or class declarations. */
58595203
MM
11036 context = current_scope ();
11037
11038 /* Build the actual enumeration constant. Note that the enumeration
11039 constants have the type of their initializers until the
11040 enumeration is complete:
11041
11042 [ dcl.enum ]
11043
11044 Following the closing brace of an enum-specifier, each enumer-
11045 ator has the type of its enumeration. Prior to the closing
11046 brace, the type of each enumerator is the type of its
11047 initializing value.
11048
11049 In finish_enum we will reset the type. Of course, if we're
a1c65f9f 11050 processing a template, there may be no value. */
58595203
MM
11051 type = value ? TREE_TYPE (value) : NULL_TREE;
11052
11053 if (context && context == current_class_type)
11054 /* This enum declaration is local to the class. We need the full
8f17b5c5 11055 lang_decl so that we can record DECL_CLASS_CONTEXT, for example. */
58595203
MM
11056 decl = build_lang_decl (CONST_DECL, name, type);
11057 else
11058 /* It's a global enum, or it's local to a function. (Note local to
e8bd800e 11059 a function could mean local to a class method. */
58595203 11060 decl = build_decl (CONST_DECL, name, type);
e8bd800e 11061
58595203 11062 DECL_CONTEXT (decl) = FROB_CONTEXT (context);
6de9cd9a 11063 TREE_CONSTANT (decl) = 1;
6de9cd9a 11064 TREE_READONLY (decl) = 1;
58595203 11065 DECL_INITIAL (decl) = value;
e8bd800e 11066
58595203
MM
11067 if (context && context == current_class_type)
11068 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
7b6d72fc
MM
11069 on the TYPE_FIELDS list for `S'. (That's so that you can say
11070 things like `S::i' later.) */
58595203
MM
11071 finish_member_declaration (decl);
11072 else
9780c24f 11073 pushdecl (decl);
58595203
MM
11074
11075 /* Add this enumeration constant to the list for this type. */
11076 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
8d08fdba
MS
11077}
11078
8d08fdba 11079\f
a8f73d4b
MM
11080/* We're defining DECL. Make sure that it's type is OK. */
11081
11082static void
11f6b451 11083check_function_type (tree decl, tree current_function_parms)
a8f73d4b
MM
11084{
11085 tree fntype = TREE_TYPE (decl);
d0f062fb 11086 tree return_type = complete_type (TREE_TYPE (fntype));
a8f73d4b
MM
11087
11088 /* In a function definition, arg types must be complete. */
11089 require_complete_types_for_parms (current_function_parms);
11090
c9387915
GB
11091 if (dependent_type_p (return_type))
11092 return;
360f866c 11093 if (!COMPLETE_OR_VOID_TYPE_P (return_type)
9e1e64ec 11094 || (TYPE_FOR_JAVA (return_type) && MAYBE_CLASS_TYPE_P (return_type)))
a8f73d4b 11095 {
51b15ede 11096 tree args = TYPE_ARG_TYPES (fntype);
3db45ab5 11097
360f866c
JJ
11098 if (!COMPLETE_OR_VOID_TYPE_P (return_type))
11099 error ("return type %q#T is incomplete", return_type);
11100 else
11101 error ("return type has Java class type %q#T", return_type);
a8f73d4b 11102
51b15ede 11103 /* Make it return void instead. */
a8f73d4b 11104 if (TREE_CODE (fntype) == METHOD_TYPE)
51b15ede
NS
11105 fntype = build_method_type_directly (TREE_TYPE (TREE_VALUE (args)),
11106 void_type_node,
11107 TREE_CHAIN (args));
a8f73d4b 11108 else
51b15ede 11109 fntype = build_function_type (void_type_node, args);
68642fb6 11110 TREE_TYPE (decl)
a8f73d4b 11111 = build_exception_variant (fntype,
51b15ede 11112 TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)));
a8f73d4b
MM
11113 }
11114 else
11115 abstract_virtuals_error (decl, TREE_TYPE (fntype));
11116}
11117
8d08fdba
MS
11118/* Create the FUNCTION_DECL for a function definition.
11119 DECLSPECS and DECLARATOR are the parts of the declaration;
11120 they describe the function's name and the type it returns,
11121 but twisted together in a fashion that parallels the syntax of C.
11122
a8f73d4b
MM
11123 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
11124 DECLARATOR is really the DECL for the function we are about to
11125 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
f444e36b 11126 indicating that the function is an inline defined in-class.
68642fb6 11127
8d08fdba
MS
11128 This function creates a binding context for the function body
11129 as well as setting up the FUNCTION_DECL in current_function_decl.
11130
8d08fdba
MS
11131 For C++, we must first check whether that datum makes any sense.
11132 For example, "class A local_a(1,2);" means that variable local_a
11133 is an aggregate of type A, which should have a constructor
72c4a4ca
GK
11134 applied to it with the argument list [1, 2].
11135
11136 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
11137 or may be a BLOCK if the function has been defined previously
11138 in this translation unit. On exit, DECL_INITIAL (decl1) will be
11139 error_mark_node if the function has never been defined, or
11140 a BLOCK if the function has been defined somewhere. */
8d08fdba 11141
058b15c1
MM
11142void
11143start_preparsed_function (tree decl1, tree attrs, int flags)
8d08fdba 11144{
8d08fdba
MS
11145 tree ctype = NULL_TREE;
11146 tree fntype;
11147 tree restype;
8d08fdba 11148 int doing_friend = 0;
e2500fed 11149 struct cp_binding_level *bl;
f444e36b 11150 tree current_function_parms;
3e3935a9 11151 struct c_fileinfo *finfo
c533e34d 11152 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1)));
1ef0df47 11153 bool honor_interface;
8d08fdba 11154
8d08fdba 11155 /* Sanity check. */
50bc768d
NS
11156 gcc_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE);
11157 gcc_assert (TREE_CHAIN (void_list_node) == NULL_TREE);
8d08fdba 11158
058b15c1
MM
11159 fntype = TREE_TYPE (decl1);
11160 if (TREE_CODE (fntype) == METHOD_TYPE)
11161 ctype = TYPE_METHOD_BASETYPE (fntype);
caf93cb0 11162
058b15c1
MM
11163 /* ISO C++ 11.4/5. A friend function defined in a class is in
11164 the (lexical) scope of the class in which it is defined. */
11165 if (!ctype && DECL_FRIEND_P (decl1))
8d08fdba 11166 {
058b15c1 11167 ctype = DECL_FRIEND_CONTEXT (decl1);
caf93cb0 11168
058b15c1
MM
11169 /* CTYPE could be null here if we're dealing with a template;
11170 for example, `inline friend float foo()' inside a template
11171 will have no CTYPE set. */
11172 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
11173 ctype = NULL_TREE;
11174 else
11175 doing_friend = 1;
8d08fdba 11176 }
68642fb6 11177
97055d5c
AO
11178 if (DECL_DECLARED_INLINE_P (decl1)
11179 && lookup_attribute ("noinline", attrs))
dee15844 11180 warning (0, "inline function %q+D given attribute noinline", decl1);
97055d5c 11181
3a47c4e4
AO
11182 /* Handle gnu_inline attribute. */
11183 if (GNU_INLINE_P (decl1))
11184 {
11185 DECL_EXTERNAL (decl1) = 1;
11186 DECL_NOT_REALLY_EXTERN (decl1) = 0;
11187 DECL_INTERFACE_KNOWN (decl1) = 1;
12cdc4fa 11188 DECL_DISREGARD_INLINE_LIMITS (decl1) = 1;
3a47c4e4
AO
11189 }
11190
5f6eeeb3
NS
11191 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
11192 /* This is a constructor, we must ensure that any default args
11193 introduced by this definition are propagated to the clones
11194 now. The clones are used directly in overload resolution. */
11195 adjust_clone_args (decl1);
11196
b35d4555
MM
11197 /* Sometimes we don't notice that a function is a static member, and
11198 build a METHOD_TYPE for it. Fix that up now. */
11199 if (ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
11200 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE)
11201 {
3afb32a4 11202 revert_static_member_fn (decl1);
b35d4555
MM
11203 ctype = NULL_TREE;
11204 }
8d08fdba 11205
f181d4ae
MM
11206 /* Set up current_class_type, and enter the scope of the class, if
11207 appropriate. */
11208 if (ctype)
14d22dd6 11209 push_nested_class (ctype);
f181d4ae 11210 else if (DECL_STATIC_FUNCTION_P (decl1))
14d22dd6 11211 push_nested_class (DECL_CONTEXT (decl1));
f181d4ae
MM
11212
11213 /* Now that we have entered the scope of the class, we must restore
11214 the bindings for any template parameters surrounding DECL1, if it
11215 is an inline member template. (Order is important; consider the
11216 case where a template parameter has the same name as a field of
11217 the class.) It is not until after this point that
11218 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
a8f73d4b 11219 if (flags & SF_INCLASS_INLINE)
f181d4ae
MM
11220 maybe_begin_member_template_processing (decl1);
11221
56cb9733 11222 /* Effective C++ rule 15. */
9188c363 11223 if (warn_ecpp
596ea4e5 11224 && DECL_OVERLOADED_OPERATOR_P (decl1) == NOP_EXPR
9188c363 11225 && TREE_CODE (TREE_TYPE (fntype)) == VOID_TYPE)
b323323f 11226 warning (OPT_Weffc__, "%<operator=%> should return a reference to %<*this%>");
9188c363
MM
11227
11228 /* Make the init_value nonzero so pushdecl knows this is not tentative.
11229 error_mark_node is replaced below (in poplevel) with the BLOCK. */
b35d4555
MM
11230 if (!DECL_INITIAL (decl1))
11231 DECL_INITIAL (decl1) = error_mark_node;
9188c363 11232
9188c363
MM
11233 /* This function exists in static storage.
11234 (This does not mean `static' in the C sense!) */
11235 TREE_STATIC (decl1) = 1;
11236
11237 /* We must call push_template_decl after current_class_type is set
11238 up. (If we are processing inline definitions after exiting a
11239 class scope, current_class_type will be NULL_TREE until set above
11240 by push_nested_class.) */
11241 if (processing_template_decl)
11e97737
VR
11242 {
11243 /* FIXME: Handle error_mark_node more gracefully. */
11244 tree newdecl1 = push_template_decl (decl1);
11245 if (newdecl1 != error_mark_node)
0cbd7506 11246 decl1 = newdecl1;
11e97737 11247 }
9188c363 11248
f181d4ae 11249 /* We are now in the scope of the function being defined. */
8d08fdba 11250 current_function_decl = decl1;
f181d4ae 11251
5566b478
MS
11252 /* Save the parm names or decls from this function's declarator
11253 where store_parm_decls will find them. */
4546865e 11254 current_function_parms = DECL_ARGUMENTS (decl1);
8d08fdba 11255
a8f73d4b
MM
11256 /* Make sure the parameter and return types are reasonable. When
11257 you declare a function, these types can be incomplete, but they
11258 must be complete when you define the function. */
c9387915 11259 check_function_type (decl1, current_function_parms);
f181d4ae 11260
a8f73d4b
MM
11261 /* Build the return declaration for the function. */
11262 restype = TREE_TYPE (fntype);
e89a6075 11263 if (DECL_RESULT (decl1) == NULL_TREE)
a8f73d4b 11264 {
b785f485
RH
11265 tree resdecl;
11266
11267 resdecl = build_decl (RESULT_DECL, 0, TYPE_MAIN_VARIANT (restype));
11268 DECL_ARTIFICIAL (resdecl) = 1;
11269 DECL_IGNORED_P (resdecl) = 1;
11270 DECL_RESULT (decl1) = resdecl;
11271
9804209d 11272 cp_apply_type_quals_to_decl (cp_type_quals (restype), resdecl);
5566b478 11273 }
a8f73d4b 11274
a8f73d4b 11275 /* Let the user know we're compiling this function. */
ea11ca7e 11276 announce_function (decl1);
b7484fbe 11277
878cd289
MS
11278 /* Record the decl so that the function name is defined.
11279 If we already have a decl for this name, and it is a FUNCTION_DECL,
11280 use the old decl. */
a8f73d4b 11281 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
878cd289 11282 {
75650646 11283 /* A specialization is not used to guide overload resolution. */
18f5be99 11284 if (!DECL_FUNCTION_MEMBER_P (decl1)
caf93cb0 11285 && !(DECL_USE_TEMPLATE (decl1) &&
18f5be99 11286 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1))))
b1a19c7c
MM
11287 {
11288 tree olddecl = pushdecl (decl1);
11289
11290 if (olddecl == error_mark_node)
11291 /* If something went wrong when registering the declaration,
11292 use DECL1; we have to have a FUNCTION_DECL to use when
11293 parsing the body of the function. */
11294 ;
11295 else
dfdec7a7
ILT
11296 {
11297 /* Otherwise, OLDDECL is either a previous declaration
11298 of the same function or DECL1 itself. */
11299
11300 if (warn_missing_declarations
11301 && olddecl == decl1
11302 && !DECL_MAIN_P (decl1)
11303 && TREE_PUBLIC (decl1)
11304 && !DECL_DECLARED_INLINE_P (decl1))
11305 {
11306 tree context;
11307
11308 /* Check whether DECL1 is in an anonymous
11309 namespace. */
11310 for (context = DECL_CONTEXT (decl1);
11311 context;
11312 context = DECL_CONTEXT (context))
11313 {
11314 if (TREE_CODE (context) == NAMESPACE_DECL
11315 && DECL_NAME (context) == NULL_TREE)
11316 break;
11317 }
11318
11319 if (context == NULL)
11320 warning (OPT_Wmissing_declarations,
11321 "no previous declaration for %q+D", decl1);
11322 }
11323
11324 decl1 = olddecl;
11325 }
b1a19c7c 11326 }
2c73f9f5 11327 else
b7698cf0 11328 {
a1c65f9f 11329 /* We need to set the DECL_CONTEXT. */
b7698cf0
JM
11330 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
11331 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
b7698cf0 11332 }
878cd289 11333 fntype = TREE_TYPE (decl1);
2ef06beb
MM
11334
11335 /* If #pragma weak applies, mark the decl appropriately now.
11336 The pragma only applies to global functions. Because
11337 determining whether or not the #pragma applies involves
11338 computing the mangled name for the declaration, we cannot
11339 apply the pragma until after we have merged this declaration
11340 with any previous declarations; if the original declaration
11341 has a linkage specification, that specification applies to
11342 the definition as well, and may affect the mangled name. */
11343 if (!DECL_CONTEXT (decl1))
11344 maybe_apply_pragma_weak (decl1);
878cd289 11345 }
5566b478 11346
72c4a4ca 11347 /* Reset this in case the call to pushdecl changed it. */
5566b478 11348 current_function_decl = decl1;
72c4a4ca
GK
11349
11350 gcc_assert (DECL_INITIAL (decl1));
11351
11352 /* This function may already have been parsed, in which case just
11353 return; our caller will skip over the body without parsing. */
11354 if (DECL_INITIAL (decl1) != error_mark_node)
11355 return;
11356
11357 /* Initialize RTL machinery. We cannot do this until
11358 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
11359 even when processing a template; this is how we get
11360 CFUN set up, and our per-function variables initialized.
11361 FIXME factor out the non-RTL stuff. */
11362 bl = current_binding_level;
182e0d71 11363 allocate_struct_function (decl1, processing_template_decl);
e8924938
PB
11364
11365 /* Initialize the language data structures. Whenever we start
11366 a new function, we destroy temporaries in the usual way. */
11367 cfun->language = GGC_CNEW (struct language_function);
11368 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
72c4a4ca
GK
11369 current_binding_level = bl;
11370
11371 /* Even though we're inside a function body, we still don't want to
11372 call expand_expr to calculate the size of a variable-sized array.
11373 We haven't necessarily assigned RTL to all variables yet, so it's
11374 not safe to try to expand expressions involving them. */
e3b5732b 11375 cfun->dont_save_pending_sizes_p = 1;
72c4a4ca
GK
11376
11377 /* Start the statement-tree, start the tree now. */
11378 DECL_SAVED_TREE (decl1) = push_stmt_list ();
878cd289 11379
78c120b5
MM
11380 /* If we are (erroneously) defining a function that we have already
11381 defined before, wipe out what we knew before. */
e2500fed
GK
11382 if (!DECL_PENDING_INLINE_P (decl1))
11383 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
b35d4555 11384
f444e36b 11385 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
b35d4555
MM
11386 {
11387 /* We know that this was set up by `grokclassfn'. We do not
11388 wait until `store_parm_decls', since evil parse errors may
11389 never get us to that point. Here we keep the consistency
11390 between `current_class_type' and `current_class_ptr'. */
11391 tree t = DECL_ARGUMENTS (decl1);
68642fb6 11392
50bc768d
NS
11393 gcc_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL);
11394 gcc_assert (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE);
68642fb6
UD
11395
11396 cp_function_chain->x_current_class_ref
5ade1ed2 11397 = cp_build_indirect_ref (t, NULL, tf_warning_or_error);
b35d4555
MM
11398 cp_function_chain->x_current_class_ptr = t;
11399
018fc244
MM
11400 /* Constructors and destructors need to know whether they're "in
11401 charge" of initializing virtual base classes. */
e0fff4b3 11402 t = TREE_CHAIN (t);
454fa7a7 11403 if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
e0fff4b3
JM
11404 {
11405 current_in_charge_parm = t;
11406 t = TREE_CHAIN (t);
11407 }
11408 if (DECL_HAS_VTT_PARM_P (decl1))
11409 {
8dc2b103 11410 gcc_assert (DECL_NAME (t) == vtt_parm_identifier);
e0fff4b3
JM
11411 current_vtt_parm = t;
11412 }
b35d4555
MM
11413 }
11414
1ef0df47
MM
11415 honor_interface = (!DECL_TEMPLATE_INSTANTIATION (decl1)
11416 /* Implicitly-defined methods (like the
11417 destructor for a class in which no destructor
11418 is explicitly declared) must not be defined
11419 until their definition is needed. So, we
11420 ignore interface specifications for
11421 compiler-generated functions. */
11422 && !DECL_ARTIFICIAL (decl1));
3db45ab5 11423
db5ae43f 11424 if (DECL_INTERFACE_KNOWN (decl1))
faae18ab 11425 {
4f1c5b7d 11426 tree ctx = decl_function_context (decl1);
86052cc3 11427
faae18ab
MS
11428 if (DECL_NOT_REALLY_EXTERN (decl1))
11429 DECL_EXTERNAL (decl1) = 0;
86052cc3 11430
79065db2 11431 if (ctx != NULL_TREE && DECL_DECLARED_INLINE_P (ctx)
86052cc3
JM
11432 && TREE_PUBLIC (ctx))
11433 /* This is a function in a local class in an extern inline
11434 function. */
11435 comdat_linkage (decl1);
faae18ab 11436 }
8d08fdba
MS
11437 /* If this function belongs to an interface, it is public.
11438 If it belongs to someone else's interface, it is also external.
1f901793 11439 This only affects inlines and template instantiations. */
1ef0df47 11440 else if (!finfo->interface_unknown && honor_interface)
8d08fdba 11441 {
caf93cb0 11442 if (DECL_DECLARED_INLINE_P (decl1)
79065db2 11443 || DECL_TEMPLATE_INSTANTIATION (decl1)
5156628f 11444 || processing_template_decl)
1f901793
JM
11445 {
11446 DECL_EXTERNAL (decl1)
5d709b00 11447 = (finfo->interface_only
caf93cb0 11448 || (DECL_DECLARED_INLINE_P (decl1)
79065db2 11449 && ! flag_implement_inlines
9c73ec84 11450 && !DECL_VINDEX (decl1)));
1f901793
JM
11451
11452 /* For WIN32 we also want to put these in linkonce sections. */
11453 maybe_make_one_only (decl1);
11454 }
db5ae43f 11455 else
893de33c 11456 DECL_EXTERNAL (decl1) = 0;
db5ae43f 11457 DECL_INTERFACE_KNOWN (decl1) = 1;
4684cd27 11458 /* If this function is in an interface implemented in this file,
3b426391 11459 make sure that the back end knows to emit this function
4684cd27
MM
11460 here. */
11461 if (!DECL_EXTERNAL (decl1))
11462 mark_needed (decl1);
8d08fdba 11463 }
5d709b00 11464 else if (finfo->interface_unknown && finfo->interface_only
1ef0df47 11465 && honor_interface)
c16c47fb
JM
11466 {
11467 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
5d709b00
ZW
11468 interface, we will have both finfo->interface_unknown and
11469 finfo->interface_only set. In that case, we don't want to
11470 use the normal heuristics because someone will supply a
11471 #pragma implementation elsewhere, and deducing it here would
11472 produce a conflict. */
c16c47fb
JM
11473 comdat_linkage (decl1);
11474 DECL_EXTERNAL (decl1) = 0;
11475 DECL_INTERFACE_KNOWN (decl1) = 1;
11476 DECL_DEFER_OUTPUT (decl1) = 1;
11477 }
8d08fdba 11478 else
a0a33927
MS
11479 {
11480 /* This is a definition, not a reference.
3a47c4e4
AO
11481 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
11482 if (!GNU_INLINE_P (decl1))
11483 DECL_EXTERNAL (decl1) = 0;
faae18ab 11484
caf93cb0 11485 if ((DECL_DECLARED_INLINE_P (decl1)
79065db2 11486 || DECL_TEMPLATE_INSTANTIATION (decl1))
5566b478
MS
11487 && ! DECL_INTERFACE_KNOWN (decl1)
11488 /* Don't try to defer nested functions for now. */
4f1c5b7d 11489 && ! decl_function_context (decl1))
878cd289
MS
11490 DECL_DEFER_OUTPUT (decl1) = 1;
11491 else
893de33c 11492 DECL_INTERFACE_KNOWN (decl1) = 1;
db5ae43f 11493 }
a9aedbc2 11494
0ed5edac
JM
11495 /* Determine the ELF visibility attribute for the function. We must not
11496 do this before calling "pushdecl", as we must allow "duplicate_decls"
11497 to merge any attributes appropriately. We also need to wait until
11498 linkage is set. */
11499 if (!DECL_CLONED_FUNCTION_P (decl1))
11500 determine_visibility (decl1);
11501
ac20c67a 11502 begin_scope (sk_function_parms, decl1);
8d08fdba 11503
5566b478
MS
11504 ++function_depth;
11505
44d10c10
PB
11506 if (DECL_DESTRUCTOR_P (decl1)
11507 || (DECL_CONSTRUCTOR_P (decl1)
11508 && targetm.cxx.cdtor_returns_this ()))
46e8c075 11509 {
44d10c10
PB
11510 cdtor_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
11511 DECL_CONTEXT (cdtor_label) = current_function_decl;
46e8c075 11512 }
8d08fdba 11513
0ba8a114 11514 start_fname_decls ();
caf93cb0 11515
f444e36b 11516 store_parm_decls (current_function_parms);
058b15c1
MM
11517}
11518
11519
11520/* Like start_preparsed_function, except that instead of a
11521 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
11522
11523 Returns 1 on success. If the DECLARATOR is not suitable for a function
11524 (it defines a datum instead), we return 0, which tells
11525 yyparse to report a parse error. */
11526
11527int
caf93cb0 11528start_function (cp_decl_specifier_seq *declspecs,
62d1db17 11529 const cp_declarator *declarator,
058b15c1
MM
11530 tree attrs)
11531{
11532 tree decl1;
11533
058b15c1
MM
11534 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
11535 /* If the declarator is not suitable for a function definition,
11536 cause a syntax error. */
11537 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
11538 return 0;
caf93cb0 11539
058b15c1 11540 if (DECL_MAIN_P (decl1))
2cfe82fe
ZW
11541 /* main must return int. grokfndecl should have corrected it
11542 (and issued a diagnostic) if the user got it wrong. */
11543 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1)),
11544 integer_type_node));
058b15c1
MM
11545
11546 start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT);
f444e36b 11547
8d08fdba
MS
11548 return 1;
11549}
11550\f
68d04c67
MM
11551/* Returns true iff an EH_SPEC_BLOCK should be created in the body of
11552 FN. */
11553
11554static bool
11555use_eh_spec_block (tree fn)
11556{
11557 return (flag_exceptions && flag_enforce_eh_specs
11558 && !processing_template_decl
11559 && TYPE_RAISES_EXCEPTIONS (TREE_TYPE (fn))
11560 /* We insert the EH_SPEC_BLOCK only in the original
11561 function; then, it is copied automatically to the
11562 clones. */
11563 && !DECL_CLONED_FUNCTION_P (fn)
11564 /* Implicitly-generated constructors and destructors have
11565 exception specifications. However, those specifications
11566 are the union of the possible exceptions specified by the
11567 constructors/destructors for bases and members, so no
11568 unallowed exception will ever reach this function. By
11569 not creating the EH_SPEC_BLOCK we save a little memory,
11570 and we avoid spurious warnings about unreachable
11571 code. */
11572 && !DECL_ARTIFICIAL (fn));
11573}
11574
8d08fdba
MS
11575/* Store the parameter declarations into the current function declaration.
11576 This is called after parsing the parameter declarations, before
11577 digesting the body of the function.
11578
11579 Also install to binding contour return value identifier, if any. */
11580
f444e36b 11581static void
11f6b451 11582store_parm_decls (tree current_function_parms)
8d08fdba 11583{
926ce8bd
KH
11584 tree fndecl = current_function_decl;
11585 tree parm;
8d08fdba 11586
8d08fdba
MS
11587 /* This is a chain of any other decls that came in among the parm
11588 declarations. If a parm is declared with enum {foo, bar} x;
11589 then CONST_DECLs for foo and bar are put here. */
11590 tree nonparms = NULL_TREE;
11591
b35d4555 11592 if (current_function_parms)
8d08fdba
MS
11593 {
11594 /* This case is when the function was defined with an ANSI prototype.
11595 The parms already have decls, so we need not do anything here
11596 except record them as in effect
11597 and complain if any redundant old-style parm decls were written. */
11598
b35d4555
MM
11599 tree specparms = current_function_parms;
11600 tree next;
11601
f444e36b 11602 /* Must clear this because it might contain TYPE_DECLs declared
b35d4555 11603 at class level. */
00e8de68 11604 current_binding_level->names = NULL;
8d08fdba 11605
f444e36b 11606 /* If we're doing semantic analysis, then we'll call pushdecl
b35d4555
MM
11607 for each of these. We must do them in reverse order so that
11608 they end in the correct forward order. */
f444e36b 11609 specparms = nreverse (specparms);
5566b478 11610
b35d4555 11611 for (parm = specparms; parm; parm = next)
8d08fdba
MS
11612 {
11613 next = TREE_CHAIN (parm);
11614 if (TREE_CODE (parm) == PARM_DECL)
11615 {
f444e36b
MM
11616 if (DECL_NAME (parm) == NULL_TREE
11617 || TREE_CODE (parm) != VOID_TYPE)
11618 pushdecl (parm);
11619 else
2d01edd7 11620 error ("parameter %qD declared void", parm);
8d08fdba
MS
11621 }
11622 else
11623 {
11624 /* If we find an enum constant or a type tag,
11625 put it aside for the moment. */
11626 TREE_CHAIN (parm) = NULL_TREE;
11627 nonparms = chainon (nonparms, parm);
11628 }
11629 }
11630
f444e36b
MM
11631 /* Get the decls in their original chain order and record in the
11632 function. This is all and only the PARM_DECLs that were
11633 pushed into scope by the loop above. */
11634 DECL_ARGUMENTS (fndecl) = getdecls ();
8d08fdba
MS
11635 }
11636 else
11637 DECL_ARGUMENTS (fndecl) = NULL_TREE;
11638
11639 /* Now store the final chain of decls for the arguments
11640 as the decl-chain of the current lexical scope.
11641 Put the enumerators in as well, at the front so that
11642 DECL_ARGUMENTS is not modified. */
00e8de68 11643 current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));
eb448459 11644
68d04c67
MM
11645 if (use_eh_spec_block (current_function_decl))
11646 current_eh_spec_block = begin_eh_spec_block ();
8d08fdba
MS
11647}
11648
8d08fdba 11649\f
59026e79
MM
11650/* We have finished doing semantic analysis on DECL, but have not yet
11651 generated RTL for its body. Save away our current state, so that
11652 when we want to generate RTL later we know what to do. */
11653
11654static void
11f6b451 11655save_function_data (tree decl)
59026e79 11656{
e2500fed 11657 struct language_function *f;
59026e79
MM
11658
11659 /* Save the language-specific per-function data so that we can
11660 get it back when we really expand this function. */
50bc768d 11661 gcc_assert (!DECL_PENDING_INLINE_P (decl));
68642fb6 11662
59026e79 11663 /* Make a copy. */
99dd239f 11664 f = GGC_NEW (struct language_function);
e2500fed 11665 memcpy (f, cp_function_chain, sizeof (struct language_function));
59026e79
MM
11666 DECL_SAVED_FUNCTION_DATA (decl) = f;
11667
11668 /* Clear out the bits we don't need. */
325c3691 11669 f->base.x_stmt_tree.x_cur_stmt_list = NULL_TREE;
59026e79 11670 f->bindings = NULL;
8e4ce833 11671 f->x_local_names = NULL;
59026e79
MM
11672}
11673
cdd2559c 11674
44d10c10 11675/* Set the return value of the constructor (if present). */
efee38a9
MM
11676
11677static void
11f6b451 11678finish_constructor_body (void)
efee38a9 11679{
44d10c10
PB
11680 tree val;
11681 tree exprstmt;
11682
298b7d2b
AH
11683 if (targetm.cxx.cdtor_returns_this ()
11684 && (! TYPE_FOR_JAVA (current_class_type)))
44d10c10
PB
11685 {
11686 /* Any return from a constructor will end up here. */
11687 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
11688
11689 val = DECL_ARGUMENTS (current_function_decl);
f293ce4b
RS
11690 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
11691 DECL_RESULT (current_function_decl), val);
44d10c10
PB
11692 /* Return the address of the object. */
11693 exprstmt = build_stmt (RETURN_EXPR, val);
11694 add_stmt (exprstmt);
11695 }
efee38a9
MM
11696}
11697
cdd2559c
JM
11698/* Do all the processing for the beginning of a destructor; set up the
11699 vtable pointers and cleanups for bases and members. */
11700
11701static void
11f6b451 11702begin_destructor_body (void)
cdd2559c 11703{
cdd2559c
JM
11704 tree compound_stmt;
11705
0e686aa6
MM
11706 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
11707 issued an error message. We still want to try to process the
11708 body of the function, but initialize_vtbl_ptrs will crash if
11709 TYPE_BINFO is NULL. */
11710 if (COMPLETE_TYPE_P (current_class_type))
11711 {
11712 compound_stmt = begin_compound_stmt (0);
11713 /* Make all virtual function table pointers in non-virtual base
11714 classes point to CURRENT_CLASS_TYPE's virtual function
11715 tables. */
11716 initialize_vtbl_ptrs (current_class_ptr);
11717 finish_compound_stmt (compound_stmt);
3db45ab5 11718
0e686aa6
MM
11719 /* And insert cleanups for our bases and members so that they
11720 will be properly destroyed if we throw. */
11721 push_base_cleanups ();
11722 }
cdd2559c
JM
11723}
11724
ade3dc07
JM
11725/* At the end of every destructor we generate code to delete the object if
11726 necessary. Do that now. */
9bfadf57
MM
11727
11728static void
11f6b451 11729finish_destructor_body (void)
9bfadf57 11730{
9bfadf57
MM
11731 tree exprstmt;
11732
5633b37c
MM
11733 /* Any return from a destructor will end up here; that way all base
11734 and member cleanups will be run when the function returns. */
44d10c10 11735 add_stmt (build_stmt (LABEL_EXPR, cdtor_label));
5633b37c 11736
52682a1b
MM
11737 /* In a virtual destructor, we must call delete. */
11738 if (DECL_VIRTUAL_P (current_function_decl))
11739 {
11740 tree if_stmt;
fa72b064 11741 tree virtual_size = cxx_sizeof (current_class_type);
68642fb6 11742
52682a1b 11743 /* [class.dtor]
68642fb6 11744
ade3dc07
JM
11745 At the point of definition of a virtual destructor (including
11746 an implicit definition), non-placement operator delete shall
11747 be looked up in the scope of the destructor's class and if
11748 found shall be accessible and unambiguous. */
3db45ab5 11749 exprstmt = build_op_delete_call(DELETE_EXPR, current_class_ptr,
63c9a190 11750 virtual_size,
3db45ab5
MS
11751 /*global_p=*/false,
11752 /*placement=*/NULL_TREE,
63c9a190 11753 /*alloc_fn=*/NULL_TREE);
298d6f60 11754
52682a1b 11755 if_stmt = begin_if_stmt ();
f293ce4b
RS
11756 finish_if_stmt_cond (build2 (BIT_AND_EXPR, integer_type_node,
11757 current_in_charge_parm,
11758 integer_one_node),
52682a1b
MM
11759 if_stmt);
11760 finish_expr_stmt (exprstmt);
11761 finish_then_clause (if_stmt);
325c3691 11762 finish_if_stmt (if_stmt);
52682a1b 11763 }
44d10c10
PB
11764
11765 if (targetm.cxx.cdtor_returns_this ())
11766 {
11767 tree val;
11768
11769 val = DECL_ARGUMENTS (current_function_decl);
f293ce4b
RS
11770 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
11771 DECL_RESULT (current_function_decl), val);
44d10c10
PB
11772 /* Return the address of the object. */
11773 exprstmt = build_stmt (RETURN_EXPR, val);
11774 add_stmt (exprstmt);
11775 }
ade3dc07 11776}
9bfadf57 11777
ade3dc07
JM
11778/* Do the necessary processing for the beginning of a function body, which
11779 in this case includes member-initializers, but not the catch clauses of
11780 a function-try-block. Currently, this means opening a binding level
86ad3aa9 11781 for the member-initializers (in a ctor) and member cleanups (in a dtor). */
ade3dc07
JM
11782
11783tree
11f6b451 11784begin_function_body (void)
ade3dc07 11785{
cdd2559c
JM
11786 tree stmt;
11787
86ad3aa9
JM
11788 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
11789 return NULL_TREE;
11790
b5856475
JM
11791 if (processing_template_decl)
11792 /* Do nothing now. */;
11793 else
11794 /* Always keep the BLOCK node associated with the outermost pair of
11795 curly braces of a function. These are needed for correct
11796 operation of dwarfout.c. */
ac20c67a 11797 keep_next_level (true);
b5856475 11798
325c3691 11799 stmt = begin_compound_stmt (BCS_FN_BODY);
cdd2559c
JM
11800
11801 if (processing_template_decl)
11802 /* Do nothing now. */;
cdd2559c
JM
11803 else if (DECL_DESTRUCTOR_P (current_function_decl))
11804 begin_destructor_body ();
11805
ade3dc07 11806 return stmt;
9bfadf57
MM
11807}
11808
ade3dc07
JM
11809/* Do the processing for the end of a function body. Currently, this means
11810 closing out the cleanups for fully-constructed bases and members, and in
11811 the case of the destructor, deleting the object if desired. Again, this
11812 is only meaningful for [cd]tors, since they are the only functions where
11813 there is a significant distinction between the main body and any
11814 function catch clauses. Handling, say, main() return semantics here
11815 would be wrong, as flowing off the end of a function catch clause for
11816 main() would also need to return 0. */
11817
11818void
11f6b451 11819finish_function_body (tree compstmt)
ade3dc07 11820{
86ad3aa9
JM
11821 if (compstmt == NULL_TREE)
11822 return;
3db45ab5 11823
5633b37c 11824 /* Close the block. */
7a3397c7 11825 finish_compound_stmt (compstmt);
ade3dc07
JM
11826
11827 if (processing_template_decl)
11828 /* Do nothing now. */;
11829 else if (DECL_CONSTRUCTOR_P (current_function_decl))
11830 finish_constructor_body ();
11831 else if (DECL_DESTRUCTOR_P (current_function_decl))
11832 finish_destructor_body ();
caf93cb0 11833}
ade3dc07 11834
86ad3aa9
JM
11835/* Given a function, returns the BLOCK corresponding to the outermost level
11836 of curly braces, skipping the artificial block created for constructor
11837 initializers. */
11838
a68ab351 11839tree
86ad3aa9
JM
11840outer_curly_brace_block (tree fndecl)
11841{
11842 tree block = BLOCK_SUBBLOCKS (DECL_INITIAL (fndecl));
11843 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
11844 /* Skip the artificial function body block. */
11845 block = BLOCK_SUBBLOCKS (block);
11846 return block;
11847}
11848
8d08fdba
MS
11849/* Finish up a function declaration and compile that function
11850 all the way to assembler language output. The free the storage
11851 for the function definition.
11852
68642fb6 11853 FLAGS is a bitwise or of the following values:
f181d4ae
MM
11854 2 - INCLASS_INLINE
11855 We just finished processing the body of an in-class inline
11856 function definition. (This processing will have taken place
87e3dbc9 11857 after the class definition is complete.) */
8d08fdba 11858
4d6abc1c 11859tree
11f6b451 11860finish_function (int flags)
8d08fdba 11861{
926ce8bd 11862 tree fndecl = current_function_decl;
8d08fdba 11863 tree fntype, ctype = NULL_TREE;
f181d4ae 11864 int inclass_inline = (flags & 2) != 0;
87e3dbc9 11865 int nested;
8d08fdba
MS
11866
11867 /* When we get some parse errors, we can end up without a
11868 current_function_decl, so cope. */
11869 if (fndecl == NULL_TREE)
4d6abc1c 11870 return error_mark_node;
8d08fdba 11871
9aad8f83
MA
11872 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
11873 && DECL_VIRTUAL_P (fndecl)
11874 && !processing_template_decl)
11875 {
11876 tree fnclass = DECL_CONTEXT (fndecl);
11877 if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
11878 keyed_classes = tree_cons (NULL_TREE, fnclass, keyed_classes);
11879 }
11880
87e3dbc9 11881 nested = function_depth > 1;
8d08fdba
MS
11882 fntype = TREE_TYPE (fndecl);
11883
9bfadf57
MM
11884 /* TREE_READONLY (fndecl) = 1;
11885 This caused &foo to be of type ptr-to-const-function
11886 which then got a warning when stored in a ptr-to-function variable. */
8d08fdba 11887
50bc768d 11888 gcc_assert (building_stmt_tree ());
72c4a4ca
GK
11889 /* The current function is being defined, so its DECL_INITIAL should
11890 be set, and unless there's a multiple definition, it should be
11891 error_mark_node. */
11892 gcc_assert (DECL_INITIAL (fndecl) == error_mark_node);
caf93cb0 11893
db9b2174
MM
11894 /* For a cloned function, we've already got all the code we need;
11895 there's no need to add any extra bits. */
f444e36b 11896 if (!DECL_CLONED_FUNCTION_P (fndecl))
8d08fdba 11897 {
ade3dc07 11898 if (DECL_MAIN_P (current_function_decl))
efee38a9 11899 {
43e05e45
SB
11900 tree stmt;
11901
11902 /* Make it so that `main' always returns 0 by default (or
11903 1 for VMS). */
08c7ae5a 11904#if VMS_TARGET
43e05e45 11905 stmt = finish_return_stmt (integer_one_node);
efee38a9 11906#else
43e05e45 11907 stmt = finish_return_stmt (integer_zero_node);
efee38a9 11908#endif
43e05e45
SB
11909 /* Hack. We don't want the middle-end to warn that this
11910 return is unreachable, so put the statement on the
11911 special line 0. */
5ffeb913
TT
11912 {
11913 location_t linezero = linemap_line_start (line_table, 0, 1);
11914 SET_EXPR_LOCATION (stmt, linezero);
11915 }
efee38a9 11916 }
87e3dbc9 11917
68d04c67 11918 if (use_eh_spec_block (current_function_decl))
52a11cbf
RH
11919 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
11920 (TREE_TYPE (current_function_decl)),
11921 current_eh_spec_block);
5566b478 11922 }
68642fb6 11923
558475f0 11924 /* If we're saving up tree structure, tie off the function now. */
325c3691
RH
11925 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
11926
11927 finish_fname_decls ();
8d2733ca 11928
b2dd096b
MM
11929 /* If this function can't throw any exceptions, remember that. */
11930 if (!processing_template_decl
11931 && !cp_function_chain->can_throw
be0436d7 11932 && !flag_non_call_exceptions
56fd65c7 11933 && !DECL_REPLACEABLE_P (fndecl))
b2dd096b
MM
11934 TREE_NOTHROW (fndecl) = 1;
11935
8d08fdba
MS
11936 /* This must come after expand_function_end because cleanups might
11937 have declarations (from inline functions) that need to go into
11938 this function's blocks. */
caf93cb0 11939
7437519c
ZW
11940 /* If the current binding level isn't the outermost binding level
11941 for this function, either there is a bug, or we have experienced
11942 syntax errors and the statement tree is malformed. */
a7e8c268 11943 if (current_binding_level->kind != sk_function_parms)
7437519c
ZW
11944 {
11945 /* Make sure we have already experienced errors. */
8dc2b103 11946 gcc_assert (errorcount);
7437519c
ZW
11947
11948 /* Throw away the broken statement tree and extra binding
0cbd7506 11949 levels. */
5882f0f3 11950 DECL_SAVED_TREE (fndecl) = alloc_stmt_list ();
7437519c 11951
a7e8c268 11952 while (current_binding_level->kind != sk_function_parms)
7437519c 11953 {
a7e8c268 11954 if (current_binding_level->kind == sk_class)
7437519c
ZW
11955 pop_nested_class ();
11956 else
11957 poplevel (0, 0, 0);
11958 }
11959 }
f444e36b 11960 poplevel (1, 0, 1);
8d08fdba 11961
4985cde3
RH
11962 /* Statements should always be full-expressions at the outermost set
11963 of curly braces for a function. */
50bc768d 11964 gcc_assert (stmts_are_full_exprs_p ());
4985cde3 11965
6de9cd9a 11966 /* Set up the named return value optimization, if we can. Candidate
59fe9274 11967 variables are selected in check_return_expr. */
07b2f2fd
JM
11968 if (current_function_return_value)
11969 {
11970 tree r = current_function_return_value;
35e939ae
JM
11971 tree outer;
11972
07b2f2fd 11973 if (r != error_mark_node
35e939ae
JM
11974 /* This is only worth doing for fns that return in memory--and
11975 simpler, since we don't have to worry about promoted modes. */
61f71b34 11976 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
35e939ae
JM
11977 /* Only allow this for variables declared in the outer scope of
11978 the function so we know that their lifetime always ends with a
11979 return; see g++.dg/opt/nrv6.C. We could be more flexible if
11980 we were to do this optimization in tree-ssa. */
86ad3aa9 11981 && (outer = outer_curly_brace_block (fndecl))
325c3691 11982 && chain_member (r, BLOCK_VARS (outer)))
6de9cd9a
DN
11983 finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));
11984
11985 current_function_return_value = NULL_TREE;
07b2f2fd
JM
11986 }
11987
a8f73d4b 11988 /* Remember that we were in class scope. */
db5ae43f 11989 if (current_class_name)
a8f73d4b 11990 ctype = current_class_type;
db5ae43f 11991
1caa11d3
MM
11992 /* Must mark the RESULT_DECL as being in this function. */
11993 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
11994
11995 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
11996 to the FUNCTION_DECL node itself. */
11997 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
11998
59026e79 11999 /* Save away current state, if appropriate. */
f444e36b 12000 if (!processing_template_decl)
59026e79
MM
12001 save_function_data (fndecl);
12002
efe49da0 12003 /* Complain if there's just no return statement. */
46cfb101 12004 if (warn_return_type
efe49da0 12005 && TREE_CODE (TREE_TYPE (fntype)) != VOID_TYPE
c1b83cc9 12006 && !dependent_type_p (TREE_TYPE (fntype))
57d5032b 12007 && !current_function_returns_value && !current_function_returns_null
efe49da0
JM
12008 /* Don't complain if we abort or throw. */
12009 && !current_function_returns_abnormally
55e99d52 12010 && !DECL_NAME (DECL_RESULT (fndecl))
4847609e 12011 && !TREE_NO_WARNING (fndecl)
44d10c10
PB
12012 /* Structor return values (if any) are set by the compiler. */
12013 && !DECL_CONSTRUCTOR_P (fndecl)
12014 && !DECL_DESTRUCTOR_P (fndecl))
4847609e
JH
12015 {
12016 warning (OPT_Wreturn_type,
12017 "no return statement in function returning non-void");
12018 TREE_NO_WARNING (fndecl) = 1;
12019 }
4985cde3 12020
6de9cd9a
DN
12021 /* Store the end of the function, so that we get good line number
12022 info for the epilogue. */
12023 cfun->function_end_locus = input_location;
12024
12025 /* Genericize before inlining. */
12026 if (!processing_template_decl)
12027 {
37e6d6fe 12028 struct language_function *f = DECL_SAVED_FUNCTION_DATA (fndecl);
5a508662 12029 cp_genericize (fndecl);
37e6d6fe
JH
12030 /* Clear out the bits we don't need. */
12031 f->x_current_class_ptr = NULL;
12032 f->x_current_class_ref = NULL;
12033 f->x_eh_spec_block = NULL;
12034 f->x_in_charge_parm = NULL;
12035 f->x_vtt_parm = NULL;
12036 f->x_return_value = NULL;
12037 f->bindings = NULL;
10827cd8 12038 f->extern_decl_map = NULL;
6de9cd9a
DN
12039
12040 /* Handle attribute((warn_unused_result)). Relies on gimple input. */
726a989a 12041 c_warn_unused_result (gimple_body (fndecl));
6de9cd9a 12042 }
37e6d6fe
JH
12043 /* Clear out the bits we don't need. */
12044 local_names = NULL;
6de9cd9a
DN
12045
12046 /* We're leaving the context of this function, so zap cfun. It's still in
12047 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
db2960f4 12048 set_cfun (NULL);
c1f927e8 12049 current_function_decl = NULL;
a8f73d4b 12050
27631dae 12051 /* If this is an in-class inline definition, we may have to pop the
a8f73d4b
MM
12052 bindings for the template parameters that we added in
12053 maybe_begin_member_template_processing when start_function was
12054 called. */
12055 if (inclass_inline)
12056 maybe_end_member_template_processing ();
12057
12058 /* Leave the scope of the class. */
12059 if (ctype)
12060 pop_nested_class ();
5566b478
MS
12061
12062 --function_depth;
8d08fdba 12063
4d6abc1c 12064 /* Clean up. */
28cbf42c 12065 if (! nested)
1f8f4a0b
MM
12066 /* Let the error reporting routines know that we're outside a
12067 function. For a nested function, this value is used in
b03e38e1 12068 cxx_pop_function_context and then reset via pop_function_context. */
1f8f4a0b 12069 current_function_decl = NULL_TREE;
4d6abc1c
MM
12070
12071 return fndecl;
8d08fdba
MS
12072}
12073\f
12074/* Create the FUNCTION_DECL for a function definition.
8d08fdba
MS
12075 DECLSPECS and DECLARATOR are the parts of the declaration;
12076 they describe the return type and the name of the function,
12077 but twisted together in a fashion that parallels the syntax of C.
12078
12079 This function creates a binding context for the function body
12080 as well as setting up the FUNCTION_DECL in current_function_decl.
12081
12082 Returns a FUNCTION_DECL on success.
12083
12084 If the DECLARATOR is not suitable for a function (it defines a datum
12085 instead), we return 0, which tells yyparse to report a parse error.
12086
12087 May return void_type_node indicating that this method is actually
12088 a friend. See grokfield for more details.
12089
12090 Came here with a `.pushlevel' .
12091
12092 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
12093 CHANGES TO CODE IN `grokfield'. */
e92cc029 12094
8d08fdba 12095tree
caf93cb0 12096start_method (cp_decl_specifier_seq *declspecs,
0cbd7506 12097 const cp_declarator *declarator, tree attrlist)
8d08fdba 12098{
c11b6f21 12099 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
91d231cb 12100 &attrlist);
8d08fdba 12101
a723baf1
MM
12102 if (fndecl == error_mark_node)
12103 return error_mark_node;
12104
12105 if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
12106 {
12107 error ("invalid member function declaration");
12108 return error_mark_node;
12109 }
8d08fdba 12110
195a5def
IR
12111 if (attrlist)
12112 cplus_decl_attributes (&fndecl, attrlist, 0);
12113
8d08fdba 12114 /* Pass friends other than inline friend functions back. */
a1774733 12115 if (fndecl == void_type_node)
8d08fdba
MS
12116 return fndecl;
12117
8d08fdba
MS
12118 if (DECL_IN_AGGR_P (fndecl))
12119 {
58ec3cc5 12120 if (DECL_CONTEXT (fndecl)
6d69fe27 12121 && TREE_CODE (DECL_CONTEXT (fndecl)) != NAMESPACE_DECL)
2d01edd7 12122 error ("%qD is already defined in class %qT", fndecl,
58ec3cc5 12123 DECL_CONTEXT (fndecl));
8ca4bf25 12124 return error_mark_node;
8d08fdba
MS
12125 }
12126
f3400fe2
JM
12127 check_template_shadow (fndecl);
12128
79065db2 12129 DECL_DECLARED_INLINE_P (fndecl) = 1;
8926095f 12130 if (flag_default_inline)
8d08fdba
MS
12131 DECL_INLINE (fndecl) = 1;
12132
36a117a5
MM
12133 /* We process method specializations in finish_struct_1. */
12134 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
4b0d3cbe
MM
12135 {
12136 fndecl = push_template_decl (fndecl);
12137 if (fndecl == error_mark_node)
12138 return fndecl;
12139 }
a0a33927 12140
8d08fdba
MS
12141 if (! DECL_FRIEND_P (fndecl))
12142 {
8d08fdba
MS
12143 if (TREE_CHAIN (fndecl))
12144 {
12145 fndecl = copy_node (fndecl);
12146 TREE_CHAIN (fndecl) = NULL_TREE;
12147 }
8d08fdba
MS
12148 }
12149
d174af6c 12150 finish_decl (fndecl, NULL_TREE, NULL_TREE);
8d08fdba 12151
f4f206f4 12152 /* Make a place for the parms. */
ac20c67a 12153 begin_scope (sk_function_parms, fndecl);
68642fb6 12154
8d08fdba
MS
12155 DECL_IN_AGGR_P (fndecl) = 1;
12156 return fndecl;
12157}
12158
12159/* Go through the motions of finishing a function definition.
12160 We don't compile this method until after the whole class has
12161 been processed.
12162
12163 FINISH_METHOD must return something that looks as though it
12164 came from GROKFIELD (since we are defining a method, after all).
12165
12166 This is called after parsing the body of the function definition.
12167 STMTS is the chain of statements that makes up the function body.
12168
12169 DECL is the ..._DECL that `start_method' provided. */
12170
12171tree
11f6b451 12172finish_method (tree decl)
8d08fdba 12173{
926ce8bd 12174 tree fndecl = decl;
8d08fdba 12175 tree old_initial;
8d08fdba 12176
926ce8bd 12177 tree link;
8d08fdba 12178
a1774733 12179 if (decl == void_type_node)
8d08fdba
MS
12180 return decl;
12181
12182 old_initial = DECL_INITIAL (fndecl);
12183
12184 /* Undo the level for the parms (from start_method).
12185 This is like poplevel, but it causes nothing to be
12186 saved. Saving information here confuses symbol-table
12187 output routines. Besides, this information will
12188 be correctly output when this method is actually
12189 compiled. */
12190
12191 /* Clear out the meanings of the local variables of this level;
12192 also record in each decl which block it belongs to. */
12193
12194 for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
12195 {
12196 if (DECL_NAME (link) != NULL_TREE)
d8f8dca1 12197 pop_binding (DECL_NAME (link), link);
50bc768d 12198 gcc_assert (TREE_CODE (link) != FUNCTION_DECL);
8d08fdba
MS
12199 DECL_CONTEXT (link) = NULL_TREE;
12200 }
12201
8d08fdba
MS
12202 poplevel (0, 0, 0);
12203
12204 DECL_INITIAL (fndecl) = old_initial;
12205
12206 /* We used to check if the context of FNDECL was different from
12207 current_class_type as another way to get inside here. This didn't work
12208 for String.cc in libg++. */
12209 if (DECL_FRIEND_P (fndecl))
12210 {
d4e6fecb 12211 VEC_safe_push (tree, gc, CLASSTYPE_INLINE_FRIENDS (current_class_type),
585b44d3 12212 fndecl);
8d08fdba
MS
12213 decl = void_type_node;
12214 }
12215
12216 return decl;
12217}
12218\f
0154eaa8
MM
12219
12220/* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
12221 we can lay it out later, when and if its type becomes complete. */
8d08fdba
MS
12222
12223void
11f6b451 12224maybe_register_incomplete_var (tree var)
8d08fdba 12225{
50bc768d 12226 gcc_assert (TREE_CODE (var) == VAR_DECL);
8d08fdba 12227
0154eaa8 12228 /* Keep track of variables with incomplete types. */
caf93cb0 12229 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
0154eaa8 12230 && DECL_EXTERNAL (var))
70adf8a9 12231 {
0154eaa8 12232 tree inner_type = TREE_TYPE (var);
caf93cb0 12233
0154eaa8
MM
12234 while (TREE_CODE (inner_type) == ARRAY_TYPE)
12235 inner_type = TREE_TYPE (inner_type);
12236 inner_type = TYPE_MAIN_VARIANT (inner_type);
caf93cb0 12237
0154eaa8
MM
12238 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
12239 /* RTTI TD entries are created while defining the type_info. */
12240 || (TYPE_LANG_SPECIFIC (inner_type)
12241 && TYPE_BEING_DEFINED (inner_type)))
12242 incomplete_vars = tree_cons (inner_type, var, incomplete_vars);
70adf8a9 12243 }
0154eaa8 12244}
70adf8a9 12245
0154eaa8 12246/* Called when a class type (given by TYPE) is defined. If there are
39a13be5 12247 any existing VAR_DECLs whose type has been completed by this
0154eaa8 12248 declaration, update them now. */
70adf8a9 12249
0154eaa8 12250void
11f6b451 12251complete_vars (tree type)
0154eaa8
MM
12252{
12253 tree *list = &incomplete_vars;
12254
50bc768d 12255 gcc_assert (CLASS_TYPE_P (type));
caf93cb0 12256 while (*list)
0154eaa8
MM
12257 {
12258 if (same_type_p (type, TREE_PURPOSE (*list)))
70adf8a9 12259 {
0154eaa8 12260 tree var = TREE_VALUE (*list);
67935995 12261 tree type = TREE_TYPE (var);
c740732f
MM
12262 /* Complete the type of the variable. The VAR_DECL itself
12263 will be laid out in expand_expr. */
67935995
MM
12264 complete_type (type);
12265 cp_apply_type_quals_to_decl (cp_type_quals (type), var);
0154eaa8
MM
12266 /* Remove this entry from the list. */
12267 *list = TREE_CHAIN (*list);
f30432d7
MS
12268 }
12269 else
0154eaa8 12270 list = &TREE_CHAIN (*list);
f30432d7 12271 }
7fb213d8
GB
12272
12273 /* Check for pending declarations which may have abstract type. */
12274 complete_type_check_abstract (type);
8d08fdba
MS
12275}
12276
5c113154
MM
12277/* If DECL is of a type which needs a cleanup, build and return an
12278 expression to perform that cleanup here. Return NULL_TREE if no
12279 cleanup need be done. */
e92cc029 12280
86f45d2c 12281tree
11f6b451 12282cxx_maybe_build_cleanup (tree decl)
8d08fdba 12283{
5c113154
MM
12284 tree type;
12285 tree attr;
12286 tree cleanup;
12287
12288 /* Assume no cleanup is required. */
12289 cleanup = NULL_TREE;
86f45d2c 12290
5c113154
MM
12291 if (error_operand_p (decl))
12292 return cleanup;
12293
12294 /* Handle "__attribute__((cleanup))". We run the cleanup function
12295 before the destructor since the destructor is what actually
12296 terminates the lifetime of the object. */
12297 attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
12298 if (attr)
12299 {
12300 tree id;
12301 tree fn;
12302 tree arg;
12303
12304 /* Get the name specified by the user for the cleanup function. */
12305 id = TREE_VALUE (TREE_VALUE (attr));
12306 /* Look up the name to find the cleanup function to call. It is
12307 important to use lookup_name here because that is what is
12308 used in c-common.c:handle_cleanup_attribute when performing
12309 initial checks on the attribute. Note that those checks
12310 include ensuring that the function found is not an overloaded
12311 function, or an object with an overloaded call operator,
39a13be5 12312 etc.; we can rely on the fact that the function found is an
5c113154
MM
12313 ordinary FUNCTION_DECL. */
12314 fn = lookup_name (id);
12315 arg = build_address (decl);
12316 mark_used (decl);
5ade1ed2
DG
12317 cleanup = cp_build_function_call (fn, build_tree_list (NULL_TREE,
12318 arg),
12319 tf_warning_or_error);
5c113154
MM
12320 }
12321 /* Handle ordinary C++ destructors. */
12322 type = TREE_TYPE (decl);
12323 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
8d08fdba 12324 {
80048418 12325 int flags = LOOKUP_NORMAL|LOOKUP_DESTRUCTOR;
5775a06a
NS
12326 bool has_vbases = (TREE_CODE (type) == RECORD_TYPE
12327 && CLASSTYPE_VBASECLASSES (type));
5c113154
MM
12328 tree addr;
12329 tree call;
8d08fdba 12330
8d08fdba 12331 if (TREE_CODE (type) == ARRAY_TYPE)
5c113154 12332 addr = decl;
8d08fdba 12333 else
5818c8e4 12334 addr = build_address (decl);
8d08fdba
MS
12335
12336 /* Optimize for space over speed here. */
5775a06a 12337 if (!has_vbases || flag_expensive_optimizations)
8d08fdba
MS
12338 flags |= LOOKUP_NONVIRTUAL;
12339
5c113154 12340 call = build_delete (TREE_TYPE (addr), addr,
86f45d2c 12341 sfk_complete_destructor, flags, 0);
5c113154 12342 if (cleanup)
525521b6 12343 cleanup = build_compound_expr (cleanup, call);
5c113154
MM
12344 else
12345 cleanup = call;
8d08fdba 12346 }
5c113154
MM
12347
12348 return cleanup;
8d08fdba
MS
12349}
12350\f
558475f0 12351/* When a stmt has been parsed, this function is called. */
8d08fdba
MS
12352
12353void
11f6b451 12354finish_stmt (void)
8d08fdba 12355{
8d08fdba
MS
12356}
12357
3afb32a4
MM
12358/* DECL was originally constructed as a non-static member function,
12359 but turned out to be static. Update it accordingly. */
700f8a87 12360
8857f91e 12361void
11f6b451 12362revert_static_member_fn (tree decl)
8d08fdba 12363{
700f8a87 12364 tree tmp;
3afb32a4
MM
12365 tree function = TREE_TYPE (decl);
12366 tree args = TYPE_ARG_TYPES (function);
8d08fdba 12367
89d684bb 12368 if (cp_type_quals (TREE_TYPE (TREE_VALUE (args)))
91063b51 12369 != TYPE_UNQUALIFIED)
c4f73174 12370 error ("static member function %q#D declared with type qualifiers", decl);
f30432d7 12371
700f8a87
MS
12372 args = TREE_CHAIN (args);
12373 tmp = build_function_type (TREE_TYPE (function), args);
89d684bb 12374 tmp = build_qualified_type (tmp, cp_type_quals (function));
f30432d7 12375 tmp = build_exception_variant (tmp,
8d08fdba 12376 TYPE_RAISES_EXCEPTIONS (function));
3afb32a4
MM
12377 TREE_TYPE (decl) = tmp;
12378 if (DECL_ARGUMENTS (decl))
12379 DECL_ARGUMENTS (decl) = TREE_CHAIN (DECL_ARGUMENTS (decl));
12380 DECL_STATIC_FUNCTION_P (decl) = 1;
8d08fdba 12381}
a4443a08 12382
e2500fed
GK
12383/* Return which tree structure is used by T, or TS_CP_GENERIC if T is
12384 one of the language-independent trees. */
4519c0a8 12385
e2500fed 12386enum cp_tree_node_structure_enum
11f6b451 12387cp_tree_node_structure (union lang_tree_node * t)
4519c0a8 12388{
e2500fed 12389 switch (TREE_CODE (&t->generic))
4519c0a8 12390 {
a723baf1 12391 case DEFAULT_ARG: return TS_CP_DEFAULT_ARG;
e2500fed 12392 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER;
e2500fed
GK
12393 case OVERLOAD: return TS_CP_OVERLOAD;
12394 case TEMPLATE_PARM_INDEX: return TS_CP_TPI;
12395 case PTRMEM_CST: return TS_CP_PTRMEM;
0cbd7506 12396 case BASELINK: return TS_CP_BASELINK;
54e67af0 12397 case STATIC_ASSERT: return TS_CP_STATIC_ASSERT;
5d80a306 12398 case ARGUMENT_PACK_SELECT: return TS_CP_ARGUMENT_PACK_SELECT;
cb68ec50 12399 case TRAIT_EXPR: return TS_CP_TRAIT_EXPR;
e2500fed 12400 default: return TS_CP_GENERIC;
4519c0a8
MM
12401 }
12402}
5fd8e536 12403
eaa7c03f
JM
12404/* Build the void_list_node (void_type_node having been created). */
12405tree
11f6b451 12406build_void_list_node (void)
eaa7c03f
JM
12407{
12408 tree t = build_tree_list (NULL_TREE, void_type_node);
eaa7c03f
JM
12409 return t;
12410}
12411
6de9cd9a 12412bool
11f6b451 12413cp_missing_noreturn_ok_p (tree decl)
d363e7bf
AJ
12414{
12415 /* A missing noreturn is ok for the `main' function. */
92643fea 12416 return DECL_MAIN_P (decl);
d363e7bf 12417}
e2500fed 12418
c18a5b6c
MM
12419/* Return the COMDAT group into which DECL should be placed. */
12420
12421const char *
12422cxx_comdat_group (tree decl)
12423{
12424 tree name;
12425
12426 /* Virtual tables, construction virtual tables, and virtual table
12427 tables all go in a single COMDAT group, named after the primary
12428 virtual table. */
12429 if (TREE_CODE (decl) == VAR_DECL && DECL_VTABLE_OR_VTT_P (decl))
12430 name = DECL_ASSEMBLER_NAME (CLASSTYPE_VTABLES (DECL_CONTEXT (decl)));
12431 /* For all other DECLs, the COMDAT group is the mangled name of the
12432 declaration itself. */
12433 else
5591e5f9
JJ
12434 {
12435 while (DECL_THUNK_P (decl))
12436 {
12437 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
12438 into the same section as the target function. In that case
12439 we must return target's name. */
12440 tree target = THUNK_TARGET (decl);
12441 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target)
12442 && DECL_SECTION_NAME (target) != NULL
12443 && DECL_ONE_ONLY (target))
12444 decl = target;
12445 else
12446 break;
12447 }
12448 name = DECL_ASSEMBLER_NAME (decl);
12449 }
c18a5b6c
MM
12450
12451 return IDENTIFIER_POINTER (name);
12452}
12453
e2500fed 12454#include "gt-cp-decl.h"