1 /* Process declarations and variables for C++ compiler.
2 Copyright (C) 1988-2019 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 any later version.
11
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
20
21
22 /* Process declarations and symbol lookup for C++ front end.
23 Also constructs types; the standard scalar types at initialization,
24 and structure, union, array and enum types when they are declared. */
25
26 /* ??? not all decl nodes are given the most useful possible
27 line numbers. For example, the CONST_DECLs for enum values. */
28
29 #include "config.h"
30 #include "system.h"
31 #include "coretypes.h"
32 #include "target.h"
33 #include "c-family/c-target.h"
34 #include "cp-tree.h"
35 #include "timevar.h"
36 #include "stringpool.h"
37 #include "cgraph.h"
38 #include "stor-layout.h"
39 #include "varasm.h"
40 #include "attribs.h"
41 #include "flags.h"
42 #include "tree-iterator.h"
43 #include "decl.h"
44 #include "intl.h"
45 #include "toplev.h"
46 #include "c-family/c-objc.h"
47 #include "c-family/c-pragma.h"
48 #include "c-family/c-ubsan.h"
49 #include "debug.h"
50 #include "plugin.h"
51 #include "builtins.h"
52 #include "gimplify.h"
53 #include "asan.h"
54 #include "gcc-rich-location.h"
55 #include "langhooks.h"
56
57 /* Possible cases of bad specifiers type used by bad_specifiers. */
58 enum bad_spec_place {
59 BSP_VAR, /* variable */
60 BSP_PARM, /* parameter */
61 BSP_TYPE, /* type */
62 BSP_FIELD /* field */
63 };
64
65 static const char *redeclaration_error_message (tree, tree);
66
67 static int decl_jump_unsafe (tree);
68 static void require_complete_types_for_parms (tree);
69 static tree grok_reference_init (tree, tree, tree, int);
70 static tree grokvardecl (tree, tree, tree, const cp_decl_specifier_seq *,
71 int, int, int, bool, int, tree, location_t);
72 static void check_static_variable_definition (tree, tree);
73 static void record_unknown_type (tree, const char *);
74 static tree builtin_function_1 (tree, tree, bool);
75 static int member_function_or_else (tree, tree, enum overload_flags);
76 static tree local_variable_p_walkfn (tree *, int *, void *);
77 static const char *tag_name (enum tag_types);
78 static tree lookup_and_check_tag (enum tag_types, tree, tag_scope, bool);
79 static void maybe_deduce_size_from_array_init (tree, tree);
80 static void layout_var_decl (tree);
81 static tree check_initializer (tree, tree, int, vec<tree, va_gc> **);
82 static void make_rtl_for_nonlocal_decl (tree, tree, const char *);
83 static void save_function_data (tree);
84 static void copy_type_enum (tree , tree);
85 static void check_function_type (tree, tree);
86 static void finish_constructor_body (void);
87 static void begin_destructor_body (void);
88 static void finish_destructor_body (void);
89 static void record_key_method_defined (tree);
90 static tree create_array_type_for_decl (tree, tree, tree, location_t);
91 static tree get_atexit_node (void);
92 static tree get_dso_handle_node (void);
93 static tree start_cleanup_fn (void);
94 static void end_cleanup_fn (void);
95 static tree cp_make_fname_decl (location_t, tree, int);
96 static void initialize_predefined_identifiers (void);
97 static tree check_special_function_return_type
98 (special_function_kind, tree, tree, int, const location_t*);
99 static tree push_cp_library_fn (enum tree_code, tree, int);
100 static tree build_cp_library_fn (tree, enum tree_code, tree, int);
101 static void store_parm_decls (tree);
102 static void initialize_local_var (tree, tree);
103 static void expand_static_init (tree, tree);
104
105 /* The following symbols are subsumed in the cp_global_trees array, and
106 listed here individually for documentation purposes.
107
108 C++ extensions
109 tree wchar_decl_node;
110
111 tree vtable_entry_type;
112 tree delta_type_node;
113 tree __t_desc_type_node;
114
115 tree class_type_node;
116 tree unknown_type_node;
117
118 Array type `vtable_entry_type[]'
119
120 tree vtbl_type_node;
121 tree vtbl_ptr_type_node;
122
123 Namespaces,
124
125 tree std_node;
126 tree abi_node;
127
128 A FUNCTION_DECL which can call `abort'. Not necessarily the
129 one that the user will declare, but sufficient to be called
130 by routines that want to abort the program.
131
132 tree abort_fndecl;
133
134 Used by RTTI
135 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
136 tree tinfo_var_id; */
137
138 tree cp_global_trees[CPTI_MAX];
139
140 /* A list of objects which have constructors or destructors
141 which reside in the global scope. The decl is stored in
142 the TREE_VALUE slot and the initializer is stored
143 in the TREE_PURPOSE slot. */
144 tree static_aggregates;
145
146 /* Like static_aggregates, but for thread_local variables. */
147 tree tls_aggregates;
148
149 /* -- end of C++ */
150
151 /* A node for the integer constant 2. */
152
153 tree integer_two_node;
154
155 /* vector of static decls. */
156 vec<tree, va_gc> *static_decls;
157
158 /* vector of keyed classes. */
159 vec<tree, va_gc> *keyed_classes;
160
161 /* Used only for jumps to as-yet undefined labels, since jumps to
162 defined labels can have their validity checked immediately. */
163
164 struct GTY((chain_next ("%h.next"))) named_label_use_entry {
165 struct named_label_use_entry *next;
166 /* The binding level to which this entry is *currently* attached.
167 This is initially the binding level in which the goto appeared,
168 but is modified as scopes are closed. */
169 cp_binding_level *binding_level;
170 /* The head of the names list that was current when the goto appeared,
171 or the inner scope popped. These are the decls that will *not* be
172 skipped when jumping to the label. */
173 tree names_in_scope;
174 /* The location of the goto, for error reporting. */
175 location_t o_goto_locus;
176 /* True if an OpenMP structured block scope has been closed since
177 the goto appeared. This means that the branch from the label will
178 illegally exit an OpenMP scope. */
179 bool in_omp_scope;
180 };
181
182 /* A list of all LABEL_DECLs in the function that have names. Here so
183 we can clear out their names' definitions at the end of the
184 function, and so we can check the validity of jumps to these labels. */
185
186 struct GTY((for_user)) named_label_entry {
187
188 tree name; /* Name of decl. */
189
190 tree label_decl; /* LABEL_DECL, unless deleted local label. */
191
192 named_label_entry *outer; /* Outer shadowed chain. */
193
194 /* The binding level to which the label is *currently* attached.
195 This is initially set to the binding level in which the label
196 is defined, but is modified as scopes are closed. */
197 cp_binding_level *binding_level;
198
199 /* The head of the names list that was current when the label was
200 defined, or the inner scope popped. These are the decls that will
201 be skipped when jumping to the label. */
202 tree names_in_scope;
203
204 /* A vector of all decls from all binding levels that would be
205 crossed by a backward branch to the label. */
206 vec<tree, va_gc> *bad_decls;
207
208 /* A list of uses of the label, before the label is defined. */
209 named_label_use_entry *uses;
210
211 /* The following bits are set after the label is defined, and are
212 updated as scopes are popped. They indicate that a jump to the
213 label will illegally enter a scope of the given flavor. */
214 bool in_try_scope;
215 bool in_catch_scope;
216 bool in_omp_scope;
217 bool in_transaction_scope;
218 bool in_constexpr_if;
219 };
220
221 #define named_labels cp_function_chain->x_named_labels
222
223 /* The number of function bodies which we are currently processing.
224 (Zero if we are at namespace scope, one inside the body of a
225 function, two inside the body of a function in a local class, etc.) */
226 int function_depth;
227
228 /* Whether the exception-specifier is part of a function type (i.e. C++17). */
229 bool flag_noexcept_type;
230
231 /* States indicating how grokdeclarator() should handle declspecs marked
232 with __attribute__((deprecated)). An object declared as
233 __attribute__((deprecated)) suppresses warnings of uses of other
234 deprecated items. */
235 enum deprecated_states deprecated_state = DEPRECATED_NORMAL;
236
237
238 /* A list of VAR_DECLs whose type was incomplete at the time the
239 variable was declared. */
240
241 struct GTY(()) incomplete_var {
242 tree decl;
243 tree incomplete_type;
244 };
245
246
247 static GTY(()) vec<incomplete_var, va_gc> *incomplete_vars;
248
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
253 tmpl_spec_kind
current_tmpl_spec_kind(int n_class_scopes)254 current_tmpl_spec_kind (int n_class_scopes)
255 {
256 int n_template_parm_scopes = 0;
257 int seen_specialization_p = 0;
258 int innermost_specialization_p = 0;
259 cp_binding_level *b;
260
261 /* Scan through the template parameter scopes. */
262 for (b = current_binding_level;
263 b->kind == sk_template_parms;
264 b = b->level_chain)
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
272 which is always invalid since [temp.expl.spec] forbids the
273 specialization of a class member template if the enclosing
274 class templates are not explicitly specialized as well. */
275 if (b->explicit_spec_p)
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
307 template <class T> void R<T>::S<T>::f(int);
308
309 This is invalid; there needs to be one set of template
310 parameters for each class. */
311 return tsk_insufficient_parms;
312 else if (n_template_parm_scopes == n_class_scopes)
313 /* We're processing a non-template declaration (even though it may
314 be a member of a template class.) For example:
315
316 template <class T> void S<T>::f(int);
317
318 The `class T' matches the `S<T>', leaving no template headers
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
324 template <> template <class T> void f (T);
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
331 template <class T> template <class U> void S<T>::f(U);
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;
337 }
338
339 /* Exit the current scope. */
340
341 void
finish_scope(void)342 finish_scope (void)
343 {
344 poplevel (0, 0, 0);
345 }
346
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
350 static void
check_label_used(tree label)351 check_label_used (tree label)
352 {
353 if (!processing_template_decl)
354 {
355 if (DECL_INITIAL (label) == NULL_TREE)
356 {
357 location_t location;
358
359 error ("label %q+D used but not defined", label);
360 location = input_location;
361 /* FIXME want (LOCATION_FILE (input_location), (line)0) */
362 /* Avoid crashing later. */
363 define_label (location, DECL_NAME (label));
364 }
365 else
366 warn_for_unused_label (label);
367 }
368 }
369
370 /* Helper function to sort named label entries in a vector by DECL_UID. */
371
372 static int
sort_labels(const void * a,const void * b)373 sort_labels (const void *a, const void *b)
374 {
375 tree label1 = *(tree const *) a;
376 tree label2 = *(tree const *) b;
377
378 /* DECL_UIDs can never be equal. */
379 return DECL_UID (label1) > DECL_UID (label2) ? -1 : +1;
380 }
381
382 /* At the end of a function, all labels declared within the function
383 go out of scope. BLOCK is the top-level block for the
384 function. */
385
386 static void
pop_labels(tree block)387 pop_labels (tree block)
388 {
389 if (!named_labels)
390 return;
391
392 /* We need to add the labels to the block chain, so debug
393 information is emitted. But, we want the order to be stable so
394 need to sort them first. Otherwise the debug output could be
395 randomly ordered. I guess it's mostly stable, unless the hash
396 table implementation changes. */
397 auto_vec<tree, 32> labels (named_labels->elements ());
398 hash_table<named_label_hash>::iterator end (named_labels->end ());
399 for (hash_table<named_label_hash>::iterator iter
400 (named_labels->begin ()); iter != end; ++iter)
401 {
402 named_label_entry *ent = *iter;
403
404 gcc_checking_assert (!ent->outer);
405 if (ent->label_decl)
406 labels.quick_push (ent->label_decl);
407 ggc_free (ent);
408 }
409 named_labels = NULL;
410 labels.qsort (sort_labels);
411
412 while (labels.length ())
413 {
414 tree label = labels.pop ();
415
416 DECL_CHAIN (label) = BLOCK_VARS (block);
417 BLOCK_VARS (block) = label;
418
419 check_label_used (label);
420 }
421 }
422
423 /* At the end of a block with local labels, restore the outer definition. */
424
425 static void
pop_local_label(tree id,tree label)426 pop_local_label (tree id, tree label)
427 {
428 check_label_used (label);
429 named_label_entry **slot = named_labels->find_slot_with_hash
430 (id, IDENTIFIER_HASH_VALUE (id), NO_INSERT);
431 named_label_entry *ent = *slot;
432
433 if (ent->outer)
434 ent = ent->outer;
435 else
436 {
437 ent = ggc_cleared_alloc<named_label_entry> ();
438 ent->name = id;
439 }
440 *slot = ent;
441 }
442
443 /* The following two routines are used to interface to Objective-C++.
444 The binding level is purposely treated as an opaque type. */
445
446 void *
objc_get_current_scope(void)447 objc_get_current_scope (void)
448 {
449 return current_binding_level;
450 }
451
452 /* The following routine is used by the NeXT-style SJLJ exceptions;
453 variables get marked 'volatile' so as to not be clobbered by
454 _setjmp()/_longjmp() calls. All variables in the current scope,
455 as well as parent scopes up to (but not including) ENCLOSING_BLK
456 shall be thusly marked. */
457
458 void
objc_mark_locals_volatile(void * enclosing_blk)459 objc_mark_locals_volatile (void *enclosing_blk)
460 {
461 cp_binding_level *scope;
462
463 for (scope = current_binding_level;
464 scope && scope != enclosing_blk;
465 scope = scope->level_chain)
466 {
467 tree decl;
468
469 for (decl = scope->names; decl; decl = TREE_CHAIN (decl))
470 objc_volatilize_decl (decl);
471
472 /* Do not climb up past the current function. */
473 if (scope->kind == sk_function_parms)
474 break;
475 }
476 }
477
478 /* True if B is the level for the condition of a constexpr if. */
479
480 static bool
level_for_constexpr_if(cp_binding_level * b)481 level_for_constexpr_if (cp_binding_level *b)
482 {
483 return (b->kind == sk_cond && b->this_entity
484 && TREE_CODE (b->this_entity) == IF_STMT
485 && IF_STMT_CONSTEXPR_P (b->this_entity));
486 }
487
488 /* Update data for defined and undefined labels when leaving a scope. */
489
490 int
poplevel_named_label_1(named_label_entry ** slot,cp_binding_level * bl)491 poplevel_named_label_1 (named_label_entry **slot, cp_binding_level *bl)
492 {
493 named_label_entry *ent = *slot;
494 cp_binding_level *obl = bl->level_chain;
495
496 if (ent->binding_level == bl)
497 {
498 tree decl;
499
500 /* ENT->NAMES_IN_SCOPE may contain a mixture of DECLs and
501 TREE_LISTs representing OVERLOADs, so be careful. */
502 for (decl = ent->names_in_scope; decl; decl = (DECL_P (decl)
503 ? DECL_CHAIN (decl)
504 : TREE_CHAIN (decl)))
505 if (decl_jump_unsafe (decl))
506 vec_safe_push (ent->bad_decls, decl);
507
508 ent->binding_level = obl;
509 ent->names_in_scope = obl->names;
510 switch (bl->kind)
511 {
512 case sk_try:
513 ent->in_try_scope = true;
514 break;
515 case sk_catch:
516 ent->in_catch_scope = true;
517 break;
518 case sk_omp:
519 ent->in_omp_scope = true;
520 break;
521 case sk_transaction:
522 ent->in_transaction_scope = true;
523 break;
524 case sk_block:
525 if (level_for_constexpr_if (bl->level_chain))
526 ent->in_constexpr_if = true;
527 break;
528 default:
529 break;
530 }
531 }
532 else if (ent->uses)
533 {
534 struct named_label_use_entry *use;
535
536 for (use = ent->uses; use ; use = use->next)
537 if (use->binding_level == bl)
538 {
539 use->binding_level = obl;
540 use->names_in_scope = obl->names;
541 if (bl->kind == sk_omp)
542 use->in_omp_scope = true;
543 }
544 }
545
546 return 1;
547 }
548
549 /* Saved errorcount to avoid -Wunused-but-set-{parameter,variable} warnings
550 when errors were reported, except for -Werror-unused-but-set-*. */
551 static int unused_but_set_errorcount;
552
553 /* Exit a binding level.
554 Pop the level off, and restore the state of the identifier-decl mappings
555 that were in effect when this level was entered.
556
557 If KEEP == 1, this level had explicit declarations, so
558 and create a "block" (a BLOCK node) for the level
559 to record its declarations and subblocks for symbol table output.
560
561 If FUNCTIONBODY is nonzero, this level is the body of a function,
562 so create a block as if KEEP were set and also clear out all
563 label names.
564
565 If REVERSE is nonzero, reverse the order of decls before putting
566 them into the BLOCK. */
567
568 tree
poplevel(int keep,int reverse,int functionbody)569 poplevel (int keep, int reverse, int functionbody)
570 {
571 tree link;
572 /* The chain of decls was accumulated in reverse order.
573 Put it into forward order, just for cleanliness. */
574 tree decls;
575 tree subblocks;
576 tree block;
577 tree decl;
578 scope_kind kind;
579
580 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
581 restart:
582
583 block = NULL_TREE;
584
585 gcc_assert (current_binding_level->kind != sk_class
586 && current_binding_level->kind != sk_namespace);
587
588 if (current_binding_level->kind == sk_cleanup)
589 functionbody = 0;
590 subblocks = functionbody >= 0 ? current_binding_level->blocks : 0;
591
592 gcc_assert (!vec_safe_length (current_binding_level->class_shadowed));
593
594 /* We used to use KEEP == 2 to indicate that the new block should go
595 at the beginning of the list of blocks at this binding level,
596 rather than the end. This hack is no longer used. */
597 gcc_assert (keep == 0 || keep == 1);
598
599 if (current_binding_level->keep)
600 keep = 1;
601
602 /* Any uses of undefined labels, and any defined labels, now operate
603 under constraints of next binding contour. */
604 if (cfun && !functionbody && named_labels)
605 named_labels->traverse<cp_binding_level *, poplevel_named_label_1>
606 (current_binding_level);
607
608 /* Get the decls in the order they were written.
609 Usually current_binding_level->names is in reverse order.
610 But parameter decls were previously put in forward order. */
611
612 decls = current_binding_level->names;
613 if (reverse)
614 {
615 decls = nreverse (decls);
616 current_binding_level->names = decls;
617 }
618
619 /* If there were any declarations or structure tags in that level,
620 or if this level is a function body,
621 create a BLOCK to record them for the life of this function. */
622 block = NULL_TREE;
623 /* Avoid function body block if possible. */
624 if (functionbody && subblocks && BLOCK_CHAIN (subblocks) == NULL_TREE)
625 keep = 0;
626 else if (keep == 1 || functionbody)
627 block = make_node (BLOCK);
628 if (block != NULL_TREE)
629 {
630 BLOCK_VARS (block) = decls;
631 BLOCK_SUBBLOCKS (block) = subblocks;
632 }
633
634 /* In each subblock, record that this is its superior. */
635 if (keep >= 0)
636 for (link = subblocks; link; link = BLOCK_CHAIN (link))
637 BLOCK_SUPERCONTEXT (link) = block;
638
639 /* Before we remove the declarations first check for unused variables. */
640 if ((warn_unused_variable || warn_unused_but_set_variable)
641 && current_binding_level->kind != sk_template_parms
642 && !processing_template_decl)
643 for (tree d = get_local_decls (); d; d = TREE_CHAIN (d))
644 {
645 /* There are cases where D itself is a TREE_LIST. See in
646 push_local_binding where the list of decls returned by
647 getdecls is built. */
648 decl = TREE_CODE (d) == TREE_LIST ? TREE_VALUE (d) : d;
649
650 tree type = TREE_TYPE (decl);
651 if (VAR_P (decl)
652 && (! TREE_USED (decl) || !DECL_READ_P (decl))
653 && ! DECL_IN_SYSTEM_HEADER (decl)
654 /* For structured bindings, consider only real variables, not
655 subobjects. */
656 && (DECL_DECOMPOSITION_P (decl) ? !DECL_DECOMP_BASE (decl)
657 : (DECL_NAME (decl) && !DECL_ARTIFICIAL (decl)))
658 && type != error_mark_node
659 && (!CLASS_TYPE_P (type)
660 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
661 || lookup_attribute ("warn_unused",
662 TYPE_ATTRIBUTES (TREE_TYPE (decl)))))
663 {
664 if (! TREE_USED (decl))
665 {
666 if (!DECL_NAME (decl) && DECL_DECOMPOSITION_P (decl))
667 warning_at (DECL_SOURCE_LOCATION (decl),
668 OPT_Wunused_variable,
669 "unused structured binding declaration");
670 else
671 warning_at (DECL_SOURCE_LOCATION (decl),
672 OPT_Wunused_variable, "unused variable %qD", decl);
673 }
674 else if (DECL_CONTEXT (decl) == current_function_decl
675 // For -Wunused-but-set-variable leave references alone.
676 && !TYPE_REF_P (TREE_TYPE (decl))
677 && errorcount == unused_but_set_errorcount)
678 {
679 if (!DECL_NAME (decl) && DECL_DECOMPOSITION_P (decl))
680 warning_at (DECL_SOURCE_LOCATION (decl),
681 OPT_Wunused_but_set_variable, "structured "
682 "binding declaration set but not used");
683 else
684 warning_at (DECL_SOURCE_LOCATION (decl),
685 OPT_Wunused_but_set_variable,
686 "variable %qD set but not used", decl);
687 unused_but_set_errorcount = errorcount;
688 }
689 }
690 }
691
692 /* Remove declarations for all the DECLs in this level. */
693 for (link = decls; link; link = TREE_CHAIN (link))
694 {
695 decl = TREE_CODE (link) == TREE_LIST ? TREE_VALUE (link) : link;
696 tree name = OVL_NAME (decl);
697
698 /* Remove the binding. */
699 if (TREE_CODE (decl) == LABEL_DECL)
700 pop_local_label (name, decl);
701 else
702 pop_local_binding (name, decl);
703 }
704
705 /* Restore the IDENTIFIER_TYPE_VALUEs. */
706 for (link = current_binding_level->type_shadowed;
707 link; link = TREE_CHAIN (link))
708 SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (link), TREE_VALUE (link));
709
710 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
711 list if a `using' declaration put them there. The debugging
712 back ends won't understand OVERLOAD, so we remove them here.
713 Because the BLOCK_VARS are (temporarily) shared with
714 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
715 popped all the bindings. Also remove undeduced 'auto' decls,
716 which LTO doesn't understand, and can't have been used by anything. */
717 if (block)
718 {
719 tree* d;
720
721 for (d = &BLOCK_VARS (block); *d; )
722 {
723 if (TREE_CODE (*d) == TREE_LIST
724 || (!processing_template_decl
725 && undeduced_auto_decl (*d)))
726 *d = TREE_CHAIN (*d);
727 else
728 d = &DECL_CHAIN (*d);
729 }
730 }
731
732 /* If the level being exited is the top level of a function,
733 check over all the labels. */
734 if (functionbody)
735 {
736 if (block)
737 {
738 /* Since this is the top level block of a function, the vars are
739 the function's parameters. Don't leave them in the BLOCK
740 because they are found in the FUNCTION_DECL instead. */
741 BLOCK_VARS (block) = 0;
742 pop_labels (block);
743 }
744 else
745 pop_labels (subblocks);
746 }
747
748 kind = current_binding_level->kind;
749 if (kind == sk_cleanup)
750 {
751 tree stmt;
752
753 /* If this is a temporary binding created for a cleanup, then we'll
754 have pushed a statement list level. Pop that, create a new
755 BIND_EXPR for the block, and insert it into the stream. */
756 stmt = pop_stmt_list (current_binding_level->statement_list);
757 stmt = c_build_bind_expr (input_location, block, stmt);
758 add_stmt (stmt);
759 }
760
761 leave_scope ();
762 if (functionbody)
763 {
764 /* The current function is being defined, so its DECL_INITIAL
765 should be error_mark_node. */
766 gcc_assert (DECL_INITIAL (current_function_decl) == error_mark_node);
767 DECL_INITIAL (current_function_decl) = block ? block : subblocks;
768 if (subblocks)
769 {
770 if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
771 {
772 if (BLOCK_SUBBLOCKS (subblocks))
773 BLOCK_OUTER_CURLY_BRACE_P (BLOCK_SUBBLOCKS (subblocks)) = 1;
774 }
775 else
776 BLOCK_OUTER_CURLY_BRACE_P (subblocks) = 1;
777 }
778 }
779 else if (block)
780 current_binding_level->blocks
781 = block_chainon (current_binding_level->blocks, block);
782
783 /* If we did not make a block for the level just exited,
784 any blocks made for inner levels
785 (since they cannot be recorded as subblocks in that level)
786 must be carried forward so they will later become subblocks
787 of something else. */
788 else if (subblocks)
789 current_binding_level->blocks
790 = block_chainon (current_binding_level->blocks, subblocks);
791
792 /* Each and every BLOCK node created here in `poplevel' is important
793 (e.g. for proper debugging information) so if we created one
794 earlier, mark it as "used". */
795 if (block)
796 TREE_USED (block) = 1;
797
798 /* All temporary bindings created for cleanups are popped silently. */
799 if (kind == sk_cleanup)
800 goto restart;
801
802 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
803 return block;
804 }
805
806 /* Call wrapup_globals_declarations for the globals in NAMESPACE. */
807 /* Diagnose odr-used extern inline variables without definitions
808 in the current TU. */
809
810 int
wrapup_namespace_globals()811 wrapup_namespace_globals ()
812 {
813 if (vec<tree, va_gc> *statics = static_decls)
814 {
815 tree decl;
816 unsigned int i;
817 FOR_EACH_VEC_ELT (*statics, i, decl)
818 {
819 if (warn_unused_function
820 && TREE_CODE (decl) == FUNCTION_DECL
821 && DECL_INITIAL (decl) == 0
822 && DECL_EXTERNAL (decl)
823 && !TREE_PUBLIC (decl)
824 && !DECL_ARTIFICIAL (decl)
825 && !DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (decl)
826 && !TREE_NO_WARNING (decl))
827 warning_at (DECL_SOURCE_LOCATION (decl),
828 OPT_Wunused_function,
829 "%qF declared %<static%> but never defined", decl);
830
831 if (VAR_P (decl)
832 && DECL_EXTERNAL (decl)
833 && DECL_INLINE_VAR_P (decl)
834 && DECL_ODR_USED (decl))
835 error_at (DECL_SOURCE_LOCATION (decl),
836 "odr-used inline variable %qD is not defined", decl);
837 }
838
839 /* Clear out the list, so we don't rescan next time. */
840 static_decls = NULL;
841
842 /* Write out any globals that need to be output. */
843 return wrapup_global_declarations (statics->address (),
844 statics->length ());
845 }
846 return 0;
847 }
848
849 /* In C++, you don't have to write `struct S' to refer to `S'; you
850 can just use `S'. We accomplish this by creating a TYPE_DECL as
851 if the user had written `typedef struct S S'. Create and return
852 the TYPE_DECL for TYPE. */
853
854 tree
create_implicit_typedef(tree name,tree type)855 create_implicit_typedef (tree name, tree type)
856 {
857 tree decl;
858
859 decl = build_decl (input_location, TYPE_DECL, name, type);
860 DECL_ARTIFICIAL (decl) = 1;
861 /* There are other implicit type declarations, like the one *within*
862 a class that allows you to write `S::S'. We must distinguish
863 amongst these. */
864 SET_DECL_IMPLICIT_TYPEDEF_P (decl);
865 TYPE_NAME (type) = decl;
866 TYPE_STUB_DECL (type) = decl;
867
868 return decl;
869 }
870
871 /* Function-scope local entities that need discriminators. Each entry
872 is a {decl,name} pair. VAR_DECLs for anon unions get their name
873 smashed, so we cannot rely on DECL_NAME. */
874
875 static GTY((deletable)) vec<tree, va_gc> *local_entities;
876
877 /* Determine the mangling discriminator of local DECL. There are
878 generally very few of these in any particular function. */
879
880 void
determine_local_discriminator(tree decl)881 determine_local_discriminator (tree decl)
882 {
883 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
884 retrofit_lang_decl (decl);
885 tree ctx = DECL_CONTEXT (decl);
886 tree name = (TREE_CODE (decl) == TYPE_DECL
887 && TYPE_UNNAMED_P (TREE_TYPE (decl))
888 ? NULL_TREE : DECL_NAME (decl));
889 size_t nelts = vec_safe_length (local_entities);
890 for (size_t i = 0; i < nelts; i += 2)
891 {
892 tree *pair = &(*local_entities)[i];
893 tree d = pair[0];
894 tree n = pair[1];
895 gcc_checking_assert (d != decl);
896 if (name == n
897 && TREE_CODE (decl) == TREE_CODE (d)
898 && ctx == DECL_CONTEXT (d))
899 {
900 tree disc = integer_one_node;
901 if (DECL_DISCRIMINATOR (d))
902 disc = build_int_cst (TREE_TYPE (disc),
903 TREE_INT_CST_LOW (DECL_DISCRIMINATOR (d)) + 1);
904 DECL_DISCRIMINATOR (decl) = disc;
905 /* Replace the saved decl. */
906 pair[0] = decl;
907 decl = NULL_TREE;
908 break;
909 }
910 }
911
912 if (decl)
913 {
914 vec_safe_reserve (local_entities, 2);
915 local_entities->quick_push (decl);
916 local_entities->quick_push (name);
917 }
918
919 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
920 }
921
922
923 /* Subroutine of duplicate_decls: return truthvalue of whether
924 or not types of these decls match.
925
926 For C++, we must compare the parameter list so that `int' can match
927 `int&' in a parameter position, but `int&' is not confused with
928 `const int&'. */
929
930 int
decls_match(tree newdecl,tree olddecl,bool record_versions)931 decls_match (tree newdecl, tree olddecl, bool record_versions /* = true */)
932 {
933 int types_match;
934
935 if (newdecl == olddecl)
936 return 1;
937
938 if (TREE_CODE (newdecl) != TREE_CODE (olddecl))
939 /* If the two DECLs are not even the same kind of thing, we're not
940 interested in their types. */
941 return 0;
942
943 gcc_assert (DECL_P (newdecl));
944
945 if (TREE_CODE (newdecl) == FUNCTION_DECL)
946 {
947 tree f1 = TREE_TYPE (newdecl);
948 tree f2 = TREE_TYPE (olddecl);
949 tree p1 = TYPE_ARG_TYPES (f1);
950 tree p2 = TYPE_ARG_TYPES (f2);
951 tree r2;
952
953 /* Specializations of different templates are different functions
954 even if they have the same type. */
955 tree t1 = (DECL_USE_TEMPLATE (newdecl)
956 ? DECL_TI_TEMPLATE (newdecl)
957 : NULL_TREE);
958 tree t2 = (DECL_USE_TEMPLATE (olddecl)
959 ? DECL_TI_TEMPLATE (olddecl)
960 : NULL_TREE);
961 if (t1 != t2)
962 return 0;
963
964 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
965 && ! (DECL_EXTERN_C_P (newdecl)
966 && DECL_EXTERN_C_P (olddecl)))
967 return 0;
968
969 /* A new declaration doesn't match a built-in one unless it
970 is also extern "C". */
971 if (DECL_IS_BUILTIN (olddecl)
972 && DECL_EXTERN_C_P (olddecl) && !DECL_EXTERN_C_P (newdecl))
973 return 0;
974
975 if (TREE_CODE (f1) != TREE_CODE (f2))
976 return 0;
977
978 /* A declaration with deduced return type should use its pre-deduction
979 type for declaration matching. */
980 r2 = fndecl_declared_return_type (olddecl);
981
982 if (same_type_p (TREE_TYPE (f1), r2))
983 {
984 if (!prototype_p (f2) && DECL_EXTERN_C_P (olddecl)
985 && fndecl_built_in_p (olddecl))
986 {
987 types_match = self_promoting_args_p (p1);
988 if (p1 == void_list_node)
989 TREE_TYPE (newdecl) = TREE_TYPE (olddecl);
990 }
991 else
992 types_match =
993 compparms (p1, p2)
994 && type_memfn_rqual (f1) == type_memfn_rqual (f2)
995 && (TYPE_ATTRIBUTES (TREE_TYPE (newdecl)) == NULL_TREE
996 || comp_type_attributes (TREE_TYPE (newdecl),
997 TREE_TYPE (olddecl)) != 0);
998 }
999 else
1000 types_match = 0;
1001
1002 /* The decls dont match if they correspond to two different versions
1003 of the same function. Disallow extern "C" functions to be
1004 versions for now. */
1005 if (types_match
1006 && !DECL_EXTERN_C_P (newdecl)
1007 && !DECL_EXTERN_C_P (olddecl)
1008 && record_versions
1009 && maybe_version_functions (newdecl, olddecl,
1010 (!DECL_FUNCTION_VERSIONED (newdecl)
1011 || !DECL_FUNCTION_VERSIONED (olddecl))))
1012 return 0;
1013 }
1014 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1015 {
1016 tree oldres = DECL_TEMPLATE_RESULT (olddecl);
1017 tree newres = DECL_TEMPLATE_RESULT (newdecl);
1018
1019 if (TREE_CODE (newres) != TREE_CODE (oldres))
1020 return 0;
1021
1022 if (!comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1023 DECL_TEMPLATE_PARMS (olddecl)))
1024 return 0;
1025
1026 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1027 types_match = (same_type_p (TREE_TYPE (oldres), TREE_TYPE (newres))
1028 && equivalently_constrained (olddecl, newdecl));
1029 else
1030 // We don't need to check equivalently_constrained for variable and
1031 // function templates because we check it on the results.
1032 types_match = decls_match (oldres, newres);
1033 }
1034 else
1035 {
1036 /* Need to check scope for variable declaration (VAR_DECL).
1037 For typedef (TYPE_DECL), scope is ignored. */
1038 if (VAR_P (newdecl)
1039 && CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl)
1040 /* [dcl.link]
1041 Two declarations for an object with C language linkage
1042 with the same name (ignoring the namespace that qualify
1043 it) that appear in different namespace scopes refer to
1044 the same object. */
1045 && !(DECL_EXTERN_C_P (olddecl) && DECL_EXTERN_C_P (newdecl)))
1046 return 0;
1047
1048 if (TREE_TYPE (newdecl) == error_mark_node)
1049 types_match = TREE_TYPE (olddecl) == error_mark_node;
1050 else if (TREE_TYPE (olddecl) == NULL_TREE)
1051 types_match = TREE_TYPE (newdecl) == NULL_TREE;
1052 else if (TREE_TYPE (newdecl) == NULL_TREE)
1053 types_match = 0;
1054 else
1055 types_match = comptypes (TREE_TYPE (newdecl),
1056 TREE_TYPE (olddecl),
1057 COMPARE_REDECLARATION);
1058 }
1059
1060 // Normal functions can be constrained, as can variable partial
1061 // specializations.
1062 if (types_match && VAR_OR_FUNCTION_DECL_P (newdecl))
1063 types_match = equivalently_constrained (newdecl, olddecl);
1064
1065 return types_match;
1066 }
1067
1068 /* NEWDECL and OLDDECL have identical signatures. If they are
1069 different versions adjust them and return true.
1070 If RECORD is set to true, record function versions. */
1071
1072 bool
maybe_version_functions(tree newdecl,tree olddecl,bool record)1073 maybe_version_functions (tree newdecl, tree olddecl, bool record)
1074 {
1075 if (!targetm.target_option.function_versions (newdecl, olddecl))
1076 return false;
1077
1078 if (!DECL_FUNCTION_VERSIONED (olddecl))
1079 {
1080 DECL_FUNCTION_VERSIONED (olddecl) = 1;
1081 if (DECL_ASSEMBLER_NAME_SET_P (olddecl))
1082 mangle_decl (olddecl);
1083 }
1084
1085 if (!DECL_FUNCTION_VERSIONED (newdecl))
1086 {
1087 DECL_FUNCTION_VERSIONED (newdecl) = 1;
1088 if (DECL_ASSEMBLER_NAME_SET_P (newdecl))
1089 mangle_decl (newdecl);
1090 }
1091
1092 if (record)
1093 cgraph_node::record_function_versions (olddecl, newdecl);
1094
1095 return true;
1096 }
1097
1098 /* If NEWDECL is `static' and an `extern' was seen previously,
1099 warn about it. OLDDECL is the previous declaration.
1100
1101 Note that this does not apply to the C++ case of declaring
1102 a variable `extern const' and then later `const'.
1103
1104 Don't complain about built-in functions, since they are beyond
1105 the user's control. */
1106
1107 void
warn_extern_redeclared_static(tree newdecl,tree olddecl)1108 warn_extern_redeclared_static (tree newdecl, tree olddecl)
1109 {
1110 if (TREE_CODE (newdecl) == TYPE_DECL
1111 || TREE_CODE (newdecl) == TEMPLATE_DECL
1112 || TREE_CODE (newdecl) == CONST_DECL
1113 || TREE_CODE (newdecl) == NAMESPACE_DECL)
1114 return;
1115
1116 /* Don't get confused by static member functions; that's a different
1117 use of `static'. */
1118 if (TREE_CODE (newdecl) == FUNCTION_DECL
1119 && DECL_STATIC_FUNCTION_P (newdecl))
1120 return;
1121
1122 /* If the old declaration was `static', or the new one isn't, then
1123 everything is OK. */
1124 if (DECL_THIS_STATIC (olddecl) || !DECL_THIS_STATIC (newdecl))
1125 return;
1126
1127 /* It's OK to declare a builtin function as `static'. */
1128 if (TREE_CODE (olddecl) == FUNCTION_DECL
1129 && DECL_ARTIFICIAL (olddecl))
1130 return;
1131
1132 auto_diagnostic_group d;
1133 if (permerror (DECL_SOURCE_LOCATION (newdecl),
1134 "%qD was declared %<extern%> and later %<static%>", newdecl))
1135 inform (DECL_SOURCE_LOCATION (olddecl),
1136 "previous declaration of %qD", olddecl);
1137 }
1138
1139 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1140 function templates. If their exception specifications do not
1141 match, issue a diagnostic. */
1142
1143 static void
check_redeclaration_exception_specification(tree new_decl,tree old_decl)1144 check_redeclaration_exception_specification (tree new_decl,
1145 tree old_decl)
1146 {
1147 tree new_exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (new_decl));
1148 tree old_exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old_decl));
1149
1150 /* Two default specs are equivalent, don't force evaluation. */
1151 if (UNEVALUATED_NOEXCEPT_SPEC_P (new_exceptions)
1152 && UNEVALUATED_NOEXCEPT_SPEC_P (old_exceptions))
1153 return;
1154
1155 if (!type_dependent_expression_p (old_decl))
1156 {
1157 maybe_instantiate_noexcept (new_decl);
1158 maybe_instantiate_noexcept (old_decl);
1159 }
1160 new_exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (new_decl));
1161 old_exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (old_decl));
1162
1163 /* [except.spec]
1164
1165 If any declaration of a function has an exception-specification,
1166 all declarations, including the definition and an explicit
1167 specialization, of that function shall have an
1168 exception-specification with the same set of type-ids. */
1169 if (! DECL_IS_BUILTIN (old_decl)
1170 && !comp_except_specs (new_exceptions, old_exceptions, ce_normal))
1171 {
1172 const char *const msg
1173 = G_("declaration of %qF has a different exception specifier");
1174 bool complained = true;
1175 location_t new_loc = DECL_SOURCE_LOCATION (new_decl);
1176 auto_diagnostic_group d;
1177 if (DECL_IN_SYSTEM_HEADER (old_decl))
1178 complained = pedwarn (new_loc, OPT_Wsystem_headers, msg, new_decl);
1179 else if (!flag_exceptions)
1180 /* We used to silently permit mismatched eh specs with
1181 -fno-exceptions, so make them a pedwarn now. */
1182 complained = pedwarn (new_loc, OPT_Wpedantic, msg, new_decl);
1183 else
1184 error_at (new_loc, msg, new_decl);
1185 if (complained)
1186 inform (DECL_SOURCE_LOCATION (old_decl),
1187 "from previous declaration %qF", old_decl);
1188 }
1189 }
1190
1191 /* Return true if OLD_DECL and NEW_DECL agree on constexprness.
1192 Otherwise issue diagnostics. */
1193
1194 static bool
validate_constexpr_redeclaration(tree old_decl,tree new_decl)1195 validate_constexpr_redeclaration (tree old_decl, tree new_decl)
1196 {
1197 old_decl = STRIP_TEMPLATE (old_decl);
1198 new_decl = STRIP_TEMPLATE (new_decl);
1199 if (!VAR_OR_FUNCTION_DECL_P (old_decl)
1200 || !VAR_OR_FUNCTION_DECL_P (new_decl))
1201 return true;
1202 if (DECL_DECLARED_CONSTEXPR_P (old_decl)
1203 == DECL_DECLARED_CONSTEXPR_P (new_decl))
1204 return true;
1205 if (TREE_CODE (old_decl) == FUNCTION_DECL)
1206 {
1207 if (fndecl_built_in_p (old_decl))
1208 {
1209 /* Hide a built-in declaration. */
1210 DECL_DECLARED_CONSTEXPR_P (old_decl)
1211 = DECL_DECLARED_CONSTEXPR_P (new_decl);
1212 return true;
1213 }
1214 /* 7.1.5 [dcl.constexpr]
1215 Note: An explicit specialization can differ from the template
1216 declaration with respect to the constexpr specifier. */
1217 if (! DECL_TEMPLATE_SPECIALIZATION (old_decl)
1218 && DECL_TEMPLATE_SPECIALIZATION (new_decl))
1219 return true;
1220
1221 error_at (DECL_SOURCE_LOCATION (new_decl),
1222 "redeclaration %qD differs in %<constexpr%> "
1223 "from previous declaration", new_decl);
1224 inform (DECL_SOURCE_LOCATION (old_decl),
1225 "previous declaration %qD", old_decl);
1226 return false;
1227 }
1228 return true;
1229 }
1230
1231 // If OLDDECL and NEWDECL are concept declarations with the same type
1232 // (i.e., and template parameters), but different requirements,
1233 // emit diagnostics and return true. Otherwise, return false.
1234 static inline bool
check_concept_refinement(tree olddecl,tree newdecl)1235 check_concept_refinement (tree olddecl, tree newdecl)
1236 {
1237 if (!DECL_DECLARED_CONCEPT_P (olddecl) || !DECL_DECLARED_CONCEPT_P (newdecl))
1238 return false;
1239
1240 tree d1 = DECL_TEMPLATE_RESULT (olddecl);
1241 tree d2 = DECL_TEMPLATE_RESULT (newdecl);
1242 if (TREE_CODE (d1) != TREE_CODE (d2))
1243 return false;
1244
1245 tree t1 = TREE_TYPE (d1);
1246 tree t2 = TREE_TYPE (d2);
1247 if (TREE_CODE (d1) == FUNCTION_DECL)
1248 {
1249 if (compparms (TYPE_ARG_TYPES (t1), TYPE_ARG_TYPES (t2))
1250 && comp_template_parms (DECL_TEMPLATE_PARMS (olddecl),
1251 DECL_TEMPLATE_PARMS (newdecl))
1252 && !equivalently_constrained (olddecl, newdecl))
1253 {
1254 error ("cannot specialize concept %q#D", olddecl);
1255 return true;
1256 }
1257 }
1258 return false;
1259 }
1260
1261 /* DECL is a redeclaration of a function or function template. If
1262 it does have default arguments issue a diagnostic. Note: this
1263 function is used to enforce the requirements in C++11 8.3.6 about
1264 no default arguments in redeclarations. */
1265
1266 static void
check_redeclaration_no_default_args(tree decl)1267 check_redeclaration_no_default_args (tree decl)
1268 {
1269 gcc_assert (DECL_DECLARES_FUNCTION_P (decl));
1270
1271 for (tree t = FUNCTION_FIRST_USER_PARMTYPE (decl);
1272 t && t != void_list_node; t = TREE_CHAIN (t))
1273 if (TREE_PURPOSE (t))
1274 {
1275 permerror (DECL_SOURCE_LOCATION (decl),
1276 "redeclaration of %q#D may not have default "
1277 "arguments", decl);
1278 return;
1279 }
1280 }
1281
1282 /* NEWDECL is a redeclaration of a function or function template OLDDECL,
1283 in any case represented as FUNCTION_DECLs (the DECL_TEMPLATE_RESULTs of
1284 the TEMPLATE_DECLs in case of function templates). This function is used
1285 to enforce the final part of C++17 11.3.6/4, about a single declaration:
1286 "If a friend declaration specifies a default argument expression, that
1287 declaration shall be a definition and shall be the only declaration of
1288 the function or function template in the translation unit." */
1289
1290 static void
check_no_redeclaration_friend_default_args(tree olddecl,tree newdecl,bool olddecl_hidden_friend_p)1291 check_no_redeclaration_friend_default_args (tree olddecl, tree newdecl,
1292 bool olddecl_hidden_friend_p)
1293 {
1294 if (!olddecl_hidden_friend_p && !DECL_FRIEND_P (newdecl))
1295 return;
1296
1297 tree t1 = FUNCTION_FIRST_USER_PARMTYPE (olddecl);
1298 tree t2 = FUNCTION_FIRST_USER_PARMTYPE (newdecl);
1299
1300 for (; t1 && t1 != void_list_node;
1301 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1302 if ((olddecl_hidden_friend_p && TREE_PURPOSE (t1))
1303 || (DECL_FRIEND_P (newdecl) && TREE_PURPOSE (t2)))
1304 {
1305 auto_diagnostic_group d;
1306 if (permerror (DECL_SOURCE_LOCATION (newdecl),
1307 "friend declaration of %q#D specifies default "
1308 "arguments and isn%'t the only declaration", newdecl))
1309 inform (DECL_SOURCE_LOCATION (olddecl),
1310 "previous declaration of %q#D", olddecl);
1311 return;
1312 }
1313 }
1314
1315 /* Merge tree bits that correspond to attributes noreturn, nothrow,
1316 const, malloc, and pure from NEWDECL with those of OLDDECL. */
1317
1318 static void
merge_attribute_bits(tree newdecl,tree olddecl)1319 merge_attribute_bits (tree newdecl, tree olddecl)
1320 {
1321 TREE_THIS_VOLATILE (newdecl) |= TREE_THIS_VOLATILE (olddecl);
1322 TREE_THIS_VOLATILE (olddecl) |= TREE_THIS_VOLATILE (newdecl);
1323 TREE_NOTHROW (newdecl) |= TREE_NOTHROW (olddecl);
1324 TREE_NOTHROW (olddecl) |= TREE_NOTHROW (newdecl);
1325 TREE_READONLY (newdecl) |= TREE_READONLY (olddecl);
1326 TREE_READONLY (olddecl) |= TREE_READONLY (newdecl);
1327 DECL_IS_MALLOC (newdecl) |= DECL_IS_MALLOC (olddecl);
1328 DECL_IS_MALLOC (olddecl) |= DECL_IS_MALLOC (newdecl);
1329 DECL_PURE_P (newdecl) |= DECL_PURE_P (olddecl);
1330 DECL_PURE_P (olddecl) |= DECL_PURE_P (newdecl);
1331 DECL_UNINLINABLE (newdecl) |= DECL_UNINLINABLE (olddecl);
1332 DECL_UNINLINABLE (olddecl) |= DECL_UNINLINABLE (newdecl);
1333 }
1334
1335 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1336 && lookup_attribute ("gnu_inline", \
1337 DECL_ATTRIBUTES (fn)))
1338
1339 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1340 If the redeclaration is invalid, a diagnostic is issued, and the
1341 error_mark_node is returned. Otherwise, OLDDECL is returned.
1342
1343 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1344 returned.
1345
1346 NEWDECL_IS_FRIEND is true if NEWDECL was declared as a friend. */
1347
1348 tree
duplicate_decls(tree newdecl,tree olddecl,bool newdecl_is_friend)1349 duplicate_decls (tree newdecl, tree olddecl, bool newdecl_is_friend)
1350 {
1351 unsigned olddecl_uid = DECL_UID (olddecl);
1352 int olddecl_friend = 0, types_match = 0, hidden_friend = 0;
1353 int olddecl_hidden_friend = 0;
1354 int new_defines_function = 0;
1355 tree new_template_info;
1356 location_t olddecl_loc = DECL_SOURCE_LOCATION (olddecl);
1357 location_t newdecl_loc = DECL_SOURCE_LOCATION (newdecl);
1358
1359 if (newdecl == olddecl)
1360 return olddecl;
1361
1362 types_match = decls_match (newdecl, olddecl);
1363
1364 /* If either the type of the new decl or the type of the old decl is an
1365 error_mark_node, then that implies that we have already issued an
1366 error (earlier) for some bogus type specification, and in that case,
1367 it is rather pointless to harass the user with yet more error message
1368 about the same declaration, so just pretend the types match here. */
1369 if (TREE_TYPE (newdecl) == error_mark_node
1370 || TREE_TYPE (olddecl) == error_mark_node)
1371 return error_mark_node;
1372
1373 /* Check for redeclaration and other discrepancies. */
1374 if (TREE_CODE (olddecl) == FUNCTION_DECL
1375 && DECL_ARTIFICIAL (olddecl))
1376 {
1377 gcc_assert (!DECL_HIDDEN_FRIEND_P (olddecl));
1378 if (TREE_CODE (newdecl) != FUNCTION_DECL)
1379 {
1380 /* Avoid warnings redeclaring built-ins which have not been
1381 explicitly declared. */
1382 if (DECL_ANTICIPATED (olddecl))
1383 {
1384 if (TREE_PUBLIC (newdecl)
1385 && CP_DECL_CONTEXT (newdecl) == global_namespace)
1386 warning_at (newdecl_loc,
1387 OPT_Wbuiltin_declaration_mismatch,
1388 "built-in function %qD declared as non-function",
1389 newdecl);
1390 return NULL_TREE;
1391 }
1392
1393 /* If you declare a built-in or predefined function name as static,
1394 the old definition is overridden, but optionally warn this was a
1395 bad choice of name. */
1396 if (! TREE_PUBLIC (newdecl))
1397 {
1398 warning_at (newdecl_loc,
1399 OPT_Wshadow,
1400 fndecl_built_in_p (olddecl)
1401 ? G_("shadowing built-in function %q#D")
1402 : G_("shadowing library function %q#D"), olddecl);
1403 /* Discard the old built-in function. */
1404 return NULL_TREE;
1405 }
1406 /* If the built-in is not ansi, then programs can override
1407 it even globally without an error. */
1408 else if (! fndecl_built_in_p (olddecl))
1409 warning_at (newdecl_loc, 0,
1410 "library function %q#D redeclared as non-function %q#D",
1411 olddecl, newdecl);
1412 else
1413 error_at (newdecl_loc,
1414 "declaration of %q#D conflicts with built-in "
1415 "declaration %q#D", newdecl, olddecl);
1416 return NULL_TREE;
1417 }
1418 else if (DECL_OMP_DECLARE_REDUCTION_P (olddecl))
1419 {
1420 gcc_assert (DECL_OMP_DECLARE_REDUCTION_P (newdecl));
1421 error_at (newdecl_loc,
1422 "redeclaration of %<pragma omp declare reduction%>");
1423 inform (olddecl_loc,
1424 "previous %<pragma omp declare reduction%> declaration");
1425 return error_mark_node;
1426 }
1427 else if (!types_match)
1428 {
1429 /* Avoid warnings redeclaring built-ins which have not been
1430 explicitly declared. */
1431 if (DECL_ANTICIPATED (olddecl))
1432 {
1433 tree t1, t2;
1434
1435 /* A new declaration doesn't match a built-in one unless it
1436 is also extern "C". */
1437 gcc_assert (DECL_IS_BUILTIN (olddecl));
1438 gcc_assert (DECL_EXTERN_C_P (olddecl));
1439 if (!DECL_EXTERN_C_P (newdecl))
1440 return NULL_TREE;
1441
1442 for (t1 = TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1443 t2 = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1444 t1 || t2;
1445 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
1446 {
1447 if (!t1 || !t2)
1448 break;
1449 /* FILE, tm types are not known at the time
1450 we create the builtins. */
1451 for (unsigned i = 0;
1452 i < sizeof (builtin_structptr_types)
1453 / sizeof (builtin_structptr_type);
1454 ++i)
1455 if (TREE_VALUE (t2) == builtin_structptr_types[i].node)
1456 {
1457 tree t = TREE_VALUE (t1);
1458
1459 if (TYPE_PTR_P (t)
1460 && TYPE_IDENTIFIER (TREE_TYPE (t))
1461 == get_identifier (builtin_structptr_types[i].str)
1462 && compparms (TREE_CHAIN (t1), TREE_CHAIN (t2)))
1463 {
1464 tree oldargs = TYPE_ARG_TYPES (TREE_TYPE (olddecl));
1465
1466 TYPE_ARG_TYPES (TREE_TYPE (olddecl))
1467 = TYPE_ARG_TYPES (TREE_TYPE (newdecl));
1468 types_match = decls_match (newdecl, olddecl);
1469 if (types_match)
1470 return duplicate_decls (newdecl, olddecl,
1471 newdecl_is_friend);
1472 TYPE_ARG_TYPES (TREE_TYPE (olddecl)) = oldargs;
1473 }
1474 goto next_arg;
1475 }
1476
1477 if (! same_type_p (TREE_VALUE (t1), TREE_VALUE (t2)))
1478 break;
1479 next_arg:;
1480 }
1481
1482 warning_at (newdecl_loc,
1483 OPT_Wbuiltin_declaration_mismatch,
1484 "declaration of %q#D conflicts with built-in "
1485 "declaration %q#D", newdecl, olddecl);
1486 }
1487 else if ((DECL_EXTERN_C_P (newdecl)
1488 && DECL_EXTERN_C_P (olddecl))
1489 || compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1490 TYPE_ARG_TYPES (TREE_TYPE (olddecl))))
1491 {
1492 /* Don't really override olddecl for __* prefixed builtins
1493 except for __[^b]*_chk, the compiler might be using those
1494 explicitly. */
1495 if (fndecl_built_in_p (olddecl))
1496 {
1497 tree id = DECL_NAME (olddecl);
1498 const char *name = IDENTIFIER_POINTER (id);
1499 size_t len;
1500
1501 if (name[0] == '_'
1502 && name[1] == '_'
1503 && (strncmp (name + 2, "builtin_",
1504 strlen ("builtin_")) == 0
1505 || (len = strlen (name)) <= strlen ("___chk")
1506 || memcmp (name + len - strlen ("_chk"),
1507 "_chk", strlen ("_chk") + 1) != 0))
1508 {
1509 if (DECL_INITIAL (newdecl))
1510 {
1511 error_at (newdecl_loc,
1512 "definition of %q#D ambiguates built-in "
1513 "declaration %q#D", newdecl, olddecl);
1514 return error_mark_node;
1515 }
1516 auto_diagnostic_group d;
1517 if (permerror (newdecl_loc,
1518 "new declaration %q#D ambiguates built-in"
1519 " declaration %q#D", newdecl, olddecl)
1520 && flag_permissive)
1521 inform (newdecl_loc,
1522 "ignoring the %q#D declaration", newdecl);
1523 return flag_permissive ? olddecl : error_mark_node;
1524 }
1525 }
1526
1527 /* A near match; override the builtin. */
1528
1529 if (TREE_PUBLIC (newdecl))
1530 warning_at (newdecl_loc,
1531 OPT_Wbuiltin_declaration_mismatch,
1532 "new declaration %q#D ambiguates built-in "
1533 "declaration %q#D", newdecl, olddecl);
1534 else
1535 warning (OPT_Wshadow,
1536 fndecl_built_in_p (olddecl)
1537 ? G_("shadowing built-in function %q#D")
1538 : G_("shadowing library function %q#D"), olddecl);
1539 }
1540 else
1541 /* Discard the old built-in function. */
1542 return NULL_TREE;
1543
1544 /* Replace the old RTL to avoid problems with inlining. */
1545 COPY_DECL_RTL (newdecl, olddecl);
1546 }
1547 /* Even if the types match, prefer the new declarations type for
1548 built-ins which have not been explicitly declared, for
1549 exception lists, etc... */
1550 else if (DECL_IS_BUILTIN (olddecl))
1551 {
1552 tree type = TREE_TYPE (newdecl);
1553 tree attribs = (*targetm.merge_type_attributes)
1554 (TREE_TYPE (olddecl), type);
1555
1556 type = cp_build_type_attribute_variant (type, attribs);
1557 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = type;
1558 }
1559
1560 /* If a function is explicitly declared "throw ()", propagate that to
1561 the corresponding builtin. */
1562 if (DECL_BUILT_IN_CLASS (olddecl) == BUILT_IN_NORMAL
1563 && DECL_ANTICIPATED (olddecl)
1564 && TREE_NOTHROW (newdecl)
1565 && !TREE_NOTHROW (olddecl))
1566 {
1567 enum built_in_function fncode = DECL_FUNCTION_CODE (olddecl);
1568 tree tmpdecl = builtin_decl_explicit (fncode);
1569 if (tmpdecl && tmpdecl != olddecl && types_match)
1570 TREE_NOTHROW (tmpdecl) = 1;
1571 }
1572
1573 /* Whether or not the builtin can throw exceptions has no
1574 bearing on this declarator. */
1575 TREE_NOTHROW (olddecl) = 0;
1576
1577 if (DECL_THIS_STATIC (newdecl) && !DECL_THIS_STATIC (olddecl))
1578 {
1579 /* If a builtin function is redeclared as `static', merge
1580 the declarations, but make the original one static. */
1581 DECL_THIS_STATIC (olddecl) = 1;
1582 TREE_PUBLIC (olddecl) = 0;
1583
1584 /* Make the old declaration consistent with the new one so
1585 that all remnants of the builtin-ness of this function
1586 will be banished. */
1587 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
1588 COPY_DECL_RTL (newdecl, olddecl);
1589 }
1590 }
1591 else if (TREE_CODE (olddecl) != TREE_CODE (newdecl))
1592 {
1593 /* C++ Standard, 3.3, clause 4:
1594 "[Note: a namespace name or a class template name must be unique
1595 in its declarative region (7.3.2, clause 14). ]" */
1596 if (TREE_CODE (olddecl) == NAMESPACE_DECL
1597 || TREE_CODE (newdecl) == NAMESPACE_DECL)
1598 /* Namespace conflicts with not namespace. */;
1599 else if (DECL_TYPE_TEMPLATE_P (olddecl)
1600 || DECL_TYPE_TEMPLATE_P (newdecl))
1601 /* Class template conflicts. */;
1602 else if ((TREE_CODE (newdecl) == FUNCTION_DECL
1603 && DECL_FUNCTION_TEMPLATE_P (olddecl))
1604 || (TREE_CODE (olddecl) == FUNCTION_DECL
1605 && DECL_FUNCTION_TEMPLATE_P (newdecl)))
1606 {
1607 /* One is a function and the other is a template
1608 function. */
1609 if (!UDLIT_OPER_P (DECL_NAME (newdecl)))
1610 return NULL_TREE;
1611
1612 /* There can only be one! */
1613 if (TREE_CODE (newdecl) == TEMPLATE_DECL
1614 && check_raw_literal_operator (olddecl))
1615 error_at (newdecl_loc,
1616 "literal operator %q#D conflicts with"
1617 " raw literal operator", newdecl);
1618 else if (check_raw_literal_operator (newdecl))
1619 error_at (newdecl_loc,
1620 "raw literal operator %q#D conflicts with"
1621 " literal operator template", newdecl);
1622 else
1623 return NULL_TREE;
1624
1625 inform (olddecl_loc, "previous declaration %q#D", olddecl);
1626 return error_mark_node;
1627 }
1628 else if (DECL_IMPLICIT_TYPEDEF_P (olddecl)
1629 || DECL_IMPLICIT_TYPEDEF_P (newdecl))
1630 /* One is an implicit typedef, that's ok. */
1631 return NULL_TREE;
1632
1633 error ("%q#D redeclared as different kind of entity", newdecl);
1634 inform (olddecl_loc, "previous declaration %q#D", olddecl);
1635
1636 return error_mark_node;
1637 }
1638 else if (!types_match)
1639 {
1640 if (CP_DECL_CONTEXT (newdecl) != CP_DECL_CONTEXT (olddecl))
1641 /* These are certainly not duplicate declarations; they're
1642 from different scopes. */
1643 return NULL_TREE;
1644
1645 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
1646 {
1647 /* The name of a class template may not be declared to refer to
1648 any other template, class, function, object, namespace, value,
1649 or type in the same scope. */
1650 if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == TYPE_DECL
1651 || TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
1652 {
1653 error_at (newdecl_loc,
1654 "conflicting declaration of template %q#D", newdecl);
1655 inform (olddecl_loc,
1656 "previous declaration %q#D", olddecl);
1657 return error_mark_node;
1658 }
1659 else if (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl)) == FUNCTION_DECL
1660 && TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == FUNCTION_DECL
1661 && compparms (TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (olddecl))),
1662 TYPE_ARG_TYPES (TREE_TYPE (DECL_TEMPLATE_RESULT (newdecl))))
1663 && comp_template_parms (DECL_TEMPLATE_PARMS (newdecl),
1664 DECL_TEMPLATE_PARMS (olddecl))
1665 /* Template functions can be disambiguated by
1666 return type. */
1667 && same_type_p (TREE_TYPE (TREE_TYPE (newdecl)),
1668 TREE_TYPE (TREE_TYPE (olddecl)))
1669 /* Template functions can also be disambiguated by
1670 constraints. */
1671 && equivalently_constrained (olddecl, newdecl))
1672 {
1673 error_at (newdecl_loc, "ambiguating new declaration %q#D",
1674 newdecl);
1675 inform (olddecl_loc,
1676 "old declaration %q#D", olddecl);
1677 }
1678 else if (check_concept_refinement (olddecl, newdecl))
1679 return error_mark_node;
1680 return NULL_TREE;
1681 }
1682 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1683 {
1684 if (DECL_EXTERN_C_P (newdecl) && DECL_EXTERN_C_P (olddecl))
1685 {
1686 error_at (newdecl_loc,
1687 "conflicting declaration of C function %q#D",
1688 newdecl);
1689 inform (olddecl_loc,
1690 "previous declaration %q#D", olddecl);
1691 return NULL_TREE;
1692 }
1693 /* For function versions, params and types match, but they
1694 are not ambiguous. */
1695 else if ((!DECL_FUNCTION_VERSIONED (newdecl)
1696 && !DECL_FUNCTION_VERSIONED (olddecl))
1697 // The functions have the same parameter types.
1698 && compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)),
1699 TYPE_ARG_TYPES (TREE_TYPE (olddecl)))
1700 // And the same constraints.
1701 && equivalently_constrained (newdecl, olddecl))
1702 {
1703 error_at (newdecl_loc,
1704 "ambiguating new declaration of %q#D", newdecl);
1705 inform (olddecl_loc,
1706 "old declaration %q#D", olddecl);
1707 return error_mark_node;
1708 }
1709 else
1710 return NULL_TREE;
1711 }
1712 else
1713 {
1714 error_at (newdecl_loc, "conflicting declaration %q#D", newdecl);
1715 inform (olddecl_loc,
1716 "previous declaration as %q#D", olddecl);
1717 return error_mark_node;
1718 }
1719 }
1720 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1721 && ((DECL_TEMPLATE_SPECIALIZATION (olddecl)
1722 && (!DECL_TEMPLATE_INFO (newdecl)
1723 || (DECL_TI_TEMPLATE (newdecl)
1724 != DECL_TI_TEMPLATE (olddecl))))
1725 || (DECL_TEMPLATE_SPECIALIZATION (newdecl)
1726 && (!DECL_TEMPLATE_INFO (olddecl)
1727 || (DECL_TI_TEMPLATE (olddecl)
1728 != DECL_TI_TEMPLATE (newdecl))))))
1729 /* It's OK to have a template specialization and a non-template
1730 with the same type, or to have specializations of two
1731 different templates with the same type. Note that if one is a
1732 specialization, and the other is an instantiation of the same
1733 template, that we do not exit at this point. That situation
1734 can occur if we instantiate a template class, and then
1735 specialize one of its methods. This situation is valid, but
1736 the declarations must be merged in the usual way. */
1737 return NULL_TREE;
1738 else if (TREE_CODE (newdecl) == FUNCTION_DECL
1739 && ((DECL_TEMPLATE_INSTANTIATION (olddecl)
1740 && !DECL_USE_TEMPLATE (newdecl))
1741 || (DECL_TEMPLATE_INSTANTIATION (newdecl)
1742 && !DECL_USE_TEMPLATE (olddecl))))
1743 /* One of the declarations is a template instantiation, and the
1744 other is not a template at all. That's OK. */
1745 return NULL_TREE;
1746 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
1747 {
1748 /* In [namespace.alias] we have:
1749
1750 In a declarative region, a namespace-alias-definition can be
1751 used to redefine a namespace-alias declared in that declarative
1752 region to refer only to the namespace to which it already
1753 refers.
1754
1755 Therefore, if we encounter a second alias directive for the same
1756 alias, we can just ignore the second directive. */
1757 if (DECL_NAMESPACE_ALIAS (newdecl)
1758 && (DECL_NAMESPACE_ALIAS (newdecl)
1759 == DECL_NAMESPACE_ALIAS (olddecl)))
1760 return olddecl;
1761
1762 /* Leave it to update_binding to merge or report error. */
1763 return NULL_TREE;
1764 }
1765 else
1766 {
1767 const char *errmsg = redeclaration_error_message (newdecl, olddecl);
1768 if (errmsg)
1769 {
1770 auto_diagnostic_group d;
1771 error_at (newdecl_loc, errmsg, newdecl);
1772 if (DECL_NAME (olddecl) != NULL_TREE)
1773 inform (olddecl_loc,
1774 (DECL_INITIAL (olddecl) && namespace_bindings_p ())
1775 ? G_("%q#D previously defined here")
1776 : G_("%q#D previously declared here"), olddecl);
1777 return error_mark_node;
1778 }
1779 else if (TREE_CODE (olddecl) == FUNCTION_DECL
1780 && DECL_INITIAL (olddecl) != NULL_TREE
1781 && !prototype_p (TREE_TYPE (olddecl))
1782 && prototype_p (TREE_TYPE (newdecl)))
1783 {
1784 /* Prototype decl follows defn w/o prototype. */
1785 auto_diagnostic_group d;
1786 if (warning_at (newdecl_loc, 0,
1787 "prototype specified for %q#D", newdecl))
1788 inform (olddecl_loc,
1789 "previous non-prototype definition here");
1790 }
1791 else if (VAR_OR_FUNCTION_DECL_P (olddecl)
1792 && DECL_LANGUAGE (newdecl) != DECL_LANGUAGE (olddecl))
1793 {
1794 /* [dcl.link]
1795 If two declarations of the same function or object
1796 specify different linkage-specifications ..., the program
1797 is ill-formed.... Except for functions with C++ linkage,
1798 a function declaration without a linkage specification
1799 shall not precede the first linkage specification for
1800 that function. A function can be declared without a
1801 linkage specification after an explicit linkage
1802 specification has been seen; the linkage explicitly
1803 specified in the earlier declaration is not affected by
1804 such a function declaration.
1805
1806 DR 563 raises the question why the restrictions on
1807 functions should not also apply to objects. Older
1808 versions of G++ silently ignore the linkage-specification
1809 for this example:
1810
1811 namespace N {
1812 extern int i;
1813 extern "C" int i;
1814 }
1815
1816 which is clearly wrong. Therefore, we now treat objects
1817 like functions. */
1818 if (current_lang_depth () == 0)
1819 {
1820 /* There is no explicit linkage-specification, so we use
1821 the linkage from the previous declaration. */
1822 retrofit_lang_decl (newdecl);
1823 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
1824 }
1825 else
1826 {
1827 auto_diagnostic_group d;
1828 error_at (newdecl_loc,
1829 "conflicting declaration of %q#D with %qL linkage",
1830 newdecl, DECL_LANGUAGE (newdecl));
1831 inform (olddecl_loc,
1832 "previous declaration with %qL linkage",
1833 DECL_LANGUAGE (olddecl));
1834 }
1835 }
1836
1837 if (DECL_LANG_SPECIFIC (olddecl) && DECL_USE_TEMPLATE (olddecl))
1838 ;
1839 else if (TREE_CODE (olddecl) == FUNCTION_DECL)
1840 {
1841 /* Note: free functions, as TEMPLATE_DECLs, are handled below. */
1842 if (DECL_FUNCTION_MEMBER_P (olddecl)
1843 && (/* grokfndecl passes member function templates too
1844 as FUNCTION_DECLs. */
1845 DECL_TEMPLATE_INFO (olddecl)
1846 /* C++11 8.3.6/6.
1847 Default arguments for a member function of a class
1848 template shall be specified on the initial declaration
1849 of the member function within the class template. */
1850 || CLASSTYPE_TEMPLATE_INFO (CP_DECL_CONTEXT (olddecl))))
1851 check_redeclaration_no_default_args (newdecl);
1852 else
1853 {
1854 tree t1 = FUNCTION_FIRST_USER_PARMTYPE (olddecl);
1855 tree t2 = FUNCTION_FIRST_USER_PARMTYPE (newdecl);
1856 int i = 1;
1857
1858 for (; t1 && t1 != void_list_node;
1859 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2), i++)
1860 if (TREE_PURPOSE (t1) && TREE_PURPOSE (t2))
1861 {
1862 if (simple_cst_equal (TREE_PURPOSE (t1),
1863 TREE_PURPOSE (t2)) == 1)
1864 {
1865 auto_diagnostic_group d;
1866 if (permerror (newdecl_loc,
1867 "default argument given for parameter "
1868 "%d of %q#D", i, newdecl))
1869 inform (olddecl_loc,
1870 "previous specification in %q#D here",
1871 olddecl);
1872 }
1873 else
1874 {
1875 auto_diagnostic_group d;
1876 error_at (newdecl_loc,
1877 "default argument given for parameter %d "
1878 "of %q#D", i, newdecl);
1879 inform (olddecl_loc,
1880 "previous specification in %q#D here",
1881 olddecl);
1882 }
1883 }
1884
1885 /* C++17 11.3.6/4: "If a friend declaration specifies a default
1886 argument expression, that declaration... shall be the only
1887 declaration of the function or function template in the
1888 translation unit." */
1889 check_no_redeclaration_friend_default_args
1890 (olddecl, newdecl, DECL_HIDDEN_FRIEND_P (olddecl));
1891 }
1892 }
1893 }
1894
1895 /* Do not merge an implicit typedef with an explicit one. In:
1896
1897 class A;
1898 ...
1899 typedef class A A __attribute__ ((foo));
1900
1901 the attribute should apply only to the typedef. */
1902 if (TREE_CODE (olddecl) == TYPE_DECL
1903 && (DECL_IMPLICIT_TYPEDEF_P (olddecl)
1904 || DECL_IMPLICIT_TYPEDEF_P (newdecl)))
1905 return NULL_TREE;
1906
1907 if (!validate_constexpr_redeclaration (olddecl, newdecl))
1908 return error_mark_node;
1909
1910 /* We have committed to returning OLDDECL at this point. */
1911
1912 /* If new decl is `static' and an `extern' was seen previously,
1913 warn about it. */
1914 warn_extern_redeclared_static (newdecl, olddecl);
1915
1916 /* True to merge attributes between the declarations, false to
1917 set OLDDECL's attributes to those of NEWDECL (for template
1918 explicit specializations that specify their own attributes
1919 independent of those specified for the primary template). */
1920 const bool merge_attr = (TREE_CODE (newdecl) != FUNCTION_DECL
1921 || !DECL_TEMPLATE_SPECIALIZATION (newdecl)
1922 || DECL_TEMPLATE_SPECIALIZATION (olddecl));
1923
1924 if (TREE_CODE (newdecl) == FUNCTION_DECL)
1925 {
1926 if (merge_attr && diagnose_mismatched_attributes (olddecl, newdecl))
1927 inform (olddecl_loc, DECL_INITIAL (olddecl)
1928 ? G_("previous definition of %qD here")
1929 : G_("previous declaration of %qD here"), olddecl);
1930
1931 /* Now that functions must hold information normally held
1932 by field decls, there is extra work to do so that
1933 declaration information does not get destroyed during
1934 definition. */
1935 if (DECL_VINDEX (olddecl))
1936 DECL_VINDEX (newdecl) = DECL_VINDEX (olddecl);
1937 if (DECL_CONTEXT (olddecl))
1938 DECL_CONTEXT (newdecl) = DECL_CONTEXT (olddecl);
1939 DECL_STATIC_CONSTRUCTOR (newdecl) |= DECL_STATIC_CONSTRUCTOR (olddecl);
1940 DECL_STATIC_DESTRUCTOR (newdecl) |= DECL_STATIC_DESTRUCTOR (olddecl);
1941 DECL_PURE_VIRTUAL_P (newdecl) |= DECL_PURE_VIRTUAL_P (olddecl);
1942 DECL_VIRTUAL_P (newdecl) |= DECL_VIRTUAL_P (olddecl);
1943 DECL_INVALID_OVERRIDER_P (newdecl) |= DECL_INVALID_OVERRIDER_P (olddecl);
1944 DECL_FINAL_P (newdecl) |= DECL_FINAL_P (olddecl);
1945 DECL_OVERRIDE_P (newdecl) |= DECL_OVERRIDE_P (olddecl);
1946 DECL_THIS_STATIC (newdecl) |= DECL_THIS_STATIC (olddecl);
1947 if (DECL_OVERLOADED_OPERATOR_P (olddecl))
1948 DECL_OVERLOADED_OPERATOR_CODE_RAW (newdecl)
1949 = DECL_OVERLOADED_OPERATOR_CODE_RAW (olddecl);
1950 new_defines_function = DECL_INITIAL (newdecl) != NULL_TREE;
1951
1952 /* Optionally warn about more than one declaration for the same
1953 name, but don't warn about a function declaration followed by a
1954 definition. */
1955 if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
1956 && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
1957 /* Don't warn about extern decl followed by definition. */
1958 && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
1959 /* Don't warn about friends, let add_friend take care of it. */
1960 && ! (newdecl_is_friend || DECL_FRIEND_P (olddecl))
1961 /* Don't warn about declaration followed by specialization. */
1962 && (! DECL_TEMPLATE_SPECIALIZATION (newdecl)
1963 || DECL_TEMPLATE_SPECIALIZATION (olddecl)))
1964 {
1965 auto_diagnostic_group d;
1966 if (warning_at (newdecl_loc,
1967 OPT_Wredundant_decls,
1968 "redundant redeclaration of %qD in same scope",
1969 newdecl))
1970 inform (olddecl_loc,
1971 "previous declaration of %qD", olddecl);
1972 }
1973
1974 if (!(DECL_TEMPLATE_INSTANTIATION (olddecl)
1975 && DECL_TEMPLATE_SPECIALIZATION (newdecl)))
1976 {
1977 if (DECL_DELETED_FN (newdecl))
1978 {
1979 auto_diagnostic_group d;
1980 error_at (newdecl_loc, "deleted definition of %qD", newdecl);
1981 inform (olddecl_loc,
1982 "previous declaration of %qD", olddecl);
1983 }
1984 DECL_DELETED_FN (newdecl) |= DECL_DELETED_FN (olddecl);
1985 }
1986 }
1987
1988 /* Deal with C++: must preserve virtual function table size. */
1989 if (TREE_CODE (olddecl) == TYPE_DECL)
1990 {
1991 tree newtype = TREE_TYPE (newdecl);
1992 tree oldtype = TREE_TYPE (olddecl);
1993
1994 if (newtype != error_mark_node && oldtype != error_mark_node
1995 && TYPE_LANG_SPECIFIC (newtype) && TYPE_LANG_SPECIFIC (oldtype))
1996 CLASSTYPE_FRIEND_CLASSES (newtype)
1997 = CLASSTYPE_FRIEND_CLASSES (oldtype);
1998
1999 DECL_ORIGINAL_TYPE (newdecl) = DECL_ORIGINAL_TYPE (olddecl);
2000 }
2001
2002 /* Copy all the DECL_... slots specified in the new decl except for
2003 any that we copy here from the old type. */
2004 if (merge_attr)
2005 DECL_ATTRIBUTES (newdecl)
2006 = (*targetm.merge_decl_attributes) (olddecl, newdecl);
2007 else
2008 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
2009
2010 if (DECL_DECLARES_FUNCTION_P (olddecl))
2011 {
2012 olddecl_friend = DECL_FRIEND_P (olddecl);
2013 olddecl_hidden_friend = DECL_HIDDEN_FRIEND_P (olddecl);
2014 hidden_friend = (DECL_ANTICIPATED (olddecl)
2015 && DECL_HIDDEN_FRIEND_P (olddecl)
2016 && newdecl_is_friend);
2017 if (!hidden_friend)
2018 {
2019 DECL_ANTICIPATED (olddecl) = 0;
2020 DECL_HIDDEN_FRIEND_P (olddecl) = 0;
2021 }
2022 }
2023
2024 if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2025 {
2026 tree old_result = DECL_TEMPLATE_RESULT (olddecl);
2027 tree new_result = DECL_TEMPLATE_RESULT (newdecl);
2028 TREE_TYPE (olddecl) = TREE_TYPE (old_result);
2029 DECL_TEMPLATE_SPECIALIZATIONS (olddecl)
2030 = chainon (DECL_TEMPLATE_SPECIALIZATIONS (olddecl),
2031 DECL_TEMPLATE_SPECIALIZATIONS (newdecl));
2032
2033 DECL_ATTRIBUTES (old_result)
2034 = (*targetm.merge_decl_attributes) (old_result, new_result);
2035
2036 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
2037 {
2038 if (DECL_SOURCE_LOCATION (newdecl)
2039 != DECL_SOURCE_LOCATION (olddecl))
2040 {
2041 /* Per C++11 8.3.6/4, default arguments cannot be added in
2042 later declarations of a function template. */
2043 check_redeclaration_no_default_args (newdecl);
2044 /* C++17 11.3.6/4: "If a friend declaration specifies a default
2045 argument expression, that declaration... shall be the only
2046 declaration of the function or function template in the
2047 translation unit." */
2048 check_no_redeclaration_friend_default_args
2049 (old_result, new_result, olddecl_hidden_friend);
2050 }
2051
2052 check_default_args (newdecl);
2053
2054 if (GNU_INLINE_P (old_result) != GNU_INLINE_P (new_result)
2055 && DECL_INITIAL (new_result))
2056 {
2057 if (DECL_INITIAL (old_result))
2058 DECL_UNINLINABLE (old_result) = 1;
2059 else
2060 DECL_UNINLINABLE (old_result) = DECL_UNINLINABLE (new_result);
2061 DECL_EXTERNAL (old_result) = DECL_EXTERNAL (new_result);
2062 DECL_NOT_REALLY_EXTERN (old_result)
2063 = DECL_NOT_REALLY_EXTERN (new_result);
2064 DECL_INTERFACE_KNOWN (old_result)
2065 = DECL_INTERFACE_KNOWN (new_result);
2066 DECL_DECLARED_INLINE_P (old_result)
2067 = DECL_DECLARED_INLINE_P (new_result);
2068 DECL_DISREGARD_INLINE_LIMITS (old_result)
2069 |= DECL_DISREGARD_INLINE_LIMITS (new_result);
2070
2071 }
2072 else
2073 {
2074 DECL_DECLARED_INLINE_P (old_result)
2075 |= DECL_DECLARED_INLINE_P (new_result);
2076 DECL_DISREGARD_INLINE_LIMITS (old_result)
2077 |= DECL_DISREGARD_INLINE_LIMITS (new_result);
2078 check_redeclaration_exception_specification (newdecl, olddecl);
2079
2080 merge_attribute_bits (new_result, old_result);
2081 }
2082 }
2083
2084 /* If the new declaration is a definition, update the file and
2085 line information on the declaration, and also make
2086 the old declaration the same definition. */
2087 if (DECL_INITIAL (new_result) != NULL_TREE)
2088 {
2089 DECL_SOURCE_LOCATION (olddecl)
2090 = DECL_SOURCE_LOCATION (old_result)
2091 = DECL_SOURCE_LOCATION (newdecl);
2092 DECL_INITIAL (old_result) = DECL_INITIAL (new_result);
2093 if (DECL_FUNCTION_TEMPLATE_P (newdecl))
2094 {
2095 tree parm;
2096 DECL_ARGUMENTS (old_result)
2097 = DECL_ARGUMENTS (new_result);
2098 for (parm = DECL_ARGUMENTS (old_result); parm;
2099 parm = DECL_CHAIN (parm))
2100 DECL_CONTEXT (parm) = old_result;
2101 }
2102 }
2103
2104 return olddecl;
2105 }
2106
2107 if (types_match)
2108 {
2109 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2110 check_redeclaration_exception_specification (newdecl, olddecl);
2111
2112 /* Automatically handles default parameters. */
2113 tree oldtype = TREE_TYPE (olddecl);
2114 tree newtype;
2115
2116 /* For typedefs use the old type, as the new type's DECL_NAME points
2117 at newdecl, which will be ggc_freed. */
2118 if (TREE_CODE (newdecl) == TYPE_DECL)
2119 {
2120 /* But NEWTYPE might have an attribute, honor that. */
2121 tree tem = TREE_TYPE (newdecl);
2122 newtype = oldtype;
2123
2124 if (TYPE_USER_ALIGN (tem))
2125 {
2126 if (TYPE_ALIGN (tem) > TYPE_ALIGN (newtype))
2127 SET_TYPE_ALIGN (newtype, TYPE_ALIGN (tem));
2128 TYPE_USER_ALIGN (newtype) = true;
2129 }
2130
2131 /* And remove the new type from the variants list. */
2132 if (TYPE_NAME (TREE_TYPE (newdecl)) == newdecl)
2133 {
2134 tree remove = TREE_TYPE (newdecl);
2135 if (TYPE_MAIN_VARIANT (remove) == remove)
2136 {
2137 gcc_assert (TYPE_NEXT_VARIANT (remove) == NULL_TREE);
2138 /* If remove is the main variant, no need to remove that
2139 from the list. One of the DECL_ORIGINAL_TYPE
2140 variants, e.g. created for aligned attribute, might still
2141 refer to the newdecl TYPE_DECL though, so remove that one
2142 in that case. */
2143 if (tree orig = DECL_ORIGINAL_TYPE (newdecl))
2144 if (orig != remove)
2145 for (tree t = TYPE_MAIN_VARIANT (orig); t;
2146 t = TYPE_MAIN_VARIANT (t))
2147 if (TYPE_NAME (TYPE_NEXT_VARIANT (t)) == newdecl)
2148 {
2149 TYPE_NEXT_VARIANT (t)
2150 = TYPE_NEXT_VARIANT (TYPE_NEXT_VARIANT (t));
2151 break;
2152 }
2153 }
2154 else
2155 for (tree t = TYPE_MAIN_VARIANT (remove); ;
2156 t = TYPE_NEXT_VARIANT (t))
2157 if (TYPE_NEXT_VARIANT (t) == remove)
2158 {
2159 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (remove);
2160 break;
2161 }
2162 }
2163 }
2164 else if (merge_attr)
2165 newtype = merge_types (TREE_TYPE (newdecl), TREE_TYPE (olddecl));
2166 else
2167 newtype = TREE_TYPE (newdecl);
2168
2169 if (VAR_P (newdecl))
2170 {
2171 DECL_THIS_EXTERN (newdecl) |= DECL_THIS_EXTERN (olddecl);
2172 /* For already initialized vars, TREE_READONLY could have been
2173 cleared in cp_finish_decl, because the var needs runtime
2174 initialization or destruction. Make sure not to set
2175 TREE_READONLY on it again. */
2176 if (DECL_INITIALIZED_P (olddecl)
2177 && !DECL_EXTERNAL (olddecl)
2178 && !TREE_READONLY (olddecl))
2179 TREE_READONLY (newdecl) = 0;
2180 DECL_INITIALIZED_P (newdecl) |= DECL_INITIALIZED_P (olddecl);
2181 DECL_NONTRIVIALLY_INITIALIZED_P (newdecl)
2182 |= DECL_NONTRIVIALLY_INITIALIZED_P (olddecl);
2183 if (DECL_DEPENDENT_INIT_P (olddecl))
2184 SET_DECL_DEPENDENT_INIT_P (newdecl, true);
2185 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (newdecl)
2186 |= DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (olddecl);
2187 if (DECL_CLASS_SCOPE_P (olddecl))
2188 DECL_DECLARED_CONSTEXPR_P (newdecl)
2189 |= DECL_DECLARED_CONSTEXPR_P (olddecl);
2190
2191 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
2192 if (DECL_LANG_SPECIFIC (olddecl)
2193 && CP_DECL_THREADPRIVATE_P (olddecl))
2194 {
2195 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
2196 retrofit_lang_decl (newdecl);
2197 CP_DECL_THREADPRIVATE_P (newdecl) = 1;
2198 }
2199 }
2200
2201 /* An explicit specialization of a function template or of a member
2202 function of a class template can be declared transaction_safe
2203 independently of whether the corresponding template entity is declared
2204 transaction_safe. */
2205 if (flag_tm && TREE_CODE (newdecl) == FUNCTION_DECL
2206 && DECL_TEMPLATE_INSTANTIATION (olddecl)
2207 && DECL_TEMPLATE_SPECIALIZATION (newdecl)
2208 && tx_safe_fn_type_p (newtype)
2209 && !tx_safe_fn_type_p (TREE_TYPE (newdecl)))
2210 newtype = tx_unsafe_fn_variant (newtype);
2211
2212 TREE_TYPE (newdecl) = TREE_TYPE (olddecl) = newtype;
2213
2214 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2215 check_default_args (newdecl);
2216
2217 /* Lay the type out, unless already done. */
2218 if (! same_type_p (newtype, oldtype)
2219 && TREE_TYPE (newdecl) != error_mark_node
2220 && !(processing_template_decl && uses_template_parms (newdecl)))
2221 layout_type (TREE_TYPE (newdecl));
2222
2223 if ((VAR_P (newdecl)
2224 || TREE_CODE (newdecl) == PARM_DECL
2225 || TREE_CODE (newdecl) == RESULT_DECL
2226 || TREE_CODE (newdecl) == FIELD_DECL
2227 || TREE_CODE (newdecl) == TYPE_DECL)
2228 && !(processing_template_decl && uses_template_parms (newdecl)))
2229 layout_decl (newdecl, 0);
2230
2231 /* Merge deprecatedness. */
2232 if (TREE_DEPRECATED (newdecl))
2233 TREE_DEPRECATED (olddecl) = 1;
2234
2235 /* Preserve function specific target and optimization options */
2236 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2237 {
2238 if (DECL_FUNCTION_SPECIFIC_TARGET (olddecl)
2239 && !DECL_FUNCTION_SPECIFIC_TARGET (newdecl))
2240 DECL_FUNCTION_SPECIFIC_TARGET (newdecl)
2241 = DECL_FUNCTION_SPECIFIC_TARGET (olddecl);
2242
2243 if (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl)
2244 && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl))
2245 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (newdecl)
2246 = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (olddecl);
2247 }
2248 else
2249 {
2250 /* Merge the const type qualifier. */
2251 if (TREE_READONLY (newdecl))
2252 TREE_READONLY (olddecl) = 1;
2253 /* Merge the volatile type qualifier. */
2254 if (TREE_THIS_VOLATILE (newdecl))
2255 TREE_THIS_VOLATILE (olddecl) = 1;
2256 }
2257
2258 /* Merge the initialization information. */
2259 if (DECL_INITIAL (newdecl) == NULL_TREE
2260 && DECL_INITIAL (olddecl) != NULL_TREE)
2261 {
2262 DECL_INITIAL (newdecl) = DECL_INITIAL (olddecl);
2263 DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl);
2264 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2265 {
2266 DECL_SAVED_TREE (newdecl) = DECL_SAVED_TREE (olddecl);
2267 DECL_STRUCT_FUNCTION (newdecl) = DECL_STRUCT_FUNCTION (olddecl);
2268 }
2269 }
2270
2271 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2272 {
2273 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (newdecl)
2274 |= DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (olddecl);
2275 DECL_NO_LIMIT_STACK (newdecl) |= DECL_NO_LIMIT_STACK (olddecl);
2276 DECL_IS_OPERATOR_NEW (newdecl) |= DECL_IS_OPERATOR_NEW (olddecl);
2277 DECL_LOOPING_CONST_OR_PURE_P (newdecl)
2278 |= DECL_LOOPING_CONST_OR_PURE_P (olddecl);
2279
2280 if (merge_attr)
2281 merge_attribute_bits (newdecl, olddecl);
2282 else
2283 {
2284 /* Merge the noreturn bit. */
2285 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
2286 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
2287 TREE_NOTHROW (olddecl) = TREE_NOTHROW (newdecl);
2288 DECL_IS_MALLOC (olddecl) = DECL_IS_MALLOC (newdecl);
2289 DECL_PURE_P (olddecl) = DECL_PURE_P (newdecl);
2290 }
2291 /* Keep the old RTL. */
2292 COPY_DECL_RTL (olddecl, newdecl);
2293 }
2294 else if (VAR_P (newdecl)
2295 && (DECL_SIZE (olddecl) || !DECL_SIZE (newdecl)))
2296 {
2297 /* Keep the old RTL. We cannot keep the old RTL if the old
2298 declaration was for an incomplete object and the new
2299 declaration is not since many attributes of the RTL will
2300 change. */
2301 COPY_DECL_RTL (olddecl, newdecl);
2302 }
2303 }
2304 /* If cannot merge, then use the new type and qualifiers,
2305 and don't preserve the old rtl. */
2306 else
2307 {
2308 /* Clean out any memory we had of the old declaration. */
2309 tree oldstatic = value_member (olddecl, static_aggregates);
2310 if (oldstatic)
2311 TREE_VALUE (oldstatic) = error_mark_node;
2312
2313 TREE_TYPE (olddecl) = TREE_TYPE (newdecl);
2314 TREE_READONLY (olddecl) = TREE_READONLY (newdecl);
2315 TREE_THIS_VOLATILE (olddecl) = TREE_THIS_VOLATILE (newdecl);
2316 TREE_NOTHROW (olddecl) = TREE_NOTHROW (newdecl);
2317 TREE_SIDE_EFFECTS (olddecl) = TREE_SIDE_EFFECTS (newdecl);
2318 }
2319
2320 /* Merge the storage class information. */
2321 merge_weak (newdecl, olddecl);
2322
2323 DECL_DEFER_OUTPUT (newdecl) |= DECL_DEFER_OUTPUT (olddecl);
2324 TREE_PUBLIC (newdecl) = TREE_PUBLIC (olddecl);
2325 TREE_STATIC (olddecl) = TREE_STATIC (newdecl) |= TREE_STATIC (olddecl);
2326 if (! DECL_EXTERNAL (olddecl))
2327 DECL_EXTERNAL (newdecl) = 0;
2328 if (! DECL_COMDAT (olddecl))
2329 DECL_COMDAT (newdecl) = 0;
2330
2331 new_template_info = NULL_TREE;
2332 if (DECL_LANG_SPECIFIC (newdecl) && DECL_LANG_SPECIFIC (olddecl))
2333 {
2334 bool new_redefines_gnu_inline = false;
2335
2336 if (new_defines_function
2337 && ((DECL_INTERFACE_KNOWN (olddecl)
2338 && TREE_CODE (olddecl) == FUNCTION_DECL)
2339 || (TREE_CODE (olddecl) == TEMPLATE_DECL
2340 && (TREE_CODE (DECL_TEMPLATE_RESULT (olddecl))
2341 == FUNCTION_DECL))))
2342 {
2343 tree fn = olddecl;
2344
2345 if (TREE_CODE (fn) == TEMPLATE_DECL)
2346 fn = DECL_TEMPLATE_RESULT (olddecl);
2347
2348 new_redefines_gnu_inline = GNU_INLINE_P (fn) && DECL_INITIAL (fn);
2349 }
2350
2351 if (!new_redefines_gnu_inline)
2352 {
2353 DECL_INTERFACE_KNOWN (newdecl) |= DECL_INTERFACE_KNOWN (olddecl);
2354 DECL_NOT_REALLY_EXTERN (newdecl) |= DECL_NOT_REALLY_EXTERN (olddecl);
2355 DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl);
2356 }
2357 DECL_TEMPLATE_INSTANTIATED (newdecl)
2358 |= DECL_TEMPLATE_INSTANTIATED (olddecl);
2359 DECL_ODR_USED (newdecl) |= DECL_ODR_USED (olddecl);
2360
2361 /* If the OLDDECL is an instantiation and/or specialization,
2362 then the NEWDECL must be too. But, it may not yet be marked
2363 as such if the caller has created NEWDECL, but has not yet
2364 figured out that it is a redeclaration. */
2365 if (!DECL_USE_TEMPLATE (newdecl))
2366 DECL_USE_TEMPLATE (newdecl) = DECL_USE_TEMPLATE (olddecl);
2367
2368 /* Don't really know how much of the language-specific
2369 values we should copy from old to new. */
2370 DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl);
2371 DECL_REPO_AVAILABLE_P (newdecl) = DECL_REPO_AVAILABLE_P (olddecl);
2372 DECL_INITIALIZED_IN_CLASS_P (newdecl)
2373 |= DECL_INITIALIZED_IN_CLASS_P (olddecl);
2374
2375 if (LANG_DECL_HAS_MIN (newdecl))
2376 {
2377 DECL_ACCESS (newdecl) = DECL_ACCESS (olddecl);
2378 if (DECL_TEMPLATE_INFO (newdecl))
2379 {
2380 new_template_info = DECL_TEMPLATE_INFO (newdecl);
2381 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
2382 && DECL_TEMPLATE_SPECIALIZATION (newdecl))
2383 /* Remember the presence of explicit specialization args. */
2384 TINFO_USED_TEMPLATE_ID (DECL_TEMPLATE_INFO (olddecl))
2385 = TINFO_USED_TEMPLATE_ID (new_template_info);
2386 }
2387 DECL_TEMPLATE_INFO (newdecl) = DECL_TEMPLATE_INFO (olddecl);
2388 }
2389 /* Only functions have these fields. */
2390 if (DECL_DECLARES_FUNCTION_P (newdecl))
2391 {
2392 DECL_NONCONVERTING_P (newdecl) = DECL_NONCONVERTING_P (olddecl);
2393 DECL_BEFRIENDING_CLASSES (newdecl)
2394 = chainon (DECL_BEFRIENDING_CLASSES (newdecl),
2395 DECL_BEFRIENDING_CLASSES (olddecl));
2396 /* DECL_THUNKS is only valid for virtual functions,
2397 otherwise it is a DECL_FRIEND_CONTEXT. */
2398 if (DECL_VIRTUAL_P (newdecl))
2399 SET_DECL_THUNKS (newdecl, DECL_THUNKS (olddecl));
2400 }
2401 /* Only variables have this field. */
2402 else if (VAR_P (newdecl)
2403 && VAR_HAD_UNKNOWN_BOUND (olddecl))
2404 SET_VAR_HAD_UNKNOWN_BOUND (newdecl);
2405 }
2406
2407 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2408 {
2409 tree parm;
2410
2411 /* Merge parameter attributes. */
2412 tree oldarg, newarg;
2413 for (oldarg = DECL_ARGUMENTS(olddecl), newarg = DECL_ARGUMENTS(newdecl);
2414 oldarg && newarg;
2415 oldarg = DECL_CHAIN(oldarg), newarg = DECL_CHAIN(newarg))
2416 {
2417 DECL_ATTRIBUTES (newarg)
2418 = (*targetm.merge_decl_attributes) (oldarg, newarg);
2419 DECL_ATTRIBUTES (oldarg) = DECL_ATTRIBUTES (newarg);
2420 }
2421
2422 if (DECL_TEMPLATE_INSTANTIATION (olddecl)
2423 && !DECL_TEMPLATE_INSTANTIATION (newdecl))
2424 {
2425 /* If newdecl is not a specialization, then it is not a
2426 template-related function at all. And that means that we
2427 should have exited above, returning 0. */
2428 gcc_assert (DECL_TEMPLATE_SPECIALIZATION (newdecl));
2429
2430 if (DECL_ODR_USED (olddecl))
2431 /* From [temp.expl.spec]:
2432
2433 If a template, a member template or the member of a class
2434 template is explicitly specialized then that
2435 specialization shall be declared before the first use of
2436 that specialization that would cause an implicit
2437 instantiation to take place, in every translation unit in
2438 which such a use occurs. */
2439 error ("explicit specialization of %qD after first use",
2440 olddecl);
2441
2442 SET_DECL_TEMPLATE_SPECIALIZATION (olddecl);
2443 DECL_COMDAT (newdecl) = (TREE_PUBLIC (newdecl)
2444 && DECL_DECLARED_INLINE_P (newdecl));
2445
2446 /* Don't propagate visibility from the template to the
2447 specialization here. We'll do that in determine_visibility if
2448 appropriate. */
2449 DECL_VISIBILITY_SPECIFIED (olddecl) = 0;
2450
2451 /* [temp.expl.spec/14] We don't inline explicit specialization
2452 just because the primary template says so. */
2453 gcc_assert (!merge_attr);
2454
2455 DECL_DECLARED_INLINE_P (olddecl)
2456 = DECL_DECLARED_INLINE_P (newdecl);
2457
2458 DECL_DISREGARD_INLINE_LIMITS (olddecl)
2459 = DECL_DISREGARD_INLINE_LIMITS (newdecl);
2460
2461 DECL_UNINLINABLE (olddecl) = DECL_UNINLINABLE (newdecl);
2462 }
2463 else if (new_defines_function && DECL_INITIAL (olddecl))
2464 {
2465 /* Never inline re-defined extern inline functions.
2466 FIXME: this could be better handled by keeping both
2467 function as separate declarations. */
2468 DECL_UNINLINABLE (newdecl) = 1;
2469 }
2470 else
2471 {
2472 if (DECL_PENDING_INLINE_P (olddecl))
2473 {
2474 DECL_PENDING_INLINE_P (newdecl) = 1;
2475 DECL_PENDING_INLINE_INFO (newdecl)
2476 = DECL_PENDING_INLINE_INFO (olddecl);
2477 }
2478 else if (DECL_PENDING_INLINE_P (newdecl))
2479 ;
2480 else if (DECL_SAVED_FUNCTION_DATA (newdecl) == NULL)
2481 DECL_SAVED_FUNCTION_DATA (newdecl)
2482 = DECL_SAVED_FUNCTION_DATA (olddecl);
2483
2484 DECL_DECLARED_INLINE_P (newdecl) |= DECL_DECLARED_INLINE_P (olddecl);
2485
2486 DECL_UNINLINABLE (newdecl) = DECL_UNINLINABLE (olddecl)
2487 = (DECL_UNINLINABLE (newdecl) || DECL_UNINLINABLE (olddecl));
2488
2489 DECL_DISREGARD_INLINE_LIMITS (newdecl)
2490 = DECL_DISREGARD_INLINE_LIMITS (olddecl)
2491 = (DECL_DISREGARD_INLINE_LIMITS (newdecl)
2492 || DECL_DISREGARD_INLINE_LIMITS (olddecl));
2493 }
2494
2495 /* Preserve abstractness on cloned [cd]tors. */
2496 DECL_ABSTRACT_P (newdecl) = DECL_ABSTRACT_P (olddecl);
2497
2498 /* Update newdecl's parms to point at olddecl. */
2499 for (parm = DECL_ARGUMENTS (newdecl); parm;
2500 parm = DECL_CHAIN (parm))
2501 DECL_CONTEXT (parm) = olddecl;
2502
2503 if (! types_match)
2504 {
2505 SET_DECL_LANGUAGE (olddecl, DECL_LANGUAGE (newdecl));
2506 COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
2507 COPY_DECL_RTL (newdecl, olddecl);
2508 }
2509 if (! types_match || new_defines_function)
2510 {
2511 /* These need to be copied so that the names are available.
2512 Note that if the types do match, we'll preserve inline
2513 info and other bits, but if not, we won't. */
2514 DECL_ARGUMENTS (olddecl) = DECL_ARGUMENTS (newdecl);
2515 DECL_RESULT (olddecl) = DECL_RESULT (newdecl);
2516 }
2517 /* If redeclaring a builtin function, it stays built in
2518 if newdecl is a gnu_inline definition, or if newdecl is just
2519 a declaration. */
2520 if (fndecl_built_in_p (olddecl)
2521 && (new_defines_function ? GNU_INLINE_P (newdecl) : types_match))
2522 {
2523 DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl);
2524 DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl);
2525 /* If we're keeping the built-in definition, keep the rtl,
2526 regardless of declaration matches. */
2527 COPY_DECL_RTL (olddecl, newdecl);
2528 if (DECL_BUILT_IN_CLASS (newdecl) == BUILT_IN_NORMAL)
2529 {
2530 enum built_in_function fncode = DECL_FUNCTION_CODE (newdecl);
2531 switch (fncode)
2532 {
2533 /* If a compatible prototype of these builtin functions
2534 is seen, assume the runtime implements it with the
2535 expected semantics. */
2536 case BUILT_IN_STPCPY:
2537 if (builtin_decl_explicit_p (fncode))
2538 set_builtin_decl_implicit_p (fncode, true);
2539 break;
2540 default:
2541 if (builtin_decl_explicit_p (fncode))
2542 set_builtin_decl_declared_p (fncode, true);
2543 break;
2544 }
2545 }
2546
2547 copy_attributes_to_builtin (newdecl);
2548 }
2549 if (new_defines_function)
2550 /* If defining a function declared with other language
2551 linkage, use the previously declared language linkage. */
2552 SET_DECL_LANGUAGE (newdecl, DECL_LANGUAGE (olddecl));
2553 else if (types_match)
2554 {
2555 DECL_RESULT (newdecl) = DECL_RESULT (olddecl);
2556 /* Don't clear out the arguments if we're just redeclaring a
2557 function. */
2558 if (DECL_ARGUMENTS (olddecl))
2559 DECL_ARGUMENTS (newdecl) = DECL_ARGUMENTS (olddecl);
2560 }
2561 }
2562 else if (TREE_CODE (newdecl) == NAMESPACE_DECL)
2563 NAMESPACE_LEVEL (newdecl) = NAMESPACE_LEVEL (olddecl);
2564
2565 /* Now preserve various other info from the definition. */
2566 TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
2567 TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
2568 DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
2569 COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
2570
2571 /* Warn about conflicting visibility specifications. */
2572 if (DECL_VISIBILITY_SPECIFIED (olddecl)
2573 && DECL_VISIBILITY_SPECIFIED (newdecl)
2574 && DECL_VISIBILITY (newdecl) != DECL_VISIBILITY (olddecl))
2575 {
2576 auto_diagnostic_group d;
2577 if (warning_at (newdecl_loc, OPT_Wattributes,
2578 "%qD: visibility attribute ignored because it "
2579 "conflicts with previous declaration", newdecl))
2580 inform (olddecl_loc,
2581 "previous declaration of %qD", olddecl);
2582 }
2583 /* Choose the declaration which specified visibility. */
2584 if (DECL_VISIBILITY_SPECIFIED (olddecl))
2585 {
2586 DECL_VISIBILITY (newdecl) = DECL_VISIBILITY (olddecl);
2587 DECL_VISIBILITY_SPECIFIED (newdecl) = 1;
2588 }
2589 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
2590 so keep this behavior. */
2591 if (VAR_P (newdecl) && DECL_HAS_INIT_PRIORITY_P (newdecl))
2592 {
2593 SET_DECL_INIT_PRIORITY (olddecl, DECL_INIT_PRIORITY (newdecl));
2594 DECL_HAS_INIT_PRIORITY_P (olddecl) = 1;
2595 }
2596 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
2597 if (DECL_ALIGN (olddecl) > DECL_ALIGN (newdecl))
2598 {
2599 SET_DECL_ALIGN (newdecl, DECL_ALIGN (olddecl));
2600 DECL_USER_ALIGN (newdecl) |= DECL_USER_ALIGN (olddecl);
2601 }
2602 DECL_USER_ALIGN (olddecl) = DECL_USER_ALIGN (newdecl);
2603 if (DECL_WARN_IF_NOT_ALIGN (olddecl)
2604 > DECL_WARN_IF_NOT_ALIGN (newdecl))
2605 SET_DECL_WARN_IF_NOT_ALIGN (newdecl,
2606 DECL_WARN_IF_NOT_ALIGN (olddecl));
2607 if (TREE_CODE (newdecl) == FIELD_DECL)
2608 DECL_PACKED (olddecl) = DECL_PACKED (newdecl);
2609
2610 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
2611 with that from NEWDECL below. */
2612 if (DECL_LANG_SPECIFIC (olddecl))
2613 {
2614 gcc_assert (DECL_LANG_SPECIFIC (olddecl)
2615 != DECL_LANG_SPECIFIC (newdecl));
2616 ggc_free (DECL_LANG_SPECIFIC (olddecl));
2617 }
2618
2619 /* Merge the USED information. */
2620 if (TREE_USED (olddecl))
2621 TREE_USED (newdecl) = 1;
2622 else if (TREE_USED (newdecl))
2623 TREE_USED (olddecl) = 1;
2624 if (VAR_P (newdecl))
2625 {
2626 if (DECL_READ_P (olddecl))
2627 DECL_READ_P (newdecl) = 1;
2628 else if (DECL_READ_P (newdecl))
2629 DECL_READ_P (olddecl) = 1;
2630 }
2631 if (DECL_PRESERVE_P (olddecl))
2632 DECL_PRESERVE_P (newdecl) = 1;
2633 else if (DECL_PRESERVE_P (newdecl))
2634 DECL_PRESERVE_P (olddecl) = 1;
2635
2636 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
2637 to olddecl and deleted. */
2638 if (TREE_CODE (newdecl) == FUNCTION_DECL
2639 && DECL_FUNCTION_VERSIONED (olddecl))
2640 {
2641 /* Set the flag for newdecl so that it gets copied to olddecl. */
2642 DECL_FUNCTION_VERSIONED (newdecl) = 1;
2643 /* newdecl will be purged after copying to olddecl and is no longer
2644 a version. */
2645 cgraph_node::delete_function_version_by_decl (newdecl);
2646 }
2647
2648 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2649 {
2650 int function_size;
2651 struct symtab_node *snode = symtab_node::get (olddecl);
2652
2653 function_size = sizeof (struct tree_decl_common);
2654
2655 memcpy ((char *) olddecl + sizeof (struct tree_common),
2656 (char *) newdecl + sizeof (struct tree_common),
2657 function_size - sizeof (struct tree_common));
2658
2659 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2660 (char *) newdecl + sizeof (struct tree_decl_common),
2661 sizeof (struct tree_function_decl) - sizeof (struct tree_decl_common));
2662
2663 /* Preserve symtab node mapping. */
2664 olddecl->decl_with_vis.symtab_node = snode;
2665
2666 if (new_template_info)
2667 /* If newdecl is a template instantiation, it is possible that
2668 the following sequence of events has occurred:
2669
2670 o A friend function was declared in a class template. The
2671 class template was instantiated.
2672
2673 o The instantiation of the friend declaration was
2674 recorded on the instantiation list, and is newdecl.
2675
2676 o Later, however, instantiate_class_template called pushdecl
2677 on the newdecl to perform name injection. But, pushdecl in
2678 turn called duplicate_decls when it discovered that another
2679 declaration of a global function with the same name already
2680 existed.
2681
2682 o Here, in duplicate_decls, we decided to clobber newdecl.
2683
2684 If we're going to do that, we'd better make sure that
2685 olddecl, and not newdecl, is on the list of
2686 instantiations so that if we try to do the instantiation
2687 again we won't get the clobbered declaration. */
2688 reregister_specialization (newdecl,
2689 new_template_info,
2690 olddecl);
2691 }
2692 else
2693 {
2694 size_t size = tree_code_size (TREE_CODE (newdecl));
2695
2696 memcpy ((char *) olddecl + sizeof (struct tree_common),
2697 (char *) newdecl + sizeof (struct tree_common),
2698 sizeof (struct tree_decl_common) - sizeof (struct tree_common));
2699 switch (TREE_CODE (newdecl))
2700 {
2701 case LABEL_DECL:
2702 case VAR_DECL:
2703 case RESULT_DECL:
2704 case PARM_DECL:
2705 case FIELD_DECL:
2706 case TYPE_DECL:
2707 case CONST_DECL:
2708 {
2709 struct symtab_node *snode = NULL;
2710
2711 if (VAR_P (newdecl)
2712 && (TREE_STATIC (olddecl) || TREE_PUBLIC (olddecl)
2713 || DECL_EXTERNAL (olddecl)))
2714 snode = symtab_node::get (olddecl);
2715 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2716 (char *) newdecl + sizeof (struct tree_decl_common),
2717 size - sizeof (struct tree_decl_common)
2718 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2719 if (VAR_P (newdecl))
2720 olddecl->decl_with_vis.symtab_node = snode;
2721 }
2722 break;
2723 default:
2724 memcpy ((char *) olddecl + sizeof (struct tree_decl_common),
2725 (char *) newdecl + sizeof (struct tree_decl_common),
2726 sizeof (struct tree_decl_non_common) - sizeof (struct tree_decl_common)
2727 + TREE_CODE_LENGTH (TREE_CODE (newdecl)) * sizeof (char *));
2728 break;
2729 }
2730 }
2731
2732 if (VAR_OR_FUNCTION_DECL_P (newdecl))
2733 {
2734 if (DECL_EXTERNAL (olddecl)
2735 || TREE_PUBLIC (olddecl)
2736 || TREE_STATIC (olddecl))
2737 {
2738 /* Merge the section attribute.
2739 We want to issue an error if the sections conflict but that must be
2740 done later in decl_attributes since we are called before attributes
2741 are assigned. */
2742 if (DECL_SECTION_NAME (newdecl) != NULL)
2743 set_decl_section_name (olddecl, DECL_SECTION_NAME (newdecl));
2744
2745 if (DECL_ONE_ONLY (newdecl))
2746 {
2747 struct symtab_node *oldsym, *newsym;
2748 if (TREE_CODE (olddecl) == FUNCTION_DECL)
2749 oldsym = cgraph_node::get_create (olddecl);
2750 else
2751 oldsym = varpool_node::get_create (olddecl);
2752 newsym = symtab_node::get (newdecl);
2753 oldsym->set_comdat_group (newsym->get_comdat_group ());
2754 }
2755 }
2756
2757 if (VAR_P (newdecl)
2758 && CP_DECL_THREAD_LOCAL_P (newdecl))
2759 {
2760 CP_DECL_THREAD_LOCAL_P (olddecl) = true;
2761 if (!processing_template_decl)
2762 set_decl_tls_model (olddecl, DECL_TLS_MODEL (newdecl));
2763 }
2764 }
2765
2766 DECL_UID (olddecl) = olddecl_uid;
2767 if (olddecl_friend)
2768 DECL_FRIEND_P (olddecl) = 1;
2769 if (hidden_friend)
2770 {
2771 DECL_ANTICIPATED (olddecl) = 1;
2772 DECL_HIDDEN_FRIEND_P (olddecl) = 1;
2773 }
2774
2775 /* NEWDECL contains the merged attribute lists.
2776 Update OLDDECL to be the same. */
2777 DECL_ATTRIBUTES (olddecl) = DECL_ATTRIBUTES (newdecl);
2778
2779 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
2780 so that encode_section_info has a chance to look at the new decl
2781 flags and attributes. */
2782 if (DECL_RTL_SET_P (olddecl)
2783 && (TREE_CODE (olddecl) == FUNCTION_DECL
2784 || (VAR_P (olddecl)
2785 && TREE_STATIC (olddecl))))
2786 make_decl_rtl (olddecl);
2787
2788 /* The NEWDECL will no longer be needed. Because every out-of-class
2789 declaration of a member results in a call to duplicate_decls,
2790 freeing these nodes represents in a significant savings.
2791
2792 Before releasing the node, be sore to remove function from symbol
2793 table that might have been inserted there to record comdat group.
2794 Be sure to however do not free DECL_STRUCT_FUNCTION because this
2795 structure is shared in between newdecl and oldecl. */
2796 if (TREE_CODE (newdecl) == FUNCTION_DECL)
2797 DECL_STRUCT_FUNCTION (newdecl) = NULL;
2798 if (VAR_OR_FUNCTION_DECL_P (newdecl))
2799 {
2800 struct symtab_node *snode = symtab_node::get (newdecl);
2801 if (snode)
2802 snode->remove ();
2803 }
2804
2805 /* Remove the associated constraints for newdecl, if any, before
2806 reclaiming memory. */
2807 if (flag_concepts)
2808 remove_constraints (newdecl);
2809
2810 ggc_free (newdecl);
2811
2812 return olddecl;
2813 }
2814
2815 /* Return zero if the declaration NEWDECL is valid
2816 when the declaration OLDDECL (assumed to be for the same name)
2817 has already been seen.
2818 Otherwise return an error message format string with a %s
2819 where the identifier should go. */
2820
2821 static const char *
redeclaration_error_message(tree newdecl,tree olddecl)2822 redeclaration_error_message (tree newdecl, tree olddecl)
2823 {
2824 if (TREE_CODE (newdecl) == TYPE_DECL)
2825 {
2826 /* Because C++ can put things into name space for free,
2827 constructs like "typedef struct foo { ... } foo"
2828 would look like an erroneous redeclaration. */
2829 if (same_type_p (TREE_TYPE (newdecl), TREE_TYPE (olddecl)))
2830 return NULL;
2831 else
2832 return G_("redefinition of %q#D");
2833 }
2834 else if (TREE_CODE (newdecl) == FUNCTION_DECL)
2835 {
2836 /* If this is a pure function, its olddecl will actually be
2837 the original initialization to `0' (which we force to call
2838 abort()). Don't complain about redefinition in this case. */
2839 if (DECL_LANG_SPECIFIC (olddecl) && DECL_PURE_VIRTUAL_P (olddecl)
2840 && DECL_INITIAL (olddecl) == NULL_TREE)
2841 return NULL;
2842
2843 /* If both functions come from different namespaces, this is not
2844 a redeclaration - this is a conflict with a used function. */
2845 if (DECL_NAMESPACE_SCOPE_P (olddecl)
2846 && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl)
2847 && ! decls_match (olddecl, newdecl))
2848 return G_("%qD conflicts with used function");
2849
2850 /* We'll complain about linkage mismatches in
2851 warn_extern_redeclared_static. */
2852
2853 /* Defining the same name twice is no good. */
2854 if (decl_defined_p (olddecl)
2855 && decl_defined_p (newdecl))
2856 {
2857 if (DECL_NAME (olddecl) == NULL_TREE)
2858 return G_("%q#D not declared in class");
2859 else if (!GNU_INLINE_P (olddecl)
2860 || GNU_INLINE_P (newdecl))
2861 return G_("redefinition of %q#D");
2862 }
2863
2864 if (DECL_DECLARED_INLINE_P (olddecl) && DECL_DECLARED_INLINE_P (newdecl))
2865 {
2866 bool olda = GNU_INLINE_P (olddecl);
2867 bool newa = GNU_INLINE_P (newdecl);
2868
2869 if (olda != newa)
2870 {
2871 if (newa)
2872 return G_("%q+D redeclared inline with "
2873 "%<gnu_inline%> attribute");
2874 else
2875 return G_("%q+D redeclared inline without "
2876 "%<gnu_inline%> attribute");
2877 }
2878 }
2879
2880 check_abi_tag_redeclaration
2881 (olddecl, lookup_attribute ("abi_tag", DECL_ATTRIBUTES (olddecl)),
2882 lookup_attribute ("abi_tag", DECL_ATTRIBUTES (newdecl)));
2883
2884 return NULL;
2885 }
2886 else if (TREE_CODE (newdecl) == TEMPLATE_DECL)
2887 {
2888 tree nt, ot;
2889
2890 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) == TYPE_DECL)
2891 {
2892 if (COMPLETE_TYPE_P (TREE_TYPE (newdecl))
2893 && COMPLETE_TYPE_P (TREE_TYPE (olddecl)))
2894 return G_("redefinition of %q#D");
2895 return NULL;
2896 }
2897
2898 if (TREE_CODE (DECL_TEMPLATE_RESULT (newdecl)) != FUNCTION_DECL
2899 || (DECL_TEMPLATE_RESULT (newdecl)
2900 == DECL_TEMPLATE_RESULT (olddecl)))
2901 return NULL;
2902
2903 nt = DECL_TEMPLATE_RESULT (newdecl);
2904 if (DECL_TEMPLATE_INFO (nt))
2905 nt = DECL_TEMPLATE_RESULT (template_for_substitution (nt));
2906 ot = DECL_TEMPLATE_RESULT (olddecl);
2907 if (DECL_TEMPLATE_INFO (ot))
2908 ot = DECL_TEMPLATE_RESULT (template_for_substitution (ot));
2909 if (DECL_INITIAL (nt) && DECL_INITIAL (ot)
2910 && (!GNU_INLINE_P (ot) || GNU_INLINE_P (nt)))
2911 return G_("redefinition of %q#D");
2912
2913 if (DECL_DECLARED_INLINE_P (ot) && DECL_DECLARED_INLINE_P (nt))
2914 {
2915 bool olda = GNU_INLINE_P (ot);
2916 bool newa = GNU_INLINE_P (nt);
2917
2918 if (olda != newa)
2919 {
2920 if (newa)
2921 return G_("%q+D redeclared inline with "
2922 "%<gnu_inline%> attribute");
2923 else
2924 return G_("%q+D redeclared inline without "
2925 "%<gnu_inline%> attribute");
2926 }
2927 }
2928
2929 /* Core issue #226 (C++0x):
2930
2931 If a friend function template declaration specifies a
2932 default template-argument, that declaration shall be a
2933 definition and shall be the only declaration of the
2934 function template in the translation unit. */
2935 if ((cxx_dialect != cxx98)
2936 && TREE_CODE (ot) == FUNCTION_DECL && DECL_FRIEND_P (ot)
2937 && !check_default_tmpl_args (nt, DECL_TEMPLATE_PARMS (newdecl),
2938 /*is_primary=*/true,
2939 /*is_partial=*/false,
2940 /*is_friend_decl=*/2))
2941 return G_("redeclaration of friend %q#D "
2942 "may not have default template arguments");
2943
2944 return NULL;
2945 }
2946 else if (VAR_P (newdecl)
2947 && CP_DECL_THREAD_LOCAL_P (newdecl) != CP_DECL_THREAD_LOCAL_P (olddecl)
2948 && (! DECL_LANG_SPECIFIC (olddecl)
2949 || ! CP_DECL_THREADPRIVATE_P (olddecl)
2950 || CP_DECL_THREAD_LOCAL_P (newdecl)))
2951 {
2952 /* Only variables can be thread-local, and all declarations must
2953 agree on this property. */
2954 if (CP_DECL_THREAD_LOCAL_P (newdecl))
2955 return G_("thread-local declaration of %q#D follows "
2956 "non-thread-local declaration");
2957 else
2958 return G_("non-thread-local declaration of %q#D follows "
2959 "thread-local declaration");
2960 }
2961 else if (toplevel_bindings_p () || DECL_NAMESPACE_SCOPE_P (newdecl))
2962 {
2963 /* The objects have been declared at namespace scope. If either
2964 is a member of an anonymous union, then this is an invalid
2965 redeclaration. For example:
2966
2967 int i;
2968 union { int i; };
2969
2970 is invalid. */
2971 if ((VAR_P (newdecl) && DECL_ANON_UNION_VAR_P (newdecl))
2972 || (VAR_P (olddecl) && DECL_ANON_UNION_VAR_P (olddecl)))
2973 return G_("redeclaration of %q#D");
2974 /* If at least one declaration is a reference, there is no
2975 conflict. For example:
2976
2977 int i = 3;
2978 extern int i;
2979
2980 is valid. */
2981 if (DECL_EXTERNAL (newdecl) || DECL_EXTERNAL (olddecl))
2982 return NULL;
2983
2984 /* Static data member declared outside a class definition
2985 if the variable is defined within the class with constexpr
2986 specifier is declaration rather than definition (and
2987 deprecated). */
2988 if (cxx_dialect >= cxx17
2989 && VAR_P (olddecl)
2990 && DECL_CLASS_SCOPE_P (olddecl)
2991 && DECL_DECLARED_CONSTEXPR_P (olddecl)
2992 && !DECL_INITIAL (newdecl))
2993 {
2994 DECL_EXTERNAL (newdecl) = 1;
2995 /* For now, only warn with explicit -Wdeprecated. */
2996 if (global_options_set.x_warn_deprecated)
2997 {
2998 auto_diagnostic_group d;
2999 if (warning_at (DECL_SOURCE_LOCATION (newdecl), OPT_Wdeprecated,
3000 "redundant redeclaration of %<constexpr%> "
3001 "static data member %qD", newdecl))
3002 inform (DECL_SOURCE_LOCATION (olddecl),
3003 "previous declaration of %qD", olddecl);
3004 }
3005 return NULL;
3006 }
3007
3008 /* Reject two definitions. */
3009 return G_("redefinition of %q#D");
3010 }
3011 else
3012 {
3013 /* Objects declared with block scope: */
3014 /* Reject two definitions, and reject a definition
3015 together with an external reference. */
3016 if (!(DECL_EXTERNAL (newdecl) && DECL_EXTERNAL (olddecl)))
3017 return G_("redeclaration of %q#D");
3018 return NULL;
3019 }
3020 }
3021
3022
3023 /* Hash and equality functions for the named_label table. */
3024
3025 hashval_t
hash(const value_type entry)3026 named_label_hash::hash (const value_type entry)
3027 {
3028 return IDENTIFIER_HASH_VALUE (entry->name);
3029 }
3030
3031 bool
equal(const value_type entry,compare_type name)3032 named_label_hash::equal (const value_type entry, compare_type name)
3033 {
3034 return name == entry->name;
3035 }
3036
3037 /* Look for a label named ID in the current function. If one cannot
3038 be found, create one. Return the named_label_entry, or NULL on
3039 failure. */
3040
3041 static named_label_entry *
lookup_label_1(tree id,bool making_local_p)3042 lookup_label_1 (tree id, bool making_local_p)
3043 {
3044 /* You can't use labels at global scope. */
3045 if (current_function_decl == NULL_TREE)
3046 {
3047 error ("label %qE referenced outside of any function", id);
3048 return NULL;
3049 }
3050
3051 if (!named_labels)
3052 named_labels = hash_table<named_label_hash>::create_ggc (13);
3053
3054 hashval_t hash = IDENTIFIER_HASH_VALUE (id);
3055 named_label_entry **slot
3056 = named_labels->find_slot_with_hash (id, hash, INSERT);
3057 named_label_entry *old = *slot;
3058
3059 if (old && old->label_decl)
3060 {
3061 if (!making_local_p)
3062 return old;
3063
3064 if (old->binding_level == current_binding_level)
3065 {
3066 error ("local label %qE conflicts with existing label", id);
3067 inform (DECL_SOURCE_LOCATION (old->label_decl), "previous label");
3068 return NULL;
3069 }
3070 }
3071
3072 /* We are making a new decl, create or reuse the named_label_entry */
3073 named_label_entry *ent = NULL;
3074 if (old && !old->label_decl)
3075 ent = old;
3076 else
3077 {
3078 ent = ggc_cleared_alloc<named_label_entry> ();
3079 ent->name = id;
3080 ent->outer = old;
3081 *slot = ent;
3082 }
3083
3084 /* Now create the LABEL_DECL. */
3085 tree decl = build_decl (input_location, LABEL_DECL, id, void_type_node);
3086
3087 DECL_CONTEXT (decl) = current_function_decl;
3088 SET_DECL_MODE (decl, VOIDmode);
3089 if (making_local_p)
3090 {
3091 C_DECLARED_LABEL_FLAG (decl) = true;
3092 DECL_CHAIN (decl) = current_binding_level->names;
3093 current_binding_level->names = decl;
3094 }
3095
3096 ent->label_decl = decl;
3097
3098 return ent;
3099 }
3100
3101 /* Wrapper for lookup_label_1. */
3102
3103 tree
lookup_label(tree id)3104 lookup_label (tree id)
3105 {
3106 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3107 named_label_entry *ent = lookup_label_1 (id, false);
3108 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3109 return ent ? ent->label_decl : NULL_TREE;
3110 }
3111
3112 tree
declare_local_label(tree id)3113 declare_local_label (tree id)
3114 {
3115 bool subtime = timevar_cond_start (TV_NAME_LOOKUP);
3116 named_label_entry *ent = lookup_label_1 (id, true);
3117 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
3118 return ent ? ent->label_decl : NULL_TREE;
3119 }
3120
3121 /* Returns nonzero if it is ill-formed to jump past the declaration of
3122 DECL. Returns 2 if it's also a real problem. */
3123
3124 static int
decl_jump_unsafe(tree decl)3125 decl_jump_unsafe (tree decl)
3126 {
3127 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
3128 with automatic storage duration is not in scope to a point where it is
3129 in scope is ill-formed unless the variable has scalar type, class type
3130 with a trivial default constructor and a trivial destructor, a
3131 cv-qualified version of one of these types, or an array of one of the
3132 preceding types and is declared without an initializer (8.5). */
3133 tree type = TREE_TYPE (decl);
3134
3135 if (!VAR_P (decl) || TREE_STATIC (decl)
3136 || type == error_mark_node)
3137 return 0;
3138
3139 if (DECL_NONTRIVIALLY_INITIALIZED_P (decl)
3140 || variably_modified_type_p (type, NULL_TREE))
3141 return 2;
3142
3143 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
3144 return 1;
3145
3146 return 0;
3147 }
3148
3149 /* A subroutine of check_previous_goto_1 and check_goto to identify a branch
3150 to the user. */
3151
3152 static bool
identify_goto(tree decl,location_t loc,const location_t * locus,diagnostic_t diag_kind)3153 identify_goto (tree decl, location_t loc, const location_t *locus,
3154 diagnostic_t diag_kind)
3155 {
3156 bool complained
3157 = emit_diagnostic (diag_kind, loc, 0,
3158 decl ? N_("jump to label %qD")
3159 : N_("jump to case label"), decl);
3160 if (complained && locus)
3161 inform (*locus, " from here");
3162 return complained;
3163 }
3164
3165 /* Check that a single previously seen jump to a newly defined label
3166 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
3167 the jump context; NAMES are the names in scope in LEVEL at the jump
3168 context; LOCUS is the source position of the jump or 0. Returns
3169 true if all is well. */
3170
3171 static bool
check_previous_goto_1(tree decl,cp_binding_level * level,tree names,bool exited_omp,const location_t * locus)3172 check_previous_goto_1 (tree decl, cp_binding_level* level, tree names,
3173 bool exited_omp, const location_t *locus)
3174 {
3175 cp_binding_level *b;
3176 bool complained = false;
3177 int identified = 0;
3178 bool saw_eh = false, saw_omp = false, saw_tm = false, saw_cxif = false;
3179
3180 if (exited_omp)
3181 {
3182 complained = identify_goto (decl, input_location, locus, DK_ERROR);
3183 if (complained)
3184 inform (input_location, " exits OpenMP structured block");
3185 saw_omp = true;
3186 identified = 2;
3187 }
3188
3189 for (b = current_binding_level; b ; b = b->level_chain)
3190 {
3191 tree new_decls, old_decls = (b == level ? names : NULL_TREE);
3192
3193 for (new_decls = b->names; new_decls != old_decls;
3194 new_decls = (DECL_P (new_decls) ? DECL_CHAIN (new_decls)
3195 : TREE_CHAIN (new_decls)))
3196 {
3197 int problem = decl_jump_unsafe (new_decls);
3198 if (! problem)
3199 continue;
3200
3201 if (!identified)
3202 {
3203 complained = identify_goto (decl, input_location, locus,
3204 problem > 1
3205 ? DK_ERROR : DK_PERMERROR);
3206 identified = 1;
3207 }
3208 if (complained)
3209 {
3210 if (problem > 1)
3211 inform (DECL_SOURCE_LOCATION (new_decls),
3212 " crosses initialization of %q#D", new_decls);
3213 else
3214 inform (DECL_SOURCE_LOCATION (new_decls),
3215 " enters scope of %q#D, which has "
3216 "non-trivial destructor", new_decls);
3217 }
3218 }
3219
3220 if (b == level)
3221 break;
3222
3223 const char *inf = NULL;
3224 location_t loc = input_location;
3225 switch (b->kind)
3226 {
3227 case sk_try:
3228 if (!saw_eh)
3229 inf = N_("enters try block");
3230 saw_eh = true;
3231 break;
3232
3233 case sk_catch:
3234 if (!saw_eh)
3235 inf = N_("enters catch block");
3236 saw_eh = true;
3237 break;
3238
3239 case sk_omp:
3240 if (!saw_omp)
3241 inf = N_("enters OpenMP structured block");
3242 saw_omp = true;
3243 break;
3244
3245 case sk_transaction:
3246 if (!saw_tm)
3247 inf = N_("enters synchronized or atomic statement");
3248 saw_tm = true;
3249 break;
3250
3251 case sk_block:
3252 if (!saw_cxif && level_for_constexpr_if (b->level_chain))
3253 {
3254 inf = N_("enters constexpr if statement");
3255 loc = EXPR_LOCATION (b->level_chain->this_entity);
3256 saw_cxif = true;
3257 }
3258 break;
3259
3260 default:
3261 break;
3262 }
3263
3264 if (inf)
3265 {
3266 if (identified < 2)
3267 complained = identify_goto (decl, input_location, locus, DK_ERROR);
3268 identified = 2;
3269 if (complained)
3270 inform (loc, " %s", inf);
3271 }
3272 }
3273
3274 return !identified;
3275 }
3276
3277 static void
check_previous_goto(tree decl,struct named_label_use_entry * use)3278 check_previous_goto (tree decl, struct named_label_use_entry *use)
3279 {
3280 check_previous_goto_1 (decl, use->binding_level,
3281 use->names_in_scope, use->in_omp_scope,
3282 &use->o_goto_locus);
3283 }
3284
3285 static bool
check_switch_goto(cp_binding_level * level)3286 check_switch_goto (cp_binding_level* level)
3287 {
3288 return check_previous_goto_1 (NULL_TREE, level, level->names, false, NULL);
3289 }
3290
3291 /* Check that a new jump to a label DECL is OK. Called by
3292 finish_goto_stmt. */
3293
3294 void
check_goto(tree decl)3295 check_goto (tree decl)
3296 {
3297 /* We can't know where a computed goto is jumping.
3298 So we assume that it's OK. */
3299 if (TREE_CODE (decl) != LABEL_DECL)
3300 return;
3301
3302 /* We didn't record any information about this label when we created it,
3303 and there's not much point since it's trivial to analyze as a return. */
3304 if (decl == cdtor_label)
3305 return;
3306
3307 hashval_t hash = IDENTIFIER_HASH_VALUE (DECL_NAME (decl));
3308 named_label_entry **slot
3309 = named_labels->find_slot_with_hash (DECL_NAME (decl), hash, NO_INSERT);
3310 named_label_entry *ent = *slot;
3311
3312 /* If the label hasn't been defined yet, defer checking. */
3313 if (! DECL_INITIAL (decl))
3314 {
3315 /* Don't bother creating another use if the last goto had the
3316 same data, and will therefore create the same set of errors. */
3317 if (ent->uses
3318 && ent->uses->names_in_scope == current_binding_level->names)
3319 return;
3320
3321 named_label_use_entry *new_use
3322 = ggc_alloc<named_label_use_entry> ();
3323 new_use->binding_level = current_binding_level;
3324 new_use->names_in_scope = current_binding_level->names;
3325 new_use->o_goto_locus = input_location;
3326 new_use->in_omp_scope = false;
3327
3328 new_use->next = ent->uses;
3329 ent->uses = new_use;
3330 return;
3331 }
3332
3333 bool saw_catch = false, complained = false;
3334 int identified = 0;
3335 tree bad;
3336 unsigned ix;
3337
3338 if (ent->in_try_scope || ent->in_catch_scope || ent->in_transaction_scope
3339 || ent->in_constexpr_if
3340 || ent->in_omp_scope || !vec_safe_is_empty (ent->bad_decls))
3341 {
3342 diagnostic_t diag_kind = DK_PERMERROR;
3343 if (ent->in_try_scope || ent->in_catch_scope || ent->in_constexpr_if
3344 || ent->in_transaction_scope || ent->in_omp_scope)
3345 diag_kind = DK_ERROR;
3346 complained = identify_goto (decl, DECL_SOURCE_LOCATION (decl),
3347 &input_location, diag_kind);
3348 identified = 1 + (diag_kind == DK_ERROR);
3349 }
3350
3351 FOR_EACH_VEC_SAFE_ELT (ent->bad_decls, ix, bad)
3352 {
3353 int u = decl_jump_unsafe (bad);
3354
3355 if (u > 1 && DECL_ARTIFICIAL (bad))
3356 {
3357 /* Can't skip init of __exception_info. */
3358 if (identified == 1)
3359 {
3360 complained = identify_goto (decl, DECL_SOURCE_LOCATION (decl),
3361 &input_location, DK_ERROR);
3362 identified = 2;
3363 }
3364 if (complained)
3365 inform (DECL_SOURCE_LOCATION (bad), " enters catch block");
3366 saw_catch = true;
3367 }
3368 else if (complained)
3369 {
3370 if (u > 1)
3371 inform (DECL_SOURCE_LOCATION (bad),
3372 " skips initialization of %q#D", bad);
3373 else
3374 inform (DECL_SOURCE_LOCATION (bad),
3375 " enters scope of %q#D which has "
3376 "non-trivial destructor", bad);
3377 }
3378 }
3379
3380 if (complained)
3381 {
3382 if (ent->in_try_scope)
3383 inform (input_location, " enters try block");
3384 else if (ent->in_catch_scope && !saw_catch)
3385 inform (input_location, " enters catch block");
3386 else if (ent->in_transaction_scope)
3387 inform (input_location, " enters synchronized or atomic statement");
3388 else if (ent->in_constexpr_if)
3389 inform (input_location, " enters %<constexpr%> if statement");
3390 }
3391
3392 if (ent->in_omp_scope)
3393 {
3394 if (complained)
3395 inform (input_location, " enters OpenMP structured block");
3396 }
3397 else if (flag_openmp)
3398 for (cp_binding_level *b = current_binding_level; b ; b = b->level_chain)
3399 {
3400 if (b == ent->binding_level)
3401 break;
3402 if (b->kind == sk_omp)
3403 {
3404 if (identified < 2)
3405 {
3406 complained = identify_goto (decl,
3407 DECL_SOURCE_LOCATION (decl),
3408 &input_location, DK_ERROR);
3409 identified = 2;
3410 }
3411 if (complained)
3412 inform (input_location, " exits OpenMP structured block");
3413 break;
3414 }
3415 }
3416 }
3417
3418 /* Check that a return is ok wrt OpenMP structured blocks.
3419 Called by finish_return_stmt. Returns true if all is well. */
3420
3421 bool
check_omp_return(void)3422 check_omp_return (void)
3423 {
3424 for (cp_binding_level *b = current_binding_level; b ; b = b->level_chain)
3425 if (b->kind == sk_omp)
3426 {
3427 error ("invalid exit from OpenMP structured block");
3428 return false;
3429 }
3430 else if (b->kind == sk_function_parms)
3431 break;
3432 return true;
3433 }
3434
3435 /* Define a label, specifying the location in the source file.
3436 Return the LABEL_DECL node for the label. */
3437
3438 static tree
define_label_1(location_t location,tree name)3439 define_label_1 (location_t location, tree name)
3440 {
3441 /* After labels, make any new cleanups in the function go into their
3442 own new (temporary) binding contour. */
3443 for (cp_binding_level *p = current_binding_level;
3444 p->kind != sk_function_parms;
3445 p = p->level_chain)
3446 p->more_cleanups_ok = 0;
3447
3448 named_label_entry *ent = lookup_label_1 (name, false);
3449 tree decl = ent->label_decl;
3450
3451 if (DECL_INITIAL (decl) != NULL_TREE)
3452 {
3453 error ("duplicate label %qD", decl);
3454 return error_mark_node;
3455 }
3456 else
3457 {
3458 /* Mark label as having been defined. */
3459 DECL_INITIAL (decl) = error_mark_node;
3460 /* Say where in the source. */
3461 DECL_SOURCE_LOCATION (decl) = location;
3462
3463 ent->binding_level = current_binding_level;
3464 ent->names_in_scope = current_binding_level->names;
3465
3466 for (named_label_use_entry *use = ent->uses; use; use = use->next)
3467 check_previous_goto (decl, use);
3468 ent->uses = NULL;
3469 }
3470
3471 return decl;
3472 }
3473
3474 /* Wrapper for define_label_1. */
3475
3476 tree
define_label(location_t location,tree name)3477 define_label (location_t location, tree name)
3478 {
3479 bool running = timevar_cond_start (TV_NAME_LOOKUP);
3480 tree ret = define_label_1 (location, name);
3481 timevar_cond_stop (TV_NAME_LOOKUP, running);
3482 return ret;
3483 }
3484
3485
3486 struct cp_switch
3487 {
3488 cp_binding_level *level;
3489 struct cp_switch *next;
3490 /* The SWITCH_STMT being built. */
3491 tree switch_stmt;
3492 /* A splay-tree mapping the low element of a case range to the high
3493 element, or NULL_TREE if there is no high element. Used to
3494 determine whether or not a new case label duplicates an old case
3495 label. We need a tree, rather than simply a hash table, because
3496 of the GNU case range extension. */
3497 splay_tree cases;
3498 /* Remember whether a default: case label has been seen. */
3499 bool has_default_p;
3500 /* Remember whether a BREAK_STMT has been seen in this SWITCH_STMT. */
3501 bool break_stmt_seen_p;
3502 /* Set if inside of {FOR,DO,WHILE}_BODY nested inside of a switch,
3503 where BREAK_STMT doesn't belong to the SWITCH_STMT. */
3504 bool in_loop_body_p;
3505 };
3506
3507 /* A stack of the currently active switch statements. The innermost
3508 switch statement is on the top of the stack. There is no need to
3509 mark the stack for garbage collection because it is only active
3510 during the processing of the body of a function, and we never
3511 collect at that point. */
3512
3513 static struct cp_switch *switch_stack;
3514
3515 /* Called right after a switch-statement condition is parsed.
3516 SWITCH_STMT is the switch statement being parsed. */
3517
3518 void
push_switch(tree switch_stmt)3519 push_switch (tree switch_stmt)
3520 {
3521 struct cp_switch *p = XNEW (struct cp_switch);
3522 p->level = current_binding_level;
3523 p->next = switch_stack;
3524 p->switch_stmt = switch_stmt;
3525 p->cases = splay_tree_new (case_compare, NULL, NULL);
3526 p->has_default_p = false;
3527 p->break_stmt_seen_p = false;
3528 p->in_loop_body_p = false;
3529 switch_stack = p;
3530 }
3531
3532 void
pop_switch(void)3533 pop_switch (void)
3534 {
3535 struct cp_switch *cs = switch_stack;
3536 location_t switch_location;
3537
3538 /* Emit warnings as needed. */
3539 switch_location = cp_expr_loc_or_loc (cs->switch_stmt, input_location);
3540 const bool bool_cond_p
3541 = (SWITCH_STMT_TYPE (cs->switch_stmt)
3542 && TREE_CODE (SWITCH_STMT_TYPE (cs->switch_stmt)) == BOOLEAN_TYPE);
3543 if (!processing_template_decl)
3544 c_do_switch_warnings (cs->cases, switch_location,
3545 SWITCH_STMT_TYPE (cs->switch_stmt),
3546 SWITCH_STMT_COND (cs->switch_stmt), bool_cond_p);
3547
3548 /* For the benefit of block_may_fallthru remember if the switch body
3549 case labels cover all possible values and if there are break; stmts. */
3550 if (cs->has_default_p
3551 || (!processing_template_decl
3552 && c_switch_covers_all_cases_p (cs->cases,
3553 SWITCH_STMT_TYPE (cs->switch_stmt))))
3554 SWITCH_STMT_ALL_CASES_P (cs->switch_stmt) = 1;
3555 if (!cs->break_stmt_seen_p)
3556 SWITCH_STMT_NO_BREAK_P (cs->switch_stmt) = 1;
3557 gcc_assert (!cs->in_loop_body_p);
3558 splay_tree_delete (cs->cases);
3559 switch_stack = switch_stack->next;
3560 free (cs);
3561 }
3562
3563 /* Note that a BREAK_STMT is about to be added. If it is inside of
3564 a SWITCH_STMT and not inside of a loop body inside of it, note
3565 in switch_stack we've seen a BREAK_STMT. */
3566
3567 void
note_break_stmt(void)3568 note_break_stmt (void)
3569 {
3570 if (switch_stack && !switch_stack->in_loop_body_p)
3571 switch_stack->break_stmt_seen_p = true;
3572 }
3573
3574 /* Note the start of processing of an iteration statement's body.
3575 The note_break_stmt function will do nothing while processing it.
3576 Return a flag that should be passed to note_iteration_stmt_body_end. */
3577
3578 bool
note_iteration_stmt_body_start(void)3579 note_iteration_stmt_body_start (void)
3580 {
3581 if (!switch_stack)
3582 return false;
3583 bool ret = switch_stack->in_loop_body_p;
3584 switch_stack->in_loop_body_p = true;
3585 return ret;
3586 }
3587
3588 /* Note the end of processing of an iteration statement's body. */
3589
3590 void
note_iteration_stmt_body_end(bool prev)3591 note_iteration_stmt_body_end (bool prev)
3592 {
3593 if (switch_stack)
3594 switch_stack->in_loop_body_p = prev;
3595 }
3596
3597 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
3598 condition. Note that if TYPE and VALUE are already integral we don't
3599 really do the conversion because the language-independent
3600 warning/optimization code will work better that way. */
3601
3602 static tree
case_conversion(tree type,tree value)3603 case_conversion (tree type, tree value)
3604 {
3605 if (value == NULL_TREE)
3606 return value;
3607
3608 value = mark_rvalue_use (value);
3609
3610 if (cxx_dialect >= cxx11
3611 && (SCOPED_ENUM_P (type)
3612 || !INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (value))))
3613 {
3614 if (INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
3615 type = type_promotes_to (type);
3616 value = (perform_implicit_conversion_flags
3617 (type, value, tf_warning_or_error,
3618 LOOKUP_IMPLICIT | LOOKUP_NO_NON_INTEGRAL));
3619 }
3620 return cxx_constant_value (value);
3621 }
3622
3623 /* Note that we've seen a definition of a case label, and complain if this
3624 is a bad place for one. */
3625
3626 tree
finish_case_label(location_t loc,tree low_value,tree high_value)3627 finish_case_label (location_t loc, tree low_value, tree high_value)
3628 {
3629 tree cond, r;
3630 cp_binding_level *p;
3631 tree type;
3632
3633 if (low_value == NULL_TREE && high_value == NULL_TREE)
3634 switch_stack->has_default_p = true;
3635
3636 if (processing_template_decl)
3637 {
3638 tree label;
3639
3640 /* For templates, just add the case label; we'll do semantic
3641 analysis at instantiation-time. */
3642 label = build_decl (loc, LABEL_DECL, NULL_TREE, void_type_node);
3643 return add_stmt (build_case_label (low_value, high_value, label));
3644 }
3645
3646 /* Find the condition on which this switch statement depends. */
3647 cond = SWITCH_STMT_COND (switch_stack->switch_stmt);
3648 if (cond && TREE_CODE (cond) == TREE_LIST)
3649 cond = TREE_VALUE (cond);
3650
3651 if (!check_switch_goto (switch_stack->level))
3652 return error_mark_node;
3653
3654 type = SWITCH_STMT_TYPE (switch_stack->switch_stmt);
3655 if (type == error_mark_node)
3656 return error_mark_node;
3657
3658 low_value = case_conversion (type, low_value);
3659 high_value = case_conversion (type, high_value);
3660
3661 r = c_add_case_label (loc, switch_stack->cases, cond, low_value, high_value);
3662
3663 /* After labels, make any new cleanups in the function go into their
3664 own new (temporary) binding contour. */
3665 for (p = current_binding_level;
3666 p->kind != sk_function_parms;
3667 p = p->level_chain)
3668 p->more_cleanups_ok = 0;
3669
3670 return r;
3671 }
3672
3673 struct typename_info {
3674 tree scope;
3675 tree name;
3676 tree template_id;
3677 bool enum_p;
3678 bool class_p;
3679 };
3680
3681 struct typename_hasher : ggc_ptr_hash<tree_node>
3682 {
3683 typedef typename_info *compare_type;
3684
3685 /* Hash a TYPENAME_TYPE. */
3686
3687 static hashval_t
hashtypename_hasher3688 hash (tree t)
3689 {
3690 hashval_t hash;
3691
3692 hash = (htab_hash_pointer (TYPE_CONTEXT (t))
3693 ^ htab_hash_pointer (TYPE_IDENTIFIER (t)));
3694
3695 return hash;
3696 }
3697
3698 /* Compare two TYPENAME_TYPEs. */
3699
3700 static bool
equaltypename_hasher3701 equal (tree t1, const typename_info *t2)
3702 {
3703 return (TYPE_IDENTIFIER (t1) == t2->name
3704 && TYPE_CONTEXT (t1) == t2->scope
3705 && TYPENAME_TYPE_FULLNAME (t1) == t2->template_id
3706 && TYPENAME_IS_ENUM_P (t1) == t2->enum_p
3707 && TYPENAME_IS_CLASS_P (t1) == t2->class_p);
3708 }
3709 };
3710
3711 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
3712 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
3713
3714 Returns the new TYPENAME_TYPE. */
3715
3716 static GTY (()) hash_table<typename_hasher> *typename_htab;
3717
3718 tree
build_typename_type(tree context,tree name,tree fullname,enum tag_types tag_type)3719 build_typename_type (tree context, tree name, tree fullname,
3720 enum tag_types tag_type)
3721 {
3722 tree t;
3723 tree d;
3724 typename_info ti;
3725 tree *e;
3726 hashval_t hash;
3727
3728 if (typename_htab == NULL)
3729 typename_htab = hash_table<typename_hasher>::create_ggc (61);
3730
3731 ti.scope = FROB_CONTEXT (context);
3732 ti.name = name;
3733 ti.template_id = fullname;
3734 ti.enum_p = tag_type == enum_type;
3735 ti.class_p = (tag_type == class_type
3736 || tag_type == record_type
3737 || tag_type == union_type);
3738 hash = (htab_hash_pointer (ti.scope)
3739 ^ htab_hash_pointer (ti.name));
3740
3741 /* See if we already have this type. */
3742 e = typename_htab->find_slot_with_hash (&ti, hash, INSERT);
3743 if (*e)
3744 t = *e;
3745 else
3746 {
3747 /* Build the TYPENAME_TYPE. */
3748 t = cxx_make_type (TYPENAME_TYPE);
3749 TYPE_CONTEXT (t) = ti.scope;
3750 TYPENAME_TYPE_FULLNAME (t) = ti.template_id;
3751 TYPENAME_IS_ENUM_P (t) = ti.enum_p;
3752 TYPENAME_IS_CLASS_P (t) = ti.class_p;
3753
3754 /* Build the corresponding TYPE_DECL. */
3755 d = build_decl (input_location, TYPE_DECL, name, t);
3756 TYPE_NAME (TREE_TYPE (d)) = d;
3757 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
3758 DECL_CONTEXT (d) = FROB_CONTEXT (context);
3759 DECL_ARTIFICIAL (d) = 1;
3760
3761 /* Store it in the hash table. */
3762 *e = t;
3763
3764 /* TYPENAME_TYPEs must always be compared structurally, because
3765 they may or may not resolve down to another type depending on
3766 the currently open classes. */
3767 SET_TYPE_STRUCTURAL_EQUALITY (t);
3768 }
3769
3770 return t;
3771 }
3772
3773 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
3774 provided to name the type. Returns an appropriate type, unless an
3775 error occurs, in which case error_mark_node is returned. If we
3776 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
3777 return that, rather than the _TYPE it corresponds to, in other
3778 cases we look through the type decl. If TF_ERROR is set, complain
3779 about errors, otherwise be quiet. */
3780
3781 tree
make_typename_type(tree context,tree name,enum tag_types tag_type,tsubst_flags_t complain)3782 make_typename_type (tree context, tree name, enum tag_types tag_type,
3783 tsubst_flags_t complain)
3784 {
3785 tree fullname;
3786 tree t;
3787 bool want_template;
3788
3789 if (name == error_mark_node
3790 || context == NULL_TREE
3791 || context == error_mark_node)
3792 return error_mark_node;
3793
3794 if (TYPE_P (name))
3795 {
3796 if (!(TYPE_LANG_SPECIFIC (name)
3797 && (CLASSTYPE_IS_TEMPLATE (name)
3798 || CLASSTYPE_USE_TEMPLATE (name))))
3799 name = TYPE_IDENTIFIER (name);
3800 else
3801 /* Create a TEMPLATE_ID_EXPR for the type. */
3802 name = build_nt (TEMPLATE_ID_EXPR,
3803 CLASSTYPE_TI_TEMPLATE (name),
3804 CLASSTYPE_TI_ARGS (name));
3805 }
3806 else if (TREE_CODE (name) == TYPE_DECL)
3807 name = DECL_NAME (name);
3808
3809 fullname = name;
3810
3811 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
3812 {
3813 name = TREE_OPERAND (name, 0);
3814 if (DECL_TYPE_TEMPLATE_P (name))
3815 name = TREE_OPERAND (fullname, 0) = DECL_NAME (name);
3816 if (TREE_CODE (name) != IDENTIFIER_NODE)
3817 {
3818 if (complain & tf_error)
3819 error ("%qD is not a type", name);
3820 return error_mark_node;
3821 }
3822 }
3823 if (TREE_CODE (name) == TEMPLATE_DECL)
3824 {
3825 if (complain & tf_error)
3826 error ("%qD used without template arguments", name);
3827 return error_mark_node;
3828 }
3829 gcc_assert (identifier_p (name));
3830 gcc_assert (TYPE_P (context));
3831
3832 if (TREE_CODE (context) == TYPE_PACK_EXPANSION)
3833 /* This can happen for C++17 variadic using (c++/88986). */;
3834 else if (!MAYBE_CLASS_TYPE_P (context))
3835 {
3836 if (complain & tf_error)
3837 error ("%q#T is not a class", context);
3838 return error_mark_node;
3839 }
3840
3841 /* When the CONTEXT is a dependent type, NAME could refer to a
3842 dependent base class of CONTEXT. But look inside it anyway
3843 if CONTEXT is a currently open scope, in case it refers to a
3844 member of the current instantiation or a non-dependent base;
3845 lookup will stop when we hit a dependent base. */
3846 if (!dependent_scope_p (context))
3847 /* We should only set WANT_TYPE when we're a nested typename type.
3848 Then we can give better diagnostics if we find a non-type. */
3849 t = lookup_field (context, name, 2, /*want_type=*/true);
3850 else
3851 t = NULL_TREE;
3852
3853 if ((!t || TREE_CODE (t) == TREE_LIST) && dependent_type_p (context))
3854 return build_typename_type (context, name, fullname, tag_type);
3855
3856 want_template = TREE_CODE (fullname) == TEMPLATE_ID_EXPR;
3857
3858 if (!t)
3859 {
3860 if (complain & tf_error)
3861 {
3862 if (!COMPLETE_TYPE_P (context))
3863 cxx_incomplete_type_error (NULL_TREE, context);
3864 else
3865 error (want_template ? G_("no class template named %q#T in %q#T")
3866 : G_("no type named %q#T in %q#T"), name, context);
3867 }
3868 return error_mark_node;
3869 }
3870
3871 /* Pull out the template from an injected-class-name (or multiple). */
3872 if (want_template)
3873 t = maybe_get_template_decl_from_type_decl (t);
3874
3875 if (TREE_CODE (t) == TREE_LIST)
3876 {
3877 if (complain & tf_error)
3878 {
3879 error ("lookup of %qT in %qT is ambiguous", name, context);
3880 print_candidates (t);
3881 }
3882 return error_mark_node;
3883 }
3884
3885 if (want_template && !DECL_TYPE_TEMPLATE_P (t))
3886 {
3887 if (complain & tf_error)
3888 error ("%<typename %T::%D%> names %q#T, which is not a class template",
3889 context, name, t);
3890 return error_mark_node;
3891 }
3892 if (!want_template && TREE_CODE (t) != TYPE_DECL)
3893 {
3894 if (complain & tf_error)
3895 error ("%<typename %T::%D%> names %q#T, which is not a type",
3896 context, name, t);
3897 return error_mark_node;
3898 }
3899
3900 if (!perform_or_defer_access_check (TYPE_BINFO (context), t, t, complain))
3901 return error_mark_node;
3902
3903 /* If we are currently parsing a template and if T is a typedef accessed
3904 through CONTEXT then we need to remember and check access of T at
3905 template instantiation time. */
3906 add_typedef_to_current_template_for_access_check (t, context, input_location);
3907
3908 if (want_template)
3909 return lookup_template_class (t, TREE_OPERAND (fullname, 1),
3910 NULL_TREE, context,
3911 /*entering_scope=*/0,
3912 complain | tf_user);
3913
3914 if (DECL_ARTIFICIAL (t) || !(complain & tf_keep_type_decl))
3915 t = TREE_TYPE (t);
3916
3917 maybe_record_typedef_use (t);
3918
3919 return t;
3920 }
3921
3922 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
3923 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
3924 in which case error_mark_node is returned.
3925
3926 If PARM_LIST is non-NULL, also make sure that the template parameter
3927 list of TEMPLATE_DECL matches.
3928
3929 If COMPLAIN zero, don't complain about any errors that occur. */
3930
3931 tree
make_unbound_class_template(tree context,tree name,tree parm_list,tsubst_flags_t complain)3932 make_unbound_class_template (tree context, tree name, tree parm_list,
3933 tsubst_flags_t complain)
3934 {
3935 tree t;
3936 tree d;
3937
3938 if (TYPE_P (name))
3939 name = TYPE_IDENTIFIER (name);
3940 else if (DECL_P (name))
3941 name = DECL_NAME (name);
3942 gcc_assert (identifier_p (name));
3943
3944 if (!dependent_type_p (context)
3945 || currently_open_class (context))
3946 {
3947 tree tmpl = NULL_TREE;
3948
3949 if (MAYBE_CLASS_TYPE_P (context))
3950 tmpl = lookup_field (context, name, 0, false);
3951
3952 if (tmpl && TREE_CODE (tmpl) == TYPE_DECL)
3953 tmpl = maybe_get_template_decl_from_type_decl (tmpl);
3954
3955 if (!tmpl || !DECL_TYPE_TEMPLATE_P (tmpl))
3956 {
3957 if (complain & tf_error)
3958 error ("no class template named %q#T in %q#T", name, context);
3959 return error_mark_node;
3960 }
3961
3962 if (parm_list
3963 && !comp_template_parms (DECL_TEMPLATE_PARMS (tmpl), parm_list))
3964 {
3965 if (complain & tf_error)
3966 {
3967 error ("template parameters do not match template %qD", tmpl);
3968 inform (DECL_SOURCE_LOCATION (tmpl),
3969 "%qD declared here", tmpl);
3970 }
3971 return error_mark_node;
3972 }
3973
3974 if (!perform_or_defer_access_check (TYPE_BINFO (context), tmpl, tmpl,
3975 complain))
3976 return error_mark_node;
3977
3978 return tmpl;
3979 }
3980
3981 /* Build the UNBOUND_CLASS_TEMPLATE. */
3982 t = cxx_make_type (UNBOUND_CLASS_TEMPLATE);
3983 TYPE_CONTEXT (t) = FROB_CONTEXT (context);
3984 TREE_TYPE (t) = NULL_TREE;
3985 SET_TYPE_STRUCTURAL_EQUALITY (t);
3986
3987 /* Build the corresponding TEMPLATE_DECL. */
3988 d = build_decl (input_location, TEMPLATE_DECL, name, t);
3989 TYPE_NAME (TREE_TYPE (d)) = d;
3990 TYPE_STUB_DECL (TREE_TYPE (d)) = d;
3991 DECL_CONTEXT (d) = FROB_CONTEXT (context);
3992 DECL_ARTIFICIAL (d) = 1;
3993 DECL_TEMPLATE_PARMS (d) = parm_list;
3994
3995 return t;
3996 }
3997
3998
3999
4000 /* Push the declarations of builtin types into the global namespace.
4001 RID_INDEX is the index of the builtin type in the array
4002 RID_POINTERS. NAME is the name used when looking up the builtin
4003 type. TYPE is the _TYPE node for the builtin type.
4004
4005 The calls to set_global_binding below should be
4006 eliminated. Built-in types should not be looked up name; their
4007 names are keywords that the parser can recognize. However, there
4008 is code in c-common.c that uses identifier_global_value to look up
4009 built-in types by name. */
4010
4011 void
record_builtin_type(enum rid rid_index,const char * name,tree type)4012 record_builtin_type (enum rid rid_index,
4013 const char* name,
4014 tree type)
4015 {
4016 tree decl = NULL_TREE;
4017
4018 if (name)
4019 {
4020 tree tname = get_identifier (name);
4021 tree tdecl = build_decl (BUILTINS_LOCATION, TYPE_DECL, tname, type);
4022 DECL_ARTIFICIAL (tdecl) = 1;
4023 set_global_binding (tdecl);
4024 decl = tdecl;
4025 }
4026
4027 if ((int) rid_index < (int) RID_MAX)
4028 if (tree rname = ridpointers[(int) rid_index])
4029 if (!decl || DECL_NAME (decl) != rname)
4030 {
4031 tree rdecl = build_decl (BUILTINS_LOCATION, TYPE_DECL, rname, type);
4032 DECL_ARTIFICIAL (rdecl) = 1;
4033 set_global_binding (rdecl);
4034 if (!decl)
4035 decl = rdecl;
4036 }
4037
4038 if (decl)
4039 {
4040 if (!TYPE_NAME (type))
4041 TYPE_NAME (type) = decl;
4042 debug_hooks->type_decl (decl, 0);
4043 }
4044 }
4045
4046 /* Push a type into the namespace so that the back ends ignore it. */
4047
4048 static void
record_unknown_type(tree type,const char * name)4049 record_unknown_type (tree type, const char* name)
4050 {
4051 tree decl = pushdecl (build_decl (UNKNOWN_LOCATION,
4052 TYPE_DECL, get_identifier (name), type));
4053 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
4054 DECL_IGNORED_P (decl) = 1;
4055 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
4056 TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
4057 SET_TYPE_ALIGN (type, 1);
4058 TYPE_USER_ALIGN (type) = 0;
4059 SET_TYPE_MODE (type, TYPE_MODE (void_type_node));
4060 }
4061
4062 /* Create all the predefined identifiers. */
4063
4064 static void
initialize_predefined_identifiers(void)4065 initialize_predefined_identifiers (void)
4066 {
4067 struct predefined_identifier
4068 {
4069 const char *name; /* Name. */
4070 tree *node; /* Node to store it in. */
4071 cp_identifier_kind kind; /* Kind of identifier. */
4072 };
4073
4074 /* A table of identifiers to create at startup. */
4075 static const predefined_identifier predefined_identifiers[] = {
4076 {"C++", &lang_name_cplusplus, cik_normal},
4077 {"C", &lang_name_c, cik_normal},
4078 /* Some of these names have a trailing space so that it is
4079 impossible for them to conflict with names written by users. */
4080 {"__ct ", &ctor_identifier, cik_ctor},
4081 {"__ct_base ", &base_ctor_identifier, cik_ctor},
4082 {"__ct_comp ", &complete_ctor_identifier, cik_ctor},
4083 {"__dt ", &dtor_identifier, cik_dtor},
4084 {"__dt_base ", &base_dtor_identifier, cik_dtor},
4085 {"__dt_comp ", &complete_dtor_identifier, cik_dtor},
4086 {"__dt_del ", &deleting_dtor_identifier, cik_dtor},
4087 {"__conv_op ", &conv_op_identifier, cik_conv_op},
4088 {"__in_chrg", &in_charge_identifier, cik_normal},
4089 {"this", &this_identifier, cik_normal},
4090 {"__delta", &delta_identifier, cik_normal},
4091 {"__pfn", &pfn_identifier, cik_normal},
4092 {"_vptr", &vptr_identifier, cik_normal},
4093 {"__vtt_parm", &vtt_parm_identifier, cik_normal},
4094 {"::", &global_identifier, cik_normal},
4095 {"std", &std_identifier, cik_normal},
4096 /* The demangler expects anonymous namespaces to be called
4097 something starting with '_GLOBAL__N_'. It no longer needs
4098 to be unique to the TU. */
4099 {"_GLOBAL__N_1", &anon_identifier, cik_normal},
4100 {"auto", &auto_identifier, cik_normal},
4101 {"decltype(auto)", &decltype_auto_identifier, cik_normal},
4102 {"initializer_list", &init_list_identifier, cik_normal},
4103 {"__for_range ", &for_range__identifier, cik_normal},
4104 {"__for_begin ", &for_begin__identifier, cik_normal},
4105 {"__for_end ", &for_end__identifier, cik_normal},
4106 {"__for_range", &for_range_identifier, cik_normal},
4107 {"__for_begin", &for_begin_identifier, cik_normal},
4108 {"__for_end", &for_end_identifier, cik_normal},
4109 {"abi_tag", &abi_tag_identifier, cik_normal},
4110 {"aligned", &aligned_identifier, cik_normal},
4111 {"begin", &begin_identifier, cik_normal},
4112 {"end", &end_identifier, cik_normal},
4113 {"get", &get__identifier, cik_normal},
4114 {"gnu", &gnu_identifier, cik_normal},
4115 {"tuple_element", &tuple_element_identifier, cik_normal},
4116 {"tuple_size", &tuple_size_identifier, cik_normal},
4117 {"type", &type_identifier, cik_normal},
4118 {"value", &value_identifier, cik_normal},
4119 {"_FUN", &fun_identifier, cik_normal},
4120 {"__closure", &closure_identifier, cik_normal},
4121 {NULL, NULL, cik_normal}
4122 };
4123
4124 for (const predefined_identifier *pid = predefined_identifiers;
4125 pid->name; ++pid)
4126 {
4127 *pid->node = get_identifier (pid->name);
4128 /* Some of these identifiers already have a special kind. */
4129 if (pid->kind != cik_normal)
4130 set_identifier_kind (*pid->node, pid->kind);
4131 }
4132 }
4133
4134 /* Create the predefined scalar types of C,
4135 and some nodes representing standard constants (0, 1, (void *)0).
4136 Initialize the global binding level.
4137 Make definitions for built-in primitive functions. */
4138
4139 void
cxx_init_decl_processing(void)4140 cxx_init_decl_processing (void)
4141 {
4142 tree void_ftype;
4143 tree void_ftype_ptr;
4144
4145 /* Create all the identifiers we need. */
4146 initialize_predefined_identifiers ();
4147
4148 /* Create the global variables. */
4149 push_to_top_level ();
4150
4151 current_function_decl = NULL_TREE;
4152 current_binding_level = NULL;
4153 /* Enter the global namespace. */
4154 gcc_assert (global_namespace == NULL_TREE);
4155 global_namespace = build_lang_decl (NAMESPACE_DECL, global_identifier,
4156 void_type_node);
4157 TREE_PUBLIC (global_namespace) = 1;
4158 DECL_CONTEXT (global_namespace)
4159 = build_translation_unit_decl (get_identifier (main_input_filename));
4160 /* Remember whether we want the empty class passing ABI change warning
4161 in this TU. */
4162 TRANSLATION_UNIT_WARN_EMPTY_P (DECL_CONTEXT (global_namespace))
4163 = warn_abi && abi_version_crosses (12);
4164 debug_hooks->register_main_translation_unit
4165 (DECL_CONTEXT (global_namespace));
4166 begin_scope (sk_namespace, global_namespace);
4167 current_namespace = global_namespace;
4168
4169 if (flag_visibility_ms_compat)
4170 default_visibility = VISIBILITY_HIDDEN;
4171
4172 /* Initially, C. */
4173 current_lang_name = lang_name_c;
4174
4175 /* Create the `std' namespace. */
4176 push_namespace (std_identifier);
4177 std_node = current_namespace;
4178 pop_namespace ();
4179
4180 flag_noexcept_type = (cxx_dialect >= cxx17);
4181
4182 c_common_nodes_and_builtins ();
4183
4184 tree bool_ftype = build_function_type_list (boolean_type_node, NULL_TREE);
4185 tree decl
4186 = add_builtin_function ("__builtin_is_constant_evaluated",
4187 bool_ftype, CP_BUILT_IN_IS_CONSTANT_EVALUATED,
4188 BUILT_IN_FRONTEND, NULL, NULL_TREE);
4189 set_call_expr_flags (decl, ECF_CONST | ECF_NOTHROW | ECF_LEAF);
4190
4191 integer_two_node = build_int_cst (NULL_TREE, 2);
4192
4193 /* Guess at the initial static decls size. */
4194 vec_alloc (static_decls, 500);
4195
4196 /* ... and keyed classes. */
4197 vec_alloc (keyed_classes, 100);
4198
4199 record_builtin_type (RID_BOOL, "bool", boolean_type_node);
4200 truthvalue_type_node = boolean_type_node;
4201 truthvalue_false_node = boolean_false_node;
4202 truthvalue_true_node = boolean_true_node;
4203
4204 empty_except_spec = build_tree_list (NULL_TREE, NULL_TREE);
4205 noexcept_true_spec = build_tree_list (boolean_true_node, NULL_TREE);
4206 noexcept_false_spec = build_tree_list (boolean_false_node, NULL_TREE);
4207 noexcept_deferred_spec = build_tree_list (make_node (DEFERRED_NOEXCEPT),
4208 NULL_TREE);
4209
4210 #if 0
4211 record_builtin_type (RID_MAX, NULL, string_type_node);
4212 #endif
4213
4214 delta_type_node = ptrdiff_type_node;
4215 vtable_index_type = ptrdiff_type_node;
4216
4217 vtt_parm_type = build_pointer_type (const_ptr_type_node);
4218 void_ftype = build_function_type_list (void_type_node, NULL_TREE);
4219 void_ftype_ptr = build_function_type_list (void_type_node,
4220 ptr_type_node, NULL_TREE);
4221 void_ftype_ptr
4222 = build_exception_variant (void_ftype_ptr, empty_except_spec);
4223
4224 /* Create the conversion operator marker. This operator's DECL_NAME
4225 is in the identifier table, so we can use identifier equality to
4226 find it. */
4227 conv_op_marker = build_lang_decl (FUNCTION_DECL, conv_op_identifier,
4228 void_ftype);
4229
4230 /* C++ extensions */
4231
4232 unknown_type_node = make_node (LANG_TYPE);
4233 record_unknown_type (unknown_type_node, "unknown type");
4234
4235 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
4236 TREE_TYPE (unknown_type_node) = unknown_type_node;
4237
4238 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
4239 result. */
4240 TYPE_POINTER_TO (unknown_type_node) = unknown_type_node;
4241 TYPE_REFERENCE_TO (unknown_type_node) = unknown_type_node;
4242
4243 init_list_type_node = make_node (LANG_TYPE);
4244 record_unknown_type (init_list_type_node, "init list");
4245
4246 {
4247 /* Make sure we get a unique function type, so we can give
4248 its pointer type a name. (This wins for gdb.) */
4249 tree vfunc_type = make_node (FUNCTION_TYPE);
4250 TREE_TYPE (vfunc_type) = integer_type_node;
4251 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
4252 layout_type (vfunc_type);
4253
4254 vtable_entry_type = build_pointer_type (vfunc_type);
4255 }
4256 record_builtin_type (RID_MAX, "__vtbl_ptr_type", vtable_entry_type);
4257
4258 vtbl_type_node
4259 = build_cplus_array_type (vtable_entry_type, NULL_TREE);
4260 layout_type (vtbl_type_node);
4261 vtbl_type_node = cp_build_qualified_type (vtbl_type_node, TYPE_QUAL_CONST);
4262 record_builtin_type (RID_MAX, NULL, vtbl_type_node);
4263 vtbl_ptr_type_node = build_pointer_type (vtable_entry_type);
4264 layout_type (vtbl_ptr_type_node);
4265 record_builtin_type (RID_MAX, NULL, vtbl_ptr_type_node);
4266
4267 push_namespace (get_identifier ("__cxxabiv1"));
4268 abi_node = current_namespace;
4269 pop_namespace ();
4270
4271 global_type_node = make_node (LANG_TYPE);
4272 record_unknown_type (global_type_node, "global type");
4273
4274 any_targ_node = make_node (LANG_TYPE);
4275 record_unknown_type (any_targ_node, "any type");
4276
4277 /* Now, C++. */
4278 current_lang_name = lang_name_cplusplus;
4279
4280 if (aligned_new_threshold > 1
4281 && !pow2p_hwi (aligned_new_threshold))
4282 {
4283 error ("%<-faligned-new=%d%> is not a power of two",
4284 aligned_new_threshold);
4285 aligned_new_threshold = 1;
4286 }
4287 if (aligned_new_threshold == -1)
4288 aligned_new_threshold = (cxx_dialect >= cxx17) ? 1 : 0;
4289 if (aligned_new_threshold == 1)
4290 aligned_new_threshold = malloc_alignment () / BITS_PER_UNIT;
4291
4292 {
4293 tree newattrs, extvisattr;
4294 tree newtype, deltype;
4295 tree ptr_ftype_sizetype;
4296 tree new_eh_spec;
4297
4298 ptr_ftype_sizetype
4299 = build_function_type_list (ptr_type_node, size_type_node, NULL_TREE);
4300 if (cxx_dialect == cxx98)
4301 {
4302 tree bad_alloc_id;
4303 tree bad_alloc_type_node;
4304 tree bad_alloc_decl;
4305
4306 push_namespace (std_identifier);
4307 bad_alloc_id = get_identifier ("bad_alloc");
4308 bad_alloc_type_node = make_class_type (RECORD_TYPE);
4309 TYPE_CONTEXT (bad_alloc_type_node) = current_namespace;
4310 bad_alloc_decl
4311 = create_implicit_typedef (bad_alloc_id, bad_alloc_type_node);
4312 DECL_CONTEXT (bad_alloc_decl) = current_namespace;
4313 pop_namespace ();
4314
4315 new_eh_spec
4316 = add_exception_specifier (NULL_TREE, bad_alloc_type_node, -1);
4317 }
4318 else
4319 new_eh_spec = noexcept_false_spec;
4320
4321 /* Ensure attribs.c is initialized. */
4322 init_attributes ();
4323
4324 /* Ensure constraint.cc is initialized. */
4325 init_constraint_processing ();
4326
4327 extvisattr = build_tree_list (get_identifier ("externally_visible"),
4328 NULL_TREE);
4329 newattrs = tree_cons (get_identifier ("alloc_size"),
4330 build_tree_list (NULL_TREE, integer_one_node),
4331 extvisattr);
4332 newtype = cp_build_type_attribute_variant (ptr_ftype_sizetype, newattrs);
4333 newtype = build_exception_variant (newtype, new_eh_spec);
4334 deltype = cp_build_type_attribute_variant (void_ftype_ptr, extvisattr);
4335 deltype = build_exception_variant (deltype, empty_except_spec);
4336 tree opnew = push_cp_library_fn (NEW_EXPR, newtype, 0);
4337 DECL_IS_MALLOC (opnew) = 1;
4338 DECL_IS_OPERATOR_NEW (opnew) = 1;
4339 opnew = push_cp_library_fn (VEC_NEW_EXPR, newtype, 0);
4340 DECL_IS_MALLOC (opnew) = 1;
4341 DECL_IS_OPERATOR_NEW (opnew) = 1;
4342 push_cp_library_fn (DELETE_EXPR, deltype, ECF_NOTHROW);
4343 push_cp_library_fn (VEC_DELETE_EXPR, deltype, ECF_NOTHROW);
4344 if (flag_sized_deallocation)
4345 {
4346 /* Also push the sized deallocation variants:
4347 void operator delete(void*, std::size_t) throw();
4348 void operator delete[](void*, std::size_t) throw(); */
4349 tree void_ftype_ptr_size
4350 = build_function_type_list (void_type_node, ptr_type_node,
4351 size_type_node, NULL_TREE);
4352 deltype = cp_build_type_attribute_variant (void_ftype_ptr_size,
4353 extvisattr);
4354 deltype = build_exception_variant (deltype, empty_except_spec);
4355 push_cp_library_fn (DELETE_EXPR, deltype, ECF_NOTHROW);
4356 push_cp_library_fn (VEC_DELETE_EXPR, deltype, ECF_NOTHROW);
4357 }
4358
4359 if (aligned_new_threshold)
4360 {
4361 push_namespace (std_identifier);
4362 tree align_id = get_identifier ("align_val_t");
4363 align_type_node = start_enum (align_id, NULL_TREE, size_type_node,
4364 NULL_TREE, /*scoped*/true, NULL);
4365 pop_namespace ();
4366
4367 /* operator new (size_t, align_val_t); */
4368 newtype = build_function_type_list (ptr_type_node, size_type_node,
4369 align_type_node, NULL_TREE);
4370 newtype = cp_build_type_attribute_variant (newtype, newattrs);
4371 newtype = build_exception_variant (newtype, new_eh_spec);
4372 opnew = push_cp_library_fn (NEW_EXPR, newtype, 0);
4373 DECL_IS_MALLOC (opnew) = 1;
4374 DECL_IS_OPERATOR_NEW (opnew) = 1;
4375 opnew = push_cp_library_fn (VEC_NEW_EXPR, newtype, 0);
4376 DECL_IS_MALLOC (opnew) = 1;
4377 DECL_IS_OPERATOR_NEW (opnew) = 1;
4378
4379 /* operator delete (void *, align_val_t); */
4380 deltype = build_function_type_list (void_type_node, ptr_type_node,
4381 align_type_node, NULL_TREE);
4382 deltype = cp_build_type_attribute_variant (deltype, extvisattr);
4383 deltype = build_exception_variant (deltype, empty_except_spec);
4384 push_cp_library_fn (DELETE_EXPR, deltype, ECF_NOTHROW);
4385 push_cp_library_fn (VEC_DELETE_EXPR, deltype, ECF_NOTHROW);
4386
4387 if (flag_sized_deallocation)
4388 {
4389 /* operator delete (void *, size_t, align_val_t); */
4390 deltype = build_function_type_list (void_type_node, ptr_type_node,
4391 size_type_node, align_type_node,
4392 NULL_TREE);
4393 deltype = cp_build_type_attribute_variant (deltype, extvisattr);
4394 deltype = build_exception_variant (deltype, empty_except_spec);
4395 push_cp_library_fn (DELETE_EXPR, deltype, ECF_NOTHROW);
4396 push_cp_library_fn (VEC_DELETE_EXPR, deltype, ECF_NOTHROW);
4397 }
4398 }
4399
4400 nullptr_type_node = make_node (NULLPTR_TYPE);
4401 TYPE_SIZE (nullptr_type_node) = bitsize_int (GET_MODE_BITSIZE (ptr_mode));
4402 TYPE_SIZE_UNIT (nullptr_type_node) = size_int (GET_MODE_SIZE (ptr_mode));
4403 TYPE_UNSIGNED (nullptr_type_node) = 1;
4404 TYPE_PRECISION (nullptr_type_node) = GET_MODE_BITSIZE (ptr_mode);
4405 if (abi_version_at_least (9))
4406 SET_TYPE_ALIGN (nullptr_type_node, GET_MODE_ALIGNMENT (ptr_mode));
4407 SET_TYPE_MODE (nullptr_type_node, ptr_mode);
4408 record_builtin_type (RID_MAX, "decltype(nullptr)", nullptr_type_node);
4409 nullptr_node = build_int_cst (nullptr_type_node, 0);
4410 }
4411
4412 abort_fndecl
4413 = build_library_fn_ptr ("__cxa_pure_virtual", void_ftype,
4414 ECF_NORETURN | ECF_NOTHROW | ECF_COLD);
4415
4416 /* Perform other language dependent initializations. */
4417 init_class_processing ();
4418 init_rtti_processing ();
4419 init_template_processing ();
4420
4421 if (flag_exceptions)
4422 init_exception_processing ();
4423
4424 if (! supports_one_only ())
4425 flag_weak = 0;
4426
4427 make_fname_decl = cp_make_fname_decl;
4428 start_fname_decls ();
4429
4430 /* Show we use EH for cleanups. */
4431 if (flag_exceptions)
4432 using_eh_for_cleanups ();
4433 }
4434
4435 /* Generate an initializer for a function naming variable from
4436 NAME. NAME may be NULL, to indicate a dependent name. TYPE_P is
4437 filled in with the type of the init. */
4438
4439 tree
cp_fname_init(const char * name,tree * type_p)4440 cp_fname_init (const char* name, tree *type_p)
4441 {
4442 tree domain = NULL_TREE;
4443 tree type;
4444 tree init = NULL_TREE;
4445 size_t length = 0;
4446
4447 if (name)
4448 {
4449 length = strlen (name);
4450 domain = build_index_type (size_int (length));
4451 init = build_string (length + 1, name);
4452 }
4453
4454 type = cp_build_qualified_type (char_type_node, TYPE_QUAL_CONST);
4455 type = build_cplus_array_type (type, domain);
4456
4457 *type_p = type;
4458
4459 if (init)
4460 TREE_TYPE (init) = type;
4461 else
4462 init = error_mark_node;
4463
4464 return init;
4465 }
4466
4467 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
4468 the decl, LOC is the location to give the decl, NAME is the
4469 initialization string and TYPE_DEP indicates whether NAME depended
4470 on the type of the function. We make use of that to detect
4471 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
4472 at the point of first use, so we mustn't push the decl now. */
4473
4474 static tree
cp_make_fname_decl(location_t loc,tree id,int type_dep)4475 cp_make_fname_decl (location_t loc, tree id, int type_dep)
4476 {
4477 const char * name = NULL;
4478 bool release_name = false;
4479 if (!(type_dep && in_template_function ()))
4480 {
4481 if (current_function_decl == NULL_TREE)
4482 name = "top level";
4483 else if (type_dep == 1) /* __PRETTY_FUNCTION__ */
4484 name = cxx_printable_name (current_function_decl, 2);
4485 else if (type_dep == 0) /* __FUNCTION__ */
4486 {
4487 name = fname_as_string (type_dep);
4488 release_name = true;
4489 }
4490 else
4491 gcc_unreachable ();
4492 }
4493 tree type;
4494 tree init = cp_fname_init (name, &type);
4495 tree decl = build_decl (loc, VAR_DECL, id, type);
4496
4497 if (release_name)
4498 free (CONST_CAST (char *, name));
4499
4500 /* As we're using pushdecl_with_scope, we must set the context. */
4501 DECL_CONTEXT (decl) = current_function_decl;
4502
4503 TREE_READONLY (decl) = 1;
4504 DECL_ARTIFICIAL (decl) = 1;
4505 DECL_DECLARED_CONSTEXPR_P (decl) = 1;
4506 TREE_STATIC (decl) = 1;
4507
4508 TREE_USED (decl) = 1;
4509
4510 if (init)
4511 {
4512 SET_DECL_VALUE_EXPR (decl, init);
4513 DECL_HAS_VALUE_EXPR_P (decl) = 1;
4514 /* For decl_constant_var_p. */
4515 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
4516 }
4517
4518 if (current_function_decl)
4519 {
4520 DECL_CONTEXT (decl) = current_function_decl;
4521 decl = pushdecl_outermost_localscope (decl);
4522 if (decl != error_mark_node)
4523 add_decl_expr (decl);
4524 }
4525 else
4526 {
4527 DECL_THIS_STATIC (decl) = true;
4528 pushdecl_top_level_and_finish (decl, NULL_TREE);
4529 }
4530
4531 return decl;
4532 }
4533
4534 static tree
builtin_function_1(tree decl,tree context,bool is_global)4535 builtin_function_1 (tree decl, tree context, bool is_global)
4536 {
4537 tree id = DECL_NAME (decl);
4538 const char *name = IDENTIFIER_POINTER (id);
4539
4540 retrofit_lang_decl (decl);
4541
4542 DECL_ARTIFICIAL (decl) = 1;
4543 SET_DECL_LANGUAGE (decl, lang_c);
4544 /* Runtime library routines are, by definition, available in an
4545 external shared object. */
4546 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
4547 DECL_VISIBILITY_SPECIFIED (decl) = 1;
4548
4549 DECL_CONTEXT (decl) = context;
4550
4551 /* A function in the user's namespace should have an explicit
4552 declaration before it is used. Mark the built-in function as
4553 anticipated but not actually declared. */
4554 if (name[0] != '_' || name[1] != '_')
4555 DECL_ANTICIPATED (decl) = 1;
4556 else if (strncmp (name + 2, "builtin_", strlen ("builtin_")) != 0)
4557 {
4558 size_t len = strlen (name);
4559
4560 /* Treat __*_chk fortification functions as anticipated as well,
4561 unless they are __builtin_*. */
4562 if (len > strlen ("___chk")
4563 && memcmp (name + len - strlen ("_chk"),
4564 "_chk", strlen ("_chk") + 1) == 0)
4565 DECL_ANTICIPATED (decl) = 1;
4566 }
4567
4568 if (is_global)
4569 return pushdecl_top_level (decl);
4570 else
4571 return pushdecl (decl);
4572 }
4573
4574 tree
cxx_builtin_function(tree decl)4575 cxx_builtin_function (tree decl)
4576 {
4577 tree id = DECL_NAME (decl);
4578 const char *name = IDENTIFIER_POINTER (id);
4579 /* All builtins that don't begin with an '_' should additionally
4580 go in the 'std' namespace. */
4581 if (name[0] != '_')
4582 {
4583 tree decl2 = copy_node(decl);
4584 push_namespace (std_identifier);
4585 builtin_function_1 (decl2, std_node, false);
4586 pop_namespace ();
4587 }
4588
4589 return builtin_function_1 (decl, NULL_TREE, false);
4590 }
4591
4592 /* Like cxx_builtin_function, but guarantee the function is added to the global
4593 scope. This is to allow function specific options to add new machine
4594 dependent builtins when the target ISA changes via attribute((target(...)))
4595 which saves space on program startup if the program does not use non-generic
4596 ISAs. */
4597
4598 tree
cxx_builtin_function_ext_scope(tree decl)4599 cxx_builtin_function_ext_scope (tree decl)
4600 {
4601
4602 tree id = DECL_NAME (decl);
4603 const char *name = IDENTIFIER_POINTER (id);
4604 /* All builtins that don't begin with an '_' should additionally
4605 go in the 'std' namespace. */
4606 if (name[0] != '_')
4607 {
4608 tree decl2 = copy_node(decl);
4609 push_namespace (std_identifier);
4610 builtin_function_1 (decl2, std_node, true);
4611 pop_namespace ();
4612 }
4613
4614 return builtin_function_1 (decl, NULL_TREE, true);
4615 }
4616
4617 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
4618 function. Not called directly. */
4619
4620 static tree
build_library_fn(tree name,enum tree_code operator_code,tree type,int ecf_flags)4621 build_library_fn (tree name, enum tree_code operator_code, tree type,
4622 int ecf_flags)
4623 {
4624 tree fn = build_lang_decl (FUNCTION_DECL, name, type);
4625 DECL_EXTERNAL (fn) = 1;
4626 TREE_PUBLIC (fn) = 1;
4627 DECL_ARTIFICIAL (fn) = 1;
4628 DECL_OVERLOADED_OPERATOR_CODE_RAW (fn)
4629 = OVL_OP_INFO (false, operator_code)->ovl_op_code;
4630 SET_DECL_LANGUAGE (fn, lang_c);
4631 /* Runtime library routines are, by definition, available in an
4632 external shared object. */
4633 DECL_VISIBILITY (fn) = VISIBILITY_DEFAULT;
4634 DECL_VISIBILITY_SPECIFIED (fn) = 1;
4635 set_call_expr_flags (fn, ecf_flags);
4636 return fn;
4637 }
4638
4639 /* Returns the _DECL for a library function with C++ linkage. */
4640
4641 static tree
build_cp_library_fn(tree name,enum tree_code operator_code,tree type,int ecf_flags)4642 build_cp_library_fn (tree name, enum tree_code operator_code, tree type,
4643 int ecf_flags)
4644 {
4645 tree fn = build_library_fn (name, operator_code, type, ecf_flags);
4646 DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
4647 SET_DECL_LANGUAGE (fn, lang_cplusplus);
4648 return fn;
4649 }
4650
4651 /* Like build_library_fn, but takes a C string instead of an
4652 IDENTIFIER_NODE. */
4653
4654 tree
build_library_fn_ptr(const char * name,tree type,int ecf_flags)4655 build_library_fn_ptr (const char* name, tree type, int ecf_flags)
4656 {
4657 return build_library_fn (get_identifier (name), ERROR_MARK, type, ecf_flags);
4658 }
4659
4660 /* Like build_cp_library_fn, but takes a C string instead of an
4661 IDENTIFIER_NODE. */
4662
4663 tree
build_cp_library_fn_ptr(const char * name,tree type,int ecf_flags)4664 build_cp_library_fn_ptr (const char* name, tree type, int ecf_flags)
4665 {
4666 return build_cp_library_fn (get_identifier (name), ERROR_MARK, type,
4667 ecf_flags);
4668 }
4669
4670 /* Like build_library_fn, but also pushes the function so that we will
4671 be able to find it via get_global_binding. Also, the function
4672 may throw exceptions listed in RAISES. */
4673
4674 tree
push_library_fn(tree name,tree type,tree raises,int ecf_flags)4675 push_library_fn (tree name, tree type, tree raises, int ecf_flags)
4676 {
4677 tree fn;
4678
4679 if (raises)
4680 type = build_exception_variant (type, raises);
4681
4682 fn = build_library_fn (name, ERROR_MARK, type, ecf_flags);
4683 pushdecl_top_level (fn);
4684 return fn;
4685 }
4686
4687 /* Like build_cp_library_fn, but also pushes the function so that it
4688 will be found by normal lookup. */
4689
4690 static tree
push_cp_library_fn(enum tree_code operator_code,tree type,int ecf_flags)4691 push_cp_library_fn (enum tree_code operator_code, tree type,
4692 int ecf_flags)
4693 {
4694 tree fn = build_cp_library_fn (ovl_op_identifier (false, operator_code),
4695 operator_code, type, ecf_flags);
4696 pushdecl (fn);
4697 if (flag_tm)
4698 apply_tm_attr (fn, get_identifier ("transaction_safe"));
4699 return fn;
4700 }
4701
4702 /* Like push_library_fn, but takes a TREE_LIST of parm types rather than
4703 a FUNCTION_TYPE. */
4704
4705 tree
push_void_library_fn(tree name,tree parmtypes,int ecf_flags)4706 push_void_library_fn (tree name, tree parmtypes, int ecf_flags)
4707 {
4708 tree type = build_function_type (void_type_node, parmtypes);
4709 return push_library_fn (name, type, NULL_TREE, ecf_flags);
4710 }
4711
4712 /* Like push_library_fn, but also note that this function throws
4713 and does not return. Used for __throw_foo and the like. */
4714
4715 tree
push_throw_library_fn(tree name,tree type)4716 push_throw_library_fn (tree name, tree type)
4717 {
4718 tree fn = push_library_fn (name, type, NULL_TREE, ECF_NORETURN | ECF_COLD);
4719 return fn;
4720 }
4721
4722 /* When we call finish_struct for an anonymous union, we create
4723 default copy constructors and such. But, an anonymous union
4724 shouldn't have such things; this function undoes the damage to the
4725 anonymous union type T.
4726
4727 (The reason that we create the synthesized methods is that we don't
4728 distinguish `union { int i; }' from `typedef union { int i; } U'.
4729 The first is an anonymous union; the second is just an ordinary
4730 union type.) */
4731
4732 void
fixup_anonymous_aggr(tree t)4733 fixup_anonymous_aggr (tree t)
4734 {
4735 /* Wipe out memory of synthesized methods. */
4736 TYPE_HAS_USER_CONSTRUCTOR (t) = 0;
4737 TYPE_HAS_DEFAULT_CONSTRUCTOR (t) = 0;
4738 TYPE_HAS_COPY_CTOR (t) = 0;
4739 TYPE_HAS_CONST_COPY_CTOR (t) = 0;
4740 TYPE_HAS_COPY_ASSIGN (t) = 0;
4741 TYPE_HAS_CONST_COPY_ASSIGN (t) = 0;
4742
4743 /* Splice the implicitly generated functions out of TYPE_FIELDS. */
4744 for (tree probe, *prev_p = &TYPE_FIELDS (t); (probe = *prev_p);)
4745 if (TREE_CODE (probe) == FUNCTION_DECL && DECL_ARTIFICIAL (probe))
4746 *prev_p = DECL_CHAIN (probe);
4747 else
4748 prev_p = &DECL_CHAIN (probe);
4749
4750 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
4751 assignment operators (because they cannot have these methods themselves).
4752 For anonymous unions this is already checked because they are not allowed
4753 in any union, otherwise we have to check it. */
4754 if (TREE_CODE (t) != UNION_TYPE)
4755 {
4756 tree field, type;
4757
4758 for (field = TYPE_FIELDS (t); field; field = DECL_CHAIN (field))
4759 if (TREE_CODE (field) == FIELD_DECL)
4760 {
4761 type = TREE_TYPE (field);
4762 if (CLASS_TYPE_P (type))
4763 {
4764 if (TYPE_NEEDS_CONSTRUCTING (type))
4765 error ("member %q+#D with constructor not allowed "
4766 "in anonymous aggregate", field);
4767 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
4768 error ("member %q+#D with destructor not allowed "
4769 "in anonymous aggregate", field);
4770 if (TYPE_HAS_COMPLEX_COPY_ASSIGN (type))
4771 error ("member %q+#D with copy assignment operator "
4772 "not allowed in anonymous aggregate", field);
4773 }
4774 }
4775 }
4776 }
4777
4778 /* Warn for an attribute located at LOCATION that appertains to the
4779 class type CLASS_TYPE that has not been properly placed after its
4780 class-key, in it class-specifier. */
4781
4782 void
warn_misplaced_attr_for_class_type(location_t location,tree class_type)4783 warn_misplaced_attr_for_class_type (location_t location,
4784 tree class_type)
4785 {
4786 gcc_assert (OVERLOAD_TYPE_P (class_type));
4787
4788 auto_diagnostic_group d;
4789 if (warning_at (location, OPT_Wattributes,
4790 "attribute ignored in declaration "
4791 "of %q#T", class_type))
4792 inform (location,
4793 "attribute for %q#T must follow the %qs keyword",
4794 class_type, class_key_or_enum_as_string (class_type));
4795 }
4796
4797 /* Make sure that a declaration with no declarator is well-formed, i.e.
4798 just declares a tagged type or anonymous union.
4799
4800 Returns the type declared; or NULL_TREE if none. */
4801
4802 tree
check_tag_decl(cp_decl_specifier_seq * declspecs,bool explicit_type_instantiation_p)4803 check_tag_decl (cp_decl_specifier_seq *declspecs,
4804 bool explicit_type_instantiation_p)
4805 {
4806 int saw_friend = decl_spec_seq_has_spec_p (declspecs, ds_friend);
4807 int saw_typedef = decl_spec_seq_has_spec_p (declspecs, ds_typedef);
4808 /* If a class, struct, or enum type is declared by the DECLSPECS
4809 (i.e, if a class-specifier, enum-specifier, or non-typename
4810 elaborated-type-specifier appears in the DECLSPECS),
4811 DECLARED_TYPE is set to the corresponding type. */
4812 tree declared_type = NULL_TREE;
4813 bool error_p = false;
4814
4815 if (declspecs->multiple_types_p)
4816 error ("multiple types in one declaration");
4817 else if (declspecs->redefined_builtin_type)
4818 {
4819 if (!in_system_header_at (input_location))
4820 permerror (declspecs->locations[ds_redefined_builtin_type_spec],
4821 "redeclaration of C++ built-in type %qT",
4822 declspecs->redefined_builtin_type);
4823 return NULL_TREE;
4824 }
4825
4826 if (declspecs->type
4827 && TYPE_P (declspecs->type)
4828 && ((TREE_CODE (declspecs->type) != TYPENAME_TYPE
4829 && MAYBE_CLASS_TYPE_P (declspecs->type))
4830 || TREE_CODE (declspecs->type) == ENUMERAL_TYPE))
4831 declared_type = declspecs->type;
4832 else if (declspecs->type == error_mark_node)
4833 error_p = true;
4834
4835 if (type_uses_auto (declared_type))
4836 {
4837 error_at (declspecs->locations[ds_type_spec],
4838 "%<auto%> can only be specified for variables "
4839 "or function declarations");
4840 return error_mark_node;
4841 }
4842
4843 if (declared_type && !OVERLOAD_TYPE_P (declared_type))
4844 declared_type = NULL_TREE;
4845
4846 if (!declared_type && !saw_friend && !error_p)
4847 permerror (input_location, "declaration does not declare anything");
4848 /* Check for an anonymous union. */
4849 else if (declared_type && RECORD_OR_UNION_CODE_P (TREE_CODE (declared_type))
4850 && TYPE_UNNAMED_P (declared_type))
4851 {
4852 /* 7/3 In a simple-declaration, the optional init-declarator-list
4853 can be omitted only when declaring a class (clause 9) or
4854 enumeration (7.2), that is, when the decl-specifier-seq contains
4855 either a class-specifier, an elaborated-type-specifier with
4856 a class-key (9.1), or an enum-specifier. In these cases and
4857 whenever a class-specifier or enum-specifier is present in the
4858 decl-specifier-seq, the identifiers in these specifiers are among
4859 the names being declared by the declaration (as class-name,
4860 enum-names, or enumerators, depending on the syntax). In such
4861 cases, and except for the declaration of an unnamed bit-field (9.6),
4862 the decl-specifier-seq shall introduce one or more names into the
4863 program, or shall redeclare a name introduced by a previous
4864 declaration. [Example:
4865 enum { }; // ill-formed
4866 typedef class { }; // ill-formed
4867 --end example] */
4868 if (saw_typedef)
4869 {
4870 error ("missing type-name in typedef-declaration");
4871 return NULL_TREE;
4872 }
4873 /* Anonymous unions are objects, so they can have specifiers. */;
4874 SET_ANON_AGGR_TYPE_P (declared_type);
4875
4876 if (TREE_CODE (declared_type) != UNION_TYPE
4877 && !in_system_header_at (input_location))
4878 pedwarn (input_location, OPT_Wpedantic, "ISO C++ prohibits anonymous structs");
4879 }
4880
4881 else
4882 {
4883 if (decl_spec_seq_has_spec_p (declspecs, ds_inline))
4884 error_at (declspecs->locations[ds_inline],
4885 "%<inline%> can only be specified for functions");
4886 else if (decl_spec_seq_has_spec_p (declspecs, ds_virtual))
4887 error_at (declspecs->locations[ds_virtual],
4888 "%<virtual%> can only be specified for functions");
4889 else if (saw_friend
4890 && (!current_class_type
4891 || current_scope () != current_class_type))
4892 error_at (declspecs->locations[ds_friend],
4893 "%<friend%> can only be specified inside a class");
4894 else if (decl_spec_seq_has_spec_p (declspecs, ds_explicit))
4895 error_at (declspecs->locations[ds_explicit],
4896 "%<explicit%> can only be specified for constructors");
4897 else if (declspecs->storage_class)
4898 error_at (declspecs->locations[ds_storage_class],
4899 "a storage class can only be specified for objects "
4900 "and functions");
4901 else if (decl_spec_seq_has_spec_p (declspecs, ds_const))
4902 error_at (declspecs->locations[ds_const],
4903 "%<const%> can only be specified for objects and "
4904 "functions");
4905 else if (decl_spec_seq_has_spec_p (declspecs, ds_volatile))
4906 error_at (declspecs->locations[ds_volatile],
4907 "%<volatile%> can only be specified for objects and "
4908 "functions");
4909 else if (decl_spec_seq_has_spec_p (declspecs, ds_restrict))
4910 error_at (declspecs->locations[ds_restrict],
4911 "%<__restrict%> can only be specified for objects and "
4912 "functions");
4913 else if (decl_spec_seq_has_spec_p (declspecs, ds_thread))
4914 error_at (declspecs->locations[ds_thread],
4915 "%<__thread%> can only be specified for objects "
4916 "and functions");
4917 else if (saw_typedef)
4918 warning_at (declspecs->locations[ds_typedef], 0,
4919 "%<typedef%> was ignored in this declaration");
4920 else if (decl_spec_seq_has_spec_p (declspecs, ds_constexpr))
4921 error_at (declspecs->locations[ds_constexpr],
4922 "%<constexpr%> cannot be used for type declarations");
4923 }
4924
4925 if (declspecs->attributes && warn_attributes && declared_type)
4926 {
4927 location_t loc;
4928 if (!CLASS_TYPE_P (declared_type)
4929 || !CLASSTYPE_TEMPLATE_INSTANTIATION (declared_type))
4930 /* For a non-template class, use the name location. */
4931 loc = location_of (declared_type);
4932 else
4933 /* For a template class (an explicit instantiation), use the
4934 current location. */
4935 loc = input_location;
4936
4937 if (explicit_type_instantiation_p)
4938 /* [dcl.attr.grammar]/4:
4939
4940 No attribute-specifier-seq shall appertain to an explicit
4941 instantiation. */
4942 {
4943 if (warning_at (loc, OPT_Wattributes,
4944 "attribute ignored in explicit instantiation %q#T",
4945 declared_type))
4946 inform (loc,
4947 "no attribute can be applied to "
4948 "an explicit instantiation");
4949 }
4950 else
4951 warn_misplaced_attr_for_class_type (loc, declared_type);
4952 }
4953
4954 return declared_type;
4955 }
4956
4957 /* Called when a declaration is seen that contains no names to declare.
4958 If its type is a reference to a structure, union or enum inherited
4959 from a containing scope, shadow that tag name for the current scope
4960 with a forward reference.
4961 If its type defines a new named structure or union
4962 or defines an enum, it is valid but we need not do anything here.
4963 Otherwise, it is an error.
4964
4965 C++: may have to grok the declspecs to learn about static,
4966 complain for anonymous unions.
4967
4968 Returns the TYPE declared -- or NULL_TREE if none. */
4969
4970 tree
shadow_tag(cp_decl_specifier_seq * declspecs)4971 shadow_tag (cp_decl_specifier_seq *declspecs)
4972 {
4973 tree t = check_tag_decl (declspecs,
4974 /*explicit_type_instantiation_p=*/false);
4975
4976 if (!t)
4977 return NULL_TREE;
4978
4979 if (maybe_process_partial_specialization (t) == error_mark_node)
4980 return NULL_TREE;
4981
4982 /* This is where the variables in an anonymous union are
4983 declared. An anonymous union declaration looks like:
4984 union { ... } ;
4985 because there is no declarator after the union, the parser
4986 sends that declaration here. */
4987 if (ANON_AGGR_TYPE_P (t))
4988 {
4989 fixup_anonymous_aggr (t);
4990
4991 if (TYPE_FIELDS (t))
4992 {
4993 tree decl = grokdeclarator (/*declarator=*/NULL,
4994 declspecs, NORMAL, 0, NULL);
4995 finish_anon_union (decl);
4996 }
4997 }
4998
4999 return t;
5000 }
5001
5002 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
5003
5004 tree
groktypename(cp_decl_specifier_seq * type_specifiers,const cp_declarator * declarator,bool is_template_arg)5005 groktypename (cp_decl_specifier_seq *type_specifiers,
5006 const cp_declarator *declarator,
5007 bool is_template_arg)
5008 {
5009 tree attrs;
5010 tree type;
5011 enum decl_context context
5012 = is_template_arg ? TEMPLATE_TYPE_ARG : TYPENAME;
5013 attrs = type_specifiers->attributes;
5014 type_specifiers->attributes = NULL_TREE;
5015 type = grokdeclarator (declarator, type_specifiers, context, 0, &attrs);
5016 if (attrs && type != error_mark_node)
5017 {
5018 if (CLASS_TYPE_P (type))
5019 warning (OPT_Wattributes, "ignoring attributes applied to class type %qT "
5020 "outside of definition", type);
5021 else if (MAYBE_CLASS_TYPE_P (type))
5022 /* A template type parameter or other dependent type. */
5023 warning (OPT_Wattributes, "ignoring attributes applied to dependent "
5024 "type %qT without an associated declaration", type);
5025 else
5026 cplus_decl_attributes (&type, attrs, 0);
5027 }
5028 return type;
5029 }
5030
5031 /* Process a DECLARATOR for a function-scope variable declaration,
5032 namespace-scope variable declaration, or function declaration.
5033 (Function definitions go through start_function; class member
5034 declarations appearing in the body of the class go through
5035 grokfield.) The DECL corresponding to the DECLARATOR is returned.
5036 If an error occurs, the error_mark_node is returned instead.
5037
5038 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
5039 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
5040 for an explicitly defaulted function, or SD_DELETED for an explicitly
5041 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
5042 implicitly initialized via a default constructor. ATTRIBUTES and
5043 PREFIX_ATTRIBUTES are GNU attributes associated with this declaration.
5044
5045 The scope represented by the context of the returned DECL is pushed
5046 (if it is not the global namespace) and is assigned to
5047 *PUSHED_SCOPE_P. The caller is then responsible for calling
5048 pop_scope on *PUSHED_SCOPE_P if it is set. */
5049
5050 tree
start_decl(const cp_declarator * declarator,cp_decl_specifier_seq * declspecs,int initialized,tree attributes,tree prefix_attributes,tree * pushed_scope_p)5051 start_decl (const cp_declarator *declarator,
5052 cp_decl_specifier_seq *declspecs,
5053 int initialized,
5054 tree attributes,
5055 tree prefix_attributes,
5056 tree *pushed_scope_p)
5057 {
5058 tree decl;
5059 tree context;
5060 bool was_public;
5061 int flags;
5062 bool alias;
5063
5064 *pushed_scope_p = NULL_TREE;
5065
5066 /* An object declared as __attribute__((deprecated)) suppresses
5067 warnings of uses of other deprecated items. */
5068 if (lookup_attribute ("deprecated", attributes))
5069 deprecated_state = DEPRECATED_SUPPRESS;
5070
5071 attributes = chainon (attributes, prefix_attributes);
5072
5073 decl = grokdeclarator (declarator, declspecs, NORMAL, initialized,
5074 &attributes);
5075
5076 deprecated_state = DEPRECATED_NORMAL;
5077
5078 if (decl == NULL_TREE || VOID_TYPE_P (decl)
5079 || decl == error_mark_node)
5080 return error_mark_node;
5081
5082 context = CP_DECL_CONTEXT (decl);
5083 if (context != global_namespace)
5084 *pushed_scope_p = push_scope (context);
5085
5086 /* Is it valid for this decl to have an initializer at all?
5087 If not, set INITIALIZED to zero, which will indirectly
5088 tell `cp_finish_decl' to ignore the initializer once it is parsed. */
5089 if (initialized
5090 && TREE_CODE (decl) == TYPE_DECL)
5091 {
5092 error_at (DECL_SOURCE_LOCATION (decl),
5093 "typedef %qD is initialized (use decltype instead)", decl);
5094 return error_mark_node;
5095 }
5096
5097 if (initialized)
5098 {
5099 if (! toplevel_bindings_p ()
5100 && DECL_EXTERNAL (decl))
5101 warning (0, "declaration of %q#D has %<extern%> and is initialized",
5102 decl);
5103 DECL_EXTERNAL (decl) = 0;
5104 if (toplevel_bindings_p ())
5105 TREE_STATIC (decl) = 1;
5106 }
5107 alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl)) != 0;
5108
5109 if (alias && TREE_CODE (decl) == FUNCTION_DECL)
5110 record_key_method_defined (decl);
5111
5112 /* If this is a typedef that names the class for linkage purposes
5113 (7.1.3p8), apply any attributes directly to the type. */
5114 if (TREE_CODE (decl) == TYPE_DECL
5115 && OVERLOAD_TYPE_P (TREE_TYPE (decl))
5116 && decl == TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (decl))))
5117 flags = ATTR_FLAG_TYPE_IN_PLACE;
5118 else
5119 flags = 0;
5120
5121 /* Set attributes here so if duplicate decl, will have proper attributes. */
5122 cplus_decl_attributes (&decl, attributes, flags);
5123
5124 /* Dllimported symbols cannot be defined. Static data members (which
5125 can be initialized in-class and dllimported) go through grokfield,
5126 not here, so we don't need to exclude those decls when checking for
5127 a definition. */
5128 if (initialized && DECL_DLLIMPORT_P (decl))
5129 {
5130 error_at (DECL_SOURCE_LOCATION (decl),
5131 "definition of %q#D is marked %<dllimport%>", decl);
5132 DECL_DLLIMPORT_P (decl) = 0;
5133 }
5134
5135 /* If #pragma weak was used, mark the decl weak now. */
5136 if (!processing_template_decl && !DECL_DECOMPOSITION_P (decl))
5137 maybe_apply_pragma_weak (decl);
5138
5139 if (TREE_CODE (decl) == FUNCTION_DECL
5140 && DECL_DECLARED_INLINE_P (decl)
5141 && DECL_UNINLINABLE (decl)
5142 && lookup_attribute ("noinline", DECL_ATTRIBUTES (decl)))
5143 warning_at (DECL_SOURCE_LOCATION (decl), 0,
5144 "inline function %qD given attribute noinline", decl);
5145
5146 if (TYPE_P (context) && COMPLETE_TYPE_P (complete_type (context)))
5147 {
5148 bool this_tmpl = (processing_template_decl
5149 > template_class_depth (context));
5150 if (VAR_P (decl))
5151 {
5152 tree field = lookup_field (context, DECL_NAME (decl), 0, false);
5153 if (field == NULL_TREE
5154 || !(VAR_P (field) || variable_template_p (field)))
5155 error ("%q+#D is not a static data member of %q#T", decl, context);
5156 else if (variable_template_p (field)
5157 && (DECL_LANG_SPECIFIC (decl)
5158 && DECL_TEMPLATE_SPECIALIZATION (decl)))
5159 /* OK, specialization was already checked. */;
5160 else if (variable_template_p (field) && !this_tmpl)
5161 {
5162 error_at (DECL_SOURCE_LOCATION (decl),
5163 "non-member-template declaration of %qD", decl);
5164 inform (DECL_SOURCE_LOCATION (field), "does not match "
5165 "member template declaration here");
5166 return error_mark_node;
5167 }
5168 else
5169 {
5170 if (variable_template_p (field))
5171 field = DECL_TEMPLATE_RESULT (field);
5172
5173 if (DECL_CONTEXT (field) != context)
5174 {
5175 if (!same_type_p (DECL_CONTEXT (field), context))
5176 permerror (input_location, "ISO C++ does not permit %<%T::%D%> "
5177 "to be defined as %<%T::%D%>",
5178 DECL_CONTEXT (field), DECL_NAME (decl),
5179 context, DECL_NAME (decl));
5180 DECL_CONTEXT (decl) = DECL_CONTEXT (field);
5181 }
5182 /* Static data member are tricky; an in-class initialization
5183 still doesn't provide a definition, so the in-class
5184 declaration will have DECL_EXTERNAL set, but will have an
5185 initialization. Thus, duplicate_decls won't warn
5186 about this situation, and so we check here. */
5187 if (initialized && DECL_INITIALIZED_IN_CLASS_P (field))
5188 error ("duplicate initialization of %qD", decl);
5189 field = duplicate_decls (decl, field,
5190 /*newdecl_is_friend=*/false);
5191 if (field == error_mark_node)
5192 return error_mark_node;
5193 else if (field)
5194 decl = field;
5195 }
5196 }
5197 else
5198 {
5199 tree field = check_classfn (context, decl,
5200 this_tmpl
5201 ? current_template_parms
5202 : NULL_TREE);
5203 if (field && field != error_mark_node
5204 && duplicate_decls (decl, field,
5205 /*newdecl_is_friend=*/false))
5206 decl = field;
5207 }
5208
5209 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
5210 DECL_IN_AGGR_P (decl) = 0;
5211 /* Do not mark DECL as an explicit specialization if it was not
5212 already marked as an instantiation; a declaration should
5213 never be marked as a specialization unless we know what
5214 template is being specialized. */
5215 if (DECL_LANG_SPECIFIC (decl) && DECL_USE_TEMPLATE (decl))
5216 {
5217 SET_DECL_TEMPLATE_SPECIALIZATION (decl);
5218 if (TREE_CODE (decl) == FUNCTION_DECL)
5219 DECL_COMDAT (decl) = (TREE_PUBLIC (decl)
5220 && DECL_DECLARED_INLINE_P (decl));
5221 else
5222 DECL_COMDAT (decl) = false;
5223
5224 /* [temp.expl.spec] An explicit specialization of a static data
5225 member of a template is a definition if the declaration
5226 includes an initializer; otherwise, it is a declaration.
5227
5228 We check for processing_specialization so this only applies
5229 to the new specialization syntax. */
5230 if (!initialized && processing_specialization)
5231 DECL_EXTERNAL (decl) = 1;
5232 }
5233
5234 if (DECL_EXTERNAL (decl) && ! DECL_TEMPLATE_SPECIALIZATION (decl)
5235 /* Aliases are definitions. */
5236 && !alias)
5237 permerror (declarator->id_loc,
5238 "declaration of %q#D outside of class is not definition",
5239 decl);
5240 }
5241
5242 was_public = TREE_PUBLIC (decl);
5243
5244 /* Enter this declaration into the symbol table. Don't push the plain
5245 VAR_DECL for a variable template. */
5246 if (!template_parm_scope_p ()
5247 || !VAR_P (decl))
5248 decl = maybe_push_decl (decl);
5249
5250 if (processing_template_decl)
5251 decl = push_template_decl (decl);
5252 if (decl == error_mark_node)
5253 return error_mark_node;
5254
5255 if (VAR_P (decl)
5256 && DECL_NAMESPACE_SCOPE_P (decl) && !TREE_PUBLIC (decl) && !was_public
5257 && !DECL_THIS_STATIC (decl) && !DECL_ARTIFICIAL (decl))
5258 {
5259 /* This is a const variable with implicit 'static'. Set
5260 DECL_THIS_STATIC so we can tell it from variables that are
5261 !TREE_PUBLIC because of the anonymous namespace. */
5262 gcc_assert (CP_TYPE_CONST_P (TREE_TYPE (decl)) || errorcount);
5263 DECL_THIS_STATIC (decl) = 1;
5264 }
5265
5266 if (current_function_decl && VAR_P (decl)
5267 && DECL_DECLARED_CONSTEXPR_P (current_function_decl))
5268 {
5269 bool ok = false;
5270 if (CP_DECL_THREAD_LOCAL_P (decl))
5271 error_at (DECL_SOURCE_LOCATION (decl),
5272 "%qD declared %<thread_local%> in %<constexpr%> function",
5273 decl);
5274 else if (TREE_STATIC (decl))
5275 error_at (DECL_SOURCE_LOCATION (decl),
5276 "%qD declared %<static%> in %<constexpr%> function", decl);
5277 else
5278 ok = true;
5279 if (!ok)
5280 cp_function_chain->invalid_constexpr = true;
5281 }
5282
5283 if (!processing_template_decl && VAR_P (decl))
5284 start_decl_1 (decl, initialized);
5285
5286 return decl;
5287 }
5288
5289 /* Process the declaration of a variable DECL. INITIALIZED is true
5290 iff DECL is explicitly initialized. (INITIALIZED is false if the
5291 variable is initialized via an implicitly-called constructor.)
5292 This function must be called for ordinary variables (including, for
5293 example, implicit instantiations of templates), but must not be
5294 called for template declarations. */
5295
5296 void
start_decl_1(tree decl,bool initialized)5297 start_decl_1 (tree decl, bool initialized)
5298 {
5299 tree type;
5300 bool complete_p;
5301 bool aggregate_definition_p;
5302
5303 gcc_assert (!processing_template_decl);
5304
5305 if (error_operand_p (decl))
5306 return;
5307
5308 gcc_assert (VAR_P (decl));
5309
5310 type = TREE_TYPE (decl);
5311 complete_p = COMPLETE_TYPE_P (type);
5312 aggregate_definition_p = MAYBE_CLASS_TYPE_P (type) && !DECL_EXTERNAL (decl);
5313
5314 /* If an explicit initializer is present, or if this is a definition
5315 of an aggregate, then we need a complete type at this point.
5316 (Scalars are always complete types, so there is nothing to
5317 check.) This code just sets COMPLETE_P; errors (if necessary)
5318 are issued below. */
5319 if ((initialized || aggregate_definition_p)
5320 && !complete_p
5321 && COMPLETE_TYPE_P (complete_type (type)))
5322 {
5323 complete_p = true;
5324 /* We will not yet have set TREE_READONLY on DECL if the type
5325 was "const", but incomplete, before this point. But, now, we
5326 have a complete type, so we can try again. */
5327 cp_apply_type_quals_to_decl (cp_type_quals (type), decl);
5328 }
5329
5330 if (initialized)
5331 /* Is it valid for this decl to have an initializer at all? */
5332 {
5333 /* Don't allow initializations for incomplete types except for
5334 arrays which might be completed by the initialization. */
5335 if (complete_p)
5336 ; /* A complete type is ok. */
5337 else if (type_uses_auto (type))
5338 ; /* An auto type is ok. */
5339 else if (TREE_CODE (type) != ARRAY_TYPE)
5340 {
5341 error ("variable %q#D has initializer but incomplete type", decl);
5342 type = TREE_TYPE (decl) = error_mark_node;
5343 }
5344 else if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (type))))
5345 {
5346 if (DECL_LANG_SPECIFIC (decl) && DECL_TEMPLATE_INFO (decl))
5347 error ("elements of array %q#D have incomplete type", decl);
5348 /* else we already gave an error in start_decl. */
5349 }
5350 }
5351 else if (aggregate_definition_p && !complete_p)
5352 {
5353 if (type_uses_auto (type))
5354 gcc_assert (CLASS_PLACEHOLDER_TEMPLATE (type));
5355 else
5356 {
5357 error ("aggregate %q#D has incomplete type and cannot be defined",
5358 decl);
5359 /* Change the type so that assemble_variable will give
5360 DECL an rtl we can live with: (mem (const_int 0)). */
5361 type = TREE_TYPE (decl) = error_mark_node;
5362 }
5363 }
5364
5365 /* Create a new scope to hold this declaration if necessary.
5366 Whether or not a new scope is necessary cannot be determined
5367 until after the type has been completed; if the type is a
5368 specialization of a class template it is not until after
5369 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
5370 will be set correctly. */
5371 maybe_push_cleanup_level (type);
5372 }
5373
5374 /* Handle initialization of references. DECL, TYPE, and INIT have the
5375 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
5376 but will be set to a new CLEANUP_STMT if a temporary is created
5377 that must be destroyed subsequently.
5378
5379 Returns an initializer expression to use to initialize DECL, or
5380 NULL if the initialization can be performed statically.
5381
5382 Quotes on semantics can be found in ARM 8.4.3. */
5383
5384 static tree
grok_reference_init(tree decl,tree type,tree init,int flags)5385 grok_reference_init (tree decl, tree type, tree init, int flags)
5386 {
5387 if (init == NULL_TREE)
5388 {
5389 if ((DECL_LANG_SPECIFIC (decl) == 0
5390 || DECL_IN_AGGR_P (decl) == 0)
5391 && ! DECL_THIS_EXTERN (decl))
5392 error_at (DECL_SOURCE_LOCATION (decl),
5393 "%qD declared as reference but not initialized", decl);
5394 return NULL_TREE;
5395 }
5396
5397 if (TREE_CODE (init) == TREE_LIST)
5398 init = build_x_compound_expr_from_list (init, ELK_INIT,
5399 tf_warning_or_error);
5400
5401 tree ttype = TREE_TYPE (type);
5402 if (TREE_CODE (ttype) != ARRAY_TYPE
5403 && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE)
5404 /* Note: default conversion is only called in very special cases. */
5405 init = decay_conversion (init, tf_warning_or_error);
5406
5407 /* check_initializer handles this for non-reference variables, but for
5408 references we need to do it here or the initializer will get the
5409 incomplete array type and confuse later calls to
5410 cp_complete_array_type. */
5411 if (TREE_CODE (ttype) == ARRAY_TYPE
5412 && TYPE_DOMAIN (ttype) == NULL_TREE
5413 && (BRACE_ENCLOSED_INITIALIZER_P (init)
5414 || TREE_CODE (init) == STRING_CST))
5415 {
5416 cp_complete_array_type (&ttype, init, false);
5417 if (ttype != TREE_TYPE (type))
5418 type = cp_build_reference_type (ttype, TYPE_REF_IS_RVALUE (type));
5419 }
5420
5421 /* Convert INIT to the reference type TYPE. This may involve the
5422 creation of a temporary, whose lifetime must be the same as that
5423 of the reference. If so, a DECL_EXPR for the temporary will be
5424 added just after the DECL_EXPR for DECL. That's why we don't set
5425 DECL_INITIAL for local references (instead assigning to them
5426 explicitly); we need to allow the temporary to be initialized
5427 first. */
5428 return initialize_reference (type, init, flags,
5429 tf_warning_or_error);
5430 }
5431
5432 /* Designated initializers in arrays are not supported in GNU C++.
5433 The parser cannot detect this error since it does not know whether
5434 a given brace-enclosed initializer is for a class type or for an
5435 array. This function checks that CE does not use a designated
5436 initializer. If it does, an error is issued. Returns true if CE
5437 is valid, i.e., does not have a designated initializer. */
5438
5439 bool
check_array_designated_initializer(constructor_elt * ce,unsigned HOST_WIDE_INT index)5440 check_array_designated_initializer (constructor_elt *ce,
5441 unsigned HOST_WIDE_INT index)
5442 {
5443 /* Designated initializers for array elements are not supported. */
5444 if (ce->index)
5445 {
5446 /* The parser only allows identifiers as designated
5447 initializers. */
5448 if (ce->index == error_mark_node)
5449 {
5450 error ("name used in a GNU-style designated "
5451 "initializer for an array");
5452 return false;
5453 }
5454 else if (identifier_p (ce->index))
5455 {
5456 error ("name %qD used in a GNU-style designated "
5457 "initializer for an array", ce->index);
5458 return false;
5459 }
5460
5461 tree ce_index = build_expr_type_conversion (WANT_INT | WANT_ENUM,
5462 ce->index, true);
5463 if (ce_index
5464 && INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (TREE_TYPE (ce_index))
5465 && (TREE_CODE (ce_index = fold_non_dependent_expr (ce_index))
5466 == INTEGER_CST))
5467 {
5468 /* A C99 designator is OK if it matches the current index. */
5469 if (wi::to_wide (ce_index) == index)
5470 {
5471 ce->index = ce_index;
5472 return true;
5473 }
5474 else
5475 sorry ("non-trivial designated initializers not supported");
5476 }
5477 else
5478 error ("C99 designator %qE is not an integral constant-expression",
5479 ce->index);
5480
5481 return false;
5482 }
5483
5484 return true;
5485 }
5486
5487 /* When parsing `int a[] = {1, 2};' we don't know the size of the
5488 array until we finish parsing the initializer. If that's the
5489 situation we're in, update DECL accordingly. */
5490
5491 static void
maybe_deduce_size_from_array_init(tree decl,tree init)5492 maybe_deduce_size_from_array_init (tree decl, tree init)
5493 {
5494 tree type = TREE_TYPE (decl);
5495
5496 if (TREE_CODE (type) == ARRAY_TYPE
5497 && TYPE_DOMAIN (type) == NULL_TREE
5498 && TREE_CODE (decl) != TYPE_DECL)
5499 {
5500 /* do_default is really a C-ism to deal with tentative definitions.
5501 But let's leave it here to ease the eventual merge. */
5502 int do_default = !DECL_EXTERNAL (decl);
5503 tree initializer = init ? init : DECL_INITIAL (decl);
5504 int failure = 0;
5505
5506 /* Check that there are no designated initializers in INIT, as
5507 those are not supported in GNU C++, and as the middle-end
5508 will crash if presented with a non-numeric designated
5509 initializer. */
5510 if (initializer && BRACE_ENCLOSED_INITIALIZER_P (initializer))
5511 {
5512 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (initializer);
5513 constructor_elt *ce;
5514 HOST_WIDE_INT i;
5515 FOR_EACH_VEC_SAFE_ELT (v, i, ce)
5516 {
5517 if (instantiation_dependent_expression_p (ce->index))
5518 return;
5519 if (!check_array_designated_initializer (ce, i))
5520 failure = 1;
5521 }
5522 }
5523
5524 if (failure)
5525 TREE_TYPE (decl) = error_mark_node;
5526 else
5527 {
5528 failure = cp_complete_array_type (&TREE_TYPE (decl), initializer,
5529 do_default);
5530 if (failure == 1)
5531 {
5532 error_at (cp_expr_loc_or_loc (initializer,
5533 DECL_SOURCE_LOCATION (decl)),
5534 "initializer fails to determine size of %qD", decl);
5535 }
5536 else if (failure == 2)
5537 {
5538 if (do_default)
5539 {
5540 error_at (DECL_SOURCE_LOCATION (decl),
5541 "array size missing in %qD", decl);
5542 }
5543 /* If a `static' var's size isn't known, make it extern as
5544 well as static, so it does not get allocated. If it's not
5545 `static', then don't mark it extern; finish_incomplete_decl
5546 will give it a default size and it will get allocated. */
5547 else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl))
5548 DECL_EXTERNAL (decl) = 1;
5549 }
5550 else if (failure == 3)
5551 {
5552 error_at (DECL_SOURCE_LOCATION (decl),
5553 "zero-size array %qD", decl);
5554 }
5555 }
5556
5557 cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl)), decl);
5558
5559 relayout_decl (decl);
5560 }
5561 }
5562
5563 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
5564 any appropriate error messages regarding the layout. */
5565
5566 static void
layout_var_decl(tree decl)5567 layout_var_decl (tree decl)
5568 {
5569 tree type;
5570
5571 type = TREE_TYPE (decl);
5572 if (type == error_mark_node)
5573 return;
5574
5575 /* If we haven't already laid out this declaration, do so now.
5576 Note that we must not call complete type for an external object
5577 because it's type might involve templates that we are not
5578 supposed to instantiate yet. (And it's perfectly valid to say
5579 `extern X x' for some incomplete type `X'.) */
5580 if (!DECL_EXTERNAL (decl))
5581 complete_type (type);
5582 if (!DECL_SIZE (decl)
5583 && TREE_TYPE (decl) != error_mark_node
5584 && complete_or_array_type_p (type))
5585 layout_decl (decl, 0);
5586
5587 if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
5588 {
5589 /* An automatic variable with an incomplete type: that is an error.
5590 Don't talk about array types here, since we took care of that
5591 message in grokdeclarator. */
5592 error_at (DECL_SOURCE_LOCATION (decl),
5593 "storage size of %qD isn%'t known", decl);
5594 TREE_TYPE (decl) = error_mark_node;
5595 }
5596 #if 0
5597 /* Keep this code around in case we later want to control debug info
5598 based on whether a type is "used". (jason 1999-11-11) */
5599
5600 else if (!DECL_EXTERNAL (decl) && MAYBE_CLASS_TYPE_P (ttype))
5601 /* Let debugger know it should output info for this type. */
5602 note_debug_info_needed (ttype);
5603
5604 if (TREE_STATIC (decl) && DECL_CLASS_SCOPE_P (decl))
5605 note_debug_info_needed (DECL_CONTEXT (decl));
5606 #endif
5607
5608 if ((DECL_EXTERNAL (decl) || TREE_STATIC (decl))
5609 && DECL_SIZE (decl) != NULL_TREE
5610 && ! TREE_CONSTANT (DECL_SIZE (decl)))
5611 {
5612 if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
5613 constant_expression_warning (DECL_SIZE (decl));
5614 else
5615 {
5616 error_at (DECL_SOURCE_LOCATION (decl),
5617 "storage size of %qD isn%'t constant", decl);
5618 TREE_TYPE (decl) = error_mark_node;
5619 }
5620 }
5621 }
5622
5623 /* If a local static variable is declared in an inline function, or if
5624 we have a weak definition, we must endeavor to create only one
5625 instance of the variable at link-time. */
5626
5627 void
maybe_commonize_var(tree decl)5628 maybe_commonize_var (tree decl)
5629 {
5630 /* Don't mess with __FUNCTION__ and similar. */
5631 if (DECL_ARTIFICIAL (decl))
5632 return;
5633
5634 /* Static data in a function with comdat linkage also has comdat
5635 linkage. */
5636 if ((TREE_STATIC (decl)
5637 && DECL_FUNCTION_SCOPE_P (decl)
5638 && vague_linkage_p (DECL_CONTEXT (decl)))
5639 || (TREE_PUBLIC (decl) && DECL_INLINE_VAR_P (decl)))
5640 {
5641 if (flag_weak)
5642 {
5643 /* With weak symbols, we simply make the variable COMDAT;
5644 that will cause copies in multiple translations units to
5645 be merged. */
5646 comdat_linkage (decl);
5647 }
5648 else
5649 {
5650 if (DECL_INITIAL (decl) == NULL_TREE
5651 || DECL_INITIAL (decl) == error_mark_node)
5652 {
5653 /* Without weak symbols, we can use COMMON to merge
5654 uninitialized variables. */
5655 TREE_PUBLIC (decl) = 1;
5656 DECL_COMMON (decl) = 1;
5657 }
5658 else
5659 {
5660 /* While for initialized variables, we must use internal
5661 linkage -- which means that multiple copies will not
5662 be merged. */
5663 TREE_PUBLIC (decl) = 0;
5664 DECL_COMMON (decl) = 0;
5665 DECL_INTERFACE_KNOWN (decl) = 1;
5666 const char *msg;
5667 if (DECL_INLINE_VAR_P (decl))
5668 msg = G_("sorry: semantics of inline variable "
5669 "%q#D are wrong (you%'ll wind up with "
5670 "multiple copies)");
5671 else
5672 msg = G_("sorry: semantics of inline function "
5673 "static data %q#D are wrong (you%'ll wind "
5674 "up with multiple copies)");
5675 if (warning_at (DECL_SOURCE_LOCATION (decl), 0,
5676 msg, decl))
5677 inform (DECL_SOURCE_LOCATION (decl),
5678 "you can work around this by removing the initializer");
5679 }
5680 }
5681 }
5682 }
5683
5684 /* Issue an error message if DECL is an uninitialized const variable.
5685 CONSTEXPR_CONTEXT_P is true when the function is called in a constexpr
5686 context from potential_constant_expression. Returns true if all is well,
5687 false otherwise. */
5688
5689 bool
check_for_uninitialized_const_var(tree decl,bool constexpr_context_p,tsubst_flags_t complain)5690 check_for_uninitialized_const_var (tree decl, bool constexpr_context_p,
5691 tsubst_flags_t complain)
5692 {
5693 tree type = strip_array_types (TREE_TYPE (decl));
5694
5695 /* ``Unless explicitly declared extern, a const object does not have
5696 external linkage and must be initialized. ($8.4; $12.1)'' ARM
5697 7.1.6 */
5698 if (VAR_P (decl)
5699 && !TYPE_REF_P (type)
5700 && (constexpr_context_p
5701 || CP_TYPE_CONST_P (type) || var_in_constexpr_fn (decl))
5702 && !DECL_NONTRIVIALLY_INITIALIZED_P (decl))
5703 {
5704 tree field = default_init_uninitialized_part (type);
5705 if (!field)
5706 return true;
5707
5708 if (!constexpr_context_p)
5709 {
5710 if (CP_TYPE_CONST_P (type))
5711 {
5712 if (complain & tf_error)
5713 permerror (DECL_SOURCE_LOCATION (decl),
5714 "uninitialized const %qD", decl);
5715 }
5716 else
5717 {
5718 if (!is_instantiation_of_constexpr (current_function_decl)
5719 && (complain & tf_error))
5720 error_at (DECL_SOURCE_LOCATION (decl),
5721 "uninitialized variable %qD in %<constexpr%> "
5722 "function", decl);
5723 cp_function_chain->invalid_constexpr = true;
5724 }
5725 }
5726 else if (complain & tf_error)
5727 error_at (DECL_SOURCE_LOCATION (decl),
5728 "uninitialized variable %qD in %<constexpr%> context",
5729 decl);
5730
5731 if (CLASS_TYPE_P (type) && (complain & tf_error))
5732 {
5733 tree defaulted_ctor;
5734
5735 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
5736 "%q#T has no user-provided default constructor", type);
5737 defaulted_ctor = in_class_defaulted_default_constructor (type);
5738 if (defaulted_ctor)
5739 inform (DECL_SOURCE_LOCATION (defaulted_ctor),
5740 "constructor is not user-provided because it is "
5741 "explicitly defaulted in the class body");
5742 inform (DECL_SOURCE_LOCATION (field),
5743 "and the implicitly-defined constructor does not "
5744 "initialize %q#D", field);
5745 }
5746
5747 return false;
5748 }
5749
5750 return true;
5751 }
5752
5753 /* Structure holding the current initializer being processed by reshape_init.
5754 CUR is a pointer to the current element being processed, END is a pointer
5755 after the last element present in the initializer. */
5756 struct reshape_iter
5757 {
5758 constructor_elt *cur;
5759 constructor_elt *end;
5760 };
5761
5762 static tree reshape_init_r (tree, reshape_iter *, bool, tsubst_flags_t);
5763
5764 /* FIELD is a FIELD_DECL or NULL. In the former case, the value
5765 returned is the next FIELD_DECL (possibly FIELD itself) that can be
5766 initialized. If there are no more such fields, the return value
5767 will be NULL. */
5768
5769 tree
next_initializable_field(tree field)5770 next_initializable_field (tree field)
5771 {
5772 while (field
5773 && (TREE_CODE (field) != FIELD_DECL
5774 || DECL_UNNAMED_BIT_FIELD (field)
5775 || (DECL_ARTIFICIAL (field)
5776 && !(cxx_dialect >= cxx17 && DECL_FIELD_IS_BASE (field)))))
5777 field = DECL_CHAIN (field);
5778
5779 return field;
5780 }
5781
5782 /* Return true for [dcl.init.list] direct-list-initialization from
5783 single element of enumeration with a fixed underlying type. */
5784
5785 bool
is_direct_enum_init(tree type,tree init)5786 is_direct_enum_init (tree type, tree init)
5787 {
5788 if (cxx_dialect >= cxx17
5789 && TREE_CODE (type) == ENUMERAL_TYPE
5790 && ENUM_FIXED_UNDERLYING_TYPE_P (type)
5791 && TREE_CODE (init) == CONSTRUCTOR
5792 && CONSTRUCTOR_IS_DIRECT_INIT (init)
5793 && CONSTRUCTOR_NELTS (init) == 1)
5794 return true;
5795 return false;
5796 }
5797
5798 /* Subroutine of reshape_init_array and reshape_init_vector, which does
5799 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
5800 INTEGER_CST representing the size of the array minus one (the maximum index),
5801 or NULL_TREE if the array was declared without specifying the size. D is
5802 the iterator within the constructor. */
5803
5804 static tree
reshape_init_array_1(tree elt_type,tree max_index,reshape_iter * d,tsubst_flags_t complain)5805 reshape_init_array_1 (tree elt_type, tree max_index, reshape_iter *d,
5806 tsubst_flags_t complain)
5807 {
5808 tree new_init;
5809 bool sized_array_p = (max_index && TREE_CONSTANT (max_index));
5810 unsigned HOST_WIDE_INT max_index_cst = 0;
5811 unsigned HOST_WIDE_INT index;
5812
5813 /* The initializer for an array is always a CONSTRUCTOR. */
5814 new_init = build_constructor (init_list_type_node, NULL);
5815
5816 if (sized_array_p)
5817 {
5818 /* Minus 1 is used for zero sized arrays. */
5819 if (integer_all_onesp (max_index))
5820 return new_init;
5821
5822 if (tree_fits_uhwi_p (max_index))
5823 max_index_cst = tree_to_uhwi (max_index);
5824 /* sizetype is sign extended, not zero extended. */
5825 else
5826 max_index_cst = tree_to_uhwi (fold_convert (size_type_node, max_index));
5827 }
5828
5829 /* Loop until there are no more initializers. */
5830 for (index = 0;
5831 d->cur != d->end && (!sized_array_p || index <= max_index_cst);
5832 ++index)
5833 {
5834 tree elt_init;
5835 constructor_elt *old_cur = d->cur;
5836
5837 check_array_designated_initializer (d->cur, index);
5838 elt_init = reshape_init_r (elt_type, d, /*first_initializer_p=*/false,
5839 complain);
5840 if (elt_init == error_mark_node)
5841 return error_mark_node;
5842 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init),
5843 size_int (index), elt_init);
5844 if (!TREE_CONSTANT (elt_init))
5845 TREE_CONSTANT (new_init) = false;
5846
5847 /* This can happen with an invalid initializer (c++/54501). */
5848 if (d->cur == old_cur && !sized_array_p)
5849 break;
5850 }
5851
5852 return new_init;
5853 }
5854
5855 /* Subroutine of reshape_init_r, processes the initializers for arrays.
5856 Parameters are the same of reshape_init_r. */
5857
5858 static tree
reshape_init_array(tree type,reshape_iter * d,tsubst_flags_t complain)5859 reshape_init_array (tree type, reshape_iter *d, tsubst_flags_t complain)
5860 {
5861 tree max_index = NULL_TREE;
5862
5863 gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
5864
5865 if (TYPE_DOMAIN (type))
5866 max_index = array_type_nelts (type);
5867
5868 return reshape_init_array_1 (TREE_TYPE (type), max_index, d, complain);
5869 }
5870
5871 /* Subroutine of reshape_init_r, processes the initializers for vectors.
5872 Parameters are the same of reshape_init_r. */
5873
5874 static tree
reshape_init_vector(tree type,reshape_iter * d,tsubst_flags_t complain)5875 reshape_init_vector (tree type, reshape_iter *d, tsubst_flags_t complain)
5876 {
5877 tree max_index = NULL_TREE;
5878
5879 gcc_assert (VECTOR_TYPE_P (type));
5880
5881 if (COMPOUND_LITERAL_P (d->cur->value))
5882 {
5883 tree value = d->cur->value;
5884 if (!same_type_p (TREE_TYPE (value), type))
5885 {
5886 if (complain & tf_error)
5887 error ("invalid type %qT as initializer for a vector of type %qT",
5888 TREE_TYPE (d->cur->value), type);
5889 value = error_mark_node;
5890 }
5891 ++d->cur;
5892 return value;
5893 }
5894
5895 /* For a vector, we initialize it as an array of the appropriate size. */
5896 if (VECTOR_TYPE_P (type))
5897 max_index = size_int (TYPE_VECTOR_SUBPARTS (type) - 1);
5898
5899 return reshape_init_array_1 (TREE_TYPE (type), max_index, d, complain);
5900 }
5901
5902 /* Subroutine of reshape_init_r, processes the initializers for classes
5903 or union. Parameters are the same of reshape_init_r. */
5904
5905 static tree
reshape_init_class(tree type,reshape_iter * d,bool first_initializer_p,tsubst_flags_t complain)5906 reshape_init_class (tree type, reshape_iter *d, bool first_initializer_p,
5907 tsubst_flags_t complain)
5908 {
5909 tree field;
5910 tree new_init;
5911
5912 gcc_assert (CLASS_TYPE_P (type));
5913
5914 /* The initializer for a class is always a CONSTRUCTOR. */
5915 new_init = build_constructor (init_list_type_node, NULL);
5916 field = next_initializable_field (TYPE_FIELDS (type));
5917
5918 if (!field)
5919 {
5920 /* [dcl.init.aggr]
5921
5922 An initializer for an aggregate member that is an
5923 empty class shall have the form of an empty
5924 initializer-list {}. */
5925 if (!first_initializer_p)
5926 {
5927 if (complain & tf_error)
5928 error ("initializer for %qT must be brace-enclosed", type);
5929 return error_mark_node;
5930 }
5931 return new_init;
5932 }
5933
5934 /* Loop through the initializable fields, gathering initializers. */
5935 while (d->cur != d->end)
5936 {
5937 tree field_init;
5938 constructor_elt *old_cur = d->cur;
5939
5940 /* Handle designated initializers, as an extension. */
5941 if (d->cur->index)
5942 {
5943 if (d->cur->index == error_mark_node)
5944 return error_mark_node;
5945
5946 if (TREE_CODE (d->cur->index) == FIELD_DECL)
5947 {
5948 /* We already reshaped this. */
5949 if (field != d->cur->index)
5950 {
5951 tree id = DECL_NAME (d->cur->index);
5952 gcc_assert (id);
5953 gcc_checking_assert (d->cur->index
5954 == get_class_binding (type, id, false));
5955 field = d->cur->index;
5956 }
5957 }
5958 else if (TREE_CODE (d->cur->index) == IDENTIFIER_NODE)
5959 field = get_class_binding (type, d->cur->index, false);
5960 else
5961 {
5962 if (complain & tf_error)
5963 error ("%<[%E] =%> used in a GNU-style designated initializer"
5964 " for class %qT", d->cur->index, type);
5965 return error_mark_node;
5966 }
5967
5968 if (!field || TREE_CODE (field) != FIELD_DECL)
5969 {
5970 if (complain & tf_error)
5971 error ("%qT has no non-static data member named %qD", type,
5972 d->cur->index);
5973 return error_mark_node;
5974 }
5975 }
5976
5977 /* If we processed all the member of the class, we are done. */
5978 if (!field)
5979 break;
5980
5981 field_init = reshape_init_r (TREE_TYPE (field), d,
5982 /*first_initializer_p=*/false, complain);
5983 if (field_init == error_mark_node)
5984 return error_mark_node;
5985
5986 if (d->cur == old_cur && d->cur->index)
5987 {
5988 /* This can happen with an invalid initializer for a flexible
5989 array member (c++/54441). */
5990 if (complain & tf_error)
5991 error ("invalid initializer for %q#D", field);
5992 return error_mark_node;
5993 }
5994
5995 CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (new_init), field, field_init);
5996
5997 /* [dcl.init.aggr]
5998
5999 When a union is initialized with a brace-enclosed
6000 initializer, the braces shall only contain an
6001 initializer for the first member of the union. */
6002 if (TREE_CODE (type) == UNION_TYPE)
6003 break;
6004
6005 field = next_initializable_field (DECL_CHAIN (field));
6006 }
6007
6008 return new_init;
6009 }
6010
6011 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
6012 designators are not valid; either complain or return true to indicate
6013 that reshape_init_r should return error_mark_node. */
6014
6015 static bool
has_designator_problem(reshape_iter * d,tsubst_flags_t complain)6016 has_designator_problem (reshape_iter *d, tsubst_flags_t complain)
6017 {
6018 if (d->cur->index)
6019 {
6020 if (complain & tf_error)
6021 error ("C99 designator %qE outside aggregate initializer",
6022 d->cur->index);
6023 else
6024 return true;
6025 }
6026 return false;
6027 }
6028
6029 /* Subroutine of reshape_init, which processes a single initializer (part of
6030 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
6031 iterator within the CONSTRUCTOR which points to the initializer to process.
6032 FIRST_INITIALIZER_P is true if this is the first initializer of the
6033 outermost CONSTRUCTOR node. */
6034
6035 static tree
reshape_init_r(tree type,reshape_iter * d,bool first_initializer_p,tsubst_flags_t complain)6036 reshape_init_r (tree type, reshape_iter *d, bool first_initializer_p,
6037 tsubst_flags_t complain)
6038 {
6039 tree init = d->cur->value;
6040
6041 if (error_operand_p (init))
6042 return error_mark_node;
6043
6044 if (first_initializer_p && !CP_AGGREGATE_TYPE_P (type)
6045 && has_designator_problem (d, complain))
6046 return error_mark_node;
6047
6048 tree stripped_init = tree_strip_any_location_wrapper (init);
6049
6050 if (TREE_CODE (type) == COMPLEX_TYPE)
6051 {
6052 /* A complex type can be initialized from one or two initializers,
6053 but braces are not elided. */
6054 d->cur++;
6055 if (BRACE_ENCLOSED_INITIALIZER_P (stripped_init))
6056 {
6057 if (CONSTRUCTOR_NELTS (stripped_init) > 2)
6058 {
6059 if (complain & tf_error)
6060 error ("too many initializers for %qT", type);
6061 else
6062 return error_mark_node;
6063 }
6064 }
6065 else if (first_initializer_p && d->cur != d->end)
6066 {
6067 vec<constructor_elt, va_gc> *v = 0;
6068 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, init);
6069 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, d->cur->value);
6070 if (has_designator_problem (d, complain))
6071 return error_mark_node;
6072 d->cur++;
6073 init = build_constructor (init_list_type_node, v);
6074 }
6075 return init;
6076 }
6077
6078 /* A non-aggregate type is always initialized with a single
6079 initializer. */
6080 if (!CP_AGGREGATE_TYPE_P (type))
6081 {
6082 /* It is invalid to initialize a non-aggregate type with a
6083 brace-enclosed initializer before C++0x.
6084 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
6085 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
6086 a CONSTRUCTOR (with a record type). */
6087 if (TREE_CODE (stripped_init) == CONSTRUCTOR
6088 /* Don't complain about a capture-init. */
6089 && !CONSTRUCTOR_IS_DIRECT_INIT (stripped_init)
6090 && BRACE_ENCLOSED_INITIALIZER_P (stripped_init)) /* p7626.C */
6091 {
6092 if (SCALAR_TYPE_P (type))
6093 {
6094 if (cxx_dialect < cxx11)
6095 {
6096 if (complain & tf_error)
6097 error ("braces around scalar initializer for type %qT",
6098 type);
6099 init = error_mark_node;
6100 }
6101 else if (first_initializer_p
6102 || (CONSTRUCTOR_NELTS (stripped_init) > 0
6103 && (BRACE_ENCLOSED_INITIALIZER_P
6104 (CONSTRUCTOR_ELT (stripped_init,0)->value))))
6105 {
6106 if (complain & tf_error)
6107 error ("too many braces around scalar initializer "
6108 "for type %qT", type);
6109 init = error_mark_node;
6110 }
6111 }
6112 else
6113 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
6114 }
6115
6116 d->cur++;
6117 return init;
6118 }
6119
6120 /* "If T is a class type and the initializer list has a single element of
6121 type cv U, where U is T or a class derived from T, the object is
6122 initialized from that element." Even if T is an aggregate. */
6123 if (cxx_dialect >= cxx11 && (CLASS_TYPE_P (type) || VECTOR_TYPE_P (type))
6124 && first_initializer_p
6125 && d->end - d->cur == 1
6126 && reference_related_p (type, TREE_TYPE (init)))
6127 {
6128 d->cur++;
6129 return init;
6130 }
6131
6132 /* [dcl.init.aggr]
6133
6134 All implicit type conversions (clause _conv_) are considered when
6135 initializing the aggregate member with an initializer from an
6136 initializer-list. If the initializer can initialize a member,
6137 the member is initialized. Otherwise, if the member is itself a
6138 non-empty subaggregate, brace elision is assumed and the
6139 initializer is considered for the initialization of the first
6140 member of the subaggregate. */
6141 if (TREE_CODE (init) != CONSTRUCTOR
6142 /* But don't try this for the first initializer, since that would be
6143 looking through the outermost braces; A a2 = { a1 }; is not a
6144 valid aggregate initialization. */
6145 && !first_initializer_p
6146 && (same_type_ignoring_top_level_qualifiers_p (type, TREE_TYPE (init))
6147 || can_convert_arg (type, TREE_TYPE (init), init, LOOKUP_NORMAL,
6148 complain)))
6149 {
6150 d->cur++;
6151 return init;
6152 }
6153
6154 /* [dcl.init.string]
6155
6156 A char array (whether plain char, signed char, or unsigned char)
6157 can be initialized by a string-literal (optionally enclosed in
6158 braces); a wchar_t array can be initialized by a wide
6159 string-literal (optionally enclosed in braces). */
6160 if (TREE_CODE (type) == ARRAY_TYPE
6161 && char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (type))))
6162 {
6163 tree str_init = init;
6164 tree stripped_str_init = stripped_init;
6165
6166 /* Strip one level of braces if and only if they enclose a single
6167 element (as allowed by [dcl.init.string]). */
6168 if (!first_initializer_p
6169 && TREE_CODE (stripped_str_init) == CONSTRUCTOR
6170 && CONSTRUCTOR_NELTS (stripped_str_init) == 1)
6171 {
6172 str_init = (*CONSTRUCTOR_ELTS (stripped_str_init))[0].value;
6173 stripped_str_init = tree_strip_any_location_wrapper (str_init);
6174 }
6175
6176 /* If it's a string literal, then it's the initializer for the array
6177 as a whole. Otherwise, continue with normal initialization for
6178 array types (one value per array element). */
6179 if (TREE_CODE (stripped_str_init) == STRING_CST)
6180 {
6181 if (has_designator_problem (d, complain))
6182 return error_mark_node;
6183 d->cur++;
6184 return str_init;
6185 }
6186 }
6187
6188 /* The following cases are about aggregates. If we are not within a full
6189 initializer already, and there is not a CONSTRUCTOR, it means that there
6190 is a missing set of braces (that is, we are processing the case for
6191 which reshape_init exists). */
6192 if (!first_initializer_p)
6193 {
6194 if (TREE_CODE (stripped_init) == CONSTRUCTOR)
6195 {
6196 tree init_type = TREE_TYPE (init);
6197 if (init_type && TYPE_PTRMEMFUNC_P (init_type))
6198 /* There is no need to call reshape_init for pointer-to-member
6199 function initializers, as they are always constructed correctly
6200 by the front end. Here we have e.g. {.__pfn=0B, .__delta=0},
6201 which is missing outermost braces. We should warn below, and
6202 one of the routines below will wrap it in additional { }. */;
6203 /* For a nested compound literal, proceed to specialized routines,
6204 to handle initialization of arrays and similar. */
6205 else if (COMPOUND_LITERAL_P (stripped_init))
6206 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (stripped_init));
6207 /* A CONSTRUCTOR of the target's type is a previously
6208 digested initializer. */
6209 else if (same_type_ignoring_top_level_qualifiers_p (type, init_type))
6210 {
6211 ++d->cur;
6212 gcc_assert (!BRACE_ENCLOSED_INITIALIZER_P (stripped_init));
6213 return init;
6214 }
6215 else
6216 {
6217 /* Something that hasn't been reshaped yet. */
6218 ++d->cur;
6219 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (stripped_init));
6220 return reshape_init (type, init, complain);
6221 }
6222 }
6223
6224 if (complain & tf_warning)
6225 warning (OPT_Wmissing_braces,
6226 "missing braces around initializer for %qT",
6227 type);
6228 }
6229
6230 /* Dispatch to specialized routines. */
6231 if (CLASS_TYPE_P (type))
6232 return reshape_init_class (type, d, first_initializer_p, complain);
6233 else if (TREE_CODE (type) == ARRAY_TYPE)
6234 return reshape_init_array (type, d, complain);
6235 else if (VECTOR_TYPE_P (type))
6236 return reshape_init_vector (type, d, complain);
6237 else
6238 gcc_unreachable();
6239 }
6240
6241 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
6242 brace-enclosed aggregate initializer.
6243
6244 INIT is the CONSTRUCTOR containing the list of initializers describing
6245 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
6246 It may not presently match the shape of the TYPE; for example:
6247
6248 struct S { int a; int b; };
6249 struct S a[] = { 1, 2, 3, 4 };
6250
6251 Here INIT will hold a vector of four elements, rather than a
6252 vector of two elements, each itself a vector of two elements. This
6253 routine transforms INIT from the former form into the latter. The
6254 revised CONSTRUCTOR node is returned. */
6255
6256 tree
reshape_init(tree type,tree init,tsubst_flags_t complain)6257 reshape_init (tree type, tree init, tsubst_flags_t complain)
6258 {
6259 vec<constructor_elt, va_gc> *v;
6260 reshape_iter d;
6261 tree new_init;
6262
6263 gcc_assert (BRACE_ENCLOSED_INITIALIZER_P (init));
6264
6265 v = CONSTRUCTOR_ELTS (init);
6266
6267 /* An empty constructor does not need reshaping, and it is always a valid
6268 initializer. */
6269 if (vec_safe_is_empty (v))
6270 return init;
6271
6272 /* Handle [dcl.init.list] direct-list-initialization from
6273 single element of enumeration with a fixed underlying type. */
6274 if (is_direct_enum_init (type, init))
6275 {
6276 tree elt = CONSTRUCTOR_ELT (init, 0)->value;
6277 type = cv_unqualified (type);
6278 if (check_narrowing (ENUM_UNDERLYING_TYPE (type), elt, complain))
6279 {
6280 warning_sentinel w (warn_useless_cast);
6281 warning_sentinel w2 (warn_ignored_qualifiers);
6282 return cp_build_c_cast (type, elt, tf_warning_or_error);
6283 }
6284 else
6285 return error_mark_node;
6286 }
6287
6288 /* Recurse on this CONSTRUCTOR. */
6289 d.cur = &(*v)[0];
6290 d.end = d.cur + v->length ();
6291
6292 new_init = reshape_init_r (type, &d, true, complain);
6293 if (new_init == error_mark_node)
6294 return error_mark_node;
6295
6296 /* Make sure all the element of the constructor were used. Otherwise,
6297 issue an error about exceeding initializers. */
6298 if (d.cur != d.end)
6299 {
6300 if (complain & tf_error)
6301 error ("too many initializers for %qT", type);
6302 return error_mark_node;
6303 }
6304
6305 if (CONSTRUCTOR_IS_DIRECT_INIT (init)
6306 && BRACE_ENCLOSED_INITIALIZER_P (new_init))
6307 CONSTRUCTOR_IS_DIRECT_INIT (new_init) = true;
6308 if (CONSTRUCTOR_IS_DESIGNATED_INIT (init)
6309 && BRACE_ENCLOSED_INITIALIZER_P (new_init))
6310 CONSTRUCTOR_IS_DESIGNATED_INIT (new_init) = true;
6311
6312 return new_init;
6313 }
6314
6315 /* Verify array initializer. Returns true if errors have been reported. */
6316
6317 bool
check_array_initializer(tree decl,tree type,tree init)6318 check_array_initializer (tree decl, tree type, tree init)
6319 {
6320 tree element_type = TREE_TYPE (type);
6321
6322 /* Structured binding when initialized with an array type needs
6323 to have complete type. */
6324 if (decl
6325 && DECL_DECOMPOSITION_P (decl)
6326 && !DECL_DECOMP_BASE (decl)
6327 && !COMPLETE_TYPE_P (type))
6328 {
6329 error_at (DECL_SOURCE_LOCATION (decl),
6330 "structured binding has incomplete type %qT", type);
6331 TREE_TYPE (decl) = error_mark_node;
6332 return true;
6333 }
6334
6335 /* The array type itself need not be complete, because the
6336 initializer may tell us how many elements are in the array.
6337 But, the elements of the array must be complete. */
6338 if (!COMPLETE_TYPE_P (complete_type (element_type)))
6339 {
6340 if (decl)
6341 error_at (DECL_SOURCE_LOCATION (decl),
6342 "elements of array %q#D have incomplete type", decl);
6343 else
6344 error ("elements of array %q#T have incomplete type", type);
6345 return true;
6346 }
6347 /* A compound literal can't have variable size. */
6348 if (init && !decl
6349 && ((COMPLETE_TYPE_P (type) && !TREE_CONSTANT (TYPE_SIZE (type)))
6350 || !TREE_CONSTANT (TYPE_SIZE (element_type))))
6351 {
6352 error ("variable-sized compound literal");
6353 return true;
6354 }
6355 return false;
6356 }
6357
6358 /* Subroutine of check_initializer; args are passed down from that function.
6359 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
6360
6361 static tree
build_aggr_init_full_exprs(tree decl,tree init,int flags)6362 build_aggr_init_full_exprs (tree decl, tree init, int flags)
6363
6364 {
6365 gcc_assert (stmts_are_full_exprs_p ());
6366 return build_aggr_init (decl, init, flags, tf_warning_or_error);
6367 }
6368
6369 /* Verify INIT (the initializer for DECL), and record the
6370 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
6371 grok_reference_init.
6372
6373 If the return value is non-NULL, it is an expression that must be
6374 evaluated dynamically to initialize DECL. */
6375
6376 static tree
check_initializer(tree decl,tree init,int flags,vec<tree,va_gc> ** cleanups)6377 check_initializer (tree decl, tree init, int flags, vec<tree, va_gc> **cleanups)
6378 {
6379 tree type = TREE_TYPE (decl);
6380 tree init_code = NULL;
6381 tree core_type;
6382
6383 /* Things that are going to be initialized need to have complete
6384 type. */
6385 TREE_TYPE (decl) = type = complete_type (TREE_TYPE (decl));
6386
6387 if (DECL_HAS_VALUE_EXPR_P (decl))
6388 {
6389 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
6390 it doesn't have storage to be initialized. */
6391 gcc_assert (init == NULL_TREE);
6392 return NULL_TREE;
6393 }
6394
6395 if (type == error_mark_node)
6396 /* We will have already complained. */
6397 return NULL_TREE;
6398
6399 if (TREE_CODE (type) == ARRAY_TYPE)
6400 {
6401 if (check_array_initializer (decl, type, init))
6402 return NULL_TREE;
6403 }
6404 else if (!COMPLETE_TYPE_P (type))
6405 {
6406 error_at (DECL_SOURCE_LOCATION (decl),
6407 "%q#D has incomplete type", decl);
6408 TREE_TYPE (decl) = error_mark_node;
6409 return NULL_TREE;
6410 }
6411 else
6412 /* There is no way to make a variable-sized class type in GNU C++. */
6413 gcc_assert (TREE_CONSTANT (TYPE_SIZE (type)));
6414
6415 if (init && BRACE_ENCLOSED_INITIALIZER_P (init))
6416 {
6417 int init_len = CONSTRUCTOR_NELTS (init);
6418 if (SCALAR_TYPE_P (type))
6419 {
6420 if (init_len == 0)
6421 {
6422 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
6423 init = build_zero_init (type, NULL_TREE, false);
6424 }
6425 else if (init_len != 1 && TREE_CODE (type) != COMPLEX_TYPE)
6426 {
6427 error_at (cp_expr_loc_or_loc (init, DECL_SOURCE_LOCATION (decl)),
6428 "scalar object %qD requires one element in "
6429 "initializer", decl);
6430 TREE_TYPE (decl) = error_mark_node;
6431 return NULL_TREE;
6432 }
6433 }
6434 }
6435
6436 if (TREE_CODE (decl) == CONST_DECL)
6437 {
6438 gcc_assert (!TYPE_REF_P (type));
6439
6440 DECL_INITIAL (decl) = init;
6441
6442 gcc_assert (init != NULL_TREE);
6443 init = NULL_TREE;
6444 }
6445 else if (!init && DECL_REALLY_EXTERN (decl))
6446 ;
6447 else if (init || type_build_ctor_call (type)
6448 || TYPE_REF_P (type))
6449 {
6450 if (TYPE_REF_P (type))
6451 {
6452 init = grok_reference_init (decl, type, init, flags);
6453 flags |= LOOKUP_ALREADY_DIGESTED;
6454 }
6455 else if (!init)
6456 check_for_uninitialized_const_var (decl, /*constexpr_context_p=*/false,
6457 tf_warning_or_error);
6458 /* Do not reshape constructors of vectors (they don't need to be
6459 reshaped. */
6460 else if (BRACE_ENCLOSED_INITIALIZER_P (init))
6461 {
6462 if (is_std_init_list (type))
6463 {
6464 init = perform_implicit_conversion (type, init,
6465 tf_warning_or_error);
6466 flags |= LOOKUP_ALREADY_DIGESTED;
6467 }
6468 else if (TYPE_NON_AGGREGATE_CLASS (type))
6469 {
6470 /* Don't reshape if the class has constructors. */
6471 if (cxx_dialect == cxx98)
6472 error_at (cp_expr_loc_or_loc (init, DECL_SOURCE_LOCATION (decl)),
6473 "in C++98 %qD must be initialized by "
6474 "constructor, not by %<{...}%>",
6475 decl);
6476 }
6477 else if (VECTOR_TYPE_P (type) && TYPE_VECTOR_OPAQUE (type))
6478 {
6479 error ("opaque vector types cannot be initialized");
6480 init = error_mark_node;
6481 }
6482 else
6483 {
6484 init = reshape_init (type, init, tf_warning_or_error);
6485 flags |= LOOKUP_NO_NARROWING;
6486 }
6487 }
6488 else if (TREE_CODE (init) == TREE_LIST
6489 && TREE_TYPE (init) != unknown_type_node
6490 && !MAYBE_CLASS_TYPE_P (type))
6491 {
6492 gcc_assert (TREE_CODE (decl) != RESULT_DECL);
6493
6494 /* We get here with code like `int a (2);' */
6495 init = build_x_compound_expr_from_list (init, ELK_INIT,
6496 tf_warning_or_error);
6497 }
6498
6499 /* If DECL has an array type without a specific bound, deduce the
6500 array size from the initializer. */
6501 maybe_deduce_size_from_array_init (decl, init);
6502 type = TREE_TYPE (decl);
6503 if (type == error_mark_node)
6504 return NULL_TREE;
6505
6506 if (((type_build_ctor_call (type) || CLASS_TYPE_P (type))
6507 && !(flags & LOOKUP_ALREADY_DIGESTED)
6508 && !(init && BRACE_ENCLOSED_INITIALIZER_P (init)
6509 && CP_AGGREGATE_TYPE_P (type)
6510 && (CLASS_TYPE_P (type)
6511 || !TYPE_NEEDS_CONSTRUCTING (type)
6512 || type_has_extended_temps (type))))
6513 || (DECL_DECOMPOSITION_P (decl) && TREE_CODE (type) == ARRAY_TYPE))
6514 {
6515 init_code = build_aggr_init_full_exprs (decl, init, flags);
6516
6517 /* A constructor call is a non-trivial initializer even if
6518 it isn't explicitly written. */
6519 if (TREE_SIDE_EFFECTS (init_code))
6520 DECL_NONTRIVIALLY_INITIALIZED_P (decl) = true;
6521
6522 /* If this is a constexpr initializer, expand_default_init will
6523 have returned an INIT_EXPR rather than a CALL_EXPR. In that
6524 case, pull the initializer back out and pass it down into
6525 store_init_value. */
6526 while (TREE_CODE (init_code) == EXPR_STMT
6527 || TREE_CODE (init_code) == CONVERT_EXPR)
6528 init_code = TREE_OPERAND (init_code, 0);
6529 if (TREE_CODE (init_code) == INIT_EXPR)
6530 {
6531 init = TREE_OPERAND (init_code, 1);
6532 init_code = NULL_TREE;
6533 /* Don't call digest_init; it's unnecessary and will complain
6534 about aggregate initialization of non-aggregate classes. */
6535 flags |= LOOKUP_ALREADY_DIGESTED;
6536 }
6537 else if (DECL_DECLARED_CONSTEXPR_P (decl))
6538 {
6539 /* Declared constexpr, but no suitable initializer; massage
6540 init appropriately so we can pass it into store_init_value
6541 for the error. */
6542 if (CLASS_TYPE_P (type)
6543 && (!init || TREE_CODE (init) == TREE_LIST))
6544 {
6545 init = build_functional_cast (type, init, tf_none);
6546 if (TREE_CODE (init) == TARGET_EXPR)
6547 TARGET_EXPR_DIRECT_INIT_P (init) = true;
6548 }
6549 init_code = NULL_TREE;
6550 }
6551 else
6552 init = NULL_TREE;
6553 }
6554
6555 if (init && TREE_CODE (init) != TREE_VEC)
6556 {
6557 /* In aggregate initialization of a variable, each element
6558 initialization is a full-expression because there is no
6559 enclosing expression. */
6560 gcc_assert (stmts_are_full_exprs_p ());
6561
6562 init_code = store_init_value (decl, init, cleanups, flags);
6563
6564 if (DECL_INITIAL (decl)
6565 && TREE_CODE (DECL_INITIAL (decl)) == CONSTRUCTOR
6566 && !vec_safe_is_empty (CONSTRUCTOR_ELTS (DECL_INITIAL (decl))))
6567 {
6568 tree elt = CONSTRUCTOR_ELTS (DECL_INITIAL (decl))->last ().value;
6569 if (TREE_CODE (TREE_TYPE (elt)) == ARRAY_TYPE
6570 && TYPE_SIZE (TREE_TYPE (elt)) == NULL_TREE)
6571 cp_complete_array_type (&TREE_TYPE (elt), elt, false);
6572 }
6573
6574 if (pedantic && TREE_CODE (type) == ARRAY_TYPE
6575 && DECL_INITIAL (decl)
6576 && TREE_CODE (DECL_INITIAL (decl)) == STRING_CST
6577 && PAREN_STRING_LITERAL_P (DECL_INITIAL (decl)))
6578 warning_at (cp_expr_loc_or_loc (DECL_INITIAL (decl),
6579 DECL_SOURCE_LOCATION (decl)),
6580 0, "array %qD initialized by parenthesized "
6581 "string literal %qE",
6582 decl, DECL_INITIAL (decl));
6583 init = NULL;
6584 }
6585 }
6586 else
6587 {
6588 if (CLASS_TYPE_P (core_type = strip_array_types (type))
6589 && (CLASSTYPE_READONLY_FIELDS_NEED_INIT (core_type)
6590 || CLASSTYPE_REF_FIELDS_NEED_INIT (core_type)))
6591 diagnose_uninitialized_cst_or_ref_member (core_type, /*using_new=*/false,
6592 /*complain=*/true);
6593
6594 check_for_uninitialized_const_var (decl, /*constexpr_context_p=*/false,
6595 tf_warning_or_error);
6596 }
6597
6598 if (init && init != error_mark_node)
6599 init_code = build2 (INIT_EXPR, type, decl, init);
6600
6601 if (init_code)
6602 {
6603 /* We might have set these in cp_finish_decl. */
6604 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = false;
6605 TREE_CONSTANT (decl) = false;
6606 }
6607
6608 if (init_code
6609 && DECL_IN_AGGR_P (decl)
6610 && DECL_INITIALIZED_IN_CLASS_P (decl))
6611 {
6612 static int explained = 0;
6613
6614 if (cxx_dialect < cxx11)
6615 error ("initializer invalid for static member with constructor");
6616 else if (cxx_dialect < cxx17)
6617 error ("non-constant in-class initialization invalid for static "
6618 "member %qD", decl);
6619 else
6620 error ("non-constant in-class initialization invalid for non-inline "
6621 "static member %qD", decl);
6622 if (!explained)
6623 {
6624 inform (input_location,
6625 "(an out of class initialization is required)");
6626 explained = 1;
6627 }
6628 return NULL_TREE;
6629 }
6630
6631 return init_code;
6632 }
6633
6634 /* If DECL is not a local variable, give it RTL. */
6635
6636 static void
make_rtl_for_nonlocal_decl(tree decl,tree init,const char * asmspec)6637 make_rtl_for_nonlocal_decl (tree decl, tree init, const char* asmspec)
6638 {
6639 int toplev = toplevel_bindings_p ();
6640 int defer_p;
6641
6642 /* Set the DECL_ASSEMBLER_NAME for the object. */
6643 if (asmspec)
6644 {
6645 /* The `register' keyword, when used together with an
6646 asm-specification, indicates that the variable should be
6647 placed in a particular register. */
6648 if (VAR_P (decl) && DECL_REGISTER (decl))
6649 {
6650 set_user_assembler_name (decl, asmspec);
6651 DECL_HARD_REGISTER (decl) = 1;
6652 }
6653 else
6654 {
6655 if (TREE_CODE (decl) == FUNCTION_DECL
6656 && fndecl_built_in_p (decl, BUILT_IN_NORMAL))
6657 set_builtin_user_assembler_name (decl, asmspec);
6658 set_user_assembler_name (decl, asmspec);
6659 }
6660 }
6661
6662 /* Handle non-variables up front. */
6663 if (!VAR_P (decl))
6664 {
6665 rest_of_decl_compilation (decl, toplev, at_eof);
6666 return;
6667 }
6668
6669 /* If we see a class member here, it should be a static data
6670 member. */
6671 if (DECL_LANG_SPECIFIC (decl) && DECL_IN_AGGR_P (decl))
6672 {
6673 gcc_assert (TREE_STATIC (decl));
6674 /* An in-class declaration of a static data member should be
6675 external; it is only a declaration, and not a definition. */
6676 if (init == NULL_TREE)
6677 gcc_assert (DECL_EXTERNAL (decl)
6678 || !TREE_PUBLIC (decl));
6679 }
6680
6681 /* We don't create any RTL for local variables. */
6682 if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
6683 return;
6684
6685 /* We defer emission of local statics until the corresponding
6686 DECL_EXPR is expanded. But with constexpr its function might never
6687 be expanded, so go ahead and tell cgraph about the variable now. */
6688 defer_p = ((DECL_FUNCTION_SCOPE_P (decl)
6689 && !var_in_maybe_constexpr_fn (decl))
6690 || DECL_VIRTUAL_P (decl));
6691
6692 /* Defer template instantiations. */
6693 if (DECL_LANG_SPECIFIC (decl)
6694 && DECL_IMPLICIT_INSTANTIATION (decl))
6695 defer_p = 1;
6696
6697 /* If we're not deferring, go ahead and assemble the variable. */
6698 if (!defer_p)
6699 rest_of_decl_compilation (decl, toplev, at_eof);
6700 }
6701
6702 /* walk_tree helper for wrap_temporary_cleanups, below. */
6703
6704 static tree
wrap_cleanups_r(tree * stmt_p,int * walk_subtrees,void * data)6705 wrap_cleanups_r (tree *stmt_p, int *walk_subtrees, void *data)
6706 {
6707 /* Stop at types or full-expression boundaries. */
6708 if (TYPE_P (*stmt_p)
6709 || TREE_CODE (*stmt_p) == CLEANUP_POINT_EXPR)
6710 {
6711 *walk_subtrees = 0;
6712 return NULL_TREE;
6713 }
6714
6715 if (TREE_CODE (*stmt_p) == TARGET_EXPR)
6716 {
6717 tree guard = (tree)data;
6718 tree tcleanup = TARGET_EXPR_CLEANUP (*stmt_p);
6719
6720 tcleanup = build2 (TRY_CATCH_EXPR, void_type_node, tcleanup, guard);
6721 /* Tell honor_protect_cleanup_actions to handle this as a separate
6722 cleanup. */
6723 TRY_CATCH_IS_CLEANUP (tcleanup) = 1;
6724
6725 TARGET_EXPR_CLEANUP (*stmt_p) = tcleanup;
6726 }
6727
6728 return NULL_TREE;
6729 }
6730
6731 /* We're initializing a local variable which has a cleanup GUARD. If there
6732 are any temporaries used in the initializer INIT of this variable, we
6733 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
6734 variable will be cleaned up properly if one of them throws.
6735
6736 Unfortunately, there's no way to express this properly in terms of
6737 nesting, as the regions for the temporaries overlap the region for the
6738 variable itself; if there are two temporaries, the variable needs to be
6739 the first thing destroyed if either of them throws. However, we only
6740 want to run the variable's cleanup if it actually got constructed. So
6741 we need to guard the temporary cleanups with the variable's cleanup if
6742 they are run on the normal path, but not if they are run on the
6743 exceptional path. We implement this by telling
6744 honor_protect_cleanup_actions to strip the variable cleanup from the
6745 exceptional path. */
6746
6747 static void
wrap_temporary_cleanups(tree init,tree guard)6748 wrap_temporary_cleanups (tree init, tree guard)
6749 {
6750 cp_walk_tree_without_duplicates (&init, wrap_cleanups_r, (void *)guard);
6751 }
6752
6753 /* Generate code to initialize DECL (a local variable). */
6754
6755 static void
initialize_local_var(tree decl,tree init)6756 initialize_local_var (tree decl, tree init)
6757 {
6758 tree type = TREE_TYPE (decl);
6759 tree cleanup;
6760 int already_used;
6761
6762 gcc_assert (VAR_P (decl)
6763 || TREE_CODE (decl) == RESULT_DECL);
6764 gcc_assert (!TREE_STATIC (decl));
6765
6766 if (DECL_SIZE (decl) == NULL_TREE)
6767 {
6768 /* If we used it already as memory, it must stay in memory. */
6769 DECL_INITIAL (decl) = NULL_TREE;
6770 TREE_ADDRESSABLE (decl) = TREE_USED (decl);
6771 return;
6772 }
6773
6774 if (type == error_mark_node)
6775 return;
6776
6777 /* Compute and store the initial value. */
6778 already_used = TREE_USED (decl) || TREE_USED (type);
6779 if (TREE_USED (type))
6780 DECL_READ_P (decl) = 1;
6781
6782 /* Generate a cleanup, if necessary. */
6783 cleanup = cxx_maybe_build_cleanup (decl, tf_warning_or_error);
6784
6785 /* Perform the initialization. */
6786 if (init)
6787 {
6788 tree rinit = (TREE_CODE (init) == INIT_EXPR
6789 ? TREE_OPERAND (init, 1) : NULL_TREE);
6790 if (rinit && !TREE_SIDE_EFFECTS (rinit))
6791 {
6792 /* Stick simple initializers in DECL_INITIAL so that
6793 -Wno-init-self works (c++/34772). */
6794 gcc_assert (TREE_OPERAND (init, 0) == decl);
6795 DECL_INITIAL (decl) = rinit;
6796
6797 if (warn_init_self && TYPE_REF_P (type))
6798 {
6799 STRIP_NOPS (rinit);
6800 if (rinit == decl)
6801 warning_at (DECL_SOURCE_LOCATION (decl),
6802 OPT_Winit_self,
6803 "reference %qD is initialized with itself", decl);
6804 }
6805 }
6806 else
6807 {
6808 int saved_stmts_are_full_exprs_p;
6809
6810 /* If we're only initializing a single object, guard the
6811 destructors of any temporaries used in its initializer with
6812 its destructor. This isn't right for arrays because each
6813 element initialization is a full-expression. */
6814 if (cleanup && TREE_CODE (type) != ARRAY_TYPE)
6815 wrap_temporary_cleanups (init, cleanup);
6816
6817 gcc_assert (building_stmt_list_p ());
6818 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
6819 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
6820 finish_expr_stmt (init);
6821 current_stmt_tree ()->stmts_are_full_exprs_p =
6822 saved_stmts_are_full_exprs_p;
6823 }
6824 }
6825
6826 /* Set this to 0 so we can tell whether an aggregate which was
6827 initialized was ever used. Don't do this if it has a
6828 destructor, so we don't complain about the 'resource
6829 allocation is initialization' idiom. Now set
6830 attribute((unused)) on types so decls of that type will be
6831 marked used. (see TREE_USED, above.) */
6832 if (TYPE_NEEDS_CONSTRUCTING (type)
6833 && ! already_used
6834 && TYPE_HAS_TRIVIAL_DESTRUCTOR (type)
6835 && DECL_NAME (decl))
6836 TREE_USED (decl) = 0;
6837 else if (already_used)
6838 TREE_USED (decl) = 1;
6839
6840 if (cleanup)
6841 finish_decl_cleanup (decl, cleanup);
6842 }
6843
6844 /* DECL is a VAR_DECL for a compiler-generated variable with static
6845 storage duration (like a virtual table) whose initializer is a
6846 compile-time constant. Initialize the variable and provide it to the
6847 back end. */
6848
6849 void
initialize_artificial_var(tree decl,vec<constructor_elt,va_gc> * v)6850 initialize_artificial_var (tree decl, vec<constructor_elt, va_gc> *v)
6851 {
6852 tree init;
6853 gcc_assert (DECL_ARTIFICIAL (decl));
6854 init = build_constructor (TREE_TYPE (decl), v);
6855 gcc_assert (TREE_CODE (init) == CONSTRUCTOR);
6856 DECL_INITIAL (decl) = init;
6857 DECL_INITIALIZED_P (decl) = 1;
6858 /* Mark the decl as constexpr so that we can access its content
6859 at compile time. */
6860 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = true;
6861 DECL_DECLARED_CONSTEXPR_P (decl) = true;
6862 determine_visibility (decl);
6863 layout_var_decl (decl);
6864 maybe_commonize_var (decl);
6865 make_rtl_for_nonlocal_decl (decl, init, /*asmspec=*/NULL);
6866 }
6867
6868 /* INIT is the initializer for a variable, as represented by the
6869 parser. Returns true iff INIT is value-dependent. */
6870
6871 static bool
value_dependent_init_p(tree init)6872 value_dependent_init_p (tree init)
6873 {
6874 if (TREE_CODE (init) == TREE_LIST)
6875 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
6876 return any_value_dependent_elements_p (init);
6877 else if (TREE_CODE (init) == CONSTRUCTOR)
6878 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
6879 {
6880 if (dependent_type_p (TREE_TYPE (init)))
6881 return true;
6882
6883 vec<constructor_elt, va_gc> *elts;
6884 size_t nelts;
6885 size_t i;
6886
6887 elts = CONSTRUCTOR_ELTS (init);
6888 nelts = vec_safe_length (elts);
6889 for (i = 0; i < nelts; ++i)
6890 if (value_dependent_init_p ((*elts)[i].value))
6891 return true;
6892 }
6893 else
6894 /* It must be a simple expression, e.g., int i = 3; */
6895 return value_dependent_expression_p (init);
6896
6897 return false;
6898 }
6899
6900 // Returns true if a DECL is VAR_DECL with the concept specifier.
6901 static inline bool
is_concept_var(tree decl)6902 is_concept_var (tree decl)
6903 {
6904 return (VAR_P (decl)
6905 // Not all variables have DECL_LANG_SPECIFIC.
6906 && DECL_LANG_SPECIFIC (decl)
6907 && DECL_DECLARED_CONCEPT_P (decl));
6908 }
6909
6910 /* A helper function to be called via walk_tree. If any label exists
6911 under *TP, it is (going to be) forced. Set has_forced_label_in_static. */
6912
6913 static tree
notice_forced_label_r(tree * tp,int * walk_subtrees,void *)6914 notice_forced_label_r (tree *tp, int *walk_subtrees, void *)
6915 {
6916 if (TYPE_P (*tp))
6917 *walk_subtrees = 0;
6918 if (TREE_CODE (*tp) == LABEL_DECL)
6919 cfun->has_forced_label_in_static = 1;
6920 return NULL_TREE;
6921 }
6922
6923 /* Finish processing of a declaration;
6924 install its line number and initial value.
6925 If the length of an array type is not known before,
6926 it must be determined now, from the initial value, or it is an error.
6927
6928 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
6929 true, then INIT is an integral constant expression.
6930
6931 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
6932 if the (init) syntax was used. */
6933
6934 void
cp_finish_decl(tree decl,tree init,bool init_const_expr_p,tree asmspec_tree,int flags)6935 cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
6936 tree asmspec_tree, int flags)
6937 {
6938 tree type;
6939 vec<tree, va_gc> *cleanups = NULL;
6940 const char *asmspec = NULL;
6941 int was_readonly = 0;
6942 bool var_definition_p = false;
6943 tree auto_node;
6944
6945 if (decl == error_mark_node)
6946 return;
6947 else if (! decl)
6948 {
6949 if (init)
6950 error ("assignment (not initialization) in declaration");
6951 return;
6952 }
6953
6954 gcc_assert (TREE_CODE (decl) != RESULT_DECL);
6955 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
6956 gcc_assert (TREE_CODE (decl) != PARM_DECL);
6957
6958 type = TREE_TYPE (decl);
6959 if (type == error_mark_node)
6960 return;
6961
6962 /* Warn about register storage specifiers except when in GNU global
6963 or local register variable extension. */
6964 if (VAR_P (decl) && DECL_REGISTER (decl) && asmspec_tree == NULL_TREE)
6965 {
6966 if (cxx_dialect >= cxx17)
6967 pedwarn (DECL_SOURCE_LOCATION (decl), OPT_Wregister,
6968 "ISO C++17 does not allow %<register%> storage "
6969 "class specifier");
6970 else
6971 warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wregister,
6972 "%<register%> storage class specifier used");
6973 }
6974
6975 /* If a name was specified, get the string. */
6976 if (at_namespace_scope_p ())
6977 asmspec_tree = maybe_apply_renaming_pragma (decl, asmspec_tree);
6978 if (asmspec_tree && asmspec_tree != error_mark_node)
6979 asmspec = TREE_STRING_POINTER (asmspec_tree);
6980
6981 if (current_class_type
6982 && CP_DECL_CONTEXT (decl) == current_class_type
6983 && TYPE_BEING_DEFINED (current_class_type)
6984 && !CLASSTYPE_TEMPLATE_INSTANTIATION (current_class_type)
6985 && (DECL_INITIAL (decl) || init))
6986 DECL_INITIALIZED_IN_CLASS_P (decl) = 1;
6987
6988 /* Do auto deduction unless decl is a function or an uninstantiated
6989 template specialization. */
6990 if (TREE_CODE (decl) != FUNCTION_DECL
6991 && !(init == NULL_TREE
6992 && DECL_LANG_SPECIFIC (decl)
6993 && DECL_TEMPLATE_INSTANTIATION (decl)
6994 && !DECL_TEMPLATE_INSTANTIATED (decl))
6995 && (auto_node = type_uses_auto (type)))
6996 {
6997 tree d_init;
6998 if (init == NULL_TREE)
6999 gcc_assert (CLASS_PLACEHOLDER_TEMPLATE (auto_node));
7000 d_init = init;
7001 if (d_init)
7002 {
7003 if (TREE_CODE (d_init) == TREE_LIST
7004 && !CLASS_PLACEHOLDER_TEMPLATE (auto_node))
7005 d_init = build_x_compound_expr_from_list (d_init, ELK_INIT,
7006 tf_warning_or_error);
7007 d_init = resolve_nondeduced_context (d_init, tf_warning_or_error);
7008 }
7009 enum auto_deduction_context adc = adc_variable_type;
7010 if (VAR_P (decl) && DECL_DECOMPOSITION_P (decl))
7011 adc = adc_decomp_type;
7012 type = TREE_TYPE (decl) = do_auto_deduction (type, d_init, auto_node,
7013 tf_warning_or_error, adc,
7014 NULL_TREE, flags);
7015 if (type == error_mark_node)
7016 return;
7017 if (TREE_CODE (type) == FUNCTION_TYPE)
7018 {
7019 error ("initializer for %<decltype(auto) %D%> has function type "
7020 "(did you forget the %<()%> ?)", decl);
7021 TREE_TYPE (decl) = error_mark_node;
7022 return;
7023 }
7024 cp_apply_type_quals_to_decl (cp_type_quals (type), decl);
7025 }
7026
7027 if (ensure_literal_type_for_constexpr_object (decl) == error_mark_node)
7028 {
7029 DECL_DECLARED_CONSTEXPR_P (decl) = 0;
7030 if (VAR_P (decl) && DECL_CLASS_SCOPE_P (decl))
7031 {
7032 init = NULL_TREE;
7033 DECL_EXTERNAL (decl) = 1;
7034 }
7035 }
7036
7037 if (VAR_P (decl)
7038 && DECL_CLASS_SCOPE_P (decl)
7039 && DECL_INITIALIZED_IN_CLASS_P (decl))
7040 check_static_variable_definition (decl, type);
7041
7042 if (init && TREE_CODE (decl) == FUNCTION_DECL)
7043 {
7044 tree clone;
7045 if (init == ridpointers[(int)RID_DELETE])
7046 {
7047 /* FIXME check this is 1st decl. */
7048 DECL_DELETED_FN (decl) = 1;
7049 DECL_DECLARED_INLINE_P (decl) = 1;
7050 DECL_INITIAL (decl) = error_mark_node;
7051 FOR_EACH_CLONE (clone, decl)
7052 {
7053 DECL_DELETED_FN (clone) = 1;
7054 DECL_DECLARED_INLINE_P (clone) = 1;
7055 DECL_INITIAL (clone) = error_mark_node;
7056 }
7057 init = NULL_TREE;
7058 }
7059 else if (init == ridpointers[(int)RID_DEFAULT])
7060 {
7061 if (defaultable_fn_check (decl))
7062 DECL_DEFAULTED_FN (decl) = 1;
7063 else
7064 DECL_INITIAL (decl) = NULL_TREE;
7065 }
7066 }
7067
7068 if (init && VAR_P (decl))
7069 {
7070 DECL_NONTRIVIALLY_INITIALIZED_P (decl) = 1;
7071 /* If DECL is a reference, then we want to know whether init is a
7072 reference constant; init_const_expr_p as passed tells us whether
7073 it's an rvalue constant. */
7074 if (TYPE_REF_P (type))
7075 init_const_expr_p = potential_constant_expression (init);
7076 if (init_const_expr_p)
7077 {
7078 /* Set these flags now for templates. We'll update the flags in
7079 store_init_value for instantiations. */
7080 DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
7081 if (decl_maybe_constant_var_p (decl)
7082 /* FIXME setting TREE_CONSTANT on refs breaks the back end. */
7083 && !TYPE_REF_P (type))
7084 TREE_CONSTANT (decl) = 1;
7085 }
7086 }
7087
7088 if (processing_template_decl)
7089 {
7090 bool type_dependent_p;
7091
7092 /* Add this declaration to the statement-tree. */
7093 if (at_function_scope_p ())
7094 add_decl_expr (decl);
7095
7096 type_dependent_p = dependent_type_p (type);
7097
7098 if (check_for_bare_parameter_packs (init))
7099 {
7100 init = NULL_TREE;
7101 DECL_INITIAL (decl) = NULL_TREE;
7102 }
7103
7104 /* Generally, initializers in templates are expanded when the
7105 template is instantiated. But, if DECL is a variable constant
7106 then it can be used in future constant expressions, so its value
7107 must be available. */
7108
7109 bool dep_init = false;
7110
7111 if (!VAR_P (decl) || type_dependent_p)
7112 /* We can't do anything if the decl has dependent type. */;
7113 else if (!init && is_concept_var (decl))
7114 {
7115 error ("variable concept has no initializer");
7116 init = boolean_true_node;
7117 }
7118 else if (init
7119 && init_const_expr_p
7120 && !TYPE_REF_P (type)
7121 && decl_maybe_constant_var_p (decl)
7122 && !(dep_init = value_dependent_init_p (init)))
7123 {
7124 /* This variable seems to be a non-dependent constant, so process
7125 its initializer. If check_initializer returns non-null the
7126 initialization wasn't constant after all. */
7127 tree init_code;
7128 cleanups = make_tree_vector ();
7129 init_code = check_initializer (decl, init, flags, &cleanups);
7130 if (init_code == NULL_TREE)
7131 init = NULL_TREE;
7132 release_tree_vector (cleanups);
7133 }
7134 else
7135 {
7136 gcc_assert (!DECL_PRETTY_FUNCTION_P (decl));
7137 /* Deduce array size even if the initializer is dependent. */
7138 maybe_deduce_size_from_array_init (decl, init);
7139 /* And complain about multiple initializers. */
7140 if (init && TREE_CODE (init) == TREE_LIST && TREE_CHAIN (init)
7141 && !MAYBE_CLASS_TYPE_P (type))
7142 init = build_x_compound_expr_from_list (init, ELK_INIT,
7143 tf_warning_or_error);
7144 }
7145
7146 if (init)
7147 DECL_INITIAL (decl) = init;
7148
7149 if (dep_init)
7150 {
7151 retrofit_lang_decl (decl);
7152 SET_DECL_DEPENDENT_INIT_P (decl, true);
7153 }
7154
7155 if (VAR_P (decl) && DECL_REGISTER (decl) && asmspec)
7156 {
7157 set_user_assembler_name (decl, asmspec);
7158 DECL_HARD_REGISTER (decl) = 1;
7159 }
7160 return;
7161 }
7162
7163 /* Just store non-static data member initializers for later. */
7164 if (init && TREE_CODE (decl) == FIELD_DECL)
7165 DECL_INITIAL (decl) = init;
7166
7167 /* Take care of TYPE_DECLs up front. */
7168 if (TREE_CODE (decl) == TYPE_DECL)
7169 {
7170 if (type != error_mark_node
7171 && MAYBE_CLASS_TYPE_P (type) && DECL_NAME (decl))
7172 {
7173 if (TREE_TYPE (DECL_NAME (decl)) && TREE_TYPE (decl) != type)
7174 warning (0, "shadowing previous type declaration of %q#D", decl);
7175 set_identifier_type_value (DECL_NAME (decl), decl);
7176 }
7177
7178 /* If we have installed this as the canonical typedef for this
7179 type, and that type has not been defined yet, delay emitting
7180 the debug information for it, as we will emit it later. */
7181 if (TYPE_MAIN_DECL (TREE_TYPE (decl)) == decl
7182 && !COMPLETE_TYPE_P (TREE_TYPE (decl)))
7183 TYPE_DECL_SUPPRESS_DEBUG (decl) = 1;
7184
7185 rest_of_decl_compilation (decl, DECL_FILE_SCOPE_P (decl),
7186 at_eof);
7187 return;
7188 }
7189
7190 /* A reference will be modified here, as it is initialized. */
7191 if (! DECL_EXTERNAL (decl)
7192 && TREE_READONLY (decl)
7193 && TYPE_REF_P (type))
7194 {
7195 was_readonly = 1;
7196 TREE_READONLY (decl) = 0;
7197 }
7198
7199 if (VAR_P (decl))
7200 {
7201 /* If this is a local variable that will need a mangled name,
7202 register it now. We must do this before processing the
7203 initializer for the variable, since the initialization might
7204 require a guard variable, and since the mangled name of the
7205 guard variable will depend on the mangled name of this
7206 variable. */
7207 if (DECL_FUNCTION_SCOPE_P (decl)
7208 && TREE_STATIC (decl)
7209 && !DECL_ARTIFICIAL (decl))
7210 {
7211 /* The variable holding an anonymous union will have had its
7212 discriminator set in finish_anon_union, after which it's
7213 NAME will have been cleared. */
7214 if (DECL_NAME (decl))
7215 determine_local_discriminator (decl);
7216 /* Normally has_forced_label_in_static is set during GIMPLE
7217 lowering, but [cd]tors are never actually compiled directly.
7218 We need to set this early so we can deal with the label
7219 address extension. */
7220 if ((DECL_CONSTRUCTOR_P (current_function_decl)
7221 || DECL_DESTRUCTOR_P (current_function_decl))
7222 && init)
7223 {
7224 walk_tree (&init, notice_forced_label_r, NULL, NULL);
7225 add_local_decl (cfun, decl);
7226 }
7227 /* And make sure it's in the symbol table for
7228 c_parse_final_cleanups to find. */
7229 varpool_node::get_create (decl);
7230 }
7231
7232 /* Convert the initializer to the type of DECL, if we have not
7233 already initialized DECL. */
7234 if (!DECL_INITIALIZED_P (decl)
7235 /* If !DECL_EXTERNAL then DECL is being defined. In the
7236 case of a static data member initialized inside the
7237 class-specifier, there can be an initializer even if DECL
7238 is *not* defined. */
7239 && (!DECL_EXTERNAL (decl) || init))
7240 {
7241 cleanups = make_tree_vector ();
7242 init = check_initializer (decl, init, flags, &cleanups);
7243
7244 /* Handle:
7245
7246 [dcl.init]
7247
7248 The memory occupied by any object of static storage
7249 duration is zero-initialized at program startup before
7250 any other initialization takes place.
7251
7252 We cannot create an appropriate initializer until after
7253 the type of DECL is finalized. If DECL_INITIAL is set,
7254 then the DECL is statically initialized, and any
7255 necessary zero-initialization has already been performed. */
7256 if (TREE_STATIC (decl) && !DECL_INITIAL (decl))
7257 DECL_INITIAL (decl) = build_zero_init (TREE_TYPE (decl),
7258 /*nelts=*/NULL_TREE,
7259 /*static_storage_p=*/true);
7260 /* Remember that the initialization for this variable has
7261 taken place. */
7262 DECL_INITIALIZED_P (decl) = 1;
7263 /* This declaration is the definition of this variable,
7264 unless we are initializing a static data member within
7265 the class specifier. */
7266 if (!DECL_EXTERNAL (decl))
7267 var_definition_p = true;
7268 }
7269 /* If the variable has an array type, lay out the type, even if
7270 there is no initializer. It is valid to index through the
7271 array, and we must get TYPE_ALIGN set correctly on the array
7272 type. */
7273 else if (TREE_CODE (type) == ARRAY_TYPE)
7274 layout_type (type);
7275
7276 if (TREE_STATIC (decl)
7277 && !at_function_scope_p ()
7278 && current_function_decl == NULL)
7279 /* So decl is a global variable or a static member of a
7280 non local class. Record the types it uses
7281 so that we can decide later to emit debug info for them. */
7282 record_types_used_by_current_var_decl (decl);
7283 }
7284
7285 /* Add this declaration to the statement-tree. This needs to happen
7286 after the call to check_initializer so that the DECL_EXPR for a
7287 reference temp is added before the DECL_EXPR for the reference itself. */
7288 if (DECL_FUNCTION_SCOPE_P (decl))
7289 {
7290 /* If we're building a variable sized type, and we might be
7291 reachable other than via the top of the current binding
7292 level, then create a new BIND_EXPR so that we deallocate
7293 the object at the right time. */
7294 if (VAR_P (decl)
7295 && DECL_SIZE (decl)
7296 && !TREE_CONSTANT (DECL_SIZE (decl))
7297 && STATEMENT_LIST_HAS_LABEL (cur_stmt_list))
7298 {
7299 tree bind;
7300 bind = build3 (BIND_EXPR, void_type_node, NULL, NULL, NULL);
7301 TREE_SIDE_EFFECTS (bind) = 1;
7302 add_stmt (bind);
7303 BIND_EXPR_BODY (bind) = push_stmt_list ();
7304 }
7305 add_decl_expr (decl);
7306 }
7307
7308 /* Let the middle end know about variables and functions -- but not
7309 static data members in uninstantiated class templates. */
7310 if (VAR_OR_FUNCTION_DECL_P (decl))
7311 {
7312 if (VAR_P (decl))
7313 {
7314 layout_var_decl (decl);
7315 maybe_commonize_var (decl);
7316 }
7317
7318 /* This needs to happen after the linkage is set. */
7319 determine_visibility (decl);
7320
7321 if (var_definition_p
7322 /* With -fmerge-all-constants, gimplify_init_constructor
7323 might add TREE_STATIC to the variable. */
7324 && (TREE_STATIC (decl) || flag_merge_constants >= 2))
7325 {
7326 /* If a TREE_READONLY variable needs initialization
7327 at runtime, it is no longer readonly and we need to
7328 avoid MEM_READONLY_P being set on RTL created for it. */
7329 if (init)
7330 {
7331 if (TREE_READONLY (decl))
7332 TREE_READONLY (decl) = 0;
7333 was_readonly = 0;
7334 }
7335 else if (was_readonly)
7336 TREE_READONLY (decl) = 1;
7337
7338 /* Likewise if it needs destruction. */
7339 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type))
7340 TREE_READONLY (decl) = 0;
7341 }
7342
7343 make_rtl_for_nonlocal_decl (decl, init, asmspec);
7344
7345 /* Check for abstractness of the type. Notice that there is no
7346 need to strip array types here since the check for those types
7347 is already done within create_array_type_for_decl. */
7348 abstract_virtuals_error (decl, type);
7349
7350 if (TREE_TYPE (decl) == error_mark_node)
7351 /* No initialization required. */
7352 ;
7353 else if (TREE_CODE (decl) == FUNCTION_DECL)
7354 {
7355 if (init)
7356 {
7357 if (init == ridpointers[(int)RID_DEFAULT])
7358 {
7359 /* An out-of-class default definition is defined at
7360 the point where it is explicitly defaulted. */
7361 if (DECL_DELETED_FN (decl))
7362 maybe_explain_implicit_delete (decl);
7363 else if (DECL_INITIAL (decl) == error_mark_node)
7364 synthesize_method (decl);
7365 }
7366 else
7367 error_at (cp_expr_loc_or_loc (init,
7368 DECL_SOURCE_LOCATION (decl)),
7369 "function %q#D is initialized like a variable",
7370 decl);
7371 }
7372 /* else no initialization required. */
7373 }
7374 else if (DECL_EXTERNAL (decl)
7375 && ! (DECL_LANG_SPECIFIC (decl)
7376 && DECL_NOT_REALLY_EXTERN (decl)))
7377 {
7378 /* check_initializer will have done any constant initialization. */
7379 }
7380 /* A variable definition. */
7381 else if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
7382 /* Initialize the local variable. */
7383 initialize_local_var (decl, init);
7384
7385 /* If a variable is defined, and then a subsequent
7386 definition with external linkage is encountered, we will
7387 get here twice for the same variable. We want to avoid
7388 calling expand_static_init more than once. For variables
7389 that are not static data members, we can call
7390 expand_static_init only when we actually process the
7391 initializer. It is not legal to redeclare a static data
7392 member, so this issue does not arise in that case. */
7393 else if (var_definition_p && TREE_STATIC (decl))
7394 expand_static_init (decl, init);
7395 }
7396
7397 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
7398 reference, insert it in the statement-tree now. */
7399 if (cleanups)
7400 {
7401 unsigned i; tree t;
7402 FOR_EACH_VEC_ELT (*cleanups, i, t)
7403 push_cleanup (decl, t, false);
7404 release_tree_vector (cleanups);
7405 }
7406
7407 if (was_readonly)
7408 TREE_READONLY (decl) = 1;
7409
7410 if (flag_openmp
7411 && VAR_P (decl)
7412 && lookup_attribute ("omp declare target implicit",
7413 DECL_ATTRIBUTES (decl)))
7414 {
7415 DECL_ATTRIBUTES (decl)
7416 = remove_attribute ("omp declare target implicit",
7417 DECL_ATTRIBUTES (decl));
7418 complete_type (TREE_TYPE (decl));
7419 if (!cp_omp_mappable_type (TREE_TYPE (decl)))
7420 error ("%q+D in declare target directive does not have mappable type",
7421 decl);
7422 else if (!lookup_attribute ("omp declare target",
7423 DECL_ATTRIBUTES (decl))
7424 && !lookup_attribute ("omp declare target link",
7425 DECL_ATTRIBUTES (decl)))
7426 DECL_ATTRIBUTES (decl)
7427 = tree_cons (get_identifier ("omp declare target"),
7428 NULL_TREE, DECL_ATTRIBUTES (decl));
7429 }
7430
7431 invoke_plugin_callbacks (PLUGIN_FINISH_DECL, decl);
7432 }
7433
7434 /* For class TYPE return itself or some its bases that contain
7435 any direct non-static data members. Return error_mark_node if an
7436 error has been diagnosed. */
7437
7438 static tree
find_decomp_class_base(location_t loc,tree type,tree ret)7439 find_decomp_class_base (location_t loc, tree type, tree ret)
7440 {
7441 bool member_seen = false;
7442 for (tree field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
7443 if (TREE_CODE (field) != FIELD_DECL
7444 || DECL_ARTIFICIAL (field)
7445 || DECL_UNNAMED_BIT_FIELD (field))
7446 continue;
7447 else if (ret)
7448 return type;
7449 else if (ANON_AGGR_TYPE_P (TREE_TYPE (field)))
7450 {
7451 if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE)
7452 error_at (loc, "cannot decompose class type %qT because it has an "
7453 "anonymous struct member", type);
7454 else
7455 error_at (loc, "cannot decompose class type %qT because it has an "
7456 "anonymous union member", type);
7457 inform (DECL_SOURCE_LOCATION (field), "declared here");
7458 return error_mark_node;
7459 }
7460 else if (!accessible_p (type, field, true))
7461 {
7462 error_at (loc, "cannot decompose inaccessible member %qD of %qT",
7463 field, type);
7464 inform (DECL_SOURCE_LOCATION (field),
7465 TREE_PRIVATE (field)
7466 ? G_("declared private here")
7467 : G_("declared protected here"));
7468 return error_mark_node;
7469 }
7470 else
7471 member_seen = true;
7472
7473 tree base_binfo, binfo;
7474 tree orig_ret = ret;
7475 int i;
7476 if (member_seen)
7477 ret = type;
7478 for (binfo = TYPE_BINFO (type), i = 0;
7479 BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
7480 {
7481 tree t = find_decomp_class_base (loc, TREE_TYPE (base_binfo), ret);
7482 if (t == error_mark_node)
7483 return error_mark_node;
7484 if (t != NULL_TREE && t != ret)
7485 {
7486 if (ret == type)
7487 {
7488 error_at (loc, "cannot decompose class type %qT: both it and "
7489 "its base class %qT have non-static data members",
7490 type, t);
7491 return error_mark_node;
7492 }
7493 else if (orig_ret != NULL_TREE)
7494 return t;
7495 else if (ret != NULL_TREE)
7496 {
7497 error_at (loc, "cannot decompose class type %qT: its base "
7498 "classes %qT and %qT have non-static data "
7499 "members", type, ret, t);
7500 return error_mark_node;
7501 }
7502 else
7503 ret = t;
7504 }
7505 }
7506 return ret;
7507 }
7508
7509 /* Return std::tuple_size<TYPE>::value. */
7510
7511 static tree
get_tuple_size(tree type)7512 get_tuple_size (tree type)
7513 {
7514 tree args = make_tree_vec (1);
7515 TREE_VEC_ELT (args, 0) = type;
7516 tree inst = lookup_template_class (tuple_size_identifier, args,
7517 /*in_decl*/NULL_TREE,
7518 /*context*/std_node,
7519 /*entering_scope*/false, tf_none);
7520 inst = complete_type (inst);
7521 if (inst == error_mark_node || !COMPLETE_TYPE_P (inst))
7522 return NULL_TREE;
7523 tree val = lookup_qualified_name (inst, value_identifier,
7524 /*type*/false, /*complain*/false);
7525 if (TREE_CODE (val) == VAR_DECL || TREE_CODE (val) == CONST_DECL)
7526 val = maybe_constant_value (val);
7527 if (TREE_CODE (val) == INTEGER_CST)
7528 return val;
7529 else
7530 return error_mark_node;
7531 }
7532
7533 /* Return std::tuple_element<I,TYPE>::type. */
7534
7535 static tree
get_tuple_element_type(tree type,unsigned i)7536 get_tuple_element_type (tree type, unsigned i)
7537 {
7538 tree args = make_tree_vec (2);
7539 TREE_VEC_ELT (args, 0) = build_int_cst (integer_type_node, i);
7540 TREE_VEC_ELT (args, 1) = type;
7541 tree inst = lookup_template_class (tuple_element_identifier, args,
7542 /*in_decl*/NULL_TREE,
7543 /*context*/std_node,
7544 /*entering_scope*/false,
7545 tf_warning_or_error);
7546 return make_typename_type (inst, type_identifier,
7547 none_type, tf_warning_or_error);
7548 }
7549
7550 /* Return e.get<i>() or get<i>(e). */
7551
7552 static tree
get_tuple_decomp_init(tree decl,unsigned i)7553 get_tuple_decomp_init (tree decl, unsigned i)
7554 {
7555 tree targs = make_tree_vec (1);
7556 TREE_VEC_ELT (targs, 0) = build_int_cst (integer_type_node, i);
7557
7558 tree etype = TREE_TYPE (decl);
7559 tree e = convert_from_reference (decl);
7560
7561 /* [The id-expression] e is an lvalue if the type of the entity e is an
7562 lvalue reference and an xvalue otherwise. */
7563 if (!TYPE_REF_P (etype)
7564 || TYPE_REF_IS_RVALUE (etype))
7565 e = move (e);
7566
7567 tree fns = lookup_qualified_name (TREE_TYPE (e), get__identifier,
7568 /*type*/false, /*complain*/false);
7569 bool use_member_get = false;
7570
7571 /* To use a member get, member lookup must find at least one
7572 declaration that is a function template
7573 whose first template parameter is a non-type parameter. */
7574 for (lkp_iterator iter (MAYBE_BASELINK_FUNCTIONS (fns)); iter; ++iter)
7575 {
7576 tree fn = *iter;
7577 if (TREE_CODE (fn) == TEMPLATE_DECL)
7578 {
7579 tree tparms = DECL_TEMPLATE_PARMS (fn);
7580 tree parm = TREE_VEC_ELT (INNERMOST_TEMPLATE_PARMS (tparms), 0);
7581 if (TREE_CODE (TREE_VALUE (parm)) == PARM_DECL)
7582 {
7583 use_member_get = true;
7584 break;
7585 }
7586 }
7587 }
7588
7589 if (use_member_get)
7590 {
7591 fns = lookup_template_function (fns, targs);
7592 return build_new_method_call (e, fns, /*args*/NULL,
7593 /*path*/NULL_TREE, LOOKUP_NORMAL,
7594 /*fn_p*/NULL, tf_warning_or_error);
7595 }
7596 else
7597 {
7598 vec<tree,va_gc> *args = make_tree_vector_single (e);
7599 fns = lookup_template_function (get__identifier, targs);
7600 fns = perform_koenig_lookup (fns, args, tf_warning_or_error);
7601 return finish_call_expr (fns, &args, /*novirt*/false,
7602 /*koenig*/true, tf_warning_or_error);
7603 }
7604 }
7605
7606 /* It's impossible to recover the decltype of a tuple decomposition variable
7607 based on the actual type of the variable, so store it in a hash table. */
7608
7609 static GTY((cache)) tree_cache_map *decomp_type_table;
7610 static void
store_decomp_type(tree v,tree t)7611 store_decomp_type (tree v, tree t)
7612 {
7613 if (!decomp_type_table)
7614 decomp_type_table = tree_cache_map::create_ggc (13);
7615 decomp_type_table->put (v, t);
7616 }
7617
7618 tree
lookup_decomp_type(tree v)7619 lookup_decomp_type (tree v)
7620 {
7621 return *decomp_type_table->get (v);
7622 }
7623
7624 /* Mangle a decomposition declaration if needed. Arguments like
7625 in cp_finish_decomp. */
7626
7627 void
cp_maybe_mangle_decomp(tree decl,tree first,unsigned int count)7628 cp_maybe_mangle_decomp (tree decl, tree first, unsigned int count)
7629 {
7630 if (!processing_template_decl
7631 && !error_operand_p (decl)
7632 && DECL_NAMESPACE_SCOPE_P (decl))
7633 {
7634 auto_vec<tree, 16> v;
7635 v.safe_grow (count);
7636 tree d = first;
7637 for (unsigned int i = 0; i < count; i++, d = DECL_CHAIN (d))
7638 v[count - i - 1] = d;
7639 SET_DECL_ASSEMBLER_NAME (decl, mangle_decomp (decl, v));
7640 maybe_apply_pragma_weak (decl);
7641 }
7642 }
7643
7644 /* Finish a decomposition declaration. DECL is the underlying declaration
7645 "e", FIRST is the head of a chain of decls for the individual identifiers
7646 chained through DECL_CHAIN in reverse order and COUNT is the number of
7647 those decls. */
7648
7649 void
cp_finish_decomp(tree decl,tree first,unsigned int count)7650 cp_finish_decomp (tree decl, tree first, unsigned int count)
7651 {
7652 if (error_operand_p (decl))
7653 {
7654 error_out:
7655 while (count--)
7656 {
7657 TREE_TYPE (first) = error_mark_node;
7658 if (DECL_HAS_VALUE_EXPR_P (first))
7659 {
7660 SET_DECL_VALUE_EXPR (first, NULL_TREE);
7661 DECL_HAS_VALUE_EXPR_P (first) = 0;
7662 }
7663 first = DECL_CHAIN (first);
7664 }
7665 if (DECL_P (decl) && DECL_NAMESPACE_SCOPE_P (decl))
7666 SET_DECL_ASSEMBLER_NAME (decl, get_identifier ("<decomp>"));
7667 return;
7668 }
7669
7670 location_t loc = DECL_SOURCE_LOCATION (decl);
7671 if (type_dependent_expression_p (decl)
7672 /* This happens for range for when not in templates.
7673 Still add the DECL_VALUE_EXPRs for later processing. */
7674 || (!processing_template_decl
7675 && type_uses_auto (TREE_TYPE (decl))))
7676 {
7677 for (unsigned int i = 0; i < count; i++)
7678 {
7679 if (!DECL_HAS_VALUE_EXPR_P (first))
7680 {
7681 tree v = build_nt (ARRAY_REF, decl,
7682 size_int (count - i - 1),
7683 NULL_TREE, NULL_TREE);
7684 SET_DECL_VALUE_EXPR (first, v);
7685 DECL_HAS_VALUE_EXPR_P (first) = 1;
7686 }
7687 if (processing_template_decl)
7688 fit_decomposition_lang_decl (first, decl);
7689 first = DECL_CHAIN (first);
7690 }
7691 return;
7692 }
7693
7694 auto_vec<tree, 16> v;
7695 v.safe_grow (count);
7696 tree d = first;
7697 for (unsigned int i = 0; i < count; i++, d = DECL_CHAIN (d))
7698 {
7699 v[count - i - 1] = d;
7700 fit_decomposition_lang_decl (d, decl);
7701 }
7702
7703 tree type = TREE_TYPE (decl);
7704 tree dexp = decl;
7705
7706 if (TYPE_REF_P (type))
7707 {
7708 dexp = convert_from_reference (dexp);
7709 type = complete_type (TREE_TYPE (type));
7710 if (type == error_mark_node)
7711 goto error_out;
7712 if (!COMPLETE_TYPE_P (type))
7713 {
7714 error_at (loc, "structured binding refers to incomplete type %qT",
7715 type);
7716 goto error_out;
7717 }
7718 }
7719
7720 tree eltype = NULL_TREE;
7721 unsigned HOST_WIDE_INT eltscnt = 0;
7722 if (TREE_CODE (type) == ARRAY_TYPE)
7723 {
7724 tree nelts;
7725 nelts = array_type_nelts_top (type);
7726 if (nelts == error_mark_node)
7727 goto error_out;
7728 if (!tree_fits_uhwi_p (nelts))
7729 {
7730 error_at (loc, "cannot decompose variable length array %qT", type);
7731 goto error_out;
7732 }
7733 eltscnt = tree_to_uhwi (nelts);
7734 if (count != eltscnt)
7735 {
7736 cnt_mismatch:
7737 if (count > eltscnt)
7738 error_n (loc, count,
7739 "%u name provided for structured binding",
7740 "%u names provided for structured binding", count);
7741 else
7742 error_n (loc, count,
7743 "only %u name provided for structured binding",
7744 "only %u names provided for structured binding", count);
7745 inform_n (loc, eltscnt,
7746 "while %qT decomposes into %wu element",
7747 "while %qT decomposes into %wu elements",
7748 type, eltscnt);
7749 goto error_out;
7750 }
7751 eltype = TREE_TYPE (type);
7752 for (unsigned int i = 0; i < count; i++)
7753 {
7754 TREE_TYPE (v[i]) = eltype;
7755 layout_decl (v[i], 0);
7756 if (processing_template_decl)
7757 continue;
7758 tree t = unshare_expr (dexp);
7759 t = build4_loc (DECL_SOURCE_LOCATION (v[i]), ARRAY_REF,
7760 eltype, t, size_int (i), NULL_TREE,
7761 NULL_TREE);
7762 SET_DECL_VALUE_EXPR (v[i], t);
7763 DECL_HAS_VALUE_EXPR_P (v[i]) = 1;
7764 }
7765 }
7766 /* 2 GNU extensions. */
7767 else if (TREE_CODE (type) == COMPLEX_TYPE)
7768 {
7769 eltscnt = 2;
7770 if (count != eltscnt)
7771 goto cnt_mismatch;
7772 eltype = cp_build_qualified_type (TREE_TYPE (type), TYPE_QUALS (type));
7773 for (unsigned int i = 0; i < count; i++)
7774 {
7775 TREE_TYPE (v[i]) = eltype;
7776 layout_decl (v[i], 0);
7777 if (processing_template_decl)
7778 continue;
7779 tree t = unshare_expr (dexp);
7780 t = build1_loc (DECL_SOURCE_LOCATION (v[i]),
7781 i ? IMAGPART_EXPR : REALPART_EXPR, eltype,
7782 t);
7783 SET_DECL_VALUE_EXPR (v[i], t);
7784 DECL_HAS_VALUE_EXPR_P (v[i]) = 1;
7785 }
7786 }
7787 else if (TREE_CODE (type) == VECTOR_TYPE)
7788 {
7789 if (!TYPE_VECTOR_SUBPARTS (type).is_constant (&eltscnt))
7790 {
7791 error_at (loc, "cannot decompose variable length vector %qT", type);
7792 goto error_out;
7793 }
7794 if (count != eltscnt)
7795 goto cnt_mismatch;
7796 eltype = cp_build_qualified_type (TREE_TYPE (type), TYPE_QUALS (type));
7797 for (unsigned int i = 0; i < count; i++)
7798 {
7799 TREE_TYPE (v[i]) = eltype;
7800 layout_decl (v[i], 0);
7801 if (processing_template_decl)
7802 continue;
7803 tree t = unshare_expr (dexp);
7804 convert_vector_to_array_for_subscript (DECL_SOURCE_LOCATION (v[i]),
7805 &t, size_int (i));
7806 t = build4_loc (DECL_SOURCE_LOCATION (v[i]), ARRAY_REF,
7807 eltype, t, size_int (i), NULL_TREE,
7808 NULL_TREE);
7809 SET_DECL_VALUE_EXPR (v[i], t);
7810 DECL_HAS_VALUE_EXPR_P (v[i]) = 1;
7811 }
7812 }
7813 else if (tree tsize = get_tuple_size (type))
7814 {
7815 if (tsize == error_mark_node)
7816 {
7817 error_at (loc, "%<std::tuple_size<%T>::value%> is not an integral "
7818 "constant expression", type);
7819 goto error_out;
7820 }
7821 if (!tree_fits_uhwi_p (tsize))
7822 {
7823 error_n (loc, count,
7824 "%u name provided for structured binding",
7825 "%u names provided for structured binding", count);
7826 inform (loc, "while %qT decomposes into %E elements",
7827 type, tsize);
7828 goto error_out;
7829 }
7830 eltscnt = tree_to_uhwi (tsize);
7831 if (count != eltscnt)
7832 goto cnt_mismatch;
7833 int save_read = DECL_READ_P (decl);
7834 for (unsigned i = 0; i < count; ++i)
7835 {
7836 location_t sloc = input_location;
7837 location_t dloc = DECL_SOURCE_LOCATION (v[i]);
7838
7839 input_location = dloc;
7840 tree init = get_tuple_decomp_init (decl, i);
7841 tree eltype = (init == error_mark_node ? error_mark_node
7842 : get_tuple_element_type (type, i));
7843 input_location = sloc;
7844
7845 if (VOID_TYPE_P (eltype))
7846 {
7847 error ("%<std::tuple_element<%u, %T>::type%> is %<void%>",
7848 i, type);
7849 eltype = error_mark_node;
7850 }
7851 if (init == error_mark_node || eltype == error_mark_node)
7852 {
7853 inform (dloc, "in initialization of structured binding "
7854 "variable %qD", v[i]);
7855 goto error_out;
7856 }
7857 /* Save the decltype away before reference collapse. */
7858 store_decomp_type (v[i], eltype);
7859 eltype = cp_build_reference_type (eltype, !lvalue_p (init));
7860 TREE_TYPE (v[i]) = eltype;
7861 layout_decl (v[i], 0);
7862 if (DECL_HAS_VALUE_EXPR_P (v[i]))
7863 {
7864 /* In this case the names are variables, not just proxies. */
7865 SET_DECL_VALUE_EXPR (v[i], NULL_TREE);
7866 DECL_HAS_VALUE_EXPR_P (v[i]) = 0;
7867 }
7868 if (!processing_template_decl)
7869 cp_finish_decl (v[i], init, /*constexpr*/false,
7870 /*asm*/NULL_TREE, LOOKUP_NORMAL);
7871 }
7872 /* Ignore reads from the underlying decl performed during initialization
7873 of the individual variables. If those will be read, we'll mark
7874 the underlying decl as read at that point. */
7875 DECL_READ_P (decl) = save_read;
7876 }
7877 else if (TREE_CODE (type) == UNION_TYPE)
7878 {
7879 error_at (loc, "cannot decompose union type %qT", type);
7880 goto error_out;
7881 }
7882 else if (!CLASS_TYPE_P (type))
7883 {
7884 error_at (loc, "cannot decompose non-array non-class type %qT", type);
7885 goto error_out;
7886 }
7887 else if (LAMBDA_TYPE_P (type))
7888 {
7889 error_at (loc, "cannot decompose lambda closure type %qT", type);
7890 goto error_out;
7891 }
7892 else if (processing_template_decl && complete_type (type) == error_mark_node)
7893 goto error_out;
7894 else if (processing_template_decl && !COMPLETE_TYPE_P (type))
7895 pedwarn (loc, 0, "structured binding refers to incomplete class type %qT",
7896 type);
7897 else
7898 {
7899 tree btype = find_decomp_class_base (loc, type, NULL_TREE);
7900 if (btype == error_mark_node)
7901 goto error_out;
7902 else if (btype == NULL_TREE)
7903 {
7904 error_at (loc, "cannot decompose class type %qT without non-static "
7905 "data members", type);
7906 goto error_out;
7907 }
7908 for (tree field = TYPE_FIELDS (btype); field; field = TREE_CHAIN (field))
7909 if (TREE_CODE (field) != FIELD_DECL
7910 || DECL_ARTIFICIAL (field)
7911 || DECL_UNNAMED_BIT_FIELD (field))
7912 continue;
7913 else
7914 eltscnt++;
7915 if (count != eltscnt)
7916 goto cnt_mismatch;
7917 tree t = dexp;
7918 if (type != btype)
7919 {
7920 t = convert_to_base (t, btype, /*check_access*/true,
7921 /*nonnull*/false, tf_warning_or_error);
7922 type = btype;
7923 }
7924 unsigned int i = 0;
7925 for (tree field = TYPE_FIELDS (btype); field; field = TREE_CHAIN (field))
7926 if (TREE_CODE (field) != FIELD_DECL
7927 || DECL_ARTIFICIAL (field)
7928 || DECL_UNNAMED_BIT_FIELD (field))
7929 continue;
7930 else
7931 {
7932 tree tt = finish_non_static_data_member (field, unshare_expr (t),
7933 NULL_TREE);
7934 if (REFERENCE_REF_P (tt))
7935 tt = TREE_OPERAND (tt, 0);
7936 TREE_TYPE (v[i]) = TREE_TYPE (tt);
7937 layout_decl (v[i], 0);
7938 if (!processing_template_decl)
7939 {
7940 SET_DECL_VALUE_EXPR (v[i], tt);
7941 DECL_HAS_VALUE_EXPR_P (v[i]) = 1;
7942 }
7943 i++;
7944 }
7945 }
7946 if (processing_template_decl)
7947 {
7948 for (unsigned int i = 0; i < count; i++)
7949 if (!DECL_HAS_VALUE_EXPR_P (v[i]))
7950 {
7951 tree a = build_nt (ARRAY_REF, decl, size_int (i),
7952 NULL_TREE, NULL_TREE);
7953 SET_DECL_VALUE_EXPR (v[i], a);
7954 DECL_HAS_VALUE_EXPR_P (v[i]) = 1;
7955 }
7956 }
7957 }
7958
7959 /* Returns a declaration for a VAR_DECL as if:
7960
7961 extern "C" TYPE NAME;
7962
7963 had been seen. Used to create compiler-generated global
7964 variables. */
7965
7966 static tree
declare_global_var(tree name,tree type)7967 declare_global_var (tree name, tree type)
7968 {
7969 tree decl;
7970
7971 push_to_top_level ();
7972 decl = build_decl (input_location, VAR_DECL, name, type);
7973 TREE_PUBLIC (decl) = 1;
7974 DECL_EXTERNAL (decl) = 1;
7975 DECL_ARTIFICIAL (decl) = 1;
7976 DECL_CONTEXT (decl) = FROB_CONTEXT (global_namespace);
7977 /* If the user has explicitly declared this variable (perhaps
7978 because the code we are compiling is part of a low-level runtime
7979 library), then it is possible that our declaration will be merged
7980 with theirs by pushdecl. */
7981 decl = pushdecl (decl);
7982 cp_finish_decl (decl, NULL_TREE, false, NULL_TREE, 0);
7983 pop_from_top_level ();
7984
7985 return decl;
7986 }
7987
7988 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
7989 if "__cxa_atexit" is not being used) corresponding to the function
7990 to be called when the program exits. */
7991
7992 static tree
get_atexit_fn_ptr_type(void)7993 get_atexit_fn_ptr_type (void)
7994 {
7995 tree fn_type;
7996
7997 if (!atexit_fn_ptr_type_node)
7998 {
7999 tree arg_type;
8000 if (flag_use_cxa_atexit
8001 && !targetm.cxx.use_atexit_for_cxa_atexit ())
8002 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
8003 arg_type = ptr_type_node;
8004 else
8005 /* The parameter to "atexit" is "void (*)(void)". */
8006 arg_type = NULL_TREE;
8007
8008 fn_type = build_function_type_list (void_type_node,
8009 arg_type, NULL_TREE);
8010 atexit_fn_ptr_type_node = build_pointer_type (fn_type);
8011 }
8012
8013 return atexit_fn_ptr_type_node;
8014 }
8015
8016 /* Returns a pointer to the `atexit' function. Note that if
8017 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
8018 `__cxa_atexit' function specified in the IA64 C++ ABI. */
8019
8020 static tree
get_atexit_node(void)8021 get_atexit_node (void)
8022 {
8023 tree atexit_fndecl;
8024 tree fn_type;
8025 tree fn_ptr_type;
8026 const char *name;
8027 bool use_aeabi_atexit;
8028
8029 if (atexit_node)
8030 return atexit_node;
8031
8032 if (flag_use_cxa_atexit && !targetm.cxx.use_atexit_for_cxa_atexit ())
8033 {
8034 /* The declaration for `__cxa_atexit' is:
8035
8036 int __cxa_atexit (void (*)(void *), void *, void *)
8037
8038 We build up the argument types and then the function type
8039 itself. */
8040 tree argtype0, argtype1, argtype2;
8041
8042 use_aeabi_atexit = targetm.cxx.use_aeabi_atexit ();
8043 /* First, build the pointer-to-function type for the first
8044 argument. */
8045 fn_ptr_type = get_atexit_fn_ptr_type ();
8046 /* Then, build the rest of the argument types. */
8047 argtype2 = ptr_type_node;
8048 if (use_aeabi_atexit)
8049 {
8050 argtype1 = fn_ptr_type;
8051 argtype0 = ptr_type_node;
8052 }
8053 else
8054 {
8055 argtype1 = ptr_type_node;
8056 argtype0 = fn_ptr_type;
8057 }
8058 /* And the final __cxa_atexit type. */
8059 fn_type = build_function_type_list (integer_type_node,
8060 argtype0, argtype1, argtype2,
8061 NULL_TREE);
8062 if (use_aeabi_atexit)
8063 name = "__aeabi_atexit";
8064 else
8065 name = "__cxa_atexit";
8066 }
8067 else
8068 {
8069 /* The declaration for `atexit' is:
8070
8071 int atexit (void (*)());
8072
8073 We build up the argument types and then the function type
8074 itself. */
8075 fn_ptr_type = get_atexit_fn_ptr_type ();
8076 /* Build the final atexit type. */
8077 fn_type = build_function_type_list (integer_type_node,
8078 fn_ptr_type, NULL_TREE);
8079 name = "atexit";
8080 }
8081
8082 /* Now, build the function declaration. */
8083 push_lang_context (lang_name_c);
8084 atexit_fndecl = build_library_fn_ptr (name, fn_type, ECF_LEAF | ECF_NOTHROW);
8085 mark_used (atexit_fndecl);
8086 pop_lang_context ();
8087 atexit_node = decay_conversion (atexit_fndecl, tf_warning_or_error);
8088
8089 return atexit_node;
8090 }
8091
8092 /* Like get_atexit_node, but for thread-local cleanups. */
8093
8094 static tree
get_thread_atexit_node(void)8095 get_thread_atexit_node (void)
8096 {
8097 /* The declaration for `__cxa_thread_atexit' is:
8098
8099 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
8100 tree fn_type = build_function_type_list (integer_type_node,
8101 get_atexit_fn_ptr_type (),
8102 ptr_type_node, ptr_type_node,
8103 NULL_TREE);
8104
8105 /* Now, build the function declaration. */
8106 tree atexit_fndecl = build_library_fn_ptr ("__cxa_thread_atexit", fn_type,
8107 ECF_LEAF | ECF_NOTHROW);
8108 return decay_conversion (atexit_fndecl, tf_warning_or_error);
8109 }
8110
8111 /* Returns the __dso_handle VAR_DECL. */
8112
8113 static tree
get_dso_handle_node(void)8114 get_dso_handle_node (void)
8115 {
8116 if (dso_handle_node)
8117 return dso_handle_node;
8118
8119 /* Declare the variable. */
8120 dso_handle_node = declare_global_var (get_identifier ("__dso_handle"),
8121 ptr_type_node);
8122
8123 #ifdef HAVE_GAS_HIDDEN
8124 if (dso_handle_node != error_mark_node)
8125 {
8126 DECL_VISIBILITY (dso_handle_node) = VISIBILITY_HIDDEN;
8127 DECL_VISIBILITY_SPECIFIED (dso_handle_node) = 1;
8128 }
8129 #endif
8130
8131 return dso_handle_node;
8132 }
8133
8134 /* Begin a new function with internal linkage whose job will be simply
8135 to destroy some particular variable. */
8136
8137 static GTY(()) int start_cleanup_cnt;
8138
8139 static tree
start_cleanup_fn(void)8140 start_cleanup_fn (void)
8141 {
8142 char name[32];
8143 tree fntype;
8144 tree fndecl;
8145 bool use_cxa_atexit = flag_use_cxa_atexit
8146 && !targetm.cxx.use_atexit_for_cxa_atexit ();
8147
8148 push_to_top_level ();
8149
8150 /* No need to mangle this. */
8151 push_lang_context (lang_name_c);
8152
8153 /* Build the name of the function. */
8154 sprintf (name, "__tcf_%d", start_cleanup_cnt++);
8155 /* Build the function declaration. */
8156 fntype = TREE_TYPE (get_atexit_fn_ptr_type ());
8157 fndecl = build_lang_decl (FUNCTION_DECL, get_identifier (name), fntype);
8158 /* It's a function with internal linkage, generated by the
8159 compiler. */
8160 TREE_PUBLIC (fndecl) = 0;
8161 DECL_ARTIFICIAL (fndecl) = 1;
8162 /* Make the function `inline' so that it is only emitted if it is
8163 actually needed. It is unlikely that it will be inlined, since
8164 it is only called via a function pointer, but we avoid unnecessary
8165 emissions this way. */
8166 DECL_DECLARED_INLINE_P (fndecl) = 1;
8167 DECL_INTERFACE_KNOWN (fndecl) = 1;
8168 /* Build the parameter. */
8169 if (use_cxa_atexit)
8170 {
8171 tree parmdecl = cp_build_parm_decl (fndecl, NULL_TREE, ptr_type_node);
8172 TREE_USED (parmdecl) = 1;
8173 DECL_READ_P (parmdecl) = 1;
8174 DECL_ARGUMENTS (fndecl) = parmdecl;
8175 }
8176
8177 pushdecl (fndecl);
8178 start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED);
8179
8180 pop_lang_context ();
8181
8182 return current_function_decl;
8183 }
8184
8185 /* Finish the cleanup function begun by start_cleanup_fn. */
8186
8187 static void
end_cleanup_fn(void)8188 end_cleanup_fn (void)
8189 {
8190 expand_or_defer_fn (finish_function (/*inline_p=*/false));
8191
8192 pop_from_top_level ();
8193 }
8194
8195 /* Generate code to handle the destruction of DECL, an object with
8196 static storage duration. */
8197
8198 tree
register_dtor_fn(tree decl)8199 register_dtor_fn (tree decl)
8200 {
8201 tree cleanup;
8202 tree addr;
8203 tree compound_stmt;
8204 tree fcall;
8205 tree type;
8206 bool ob_parm, dso_parm, use_dtor;
8207 tree arg0, arg1, arg2;
8208 tree atex_node;
8209
8210 type = TREE_TYPE (decl);
8211 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
8212 return void_node;
8213
8214 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
8215 "__aeabi_atexit"), and DECL is a class object, we can just pass the
8216 destructor to "__cxa_atexit"; we don't have to build a temporary
8217 function to do the cleanup. */
8218 dso_parm = (flag_use_cxa_atexit
8219 && !targetm.cxx.use_atexit_for_cxa_atexit ());
8220 ob_parm = (CP_DECL_THREAD_LOCAL_P (decl) || dso_parm);
8221 use_dtor = ob_parm && CLASS_TYPE_P (type);
8222 if (use_dtor)
8223 {
8224 cleanup = get_class_binding (type, complete_dtor_identifier);
8225
8226 /* Make sure it is accessible. */
8227 perform_or_defer_access_check (TYPE_BINFO (type), cleanup, cleanup,
8228 tf_warning_or_error);
8229 }
8230 else
8231 {
8232 /* Call build_cleanup before we enter the anonymous function so
8233 that any access checks will be done relative to the current
8234 scope, rather than the scope of the anonymous function. */
8235 build_cleanup (decl);
8236
8237 /* Now start the function. */
8238 cleanup = start_cleanup_fn ();
8239
8240 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
8241 to the original function, rather than the anonymous one. That
8242 will make the back end think that nested functions are in use,
8243 which causes confusion. */
8244 push_deferring_access_checks (dk_no_check);
8245 fcall = build_cleanup (decl);
8246 pop_deferring_access_checks ();
8247
8248 /* Create the body of the anonymous function. */
8249 compound_stmt = begin_compound_stmt (BCS_FN_BODY);
8250 finish_expr_stmt (fcall);
8251 finish_compound_stmt (compound_stmt);
8252 end_cleanup_fn ();
8253 }
8254
8255 /* Call atexit with the cleanup function. */
8256 mark_used (cleanup);
8257 cleanup = build_address (cleanup);
8258
8259 if (CP_DECL_THREAD_LOCAL_P (decl))
8260 atex_node = get_thread_atexit_node ();
8261 else
8262 atex_node = get_atexit_node ();
8263
8264 if (use_dtor)
8265 {
8266 /* We must convert CLEANUP to the type that "__cxa_atexit"
8267 expects. */
8268 cleanup = build_nop (get_atexit_fn_ptr_type (), cleanup);
8269 /* "__cxa_atexit" will pass the address of DECL to the
8270 cleanup function. */
8271 mark_used (decl);
8272 addr = build_address (decl);
8273 /* The declared type of the parameter to "__cxa_atexit" is
8274 "void *". For plain "T*", we could just let the
8275 machinery in cp_build_function_call convert it -- but if the
8276 type is "cv-qualified T *", then we need to convert it
8277 before passing it in, to avoid spurious errors. */
8278 addr = build_nop (ptr_type_node, addr);
8279 }
8280 else
8281 /* Since the cleanup functions we build ignore the address
8282 they're given, there's no reason to pass the actual address
8283 in, and, in general, it's cheaper to pass NULL than any
8284 other value. */
8285 addr = null_pointer_node;
8286
8287 if (dso_parm)
8288 arg2 = cp_build_addr_expr (get_dso_handle_node (),
8289 tf_warning_or_error);
8290 else if (ob_parm)
8291 /* Just pass NULL to the dso handle parm if we don't actually
8292 have a DSO handle on this target. */
8293 arg2 = null_pointer_node;
8294 else
8295 arg2 = NULL_TREE;
8296
8297 if (ob_parm)
8298 {
8299 if (!CP_DECL_THREAD_LOCAL_P (decl)
8300 && targetm.cxx.use_aeabi_atexit ())
8301 {
8302 arg1 = cleanup;
8303 arg0 = addr;
8304 }
8305 else
8306 {
8307 arg1 = addr;
8308 arg0 = cleanup;
8309 }
8310 }
8311 else
8312 {
8313 arg0 = cleanup;
8314 arg1 = NULL_TREE;
8315 }
8316 return cp_build_function_call_nary (atex_node, tf_warning_or_error,
8317 arg0, arg1, arg2, NULL_TREE);
8318 }
8319
8320 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
8321 is its initializer. Generate code to handle the construction
8322 and destruction of DECL. */
8323
8324 static void
expand_static_init(tree decl,tree init)8325 expand_static_init (tree decl, tree init)
8326 {
8327 gcc_assert (VAR_P (decl));
8328 gcc_assert (TREE_STATIC (decl));
8329
8330 /* Some variables require no dynamic initialization. */
8331 if (TYPE_HAS_TRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
8332 {
8333 /* Make sure the destructor is callable. */
8334 cxx_maybe_build_cleanup (decl, tf_warning_or_error);
8335 if (!init)
8336 return;
8337 }
8338
8339 if (CP_DECL_THREAD_LOCAL_P (decl) && DECL_GNU_TLS_P (decl)
8340 && !DECL_FUNCTION_SCOPE_P (decl))
8341 {
8342 location_t dloc = DECL_SOURCE_LOCATION (decl);
8343 if (init)
8344 error_at (dloc, "non-local variable %qD declared %<__thread%> "
8345 "needs dynamic initialization", decl);
8346 else
8347 error_at (dloc, "non-local variable %qD declared %<__thread%> "
8348 "has a non-trivial destructor", decl);
8349 static bool informed;
8350 if (!informed)
8351 {
8352 inform (dloc, "C++11 %<thread_local%> allows dynamic "
8353 "initialization and destruction");
8354 informed = true;
8355 }
8356 return;
8357 }
8358
8359 if (DECL_FUNCTION_SCOPE_P (decl))
8360 {
8361 /* Emit code to perform this initialization but once. */
8362 tree if_stmt = NULL_TREE, inner_if_stmt = NULL_TREE;
8363 tree then_clause = NULL_TREE, inner_then_clause = NULL_TREE;
8364 tree guard, guard_addr;
8365 tree flag, begin;
8366 /* We don't need thread-safety code for thread-local vars. */
8367 bool thread_guard = (flag_threadsafe_statics
8368 && !CP_DECL_THREAD_LOCAL_P (decl));
8369
8370 /* Emit code to perform this initialization but once. This code
8371 looks like:
8372
8373 static <type> guard;
8374 if (!__atomic_load (guard.first_byte)) {
8375 if (__cxa_guard_acquire (&guard)) {
8376 bool flag = false;
8377 try {
8378 // Do initialization.
8379 flag = true; __cxa_guard_release (&guard);
8380 // Register variable for destruction at end of program.
8381 } catch {
8382 if (!flag) __cxa_guard_abort (&guard);
8383 }
8384 }
8385 }
8386
8387 Note that the `flag' variable is only set to 1 *after* the
8388 initialization is complete. This ensures that an exception,
8389 thrown during the construction, will cause the variable to
8390 reinitialized when we pass through this code again, as per:
8391
8392 [stmt.dcl]
8393
8394 If the initialization exits by throwing an exception, the
8395 initialization is not complete, so it will be tried again
8396 the next time control enters the declaration.
8397
8398 This process should be thread-safe, too; multiple threads
8399 should not be able to initialize the variable more than
8400 once. */
8401
8402 /* Create the guard variable. */
8403 guard = get_guard (decl);
8404
8405 /* Begin the conditional initialization. */
8406 if_stmt = begin_if_stmt ();
8407
8408 finish_if_stmt_cond (get_guard_cond (guard, thread_guard), if_stmt);
8409 then_clause = begin_compound_stmt (BCS_NO_SCOPE);
8410
8411 if (thread_guard)
8412 {
8413 tree vfntype = NULL_TREE;
8414 tree acquire_name, release_name, abort_name;
8415 tree acquire_fn, release_fn, abort_fn;
8416 guard_addr = build_address (guard);
8417
8418 acquire_name = get_identifier ("__cxa_guard_acquire");
8419 release_name = get_identifier ("__cxa_guard_release");
8420 abort_name = get_identifier ("__cxa_guard_abort");
8421 acquire_fn = get_global_binding (acquire_name);
8422 release_fn = get_global_binding (release_name);
8423 abort_fn = get_global_binding (abort_name);
8424 if (!acquire_fn)
8425 acquire_fn = push_library_fn
8426 (acquire_name, build_function_type_list (integer_type_node,
8427 TREE_TYPE (guard_addr),
8428 NULL_TREE),
8429 NULL_TREE, ECF_NOTHROW);
8430 if (!release_fn || !abort_fn)
8431 vfntype = build_function_type_list (void_type_node,
8432 TREE_TYPE (guard_addr),
8433 NULL_TREE);
8434 if (!release_fn)
8435 release_fn = push_library_fn (release_name, vfntype, NULL_TREE,
8436 ECF_NOTHROW);
8437 if (!abort_fn)
8438 abort_fn = push_library_fn (abort_name, vfntype, NULL_TREE,
8439 ECF_NOTHROW | ECF_LEAF);
8440
8441 inner_if_stmt = begin_if_stmt ();
8442 finish_if_stmt_cond (build_call_n (acquire_fn, 1, guard_addr),
8443 inner_if_stmt);
8444
8445 inner_then_clause = begin_compound_stmt (BCS_NO_SCOPE);
8446 begin = get_target_expr (boolean_false_node);
8447 flag = TARGET_EXPR_SLOT (begin);
8448
8449 TARGET_EXPR_CLEANUP (begin)
8450 = build3 (COND_EXPR, void_type_node, flag,
8451 void_node,
8452 build_call_n (abort_fn, 1, guard_addr));
8453 CLEANUP_EH_ONLY (begin) = 1;
8454
8455 /* Do the initialization itself. */
8456 init = add_stmt_to_compound (begin, init);
8457 init = add_stmt_to_compound (init,
8458 build2 (MODIFY_EXPR, void_type_node,
8459 flag, boolean_true_node));
8460
8461 /* Use atexit to register a function for destroying this static
8462 variable. Do this before calling __cxa_guard_release. */
8463 init = add_stmt_to_compound (init, register_dtor_fn (decl));
8464
8465 init = add_stmt_to_compound (init, build_call_n (release_fn, 1,
8466 guard_addr));
8467 }
8468 else
8469 {
8470 init = add_stmt_to_compound (init, set_guard (guard));
8471
8472 /* Use atexit to register a function for destroying this static
8473 variable. */
8474 init = add_stmt_to_compound (init, register_dtor_fn (decl));
8475 }
8476
8477 finish_expr_stmt (init);
8478
8479 if (thread_guard)
8480 {
8481 finish_compound_stmt (inner_then_clause);
8482 finish_then_clause (inner_if_stmt);
8483 finish_if_stmt (inner_if_stmt);
8484 }
8485
8486 finish_compound_stmt (then_clause);
8487 finish_then_clause (if_stmt);
8488 finish_if_stmt (if_stmt);
8489 }
8490 else if (CP_DECL_THREAD_LOCAL_P (decl))
8491 tls_aggregates = tree_cons (init, decl, tls_aggregates);
8492 else
8493 static_aggregates = tree_cons (init, decl, static_aggregates);
8494 }
8495
8496
8497 /* Make TYPE a complete type based on INITIAL_VALUE.
8498 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
8499 2 if there was no information (in which case assume 0 if DO_DEFAULT),
8500 3 if the initializer list is empty (in pedantic mode). */
8501
8502 int
cp_complete_array_type(tree * ptype,tree initial_value,bool do_default)8503 cp_complete_array_type (tree *ptype, tree initial_value, bool do_default)
8504 {
8505 int failure;
8506 tree type, elt_type;
8507
8508 /* Don't get confused by a CONSTRUCTOR for some other type. */
8509 if (initial_value && TREE_CODE (initial_value) == CONSTRUCTOR
8510 && !BRACE_ENCLOSED_INITIALIZER_P (initial_value)
8511 && TREE_CODE (TREE_TYPE (initial_value)) != ARRAY_TYPE)
8512 return 1;
8513
8514 if (initial_value)
8515 {
8516 unsigned HOST_WIDE_INT i;
8517 tree value;
8518
8519 /* An array of character type can be initialized from a
8520 brace-enclosed string constant.
8521
8522 FIXME: this code is duplicated from reshape_init. Probably
8523 we should just call reshape_init here? */
8524 if (char_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (*ptype)))
8525 && TREE_CODE (initial_value) == CONSTRUCTOR
8526 && !vec_safe_is_empty (CONSTRUCTOR_ELTS (initial_value)))
8527 {
8528 vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (initial_value);
8529 tree value = (*v)[0].value;
8530 STRIP_ANY_LOCATION_WRAPPER (value);
8531
8532 if (TREE_CODE (value) == STRING_CST
8533 && v->length () == 1)
8534 initial_value = value;
8535 }
8536
8537 /* If any of the elements are parameter packs, we can't actually
8538 complete this type now because the array size is dependent. */
8539 if (TREE_CODE (initial_value) == CONSTRUCTOR)
8540 {
8541 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (initial_value),
8542 i, value)
8543 {
8544 if (PACK_EXPANSION_P (value))
8545 return 0;
8546 }
8547 }
8548 }
8549
8550 failure = complete_array_type (ptype, initial_value, do_default);
8551
8552 /* We can create the array before the element type is complete, which
8553 means that we didn't have these two bits set in the original type
8554 either. In completing the type, we are expected to propagate these
8555 bits. See also complete_type which does the same thing for arrays
8556 of fixed size. */
8557 type = *ptype;
8558 if (type != error_mark_node && TYPE_DOMAIN (type))
8559 {
8560 elt_type = TREE_TYPE (type);
8561 TYPE_NEEDS_CONSTRUCTING (type) = TYPE_NEEDS_CONSTRUCTING (elt_type);
8562 TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
8563 = TYPE_HAS_NONTRIVIAL_DESTRUCTOR (elt_type);
8564 }
8565
8566 return failure;
8567 }
8568
8569 /* As above, but either give an error or reject zero-size arrays, depending
8570 on COMPLAIN. */
8571
8572 int
cp_complete_array_type_or_error(tree * ptype,tree initial_value,bool do_default,tsubst_flags_t complain)8573 cp_complete_array_type_or_error (tree *ptype, tree initial_value,
8574 bool do_default, tsubst_flags_t complain)
8575 {
8576 int failure;
8577 bool sfinae = !(complain & tf_error);
8578 /* In SFINAE context we can't be lenient about zero-size arrays. */
8579 if (sfinae)
8580 ++pedantic;
8581 failure = cp_complete_array_type (ptype, initial_value, do_default);
8582 if (sfinae)
8583 --pedantic;
8584 if (failure)
8585 {
8586 if (sfinae)
8587 /* Not an error. */;
8588 else if (failure == 1)
8589 error ("initializer fails to determine size of %qT", *ptype);
8590 else if (failure == 2)
8591 {
8592 if (do_default)
8593 error ("array size missing in %qT", *ptype);
8594 }
8595 else if (failure == 3)
8596 error ("zero-size array %qT", *ptype);
8597 *ptype = error_mark_node;
8598 }
8599 return failure;
8600 }
8601
8602 /* Return zero if something is declared to be a member of type
8603 CTYPE when in the context of CUR_TYPE. STRING is the error
8604 message to print in that case. Otherwise, quietly return 1. */
8605
8606 static int
member_function_or_else(tree ctype,tree cur_type,enum overload_flags flags)8607 member_function_or_else (tree ctype, tree cur_type, enum overload_flags flags)
8608 {
8609 if (ctype && ctype != cur_type)
8610 {
8611 if (flags == DTOR_FLAG)
8612 error ("destructor for alien class %qT cannot be a member", ctype);
8613 else
8614 error ("constructor for alien class %qT cannot be a member", ctype);
8615 return 0;
8616 }
8617 return 1;
8618 }
8619
8620 /* Subroutine of `grokdeclarator'. */
8621
8622 /* Generate errors possibly applicable for a given set of specifiers.
8623 This is for ARM $7.1.2. */
8624
8625 static void
bad_specifiers(tree object,enum bad_spec_place type,int virtualp,int quals,int inlinep,int friendp,int raises,const location_t * locations)8626 bad_specifiers (tree object,
8627 enum bad_spec_place type,
8628 int virtualp,
8629 int quals,
8630 int inlinep,
8631 int friendp,
8632 int raises,
8633 const location_t* locations)
8634 {
8635 switch (type)
8636 {
8637 case BSP_VAR:
8638 if (virtualp)
8639 error_at (locations[ds_virtual],
8640 "%qD declared as a %<virtual%> variable", object);
8641 if (quals)
8642 error ("%<const%> and %<volatile%> function specifiers on "
8643 "%qD invalid in variable declaration", object);
8644 break;
8645 case BSP_PARM:
8646 if (virtualp)
8647 error_at (locations[ds_virtual],
8648 "%qD declared as a %<virtual%> parameter", object);
8649 if (inlinep)
8650 error_at (locations[ds_inline],
8651 "%qD declared as an %<inline%> parameter", object);
8652 if (quals)
8653 error ("%<const%> and %<volatile%> function specifiers on "
8654 "%qD invalid in parameter declaration", object);
8655 break;
8656 case BSP_TYPE:
8657 if (virtualp)
8658 error_at (locations[ds_virtual],
8659 "%qD declared as a %<virtual%> type", object);
8660 if (inlinep)
8661 error_at (locations[ds_inline],
8662 "%qD declared as an %<inline%> type", object);
8663 if (quals)
8664 error ("%<const%> and %<volatile%> function specifiers on "
8665 "%qD invalid in type declaration", object);
8666 break;
8667 case BSP_FIELD:
8668 if (virtualp)
8669 error_at (locations[ds_virtual],
8670 "%qD declared as a %<virtual%> field", object);
8671 if (inlinep)
8672 error_at (locations[ds_inline],
8673 "%qD declared as an %<inline%> field", object);
8674 if (quals)
8675 error ("%<const%> and %<volatile%> function specifiers on "
8676 "%qD invalid in field declaration", object);
8677 break;
8678 default:
8679 gcc_unreachable();
8680 }
8681 if (friendp)
8682 error ("%q+D declared as a friend", object);
8683 if (raises
8684 && !flag_noexcept_type
8685 && (TREE_CODE (object) == TYPE_DECL
8686 || (!TYPE_PTRFN_P (TREE_TYPE (object))
8687 && !TYPE_REFFN_P (TREE_TYPE (object))
8688 && !TYPE_PTRMEMFUNC_P (TREE_TYPE (object)))))
8689 error ("%q+D declared with an exception specification", object);
8690 }
8691
8692 /* DECL is a member function or static data member and is presently
8693 being defined. Check that the definition is taking place in a
8694 valid namespace. */
8695
8696 static void
check_class_member_definition_namespace(tree decl)8697 check_class_member_definition_namespace (tree decl)
8698 {
8699 /* These checks only apply to member functions and static data
8700 members. */
8701 gcc_assert (VAR_OR_FUNCTION_DECL_P (decl));
8702 /* We check for problems with specializations in pt.c in
8703 check_specialization_namespace, where we can issue better
8704 diagnostics. */
8705 if (processing_specialization)
8706 return;
8707 /* We check this in check_explicit_instantiation_namespace. */
8708 if (processing_explicit_instantiation)
8709 return;
8710 /* [class.mfct]
8711
8712 A member function definition that appears outside of the
8713 class definition shall appear in a namespace scope enclosing
8714 the class definition.
8715
8716 [class.static.data]
8717
8718 The definition for a static data member shall appear in a
8719 namespace scope enclosing the member's class definition. */
8720 if (!is_ancestor (current_namespace, DECL_CONTEXT (decl)))
8721 permerror (input_location, "definition of %qD is not in namespace enclosing %qT",
8722 decl, DECL_CONTEXT (decl));
8723 }
8724
8725 /* Build a PARM_DECL for the "this" parameter of FN. TYPE is the
8726 METHOD_TYPE for a non-static member function; QUALS are the
8727 cv-qualifiers that apply to the function. */
8728
8729 tree
build_this_parm(tree fn,tree type,cp_cv_quals quals)8730 build_this_parm (tree fn, tree type, cp_cv_quals quals)
8731 {
8732 tree this_type;
8733 tree qual_type;
8734 tree parm;
8735 cp_cv_quals this_quals;
8736
8737 if (CLASS_TYPE_P (type))
8738 {
8739 this_type
8740 = cp_build_qualified_type (type, quals & ~TYPE_QUAL_RESTRICT);
8741 this_type = build_pointer_type (this_type);
8742 }
8743 else
8744 this_type = type_of_this_parm (type);
8745 /* The `this' parameter is implicitly `const'; it cannot be
8746 assigned to. */
8747 this_quals = (quals & TYPE_QUAL_RESTRICT) | TYPE_QUAL_CONST;
8748 qual_type = cp_build_qualified_type (this_type, this_quals);
8749 parm = build_artificial_parm (fn, this_identifier, qual_type);
8750 cp_apply_type_quals_to_decl (this_quals, parm);
8751 return parm;
8752 }
8753
8754 /* DECL is a static member function. Complain if it was declared
8755 with function-cv-quals. */
8756
8757 static void
check_static_quals(tree decl,cp_cv_quals quals)8758 check_static_quals (tree decl, cp_cv_quals quals)
8759 {
8760 if (quals != TYPE_UNQUALIFIED)
8761 error ("static member function %q#D declared with type qualifiers",
8762 decl);
8763 }
8764
8765 // Check that FN takes no arguments and returns bool.
8766 static void
check_concept_fn(tree fn)8767 check_concept_fn (tree fn)
8768 {
8769 // A constraint is nullary.
8770 if (DECL_ARGUMENTS (fn))
8771 error_at (DECL_SOURCE_LOCATION (fn),
8772 "concept %q#D declared with function parameters", fn);
8773
8774 // The declared return type of the concept shall be bool, and
8775 // it shall not be deduced from it definition.
8776 tree type = TREE_TYPE (TREE_TYPE (fn));
8777 if (is_auto (type))
8778 error_at (DECL_SOURCE_LOCATION (fn),
8779 "concept %q#D declared with a deduced return type", fn);
8780 else if (type != boolean_type_node)
8781 error_at (DECL_SOURCE_LOCATION (fn),
8782 "concept %q#D with non-%<bool%> return type %qT", fn, type);
8783 }
8784
8785 /* Helper function. Replace the temporary this parameter injected
8786 during cp_finish_omp_declare_simd with the real this parameter. */
8787
8788 static tree
declare_simd_adjust_this(tree * tp,int * walk_subtrees,void * data)8789 declare_simd_adjust_this (tree *tp, int *walk_subtrees, void *data)
8790 {
8791 tree this_parm = (tree) data;
8792 if (TREE_CODE (*tp) == PARM_DECL
8793 && DECL_NAME (*tp) == this_identifier
8794 && *tp != this_parm)
8795 *tp = this_parm;
8796 else if (TYPE_P (*tp))
8797 *walk_subtrees = 0;
8798 return NULL_TREE;
8799 }
8800
8801 /* CTYPE is class type, or null if non-class.
8802 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
8803 or METHOD_TYPE.
8804 DECLARATOR is the function's name.
8805 PARMS is a chain of PARM_DECLs for the function.
8806 VIRTUALP is truthvalue of whether the function is virtual or not.
8807 FLAGS are to be passed through to `grokclassfn'.
8808 QUALS are qualifiers indicating whether the function is `const'
8809 or `volatile'.
8810 RAISES is a list of exceptions that this function can raise.
8811 CHECK is 1 if we must find this method in CTYPE, 0 if we should
8812 not look, and -1 if we should not call `grokclassfn' at all.
8813
8814 SFK is the kind of special function (if any) for the new function.
8815
8816 Returns `NULL_TREE' if something goes wrong, after issuing
8817 applicable error messages. */
8818
8819 static tree
grokfndecl(tree ctype,tree type,tree declarator,tree parms,tree orig_declarator,const cp_decl_specifier_seq * declspecs,tree decl_reqs,int virtualp,enum overload_flags flags,cp_cv_quals quals,cp_ref_qualifier rqual,tree raises,int check,int friendp,int publicp,int inlinep,bool deletedp,special_function_kind sfk,bool funcdef_flag,bool late_return_type_p,int template_count,tree in_namespace,tree * attrlist,location_t location)8820 grokfndecl (tree ctype,
8821 tree type,
8822 tree declarator,
8823 tree parms,
8824 tree orig_declarator,
8825 const cp_decl_specifier_seq *declspecs,
8826 tree decl_reqs,
8827 int virtualp,
8828 enum overload_flags flags,
8829 cp_cv_quals quals,
8830 cp_ref_qualifier rqual,
8831 tree raises,
8832 int check,
8833 int friendp,
8834 int publicp,
8835 int inlinep,
8836 bool deletedp,
8837 special_function_kind sfk,
8838 bool funcdef_flag,
8839 bool late_return_type_p,
8840 int template_count,
8841 tree in_namespace,
8842 tree* attrlist,
8843 location_t location)
8844 {
8845 tree decl;
8846 int staticp = ctype && TREE_CODE (type) == FUNCTION_TYPE;
8847 tree t;
8848
8849 if (location == UNKNOWN_LOCATION)
8850 location = input_location;
8851
8852 // Was the concept specifier present?
8853 bool concept_p = inlinep & 4;
8854
8855 // Concept declarations must have a corresponding definition.
8856 if (concept_p && !funcdef_flag)
8857 {
8858 error_at (location, "concept %qD has no definition", declarator);
8859 return NULL_TREE;
8860 }
8861
8862 type = build_cp_fntype_variant (type, rqual, raises, late_return_type_p);
8863
8864 decl = build_lang_decl_loc (location, FUNCTION_DECL, declarator, type);
8865
8866 /* Set the constraints on the declaration. */
8867 if (flag_concepts)
8868 {
8869 tree tmpl_reqs = NULL_TREE;
8870 if (processing_template_decl > template_class_depth (ctype))
8871 tmpl_reqs = TEMPLATE_PARMS_CONSTRAINTS (current_template_parms);
8872
8873 /* Adjust the required expression into a constraint. */
8874 if (decl_reqs)
8875 decl_reqs = normalize_expression (decl_reqs);
8876
8877 tree ci = build_constraints (tmpl_reqs, decl_reqs);
8878 set_constraints (decl, ci);
8879 }
8880
8881 if (TREE_CODE (type) == METHOD_TYPE)
8882 {
8883 tree parm = build_this_parm (decl, type, quals);
8884 DECL_CHAIN (parm) = parms;
8885 parms = parm;
8886
8887 /* Allocate space to hold the vptr bit if needed. */
8888 SET_DECL_ALIGN (decl, MINIMUM_METHOD_BOUNDARY);
8889 }
8890
8891 DECL_ARGUMENTS (decl) = parms;
8892 for (t = parms; t; t = DECL_CHAIN (t))
8893 DECL_CONTEXT (t) = decl;
8894
8895 /* Propagate volatile out from type to decl. */
8896 if (TYPE_VOLATILE (type))
8897 TREE_THIS_VOLATILE (decl) = 1;
8898
8899 /* Setup decl according to sfk. */
8900 switch (sfk)
8901 {
8902 case sfk_constructor:
8903 case sfk_copy_constructor:
8904 case sfk_move_constructor:
8905 DECL_CXX_CONSTRUCTOR_P (decl) = 1;
8906 DECL_NAME (decl) = ctor_identifier;
8907 break;
8908 case sfk_destructor:
8909 DECL_CXX_DESTRUCTOR_P (decl) = 1;
8910 DECL_NAME (decl) = dtor_identifier;
8911 break;
8912 default:
8913 break;
8914 }
8915
8916 if (friendp && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)
8917 {
8918 if (funcdef_flag)
8919 error_at (location,
8920 "defining explicit specialization %qD in friend declaration",
8921 orig_declarator);
8922 else
8923 {
8924 tree fns = TREE_OPERAND (orig_declarator, 0);
8925 tree args = TREE_OPERAND (orig_declarator, 1);
8926
8927 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
8928 {
8929 /* Something like `template <class T> friend void f<T>()'. */
8930 error_at (location,
8931 "invalid use of template-id %qD in declaration "
8932 "of primary template",
8933 orig_declarator);
8934 return NULL_TREE;
8935 }
8936
8937
8938 /* A friend declaration of the form friend void f<>(). Record
8939 the information in the TEMPLATE_ID_EXPR. */
8940 SET_DECL_IMPLICIT_INSTANTIATION (decl);
8941
8942 gcc_assert (identifier_p (fns)
8943 || TREE_CODE (fns) == OVERLOAD
8944 || TREE_CODE (fns) == FUNCTION_DECL);
8945 DECL_TEMPLATE_INFO (decl) = build_template_info (fns, args);
8946
8947 for (t = TYPE_ARG_TYPES (TREE_TYPE (decl)); t; t = TREE_CHAIN (t))
8948 if (TREE_PURPOSE (t)
8949 && TREE_CODE (TREE_PURPOSE (t)) == DEFAULT_ARG)
8950 {
8951 error_at (defarg_location (TREE_PURPOSE (t)),
8952 "default arguments are not allowed in declaration "
8953 "of friend template specialization %qD",
8954 decl);
8955 return NULL_TREE;
8956 }
8957
8958 if (inlinep & 1)
8959 {
8960 error_at (declspecs->locations[ds_inline],
8961 "%<inline%> is not allowed in declaration of friend "
8962 "template specialization %qD",
8963 decl);
8964 return NULL_TREE;
8965 }
8966 }
8967 }
8968
8969 /* C++17 11.3.6/4: "If a friend declaration specifies a default argument
8970 expression, that declaration shall be a definition..." */
8971 if (friendp && !funcdef_flag)
8972 {
8973 for (tree t = FUNCTION_FIRST_USER_PARMTYPE (decl);
8974 t && t != void_list_node; t = TREE_CHAIN (t))
8975 if (TREE_PURPOSE (t))
8976 {
8977 permerror (DECL_SOURCE_LOCATION (decl),
8978 "friend declaration of %qD specifies default "
8979 "arguments and isn%'t a definition", decl);
8980 break;
8981 }
8982 }
8983
8984 /* If this decl has namespace scope, set that up. */
8985 if (in_namespace)
8986 set_decl_namespace (decl, in_namespace, friendp);
8987 else if (!ctype)
8988 DECL_CONTEXT (decl) = FROB_CONTEXT (current_decl_namespace ());
8989
8990 /* `main' and builtins have implicit 'C' linkage. */
8991 if (ctype == NULL_TREE
8992 && DECL_FILE_SCOPE_P (decl)
8993 && current_lang_name == lang_name_cplusplus
8994 && (MAIN_NAME_P (declarator)
8995 || (IDENTIFIER_LENGTH (declarator) > 10
8996 && IDENTIFIER_POINTER (declarator)[0] == '_'
8997 && IDENTIFIER_POINTER (declarator)[1] == '_'
8998 && strncmp (IDENTIFIER_POINTER (declarator)+2,
8999 "builtin_", 8) == 0)
9000 || (targetcm.cxx_implicit_extern_c
9001 && (targetcm.cxx_implicit_extern_c
9002 (IDENTIFIER_POINTER (declarator))))))
9003 SET_DECL_LANGUAGE (decl, lang_c);
9004
9005 /* Should probably propagate const out from type to decl I bet (mrs). */
9006 if (staticp)
9007 {
9008 DECL_STATIC_FUNCTION_P (decl) = 1;
9009 DECL_CONTEXT (decl) = ctype;
9010 }
9011
9012 if (deletedp)
9013 DECL_DELETED_FN (decl) = 1;
9014
9015 if (ctype)
9016 {
9017 DECL_CONTEXT (decl) = ctype;
9018 if (funcdef_flag)
9019 check_class_member_definition_namespace (decl);
9020 }
9021
9022 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
9023 {
9024 if (PROCESSING_REAL_TEMPLATE_DECL_P())
9025 error_at (location, "cannot declare %<::main%> to be a template");
9026 if (inlinep & 1)
9027 error_at (declspecs->locations[ds_inline],
9028 "cannot declare %<::main%> to be inline");
9029 if (inlinep & 2)
9030 error_at (declspecs->locations[ds_constexpr],
9031 "cannot declare %<::main%> to be %<constexpr%>");
9032 if (!publicp)
9033 error_at (location, "cannot declare %<::main%> to be static");
9034 inlinep = 0;
9035 publicp = 1;
9036 }
9037
9038 /* Members of anonymous types and local classes have no linkage; make
9039 them internal. If a typedef is made later, this will be changed. */
9040 if (ctype && (!TREE_PUBLIC (TYPE_MAIN_DECL (ctype))
9041 || decl_function_context (TYPE_MAIN_DECL (ctype))))
9042 publicp = 0;
9043
9044 if (publicp && cxx_dialect == cxx98)
9045 {
9046 /* [basic.link]: A name with no linkage (notably, the name of a class
9047 or enumeration declared in a local scope) shall not be used to
9048 declare an entity with linkage.
9049
9050 DR 757 relaxes this restriction for C++0x. */
9051 no_linkage_error (decl);
9052 }
9053
9054 TREE_PUBLIC (decl) = publicp;
9055 if (! publicp)
9056 {
9057 DECL_INTERFACE_KNOWN (decl) = 1;
9058 DECL_NOT_REALLY_EXTERN (decl) = 1;
9059 }
9060
9061 /* If the declaration was declared inline, mark it as such. */
9062 if (inlinep)
9063 {
9064 DECL_DECLARED_INLINE_P (decl) = 1;
9065 if (publicp)
9066 DECL_COMDAT (decl) = 1;
9067 }
9068 if (inlinep & 2)
9069 DECL_DECLARED_CONSTEXPR_P (decl) = true;
9070
9071 // If the concept declaration specifier was found, check
9072 // that the declaration satisfies the necessary requirements.
9073 if (concept_p)
9074 {
9075 DECL_DECLARED_CONCEPT_P (decl) = true;
9076 check_concept_fn (decl);
9077 }
9078
9079 DECL_EXTERNAL (decl) = 1;
9080 if (TREE_CODE (type) == FUNCTION_TYPE)
9081 {
9082 if (quals || rqual)
9083 TREE_TYPE (decl) = apply_memfn_quals (TREE_TYPE (decl),
9084 TYPE_UNQUALIFIED,
9085 REF_QUAL_NONE);
9086
9087 if (quals)
9088 {
9089 error (ctype
9090 ? G_("static member function %qD cannot have cv-qualifier")
9091 : G_("non-member function %qD cannot have cv-qualifier"),
9092 decl);
9093 quals = TYPE_UNQUALIFIED;
9094 }
9095
9096 if (rqual)
9097 {
9098 error (ctype
9099 ? G_("static member function %qD cannot have ref-qualifier")
9100 : G_("non-member function %qD cannot have ref-qualifier"),
9101 decl);
9102 rqual = REF_QUAL_NONE;
9103 }
9104 }
9105
9106 if (deduction_guide_p (decl))
9107 {
9108 if (!DECL_NAMESPACE_SCOPE_P (decl))
9109 {
9110 error_at (location, "deduction guide %qD must be declared at "
9111 "namespace scope", decl);
9112 return NULL_TREE;
9113 }
9114 if (funcdef_flag)
9115 error_at (location,
9116 "deduction guide %qD must not have a function body", decl);
9117 }
9118 else if (IDENTIFIER_ANY_OP_P (DECL_NAME (decl))
9119 && !grok_op_properties (decl, /*complain=*/true))
9120 return NULL_TREE;
9121 else if (UDLIT_OPER_P (DECL_NAME (decl)))
9122 {
9123 bool long_long_unsigned_p;
9124 bool long_double_p;
9125 const char *suffix = NULL;
9126 /* [over.literal]/6: Literal operators shall not have C linkage. */
9127 if (DECL_LANGUAGE (decl) == lang_c)
9128 {
9129 error_at (location, "literal operator with C linkage");
9130 maybe_show_extern_c_location ();
9131 return NULL_TREE;
9132 }
9133
9134 if (DECL_NAMESPACE_SCOPE_P (decl))
9135 {
9136 if (!check_literal_operator_args (decl, &long_long_unsigned_p,
9137 &long_double_p))
9138 {
9139 error_at (location, "%qD has invalid argument list", decl);
9140 return NULL_TREE;
9141 }
9142
9143 suffix = UDLIT_OP_SUFFIX (DECL_NAME (decl));
9144 if (long_long_unsigned_p)
9145 {
9146 if (cpp_interpret_int_suffix (parse_in, suffix, strlen (suffix)))
9147 warning_at (location, 0, "integer suffix %qs"
9148 " shadowed by implementation", suffix);
9149 }
9150 else if (long_double_p)
9151 {
9152 if (cpp_interpret_float_suffix (parse_in, suffix, strlen (suffix)))
9153 warning_at (location, 0, "floating point suffix %qs"
9154 " shadowed by implementation", suffix);
9155 }
9156 /* 17.6.3.3.5 */
9157 if (suffix[0] != '_'
9158 && !in_system_header_at (location)
9159 && !current_function_decl && !(friendp && !funcdef_flag))
9160 warning_at (location, OPT_Wliteral_suffix,
9161 "literal operator suffixes not preceded by %<_%>"
9162 " are reserved for future standardization");
9163 }
9164 else
9165 {
9166 error_at (location, "%qD must be a non-member function", decl);
9167 return NULL_TREE;
9168 }
9169 }
9170
9171 if (funcdef_flag)
9172 /* Make the init_value nonzero so pushdecl knows this is not
9173 tentative. error_mark_node is replaced later with the BLOCK. */
9174 DECL_INITIAL (decl) = error_mark_node;
9175
9176 if (TYPE_NOTHROW_P (type) || nothrow_libfn_p (decl))
9177 TREE_NOTHROW (decl) = 1;
9178
9179 if (flag_openmp || flag_openmp_simd)
9180 {
9181 /* Adjust "omp declare simd" attributes. */
9182 tree ods = lookup_attribute ("omp declare simd", *attrlist);
9183 if (ods)
9184 {
9185 tree attr;
9186 for (attr = ods; attr;
9187 attr = lookup_attribute ("omp declare simd", TREE_CHAIN (attr)))
9188 {
9189 if (TREE_CODE (type) == METHOD_TYPE)
9190 walk_tree (&TREE_VALUE (attr), declare_simd_adjust_this,
9191 DECL_ARGUMENTS (decl), NULL);
9192 if (TREE_VALUE (attr) != NULL_TREE)
9193 {
9194 tree cl = TREE_VALUE (TREE_VALUE (attr));
9195 cl = c_omp_declare_simd_clauses_to_numbers
9196 (DECL_ARGUMENTS (decl), cl);
9197 if (cl)
9198 TREE_VALUE (TREE_VALUE (attr)) = cl;
9199 else
9200 TREE_VALUE (attr) = NULL_TREE;
9201 }
9202 }
9203 }
9204 }
9205
9206 /* Caller will do the rest of this. */
9207 if (check < 0)
9208 return decl;
9209
9210 if (ctype != NULL_TREE)
9211 grokclassfn (ctype, decl, flags);
9212
9213 /* 12.4/3 */
9214 if (cxx_dialect >= cxx11
9215 && DECL_DESTRUCTOR_P (decl)
9216 && !TYPE_BEING_DEFINED (DECL_CONTEXT (decl))
9217 && !processing_template_decl)
9218 deduce_noexcept_on_destructor (decl);
9219
9220 decl = check_explicit_specialization (orig_declarator, decl,
9221 template_count,
9222 2 * funcdef_flag +
9223 4 * (friendp != 0) +
9224 8 * concept_p,
9225 *attrlist);
9226 if (decl == error_mark_node)
9227 return NULL_TREE;
9228
9229 if (DECL_STATIC_FUNCTION_P (decl))
9230 check_static_quals (decl, quals);
9231
9232 if (attrlist)
9233 {
9234 cplus_decl_attributes (&decl, *attrlist, 0);
9235 *attrlist = NULL_TREE;
9236 }
9237
9238 /* Check main's type after attributes have been applied. */
9239 if (ctype == NULL_TREE && DECL_MAIN_P (decl))
9240 {
9241 if (!same_type_p (TREE_TYPE (TREE_TYPE (decl)),
9242 integer_type_node))
9243 {
9244 tree oldtypeargs = TYPE_ARG_TYPES (TREE_TYPE (decl));
9245 tree newtype;
9246 error_at (declspecs->locations[ds_type_spec],
9247 "%<::main%> must return %<int%>");
9248 newtype = build_function_type (integer_type_node, oldtypeargs);
9249 TREE_TYPE (decl) = newtype;
9250 }
9251 if (warn_main)
9252 check_main_parameter_types (decl);
9253 }
9254
9255 if (ctype != NULL_TREE && check)
9256 {
9257 tree old_decl = check_classfn (ctype, decl,
9258 (processing_template_decl
9259 > template_class_depth (ctype))
9260 ? current_template_parms
9261 : NULL_TREE);
9262
9263 if (old_decl == error_mark_node)
9264 return NULL_TREE;
9265
9266 if (old_decl)
9267 {
9268 tree ok;
9269 tree pushed_scope;
9270
9271 if (TREE_CODE (old_decl) == TEMPLATE_DECL)
9272 /* Because grokfndecl is always supposed to return a
9273 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
9274 here. We depend on our callers to figure out that its
9275 really a template that's being returned. */
9276 old_decl = DECL_TEMPLATE_RESULT (old_decl);
9277
9278 if (DECL_STATIC_FUNCTION_P (old_decl)
9279 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE)
9280 {
9281 /* Remove the `this' parm added by grokclassfn. */
9282 revert_static_member_fn (decl);
9283 check_static_quals (decl, quals);
9284 }
9285 if (DECL_ARTIFICIAL (old_decl))
9286 {
9287 error ("definition of implicitly-declared %qD", old_decl);
9288 return NULL_TREE;
9289 }
9290 else if (DECL_DEFAULTED_FN (old_decl))
9291 {
9292 error ("definition of explicitly-defaulted %q+D", decl);
9293 inform (DECL_SOURCE_LOCATION (old_decl),
9294 "%q#D explicitly defaulted here", old_decl);
9295 return NULL_TREE;
9296 }
9297
9298 /* Since we've smashed OLD_DECL to its
9299 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
9300 if (TREE_CODE (decl) == TEMPLATE_DECL)
9301 decl = DECL_TEMPLATE_RESULT (decl);
9302
9303 /* Attempt to merge the declarations. This can fail, in
9304 the case of some invalid specialization declarations. */
9305 pushed_scope = push_scope (ctype);
9306 ok = duplicate_decls (decl, old_decl, friendp);
9307 if (pushed_scope)
9308 pop_scope (pushed_scope);
9309 if (!ok)
9310 {
9311 error ("no %q#D member function declared in class %qT",
9312 decl, ctype);
9313 return NULL_TREE;
9314 }
9315 if (ok == error_mark_node)
9316 return NULL_TREE;
9317 return old_decl;
9318 }
9319 }
9320
9321 if (DECL_CONSTRUCTOR_P (decl) && !grok_ctor_properties (ctype, decl))
9322 return NULL_TREE;
9323
9324 if (ctype == NULL_TREE || check)
9325 return decl;
9326
9327 if (virtualp)
9328 DECL_VIRTUAL_P (decl) = 1;
9329
9330 return decl;
9331 }
9332
9333 /* decl is a FUNCTION_DECL.
9334 specifiers are the parsed virt-specifiers.
9335
9336 Set flags to reflect the virt-specifiers.
9337
9338 Returns decl. */
9339
9340 static tree
set_virt_specifiers(tree decl,cp_virt_specifiers specifiers)9341 set_virt_specifiers (tree decl, cp_virt_specifiers specifiers)
9342 {
9343 if (decl == NULL_TREE)
9344 return decl;
9345 if (specifiers & VIRT_SPEC_OVERRIDE)
9346 DECL_OVERRIDE_P (decl) = 1;
9347 if (specifiers & VIRT_SPEC_FINAL)
9348 DECL_FINAL_P (decl) = 1;
9349 return decl;
9350 }
9351
9352 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
9353 the linkage that DECL will receive in the object file. */
9354
9355 static void
set_linkage_for_static_data_member(tree decl)9356 set_linkage_for_static_data_member (tree decl)
9357 {
9358 /* A static data member always has static storage duration and
9359 external linkage. Note that static data members are forbidden in
9360 local classes -- the only situation in which a class has
9361 non-external linkage. */
9362 TREE_PUBLIC (decl) = 1;
9363 TREE_STATIC (decl) = 1;
9364 /* For non-template classes, static data members are always put
9365 out in exactly those files where they are defined, just as
9366 with ordinary namespace-scope variables. */
9367 if (!processing_template_decl)
9368 DECL_INTERFACE_KNOWN (decl) = 1;
9369 }
9370
9371 /* Create a VAR_DECL named NAME with the indicated TYPE.
9372
9373 If SCOPE is non-NULL, it is the class type or namespace containing
9374 the variable. If SCOPE is NULL, the variable should is created in
9375 the innermost enclosing scope. */
9376
9377 static tree
grokvardecl(tree type,tree name,tree orig_declarator,const cp_decl_specifier_seq * declspecs,int initialized,int type_quals,int inlinep,bool conceptp,int template_count,tree scope,location_t location)9378 grokvardecl (tree type,
9379 tree name,
9380 tree orig_declarator,
9381 const cp_decl_specifier_seq *declspecs,
9382 int initialized,
9383 int type_quals,
9384 int inlinep,
9385 bool conceptp,
9386 int template_count,
9387 tree scope,
9388 location_t location)
9389 {
9390 tree decl;
9391 tree explicit_scope;
9392
9393 gcc_assert (!name || identifier_p (name));
9394
9395 bool constp = (type_quals & TYPE_QUAL_CONST) != 0;
9396 bool volatilep = (type_quals & TYPE_QUAL_VOLATILE) != 0;
9397
9398 /* Compute the scope in which to place the variable, but remember
9399 whether or not that scope was explicitly specified by the user. */
9400 explicit_scope = scope;
9401 if (!scope)
9402 {
9403 /* An explicit "extern" specifier indicates a namespace-scope
9404 variable. */
9405 if (declspecs->storage_class == sc_extern)
9406 scope = current_decl_namespace ();
9407 else if (!at_function_scope_p ())
9408 scope = current_scope ();
9409 }
9410
9411 if (scope
9412 && (/* If the variable is a namespace-scope variable declared in a
9413 template, we need DECL_LANG_SPECIFIC. */
9414 (TREE_CODE (scope) == NAMESPACE_DECL && processing_template_decl)
9415 /* Similarly for namespace-scope variables with language linkage
9416 other than C++. */
9417 || (TREE_CODE (scope) == NAMESPACE_DECL
9418 && current_lang_name != lang_name_cplusplus)
9419 /* Similarly for static data members. */
9420 || TYPE_P (scope)
9421 /* Similarly for explicit specializations. */
9422 || (orig_declarator
9423 && TREE_CODE (orig_declarator) == TEMPLATE_ID_EXPR)))
9424 decl = build_lang_decl_loc (location, VAR_DECL, name, type);
9425 else
9426 decl = build_decl (location, VAR_DECL, name, type);
9427
9428 if (explicit_scope && TREE_CODE (explicit_scope) == NAMESPACE_DECL)
9429 set_decl_namespace (decl, explicit_scope, 0);
9430 else
9431 DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
9432
9433 if (declspecs->storage_class == sc_extern)
9434 {
9435 DECL_THIS_EXTERN (decl) = 1;
9436 DECL_EXTERNAL (decl) = !initialized;
9437 }
9438
9439 if (DECL_CLASS_SCOPE_P (decl))
9440 {
9441 set_linkage_for_static_data_member (decl);
9442 /* This function is only called with out-of-class definitions. */
9443 DECL_EXTERNAL (decl) = 0;
9444 check_class_member_definition_namespace (decl);
9445 }
9446 /* At top level, either `static' or no s.c. makes a definition
9447 (perhaps tentative), and absence of `static' makes it public. */
9448 else if (toplevel_bindings_p ())
9449 {
9450 TREE_PUBLIC (decl) = (declspecs->storage_class != sc_static
9451 && (DECL_THIS_EXTERN (decl)
9452 || ! constp
9453 || volatilep
9454 || inlinep));
9455 TREE_STATIC (decl) = ! DECL_EXTERNAL (decl);
9456 }
9457 /* Not at top level, only `static' makes a static definition. */
9458 else
9459 {
9460 TREE_STATIC (decl) = declspecs->storage_class == sc_static;
9461 TREE_PUBLIC (decl) = DECL_EXTERNAL (decl);
9462 }
9463
9464 if (decl_spec_seq_has_spec_p (declspecs, ds_thread))
9465 {
9466 if (DECL_EXTERNAL (decl) || TREE_STATIC (decl))
9467 {
9468 CP_DECL_THREAD_LOCAL_P (decl) = true;
9469 if (!processing_template_decl)
9470 set_decl_tls_model (decl, decl_default_tls_model (decl));
9471 }
9472 if (declspecs->gnu_thread_keyword_p)
9473 SET_DECL_GNU_TLS_P (decl);
9474 }
9475
9476 /* If the type of the decl has no linkage, make sure that we'll
9477 notice that in mark_used. */
9478 if (cxx_dialect > cxx98
9479 && decl_linkage (decl) != lk_none
9480 && DECL_LANG_SPECIFIC (decl) == NULL
9481 && !DECL_EXTERN_C_P (decl)
9482 && no_linkage_check (TREE_TYPE (decl), /*relaxed_p=*/false))
9483 retrofit_lang_decl (decl);
9484
9485 if (TREE_PUBLIC (decl))
9486 {
9487 /* [basic.link]: A name with no linkage (notably, the name of a class
9488 or enumeration declared in a local scope) shall not be used to
9489 declare an entity with linkage.
9490
9491 DR 757 relaxes this restriction for C++0x. */
9492 if (cxx_dialect < cxx11)
9493 no_linkage_error (decl);
9494 }
9495 else
9496 DECL_INTERFACE_KNOWN (decl) = 1;
9497
9498 if (DECL_NAME (decl)
9499 && MAIN_NAME_P (DECL_NAME (decl))
9500 && scope == global_namespace)
9501 error ("cannot declare %<::main%> to be a global variable");
9502
9503 /* Check that the variable can be safely declared as a concept.
9504 Note that this also forbids explicit specializations. */
9505 if (conceptp)
9506 {
9507 if (!processing_template_decl)
9508 {
9509 error_at (declspecs->locations[ds_concept],
9510 "a non-template variable cannot be %<concept%>");
9511 return NULL_TREE;
9512 }
9513 else
9514 DECL_DECLARED_CONCEPT_P (decl) = true;
9515 if (!same_type_ignoring_top_level_qualifiers_p (type, boolean_type_node))
9516 error_at (declspecs->locations[ds_type_spec],
9517 "concept must have type %<bool%>");
9518 }
9519 else if (flag_concepts
9520 && processing_template_decl > template_class_depth (scope))
9521 {
9522 tree reqs = TEMPLATE_PARMS_CONSTRAINTS (current_template_parms);
9523 tree ci = build_constraints (reqs, NULL_TREE);
9524 set_constraints (decl, ci);
9525 }
9526
9527 // Handle explicit specializations and instantiations of variable templates.
9528 if (orig_declarator)
9529 decl = check_explicit_specialization (orig_declarator, decl,
9530 template_count, conceptp * 8);
9531
9532 return decl != error_mark_node ? decl : NULL_TREE;
9533 }
9534
9535 /* Create and return a canonical pointer to member function type, for
9536 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
9537
9538 tree
build_ptrmemfunc_type(tree type)9539 build_ptrmemfunc_type (tree type)
9540 {
9541 tree field, fields;
9542 tree t;
9543
9544 if (type == error_mark_node)
9545 return type;
9546
9547 /* Make sure that we always have the unqualified pointer-to-member
9548 type first. */
9549 if (cp_cv_quals quals = cp_type_quals (type))
9550 {
9551 tree unqual = build_ptrmemfunc_type (TYPE_MAIN_VARIANT (type));
9552 return cp_build_qualified_type (unqual, quals);
9553 }
9554
9555 /* If a canonical type already exists for this type, use it. We use
9556 this method instead of type_hash_canon, because it only does a
9557 simple equality check on the list of field members. */
9558
9559 t = TYPE_PTRMEMFUNC_TYPE (type);
9560 if (t)
9561 return t;
9562
9563 t = make_node (RECORD_TYPE);
9564
9565 /* Let the front end know this is a pointer to member function. */
9566 TYPE_PTRMEMFUNC_FLAG (t) = 1;
9567
9568 field = build_decl (input_location, FIELD_DECL, pfn_identifier, type);
9569 DECL_NONADDRESSABLE_P (field) = 1;
9570 fields = field;
9571
9572 field = build_decl (input_location, FIELD_DECL, delta_identifier,
9573 delta_type_node);
9574 DECL_NONADDRESSABLE_P (field) = 1;
9575 DECL_CHAIN (field) = fields;
9576 fields = field;
9577
9578 finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
9579
9580 /* Zap out the name so that the back end will give us the debugging
9581 information for this anonymous RECORD_TYPE. */
9582 TYPE_NAME (t) = NULL_TREE;
9583
9584 /* Cache this pointer-to-member type so that we can find it again
9585 later. */
9586 TYPE_PTRMEMFUNC_TYPE (type) = t;
9587
9588 if (TYPE_STRUCTURAL_EQUALITY_P (type))
9589 SET_TYPE_STRUCTURAL_EQUALITY (t);
9590 else if (TYPE_CANONICAL (type) != type)
9591 TYPE_CANONICAL (t) = build_ptrmemfunc_type (TYPE_CANONICAL (type));
9592
9593 return t;
9594 }
9595
9596 /* Create and return a pointer to data member type. */
9597
9598 tree
build_ptrmem_type(tree class_type,tree member_type)9599 build_ptrmem_type (tree class_type, tree member_type)
9600 {
9601 if (TREE_CODE (member_type) == METHOD_TYPE)
9602 {
9603 cp_cv_quals quals = type_memfn_quals (member_type);
9604 cp_ref_qualifier rqual = type_memfn_rqual (member_type);
9605 member_type = build_memfn_type (member_type, class_type, quals, rqual);
9606 return build_ptrmemfunc_type (build_pointer_type (member_type));
9607 }
9608 else
9609 {
9610 gcc_assert (TREE_CODE (member_type) != FUNCTION_TYPE);
9611 return build_offset_type (class_type, member_type);
9612 }
9613 }
9614
9615 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
9616 Check to see that the definition is valid. Issue appropriate error
9617 messages. */
9618
9619 static void
check_static_variable_definition(tree decl,tree type)9620 check_static_variable_definition (tree decl, tree type)
9621 {
9622 /* Avoid redundant diagnostics on out-of-class definitions. */
9623 if (!current_class_type || !TYPE_BEING_DEFINED (current_class_type))
9624 ;
9625 /* Can't check yet if we don't know the type. */
9626 else if (dependent_type_p (type))
9627 ;
9628 /* If DECL is declared constexpr, we'll do the appropriate checks
9629 in check_initializer. Similarly for inline static data members. */
9630 else if (DECL_P (decl)
9631 && (DECL_DECLARED_CONSTEXPR_P (decl)
9632 || undeduced_auto_decl (decl)
9633 || DECL_VAR_DECLARED_INLINE_P (decl)))
9634 ;
9635 else if (cxx_dialect >= cxx11 && !INTEGRAL_OR_ENUMERATION_TYPE_P (type))
9636 {
9637 if (!COMPLETE_TYPE_P (type))
9638 error_at (DECL_SOURCE_LOCATION (decl),
9639 "in-class initialization of static data member %q#D of "
9640 "incomplete type", decl);
9641 else if (literal_type_p (type))
9642 permerror (DECL_SOURCE_LOCATION (decl),
9643 "%<constexpr%> needed for in-class initialization of "
9644 "static data member %q#D of non-integral type", decl);
9645 else
9646 error_at (DECL_SOURCE_LOCATION (decl),
9647 "in-class initialization of static data member %q#D of "
9648 "non-literal type", decl);
9649 }
9650 /* Motion 10 at San Diego: If a static const integral data member is
9651 initialized with an integral constant expression, the initializer
9652 may appear either in the declaration (within the class), or in
9653 the definition, but not both. If it appears in the class, the
9654 member is a member constant. The file-scope definition is always
9655 required. */
9656 else if (!ARITHMETIC_TYPE_P (type) && TREE_CODE (type) != ENUMERAL_TYPE)
9657 error_at (DECL_SOURCE_LOCATION (decl),
9658 "invalid in-class initialization of static data member "
9659 "of non-integral type %qT",
9660 type);
9661 else if (!CP_TYPE_CONST_P (type))
9662 error_at (DECL_SOURCE_LOCATION (decl),
9663 "ISO C++ forbids in-class initialization of non-const "
9664 "static member %qD",
9665 decl);
9666 else if (!INTEGRAL_OR_ENUMERATION_TYPE_P (type))
9667 pedwarn (DECL_SOURCE_LOCATION (decl), OPT_Wpedantic,
9668 "ISO C++ forbids initialization of member constant "
9669 "%qD of non-integral type %qT", decl, type);
9670 }
9671
9672 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
9673 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
9674 expressions out into temporary variables so that walk_tree doesn't
9675 step into them (c++/15764). */
9676
9677 static tree
stabilize_save_expr_r(tree * expr_p,int * walk_subtrees,void * data)9678 stabilize_save_expr_r (tree *expr_p, int *walk_subtrees, void *data)
9679 {
9680 hash_set<tree> *pset = (hash_set<tree> *)data;
9681 tree expr = *expr_p;
9682 if (TREE_CODE (expr) == SAVE_EXPR)
9683 {
9684 tree op = TREE_OPERAND (expr, 0);
9685 cp_walk_tree (&op, stabilize_save_expr_r, data, pset);
9686 if (TREE_SIDE_EFFECTS (op))
9687 TREE_OPERAND (expr, 0) = get_temp_regvar (TREE_TYPE (op), op);
9688 *walk_subtrees = 0;
9689 }
9690 else if (!EXPR_P (expr) || !TREE_SIDE_EFFECTS (expr))
9691 *walk_subtrees = 0;
9692 return NULL;
9693 }
9694
9695 /* Entry point for the above. */
9696
9697 static void
stabilize_vla_size(tree size)9698 stabilize_vla_size (tree size)
9699 {
9700 hash_set<tree> pset;
9701 /* Break out any function calls into temporary variables. */
9702 cp_walk_tree (&size, stabilize_save_expr_r, &pset, &pset);
9703 }
9704
9705 /* Reduce a SIZEOF_EXPR to its value. */
9706
9707 tree
fold_sizeof_expr(tree t)9708 fold_sizeof_expr (tree t)
9709 {
9710 tree r;
9711 if (SIZEOF_EXPR_TYPE_P (t))
9712 r = cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (t, 0)),
9713 SIZEOF_EXPR, false, false);
9714 else if (TYPE_P (TREE_OPERAND (t, 0)))
9715 r = cxx_sizeof_or_alignof_type (TREE_OPERAND (t, 0), SIZEOF_EXPR,
9716 false, false);
9717 else
9718 r = cxx_sizeof_or_alignof_expr (TREE_OPERAND (t, 0), SIZEOF_EXPR,
9719 false);
9720 if (r == error_mark_node)
9721 r = size_one_node;
9722 return r;
9723 }
9724
9725 /* Given the SIZE (i.e., number of elements) in an array, compute
9726 an appropriate index type for the array. If non-NULL, NAME is
9727 the name of the entity being declared. */
9728
9729 static tree
compute_array_index_type_loc(location_t name_loc,tree name,tree size,tsubst_flags_t complain)9730 compute_array_index_type_loc (location_t name_loc, tree name, tree size,
9731 tsubst_flags_t complain)
9732 {
9733 if (error_operand_p (size))
9734 return error_mark_node;
9735
9736 /* The type of the index being computed. */
9737 tree itype;
9738
9739 /* The original numeric size as seen in the source code before
9740 conversion to size_t. */
9741 tree origsize = size;
9742
9743 location_t loc = cp_expr_loc_or_loc (size, name ? name_loc : input_location);
9744
9745 if (!type_dependent_expression_p (size))
9746 {
9747 origsize = size = mark_rvalue_use (size);
9748
9749 if (cxx_dialect < cxx11 && TREE_CODE (size) == NOP_EXPR
9750 && TREE_SIDE_EFFECTS (size))
9751 /* In C++98, we mark a non-constant array bound with a magic
9752 NOP_EXPR with TREE_SIDE_EFFECTS; don't fold in that case. */;
9753 else
9754 {
9755 size = instantiate_non_dependent_expr_sfinae (size, complain);
9756 size = build_converted_constant_expr (size_type_node, size, complain);
9757 /* Pedantically a constant expression is required here and so
9758 __builtin_is_constant_evaluated () should fold to true if it
9759 is successfully folded into a constant. */
9760 size = maybe_constant_value (size, NULL_TREE,
9761 /*manifestly_const_eval=*/true);
9762
9763 if (!TREE_CONSTANT (size))
9764 size = origsize;
9765 }
9766
9767 if (error_operand_p (size))
9768 return error_mark_node;
9769
9770 /* The array bound must be an integer type. */
9771 tree type = TREE_TYPE (size);
9772 if (!INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P (type))
9773 {
9774 if (!(complain & tf_error))
9775 return error_mark_node;
9776 if (name)
9777 error_at (loc, "size of array %qD has non-integral type %qT",
9778 name, type);
9779 else
9780 error_at (loc, "size of array has non-integral type %qT", type);
9781 size = integer_one_node;
9782 }
9783 }
9784
9785 /* A type is dependent if it is...an array type constructed from any
9786 dependent type or whose size is specified by a constant expression
9787 that is value-dependent. */
9788 /* We can only call value_dependent_expression_p on integral constant
9789 expressions; treat non-constant expressions as dependent, too. */
9790 if (processing_template_decl
9791 && (type_dependent_expression_p (size)
9792 || !TREE_CONSTANT (size) || value_dependent_expression_p (size)))
9793 {
9794 /* We cannot do any checking for a SIZE that isn't known to be
9795 constant. Just build the index type and mark that it requires
9796 structural equality checks. */
9797 itype = build_index_type (build_min (MINUS_EXPR, sizetype,
9798 size, size_one_node));
9799 TYPE_DEPENDENT_P (itype) = 1;
9800 TYPE_DEPENDENT_P_VALID (itype) = 1;
9801 SET_TYPE_STRUCTURAL_EQUALITY (itype);
9802 return itype;
9803 }
9804
9805 if (TREE_CODE (size) != INTEGER_CST)
9806 {
9807 tree folded = cp_fully_fold (size);
9808 if (TREE_CODE (folded) == INTEGER_CST)
9809 {
9810 if (name)
9811 pedwarn (loc, OPT_Wpedantic, "size of array %qD is not an "
9812 "integral constant-expression", name);
9813 else
9814 pedwarn (loc, OPT_Wpedantic,
9815 "size of array is not an integral constant-expression");
9816 }
9817 /* Use the folded result for VLAs, too; it will have resolved
9818 SIZEOF_EXPR. */
9819 size = folded;
9820 }
9821
9822 /* Normally, the array-bound will be a constant. */
9823 if (TREE_CODE (size) == INTEGER_CST)
9824 {
9825 /* The size to use in diagnostics that reflects the constant
9826 size used in the source, rather than SIZE massaged above. */
9827 tree diagsize = size;
9828
9829 /* If the original size before conversion to size_t was signed
9830 and negative, convert it to ssizetype to restore the sign. */
9831 if (!TYPE_UNSIGNED (TREE_TYPE (origsize))
9832 && TREE_CODE (size) == INTEGER_CST
9833 && tree_int_cst_sign_bit (size))
9834 {
9835 diagsize = fold_convert (ssizetype, size);
9836
9837 /* Clear the overflow bit that may have been set as a result
9838 of the conversion from the sizetype of the new size to
9839 ssizetype. */
9840 TREE_OVERFLOW (diagsize) = false;
9841 }
9842
9843 /* Verify that the array has a positive number of elements
9844 and issue the appropriate diagnostic if it doesn't. */
9845 if (!valid_array_size_p (loc, diagsize, name, (complain & tf_error)))
9846 {
9847 if (!(complain & tf_error))
9848 return error_mark_node;
9849 size = integer_one_node;
9850 }
9851 /* As an extension we allow zero-sized arrays. */
9852 else if (integer_zerop (size))
9853 {
9854 if (!(complain & tf_error))
9855 /* We must fail if performing argument deduction (as
9856 indicated by the state of complain), so that
9857 another substitution can be found. */
9858 return error_mark_node;
9859 else if (in_system_header_at (input_location))
9860 /* Allow them in system headers because glibc uses them. */;
9861 else if (name)
9862 pedwarn (loc, OPT_Wpedantic,
9863 "ISO C++ forbids zero-size array %qD", name);
9864 else
9865 pedwarn (loc, OPT_Wpedantic,
9866 "ISO C++ forbids zero-size array");
9867 }
9868 }
9869 else if (TREE_CONSTANT (size)
9870 /* We don't allow VLAs at non-function scopes, or during
9871 tentative template substitution. */
9872 || !at_function_scope_p ()
9873 || !(complain & tf_error))
9874 {
9875 if (!(complain & tf_error))
9876 return error_mark_node;
9877 /* `(int) &fn' is not a valid array bound. */
9878 if (name)
9879 error_at (loc,
9880 "size of array %qD is not an integral constant-expression",
9881 name);
9882 else
9883 error_at (loc, "size of array is not an integral constant-expression");
9884 size = integer_one_node;
9885 }
9886 else if (pedantic && warn_vla != 0)
9887 {
9888 if (name)
9889 pedwarn (name_loc, OPT_Wvla,
9890 "ISO C++ forbids variable length array %qD", name);
9891 else
9892 pedwarn (input_location, OPT_Wvla,
9893 "ISO C++ forbids variable length array");
9894 }
9895 else if (warn_vla > 0)
9896 {
9897 if (name)
9898 warning_at (name_loc, OPT_Wvla,
9899 "variable length array %qD is used", name);
9900 else
9901 warning (OPT_Wvla,
9902 "variable length array is used");
9903 }
9904
9905 if (processing_template_decl && !TREE_CONSTANT (size))
9906 /* A variable sized array. */
9907 itype = build_min (MINUS_EXPR, sizetype, size, integer_one_node);
9908 else
9909 {
9910 /* Compute the index of the largest element in the array. It is
9911 one less than the number of elements in the array. We save
9912 and restore PROCESSING_TEMPLATE_DECL so that computations in
9913 cp_build_binary_op will be appropriately folded. */
9914 {
9915 processing_template_decl_sentinel s;
9916 itype = cp_build_binary_op (input_location,
9917 MINUS_EXPR,
9918 cp_convert (ssizetype, size, complain),
9919 cp_convert (ssizetype, integer_one_node,
9920 complain),
9921 complain);
9922 itype = maybe_constant_value (itype);
9923 }
9924
9925 if (!TREE_CONSTANT (itype))
9926 {
9927 /* A variable sized array. */
9928 itype = variable_size (itype);
9929
9930 stabilize_vla_size (itype);
9931
9932 if (sanitize_flags_p (SANITIZE_VLA)
9933 && current_function_decl != NULL_TREE)
9934 {
9935 /* We have to add 1 -- in the ubsan routine we generate
9936 LE_EXPR rather than LT_EXPR. */
9937 tree t = fold_build2 (PLUS_EXPR, TREE_TYPE (itype), itype,
9938 build_one_cst (TREE_TYPE (itype)));
9939 t = ubsan_instrument_vla (input_location, t);
9940 finish_expr_stmt (t);
9941 }
9942 }
9943 /* Make sure that there was no overflow when creating to a signed
9944 index type. (For example, on a 32-bit machine, an array with
9945 size 2^32 - 1 is too big.) */
9946 else if (TREE_CODE (itype) == INTEGER_CST
9947 && TREE_OVERFLOW (itype))
9948 {
9949 if (!(complain & tf_error))
9950 return error_mark_node;
9951 error ("overflow in array dimension");
9952 TREE_OVERFLOW (itype) = 0;
9953 }
9954 }
9955
9956 /* Create and return the appropriate index type. */
9957 itype = build_index_type (itype);
9958
9959 /* If the index type were dependent, we would have returned early, so
9960 remember that it isn't. */
9961 TYPE_DEPENDENT_P (itype) = 0;
9962 TYPE_DEPENDENT_P_VALID (itype) = 1;
9963 return itype;
9964 }
9965
9966 tree
compute_array_index_type(tree name,tree size,tsubst_flags_t complain)9967 compute_array_index_type (tree name, tree size, tsubst_flags_t complain)
9968 {
9969 return compute_array_index_type_loc (input_location, name, size, complain);
9970 }
9971
9972 /* Returns the scope (if any) in which the entity declared by
9973 DECLARATOR will be located. If the entity was declared with an
9974 unqualified name, NULL_TREE is returned. */
9975
9976 tree
get_scope_of_declarator(const cp_declarator * declarator)9977 get_scope_of_declarator (const cp_declarator *declarator)
9978 {
9979 while (declarator && declarator->kind != cdk_id)
9980 declarator = declarator->declarator;
9981
9982 /* If the declarator-id is a SCOPE_REF, the scope in which the
9983 declaration occurs is the first operand. */
9984 if (declarator
9985 && declarator->u.id.qualifying_scope)
9986 return declarator->u.id.qualifying_scope;
9987
9988 /* Otherwise, the declarator is not a qualified name; the entity will
9989 be declared in the current scope. */
9990 return NULL_TREE;
9991 }
9992
9993 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
9994 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
9995 with this type. */
9996
9997 static tree
create_array_type_for_decl(tree name,tree type,tree size,location_t loc)9998 create_array_type_for_decl (tree name, tree type, tree size, location_t loc)
9999 {
10000 tree itype = NULL_TREE;
10001
10002 /* If things have already gone awry, bail now. */
10003 if (type == error_mark_node || size == error_mark_node)
10004 return error_mark_node;
10005
10006 /* 8.3.4/1: If the type of the identifier of D contains the auto
10007 type-specifier, the program is ill-formed. */
10008 if (type_uses_auto (type))
10009 {
10010 if (name)
10011 error_at (loc, "%qD declared as array of %qT", name, type);
10012 else
10013 error ("creating array of %qT", type);
10014 return error_mark_node;
10015 }
10016
10017 /* If there are some types which cannot be array elements,
10018 issue an error-message and return. */
10019 switch (TREE_CODE (type))
10020 {
10021 case VOID_TYPE:
10022 if (name)
10023 error_at (loc, "declaration of %qD as array of void", name);
10024 else
10025 error ("creating array of void");
10026 return error_mark_node;
10027
10028 case FUNCTION_TYPE:
10029 if (name)
10030 error_at (loc, "declaration of %qD as array of functions", name);
10031 else
10032 error ("creating array of functions");
10033 return error_mark_node;
10034
10035 case REFERENCE_TYPE:
10036 if (name)
10037 error_at (loc, "declaration of %qD as array of references", name);
10038 else
10039 error ("creating array of references");
10040 return error_mark_node;
10041
10042 case METHOD_TYPE:
10043 if (name)
10044 error_at (loc, "declaration of %qD as array of function members",
10045 name);
10046 else
10047 error ("creating array of function members");
10048 return error_mark_node;
10049
10050 default:
10051 break;
10052 }
10053
10054 /* [dcl.array]
10055
10056 The constant expressions that specify the bounds of the arrays
10057 can be omitted only for the first member of the sequence. */
10058 if (TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type))
10059 {
10060 if (name)
10061 error_at (loc, "declaration of %qD as multidimensional array must "
10062 "have bounds for all dimensions except the first",
10063 name);
10064 else
10065 error ("multidimensional array must have bounds for all "
10066 "dimensions except the first");
10067
10068 return error_mark_node;
10069 }
10070
10071 /* Figure out the index type for the array. */
10072 if (size)
10073 itype = compute_array_index_type_loc (loc, name, size,
10074 tf_warning_or_error);
10075
10076 /* [dcl.array]
10077 T is called the array element type; this type shall not be [...] an
10078 abstract class type. */
10079 abstract_virtuals_error (name, type);
10080
10081 return build_cplus_array_type (type, itype);
10082 }
10083
10084 /* Returns the smallest location that is not UNKNOWN_LOCATION. */
10085
10086 static location_t
min_location(location_t loca,location_t locb)10087 min_location (location_t loca, location_t locb)
10088 {
10089 if (loca == UNKNOWN_LOCATION
10090 || (locb != UNKNOWN_LOCATION
10091 && linemap_location_before_p (line_table, locb, loca)))
10092 return locb;
10093 return loca;
10094 }
10095
10096 /* Returns the smallest location != UNKNOWN_LOCATION among the
10097 three stored in LOCATIONS[ds_const], LOCATIONS[ds_volatile],
10098 and LOCATIONS[ds_restrict]. */
10099
10100 static location_t
smallest_type_quals_location(int type_quals,const location_t * locations)10101 smallest_type_quals_location (int type_quals, const location_t* locations)
10102 {
10103 location_t loc = UNKNOWN_LOCATION;
10104
10105 if (type_quals & TYPE_QUAL_CONST)
10106 loc = locations[ds_const];
10107
10108 if (type_quals & TYPE_QUAL_VOLATILE)
10109 loc = min_location (loc, locations[ds_volatile]);
10110
10111 if (type_quals & TYPE_QUAL_RESTRICT)
10112 loc = min_location (loc, locations[ds_restrict]);
10113
10114 return loc;
10115 }
10116
10117 /* Check that it's OK to declare a function with the indicated TYPE
10118 and TYPE_QUALS. SFK indicates the kind of special function (if any)
10119 that this function is. OPTYPE is the type given in a conversion
10120 operator declaration, or the class type for a constructor/destructor.
10121 Returns the actual return type of the function; that may be different
10122 than TYPE if an error occurs, or for certain special functions. */
10123
10124 static tree
check_special_function_return_type(special_function_kind sfk,tree type,tree optype,int type_quals,const location_t * locations)10125 check_special_function_return_type (special_function_kind sfk,
10126 tree type,
10127 tree optype,
10128 int type_quals,
10129 const location_t* locations)
10130 {
10131 switch (sfk)
10132 {
10133 case sfk_constructor:
10134 if (type)
10135 error ("return type specification for constructor invalid");
10136 else if (type_quals != TYPE_UNQUALIFIED)
10137 error_at (smallest_type_quals_location (type_quals, locations),
10138 "qualifiers are not allowed on constructor declaration");
10139
10140 if (targetm.cxx.cdtor_returns_this ())
10141 type = build_pointer_type (optype);
10142 else
10143 type = void_type_node;
10144 break;
10145
10146 case sfk_destructor:
10147 if (type)
10148 error ("return type specification for destructor invalid");
10149 else if (type_quals != TYPE_UNQUALIFIED)
10150 error_at (smallest_type_quals_location (type_quals, locations),
10151 "qualifiers are not allowed on destructor declaration");
10152
10153 /* We can't use the proper return type here because we run into
10154 problems with ambiguous bases and covariant returns. */
10155 if (targetm.cxx.cdtor_returns_this ())
10156 type = build_pointer_type (void_type_node);
10157 else
10158 type = void_type_node;
10159 break;
10160
10161 case sfk_conversion:
10162 if (type)
10163 error ("return type specified for %<operator %T%>", optype);
10164 else if (type_quals != TYPE_UNQUALIFIED)
10165 error_at (smallest_type_quals_location (type_quals, locations),
10166 "qualifiers are not allowed on declaration of "
10167 "%<operator %T%>", optype);
10168
10169 type = optype;
10170 break;
10171
10172 case sfk_deduction_guide:
10173 if (type)
10174 error ("return type specified for deduction guide");
10175 else if (type_quals != TYPE_UNQUALIFIED)
10176 error_at (smallest_type_quals_location (type_quals, locations),
10177 "qualifiers are not allowed on declaration of "
10178 "deduction guide");
10179 if (TREE_CODE (optype) == TEMPLATE_TEMPLATE_PARM)
10180 {
10181 error ("template template parameter %qT in declaration of "
10182 "deduction guide", optype);
10183 type = error_mark_node;
10184 }
10185 else
10186 type = make_template_placeholder (CLASSTYPE_TI_TEMPLATE (optype));
10187 for (int i = 0; i < ds_last; ++i)
10188 if (i != ds_explicit && locations[i])
10189 error_at (locations[i],
10190 "decl-specifier in declaration of deduction guide");
10191 break;
10192
10193 default:
10194 gcc_unreachable ();
10195 }
10196
10197 return type;
10198 }
10199
10200 /* A variable or data member (whose unqualified name is IDENTIFIER)
10201 has been declared with the indicated TYPE. If the TYPE is not
10202 acceptable, issue an error message and return a type to use for
10203 error-recovery purposes. */
10204
10205 tree
check_var_type(tree identifier,tree type)10206 check_var_type (tree identifier, tree type)
10207 {
10208 if (VOID_TYPE_P (type))
10209 {
10210 if (!identifier)
10211 error ("unnamed variable or field declared void");
10212 else if (identifier_p (identifier))
10213 {
10214 gcc_assert (!IDENTIFIER_ANY_OP_P (identifier));
10215 error ("variable or field %qE declared void", identifier);
10216 }
10217 else
10218 error ("variable or field declared void");
10219 type = error_mark_node;
10220 }
10221
10222 return type;
10223 }
10224
10225 /* Handle declaring DECL as an inline variable. */
10226
10227 static void
mark_inline_variable(tree decl,location_t loc)10228 mark_inline_variable (tree decl, location_t loc)
10229 {
10230 bool inlinep = true;
10231 if (! toplevel_bindings_p ())
10232 {
10233 error_at (loc, "%<inline%> specifier invalid for variable "
10234 "%qD declared at block scope", decl);
10235 inlinep = false;
10236 }
10237 else if (cxx_dialect < cxx17)
10238 pedwarn (loc, 0, "inline variables are only available "
10239 "with %<-std=c++17%> or %<-std=gnu++17%>");
10240 if (inlinep)
10241 {
10242 retrofit_lang_decl (decl);
10243 SET_DECL_VAR_DECLARED_INLINE_P (decl);
10244 }
10245 }
10246
10247
10248 /* Assign a typedef-given name to a class or enumeration type declared
10249 as anonymous at first. This was split out of grokdeclarator
10250 because it is also used in libcc1. */
10251
10252 void
name_unnamed_type(tree type,tree decl)10253 name_unnamed_type (tree type, tree decl)
10254 {
10255 gcc_assert (TYPE_UNNAMED_P (type));
10256
10257 /* Replace the anonymous name with the real name everywhere. */
10258 for (tree t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
10259 {
10260 if (anon_aggrname_p (TYPE_IDENTIFIER (t)))
10261 /* We do not rename the debug info representing the
10262 unnamed tagged type because the standard says in
10263 [dcl.typedef] that the naming applies only for
10264 linkage purposes. */
10265 /*debug_hooks->set_name (t, decl);*/
10266 TYPE_NAME (t) = decl;
10267 }
10268
10269 if (TYPE_LANG_SPECIFIC (type))
10270 TYPE_WAS_UNNAMED (type) = 1;
10271
10272 /* If this is a typedef within a template class, the nested
10273 type is a (non-primary) template. The name for the
10274 template needs updating as well. */
10275 if (TYPE_LANG_SPECIFIC (type) && CLASSTYPE_TEMPLATE_INFO (type))
10276 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
10277 = TYPE_IDENTIFIER (type);
10278
10279 /* Adjust linkage now that we aren't unnamed anymore. */
10280 reset_type_linkage (type);
10281
10282 /* FIXME remangle member functions; member functions of a
10283 type with external linkage have external linkage. */
10284
10285 /* Check that our job is done, and that it would fail if we
10286 attempted to do it again. */
10287 gcc_assert (!TYPE_UNNAMED_P (type));
10288 }
10289
10290 /* Given declspecs and a declarator (abstract or otherwise), determine
10291 the name and type of the object declared and construct a DECL node
10292 for it.
10293
10294 DECLSPECS points to the representation of declaration-specifier
10295 sequence that precedes declarator.
10296
10297 DECL_CONTEXT says which syntactic context this declaration is in:
10298 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
10299 FUNCDEF for a function definition. Like NORMAL but a few different
10300 error messages in each case. Return value may be zero meaning
10301 this definition is too screwy to try to parse.
10302 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
10303 handle member functions (which have FIELD context).
10304 Return value may be zero meaning this definition is too screwy to
10305 try to parse.
10306 PARM for a parameter declaration (either within a function prototype
10307 or before a function body). Make a PARM_DECL, or return void_type_node.
10308 TPARM for a template parameter declaration.
10309 CATCHPARM for a parameter declaration before a catch clause.
10310 TYPENAME if for a typename (in a cast or sizeof).
10311 Don't make a DECL node; just return the ..._TYPE node.
10312 FIELD for a struct or union field; make a FIELD_DECL.
10313 BITFIELD for a field with specified width.
10314
10315 INITIALIZED is as for start_decl.
10316
10317 ATTRLIST is a pointer to the list of attributes, which may be NULL
10318 if there are none; *ATTRLIST may be modified if attributes from inside
10319 the declarator should be applied to the declaration.
10320
10321 When this function is called, scoping variables (such as
10322 CURRENT_CLASS_TYPE) should reflect the scope in which the
10323 declaration occurs, not the scope in which the new declaration will
10324 be placed. For example, on:
10325
10326 void S::f() { ... }
10327
10328 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
10329 should not be `S'.
10330
10331 Returns a DECL (if a declarator is present), a TYPE (if there is no
10332 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
10333 error occurs. */
10334
10335 tree
grokdeclarator(const cp_declarator * declarator,cp_decl_specifier_seq * declspecs,enum decl_context decl_context,int initialized,tree * attrlist)10336 grokdeclarator (const cp_declarator *declarator,
10337 cp_decl_specifier_seq *declspecs,
10338 enum decl_context decl_context,
10339 int initialized,
10340 tree* attrlist)
10341 {
10342 tree type = NULL_TREE;
10343 int longlong = 0;
10344 int explicit_intN = 0;
10345 int virtualp, explicitp, friendp, inlinep, staticp;
10346 int explicit_int = 0;
10347 int explicit_char = 0;
10348 int defaulted_int = 0;
10349
10350 tree typedef_decl = NULL_TREE;
10351 const char *name = NULL;
10352 tree typedef_type = NULL_TREE;
10353 /* True if this declarator is a function definition. */
10354 bool funcdef_flag = false;
10355 cp_declarator_kind innermost_code = cdk_error;
10356 int bitfield = 0;
10357 #if 0
10358 /* See the code below that used this. */
10359 tree decl_attr = NULL_TREE;
10360 #endif
10361
10362 /* Keep track of what sort of function is being processed
10363 so that we can warn about default return values, or explicit
10364 return values which do not match prescribed defaults. */
10365 special_function_kind sfk = sfk_none;
10366
10367 tree dname = NULL_TREE;
10368 tree ctor_return_type = NULL_TREE;
10369 enum overload_flags flags = NO_SPECIAL;
10370 /* cv-qualifiers that apply to the declarator, for a declaration of
10371 a member function. */
10372 cp_cv_quals memfn_quals = TYPE_UNQUALIFIED;
10373 /* virt-specifiers that apply to the declarator, for a declaration of
10374 a member function. */
10375 cp_virt_specifiers virt_specifiers = VIRT_SPEC_UNSPECIFIED;
10376 /* ref-qualifier that applies to the declarator, for a declaration of
10377 a member function. */
10378 cp_ref_qualifier rqual = REF_QUAL_NONE;
10379 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
10380 int type_quals = TYPE_UNQUALIFIED;
10381 tree raises = NULL_TREE;
10382 int template_count = 0;
10383 tree returned_attrs = NULL_TREE;
10384 tree parms = NULL_TREE;
10385 const cp_declarator *id_declarator;
10386 /* The unqualified name of the declarator; either an
10387 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
10388 tree unqualified_id;
10389 /* The class type, if any, in which this entity is located,
10390 or NULL_TREE if none. Note that this value may be different from
10391 the current class type; for example if an attempt is made to declare
10392 "A::f" inside "B", this value will be "A". */
10393 tree ctype = current_class_type;
10394 /* The NAMESPACE_DECL for the namespace in which this entity is
10395 located. If an unqualified name is used to declare the entity,
10396 this value will be NULL_TREE, even if the entity is located at
10397 namespace scope. */
10398 tree in_namespace = NULL_TREE;
10399 cp_storage_class storage_class;
10400 bool unsigned_p, signed_p, short_p, long_p, thread_p;
10401 bool type_was_error_mark_node = false;
10402 bool parameter_pack_p = declarator ? declarator->parameter_pack_p : false;
10403 bool template_type_arg = false;
10404 bool template_parm_flag = false;
10405 bool typedef_p = decl_spec_seq_has_spec_p (declspecs, ds_typedef);
10406 bool constexpr_p = decl_spec_seq_has_spec_p (declspecs, ds_constexpr);
10407 bool late_return_type_p = false;
10408 bool array_parameter_p = false;
10409 location_t saved_loc = input_location;
10410 tree reqs = NULL_TREE;
10411
10412 signed_p = decl_spec_seq_has_spec_p (declspecs, ds_signed);
10413 unsigned_p = decl_spec_seq_has_spec_p (declspecs, ds_unsigned);
10414 short_p = decl_spec_seq_has_spec_p (declspecs, ds_short);
10415 long_p = decl_spec_seq_has_spec_p (declspecs, ds_long);
10416 longlong = decl_spec_seq_has_spec_p (declspecs, ds_long_long);
10417 explicit_intN = declspecs->explicit_intN_p;
10418 thread_p = decl_spec_seq_has_spec_p (declspecs, ds_thread);
10419
10420 // Was concept_p specified? Note that ds_concept
10421 // implies ds_constexpr!
10422 bool concept_p = decl_spec_seq_has_spec_p (declspecs, ds_concept);
10423 if (concept_p)
10424 constexpr_p = true;
10425
10426 if (decl_spec_seq_has_spec_p (declspecs, ds_const))
10427 type_quals |= TYPE_QUAL_CONST;
10428 if (decl_spec_seq_has_spec_p (declspecs, ds_volatile))
10429 type_quals |= TYPE_QUAL_VOLATILE;
10430 if (decl_spec_seq_has_spec_p (declspecs, ds_restrict))
10431 type_quals |= TYPE_QUAL_RESTRICT;
10432
10433 if (decl_context == FUNCDEF)
10434 funcdef_flag = true, decl_context = NORMAL;
10435 else if (decl_context == MEMFUNCDEF)
10436 funcdef_flag = true, decl_context = FIELD;
10437 else if (decl_context == BITFIELD)
10438 bitfield = 1, decl_context = FIELD;
10439 else if (decl_context == TEMPLATE_TYPE_ARG)
10440 template_type_arg = true, decl_context = TYPENAME;
10441 else if (decl_context == TPARM)
10442 template_parm_flag = true, decl_context = PARM;
10443
10444 if (initialized > 1)
10445 funcdef_flag = true;
10446
10447 location_t typespec_loc = smallest_type_quals_location (type_quals,
10448 declspecs->locations);
10449 if (typespec_loc == UNKNOWN_LOCATION)
10450 typespec_loc = declspecs->locations[ds_type_spec];
10451 if (typespec_loc == UNKNOWN_LOCATION)
10452 typespec_loc = input_location;
10453
10454 /* Look inside a declarator for the name being declared
10455 and get it as a string, for an error message. */
10456 for (id_declarator = declarator;
10457 id_declarator;
10458 id_declarator = id_declarator->declarator)
10459 {
10460 if (id_declarator->kind != cdk_id)
10461 innermost_code = id_declarator->kind;
10462
10463 switch (id_declarator->kind)
10464 {
10465 case cdk_function:
10466 if (id_declarator->declarator
10467 && id_declarator->declarator->kind == cdk_id)
10468 {
10469 sfk = id_declarator->declarator->u.id.sfk;
10470 if (sfk == sfk_destructor)
10471 flags = DTOR_FLAG;
10472 }
10473 break;
10474
10475 case cdk_id:
10476 {
10477 tree qualifying_scope = id_declarator->u.id.qualifying_scope;
10478 tree decl = id_declarator->u.id.unqualified_name;
10479 if (!decl)
10480 break;
10481 if (qualifying_scope)
10482 {
10483 if (check_for_bare_parameter_packs (qualifying_scope,
10484 id_declarator->id_loc))
10485 return error_mark_node;
10486 if (at_function_scope_p ())
10487 {
10488 /* [dcl.meaning]
10489
10490 A declarator-id shall not be qualified except
10491 for ...
10492
10493 None of the cases are permitted in block
10494 scope. */
10495 if (qualifying_scope == global_namespace)
10496 error ("invalid use of qualified-name %<::%D%>",
10497 decl);
10498 else if (TYPE_P (qualifying_scope))
10499 error ("invalid use of qualified-name %<%T::%D%>",
10500 qualifying_scope, decl);
10501 else
10502 error ("invalid use of qualified-name %<%D::%D%>",
10503 qualifying_scope, decl);
10504 return error_mark_node;
10505 }
10506 else if (TYPE_P (qualifying_scope))
10507 {
10508 ctype = qualifying_scope;
10509 if (!MAYBE_CLASS_TYPE_P (ctype))
10510 {
10511 error ("%q#T is not a class or a namespace", ctype);
10512 ctype = NULL_TREE;
10513 }
10514 else if (innermost_code != cdk_function
10515 && current_class_type
10516 && !uniquely_derived_from_p (ctype,
10517 current_class_type))
10518 {
10519 error ("invalid use of qualified-name %<%T::%D%>",
10520 qualifying_scope, decl);
10521 return error_mark_node;
10522 }
10523 }
10524 else if (TREE_CODE (qualifying_scope) == NAMESPACE_DECL)
10525 in_namespace = qualifying_scope;
10526 }
10527 switch (TREE_CODE (decl))
10528 {
10529 case BIT_NOT_EXPR:
10530 {
10531 if (innermost_code != cdk_function)
10532 {
10533 error ("declaration of %qD as non-function", decl);
10534 return error_mark_node;
10535 }
10536 else if (!qualifying_scope
10537 && !(current_class_type && at_class_scope_p ()))
10538 {
10539 error ("declaration of %qD as non-member", decl);
10540 return error_mark_node;
10541 }
10542
10543 tree type = TREE_OPERAND (decl, 0);
10544 if (TYPE_P (type))
10545 type = constructor_name (type);
10546 name = identifier_to_locale (IDENTIFIER_POINTER (type));
10547 dname = decl;
10548 }
10549 break;
10550
10551 case TEMPLATE_ID_EXPR:
10552 {
10553 tree fns = TREE_OPERAND (decl, 0);
10554
10555 dname = fns;
10556 if (!identifier_p (dname))
10557 dname = OVL_NAME (dname);
10558 }
10559 /* Fall through. */
10560
10561 case IDENTIFIER_NODE:
10562 if (identifier_p (decl))
10563 dname = decl;
10564
10565 if (IDENTIFIER_KEYWORD_P (dname))
10566 {
10567 error ("declarator-id missing; using reserved word %qD",
10568 dname);
10569 name = identifier_to_locale (IDENTIFIER_POINTER (dname));
10570 }
10571 else if (!IDENTIFIER_CONV_OP_P (dname))
10572 name = identifier_to_locale (IDENTIFIER_POINTER (dname));
10573 else
10574 {
10575 gcc_assert (flags == NO_SPECIAL);
10576 flags = TYPENAME_FLAG;
10577 sfk = sfk_conversion;
10578 tree glob = get_global_binding (dname);
10579 if (glob && TREE_CODE (glob) == TYPE_DECL)
10580 name = identifier_to_locale (IDENTIFIER_POINTER (dname));
10581 else
10582 name = "<invalid operator>";
10583 }
10584 break;
10585
10586 default:
10587 gcc_unreachable ();
10588 }
10589 break;
10590 }
10591
10592 case cdk_array:
10593 case cdk_pointer:
10594 case cdk_reference:
10595 case cdk_ptrmem:
10596 break;
10597
10598 case cdk_decomp:
10599 name = "structured binding";
10600 break;
10601
10602 case cdk_error:
10603 return error_mark_node;
10604
10605 default:
10606 gcc_unreachable ();
10607 }
10608 if (id_declarator->kind == cdk_id)
10609 break;
10610 }
10611
10612 /* [dcl.fct.edf]
10613
10614 The declarator in a function-definition shall have the form
10615 D1 ( parameter-declaration-clause) ... */
10616 if (funcdef_flag && innermost_code != cdk_function)
10617 {
10618 error ("function definition does not declare parameters");
10619 return error_mark_node;
10620 }
10621
10622 if (flags == TYPENAME_FLAG
10623 && innermost_code != cdk_function
10624 && ! (ctype && !declspecs->any_specifiers_p))
10625 {
10626 error ("declaration of %qD as non-function", dname);
10627 return error_mark_node;
10628 }
10629
10630 if (dname && identifier_p (dname))
10631 {
10632 if (UDLIT_OPER_P (dname)
10633 && innermost_code != cdk_function)
10634 {
10635 error ("declaration of %qD as non-function", dname);
10636 return error_mark_node;
10637 }
10638
10639 if (IDENTIFIER_ANY_OP_P (dname))
10640 {
10641 if (typedef_p)
10642 {
10643 error ("declaration of %qD as %<typedef%>", dname);
10644 return error_mark_node;
10645 }
10646 else if (decl_context == PARM || decl_context == CATCHPARM)
10647 {
10648 error ("declaration of %qD as parameter", dname);
10649 return error_mark_node;
10650 }
10651 }
10652 }
10653
10654 /* Anything declared one level down from the top level
10655 must be one of the parameters of a function
10656 (because the body is at least two levels down). */
10657
10658 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
10659 by not allowing C++ class definitions to specify their parameters
10660 with xdecls (must be spec.d in the parmlist).
10661
10662 Since we now wait to push a class scope until we are sure that
10663 we are in a legitimate method context, we must set oldcname
10664 explicitly (since current_class_name is not yet alive).
10665
10666 We also want to avoid calling this a PARM if it is in a namespace. */
10667
10668 if (decl_context == NORMAL && !toplevel_bindings_p ())
10669 {
10670 cp_binding_level *b = current_binding_level;
10671 current_binding_level = b->level_chain;
10672 if (current_binding_level != 0 && toplevel_bindings_p ())
10673 decl_context = PARM;
10674 current_binding_level = b;
10675 }
10676
10677 if (name == NULL)
10678 name = decl_context == PARM ? "parameter" : "type name";
10679
10680 if (concept_p && typedef_p)
10681 {
10682 error_at (declspecs->locations[ds_concept],
10683 "%<concept%> cannot appear in a typedef declaration");
10684 return error_mark_node;
10685 }
10686
10687 if (constexpr_p && typedef_p)
10688 {
10689 error_at (declspecs->locations[ds_constexpr],
10690 "%<constexpr%> cannot appear in a typedef declaration");
10691 return error_mark_node;
10692 }
10693
10694 /* If there were multiple types specified in the decl-specifier-seq,
10695 issue an error message. */
10696 if (declspecs->multiple_types_p)
10697 {
10698 error ("two or more data types in declaration of %qs", name);
10699 return error_mark_node;
10700 }
10701
10702 if (declspecs->conflicting_specifiers_p)
10703 {
10704 error ("conflicting specifiers in declaration of %qs", name);
10705 return error_mark_node;
10706 }
10707
10708 /* Extract the basic type from the decl-specifier-seq. */
10709 type = declspecs->type;
10710 if (type == error_mark_node)
10711 {
10712 type = NULL_TREE;
10713 type_was_error_mark_node = true;
10714 }
10715 cp_warn_deprecated_use (type);
10716 if (type && TREE_CODE (type) == TYPE_DECL)
10717 {
10718 typedef_decl = type;
10719 type = TREE_TYPE (typedef_decl);
10720 if (DECL_ARTIFICIAL (typedef_decl))
10721 cp_warn_deprecated_use (type);
10722 }
10723 /* No type at all: default to `int', and set DEFAULTED_INT
10724 because it was not a user-defined typedef. */
10725 if (type == NULL_TREE)
10726 {
10727 if (signed_p || unsigned_p || long_p || short_p)
10728 {
10729 /* These imply 'int'. */
10730 type = integer_type_node;
10731 defaulted_int = 1;
10732 }
10733 /* If we just have "complex", it is equivalent to "complex double". */
10734 else if (!longlong && !explicit_intN
10735 && decl_spec_seq_has_spec_p (declspecs, ds_complex))
10736 {
10737 type = double_type_node;
10738 pedwarn (declspecs->locations[ds_complex], OPT_Wpedantic,
10739 "ISO C++ does not support plain %<complex%> meaning "
10740 "%<double complex%>");
10741 }
10742 }
10743 /* Gather flags. */
10744 explicit_int = declspecs->explicit_int_p;
10745 explicit_char = declspecs->explicit_char_p;
10746
10747 #if 0
10748 /* See the code below that used this. */
10749 if (typedef_decl)
10750 decl_attr = DECL_ATTRIBUTES (typedef_decl);
10751 #endif
10752 typedef_type = type;
10753
10754 if (sfk == sfk_conversion || sfk == sfk_deduction_guide)
10755 ctor_return_type = TREE_TYPE (dname);
10756 else
10757 ctor_return_type = ctype;
10758
10759 if (sfk != sfk_none)
10760 {
10761 type = check_special_function_return_type (sfk, type,
10762 ctor_return_type,
10763 type_quals,
10764 declspecs->locations);
10765 type_quals = TYPE_UNQUALIFIED;
10766 }
10767 else if (type == NULL_TREE)
10768 {
10769 int is_main;
10770
10771 explicit_int = -1;
10772
10773 /* We handle `main' specially here, because 'main () { }' is so
10774 common. With no options, it is allowed. With -Wreturn-type,
10775 it is a warning. It is only an error with -pedantic-errors. */
10776 is_main = (funcdef_flag
10777 && dname && identifier_p (dname)
10778 && MAIN_NAME_P (dname)
10779 && ctype == NULL_TREE
10780 && in_namespace == NULL_TREE
10781 && current_namespace == global_namespace);
10782
10783 if (type_was_error_mark_node)
10784 /* We've already issued an error, don't complain more. */;
10785 else if (in_system_header_at (input_location) || flag_ms_extensions)
10786 /* Allow it, sigh. */;
10787 else if (! is_main)
10788 permerror (input_location, "ISO C++ forbids declaration of %qs with no type", name);
10789 else if (pedantic)
10790 pedwarn (input_location, OPT_Wpedantic,
10791 "ISO C++ forbids declaration of %qs with no type", name);
10792 else
10793 warning (OPT_Wreturn_type,
10794 "ISO C++ forbids declaration of %qs with no type", name);
10795
10796 if (type_was_error_mark_node && template_parm_flag)
10797 /* FIXME we should be able to propagate the error_mark_node as is
10798 for other contexts too. */
10799 type = error_mark_node;
10800 else
10801 type = integer_type_node;
10802 }
10803
10804 ctype = NULL_TREE;
10805
10806 if (explicit_intN)
10807 {
10808 if (! int_n_enabled_p[declspecs->int_n_idx])
10809 {
10810 error ("%<__int%d%> is not supported by this target",
10811 int_n_data[declspecs->int_n_idx].bitsize);
10812 explicit_intN = false;
10813 }
10814 else if (pedantic && ! in_system_header_at (input_location))
10815 pedwarn (input_location, OPT_Wpedantic,
10816 "ISO C++ does not support %<__int%d%> for %qs",
10817 int_n_data[declspecs->int_n_idx].bitsize, name);
10818 }
10819
10820 /* Now process the modifiers that were specified
10821 and check for invalid combinations. */
10822
10823 /* Long double is a special combination. */
10824 if (long_p && !longlong && TYPE_MAIN_VARIANT (type) == double_type_node)
10825 {
10826 long_p = false;
10827 type = cp_build_qualified_type (long_double_type_node,
10828 cp_type_quals (type));
10829 }
10830
10831 /* Check all other uses of type modifiers. */
10832
10833 if (unsigned_p || signed_p || long_p || short_p)
10834 {
10835 location_t loc;
10836 const char *key;
10837 if (unsigned_p)
10838 {
10839 key = "unsigned";
10840 loc = declspecs->locations[ds_unsigned];
10841 }
10842 else if (signed_p)
10843 {
10844 key = "signed";
10845 loc = declspecs->locations[ds_signed];
10846 }
10847 else if (longlong)
10848 {
10849 key = "long long";
10850 loc = declspecs->locations[ds_long_long];
10851 }
10852 else if (long_p)
10853 {
10854 key = "long";
10855 loc = declspecs->locations[ds_long];
10856 }
10857 else /* if (short_p) */
10858 {
10859 key = "short";
10860 loc = declspecs->locations[ds_short];
10861 }
10862
10863 int ok = 0;
10864
10865 if (signed_p && unsigned_p)
10866 {
10867 gcc_rich_location richloc (declspecs->locations[ds_signed]);
10868 richloc.add_range (declspecs->locations[ds_unsigned]);
10869 error_at (&richloc,
10870 "%<signed%> and %<unsigned%> specified together");
10871 }
10872 else if (long_p && short_p)
10873 {
10874 gcc_rich_location richloc (declspecs->locations[ds_long]);
10875 richloc.add_range (declspecs->locations[ds_short]);
10876 error_at (&richloc, "%<long%> and %<short%> specified together");
10877 }
10878 else if (TREE_CODE (type) != INTEGER_TYPE
10879 || type == char8_type_node
10880 || type == char16_type_node
10881 || type == char32_type_node
10882 || ((long_p || short_p)
10883 && (explicit_char || explicit_intN)))
10884 error_at (loc, "%qs specified with %qT", key, type);
10885 else if (!explicit_int && !defaulted_int
10886 && !explicit_char && !explicit_intN)
10887 {
10888 if (typedef_decl)
10889 {
10890 pedwarn (loc, OPT_Wpedantic, "%qs specified with %qT",
10891 key, type);
10892 ok = !flag_pedantic_errors;
10893 }
10894 else if (declspecs->decltype_p)
10895 error_at (loc, "%qs specified with %<decltype%>", key);
10896 else
10897 error_at (loc, "%qs specified with %<typeof%>", key);
10898 }
10899 else
10900 ok = 1;
10901
10902 /* Discard the type modifiers if they are invalid. */
10903 if (! ok)
10904 {
10905 unsigned_p = false;
10906 signed_p = false;
10907 long_p = false;
10908 short_p = false;
10909 longlong = 0;
10910 }
10911 }
10912
10913 /* Decide whether an integer type is signed or not.
10914 Optionally treat bitfields as signed by default. */
10915 if (unsigned_p
10916 /* [class.bit]
10917
10918 It is implementation-defined whether a plain (neither
10919 explicitly signed or unsigned) char, short, int, or long
10920 bit-field is signed or unsigned.
10921
10922 Naturally, we extend this to long long as well. Note that
10923 this does not include wchar_t. */
10924 || (bitfield && !flag_signed_bitfields
10925 && !signed_p
10926 /* A typedef for plain `int' without `signed' can be
10927 controlled just like plain `int', but a typedef for
10928 `signed int' cannot be so controlled. */
10929 && !(typedef_decl
10930 && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl))
10931 && TREE_CODE (type) == INTEGER_TYPE
10932 && !same_type_p (TYPE_MAIN_VARIANT (type), wchar_type_node)))
10933 {
10934 if (explicit_intN)
10935 type = int_n_trees[declspecs->int_n_idx].unsigned_type;
10936 else if (longlong)
10937 type = long_long_unsigned_type_node;
10938 else if (long_p)
10939 type = long_unsigned_type_node;
10940 else if (short_p)
10941 type = short_unsigned_type_node;
10942 else if (type == char_type_node)
10943 type = unsigned_char_type_node;
10944 else if (typedef_decl)
10945 type = unsigned_type_for (type);
10946 else
10947 type = unsigned_type_node;
10948 }
10949 else if (signed_p && type == char_type_node)
10950 type = signed_char_type_node;
10951 else if (explicit_intN)
10952 type = int_n_trees[declspecs->int_n_idx].signed_type;
10953 else if (longlong)
10954 type = long_long_integer_type_node;
10955 else if (long_p)
10956 type = long_integer_type_node;
10957 else if (short_p)
10958 type = short_integer_type_node;
10959
10960 if (decl_spec_seq_has_spec_p (declspecs, ds_complex))
10961 {
10962 if (TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
10963 error ("complex invalid for %qs", name);
10964 /* If a modifier is specified, the resulting complex is the complex
10965 form of TYPE. E.g, "complex short" is "complex short int". */
10966 else if (type == integer_type_node)
10967 type = complex_integer_type_node;
10968 else if (type == float_type_node)
10969 type = complex_float_type_node;
10970 else if (type == double_type_node)
10971 type = complex_double_type_node;
10972 else if (type == long_double_type_node)
10973 type = complex_long_double_type_node;
10974 else
10975 type = build_complex_type (type);
10976 }
10977
10978 /* If we're using the injected-class-name to form a compound type or a
10979 declaration, replace it with the underlying class so we don't get
10980 redundant typedefs in the debug output. But if we are returning the
10981 type unchanged, leave it alone so that it's available to
10982 maybe_get_template_decl_from_type_decl. */
10983 if (CLASS_TYPE_P (type)
10984 && DECL_SELF_REFERENCE_P (TYPE_NAME (type))
10985 && type == TREE_TYPE (TYPE_NAME (type))
10986 && (declarator || type_quals))
10987 type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
10988
10989 type_quals |= cp_type_quals (type);
10990 type = cp_build_qualified_type_real
10991 (type, type_quals, ((((typedef_decl && !DECL_ARTIFICIAL (typedef_decl))
10992 || declspecs->decltype_p)
10993 ? tf_ignore_bad_quals : 0) | tf_warning_or_error));
10994 /* We might have ignored or rejected some of the qualifiers. */
10995 type_quals = cp_type_quals (type);
10996
10997 if (cxx_dialect >= cxx17 && type && is_auto (type)
10998 && innermost_code != cdk_function
10999 && id_declarator && declarator != id_declarator)
11000 if (tree tmpl = CLASS_PLACEHOLDER_TEMPLATE (type))
11001 {
11002 error_at (typespec_loc, "template placeholder type %qT must be followed "
11003 "by a simple declarator-id", type);
11004 inform (DECL_SOURCE_LOCATION (tmpl), "%qD declared here", tmpl);
11005 type = error_mark_node;
11006 }
11007
11008 staticp = 0;
11009 inlinep = decl_spec_seq_has_spec_p (declspecs, ds_inline);
11010 virtualp = decl_spec_seq_has_spec_p (declspecs, ds_virtual);
11011 explicitp = decl_spec_seq_has_spec_p (declspecs, ds_explicit);
11012
11013 storage_class = declspecs->storage_class;
11014 if (storage_class == sc_static)
11015 staticp = 1 + (decl_context == FIELD);
11016
11017 if (virtualp)
11018 {
11019 if (staticp == 2)
11020 {
11021 gcc_rich_location richloc (declspecs->locations[ds_virtual]);
11022 richloc.add_range (declspecs->locations[ds_storage_class]);
11023 error_at (&richloc, "member %qD cannot be declared both %<virtual%> "
11024 "and %<static%>", dname);
11025 storage_class = sc_none;
11026 staticp = 0;
11027 }
11028 if (constexpr_p && cxx_dialect < cxx2a)
11029 {
11030 gcc_rich_location richloc (declspecs->locations[ds_virtual]);
11031 richloc.add_range (declspecs->locations[ds_constexpr]);
11032 pedwarn (&richloc, OPT_Wpedantic, "member %qD can be declared both "
11033 "%<virtual%> and %<constexpr%> only in %<-std=c++2a%> or "
11034 "%<-std=gnu++2a%>", dname);
11035 }
11036 }
11037 friendp = decl_spec_seq_has_spec_p (declspecs, ds_friend);
11038
11039 /* Issue errors about use of storage classes for parameters. */
11040 if (decl_context == PARM)
11041 {
11042 if (typedef_p)
11043 {
11044 error_at (declspecs->locations[ds_typedef],
11045 "typedef declaration invalid in parameter declaration");
11046 return error_mark_node;
11047 }
11048 else if (template_parm_flag && storage_class != sc_none)
11049 {
11050 error_at (min_location (declspecs->locations[ds_thread],
11051 declspecs->locations[ds_storage_class]),
11052 "storage class specified for template parameter %qs",
11053 name);
11054 return error_mark_node;
11055 }
11056 else if (storage_class == sc_static
11057 || storage_class == sc_extern
11058 || thread_p)
11059 {
11060 error_at (min_location (declspecs->locations[ds_thread],
11061 declspecs->locations[ds_storage_class]),
11062 "storage class specified for parameter %qs", name);
11063 return error_mark_node;
11064 }
11065
11066 /* Function parameters cannot be concept. */
11067 if (concept_p)
11068 error_at (declspecs->locations[ds_concept],
11069 "a parameter cannot be declared %<concept%>");
11070 /* Function parameters cannot be constexpr. If we saw one, moan
11071 and pretend it wasn't there. */
11072 else if (constexpr_p)
11073 {
11074 error_at (declspecs->locations[ds_constexpr],
11075 "a parameter cannot be declared %<constexpr%>");
11076 constexpr_p = 0;
11077 }
11078 }
11079
11080 /* Give error if `virtual' is used outside of class declaration. */
11081 if (virtualp
11082 && (current_class_name == NULL_TREE || decl_context != FIELD))
11083 {
11084 error_at (declspecs->locations[ds_virtual],
11085 "%<virtual%> outside class declaration");
11086 virtualp = 0;
11087 }
11088
11089 if (innermost_code == cdk_decomp)
11090 {
11091 location_t loc = (declarator->kind == cdk_reference
11092 ? declarator->declarator->id_loc : declarator->id_loc);
11093 if (inlinep)
11094 error_at (declspecs->locations[ds_inline],
11095 "structured binding declaration cannot be %<inline%>");
11096 if (typedef_p)
11097 error_at (declspecs->locations[ds_typedef],
11098 "structured binding declaration cannot be %<typedef%>");
11099 if (constexpr_p)
11100 error_at (declspecs->locations[ds_constexpr], "structured "
11101 "binding declaration cannot be %<constexpr%>");
11102 if (thread_p)
11103 error_at (declspecs->locations[ds_thread],
11104 "structured binding declaration cannot be %qs",
11105 declspecs->gnu_thread_keyword_p
11106 ? "__thread" : "thread_local");
11107 if (concept_p)
11108 error_at (declspecs->locations[ds_concept],
11109 "structured binding declaration cannot be %<concept%>");
11110 switch (storage_class)
11111 {
11112 case sc_none:
11113 break;
11114 case sc_register:
11115 error_at (loc, "structured binding declaration cannot be "
11116 "%<register%>");
11117 break;
11118 case sc_static:
11119 error_at (loc, "structured binding declaration cannot be "
11120 "%<static%>");
11121 break;
11122 case sc_extern:
11123 error_at (loc, "structured binding declaration cannot be "
11124 "%<extern%>");
11125 break;
11126 case sc_mutable:
11127 error_at (loc, "structured binding declaration cannot be "
11128 "%<mutable%>");
11129 break;
11130 case sc_auto:
11131 error_at (loc, "structured binding declaration cannot be "
11132 "C++98 %<auto%>");
11133 break;
11134 default:
11135 gcc_unreachable ();
11136 }
11137 if (TREE_CODE (type) != TEMPLATE_TYPE_PARM
11138 || TYPE_IDENTIFIER (type) != auto_identifier)
11139 {
11140 if (type != error_mark_node)
11141 {
11142 error_at (loc, "structured binding declaration cannot have "
11143 "type %qT", type);
11144 inform (loc,
11145 "type must be cv-qualified %<auto%> or reference to "
11146 "cv-qualified %<auto%>");
11147 }
11148 type = build_qualified_type (make_auto (), type_quals);
11149 declspecs->type = type;
11150 }
11151 inlinep = 0;
11152 typedef_p = 0;
11153 constexpr_p = 0;
11154 thread_p = 0;
11155 concept_p = 0;
11156 storage_class = sc_none;
11157 staticp = 0;
11158 declspecs->storage_class = sc_none;
11159 declspecs->locations[ds_thread] = UNKNOWN_LOCATION;
11160 }
11161
11162 /* Static anonymous unions are dealt with here. */
11163 if (staticp && decl_context == TYPENAME
11164 && declspecs->type
11165 && ANON_AGGR_TYPE_P (declspecs->type))
11166 decl_context = FIELD;
11167
11168 /* Warn about storage classes that are invalid for certain
11169 kinds of declarations (parameters, typenames, etc.). */
11170 if (thread_p
11171 && ((storage_class
11172 && storage_class != sc_extern
11173 && storage_class != sc_static)
11174 || typedef_p))
11175 {
11176 error ("multiple storage classes in declaration of %qs", name);
11177 thread_p = false;
11178 }
11179 if (decl_context != NORMAL
11180 && ((storage_class != sc_none
11181 && storage_class != sc_mutable)
11182 || thread_p))
11183 {
11184 if ((decl_context == PARM || decl_context == CATCHPARM)
11185 && (storage_class == sc_register
11186 || storage_class == sc_auto))
11187 ;
11188 else if (typedef_p)
11189 ;
11190 else if (decl_context == FIELD
11191 /* C++ allows static class elements. */
11192 && storage_class == sc_static)
11193 /* C++ also allows inlines and signed and unsigned elements,
11194 but in those cases we don't come in here. */
11195 ;
11196 else
11197 {
11198 location_t loc
11199 = min_location (declspecs->locations[ds_thread],
11200 declspecs->locations[ds_storage_class]);
11201 if (decl_context == FIELD)
11202 error_at (loc, "storage class specified for %qs", name);
11203 else if (decl_context == PARM || decl_context == CATCHPARM)
11204 error_at (loc, "storage class specified for parameter %qs", name);
11205 else
11206 error_at (loc, "storage class specified for typename");
11207 if (storage_class == sc_register
11208 || storage_class == sc_auto
11209 || storage_class == sc_extern
11210 || thread_p)
11211 storage_class = sc_none;
11212 }
11213 }
11214 else if (storage_class == sc_extern && funcdef_flag
11215 && ! toplevel_bindings_p ())
11216 error ("nested function %qs declared %<extern%>", name);
11217 else if (toplevel_bindings_p ())
11218 {
11219 if (storage_class == sc_auto)
11220 error ("top-level declaration of %qs specifies %<auto%>", name);
11221 }
11222 else if (thread_p
11223 && storage_class != sc_extern
11224 && storage_class != sc_static)
11225 {
11226 if (declspecs->gnu_thread_keyword_p)
11227 pedwarn (declspecs->locations[ds_thread],
11228 0, "function-scope %qs implicitly auto and "
11229 "declared %<__thread%>", name);
11230
11231 /* When thread_local is applied to a variable of block scope the
11232 storage-class-specifier static is implied if it does not appear
11233 explicitly. */
11234 storage_class = declspecs->storage_class = sc_static;
11235 staticp = 1;
11236 }
11237
11238 if (storage_class && friendp)
11239 {
11240 error_at (min_location (declspecs->locations[ds_thread],
11241 declspecs->locations[ds_storage_class]),
11242 "storage class specifiers invalid in friend function "
11243 "declarations");
11244 storage_class = sc_none;
11245 staticp = 0;
11246 }
11247
11248 if (!id_declarator)
11249 unqualified_id = NULL_TREE;
11250 else
11251 {
11252 unqualified_id = id_declarator->u.id.unqualified_name;
11253 switch (TREE_CODE (unqualified_id))
11254 {
11255 case BIT_NOT_EXPR:
11256 unqualified_id = TREE_OPERAND (unqualified_id, 0);
11257 if (TYPE_P (unqualified_id))
11258 unqualified_id = constructor_name (unqualified_id);
11259 break;
11260
11261 case IDENTIFIER_NODE:
11262 case TEMPLATE_ID_EXPR:
11263 break;
11264
11265 default:
11266 gcc_unreachable ();
11267 }
11268 }
11269
11270 if (declspecs->std_attributes)
11271 {
11272 location_t attr_loc = declspecs->locations[ds_std_attribute];
11273 if (warning_at (attr_loc, OPT_Wattributes, "attribute ignored"))
11274 inform (attr_loc, "an attribute that appertains to a type-specifier "
11275 "is ignored");
11276 }
11277
11278 /* Determine the type of the entity declared by recurring on the
11279 declarator. */
11280 for (; declarator; declarator = declarator->declarator)
11281 {
11282 const cp_declarator *inner_declarator;
11283 tree attrs;
11284
11285 if (type == error_mark_node)
11286 return error_mark_node;
11287
11288 attrs = declarator->attributes;
11289 if (attrs)
11290 {
11291 int attr_flags;
11292
11293 attr_flags = 0;
11294 if (declarator == NULL || declarator->kind == cdk_id)
11295 attr_flags |= (int) ATTR_FLAG_DECL_NEXT;
11296 if (declarator->kind == cdk_function)
11297 attr_flags |= (int) ATTR_FLAG_FUNCTION_NEXT;
11298 if (declarator->kind == cdk_array)
11299 attr_flags |= (int) ATTR_FLAG_ARRAY_NEXT;
11300 tree late_attrs = NULL_TREE;
11301 if (decl_context != PARM)
11302 /* Assume that any attributes that get applied late to
11303 templates will DTRT when applied to the declaration
11304 as a whole. */
11305 late_attrs = splice_template_attributes (&attrs, type);
11306 returned_attrs = decl_attributes (&type,
11307 chainon (returned_attrs, attrs),
11308 attr_flags);
11309 returned_attrs = chainon (late_attrs, returned_attrs);
11310 }
11311
11312 inner_declarator = declarator->declarator;
11313
11314 /* We don't want to warn in parameter context because we don't
11315 yet know if the parse will succeed, and this might turn out
11316 to be a constructor call. */
11317 if (decl_context != PARM
11318 && decl_context != TYPENAME
11319 && !typedef_p
11320 && declarator->parenthesized != UNKNOWN_LOCATION
11321 /* If the type is class-like and the inner name used a
11322 global namespace qualifier, we need the parens.
11323 Unfortunately all we can tell is whether a qualified name
11324 was used or not. */
11325 && !(inner_declarator
11326 && inner_declarator->kind == cdk_id
11327 && inner_declarator->u.id.qualifying_scope
11328 && (MAYBE_CLASS_TYPE_P (type)
11329 || TREE_CODE (type) == ENUMERAL_TYPE)))
11330 warning_at (declarator->parenthesized, OPT_Wparentheses,
11331 "unnecessary parentheses in declaration of %qs", name);
11332 if (declarator->kind == cdk_id || declarator->kind == cdk_decomp)
11333 break;
11334
11335 switch (declarator->kind)
11336 {
11337 case cdk_array:
11338 type = create_array_type_for_decl (dname, type,
11339 declarator->u.array.bounds,
11340 declarator->id_loc);
11341 if (!valid_array_size_p (input_location, type, dname))
11342 type = error_mark_node;
11343
11344 if (declarator->std_attributes)
11345 /* [dcl.array]/1:
11346
11347 The optional attribute-specifier-seq appertains to the
11348 array. */
11349 returned_attrs = chainon (returned_attrs,
11350 declarator->std_attributes);
11351 break;
11352
11353 case cdk_function:
11354 {
11355 tree arg_types;
11356 int funcdecl_p;
11357
11358 /* Declaring a function type. */
11359
11360 input_location = declspecs->locations[ds_type_spec];
11361 abstract_virtuals_error (ACU_RETURN, type);
11362 input_location = saved_loc;
11363
11364 /* Pick up type qualifiers which should be applied to `this'. */
11365 memfn_quals = declarator->u.function.qualifiers;
11366 /* Pick up virt-specifiers. */
11367 virt_specifiers = declarator->u.function.virt_specifiers;
11368 /* And ref-qualifier, too */
11369 rqual = declarator->u.function.ref_qualifier;
11370 /* And tx-qualifier. */
11371 tree tx_qual = declarator->u.function.tx_qualifier;
11372 /* Pick up the exception specifications. */
11373 raises = declarator->u.function.exception_specification;
11374 /* If the exception-specification is ill-formed, let's pretend
11375 there wasn't one. */
11376 if (raises == error_mark_node)
11377 raises = NULL_TREE;
11378
11379 if (reqs)
11380 error_at (location_of (reqs), "requires-clause on return type");
11381 reqs = declarator->u.function.requires_clause;
11382
11383 /* Say it's a definition only for the CALL_EXPR
11384 closest to the identifier. */
11385 funcdecl_p = inner_declarator && inner_declarator->kind == cdk_id;
11386
11387 /* Handle a late-specified return type. */
11388 tree late_return_type = declarator->u.function.late_return_type;
11389 if (funcdecl_p
11390 /* This is the case e.g. for
11391 using T = auto () -> int. */
11392 || inner_declarator == NULL)
11393 {
11394 if (tree auto_node = type_uses_auto (type))
11395 {
11396 if (!late_return_type)
11397 {
11398 if (current_class_type
11399 && LAMBDA_TYPE_P (current_class_type))
11400 /* OK for C++11 lambdas. */;
11401 else if (cxx_dialect < cxx14)
11402 {
11403 error_at (typespec_loc, "%qs function uses "
11404 "%<auto%> type specifier without "
11405 "trailing return type", name);
11406 inform (typespec_loc,
11407 "deduced return type only available "
11408 "with %<-std=c++14%> or %<-std=gnu++14%>");
11409 }
11410 else if (virtualp)
11411 {
11412 error_at (typespec_loc, "virtual function "
11413 "cannot have deduced return type");
11414 virtualp = false;
11415 }
11416 }
11417 else if (!is_auto (type) && sfk != sfk_conversion)
11418 {
11419 error_at (typespec_loc, "%qs function with trailing "
11420 "return type has %qT as its type rather "
11421 "than plain %<auto%>", name, type);
11422 return error_mark_node;
11423 }
11424 else if (is_auto (type) && AUTO_IS_DECLTYPE (type))
11425 {
11426 if (funcdecl_p)
11427 error_at (typespec_loc,
11428 "%qs function with trailing return type "
11429 "has %<decltype(auto)%> as its type "
11430 "rather than plain %<auto%>", name);
11431 else
11432 error_at (typespec_loc,
11433 "invalid use of %<decltype(auto)%>");
11434 return error_mark_node;
11435 }
11436 tree tmpl = CLASS_PLACEHOLDER_TEMPLATE (auto_node);
11437 if (!tmpl)
11438 if (tree late_auto = type_uses_auto (late_return_type))
11439 tmpl = CLASS_PLACEHOLDER_TEMPLATE (late_auto);
11440 if (tmpl && funcdecl_p)
11441 {
11442 if (!dguide_name_p (unqualified_id))
11443 {
11444 error_at (declarator->id_loc, "deduced class "
11445 "type %qD in function return type",
11446 DECL_NAME (tmpl));
11447 inform (DECL_SOURCE_LOCATION (tmpl),
11448 "%qD declared here", tmpl);
11449 return error_mark_node;
11450 }
11451 else if (!late_return_type)
11452 {
11453 error_at (declarator->id_loc, "deduction guide "
11454 "for %qT must have trailing return "
11455 "type", TREE_TYPE (tmpl));
11456 inform (DECL_SOURCE_LOCATION (tmpl),
11457 "%qD declared here", tmpl);
11458 return error_mark_node;
11459 }
11460 else if (CLASS_TYPE_P (late_return_type)
11461 && CLASSTYPE_TEMPLATE_INFO (late_return_type)
11462 && (CLASSTYPE_TI_TEMPLATE (late_return_type)
11463 == tmpl))
11464 /* OK */;
11465 else
11466 error ("trailing return type %qT of deduction guide "
11467 "is not a specialization of %qT",
11468 late_return_type, TREE_TYPE (tmpl));
11469 }
11470 }
11471 else if (late_return_type
11472 && sfk != sfk_conversion)
11473 {
11474 if (late_return_type == error_mark_node)
11475 return error_mark_node;
11476 if (cxx_dialect < cxx11)
11477 /* Not using maybe_warn_cpp0x because this should
11478 always be an error. */
11479 error_at (typespec_loc,
11480 "trailing return type only available "
11481 "with %<-std=c++11%> or %<-std=gnu++11%>");
11482 else
11483 error_at (typespec_loc, "%qs function with trailing "
11484 "return type not declared with %<auto%> "
11485 "type specifier", name);
11486 return error_mark_node;
11487 }
11488 }
11489 type = splice_late_return_type (type, late_return_type);
11490 if (type == error_mark_node)
11491 return error_mark_node;
11492
11493 if (late_return_type)
11494 {
11495 late_return_type_p = true;
11496 type_quals = cp_type_quals (type);
11497 }
11498
11499 if (type_quals != TYPE_UNQUALIFIED)
11500 {
11501 if (SCALAR_TYPE_P (type) || VOID_TYPE_P (type))
11502 warning_at (typespec_loc, OPT_Wignored_qualifiers, "type "
11503 "qualifiers ignored on function return type");
11504 /* We now know that the TYPE_QUALS don't apply to the
11505 decl, but to its return type. */
11506 type_quals = TYPE_UNQUALIFIED;
11507 }
11508
11509 /* Error about some types functions can't return. */
11510
11511 if (TREE_CODE (type) == FUNCTION_TYPE)
11512 {
11513 error_at (typespec_loc, "%qs declared as function returning "
11514 "a function", name);
11515 return error_mark_node;
11516 }
11517 if (TREE_CODE (type) == ARRAY_TYPE)
11518 {
11519 error_at (typespec_loc, "%qs declared as function returning "
11520 "an array", name);
11521 return error_mark_node;
11522 }
11523
11524 if (ctype == NULL_TREE
11525 && decl_context == FIELD
11526 && funcdecl_p
11527 && friendp == 0)
11528 ctype = current_class_type;
11529
11530 if (ctype && (sfk == sfk_constructor
11531 || sfk == sfk_destructor))
11532 {
11533 /* We are within a class's scope. If our declarator name
11534 is the same as the class name, and we are defining
11535 a function, then it is a constructor/destructor, and
11536 therefore returns a void type. */
11537
11538 /* ISO C++ 12.4/2. A destructor may not be declared
11539 const or volatile. A destructor may not be static.
11540 A destructor may not be declared with ref-qualifier.
11541
11542 ISO C++ 12.1. A constructor may not be declared
11543 const or volatile. A constructor may not be
11544 virtual. A constructor may not be static.
11545 A constructor may not be declared with ref-qualifier. */
11546 if (staticp == 2)
11547 error ((flags == DTOR_FLAG)
11548 ? G_("destructor cannot be static member function")
11549 : G_("constructor cannot be static member function"));
11550 if (memfn_quals)
11551 {
11552 error ((flags == DTOR_FLAG)
11553 ? G_("destructors may not be cv-qualified")
11554 : G_("constructors may not be cv-qualified"));
11555 memfn_quals = TYPE_UNQUALIFIED;
11556 }
11557
11558 if (rqual)
11559 {
11560 maybe_warn_cpp0x (CPP0X_REF_QUALIFIER);
11561 error ((flags == DTOR_FLAG)
11562 ? G_("destructors may not be ref-qualified")
11563 : G_("constructors may not be ref-qualified"));
11564 rqual = REF_QUAL_NONE;
11565 }
11566
11567 if (decl_context == FIELD
11568 && !member_function_or_else (ctype,
11569 current_class_type,
11570 flags))
11571 return error_mark_node;
11572
11573 if (flags != DTOR_FLAG)
11574 {
11575 /* It's a constructor. */
11576 if (explicitp == 1)
11577 explicitp = 2;
11578 if (virtualp)
11579 {
11580 permerror (declspecs->locations[ds_virtual],
11581 "constructors cannot be declared %<virtual%>");
11582 virtualp = 0;
11583 }
11584 if (decl_context == FIELD
11585 && sfk != sfk_constructor)
11586 return error_mark_node;
11587 }
11588 if (decl_context == FIELD)
11589 staticp = 0;
11590 }
11591 else if (friendp)
11592 {
11593 if (virtualp)
11594 {
11595 /* Cannot be both friend and virtual. */
11596 gcc_rich_location richloc (declspecs->locations[ds_virtual]);
11597 richloc.add_range (declspecs->locations[ds_friend]);
11598 error_at (&richloc, "virtual functions cannot be friends");
11599 friendp = 0;
11600 }
11601 if (decl_context == NORMAL)
11602 error ("friend declaration not in class definition");
11603 if (current_function_decl && funcdef_flag)
11604 {
11605 error ("can%'t define friend function %qs in a local "
11606 "class definition", name);
11607 friendp = 0;
11608 }
11609 }
11610 else if (ctype && sfk == sfk_conversion)
11611 {
11612 if (explicitp == 1)
11613 {
11614 maybe_warn_cpp0x (CPP0X_EXPLICIT_CONVERSION);
11615 explicitp = 2;
11616 }
11617 if (late_return_type_p)
11618 error ("a conversion function cannot have a trailing return type");
11619 }
11620 else if (sfk == sfk_deduction_guide)
11621 {
11622 if (explicitp == 1)
11623 explicitp = 2;
11624 }
11625
11626 tree pushed_scope = NULL_TREE;
11627 if (funcdecl_p
11628 && decl_context != FIELD
11629 && inner_declarator->u.id.qualifying_scope
11630 && CLASS_TYPE_P (inner_declarator->u.id.qualifying_scope))
11631 pushed_scope
11632 = push_scope (inner_declarator->u.id.qualifying_scope);
11633
11634 arg_types = grokparms (declarator->u.function.parameters, &parms);
11635
11636 if (pushed_scope)
11637 pop_scope (pushed_scope);
11638
11639 if (inner_declarator
11640 && inner_declarator->kind == cdk_id
11641 && inner_declarator->u.id.sfk == sfk_destructor
11642 && arg_types != void_list_node)
11643 {
11644 error ("destructors may not have parameters");
11645 arg_types = void_list_node;
11646 parms = NULL_TREE;
11647 }
11648
11649 type = build_function_type (type, arg_types);
11650
11651 tree attrs = declarator->std_attributes;
11652 if (tx_qual)
11653 {
11654 tree att = build_tree_list (tx_qual, NULL_TREE);
11655 /* transaction_safe applies to the type, but
11656 transaction_safe_dynamic applies to the function. */
11657 if (is_attribute_p ("transaction_safe", tx_qual))
11658 attrs = chainon (attrs, att);
11659 else
11660 returned_attrs = chainon (returned_attrs, att);
11661 }
11662 if (attrs)
11663 /* [dcl.fct]/2:
11664
11665 The optional attribute-specifier-seq appertains to
11666 the function type. */
11667 decl_attributes (&type, attrs, 0);
11668
11669 if (raises)
11670 type = build_exception_variant (type, raises);
11671 }
11672 break;
11673
11674 case cdk_pointer:
11675 case cdk_reference:
11676 case cdk_ptrmem:
11677 /* Filter out pointers-to-references and references-to-references.
11678 We can get these if a TYPE_DECL is used. */
11679
11680 if (TYPE_REF_P (type))
11681 {
11682 if (declarator->kind != cdk_reference)
11683 {
11684 error ("cannot declare pointer to %q#T", type);
11685 type = TREE_TYPE (type);
11686 }
11687
11688 /* In C++0x, we allow reference to reference declarations
11689 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
11690 and template type arguments [14.3.1/4 temp.arg.type]. The
11691 check for direct reference to reference declarations, which
11692 are still forbidden, occurs below. Reasoning behind the change
11693 can be found in DR106, DR540, and the rvalue reference
11694 proposals. */
11695 else if (cxx_dialect == cxx98)
11696 {
11697 error ("cannot declare reference to %q#T", type);
11698 type = TREE_TYPE (type);
11699 }
11700 }
11701 else if (VOID_TYPE_P (type))
11702 {
11703 if (declarator->kind == cdk_reference)
11704 error ("cannot declare reference to %q#T", type);
11705 else if (declarator->kind == cdk_ptrmem)
11706 error ("cannot declare pointer to %q#T member", type);
11707 }
11708
11709 /* We now know that the TYPE_QUALS don't apply to the decl,
11710 but to the target of the pointer. */
11711 type_quals = TYPE_UNQUALIFIED;
11712
11713 /* This code used to handle METHOD_TYPE, but I don't think it's
11714 possible to get it here anymore. */
11715 gcc_assert (TREE_CODE (type) != METHOD_TYPE);
11716 if (declarator->kind == cdk_ptrmem
11717 && TREE_CODE (type) == FUNCTION_TYPE)
11718 {
11719 memfn_quals |= type_memfn_quals (type);
11720 type = build_memfn_type (type,
11721 declarator->u.pointer.class_type,
11722 memfn_quals,
11723 rqual);
11724 if (type == error_mark_node)
11725 return error_mark_node;
11726
11727 rqual = REF_QUAL_NONE;
11728 memfn_quals = TYPE_UNQUALIFIED;
11729 }
11730
11731 if (TREE_CODE (type) == FUNCTION_TYPE
11732 && (type_memfn_quals (type) != TYPE_UNQUALIFIED
11733 || type_memfn_rqual (type) != REF_QUAL_NONE))
11734 error (declarator->kind == cdk_reference
11735 ? G_("cannot declare reference to qualified function type %qT")
11736 : G_("cannot declare pointer to qualified function type %qT"),
11737 type);
11738
11739 /* When the pointed-to type involves components of variable size,
11740 care must be taken to ensure that the size evaluation code is
11741 emitted early enough to dominate all the possible later uses
11742 and late enough for the variables on which it depends to have
11743 been assigned.
11744
11745 This is expected to happen automatically when the pointed-to
11746 type has a name/declaration of it's own, but special attention
11747 is required if the type is anonymous.
11748
11749 We handle the NORMAL and FIELD contexts here by inserting a
11750 dummy statement that just evaluates the size at a safe point
11751 and ensures it is not deferred until e.g. within a deeper
11752 conditional context (c++/43555).
11753
11754 We expect nothing to be needed here for PARM or TYPENAME.
11755 Evaluating the size at this point for TYPENAME would
11756 actually be incorrect, as we might be in the middle of an
11757 expression with side effects on the pointed-to type size
11758 "arguments" prior to the pointer declaration point and the
11759 size evaluation could end up prior to the side effects. */
11760
11761 if (!TYPE_NAME (type)
11762 && (decl_context == NORMAL || decl_context == FIELD)
11763 && at_function_scope_p ()
11764 && variably_modified_type_p (type, NULL_TREE))
11765 {
11766 TYPE_NAME (type) = build_decl (UNKNOWN_LOCATION, TYPE_DECL,
11767 NULL_TREE, type);
11768 add_decl_expr (TYPE_NAME (type));
11769 }
11770
11771 if (declarator->kind == cdk_reference)
11772 {
11773 /* In C++0x, the type we are creating a reference to might be
11774 a typedef which is itself a reference type. In that case,
11775 we follow the reference collapsing rules in
11776 [7.1.3/8 dcl.typedef] to create the final reference type:
11777
11778 "If a typedef TD names a type that is a reference to a type
11779 T, an attempt to create the type 'lvalue reference to cv TD'
11780 creates the type 'lvalue reference to T,' while an attempt
11781 to create the type "rvalue reference to cv TD' creates the
11782 type TD."
11783 */
11784 if (VOID_TYPE_P (type))
11785 /* We already gave an error. */;
11786 else if (TYPE_REF_P (type))
11787 {
11788 if (declarator->u.reference.rvalue_ref)
11789 /* Leave type alone. */;
11790 else
11791 type = cp_build_reference_type (TREE_TYPE (type), false);
11792 }
11793 else
11794 type = cp_build_reference_type
11795 (type, declarator->u.reference.rvalue_ref);
11796
11797 /* In C++0x, we need this check for direct reference to
11798 reference declarations, which are forbidden by
11799 [8.3.2/5 dcl.ref]. Reference to reference declarations
11800 are only allowed indirectly through typedefs and template
11801 type arguments. Example:
11802
11803 void foo(int & &); // invalid ref-to-ref decl
11804
11805 typedef int & int_ref;
11806 void foo(int_ref &); // valid ref-to-ref decl
11807 */
11808 if (inner_declarator && inner_declarator->kind == cdk_reference)
11809 error ("cannot declare reference to %q#T, which is not "
11810 "a typedef or a template type argument", type);
11811 }
11812 else if (TREE_CODE (type) == METHOD_TYPE)
11813 type = build_ptrmemfunc_type (build_pointer_type (type));
11814 else if (declarator->kind == cdk_ptrmem)
11815 {
11816 gcc_assert (TREE_CODE (declarator->u.pointer.class_type)
11817 != NAMESPACE_DECL);
11818 if (declarator->u.pointer.class_type == error_mark_node)
11819 /* We will already have complained. */
11820 type = error_mark_node;
11821 else
11822 type = build_ptrmem_type (declarator->u.pointer.class_type,
11823 type);
11824 }
11825 else
11826 type = build_pointer_type (type);
11827
11828 /* Process a list of type modifier keywords (such as
11829 const or volatile) that were given inside the `*' or `&'. */
11830
11831 if (declarator->u.pointer.qualifiers)
11832 {
11833 type
11834 = cp_build_qualified_type (type,
11835 declarator->u.pointer.qualifiers);
11836 type_quals = cp_type_quals (type);
11837 }
11838
11839 /* Apply C++11 attributes to the pointer, and not to the
11840 type pointed to. This is unlike what is done for GNU
11841 attributes above. It is to comply with [dcl.ptr]/1:
11842
11843 [the optional attribute-specifier-seq (7.6.1) appertains
11844 to the pointer and not to the object pointed to]. */
11845 if (declarator->std_attributes)
11846 decl_attributes (&type, declarator->std_attributes,
11847 0);
11848
11849 ctype = NULL_TREE;
11850 break;
11851
11852 case cdk_error:
11853 break;
11854
11855 default:
11856 gcc_unreachable ();
11857 }
11858 }
11859
11860 /* A `constexpr' specifier used in an object declaration declares
11861 the object as `const'. */
11862 if (constexpr_p && innermost_code != cdk_function)
11863 {
11864 /* DR1688 says that a `constexpr' specifier in combination with
11865 `volatile' is valid. */
11866
11867 if (!TYPE_REF_P (type))
11868 {
11869 type_quals |= TYPE_QUAL_CONST;
11870 type = cp_build_qualified_type (type, type_quals);
11871 }
11872 }
11873
11874 if (unqualified_id && TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR
11875 && TREE_CODE (type) != FUNCTION_TYPE
11876 && TREE_CODE (type) != METHOD_TYPE
11877 && !variable_template_p (TREE_OPERAND (unqualified_id, 0)))
11878 {
11879 error ("template-id %qD used as a declarator",
11880 unqualified_id);
11881 unqualified_id = dname;
11882 }
11883
11884 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
11885 qualified with a class-name, turn it into a METHOD_TYPE, unless
11886 we know that the function is static. We take advantage of this
11887 opportunity to do other processing that pertains to entities
11888 explicitly declared to be class members. Note that if DECLARATOR
11889 is non-NULL, we know it is a cdk_id declarator; otherwise, we
11890 would not have exited the loop above. */
11891 if (declarator
11892 && declarator->kind == cdk_id
11893 && declarator->u.id.qualifying_scope
11894 && MAYBE_CLASS_TYPE_P (declarator->u.id.qualifying_scope))
11895 {
11896 ctype = declarator->u.id.qualifying_scope;
11897 ctype = TYPE_MAIN_VARIANT (ctype);
11898 template_count = num_template_headers_for_class (ctype);
11899
11900 if (ctype == current_class_type)
11901 {
11902 if (friendp)
11903 {
11904 permerror (input_location, "member functions are implicitly "
11905 "friends of their class");
11906 friendp = 0;
11907 }
11908 else
11909 permerror (declarator->id_loc,
11910 "extra qualification %<%T::%> on member %qs",
11911 ctype, name);
11912 }
11913 else if (/* If the qualifying type is already complete, then we
11914 can skip the following checks. */
11915 !COMPLETE_TYPE_P (ctype)
11916 && (/* If the function is being defined, then
11917 qualifying type must certainly be complete. */
11918 funcdef_flag
11919 /* A friend declaration of "T::f" is OK, even if
11920 "T" is a template parameter. But, if this
11921 function is not a friend, the qualifying type
11922 must be a class. */
11923 || (!friendp && !CLASS_TYPE_P (ctype))
11924 /* For a declaration, the type need not be
11925 complete, if either it is dependent (since there
11926 is no meaningful definition of complete in that
11927 case) or the qualifying class is currently being
11928 defined. */
11929 || !(dependent_type_p (ctype)
11930 || currently_open_class (ctype)))
11931 /* Check that the qualifying type is complete. */
11932 && !complete_type_or_else (ctype, NULL_TREE))
11933 return error_mark_node;
11934 else if (TREE_CODE (type) == FUNCTION_TYPE)
11935 {
11936 if (current_class_type
11937 && (!friendp || funcdef_flag || initialized))
11938 {
11939 error (funcdef_flag || initialized
11940 ? G_("cannot define member function %<%T::%s%> "
11941 "within %qT")
11942 : G_("cannot declare member function %<%T::%s%> "
11943 "within %qT"),
11944 ctype, name, current_class_type);
11945 return error_mark_node;
11946 }
11947 }
11948 else if (typedef_p && current_class_type)
11949 {
11950 error ("cannot declare member %<%T::%s%> within %qT",
11951 ctype, name, current_class_type);
11952 return error_mark_node;
11953 }
11954 }
11955
11956 if (ctype == NULL_TREE && decl_context == FIELD && friendp == 0)
11957 ctype = current_class_type;
11958
11959 /* Now TYPE has the actual type. */
11960
11961 if (returned_attrs)
11962 {
11963 if (attrlist)
11964 *attrlist = chainon (returned_attrs, *attrlist);
11965 else
11966 attrlist = &returned_attrs;
11967 }
11968
11969 if (declarator
11970 && declarator->kind == cdk_id
11971 && declarator->std_attributes
11972 && attrlist != NULL)
11973 {
11974 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
11975 a declarator-id appertains to the entity that is declared. */
11976 if (declarator->std_attributes != error_mark_node)
11977 *attrlist = chainon (*attrlist, declarator->std_attributes);
11978 else
11979 /* We should have already diagnosed the issue (c++/78344). */
11980 gcc_assert (seen_error ());
11981 }
11982
11983 /* Handle parameter packs. */
11984 if (parameter_pack_p)
11985 {
11986 if (decl_context == PARM)
11987 /* Turn the type into a pack expansion.*/
11988 type = make_pack_expansion (type);
11989 else
11990 error ("non-parameter %qs cannot be a parameter pack", name);
11991 }
11992
11993 if ((decl_context == FIELD || decl_context == PARM)
11994 && !processing_template_decl
11995 && variably_modified_type_p (type, NULL_TREE))
11996 {
11997 if (decl_context == FIELD)
11998 error ("data member may not have variably modified type %qT", type);
11999 else
12000 error ("parameter may not have variably modified type %qT", type);
12001 type = error_mark_node;
12002 }
12003
12004 if (explicitp == 1 || (explicitp && friendp))
12005 {
12006 /* [dcl.fct.spec] (C++11) The explicit specifier shall be used only
12007 in the declaration of a constructor or conversion function within
12008 a class definition. */
12009 if (!current_class_type)
12010 error_at (declspecs->locations[ds_explicit],
12011 "%<explicit%> outside class declaration");
12012 else if (friendp)
12013 error_at (declspecs->locations[ds_explicit],
12014 "%<explicit%> in friend declaration");
12015 else
12016 error_at (declspecs->locations[ds_explicit],
12017 "only declarations of constructors and conversion operators "
12018 "can be %<explicit%>");
12019 explicitp = 0;
12020 }
12021
12022 if (storage_class == sc_mutable)
12023 {
12024 location_t sloc = declspecs->locations[ds_storage_class];
12025 if (decl_context != FIELD || friendp)
12026 {
12027 error_at (sloc, "non-member %qs cannot be declared %<mutable%>",
12028 name);
12029 storage_class = sc_none;
12030 }
12031 else if (decl_context == TYPENAME || typedef_p)
12032 {
12033 error_at (sloc,
12034 "non-object member %qs cannot be declared %<mutable%>",
12035 name);
12036 storage_class = sc_none;
12037 }
12038 else if (TREE_CODE (type) == FUNCTION_TYPE
12039 || TREE_CODE (type) == METHOD_TYPE)
12040 {
12041 error_at (sloc, "function %qs cannot be declared %<mutable%>",
12042 name);
12043 storage_class = sc_none;
12044 }
12045 else if (staticp)
12046 {
12047 error_at (sloc, "%<static%> %qs cannot be declared %<mutable%>",
12048 name);
12049 storage_class = sc_none;
12050 }
12051 else if (type_quals & TYPE_QUAL_CONST)
12052 {
12053 error_at (sloc, "%<const%> %qs cannot be declared %<mutable%>",
12054 name);
12055 storage_class = sc_none;
12056 }
12057 else if (TYPE_REF_P (type))
12058 {
12059 permerror (sloc, "reference %qs cannot be declared %<mutable%>",
12060 name);
12061 storage_class = sc_none;
12062 }
12063 }
12064
12065 location_t loc = declarator ? declarator->id_loc : input_location;
12066
12067 /* If this is declaring a typedef name, return a TYPE_DECL. */
12068 if (typedef_p && decl_context != TYPENAME)
12069 {
12070 bool alias_p = decl_spec_seq_has_spec_p (declspecs, ds_alias);
12071 tree decl;
12072
12073 /* This declaration:
12074
12075 typedef void f(int) const;
12076
12077 declares a function type which is not a member of any
12078 particular class, but which is cv-qualified; for
12079 example "f S::*" declares a pointer to a const-qualified
12080 member function of S. We record the cv-qualification in the
12081 function type. */
12082 if ((rqual || memfn_quals) && TREE_CODE (type) == FUNCTION_TYPE)
12083 {
12084 type = apply_memfn_quals (type, memfn_quals, rqual);
12085
12086 /* We have now dealt with these qualifiers. */
12087 memfn_quals = TYPE_UNQUALIFIED;
12088 rqual = REF_QUAL_NONE;
12089 }
12090
12091 if (type_uses_auto (type))
12092 {
12093 if (alias_p)
12094 error_at (declspecs->locations[ds_type_spec],
12095 "%<auto%> not allowed in alias declaration");
12096 else
12097 error_at (declspecs->locations[ds_type_spec],
12098 "typedef declared %<auto%>");
12099 type = error_mark_node;
12100 }
12101
12102 if (reqs)
12103 error_at (location_of (reqs), "requires-clause on typedef");
12104
12105 if (id_declarator && declarator->u.id.qualifying_scope)
12106 {
12107 error ("typedef name may not be a nested-name-specifier");
12108 type = error_mark_node;
12109 }
12110
12111 if (decl_context == FIELD)
12112 decl = build_lang_decl_loc (loc, TYPE_DECL, unqualified_id, type);
12113 else
12114 decl = build_decl (loc, TYPE_DECL, unqualified_id, type);
12115
12116 if (decl_context != FIELD)
12117 {
12118 if (!current_function_decl)
12119 DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
12120 else if (DECL_MAYBE_IN_CHARGE_CDTOR_P (current_function_decl))
12121 /* The TYPE_DECL is "abstract" because there will be
12122 clones of this constructor/destructor, and there will
12123 be copies of this TYPE_DECL generated in those
12124 clones. The decloning optimization (for space) may
12125 revert this subsequently if it determines that
12126 the clones should share a common implementation. */
12127 DECL_ABSTRACT_P (decl) = true;
12128 }
12129 else if (current_class_type
12130 && constructor_name_p (unqualified_id, current_class_type))
12131 permerror (input_location, "ISO C++ forbids nested type %qD with same name "
12132 "as enclosing class",
12133 unqualified_id);
12134
12135 /* If the user declares "typedef struct {...} foo" then the
12136 struct will have an anonymous name. Fill that name in now.
12137 Nothing can refer to it, so nothing needs know about the name
12138 change. */
12139 if (type != error_mark_node
12140 && unqualified_id
12141 && TYPE_NAME (type)
12142 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
12143 && TYPE_UNNAMED_P (type)
12144 && declspecs->type_definition_p
12145 && attributes_naming_typedef_ok (*attrlist)
12146 && cp_type_quals (type) == TYPE_UNQUALIFIED)
12147 name_unnamed_type (type, decl);
12148
12149 if (signed_p
12150 || (typedef_decl && C_TYPEDEF_EXPLICITLY_SIGNED (typedef_decl)))
12151 C_TYPEDEF_EXPLICITLY_SIGNED (decl) = 1;
12152
12153 bad_specifiers (decl, BSP_TYPE, virtualp,
12154 memfn_quals != TYPE_UNQUALIFIED,
12155 inlinep, friendp, raises != NULL_TREE,
12156 declspecs->locations);
12157
12158 if (alias_p)
12159 /* Acknowledge that this was written:
12160 `using analias = atype;'. */
12161 TYPE_DECL_ALIAS_P (decl) = 1;
12162
12163 return decl;
12164 }
12165
12166 /* Detect the case of an array type of unspecified size
12167 which came, as such, direct from a typedef name.
12168 We must copy the type, so that the array's domain can be
12169 individually set by the object's initializer. */
12170
12171 if (type && typedef_type
12172 && TREE_CODE (type) == ARRAY_TYPE && !TYPE_DOMAIN (type)
12173 && TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (typedef_type))
12174 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
12175
12176 /* Detect where we're using a typedef of function type to declare a
12177 function. PARMS will not be set, so we must create it now. */
12178
12179 if (type == typedef_type && TREE_CODE (type) == FUNCTION_TYPE)
12180 {
12181 tree decls = NULL_TREE;
12182 tree args;
12183
12184 for (args = TYPE_ARG_TYPES (type);
12185 args && args != void_list_node;
12186 args = TREE_CHAIN (args))
12187 {
12188 tree decl = cp_build_parm_decl (NULL_TREE, NULL_TREE,
12189 TREE_VALUE (args));
12190
12191 DECL_CHAIN (decl) = decls;
12192 decls = decl;
12193 }
12194
12195 parms = nreverse (decls);
12196
12197 if (decl_context != TYPENAME)
12198 {
12199 /* The qualifiers on the function type become the qualifiers on
12200 the non-static member function. */
12201 memfn_quals |= type_memfn_quals (type);
12202 rqual = type_memfn_rqual (type);
12203 type_quals = TYPE_UNQUALIFIED;
12204 raises = TYPE_RAISES_EXCEPTIONS (type);
12205 }
12206 }
12207
12208 /* If this is a type name (such as, in a cast or sizeof),
12209 compute the type and return it now. */
12210
12211 if (decl_context == TYPENAME)
12212 {
12213 /* Note that here we don't care about type_quals. */
12214
12215 /* Special case: "friend class foo" looks like a TYPENAME context. */
12216 if (friendp)
12217 {
12218 if (inlinep)
12219 {
12220 error ("%<inline%> specified for friend class declaration");
12221 inlinep = 0;
12222 }
12223
12224 if (!current_aggr)
12225 {
12226 /* Don't allow friend declaration without a class-key. */
12227 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
12228 permerror (input_location, "template parameters cannot be friends");
12229 else if (TREE_CODE (type) == TYPENAME_TYPE)
12230 permerror (input_location, "friend declaration requires class-key, "
12231 "i.e. %<friend class %T::%D%>",
12232 TYPE_CONTEXT (type), TYPENAME_TYPE_FULLNAME (type));
12233 else
12234 permerror (input_location, "friend declaration requires class-key, "
12235 "i.e. %<friend %#T%>",
12236 type);
12237 }
12238
12239 /* Only try to do this stuff if we didn't already give up. */
12240 if (type != integer_type_node)
12241 {
12242 /* A friendly class? */
12243 if (current_class_type)
12244 make_friend_class (current_class_type, TYPE_MAIN_VARIANT (type),
12245 /*complain=*/true);
12246 else
12247 error ("trying to make class %qT a friend of global scope",
12248 type);
12249
12250 type = void_type_node;
12251 }
12252 }
12253 else if (memfn_quals || rqual)
12254 {
12255 if (ctype == NULL_TREE
12256 && TREE_CODE (type) == METHOD_TYPE)
12257 ctype = TYPE_METHOD_BASETYPE (type);
12258
12259 if (ctype)
12260 type = build_memfn_type (type, ctype, memfn_quals, rqual);
12261 /* Core issue #547: need to allow this in template type args.
12262 Allow it in general in C++11 for alias-declarations. */
12263 else if ((template_type_arg || cxx_dialect >= cxx11)
12264 && TREE_CODE (type) == FUNCTION_TYPE)
12265 type = apply_memfn_quals (type, memfn_quals, rqual);
12266 else
12267 error ("invalid qualifiers on non-member function type");
12268 }
12269
12270 if (reqs)
12271 error_at (location_of (reqs), "requires-clause on type-id");
12272
12273 return type;
12274 }
12275 else if (unqualified_id == NULL_TREE && decl_context != PARM
12276 && decl_context != CATCHPARM
12277 && TREE_CODE (type) != UNION_TYPE
12278 && ! bitfield
12279 && innermost_code != cdk_decomp)
12280 {
12281 error ("abstract declarator %qT used as declaration", type);
12282 return error_mark_node;
12283 }
12284
12285 if (!FUNC_OR_METHOD_TYPE_P (type))
12286 {
12287 /* Only functions may be declared using an operator-function-id. */
12288 if (dname && IDENTIFIER_ANY_OP_P (dname))
12289 {
12290 error ("declaration of %qD as non-function", dname);
12291 return error_mark_node;
12292 }
12293
12294 if (reqs)
12295 error_at (location_of (reqs),
12296 "requires-clause on declaration of non-function type %qT",
12297 type);
12298 }
12299
12300 /* We don't check parameter types here because we can emit a better
12301 error message later. */
12302 if (decl_context != PARM)
12303 {
12304 type = check_var_type (unqualified_id, type);
12305 if (type == error_mark_node)
12306 return error_mark_node;
12307 }
12308
12309 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
12310 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
12311
12312 if (decl_context == PARM || decl_context == CATCHPARM)
12313 {
12314 if (ctype || in_namespace)
12315 error ("cannot use %<::%> in parameter declaration");
12316
12317 if (type_uses_auto (type)
12318 && !(cxx_dialect >= cxx17 && template_parm_flag))
12319 {
12320 if (cxx_dialect >= cxx14)
12321 error ("%<auto%> parameter not permitted in this context");
12322 else
12323 error ("parameter declared %<auto%>");
12324 type = error_mark_node;
12325 }
12326
12327 /* A parameter declared as an array of T is really a pointer to T.
12328 One declared as a function is really a pointer to a function.
12329 One declared as a member is really a pointer to member. */
12330
12331 if (TREE_CODE (type) == ARRAY_TYPE)
12332 {
12333 /* Transfer const-ness of array into that of type pointed to. */
12334 type = build_pointer_type (TREE_TYPE (type));
12335 type_quals = TYPE_UNQUALIFIED;
12336 array_parameter_p = true;
12337 }
12338 else if (TREE_CODE (type) == FUNCTION_TYPE)
12339 type = build_pointer_type (type);
12340 }
12341
12342 if (ctype && TREE_CODE (type) == FUNCTION_TYPE && staticp < 2
12343 && !(unqualified_id
12344 && identifier_p (unqualified_id)
12345 && IDENTIFIER_NEWDEL_OP_P (unqualified_id)))
12346 {
12347 cp_cv_quals real_quals = memfn_quals;
12348 if (cxx_dialect < cxx14 && constexpr_p
12349 && sfk != sfk_constructor && sfk != sfk_destructor)
12350 real_quals |= TYPE_QUAL_CONST;
12351 type = build_memfn_type (type, ctype, real_quals, rqual);
12352 }
12353
12354 {
12355 tree decl = NULL_TREE;
12356
12357 if (decl_context == PARM)
12358 {
12359 decl = cp_build_parm_decl (NULL_TREE, unqualified_id, type);
12360 DECL_ARRAY_PARAMETER_P (decl) = array_parameter_p;
12361
12362 bad_specifiers (decl, BSP_PARM, virtualp,
12363 memfn_quals != TYPE_UNQUALIFIED,
12364 inlinep, friendp, raises != NULL_TREE,
12365 declspecs->locations);
12366 }
12367 else if (decl_context == FIELD)
12368 {
12369 if (!staticp && !friendp && TREE_CODE (type) != METHOD_TYPE)
12370 if (tree auto_node = type_uses_auto (type))
12371 {
12372 location_t tloc = declspecs->locations[ds_type_spec];
12373 if (CLASS_PLACEHOLDER_TEMPLATE (auto_node))
12374 error_at (tloc, "invalid use of template-name %qE without an "
12375 "argument list",
12376 CLASS_PLACEHOLDER_TEMPLATE (auto_node));
12377 else
12378 error_at (tloc, "non-static data member declared with "
12379 "placeholder %qT", auto_node);
12380 type = error_mark_node;
12381 }
12382
12383 /* The C99 flexible array extension. */
12384 if (!staticp && TREE_CODE (type) == ARRAY_TYPE
12385 && TYPE_DOMAIN (type) == NULL_TREE)
12386 {
12387 if (ctype
12388 && (TREE_CODE (ctype) == UNION_TYPE
12389 || TREE_CODE (ctype) == QUAL_UNION_TYPE))
12390 {
12391 error ("flexible array member in union");
12392 type = error_mark_node;
12393 }
12394 else
12395 {
12396 /* Array is a flexible member. */
12397 if (in_system_header_at (input_location))
12398 /* Do not warn on flexible array members in system
12399 headers because glibc uses them. */;
12400 else if (name && declarator)
12401 pedwarn (declarator->id_loc, OPT_Wpedantic,
12402 "ISO C++ forbids flexible array member %qs", name);
12403 else
12404 pedwarn (input_location, OPT_Wpedantic,
12405 "ISO C++ forbids flexible array members");
12406
12407 /* Flexible array member has a null domain. */
12408 type = build_cplus_array_type (TREE_TYPE (type), NULL_TREE);
12409 }
12410 }
12411
12412 if (type == error_mark_node)
12413 {
12414 /* Happens when declaring arrays of sizes which
12415 are error_mark_node, for example. */
12416 decl = NULL_TREE;
12417 }
12418 else if (in_namespace && !friendp)
12419 {
12420 /* Something like struct S { int N::j; }; */
12421 error ("invalid use of %<::%>");
12422 return error_mark_node;
12423 }
12424 else if (FUNC_OR_METHOD_TYPE_P (type) && unqualified_id)
12425 {
12426 int publicp = 0;
12427 tree function_context;
12428
12429 if (friendp == 0)
12430 {
12431 /* This should never happen in pure C++ (the check
12432 could be an assert). It could happen in
12433 Objective-C++ if someone writes invalid code that
12434 uses a function declaration for an instance
12435 variable or property (instance variables and
12436 properties are parsed as FIELD_DECLs, but they are
12437 part of an Objective-C class, not a C++ class).
12438 That code is invalid and is caught by this
12439 check. */
12440 if (!ctype)
12441 {
12442 error ("declaration of function %qD in invalid context",
12443 unqualified_id);
12444 return error_mark_node;
12445 }
12446
12447 /* ``A union may [ ... ] not [ have ] virtual functions.''
12448 ARM 9.5 */
12449 if (virtualp && TREE_CODE (ctype) == UNION_TYPE)
12450 {
12451 error_at (declspecs->locations[ds_virtual],
12452 "function %qD declared %<virtual%> inside a union",
12453 unqualified_id);
12454 return error_mark_node;
12455 }
12456
12457 if (virtualp
12458 && identifier_p (unqualified_id)
12459 && IDENTIFIER_NEWDEL_OP_P (unqualified_id))
12460 {
12461 error_at (declspecs->locations[ds_virtual],
12462 "%qD cannot be declared %<virtual%>, since it "
12463 "is always static", unqualified_id);
12464 virtualp = 0;
12465 }
12466 }
12467
12468 /* Check that the name used for a destructor makes sense. */
12469 if (sfk == sfk_destructor)
12470 {
12471 tree uqname = id_declarator->u.id.unqualified_name;
12472
12473 if (!ctype)
12474 {
12475 gcc_assert (friendp);
12476 error ("expected qualified name in friend declaration "
12477 "for destructor %qD", uqname);
12478 return error_mark_node;
12479 }
12480
12481 if (!check_dtor_name (ctype, TREE_OPERAND (uqname, 0)))
12482 {
12483 error ("declaration of %qD as member of %qT",
12484 uqname, ctype);
12485 return error_mark_node;
12486 }
12487 if (concept_p)
12488 {
12489 error_at (declspecs->locations[ds_concept],
12490 "a destructor cannot be %<concept%>");
12491 return error_mark_node;
12492 }
12493 if (constexpr_p)
12494 {
12495 error_at (declspecs->locations[ds_constexpr],
12496 "a destructor cannot be %<constexpr%>");
12497 return error_mark_node;
12498 }
12499 }
12500 else if (sfk == sfk_constructor && friendp && !ctype)
12501 {
12502 error ("expected qualified name in friend declaration "
12503 "for constructor %qD",
12504 id_declarator->u.id.unqualified_name);
12505 return error_mark_node;
12506 }
12507 if (sfk == sfk_constructor)
12508 if (concept_p)
12509 {
12510 error_at (declspecs->locations[ds_concept],
12511 "a constructor cannot be %<concept%>");
12512 return error_mark_node;
12513 }
12514 if (concept_p)
12515 {
12516 error_at (declspecs->locations[ds_concept],
12517 "a concept cannot be a member function");
12518 concept_p = false;
12519 }
12520
12521 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
12522 {
12523 tree tmpl = TREE_OPERAND (unqualified_id, 0);
12524 if (variable_template_p (tmpl))
12525 {
12526 error ("specialization of variable template %qD "
12527 "declared as function", tmpl);
12528 inform (DECL_SOURCE_LOCATION (tmpl),
12529 "variable template declared here");
12530 return error_mark_node;
12531 }
12532 }
12533
12534 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
12535 function_context = (ctype != NULL_TREE) ?
12536 decl_function_context (TYPE_MAIN_DECL (ctype)) : NULL_TREE;
12537 publicp = (! friendp || ! staticp)
12538 && function_context == NULL_TREE;
12539
12540 decl = grokfndecl (ctype, type,
12541 TREE_CODE (unqualified_id) != TEMPLATE_ID_EXPR
12542 ? unqualified_id : dname,
12543 parms,
12544 unqualified_id,
12545 declspecs,
12546 reqs,
12547 virtualp, flags, memfn_quals, rqual, raises,
12548 friendp ? -1 : 0, friendp, publicp,
12549 inlinep | (2 * constexpr_p) | (4 * concept_p),
12550 initialized == SD_DELETED, sfk,
12551 funcdef_flag, late_return_type_p,
12552 template_count, in_namespace,
12553 attrlist, declarator->id_loc);
12554 decl = set_virt_specifiers (decl, virt_specifiers);
12555 if (decl == NULL_TREE)
12556 return error_mark_node;
12557 #if 0
12558 /* This clobbers the attrs stored in `decl' from `attrlist'. */
12559 /* The decl and setting of decl_attr is also turned off. */
12560 decl = build_decl_attribute_variant (decl, decl_attr);
12561 #endif
12562
12563 /* [class.conv.ctor]
12564
12565 A constructor declared without the function-specifier
12566 explicit that can be called with a single parameter
12567 specifies a conversion from the type of its first
12568 parameter to the type of its class. Such a constructor
12569 is called a converting constructor. */
12570 if (explicitp == 2)
12571 DECL_NONCONVERTING_P (decl) = 1;
12572
12573 if (declspecs->explicit_specifier)
12574 store_explicit_specifier (decl, declspecs->explicit_specifier);
12575 }
12576 else if (!staticp && !dependent_type_p (type)
12577 && !COMPLETE_TYPE_P (complete_type (type))
12578 && (!complete_or_array_type_p (type)
12579 || initialized == 0))
12580 {
12581 if (TREE_CODE (type) != ARRAY_TYPE
12582 || !COMPLETE_TYPE_P (TREE_TYPE (type)))
12583 {
12584 if (unqualified_id)
12585 {
12586 error_at (declarator->id_loc,
12587 "field %qD has incomplete type %qT",
12588 unqualified_id, type);
12589 cxx_incomplete_type_inform (strip_array_types (type));
12590 }
12591 else
12592 error ("name %qT has incomplete type", type);
12593
12594 type = error_mark_node;
12595 decl = NULL_TREE;
12596 }
12597 }
12598 else
12599 {
12600 if (friendp)
12601 {
12602 if (unqualified_id && declarator)
12603 error_at (declarator->id_loc,
12604 "%qE is neither function nor member function; "
12605 "cannot be declared friend", unqualified_id);
12606 else
12607 error ("unnamed field is neither function nor member "
12608 "function; cannot be declared friend");
12609 return error_mark_node;
12610 }
12611 decl = NULL_TREE;
12612 }
12613
12614 if (friendp)
12615 {
12616 /* Friends are treated specially. */
12617 if (ctype == current_class_type)
12618 ; /* We already issued a permerror. */
12619 else if (decl && DECL_NAME (decl))
12620 {
12621 if (template_class_depth (current_class_type) == 0)
12622 {
12623 decl = check_explicit_specialization
12624 (unqualified_id, decl, template_count,
12625 2 * funcdef_flag + 4);
12626 if (decl == error_mark_node)
12627 return error_mark_node;
12628 }
12629
12630 decl = do_friend (ctype, unqualified_id, decl,
12631 *attrlist, flags,
12632 funcdef_flag);
12633 return decl;
12634 }
12635 else
12636 return error_mark_node;
12637 }
12638
12639 /* Structure field. It may not be a function, except for C++. */
12640
12641 if (decl == NULL_TREE)
12642 {
12643 if (staticp)
12644 {
12645 /* C++ allows static class members. All other work
12646 for this is done by grokfield. */
12647 decl = build_lang_decl_loc (loc, VAR_DECL,
12648 unqualified_id, type);
12649 set_linkage_for_static_data_member (decl);
12650 if (concept_p)
12651 error_at (declspecs->locations[ds_concept],
12652 "static data member %qE declared %<concept%>",
12653 unqualified_id);
12654 else if (constexpr_p && !initialized)
12655 {
12656 error_at (DECL_SOURCE_LOCATION (decl),
12657 "%<constexpr%> static data member %qD must "
12658 "have an initializer", decl);
12659 constexpr_p = false;
12660 }
12661
12662 if (inlinep)
12663 mark_inline_variable (decl, declspecs->locations[ds_inline]);
12664
12665 if (!DECL_VAR_DECLARED_INLINE_P (decl)
12666 && !(cxx_dialect >= cxx17 && constexpr_p))
12667 /* Even if there is an in-class initialization, DECL
12668 is considered undefined until an out-of-class
12669 definition is provided, unless this is an inline
12670 variable. */
12671 DECL_EXTERNAL (decl) = 1;
12672
12673 if (thread_p)
12674 {
12675 CP_DECL_THREAD_LOCAL_P (decl) = true;
12676 if (!processing_template_decl)
12677 set_decl_tls_model (decl, decl_default_tls_model (decl));
12678 if (declspecs->gnu_thread_keyword_p)
12679 SET_DECL_GNU_TLS_P (decl);
12680 }
12681 }
12682 else
12683 {
12684 if (concept_p)
12685 error_at (declspecs->locations[ds_concept],
12686 "non-static data member %qE declared %<concept%>",
12687 unqualified_id);
12688 else if (constexpr_p)
12689 {
12690 error_at (declspecs->locations[ds_constexpr],
12691 "non-static data member %qE declared %<constexpr%>",
12692 unqualified_id);
12693 constexpr_p = false;
12694 }
12695 decl = build_decl (loc, FIELD_DECL, unqualified_id, type);
12696 DECL_NONADDRESSABLE_P (decl) = bitfield;
12697 if (bitfield && !unqualified_id)
12698 {
12699 TREE_NO_WARNING (decl) = 1;
12700 DECL_PADDING_P (decl) = 1;
12701 }
12702
12703 if (storage_class == sc_mutable)
12704 {
12705 DECL_MUTABLE_P (decl) = 1;
12706 storage_class = sc_none;
12707 }
12708
12709 if (initialized)
12710 {
12711 /* An attempt is being made to initialize a non-static
12712 member. This is new in C++11. */
12713 maybe_warn_cpp0x (CPP0X_NSDMI);
12714
12715 /* If this has been parsed with static storage class, but
12716 errors forced staticp to be cleared, ensure NSDMI is
12717 not present. */
12718 if (declspecs->storage_class == sc_static)
12719 DECL_INITIAL (decl) = error_mark_node;
12720 }
12721 }
12722
12723 bad_specifiers (decl, BSP_FIELD, virtualp,
12724 memfn_quals != TYPE_UNQUALIFIED,
12725 staticp ? false : inlinep, friendp,
12726 raises != NULL_TREE,
12727 declspecs->locations);
12728 }
12729 }
12730 else if (TREE_CODE (type) == FUNCTION_TYPE
12731 || TREE_CODE (type) == METHOD_TYPE)
12732 {
12733 tree original_name;
12734 int publicp = 0;
12735
12736 if (!unqualified_id)
12737 return error_mark_node;
12738
12739 if (TREE_CODE (unqualified_id) == TEMPLATE_ID_EXPR)
12740 original_name = dname;
12741 else
12742 original_name = unqualified_id;
12743 // FIXME:gcc_assert (original_name == dname);
12744
12745 if (storage_class == sc_auto)
12746 error ("storage class %<auto%> invalid for function %qs", name);
12747 else if (storage_class == sc_register)
12748 error ("storage class %<register%> invalid for function %qs", name);
12749 else if (thread_p)
12750 {
12751 if (declspecs->gnu_thread_keyword_p)
12752 error_at (declspecs->locations[ds_thread],
12753 "storage class %<__thread%> invalid for function %qs",
12754 name);
12755 else
12756 error_at (declspecs->locations[ds_thread],
12757 "storage class %<thread_local%> invalid for "
12758 "function %qs", name);
12759 }
12760
12761 if (virt_specifiers)
12762 error ("virt-specifiers in %qs not allowed outside a class "
12763 "definition", name);
12764 /* Function declaration not at top level.
12765 Storage classes other than `extern' are not allowed
12766 and `extern' makes no difference. */
12767 if (! toplevel_bindings_p ()
12768 && (storage_class == sc_static
12769 || decl_spec_seq_has_spec_p (declspecs, ds_inline))
12770 && pedantic)
12771 {
12772 if (storage_class == sc_static)
12773 pedwarn (declspecs->locations[ds_storage_class], OPT_Wpedantic,
12774 "%<static%> specifier invalid for function %qs "
12775 "declared out of global scope", name);
12776 else
12777 pedwarn (declspecs->locations[ds_inline], OPT_Wpedantic,
12778 "%<inline%> specifier invalid for function %qs "
12779 "declared out of global scope", name);
12780 }
12781
12782 if (ctype == NULL_TREE)
12783 {
12784 if (virtualp)
12785 {
12786 error ("virtual non-class function %qs", name);
12787 virtualp = 0;
12788 }
12789 else if (sfk == sfk_constructor
12790 || sfk == sfk_destructor)
12791 {
12792 error (funcdef_flag
12793 ? G_("%qs defined in a non-class scope")
12794 : G_("%qs declared in a non-class scope"), name);
12795 sfk = sfk_none;
12796 }
12797 }
12798
12799 /* Record whether the function is public. */
12800 publicp = (ctype != NULL_TREE
12801 || storage_class != sc_static);
12802
12803 decl = grokfndecl (ctype, type, original_name, parms, unqualified_id,
12804 declspecs,
12805 reqs, virtualp, flags, memfn_quals, rqual, raises,
12806 1, friendp,
12807 publicp,
12808 inlinep | (2 * constexpr_p) | (4 * concept_p),
12809 initialized == SD_DELETED,
12810 sfk,
12811 funcdef_flag,
12812 late_return_type_p,
12813 template_count, in_namespace, attrlist,
12814 declarator->id_loc);
12815 if (decl == NULL_TREE)
12816 return error_mark_node;
12817
12818 if (explicitp == 2)
12819 DECL_NONCONVERTING_P (decl) = 1;
12820 if (staticp == 1)
12821 {
12822 int invalid_static = 0;
12823
12824 /* Don't allow a static member function in a class, and forbid
12825 declaring main to be static. */
12826 if (TREE_CODE (type) == METHOD_TYPE)
12827 {
12828 permerror (input_location, "cannot declare member function %qD to have "
12829 "static linkage", decl);
12830 invalid_static = 1;
12831 }
12832 else if (current_function_decl)
12833 {
12834 /* 7.1.1: There can be no static function declarations within a
12835 block. */
12836 error_at (declspecs->locations[ds_storage_class],
12837 "cannot declare static function inside another function");
12838 invalid_static = 1;
12839 }
12840
12841 if (invalid_static)
12842 {
12843 staticp = 0;
12844 storage_class = sc_none;
12845 }
12846 }
12847 }
12848 else
12849 {
12850 /* It's a variable. */
12851
12852 /* An uninitialized decl with `extern' is a reference. */
12853 decl = grokvardecl (type, dname, unqualified_id,
12854 declspecs,
12855 initialized,
12856 type_quals,
12857 inlinep,
12858 concept_p,
12859 template_count,
12860 ctype ? ctype : in_namespace,
12861 loc);
12862 if (decl == NULL_TREE)
12863 return error_mark_node;
12864
12865 bad_specifiers (decl, BSP_VAR, virtualp,
12866 memfn_quals != TYPE_UNQUALIFIED,
12867 inlinep, friendp, raises != NULL_TREE,
12868 declspecs->locations);
12869
12870 if (ctype)
12871 {
12872 DECL_CONTEXT (decl) = ctype;
12873 if (staticp == 1)
12874 {
12875 permerror (declspecs->locations[ds_storage_class],
12876 "%<static%> may not be used when defining "
12877 "(as opposed to declaring) a static data member");
12878 staticp = 0;
12879 storage_class = sc_none;
12880 }
12881 if (storage_class == sc_register && TREE_STATIC (decl))
12882 {
12883 error ("static member %qD declared %<register%>", decl);
12884 storage_class = sc_none;
12885 }
12886 if (storage_class == sc_extern && pedantic)
12887 {
12888 pedwarn (input_location, OPT_Wpedantic,
12889 "cannot explicitly declare member %q#D to have "
12890 "extern linkage", decl);
12891 storage_class = sc_none;
12892 }
12893 }
12894 else if (constexpr_p && DECL_EXTERNAL (decl))
12895 {
12896 error_at (DECL_SOURCE_LOCATION (decl),
12897 "declaration of %<constexpr%> variable %qD "
12898 "is not a definition", decl);
12899 constexpr_p = false;
12900 }
12901
12902 if (inlinep)
12903 mark_inline_variable (decl, declspecs->locations[ds_inline]);
12904 if (innermost_code == cdk_decomp)
12905 {
12906 gcc_assert (declarator && declarator->kind == cdk_decomp);
12907 DECL_SOURCE_LOCATION (decl) = declarator->id_loc;
12908 DECL_ARTIFICIAL (decl) = 1;
12909 fit_decomposition_lang_decl (decl, NULL_TREE);
12910 }
12911 }
12912
12913 if (VAR_P (decl) && !initialized)
12914 if (tree auto_node = type_uses_auto (type))
12915 if (!CLASS_PLACEHOLDER_TEMPLATE (auto_node))
12916 {
12917 location_t loc = declspecs->locations[ds_type_spec];
12918 error_at (loc, "declaration of %q#D has no initializer", decl);
12919 TREE_TYPE (decl) = error_mark_node;
12920 }
12921
12922 if (storage_class == sc_extern && initialized && !funcdef_flag)
12923 {
12924 if (toplevel_bindings_p ())
12925 {
12926 /* It's common practice (and completely valid) to have a const
12927 be initialized and declared extern. */
12928 if (!(type_quals & TYPE_QUAL_CONST))
12929 warning_at (DECL_SOURCE_LOCATION (decl), 0,
12930 "%qs initialized and declared %<extern%>", name);
12931 }
12932 else
12933 {
12934 error_at (DECL_SOURCE_LOCATION (decl),
12935 "%qs has both %<extern%> and initializer", name);
12936 return error_mark_node;
12937 }
12938 }
12939
12940 /* Record `register' declaration for warnings on &
12941 and in case doing stupid register allocation. */
12942
12943 if (storage_class == sc_register)
12944 {
12945 DECL_REGISTER (decl) = 1;
12946 /* Warn about register storage specifiers on PARM_DECLs. */
12947 if (TREE_CODE (decl) == PARM_DECL)
12948 {
12949 if (cxx_dialect >= cxx17)
12950 pedwarn (DECL_SOURCE_LOCATION (decl), OPT_Wregister,
12951 "ISO C++17 does not allow %<register%> storage "
12952 "class specifier");
12953 else
12954 warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wregister,
12955 "%<register%> storage class specifier used");
12956 }
12957 }
12958 else if (storage_class == sc_extern)
12959 DECL_THIS_EXTERN (decl) = 1;
12960 else if (storage_class == sc_static)
12961 DECL_THIS_STATIC (decl) = 1;
12962
12963 /* Set constexpr flag on vars (functions got it in grokfndecl). */
12964 if (constexpr_p && VAR_P (decl))
12965 DECL_DECLARED_CONSTEXPR_P (decl) = true;
12966
12967 /* Record constancy and volatility on the DECL itself . There's
12968 no need to do this when processing a template; we'll do this
12969 for the instantiated declaration based on the type of DECL. */
12970 if (!processing_template_decl)
12971 cp_apply_type_quals_to_decl (type_quals, decl);
12972
12973 return decl;
12974 }
12975 }
12976
12977 /* Subroutine of start_function. Ensure that each of the parameter
12978 types (as listed in PARMS) is complete, as is required for a
12979 function definition. */
12980
12981 static void
require_complete_types_for_parms(tree parms)12982 require_complete_types_for_parms (tree parms)
12983 {
12984 for (; parms; parms = DECL_CHAIN (parms))
12985 {
12986 if (dependent_type_p (TREE_TYPE (parms)))
12987 continue;
12988 if (!VOID_TYPE_P (TREE_TYPE (parms))
12989 && complete_type_or_else (TREE_TYPE (parms), parms))
12990 {
12991 relayout_decl (parms);
12992 DECL_ARG_TYPE (parms) = type_passed_as (TREE_TYPE (parms));
12993
12994 maybe_warn_parm_abi (TREE_TYPE (parms),
12995 DECL_SOURCE_LOCATION (parms));
12996 }
12997 else
12998 /* grokparms or complete_type_or_else will have already issued
12999 an error. */
13000 TREE_TYPE (parms) = error_mark_node;
13001 }
13002 }
13003
13004 /* Returns nonzero if T is a local variable. */
13005
13006 int
local_variable_p(const_tree t)13007 local_variable_p (const_tree t)
13008 {
13009 if ((VAR_P (t)
13010 /* A VAR_DECL with a context that is a _TYPE is a static data
13011 member. */
13012 && !TYPE_P (CP_DECL_CONTEXT (t))
13013 /* Any other non-local variable must be at namespace scope. */
13014 && !DECL_NAMESPACE_SCOPE_P (t))
13015 || (TREE_CODE (t) == PARM_DECL))
13016 return 1;
13017
13018 return 0;
13019 }
13020
13021 /* Like local_variable_p, but suitable for use as a tree-walking
13022 function. */
13023
13024 static tree
local_variable_p_walkfn(tree * tp,int * walk_subtrees,void *)13025 local_variable_p_walkfn (tree *tp, int *walk_subtrees,
13026 void * /*data*/)
13027 {
13028 if (local_variable_p (*tp)
13029 && (!DECL_ARTIFICIAL (*tp) || DECL_NAME (*tp) == this_identifier))
13030 return *tp;
13031 else if (TYPE_P (*tp))
13032 *walk_subtrees = 0;
13033
13034 return NULL_TREE;
13035 }
13036
13037 /* Check that ARG, which is a default-argument expression for a
13038 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
13039 something goes wrong. DECL may also be a _TYPE node, rather than a
13040 DECL, if there is no DECL available. */
13041
13042 tree
check_default_argument(tree decl,tree arg,tsubst_flags_t complain)13043 check_default_argument (tree decl, tree arg, tsubst_flags_t complain)
13044 {
13045 tree var;
13046 tree decl_type;
13047
13048 if (TREE_CODE (arg) == DEFAULT_ARG)
13049 /* We get a DEFAULT_ARG when looking at an in-class declaration
13050 with a default argument. Ignore the argument for now; we'll
13051 deal with it after the class is complete. */
13052 return arg;
13053
13054 if (TYPE_P (decl))
13055 {
13056 decl_type = decl;
13057 decl = NULL_TREE;
13058 }
13059 else
13060 decl_type = TREE_TYPE (decl);
13061
13062 if (arg == error_mark_node
13063 || decl == error_mark_node
13064 || TREE_TYPE (arg) == error_mark_node
13065 || decl_type == error_mark_node)
13066 /* Something already went wrong. There's no need to check
13067 further. */
13068 return error_mark_node;
13069
13070 /* [dcl.fct.default]
13071
13072 A default argument expression is implicitly converted to the
13073 parameter type. */
13074 ++cp_unevaluated_operand;
13075 /* Avoid digest_init clobbering the initializer. */
13076 tree carg = BRACE_ENCLOSED_INITIALIZER_P (arg) ? unshare_expr (arg): arg;
13077 perform_implicit_conversion_flags (decl_type, carg, complain,
13078 LOOKUP_IMPLICIT);
13079 --cp_unevaluated_operand;
13080
13081 /* Avoid redundant -Wzero-as-null-pointer-constant warnings at
13082 the call sites. */
13083 if (TYPE_PTR_OR_PTRMEM_P (decl_type)
13084 && null_ptr_cst_p (arg)
13085 /* Don't lose side-effects as in PR90473. */
13086 && !TREE_SIDE_EFFECTS (arg))
13087 return nullptr_node;
13088
13089 /* [dcl.fct.default]
13090
13091 Local variables shall not be used in default argument
13092 expressions.
13093
13094 The keyword `this' shall not be used in a default argument of a
13095 member function. */
13096 var = cp_walk_tree_without_duplicates (&arg, local_variable_p_walkfn, NULL);
13097 if (var)
13098 {
13099 if (complain & tf_warning_or_error)
13100 {
13101 if (DECL_NAME (var) == this_identifier)
13102 permerror (input_location, "default argument %qE uses %qD",
13103 arg, var);
13104 else
13105 error ("default argument %qE uses local variable %qD", arg, var);
13106 }
13107 return error_mark_node;
13108 }
13109
13110 /* All is well. */
13111 return arg;
13112 }
13113
13114 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
13115
13116 static tree
type_is_deprecated(tree type)13117 type_is_deprecated (tree type)
13118 {
13119 enum tree_code code;
13120 if (TREE_DEPRECATED (type))
13121 return type;
13122 if (TYPE_NAME (type))
13123 {
13124 if (TREE_DEPRECATED (TYPE_NAME (type)))
13125 return type;
13126 else
13127 return NULL_TREE;
13128 }
13129
13130 /* Do warn about using typedefs to a deprecated class. */
13131 if (OVERLOAD_TYPE_P (type) && type != TYPE_MAIN_VARIANT (type))
13132 return type_is_deprecated (TYPE_MAIN_VARIANT (type));
13133
13134 code = TREE_CODE (type);
13135
13136 if (code == POINTER_TYPE || code == REFERENCE_TYPE
13137 || code == OFFSET_TYPE || code == FUNCTION_TYPE
13138 || code == METHOD_TYPE || code == ARRAY_TYPE)
13139 return type_is_deprecated (TREE_TYPE (type));
13140
13141 if (TYPE_PTRMEMFUNC_P (type))
13142 return type_is_deprecated
13143 (TREE_TYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type))));
13144
13145 return NULL_TREE;
13146 }
13147
13148 /* Decode the list of parameter types for a function type.
13149 Given the list of things declared inside the parens,
13150 return a list of types.
13151
13152 If this parameter does not end with an ellipsis, we append
13153 void_list_node.
13154
13155 *PARMS is set to the chain of PARM_DECLs created. */
13156
13157 tree
grokparms(tree parmlist,tree * parms)13158 grokparms (tree parmlist, tree *parms)
13159 {
13160 tree result = NULL_TREE;
13161 tree decls = NULL_TREE;
13162 tree parm;
13163 int any_error = 0;
13164
13165 for (parm = parmlist; parm != NULL_TREE; parm = TREE_CHAIN (parm))
13166 {
13167 tree type = NULL_TREE;
13168 tree init = TREE_PURPOSE (parm);
13169 tree decl = TREE_VALUE (parm);
13170
13171 if (parm == void_list_node)
13172 break;
13173
13174 if (! decl || TREE_TYPE (decl) == error_mark_node)
13175 continue;
13176
13177 type = TREE_TYPE (decl);
13178 if (VOID_TYPE_P (type))
13179 {
13180 if (same_type_p (type, void_type_node)
13181 && !init
13182 && !DECL_NAME (decl) && !result
13183 && TREE_CHAIN (parm) == void_list_node)
13184 /* DR 577: A parameter list consisting of a single
13185 unnamed parameter of non-dependent type 'void'. */
13186 break;
13187 else if (cv_qualified_p (type))
13188 error_at (DECL_SOURCE_LOCATION (decl),
13189 "invalid use of cv-qualified type %qT in "
13190 "parameter declaration", type);
13191 else
13192 error_at (DECL_SOURCE_LOCATION (decl),
13193 "invalid use of type %<void%> in parameter "
13194 "declaration");
13195 /* It's not a good idea to actually create parameters of
13196 type `void'; other parts of the compiler assume that a
13197 void type terminates the parameter list. */
13198 type = error_mark_node;
13199 TREE_TYPE (decl) = error_mark_node;
13200 }
13201
13202 if (type != error_mark_node)
13203 {
13204 if (deprecated_state != DEPRECATED_SUPPRESS)
13205 {
13206 tree deptype = type_is_deprecated (type);
13207 if (deptype)
13208 cp_warn_deprecated_use (deptype);
13209 }
13210
13211 /* Top-level qualifiers on the parameters are
13212 ignored for function types. */
13213 type = cp_build_qualified_type (type, 0);
13214 if (TREE_CODE (type) == METHOD_TYPE)
13215 {
13216 error ("parameter %qD invalidly declared method type", decl);
13217 type = build_pointer_type (type);
13218 TREE_TYPE (decl) = type;
13219 }
13220 else if (abstract_virtuals_error (decl, type))
13221 any_error = 1; /* Seems like a good idea. */
13222 else if (cxx_dialect < cxx17 && INDIRECT_TYPE_P (type))
13223 {
13224 /* Before C++17 DR 393:
13225 [dcl.fct]/6, parameter types cannot contain pointers
13226 (references) to arrays of unknown bound. */
13227 tree t = TREE_TYPE (type);
13228 int ptr = TYPE_PTR_P (type);
13229
13230 while (1)
13231 {
13232 if (TYPE_PTR_P (t))
13233 ptr = 1;
13234 else if (TREE_CODE (t) != ARRAY_TYPE)
13235 break;
13236 else if (!TYPE_DOMAIN (t))
13237 break;
13238 t = TREE_TYPE (t);
13239 }
13240 if (TREE_CODE (t) == ARRAY_TYPE)
13241 pedwarn (DECL_SOURCE_LOCATION (decl), OPT_Wpedantic,
13242 ptr
13243 ? G_("parameter %qD includes pointer to array of "
13244 "unknown bound %qT")
13245 : G_("parameter %qD includes reference to array of "
13246 "unknown bound %qT"),
13247 decl, t);
13248 }
13249
13250 if (any_error)
13251 init = NULL_TREE;
13252 else if (init && !processing_template_decl)
13253 init = check_default_argument (decl, init, tf_warning_or_error);
13254 }
13255
13256 DECL_CHAIN (decl) = decls;
13257 decls = decl;
13258 result = tree_cons (init, type, result);
13259 }
13260 decls = nreverse (decls);
13261 result = nreverse (result);
13262 if (parm)
13263 result = chainon (result, void_list_node);
13264 *parms = decls;
13265
13266 return result;
13267 }
13268
13269
13270 /* D is a constructor or overloaded `operator='.
13271
13272 Let T be the class in which D is declared. Then, this function
13273 returns:
13274
13275 -1 if D's is an ill-formed constructor or copy assignment operator
13276 whose first parameter is of type `T'.
13277 0 if D is not a copy constructor or copy assignment
13278 operator.
13279 1 if D is a copy constructor or copy assignment operator whose
13280 first parameter is a reference to non-const qualified T.
13281 2 if D is a copy constructor or copy assignment operator whose
13282 first parameter is a reference to const qualified T.
13283
13284 This function can be used as a predicate. Positive values indicate
13285 a copy constructor and nonzero values indicate a copy assignment
13286 operator. */
13287
13288 int
copy_fn_p(const_tree d)13289 copy_fn_p (const_tree d)
13290 {
13291 tree args;
13292 tree arg_type;
13293 int result = 1;
13294
13295 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
13296
13297 if (TREE_CODE (d) == TEMPLATE_DECL
13298 || (DECL_TEMPLATE_INFO (d)
13299 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
13300 /* Instantiations of template member functions are never copy
13301 functions. Note that member functions of templated classes are
13302 represented as template functions internally, and we must
13303 accept those as copy functions. */
13304 return 0;
13305
13306 args = FUNCTION_FIRST_USER_PARMTYPE (d);
13307 if (!args)
13308 return 0;
13309
13310 arg_type = TREE_VALUE (args);
13311 if (arg_type == error_mark_node)
13312 return 0;
13313
13314 if (TYPE_MAIN_VARIANT (arg_type) == DECL_CONTEXT (d))
13315 {
13316 /* Pass by value copy assignment operator. */
13317 result = -1;
13318 }
13319 else if (TYPE_REF_P (arg_type)
13320 && !TYPE_REF_IS_RVALUE (arg_type)
13321 && TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)) == DECL_CONTEXT (d))
13322 {
13323 if (CP_TYPE_CONST_P (TREE_TYPE (arg_type)))
13324 result = 2;
13325 }
13326 else
13327 return 0;
13328
13329 args = TREE_CHAIN (args);
13330
13331 if (args && args != void_list_node && !TREE_PURPOSE (args))
13332 /* There are more non-optional args. */
13333 return 0;
13334
13335 return result;
13336 }
13337
13338 /* D is a constructor or overloaded `operator='.
13339
13340 Let T be the class in which D is declared. Then, this function
13341 returns true when D is a move constructor or move assignment
13342 operator, false otherwise. */
13343
13344 bool
move_fn_p(const_tree d)13345 move_fn_p (const_tree d)
13346 {
13347 gcc_assert (DECL_FUNCTION_MEMBER_P (d));
13348
13349 if (cxx_dialect == cxx98)
13350 /* There are no move constructors if we are in C++98 mode. */
13351 return false;
13352
13353 if (TREE_CODE (d) == TEMPLATE_DECL
13354 || (DECL_TEMPLATE_INFO (d)
13355 && DECL_MEMBER_TEMPLATE_P (DECL_TI_TEMPLATE (d))))
13356 /* Instantiations of template member functions are never move
13357 functions. Note that member functions of templated classes are
13358 represented as template functions internally, and we must
13359 accept those as move functions. */
13360 return 0;
13361
13362 return move_signature_fn_p (d);
13363 }
13364
13365 /* D is a constructor or overloaded `operator='.
13366
13367 Then, this function returns true when D has the same signature as a move
13368 constructor or move assignment operator (because either it is such a
13369 ctor/op= or it is a template specialization with the same signature),
13370 false otherwise. */
13371
13372 bool
move_signature_fn_p(const_tree d)13373 move_signature_fn_p (const_tree d)
13374 {
13375 tree args;
13376 tree arg_type;
13377 bool result = false;
13378
13379 args = FUNCTION_FIRST_USER_PARMTYPE (d);
13380 if (!args)
13381 return 0;
13382
13383 arg_type = TREE_VALUE (args);
13384 if (arg_type == error_mark_node)
13385 return 0;
13386
13387 if (TYPE_REF_P (arg_type)
13388 && TYPE_REF_IS_RVALUE (arg_type)
13389 && same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (arg_type)),
13390 DECL_CONTEXT (d)))
13391 result = true;
13392
13393 args = TREE_CHAIN (args);
13394
13395 if (args && args != void_list_node && !TREE_PURPOSE (args))
13396 /* There are more non-optional args. */
13397 return false;
13398
13399 return result;
13400 }
13401
13402 /* Remember any special properties of member function DECL. */
13403
13404 void
grok_special_member_properties(tree decl)13405 grok_special_member_properties (tree decl)
13406 {
13407 tree class_type;
13408
13409 if (TREE_CODE (decl) == USING_DECL
13410 || !DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
13411 return;
13412
13413 class_type = DECL_CONTEXT (decl);
13414 if (IDENTIFIER_CTOR_P (DECL_NAME (decl)))
13415 {
13416 int ctor = copy_fn_p (decl);
13417
13418 if (!DECL_ARTIFICIAL (decl))
13419 TYPE_HAS_USER_CONSTRUCTOR (class_type) = 1;
13420
13421 if (ctor > 0)
13422 {
13423 /* [class.copy]
13424
13425 A non-template constructor for class X is a copy
13426 constructor if its first parameter is of type X&, const
13427 X&, volatile X& or const volatile X&, and either there
13428 are no other parameters or else all other parameters have
13429 default arguments. */
13430 TYPE_HAS_COPY_CTOR (class_type) = 1;
13431 if (user_provided_p (decl))
13432 TYPE_HAS_COMPLEX_COPY_CTOR (class_type) = 1;
13433 if (ctor > 1)
13434 TYPE_HAS_CONST_COPY_CTOR (class_type) = 1;
13435 }
13436 else if (sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (decl)))
13437 TYPE_HAS_DEFAULT_CONSTRUCTOR (class_type) = 1;
13438 else if (move_fn_p (decl) && user_provided_p (decl))
13439 TYPE_HAS_COMPLEX_MOVE_CTOR (class_type) = 1;
13440 else if (is_list_ctor (decl))
13441 TYPE_HAS_LIST_CTOR (class_type) = 1;
13442
13443 if (DECL_DECLARED_CONSTEXPR_P (decl)
13444 && !ctor && !move_fn_p (decl))
13445 TYPE_HAS_CONSTEXPR_CTOR (class_type) = 1;
13446 }
13447 else if (DECL_NAME (decl) == assign_op_identifier)
13448 {
13449 /* [class.copy]
13450
13451 A non-template assignment operator for class X is a copy
13452 assignment operator if its parameter is of type X, X&, const
13453 X&, volatile X& or const volatile X&. */
13454
13455 int assop = copy_fn_p (decl);
13456
13457 if (assop)
13458 {
13459 TYPE_HAS_COPY_ASSIGN (class_type) = 1;
13460 if (user_provided_p (decl))
13461 TYPE_HAS_COMPLEX_COPY_ASSIGN (class_type) = 1;
13462 if (assop != 1)
13463 TYPE_HAS_CONST_COPY_ASSIGN (class_type) = 1;
13464 }
13465 else if (move_fn_p (decl) && user_provided_p (decl))
13466 TYPE_HAS_COMPLEX_MOVE_ASSIGN (class_type) = 1;
13467 }
13468 else if (IDENTIFIER_CONV_OP_P (DECL_NAME (decl)))
13469 TYPE_HAS_CONVERSION (class_type) = true;
13470
13471 /* Destructors are handled in check_methods. */
13472 }
13473
13474 /* Check a constructor DECL has the correct form. Complains
13475 if the class has a constructor of the form X(X). */
13476
13477 bool
grok_ctor_properties(const_tree ctype,const_tree decl)13478 grok_ctor_properties (const_tree ctype, const_tree decl)
13479 {
13480 int ctor_parm = copy_fn_p (decl);
13481
13482 if (ctor_parm < 0)
13483 {
13484 /* [class.copy]
13485
13486 A declaration of a constructor for a class X is ill-formed if
13487 its first parameter is of type (optionally cv-qualified) X
13488 and either there are no other parameters or else all other
13489 parameters have default arguments.
13490
13491 We *don't* complain about member template instantiations that
13492 have this form, though; they can occur as we try to decide
13493 what constructor to use during overload resolution. Since
13494 overload resolution will never prefer such a constructor to
13495 the non-template copy constructor (which is either explicitly
13496 or implicitly defined), there's no need to worry about their
13497 existence. Theoretically, they should never even be
13498 instantiated, but that's hard to forestall. */
13499 error ("invalid constructor; you probably meant %<%T (const %T&)%>",
13500 ctype, ctype);
13501 return false;
13502 }
13503
13504 return true;
13505 }
13506
13507 /* DECL is a declaration for an overloaded or conversion operator. If
13508 COMPLAIN is true, errors are issued for invalid declarations. */
13509
13510 bool
grok_op_properties(tree decl,bool complain)13511 grok_op_properties (tree decl, bool complain)
13512 {
13513 tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
13514 bool methodp = TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE;
13515 tree name = DECL_NAME (decl);
13516 location_t loc = DECL_SOURCE_LOCATION (decl);
13517
13518 tree class_type = DECL_CONTEXT (decl);
13519 if (class_type && !CLASS_TYPE_P (class_type))
13520 class_type = NULL_TREE;
13521
13522 tree_code operator_code;
13523 unsigned op_flags;
13524 if (IDENTIFIER_CONV_OP_P (name))
13525 {
13526 /* Conversion operators are TYPE_EXPR for the purposes of this
13527 function. */
13528 operator_code = TYPE_EXPR;
13529 op_flags = OVL_OP_FLAG_UNARY;
13530 }
13531 else
13532 {
13533 const ovl_op_info_t *ovl_op = IDENTIFIER_OVL_OP_INFO (name);
13534
13535 operator_code = ovl_op->tree_code;
13536 op_flags = ovl_op->flags;
13537 gcc_checking_assert (operator_code != ERROR_MARK);
13538 DECL_OVERLOADED_OPERATOR_CODE_RAW (decl) = ovl_op->ovl_op_code;
13539 }
13540
13541 if (op_flags & OVL_OP_FLAG_ALLOC)
13542 {
13543 /* operator new and operator delete are quite special. */
13544 if (class_type)
13545 switch (op_flags)
13546 {
13547 case OVL_OP_FLAG_ALLOC:
13548 TYPE_HAS_NEW_OPERATOR (class_type) = 1;
13549 break;
13550
13551 case OVL_OP_FLAG_ALLOC | OVL_OP_FLAG_DELETE:
13552 TYPE_GETS_DELETE (class_type) |= 1;
13553 break;
13554
13555 case OVL_OP_FLAG_ALLOC | OVL_OP_FLAG_VEC:
13556 TYPE_HAS_ARRAY_NEW_OPERATOR (class_type) = 1;
13557 break;
13558
13559 case OVL_OP_FLAG_ALLOC | OVL_OP_FLAG_DELETE | OVL_OP_FLAG_VEC:
13560 TYPE_GETS_DELETE (class_type) |= 2;
13561 break;
13562
13563 default:
13564 gcc_unreachable ();
13565 }
13566
13567 /* [basic.std.dynamic.allocation]/1:
13568
13569 A program is ill-formed if an allocation function is declared
13570 in a namespace scope other than global scope or declared
13571 static in global scope.
13572
13573 The same also holds true for deallocation functions. */
13574 if (DECL_NAMESPACE_SCOPE_P (decl))
13575 {
13576 if (CP_DECL_CONTEXT (decl) != global_namespace)
13577 {
13578 error_at (loc, "%qD may not be declared within a namespace",
13579 decl);
13580 return false;
13581 }
13582
13583 if (!TREE_PUBLIC (decl))
13584 {
13585 error_at (loc, "%qD may not be declared as static", decl);
13586 return false;
13587 }
13588 }
13589
13590 if (op_flags & OVL_OP_FLAG_DELETE)
13591 coerce_delete_type (decl, loc);
13592 else
13593 {
13594 DECL_IS_OPERATOR_NEW (decl) = 1;
13595 TREE_TYPE (decl) = coerce_new_type (TREE_TYPE (decl), loc);
13596 }
13597
13598 return true;
13599 }
13600
13601 /* An operator function must either be a non-static member function
13602 or have at least one parameter of a class, a reference to a class,
13603 an enumeration, or a reference to an enumeration. 13.4.0.6 */
13604 if (! methodp || DECL_STATIC_FUNCTION_P (decl))
13605 {
13606 if (operator_code == TYPE_EXPR
13607 || operator_code == CALL_EXPR
13608 || operator_code == COMPONENT_REF
13609 || operator_code == ARRAY_REF
13610 || operator_code == NOP_EXPR)
13611 {
13612 error_at (loc, "%qD must be a nonstatic member function", decl);
13613 return false;
13614 }
13615
13616 if (DECL_STATIC_FUNCTION_P (decl))
13617 {
13618 error_at (loc, "%qD must be either a non-static member "
13619 "function or a non-member function", decl);
13620 return false;
13621 }
13622
13623 for (tree arg = argtypes; ; arg = TREE_CHAIN (arg))
13624 {
13625 if (!arg || arg == void_list_node)
13626 {
13627 if (complain)
13628 error_at(loc, "%qD must have an argument of class or "
13629 "enumerated type", decl);
13630 return false;
13631 }
13632
13633 tree type = non_reference (TREE_VALUE (arg));
13634 if (type == error_mark_node)
13635 return false;
13636
13637 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
13638 because these checks are performed even on template
13639 functions. */
13640 if (MAYBE_CLASS_TYPE_P (type)
13641 || TREE_CODE (type) == ENUMERAL_TYPE)
13642 break;
13643 }
13644 }
13645
13646 if (operator_code == CALL_EXPR)
13647 /* There are no further restrictions on the arguments to an overloaded
13648 "operator ()". */
13649 return true;
13650
13651 if (operator_code == COND_EXPR)
13652 {
13653 /* 13.4.0.3 */
13654 error_at (loc, "ISO C++ prohibits overloading operator ?:");
13655 return false;
13656 }
13657
13658 /* Count the number of arguments and check for ellipsis. */
13659 int arity = 0;
13660 for (tree arg = argtypes; arg != void_list_node; arg = TREE_CHAIN (arg))
13661 {
13662 if (!arg)
13663 {
13664 /* Variadic. */
13665 error_at (loc, "%qD must not have variable number of arguments",
13666 decl);
13667 return false;
13668 }
13669 ++arity;
13670 }
13671
13672 /* Verify correct number of arguments. */
13673 switch (op_flags)
13674 {
13675 case OVL_OP_FLAG_AMBIARY:
13676 if (arity == 1)
13677 {
13678 /* We have a unary instance of an ambi-ary op. Remap to the
13679 unary one. */
13680 unsigned alt = ovl_op_alternate[ovl_op_mapping [operator_code]];
13681 const ovl_op_info_t *ovl_op = &ovl_op_info[false][alt];
13682 gcc_checking_assert (ovl_op->flags == OVL_OP_FLAG_UNARY);
13683 operator_code = ovl_op->tree_code;
13684 DECL_OVERLOADED_OPERATOR_CODE_RAW (decl) = ovl_op->ovl_op_code;
13685 }
13686 else if (arity != 2)
13687 {
13688 /* This was an ambiguous operator but is invalid. */
13689 error_at (loc,
13690 methodp
13691 ? G_("%qD must have either zero or one argument")
13692 : G_("%qD must have either one or two arguments"), decl);
13693 return false;
13694 }
13695 else if ((operator_code == POSTINCREMENT_EXPR
13696 || operator_code == POSTDECREMENT_EXPR)
13697 && ! processing_template_decl
13698 /* x++ and x--'s second argument must be an int. */
13699 && ! same_type_p (TREE_VALUE (TREE_CHAIN (argtypes)),
13700 integer_type_node))
13701 {
13702 error_at (loc,
13703 methodp
13704 ? G_("postfix %qD must have %<int%> as its argument")
13705 : G_("postfix %qD must have %<int%> as its second argument"),
13706 decl);
13707 return false;
13708 }
13709 break;
13710
13711 case OVL_OP_FLAG_UNARY:
13712 if (arity != 1)
13713 {
13714 error_at (loc,
13715 methodp
13716 ? G_("%qD must have no arguments")
13717 : G_("%qD must have exactly one argument"), decl);
13718 return false;
13719 }
13720 break;
13721
13722 case OVL_OP_FLAG_BINARY:
13723 if (arity != 2)
13724 {
13725 error_at (loc,
13726 methodp
13727 ? G_("%qD must have exactly one argument")
13728 : G_("%qD must have exactly two arguments"), decl);
13729 return false;
13730 }
13731 break;
13732
13733 default:
13734 gcc_unreachable ();
13735 }
13736
13737 /* There can be no default arguments. */
13738 for (tree arg = argtypes; arg != void_list_node; arg = TREE_CHAIN (arg))
13739 if (TREE_PURPOSE (arg))
13740 {
13741 TREE_PURPOSE (arg) = NULL_TREE;
13742 error_at (loc, "%qD cannot have default arguments", decl);
13743 return false;
13744 }
13745
13746 /* At this point the declaration is well-formed. It may not be
13747 sensible though. */
13748
13749 /* Check member function warnings only on the in-class declaration.
13750 There's no point warning on an out-of-class definition. */
13751 if (class_type && class_type != current_class_type)
13752 return true;
13753
13754 /* Warn about conversion operators that will never be used. */
13755 if (IDENTIFIER_CONV_OP_P (name)
13756 && ! DECL_TEMPLATE_INFO (decl)
13757 && warn_class_conversion)
13758 {
13759 tree t = TREE_TYPE (name);
13760 int ref = TYPE_REF_P (t);
13761
13762 if (ref)
13763 t = TYPE_MAIN_VARIANT (TREE_TYPE (t));
13764
13765 if (VOID_TYPE_P (t))
13766 warning_at (loc, OPT_Wclass_conversion, "converting %qT to %<void%> "
13767 "will never use a type conversion operator", class_type);
13768 else if (class_type)
13769 {
13770 if (same_type_ignoring_top_level_qualifiers_p (t, class_type))
13771 warning_at (loc, OPT_Wclass_conversion,
13772 ref
13773 ? G_("converting %qT to a reference to the same type "
13774 "will never use a type conversion operator")
13775 : G_("converting %qT to the same type "
13776 "will never use a type conversion operator"),
13777 class_type);
13778 /* Don't force t to be complete here. */
13779 else if (MAYBE_CLASS_TYPE_P (t)
13780 && COMPLETE_TYPE_P (t)
13781 && DERIVED_FROM_P (t, class_type))
13782 warning_at (loc, OPT_Wclass_conversion,
13783 ref
13784 ? G_("converting %qT to a reference to a base class "
13785 "%qT will never use a type conversion operator")
13786 : G_("converting %qT to a base class %qT "
13787 "will never use a type conversion operator"),
13788 class_type, t);
13789 }
13790 }
13791
13792 if (!warn_ecpp)
13793 return true;
13794
13795 /* Effective C++ rules below. */
13796
13797 /* More Effective C++ rule 7. */
13798 if (operator_code == TRUTH_ANDIF_EXPR
13799 || operator_code == TRUTH_ORIF_EXPR
13800 || operator_code == COMPOUND_EXPR)
13801 warning_at (loc, OPT_Weffc__,
13802 "user-defined %qD always evaluates both arguments", decl);
13803
13804 /* More Effective C++ rule 6. */
13805 if (operator_code == POSTINCREMENT_EXPR
13806 || operator_code == POSTDECREMENT_EXPR
13807 || operator_code == PREINCREMENT_EXPR
13808 || operator_code == PREDECREMENT_EXPR)
13809 {
13810 tree arg = TREE_VALUE (argtypes);
13811 tree ret = TREE_TYPE (TREE_TYPE (decl));
13812 if (methodp || TYPE_REF_P (arg))
13813 arg = TREE_TYPE (arg);
13814 arg = TYPE_MAIN_VARIANT (arg);
13815
13816 if (operator_code == PREINCREMENT_EXPR
13817 || operator_code == PREDECREMENT_EXPR)
13818 {
13819 if (!TYPE_REF_P (ret)
13820 || !same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ret)), arg))
13821 warning_at (loc, OPT_Weffc__, "prefix %qD should return %qT", decl,
13822 build_reference_type (arg));
13823 }
13824 else
13825 {
13826 if (!same_type_p (TYPE_MAIN_VARIANT (ret), arg))
13827 warning_at (loc, OPT_Weffc__,
13828 "postfix %qD should return %qT", decl, arg);
13829 }
13830 }
13831
13832 /* Effective C++ rule 23. */
13833 if (!DECL_ASSIGNMENT_OPERATOR_P (decl)
13834 && (operator_code == PLUS_EXPR
13835 || operator_code == MINUS_EXPR
13836 || operator_code == TRUNC_DIV_EXPR
13837 || operator_code == MULT_EXPR
13838 || operator_code == TRUNC_MOD_EXPR)
13839 && TYPE_REF_P (TREE_TYPE (TREE_TYPE (decl))))
13840 warning_at (loc, OPT_Weffc__, "%qD should return by value", decl);
13841
13842 return true;
13843 }
13844
13845 /* Return a string giving the keyword associate with CODE. */
13846
13847 static const char *
tag_name(enum tag_types code)13848 tag_name (enum tag_types code)
13849 {
13850 switch (code)
13851 {
13852 case record_type:
13853 return "struct";
13854 case class_type:
13855 return "class";
13856 case union_type:
13857 return "union";
13858 case enum_type:
13859 return "enum";
13860 case typename_type:
13861 return "typename";
13862 default:
13863 gcc_unreachable ();
13864 }
13865 }
13866
13867 /* Name lookup in an elaborated-type-specifier (after the keyword
13868 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
13869 elaborated-type-specifier is invalid, issue a diagnostic and return
13870 error_mark_node; otherwise, return the *_TYPE to which it referred.
13871 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
13872
13873 tree
check_elaborated_type_specifier(enum tag_types tag_code,tree decl,bool allow_template_p)13874 check_elaborated_type_specifier (enum tag_types tag_code,
13875 tree decl,
13876 bool allow_template_p)
13877 {
13878 tree type;
13879
13880 /* In the case of:
13881
13882 struct S { struct S *p; };
13883
13884 name lookup will find the TYPE_DECL for the implicit "S::S"
13885 typedef. Adjust for that here. */
13886 if (DECL_SELF_REFERENCE_P (decl))
13887 decl = TYPE_NAME (TREE_TYPE (decl));
13888
13889 type = TREE_TYPE (decl);
13890
13891 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
13892 is false for this case as well. */
13893 if (TREE_CODE (type) == TEMPLATE_TYPE_PARM)
13894 {
13895 error ("using template type parameter %qT after %qs",
13896 type, tag_name (tag_code));
13897 return error_mark_node;
13898 }
13899 /* Accept template template parameters. */
13900 else if (allow_template_p
13901 && (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM
13902 || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM))
13903 ;
13904 /* [dcl.type.elab]
13905
13906 If the identifier resolves to a typedef-name or the
13907 simple-template-id resolves to an alias template
13908 specialization, the elaborated-type-specifier is ill-formed.
13909
13910 In other words, the only legitimate declaration to use in the
13911 elaborated type specifier is the implicit typedef created when
13912 the type is declared. */
13913 else if (!DECL_IMPLICIT_TYPEDEF_P (decl)
13914 && !DECL_SELF_REFERENCE_P (decl)
13915 && tag_code != typename_type)
13916 {
13917 if (alias_template_specialization_p (type))
13918 error ("using alias template specialization %qT after %qs",
13919 type, tag_name (tag_code));
13920 else
13921 error ("using typedef-name %qD after %qs", decl, tag_name (tag_code));
13922 inform (DECL_SOURCE_LOCATION (decl),
13923 "%qD has a previous declaration here", decl);
13924 return error_mark_node;
13925 }
13926 else if (TREE_CODE (type) != RECORD_TYPE
13927 && TREE_CODE (type) != UNION_TYPE
13928 && tag_code != enum_type
13929 && tag_code != typename_type)
13930 {
13931 error ("%qT referred to as %qs", type, tag_name (tag_code));
13932 inform (location_of (type), "%qT has a previous declaration here", type);
13933 return error_mark_node;
13934 }
13935 else if (TREE_CODE (type) != ENUMERAL_TYPE
13936 && tag_code == enum_type)
13937 {
13938 error ("%qT referred to as enum", type);
13939 inform (location_of (type), "%qT has a previous declaration here", type);
13940 return error_mark_node;
13941 }
13942 else if (!allow_template_p
13943 && TREE_CODE (type) == RECORD_TYPE
13944 && CLASSTYPE_IS_TEMPLATE (type))
13945 {
13946 /* If a class template appears as elaborated type specifier
13947 without a template header such as:
13948
13949 template <class T> class C {};
13950 void f(class C); // No template header here
13951
13952 then the required template argument is missing. */
13953 error ("template argument required for %<%s %T%>",
13954 tag_name (tag_code),
13955 DECL_NAME (CLASSTYPE_TI_TEMPLATE (type)));
13956 return error_mark_node;
13957 }
13958
13959 return type;
13960 }
13961
13962 /* Lookup NAME in elaborate type specifier in scope according to
13963 SCOPE and issue diagnostics if necessary.
13964 Return *_TYPE node upon success, NULL_TREE when the NAME is not
13965 found, and ERROR_MARK_NODE for type error. */
13966
13967 static tree
lookup_and_check_tag(enum tag_types tag_code,tree name,tag_scope scope,bool template_header_p)13968 lookup_and_check_tag (enum tag_types tag_code, tree name,
13969 tag_scope scope, bool template_header_p)
13970 {
13971 tree t;
13972 tree decl;
13973 if (scope == ts_global)
13974 {
13975 /* First try ordinary name lookup, ignoring hidden class name
13976 injected via friend declaration. */
13977 decl = lookup_name_prefer_type (name, 2);
13978 decl = strip_using_decl (decl);
13979 /* If that fails, the name will be placed in the smallest
13980 non-class, non-function-prototype scope according to 3.3.1/5.
13981 We may already have a hidden name declared as friend in this
13982 scope. So lookup again but not ignoring hidden names.
13983 If we find one, that name will be made visible rather than
13984 creating a new tag. */
13985 if (!decl)
13986 decl = lookup_type_scope (name, ts_within_enclosing_non_class);
13987 }
13988 else
13989 decl = lookup_type_scope (name, scope);
13990
13991 if (decl
13992 && (DECL_CLASS_TEMPLATE_P (decl)
13993 /* If scope is ts_current we're defining a class, so ignore a
13994 template template parameter. */
13995 || (scope != ts_current
13996 && DECL_TEMPLATE_TEMPLATE_PARM_P (decl))))
13997 decl = DECL_TEMPLATE_RESULT (decl);
13998
13999 if (decl && TREE_CODE (decl) == TYPE_DECL)
14000 {
14001 /* Look for invalid nested type:
14002 class C {
14003 class C {};
14004 }; */
14005 if (scope == ts_current && DECL_SELF_REFERENCE_P (decl))
14006 {
14007 error ("%qD has the same name as the class in which it is "
14008 "declared",
14009 decl);
14010 return error_mark_node;
14011 }
14012
14013 /* Two cases we need to consider when deciding if a class
14014 template is allowed as an elaborated type specifier:
14015 1. It is a self reference to its own class.
14016 2. It comes with a template header.
14017
14018 For example:
14019
14020 template <class T> class C {
14021 class C *c1; // DECL_SELF_REFERENCE_P is true
14022 class D;
14023 };
14024 template <class U> class C; // template_header_p is true
14025 template <class T> class C<T>::D {
14026 class C *c2; // DECL_SELF_REFERENCE_P is true
14027 }; */
14028
14029 t = check_elaborated_type_specifier (tag_code,
14030 decl,
14031 template_header_p
14032 | DECL_SELF_REFERENCE_P (decl));
14033 if (template_header_p && t && CLASS_TYPE_P (t)
14034 && (!CLASSTYPE_TEMPLATE_INFO (t)
14035 || (!PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (t)))))
14036 {
14037 error ("%qT is not a template", t);
14038 inform (location_of (t), "previous declaration here");
14039 if (TYPE_CLASS_SCOPE_P (t)
14040 && CLASSTYPE_TEMPLATE_INFO (TYPE_CONTEXT (t)))
14041 inform (input_location,
14042 "perhaps you want to explicitly add %<%T::%>",
14043 TYPE_CONTEXT (t));
14044 t = error_mark_node;
14045 }
14046
14047 return t;
14048 }
14049 else if (decl && TREE_CODE (decl) == TREE_LIST)
14050 {
14051 error ("reference to %qD is ambiguous", name);
14052 print_candidates (decl);
14053 return error_mark_node;
14054 }
14055 else
14056 return NULL_TREE;
14057 }
14058
14059 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
14060 Define the tag as a forward-reference if it is not defined.
14061
14062 If a declaration is given, process it here, and report an error if
14063 multiple declarations are not identical.
14064
14065 SCOPE is TS_CURRENT when this is also a definition. Only look in
14066 the current frame for the name (since C++ allows new names in any
14067 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
14068 declaration. Only look beginning from the current scope outward up
14069 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
14070
14071 TEMPLATE_HEADER_P is true when this declaration is preceded by
14072 a set of template parameters. */
14073
14074 static tree
xref_tag_1(enum tag_types tag_code,tree name,tag_scope scope,bool template_header_p)14075 xref_tag_1 (enum tag_types tag_code, tree name,
14076 tag_scope scope, bool template_header_p)
14077 {
14078 enum tree_code code;
14079 tree context = NULL_TREE;
14080
14081 gcc_assert (identifier_p (name));
14082
14083 switch (tag_code)
14084 {
14085 case record_type:
14086 case class_type:
14087 code = RECORD_TYPE;
14088 break;
14089 case union_type:
14090 code = UNION_TYPE;
14091 break;
14092 case enum_type:
14093 code = ENUMERAL_TYPE;
14094 break;
14095 default:
14096 gcc_unreachable ();
14097 }
14098
14099 /* In case of anonymous name, xref_tag is only called to
14100 make type node and push name. Name lookup is not required. */
14101 tree t = NULL_TREE;
14102 if (scope != ts_lambda && !anon_aggrname_p (name))
14103 t = lookup_and_check_tag (tag_code, name, scope, template_header_p);
14104
14105 if (t == error_mark_node)
14106 return error_mark_node;
14107
14108 if (scope != ts_current && t && current_class_type
14109 && template_class_depth (current_class_type)
14110 && template_header_p)
14111 {
14112 if (TREE_CODE (t) == TEMPLATE_TEMPLATE_PARM)
14113 return t;
14114
14115 /* Since SCOPE is not TS_CURRENT, we are not looking at a
14116 definition of this tag. Since, in addition, we are currently
14117 processing a (member) template declaration of a template
14118 class, we must be very careful; consider:
14119
14120 template <class X> struct S1
14121
14122 template <class U> struct S2
14123 {
14124 template <class V> friend struct S1;
14125 };
14126
14127 Here, the S2::S1 declaration should not be confused with the
14128 outer declaration. In particular, the inner version should
14129 have a template parameter of level 2, not level 1.
14130
14131 On the other hand, when presented with:
14132
14133 template <class T> struct S1
14134 {
14135 template <class U> struct S2 {};
14136 template <class U> friend struct S2;
14137 };
14138
14139 the friend must find S1::S2 eventually. We accomplish this
14140 by making sure that the new type we create to represent this
14141 declaration has the right TYPE_CONTEXT. */
14142 context = TYPE_CONTEXT (t);
14143 t = NULL_TREE;
14144 }
14145
14146 if (! t)
14147 {
14148 /* If no such tag is yet defined, create a forward-reference node
14149 and record it as the "definition".
14150 When a real declaration of this type is found,
14151 the forward-reference will be altered into a real type. */
14152 if (code == ENUMERAL_TYPE)
14153 {
14154 error ("use of enum %q#D without previous declaration", name);
14155 return error_mark_node;
14156 }
14157 else
14158 {
14159 t = make_class_type (code);
14160 TYPE_CONTEXT (t) = context;
14161 if (scope == ts_lambda)
14162 {
14163 /* Mark it as a lambda type. */
14164 CLASSTYPE_LAMBDA_EXPR (t) = error_mark_node;
14165 /* And push it into current scope. */
14166 scope = ts_current;
14167 }
14168 t = pushtag (name, t, scope);
14169 }
14170 }
14171 else
14172 {
14173 if (template_header_p && MAYBE_CLASS_TYPE_P (t))
14174 {
14175 /* Check that we aren't trying to overload a class with different
14176 constraints. */
14177 tree constr = NULL_TREE;
14178 if (current_template_parms)
14179 {
14180 tree reqs = TEMPLATE_PARMS_CONSTRAINTS (current_template_parms);
14181 constr = build_constraints (reqs, NULL_TREE);
14182 }
14183 if (!redeclare_class_template (t, current_template_parms, constr))
14184 return error_mark_node;
14185 }
14186 else if (!processing_template_decl
14187 && CLASS_TYPE_P (t)
14188 && CLASSTYPE_IS_TEMPLATE (t))
14189 {
14190 error ("redeclaration of %qT as a non-template", t);
14191 inform (location_of (t), "previous declaration %qD", t);
14192 return error_mark_node;
14193 }
14194
14195 if (scope != ts_within_enclosing_non_class && TYPE_HIDDEN_P (t))
14196 {
14197 /* This is no longer an invisible friend. Make it
14198 visible. */
14199 tree decl = TYPE_NAME (t);
14200
14201 DECL_ANTICIPATED (decl) = false;
14202 DECL_FRIEND_P (decl) = false;
14203
14204 if (TYPE_TEMPLATE_INFO (t))
14205 {
14206 tree tmpl = TYPE_TI_TEMPLATE (t);
14207 DECL_ANTICIPATED (tmpl) = false;
14208 DECL_FRIEND_P (tmpl) = false;
14209 }
14210 }
14211 }
14212
14213 return t;
14214 }
14215
14216 /* Wrapper for xref_tag_1. */
14217
14218 tree
xref_tag(enum tag_types tag_code,tree name,tag_scope scope,bool template_header_p)14219 xref_tag (enum tag_types tag_code, tree name,
14220 tag_scope scope, bool template_header_p)
14221 {
14222 tree ret;
14223 bool subtime;
14224 subtime = timevar_cond_start (TV_NAME_LOOKUP);
14225 ret = xref_tag_1 (tag_code, name, scope, template_header_p);
14226 timevar_cond_stop (TV_NAME_LOOKUP, subtime);
14227 return ret;
14228 }
14229
14230
14231 tree
xref_tag_from_type(tree old,tree id,tag_scope scope)14232 xref_tag_from_type (tree old, tree id, tag_scope scope)
14233 {
14234 enum tag_types tag_kind;
14235
14236 if (TREE_CODE (old) == RECORD_TYPE)
14237 tag_kind = (CLASSTYPE_DECLARED_CLASS (old) ? class_type : record_type);
14238 else
14239 tag_kind = union_type;
14240
14241 if (id == NULL_TREE)
14242 id = TYPE_IDENTIFIER (old);
14243
14244 return xref_tag (tag_kind, id, scope, false);
14245 }
14246
14247 /* Create the binfo hierarchy for REF with (possibly NULL) base list
14248 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
14249 access_* node, and the TREE_VALUE is the type of the base-class.
14250 Non-NULL TREE_TYPE indicates virtual inheritance. */
14251
14252 void
xref_basetypes(tree ref,tree base_list)14253 xref_basetypes (tree ref, tree base_list)
14254 {
14255 tree *basep;
14256 tree binfo, base_binfo;
14257 unsigned max_vbases = 0; /* Maximum direct & indirect virtual bases. */
14258 unsigned max_bases = 0; /* Maximum direct bases. */
14259 unsigned max_dvbases = 0; /* Maximum direct virtual bases. */
14260 int i;
14261 tree default_access;
14262 tree igo_prev; /* Track Inheritance Graph Order. */
14263
14264 if (ref == error_mark_node)
14265 return;
14266
14267 /* The base of a derived class is private by default, all others are
14268 public. */
14269 default_access = (TREE_CODE (ref) == RECORD_TYPE
14270 && CLASSTYPE_DECLARED_CLASS (ref)
14271 ? access_private_node : access_public_node);
14272
14273 /* First, make sure that any templates in base-classes are
14274 instantiated. This ensures that if we call ourselves recursively
14275 we do not get confused about which classes are marked and which
14276 are not. */
14277 basep = &base_list;
14278 while (*basep)
14279 {
14280 tree basetype = TREE_VALUE (*basep);
14281
14282 /* The dependent_type_p call below should really be dependent_scope_p
14283 so that we give a hard error about using an incomplete type as a
14284 base, but we allow it with a pedwarn for backward
14285 compatibility. */
14286 if (processing_template_decl
14287 && CLASS_TYPE_P (basetype) && TYPE_BEING_DEFINED (basetype))
14288 cxx_incomplete_type_diagnostic (NULL_TREE, basetype, DK_PEDWARN);
14289 if (!dependent_type_p (basetype)
14290 && !complete_type_or_else (basetype, NULL))
14291 /* An incomplete type. Remove it from the list. */
14292 *basep = TREE_CHAIN (*basep);
14293 else
14294 {
14295 max_bases++;
14296 if (TREE_TYPE (*basep))
14297 max_dvbases++;
14298 if (CLASS_TYPE_P (basetype))
14299 max_vbases += vec_safe_length (CLASSTYPE_VBASECLASSES (basetype));
14300 basep = &TREE_CHAIN (*basep);
14301 }
14302 }
14303 max_vbases += max_dvbases;
14304
14305 TYPE_MARKED_P (ref) = 1;
14306
14307 /* The binfo slot should be empty, unless this is an (ill-formed)
14308 redefinition. */
14309 gcc_assert (!TYPE_BINFO (ref) || TYPE_SIZE (ref));
14310
14311 gcc_assert (TYPE_MAIN_VARIANT (ref) == ref);
14312
14313 binfo = make_tree_binfo (max_bases);
14314
14315 TYPE_BINFO (ref) = binfo;
14316 BINFO_OFFSET (binfo) = size_zero_node;
14317 BINFO_TYPE (binfo) = ref;
14318
14319 /* Apply base-class info set up to the variants of this type. */
14320 fixup_type_variants (ref);
14321
14322 if (max_bases)
14323 {
14324 vec_alloc (BINFO_BASE_ACCESSES (binfo), max_bases);
14325 /* A C++98 POD cannot have base classes. */
14326 CLASSTYPE_NON_LAYOUT_POD_P (ref) = true;
14327
14328 if (TREE_CODE (ref) == UNION_TYPE)
14329 {
14330 error ("derived union %qT invalid", ref);
14331 return;
14332 }
14333 }
14334
14335 if (max_bases > 1)
14336 warning (OPT_Wmultiple_inheritance,
14337 "%qT defined with multiple direct bases", ref);
14338
14339 if (max_vbases)
14340 {
14341 /* An aggregate can't have virtual base classes. */
14342 CLASSTYPE_NON_AGGREGATE (ref) = true;
14343
14344 vec_alloc (CLASSTYPE_VBASECLASSES (ref), max_vbases);
14345
14346 if (max_dvbases)
14347 warning (OPT_Wvirtual_inheritance,
14348 "%qT defined with direct virtual base", ref);
14349 }
14350
14351 for (igo_prev = binfo; base_list; base_list = TREE_CHAIN (base_list))
14352 {
14353 tree access = TREE_PURPOSE (base_list);
14354 int via_virtual = TREE_TYPE (base_list) != NULL_TREE;
14355 tree basetype = TREE_VALUE (base_list);
14356
14357 if (access == access_default_node)
14358 access = default_access;
14359
14360 /* Before C++17, an aggregate cannot have base classes. In C++17, an
14361 aggregate can't have virtual, private, or protected base classes. */
14362 if (cxx_dialect < cxx17
14363 || access != access_public_node
14364 || via_virtual)
14365 CLASSTYPE_NON_AGGREGATE (ref) = true;
14366
14367 if (PACK_EXPANSION_P (basetype))
14368 basetype = PACK_EXPANSION_PATTERN (basetype);
14369 if (TREE_CODE (basetype) == TYPE_DECL)
14370 basetype = TREE_TYPE (basetype);
14371 if (!MAYBE_CLASS_TYPE_P (basetype) || TREE_CODE (basetype) == UNION_TYPE)
14372 {
14373 error ("base type %qT fails to be a struct or class type",
14374 basetype);
14375 goto dropped_base;
14376 }
14377
14378 base_binfo = NULL_TREE;
14379 if (CLASS_TYPE_P (basetype) && !dependent_scope_p (basetype))
14380 {
14381 base_binfo = TYPE_BINFO (basetype);
14382 /* The original basetype could have been a typedef'd type. */
14383 basetype = BINFO_TYPE (base_binfo);
14384
14385 /* Inherit flags from the base. */
14386 TYPE_HAS_NEW_OPERATOR (ref)
14387 |= TYPE_HAS_NEW_OPERATOR (basetype);
14388 TYPE_HAS_ARRAY_NEW_OPERATOR (ref)
14389 |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);
14390 TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);
14391 TYPE_HAS_CONVERSION (ref) |= TYPE_HAS_CONVERSION (basetype);
14392 CLASSTYPE_DIAMOND_SHAPED_P (ref)
14393 |= CLASSTYPE_DIAMOND_SHAPED_P (basetype);
14394 CLASSTYPE_REPEATED_BASE_P (ref)
14395 |= CLASSTYPE_REPEATED_BASE_P (basetype);
14396 }
14397
14398 /* We must do this test after we've seen through a typedef
14399 type. */
14400 if (TYPE_MARKED_P (basetype))
14401 {
14402 if (basetype == ref)
14403 error ("recursive type %qT undefined", basetype);
14404 else
14405 error ("duplicate base type %qT invalid", basetype);
14406 goto dropped_base;
14407 }
14408
14409 if (PACK_EXPANSION_P (TREE_VALUE (base_list)))
14410 /* Regenerate the pack expansion for the bases. */
14411 basetype = make_pack_expansion (basetype);
14412
14413 TYPE_MARKED_P (basetype) = 1;
14414
14415 base_binfo = copy_binfo (base_binfo, basetype, ref,
14416 &igo_prev, via_virtual);
14417 if (!BINFO_INHERITANCE_CHAIN (base_binfo))
14418 BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
14419
14420 BINFO_BASE_APPEND (binfo, base_binfo);
14421 BINFO_BASE_ACCESS_APPEND (binfo, access);
14422 continue;
14423
14424 dropped_base:
14425 /* Update max_vbases to reflect the reality that we are dropping
14426 this base: if it reaches zero we want to undo the vec_alloc
14427 above to avoid inconsistencies during error-recovery: eg, in
14428 build_special_member_call, CLASSTYPE_VBASECLASSES non null
14429 and vtt null (c++/27952). */
14430 if (via_virtual)
14431 max_vbases--;
14432 if (CLASS_TYPE_P (basetype))
14433 max_vbases
14434 -= vec_safe_length (CLASSTYPE_VBASECLASSES (basetype));
14435 }
14436
14437 if (CLASSTYPE_VBASECLASSES (ref)
14438 && max_vbases == 0)
14439 vec_free (CLASSTYPE_VBASECLASSES (ref));
14440
14441 if (vec_safe_length (CLASSTYPE_VBASECLASSES (ref)) < max_vbases)
14442 /* If we didn't get max_vbases vbases, we must have shared at
14443 least one of them, and are therefore diamond shaped. */
14444 CLASSTYPE_DIAMOND_SHAPED_P (ref) = 1;
14445
14446 /* Unmark all the types. */
14447 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
14448 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
14449 TYPE_MARKED_P (ref) = 0;
14450
14451 /* Now see if we have a repeated base type. */
14452 if (!CLASSTYPE_REPEATED_BASE_P (ref))
14453 {
14454 for (base_binfo = binfo; base_binfo;
14455 base_binfo = TREE_CHAIN (base_binfo))
14456 {
14457 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
14458 {
14459 CLASSTYPE_REPEATED_BASE_P (ref) = 1;
14460 break;
14461 }
14462 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 1;
14463 }
14464 for (base_binfo = binfo; base_binfo;
14465 base_binfo = TREE_CHAIN (base_binfo))
14466 if (TYPE_MARKED_P (BINFO_TYPE (base_binfo)))
14467 TYPE_MARKED_P (BINFO_TYPE (base_binfo)) = 0;
14468 else
14469 break;
14470 }
14471 }
14472
14473
14474 /* Copies the enum-related properties from type SRC to type DST.
14475 Used with the underlying type of an enum and the enum itself. */
14476 static void
copy_type_enum(tree dst,tree src)14477 copy_type_enum (tree dst, tree src)
14478 {
14479 tree t;
14480 for (t = dst; t; t = TYPE_NEXT_VARIANT (t))
14481 {
14482 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (src);
14483 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (src);
14484 TYPE_SIZE (t) = TYPE_SIZE (src);
14485 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (src);
14486 SET_TYPE_MODE (dst, TYPE_MODE (src));
14487 TYPE_PRECISION (t) = TYPE_PRECISION (src);
14488 unsigned valign = TYPE_ALIGN (src);
14489 if (TYPE_USER_ALIGN (t))
14490 valign = MAX (valign, TYPE_ALIGN (t));
14491 else
14492 TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (src);
14493 SET_TYPE_ALIGN (t, valign);
14494 TYPE_UNSIGNED (t) = TYPE_UNSIGNED (src);
14495 }
14496 }
14497
14498 /* Begin compiling the definition of an enumeration type.
14499 NAME is its name,
14500
14501 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
14502
14503 UNDERLYING_TYPE is the type that will be used as the storage for
14504 the enumeration type. This should be NULL_TREE if no storage type
14505 was specified.
14506
14507 ATTRIBUTES are any attributes specified after the enum-key.
14508
14509 SCOPED_ENUM_P is true if this is a scoped enumeration type.
14510
14511 if IS_NEW is not NULL, gets TRUE iff a new type is created.
14512
14513 Returns the type object, as yet incomplete.
14514 Also records info about it so that build_enumerator
14515 may be used to declare the individual values as they are read. */
14516
14517 tree
start_enum(tree name,tree enumtype,tree underlying_type,tree attributes,bool scoped_enum_p,bool * is_new)14518 start_enum (tree name, tree enumtype, tree underlying_type,
14519 tree attributes, bool scoped_enum_p, bool *is_new)
14520 {
14521 tree prevtype = NULL_TREE;
14522 gcc_assert (identifier_p (name));
14523
14524 if (is_new)
14525 *is_new = false;
14526 /* [C++0x dcl.enum]p5:
14527
14528 If not explicitly specified, the underlying type of a scoped
14529 enumeration type is int. */
14530 if (!underlying_type && scoped_enum_p)
14531 underlying_type = integer_type_node;
14532
14533 if (underlying_type)
14534 underlying_type = cv_unqualified (underlying_type);
14535
14536 /* If this is the real definition for a previous forward reference,
14537 fill in the contents in the same object that used to be the
14538 forward reference. */
14539 if (!enumtype)
14540 enumtype = lookup_and_check_tag (enum_type, name,
14541 /*tag_scope=*/ts_current,
14542 /*template_header_p=*/false);
14543
14544 /* In case of a template_decl, the only check that should be deferred
14545 to instantiation time is the comparison of underlying types. */
14546 if (enumtype && TREE_CODE (enumtype) == ENUMERAL_TYPE)
14547 {
14548 if (scoped_enum_p != SCOPED_ENUM_P (enumtype))
14549 {
14550 error_at (input_location, "scoped/unscoped mismatch "
14551 "in enum %q#T", enumtype);
14552 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype)),
14553 "previous definition here");
14554 enumtype = error_mark_node;
14555 }
14556 else if (ENUM_FIXED_UNDERLYING_TYPE_P (enumtype) != !! underlying_type)
14557 {
14558 error_at (input_location, "underlying type mismatch "
14559 "in enum %q#T", enumtype);
14560 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype)),
14561 "previous definition here");
14562 enumtype = error_mark_node;
14563 }
14564 else if (underlying_type && ENUM_UNDERLYING_TYPE (enumtype)
14565 && !same_type_p (underlying_type,
14566 ENUM_UNDERLYING_TYPE (enumtype)))
14567 {
14568 error_at (input_location, "different underlying type "
14569 "in enum %q#T", enumtype);
14570 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (enumtype)),
14571 "previous definition here");
14572 underlying_type = NULL_TREE;
14573 }
14574 }
14575
14576 if (!enumtype || TREE_CODE (enumtype) != ENUMERAL_TYPE
14577 || processing_template_decl)
14578 {
14579 /* In case of error, make a dummy enum to allow parsing to
14580 continue. */
14581 if (enumtype == error_mark_node)
14582 {
14583 name = make_anon_name ();
14584 enumtype = NULL_TREE;
14585 }
14586
14587 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
14588 of an opaque enum, or an opaque enum of an already defined
14589 enumeration (C++11).
14590 In any other case, it'll be NULL_TREE. */
14591 if (!enumtype)
14592 {
14593 if (is_new)
14594 *is_new = true;
14595 }
14596 prevtype = enumtype;
14597
14598 /* Do not push the decl more than once. */
14599 if (!enumtype
14600 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
14601 {
14602 enumtype = cxx_make_type (ENUMERAL_TYPE);
14603 enumtype = pushtag (name, enumtype, /*tag_scope=*/ts_current);
14604
14605 /* std::byte aliases anything. */
14606 if (enumtype != error_mark_node
14607 && TYPE_CONTEXT (enumtype) == std_node
14608 && !strcmp ("byte", TYPE_NAME_STRING (enumtype)))
14609 TYPE_ALIAS_SET (enumtype) = 0;
14610 }
14611 else
14612 enumtype = xref_tag (enum_type, name, /*tag_scope=*/ts_current,
14613 false);
14614
14615 if (enumtype == error_mark_node)
14616 return error_mark_node;
14617
14618 /* The enum is considered opaque until the opening '{' of the
14619 enumerator list. */
14620 SET_OPAQUE_ENUM_P (enumtype, true);
14621 ENUM_FIXED_UNDERLYING_TYPE_P (enumtype) = !! underlying_type;
14622 }
14623
14624 SET_SCOPED_ENUM_P (enumtype, scoped_enum_p);
14625
14626 cplus_decl_attributes (&enumtype, attributes, (int)ATTR_FLAG_TYPE_IN_PLACE);
14627
14628 if (underlying_type)
14629 {
14630 if (ENUM_UNDERLYING_TYPE (enumtype))
14631 /* We already checked that it matches, don't change it to a different
14632 typedef variant. */;
14633 else if (CP_INTEGRAL_TYPE_P (underlying_type))
14634 {
14635 copy_type_enum (enumtype, underlying_type);
14636 ENUM_UNDERLYING_TYPE (enumtype) = underlying_type;
14637 }
14638 else if (dependent_type_p (underlying_type))
14639 ENUM_UNDERLYING_TYPE (enumtype) = underlying_type;
14640 else
14641 error ("underlying type %qT of %qT must be an integral type",
14642 underlying_type, enumtype);
14643 }
14644
14645 /* If into a template class, the returned enum is always the first
14646 declaration (opaque or not) seen. This way all the references to
14647 this type will be to the same declaration. The following ones are used
14648 only to check for definition errors. */
14649 if (prevtype && processing_template_decl)
14650 return prevtype;
14651 else
14652 return enumtype;
14653 }
14654
14655 /* After processing and defining all the values of an enumeration type,
14656 install their decls in the enumeration type.
14657 ENUMTYPE is the type object. */
14658
14659 void
finish_enum_value_list(tree enumtype)14660 finish_enum_value_list (tree enumtype)
14661 {
14662 tree values;
14663 tree underlying_type;
14664 tree decl;
14665 tree value;
14666 tree minnode, maxnode;
14667 tree t;
14668
14669 bool fixed_underlying_type_p
14670 = ENUM_UNDERLYING_TYPE (enumtype) != NULL_TREE;
14671
14672 /* We built up the VALUES in reverse order. */
14673 TYPE_VALUES (enumtype) = nreverse (TYPE_VALUES (enumtype));
14674
14675 /* For an enum defined in a template, just set the type of the values;
14676 all further processing is postponed until the template is
14677 instantiated. We need to set the type so that tsubst of a CONST_DECL
14678 works. */
14679 if (processing_template_decl)
14680 {
14681 for (values = TYPE_VALUES (enumtype);
14682 values;
14683 values = TREE_CHAIN (values))
14684 TREE_TYPE (TREE_VALUE (values)) = enumtype;
14685 return;
14686 }
14687
14688 /* Determine the minimum and maximum values of the enumerators. */
14689 if (TYPE_VALUES (enumtype))
14690 {
14691 minnode = maxnode = NULL_TREE;
14692
14693 for (values = TYPE_VALUES (enumtype);
14694 values;
14695 values = TREE_CHAIN (values))
14696 {
14697 decl = TREE_VALUE (values);
14698
14699 /* [dcl.enum]: Following the closing brace of an enum-specifier,
14700 each enumerator has the type of its enumeration. Prior to the
14701 closing brace, the type of each enumerator is the type of its
14702 initializing value. */
14703 TREE_TYPE (decl) = enumtype;
14704
14705 /* Update the minimum and maximum values, if appropriate. */
14706 value = DECL_INITIAL (decl);
14707 if (value == error_mark_node)
14708 value = integer_zero_node;
14709 /* Figure out what the minimum and maximum values of the
14710 enumerators are. */
14711 if (!minnode)
14712 minnode = maxnode = value;
14713 else if (tree_int_cst_lt (maxnode, value))
14714 maxnode = value;
14715 else if (tree_int_cst_lt (value, minnode))
14716 minnode = value;
14717 }
14718 }
14719 else
14720 /* [dcl.enum]
14721
14722 If the enumerator-list is empty, the underlying type is as if
14723 the enumeration had a single enumerator with value 0. */
14724 minnode = maxnode = integer_zero_node;
14725
14726 if (!fixed_underlying_type_p)
14727 {
14728 /* Compute the number of bits require to represent all values of the
14729 enumeration. We must do this before the type of MINNODE and
14730 MAXNODE are transformed, since tree_int_cst_min_precision relies
14731 on the TREE_TYPE of the value it is passed. */
14732 signop sgn = tree_int_cst_sgn (minnode) >= 0 ? UNSIGNED : SIGNED;
14733 int lowprec = tree_int_cst_min_precision (minnode, sgn);
14734 int highprec = tree_int_cst_min_precision (maxnode, sgn);
14735 int precision = MAX (lowprec, highprec);
14736 unsigned int itk;
14737 bool use_short_enum;
14738
14739 /* Determine the underlying type of the enumeration.
14740
14741 [dcl.enum]
14742
14743 The underlying type of an enumeration is an integral type that
14744 can represent all the enumerator values defined in the
14745 enumeration. It is implementation-defined which integral type is
14746 used as the underlying type for an enumeration except that the
14747 underlying type shall not be larger than int unless the value of
14748 an enumerator cannot fit in an int or unsigned int.
14749
14750 We use "int" or an "unsigned int" as the underlying type, even if
14751 a smaller integral type would work, unless the user has
14752 explicitly requested that we use the smallest possible type. The
14753 user can request that for all enumerations with a command line
14754 flag, or for just one enumeration with an attribute. */
14755
14756 use_short_enum = flag_short_enums
14757 || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype));
14758
14759 /* If the precision of the type was specified with an attribute and it
14760 was too small, give an error. Otherwise, use it. */
14761 if (TYPE_PRECISION (enumtype))
14762 {
14763 if (precision > TYPE_PRECISION (enumtype))
14764 error ("specified mode too small for enumeral values");
14765 else
14766 {
14767 use_short_enum = true;
14768 precision = TYPE_PRECISION (enumtype);
14769 }
14770 }
14771
14772 for (itk = (use_short_enum ? itk_char : itk_int);
14773 itk != itk_none;
14774 itk++)
14775 {
14776 underlying_type = integer_types[itk];
14777 if (underlying_type != NULL_TREE
14778 && TYPE_PRECISION (underlying_type) >= precision
14779 && TYPE_SIGN (underlying_type) == sgn)
14780 break;
14781 }
14782 if (itk == itk_none)
14783 {
14784 /* DR 377
14785
14786 IF no integral type can represent all the enumerator values, the
14787 enumeration is ill-formed. */
14788 error ("no integral type can represent all of the enumerator values "
14789 "for %qT", enumtype);
14790 precision = TYPE_PRECISION (long_long_integer_type_node);
14791 underlying_type = integer_types[itk_unsigned_long_long];
14792 }
14793
14794 /* [dcl.enum]
14795
14796 The value of sizeof() applied to an enumeration type, an object
14797 of an enumeration type, or an enumerator, is the value of sizeof()
14798 applied to the underlying type. */
14799 copy_type_enum (enumtype, underlying_type);
14800
14801 /* Compute the minimum and maximum values for the type.
14802
14803 [dcl.enum]
14804
14805 For an enumeration where emin is the smallest enumerator and emax
14806 is the largest, the values of the enumeration are the values of the
14807 underlying type in the range bmin to bmax, where bmin and bmax are,
14808 respectively, the smallest and largest values of the smallest bit-
14809 field that can store emin and emax. */
14810
14811 /* The middle-end currently assumes that types with TYPE_PRECISION
14812 narrower than their underlying type are suitably zero or sign
14813 extended to fill their mode. Similarly, it assumes that the front
14814 end assures that a value of a particular type must be within
14815 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
14816
14817 We used to set these fields based on bmin and bmax, but that led
14818 to invalid assumptions like optimizing away bounds checking. So
14819 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
14820 TYPE_MAX_VALUE to the values for the mode above and only restrict
14821 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
14822 ENUM_UNDERLYING_TYPE (enumtype)
14823 = build_distinct_type_copy (underlying_type);
14824 TYPE_PRECISION (ENUM_UNDERLYING_TYPE (enumtype)) = precision;
14825 set_min_and_max_values_for_integral_type
14826 (ENUM_UNDERLYING_TYPE (enumtype), precision, sgn);
14827
14828 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
14829 if (flag_strict_enums)
14830 set_min_and_max_values_for_integral_type (enumtype, precision, sgn);
14831 }
14832 else
14833 underlying_type = ENUM_UNDERLYING_TYPE (enumtype);
14834
14835 /* Convert each of the enumerators to the type of the underlying
14836 type of the enumeration. */
14837 for (values = TYPE_VALUES (enumtype); values; values = TREE_CHAIN (values))
14838 {
14839 location_t saved_location;
14840
14841 decl = TREE_VALUE (values);
14842 saved_location = input_location;
14843 input_location = DECL_SOURCE_LOCATION (decl);
14844 if (fixed_underlying_type_p)
14845 /* If the enumeration type has a fixed underlying type, we
14846 already checked all of the enumerator values. */
14847 value = DECL_INITIAL (decl);
14848 else
14849 value = perform_implicit_conversion (underlying_type,
14850 DECL_INITIAL (decl),
14851 tf_warning_or_error);
14852 input_location = saved_location;
14853
14854 /* Do not clobber shared ints. */
14855 if (value != error_mark_node)
14856 {
14857 value = copy_node (value);
14858
14859 TREE_TYPE (value) = enumtype;
14860 }
14861 DECL_INITIAL (decl) = value;
14862 }
14863
14864 /* Fix up all variant types of this enum type. */
14865 for (t = TYPE_MAIN_VARIANT (enumtype); t; t = TYPE_NEXT_VARIANT (t))
14866 TYPE_VALUES (t) = TYPE_VALUES (enumtype);
14867
14868 if (at_class_scope_p ()
14869 && COMPLETE_TYPE_P (current_class_type)
14870 && UNSCOPED_ENUM_P (enumtype))
14871 {
14872 insert_late_enum_def_bindings (current_class_type, enumtype);
14873 /* TYPE_FIELDS needs fixup. */
14874 fixup_type_variants (current_class_type);
14875 }
14876
14877 /* Finish debugging output for this type. */
14878 rest_of_type_compilation (enumtype, namespace_bindings_p ());
14879
14880 /* Each enumerator now has the type of its enumeration. Clear the cache
14881 so that this change in types doesn't confuse us later on. */
14882 clear_cv_and_fold_caches ();
14883 }
14884
14885 /* Finishes the enum type. This is called only the first time an
14886 enumeration is seen, be it opaque or odinary.
14887 ENUMTYPE is the type object. */
14888
14889 void
finish_enum(tree enumtype)14890 finish_enum (tree enumtype)
14891 {
14892 if (processing_template_decl)
14893 {
14894 if (at_function_scope_p ())
14895 add_stmt (build_min (TAG_DEFN, enumtype));
14896 return;
14897 }
14898
14899 /* If this is a forward declaration, there should not be any variants,
14900 though we can get a variant in the middle of an enum-specifier with
14901 wacky code like 'enum E { e = sizeof(const E*) };' */
14902 gcc_assert (enumtype == TYPE_MAIN_VARIANT (enumtype)
14903 && (TYPE_VALUES (enumtype)
14904 || !TYPE_NEXT_VARIANT (enumtype)));
14905 }
14906
14907 /* Build and install a CONST_DECL for an enumeration constant of the
14908 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
14909 Apply ATTRIBUTES if available. LOC is the location of NAME.
14910 Assignment of sequential values by default is handled here. */
14911
14912 void
build_enumerator(tree name,tree value,tree enumtype,tree attributes,location_t loc)14913 build_enumerator (tree name, tree value, tree enumtype, tree attributes,
14914 location_t loc)
14915 {
14916 tree decl;
14917 tree context;
14918 tree type;
14919
14920 /* scalar_constant_value will pull out this expression, so make sure
14921 it's folded as appropriate. */
14922 if (processing_template_decl)
14923 value = fold_non_dependent_expr (value);
14924
14925 /* If the VALUE was erroneous, pretend it wasn't there; that will
14926 result in the enum being assigned the next value in sequence. */
14927 if (value == error_mark_node)
14928 value = NULL_TREE;
14929
14930 /* Remove no-op casts from the value. */
14931 if (value)
14932 STRIP_TYPE_NOPS (value);
14933
14934 if (! processing_template_decl)
14935 {
14936 /* Validate and default VALUE. */
14937 if (value != NULL_TREE)
14938 {
14939 if (!ENUM_UNDERLYING_TYPE (enumtype))
14940 {
14941 tree tmp_value = build_expr_type_conversion (WANT_INT | WANT_ENUM,
14942 value, true);
14943 if (tmp_value)
14944 value = tmp_value;
14945 }
14946 else if (! INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P
14947 (TREE_TYPE (value)))
14948 value = perform_implicit_conversion_flags
14949 (ENUM_UNDERLYING_TYPE (enumtype), value, tf_warning_or_error,
14950 LOOKUP_IMPLICIT | LOOKUP_NO_NARROWING);
14951
14952 if (value == error_mark_node)
14953 value = NULL_TREE;
14954
14955 if (value != NULL_TREE)
14956 {
14957 if (! INTEGRAL_OR_UNSCOPED_ENUMERATION_TYPE_P
14958 (TREE_TYPE (value)))
14959 {
14960 error ("enumerator value for %qD must have integral or "
14961 "unscoped enumeration type", name);
14962 value = NULL_TREE;
14963 }
14964 else
14965 {
14966 value = cxx_constant_value (value);
14967
14968 if (TREE_CODE (value) != INTEGER_CST)
14969 {
14970 error ("enumerator value for %qD is not an integer "
14971 "constant", name);
14972 value = NULL_TREE;
14973 }
14974 }
14975 }
14976 }
14977
14978 /* Default based on previous value. */
14979 if (value == NULL_TREE)
14980 {
14981 if (TYPE_VALUES (enumtype))
14982 {
14983 tree prev_value;
14984
14985 /* C++03 7.2/4: If no initializer is specified for the first
14986 enumerator, the type is an unspecified integral
14987 type. Otherwise the type is the same as the type of the
14988 initializing value of the preceding enumerator unless the
14989 incremented value is not representable in that type, in
14990 which case the type is an unspecified integral type
14991 sufficient to contain the incremented value. */
14992 prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
14993 if (error_operand_p (prev_value))
14994 value = error_mark_node;
14995 else
14996 {
14997 wi::overflow_type overflowed;
14998 tree type = TREE_TYPE (prev_value);
14999 signop sgn = TYPE_SIGN (type);
15000 widest_int wi = wi::add (wi::to_widest (prev_value), 1, sgn,
15001 &overflowed);
15002 if (!overflowed)
15003 {
15004 bool pos = !wi::neg_p (wi, sgn);
15005 if (!wi::fits_to_tree_p (wi, type))
15006 {
15007 unsigned int itk;
15008 for (itk = itk_int; itk != itk_none; itk++)
15009 {
15010 type = integer_types[itk];
15011 if (type != NULL_TREE
15012 && (pos || !TYPE_UNSIGNED (type))
15013 && wi::fits_to_tree_p (wi, type))
15014 break;
15015 }
15016 if (type && cxx_dialect < cxx11
15017 && itk > itk_unsigned_long)
15018 pedwarn (input_location, OPT_Wlong_long,
15019 pos ? G_("\
15020 incremented enumerator value is too large for %<unsigned long%>") : G_("\
15021 incremented enumerator value is too large for %<long%>"));
15022 }
15023 if (type == NULL_TREE)
15024 overflowed = wi::OVF_UNKNOWN;
15025 else
15026 value = wide_int_to_tree (type, wi);
15027 }
15028
15029 if (overflowed)
15030 {
15031 error ("overflow in enumeration values at %qD", name);
15032 value = error_mark_node;
15033 }
15034 }
15035 }
15036 else
15037 value = integer_zero_node;
15038 }
15039
15040 /* Remove no-op casts from the value. */
15041 STRIP_TYPE_NOPS (value);
15042
15043 /* If the underlying type of the enum is fixed, check whether
15044 the enumerator values fits in the underlying type. If it
15045 does not fit, the program is ill-formed [C++0x dcl.enum]. */
15046 if (ENUM_UNDERLYING_TYPE (enumtype)
15047 && value
15048 && TREE_CODE (value) == INTEGER_CST)
15049 {
15050 if (!int_fits_type_p (value, ENUM_UNDERLYING_TYPE (enumtype)))
15051 error ("enumerator value %qE is outside the range of underlying "
15052 "type %qT", value, ENUM_UNDERLYING_TYPE (enumtype));
15053
15054 /* Convert the value to the appropriate type. */
15055 value = fold_convert (ENUM_UNDERLYING_TYPE (enumtype), value);
15056 }
15057 }
15058
15059 /* C++ associates enums with global, function, or class declarations. */
15060 context = current_scope ();
15061
15062 /* Build the actual enumeration constant. Note that the enumeration
15063 constants have the underlying type of the enum (if it is fixed)
15064 or the type of their initializer (if the underlying type of the
15065 enum is not fixed):
15066
15067 [ C++0x dcl.enum ]
15068
15069 If the underlying type is fixed, the type of each enumerator
15070 prior to the closing brace is the underlying type; if the
15071 initializing value of an enumerator cannot be represented by
15072 the underlying type, the program is ill-formed. If the
15073 underlying type is not fixed, the type of each enumerator is
15074 the type of its initializing value.
15075
15076 If the underlying type is not fixed, it will be computed by
15077 finish_enum and we will reset the type of this enumerator. Of
15078 course, if we're processing a template, there may be no value. */
15079 type = value ? TREE_TYPE (value) : NULL_TREE;
15080
15081 decl = build_decl (loc, CONST_DECL, name, type);
15082
15083 DECL_CONTEXT (decl) = enumtype;
15084 TREE_CONSTANT (decl) = 1;
15085 TREE_READONLY (decl) = 1;
15086 DECL_INITIAL (decl) = value;
15087
15088 if (attributes)
15089 cplus_decl_attributes (&decl, attributes, 0);
15090
15091 if (context && context == current_class_type && !SCOPED_ENUM_P (enumtype))
15092 {
15093 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
15094 on the TYPE_FIELDS list for `S'. (That's so that you can say
15095 things like `S::i' later.) */
15096
15097 /* The enumerator may be getting declared outside of its enclosing
15098 class, like so:
15099
15100 class S { public: enum E : int; }; enum S::E : int { i = 7; };
15101
15102 For which case we need to make sure that the access of `S::i'
15103 matches the access of `S::E'. */
15104 tree saved_cas = current_access_specifier;
15105 if (TREE_PRIVATE (TYPE_NAME (enumtype)))
15106 current_access_specifier = access_private_node;
15107 else if (TREE_PROTECTED (TYPE_NAME (enumtype)))
15108 current_access_specifier = access_protected_node;
15109 else
15110 current_access_specifier = access_public_node;
15111
15112 finish_member_declaration (decl);
15113
15114 current_access_specifier = saved_cas;
15115 }
15116 else
15117 pushdecl (decl);
15118
15119 /* Add this enumeration constant to the list for this type. */
15120 TYPE_VALUES (enumtype) = tree_cons (name, decl, TYPE_VALUES (enumtype));
15121 }
15122
15123 /* Look for an enumerator with the given NAME within the enumeration
15124 type ENUMTYPE. This routine is used primarily for qualified name
15125 lookup into an enumerator in C++0x, e.g.,
15126
15127 enum class Color { Red, Green, Blue };
15128
15129 Color color = Color::Red;
15130
15131 Returns the value corresponding to the enumerator, or
15132 NULL_TREE if no such enumerator was found. */
15133 tree
lookup_enumerator(tree enumtype,tree name)15134 lookup_enumerator (tree enumtype, tree name)
15135 {
15136 tree e;
15137 gcc_assert (enumtype && TREE_CODE (enumtype) == ENUMERAL_TYPE);
15138
15139 e = purpose_member (name, TYPE_VALUES (enumtype));
15140 return e? TREE_VALUE (e) : NULL_TREE;
15141 }
15142
15143
15144 /* We're defining DECL. Make sure that its type is OK. */
15145
15146 static void
check_function_type(tree decl,tree current_function_parms)15147 check_function_type (tree decl, tree current_function_parms)
15148 {
15149 tree fntype = TREE_TYPE (decl);
15150 tree return_type = complete_type (TREE_TYPE (fntype));
15151
15152 /* In a function definition, arg types must be complete. */
15153 require_complete_types_for_parms (current_function_parms);
15154
15155 if (dependent_type_p (return_type)
15156 || type_uses_auto (return_type))
15157 return;
15158 if (!COMPLETE_OR_VOID_TYPE_P (return_type))
15159 {
15160 tree args = TYPE_ARG_TYPES (fntype);
15161
15162 error ("return type %q#T is incomplete", return_type);
15163
15164 /* Make it return void instead. */
15165 if (TREE_CODE (fntype) == METHOD_TYPE)
15166 fntype = build_method_type_directly (TREE_TYPE (TREE_VALUE (args)),
15167 void_type_node,
15168 TREE_CHAIN (args));
15169 else
15170 fntype = build_function_type (void_type_node, args);
15171 fntype = (cp_build_type_attribute_variant
15172 (fntype, TYPE_ATTRIBUTES (TREE_TYPE (decl))));
15173 fntype = cxx_copy_lang_qualifiers (fntype, TREE_TYPE (decl));
15174 TREE_TYPE (decl) = fntype;
15175 }
15176 else
15177 {
15178 abstract_virtuals_error (decl, TREE_TYPE (fntype));
15179 maybe_warn_parm_abi (TREE_TYPE (fntype),
15180 DECL_SOURCE_LOCATION (decl));
15181 }
15182 }
15183
15184 /* True iff FN is an implicitly-defined default constructor. */
15185
15186 static bool
implicit_default_ctor_p(tree fn)15187 implicit_default_ctor_p (tree fn)
15188 {
15189 return (DECL_CONSTRUCTOR_P (fn)
15190 && !user_provided_p (fn)
15191 && sufficient_parms_p (FUNCTION_FIRST_USER_PARMTYPE (fn)));
15192 }
15193
15194 /* Clobber the contents of *this to let the back end know that the object
15195 storage is dead when we enter the constructor or leave the destructor. */
15196
15197 static tree
build_clobber_this()15198 build_clobber_this ()
15199 {
15200 /* Clobbering an empty base is pointless, and harmful if its one byte
15201 TYPE_SIZE overlays real data. */
15202 if (is_empty_class (current_class_type))
15203 return void_node;
15204
15205 /* If we have virtual bases, clobber the whole object, but only if we're in
15206 charge. If we don't have virtual bases, clobber the as-base type so we
15207 don't mess with tail padding. */
15208 bool vbases = CLASSTYPE_VBASECLASSES (current_class_type);
15209
15210 tree ctype = current_class_type;
15211 if (!vbases)
15212 ctype = CLASSTYPE_AS_BASE (ctype);
15213
15214 tree clobber = build_clobber (ctype);
15215
15216 tree thisref = current_class_ref;
15217 if (ctype != current_class_type)
15218 {
15219 thisref = build_nop (build_reference_type (ctype), current_class_ptr);
15220 thisref = convert_from_reference (thisref);
15221 }
15222
15223 tree exprstmt = build2 (MODIFY_EXPR, void_type_node, thisref, clobber);
15224 if (vbases)
15225 exprstmt = build_if_in_charge (exprstmt);
15226
15227 return exprstmt;
15228 }
15229
15230 /* Create the FUNCTION_DECL for a function definition.
15231 DECLSPECS and DECLARATOR are the parts of the declaration;
15232 they describe the function's name and the type it returns,
15233 but twisted together in a fashion that parallels the syntax of C.
15234
15235 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
15236 DECLARATOR is really the DECL for the function we are about to
15237 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
15238 indicating that the function is an inline defined in-class.
15239
15240 This function creates a binding context for the function body
15241 as well as setting up the FUNCTION_DECL in current_function_decl.
15242
15243 For C++, we must first check whether that datum makes any sense.
15244 For example, "class A local_a(1,2);" means that variable local_a
15245 is an aggregate of type A, which should have a constructor
15246 applied to it with the argument list [1, 2].
15247
15248 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
15249 or may be a BLOCK if the function has been defined previously
15250 in this translation unit. On exit, DECL_INITIAL (decl1) will be
15251 error_mark_node if the function has never been defined, or
15252 a BLOCK if the function has been defined somewhere. */
15253
15254 bool
start_preparsed_function(tree decl1,tree attrs,int flags)15255 start_preparsed_function (tree decl1, tree attrs, int flags)
15256 {
15257 tree ctype = NULL_TREE;
15258 tree fntype;
15259 tree restype;
15260 int doing_friend = 0;
15261 cp_binding_level *bl;
15262 tree current_function_parms;
15263 struct c_fileinfo *finfo
15264 = get_fileinfo (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1)));
15265 bool honor_interface;
15266
15267 /* Sanity check. */
15268 gcc_assert (VOID_TYPE_P (TREE_VALUE (void_list_node)));
15269 gcc_assert (TREE_CHAIN (void_list_node) == NULL_TREE);
15270
15271 fntype = TREE_TYPE (decl1);
15272 if (TREE_CODE (fntype) == METHOD_TYPE)
15273 ctype = TYPE_METHOD_BASETYPE (fntype);
15274
15275 /* ISO C++ 11.4/5. A friend function defined in a class is in
15276 the (lexical) scope of the class in which it is defined. */
15277 if (!ctype && DECL_FRIEND_P (decl1))
15278 {
15279 ctype = DECL_FRIEND_CONTEXT (decl1);
15280
15281 /* CTYPE could be null here if we're dealing with a template;
15282 for example, `inline friend float foo()' inside a template
15283 will have no CTYPE set. */
15284 if (ctype && TREE_CODE (ctype) != RECORD_TYPE)
15285 ctype = NULL_TREE;
15286 else
15287 doing_friend = 1;
15288 }
15289
15290 if (DECL_DECLARED_INLINE_P (decl1)
15291 && lookup_attribute ("noinline", attrs))
15292 warning_at (DECL_SOURCE_LOCATION (decl1), 0,
15293 "inline function %qD given attribute noinline", decl1);
15294
15295 /* Handle gnu_inline attribute. */
15296 if (GNU_INLINE_P (decl1))
15297 {
15298 DECL_EXTERNAL (decl1) = 1;
15299 DECL_NOT_REALLY_EXTERN (decl1) = 0;
15300 DECL_INTERFACE_KNOWN (decl1) = 1;
15301 DECL_DISREGARD_INLINE_LIMITS (decl1) = 1;
15302 }
15303
15304 if (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl1))
15305 /* This is a constructor, we must ensure that any default args
15306 introduced by this definition are propagated to the clones
15307 now. The clones are used directly in overload resolution. */
15308 adjust_clone_args (decl1);
15309
15310 /* Sometimes we don't notice that a function is a static member, and
15311 build a METHOD_TYPE for it. Fix that up now. */
15312 gcc_assert (!(ctype != NULL_TREE && DECL_STATIC_FUNCTION_P (decl1)
15313 && TREE_CODE (TREE_TYPE (decl1)) == METHOD_TYPE));
15314
15315 /* Set up current_class_type, and enter the scope of the class, if
15316 appropriate. */
15317 if (ctype)
15318 push_nested_class (ctype);
15319 else if (DECL_STATIC_FUNCTION_P (decl1))
15320 push_nested_class (DECL_CONTEXT (decl1));
15321
15322 /* Now that we have entered the scope of the class, we must restore
15323 the bindings for any template parameters surrounding DECL1, if it
15324 is an inline member template. (Order is important; consider the
15325 case where a template parameter has the same name as a field of
15326 the class.) It is not until after this point that
15327 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
15328 if (flags & SF_INCLASS_INLINE)
15329 maybe_begin_member_template_processing (decl1);
15330
15331 /* Effective C++ rule 15. */
15332 if (warn_ecpp
15333 && DECL_ASSIGNMENT_OPERATOR_P (decl1)
15334 && DECL_OVERLOADED_OPERATOR_IS (decl1, NOP_EXPR)
15335 && VOID_TYPE_P (TREE_TYPE (fntype)))
15336 warning (OPT_Weffc__,
15337 "%<operator=%> should return a reference to %<*this%>");
15338
15339 /* Make the init_value nonzero so pushdecl knows this is not tentative.
15340 error_mark_node is replaced below (in poplevel) with the BLOCK. */
15341 if (!DECL_INITIAL (decl1))
15342 DECL_INITIAL (decl1) = error_mark_node;
15343
15344 /* This function exists in static storage.
15345 (This does not mean `static' in the C sense!) */
15346 TREE_STATIC (decl1) = 1;
15347
15348 /* We must call push_template_decl after current_class_type is set
15349 up. (If we are processing inline definitions after exiting a
15350 class scope, current_class_type will be NULL_TREE until set above
15351 by push_nested_class.) */
15352 if (processing_template_decl)
15353 {
15354 tree newdecl1 = push_template_decl (decl1);
15355 if (newdecl1 == error_mark_node)
15356 {
15357 if (ctype || DECL_STATIC_FUNCTION_P (decl1))
15358 pop_nested_class ();
15359 return false;
15360 }
15361 decl1 = newdecl1;
15362 }
15363
15364 /* Make sure the parameter and return types are reasonable. When
15365 you declare a function, these types can be incomplete, but they
15366 must be complete when you define the function. */
15367 check_function_type (decl1, DECL_ARGUMENTS (decl1));
15368
15369 /* Build the return declaration for the function. */
15370 restype = TREE_TYPE (fntype);
15371
15372 if (DECL_RESULT (decl1) == NULL_TREE)
15373 {
15374 tree resdecl;
15375
15376 resdecl = build_decl (input_location, RESULT_DECL, 0, restype);
15377 DECL_ARTIFICIAL (resdecl) = 1;
15378 DECL_IGNORED_P (resdecl) = 1;
15379 DECL_RESULT (decl1) = resdecl;
15380
15381 cp_apply_type_quals_to_decl (cp_type_quals (restype), resdecl);
15382 }
15383
15384 /* Record the decl so that the function name is defined.
15385 If we already have a decl for this name, and it is a FUNCTION_DECL,
15386 use the old decl. */
15387 if (!processing_template_decl && !(flags & SF_PRE_PARSED))
15388 {
15389 /* A specialization is not used to guide overload resolution. */
15390 if (!DECL_FUNCTION_MEMBER_P (decl1)
15391 && !(DECL_USE_TEMPLATE (decl1) &&
15392 PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl1))))
15393 {
15394 tree olddecl = pushdecl (decl1);
15395
15396 if (olddecl == error_mark_node)
15397 /* If something went wrong when registering the declaration,
15398 use DECL1; we have to have a FUNCTION_DECL to use when
15399 parsing the body of the function. */
15400 ;
15401 else
15402 {
15403 /* Otherwise, OLDDECL is either a previous declaration
15404 of the same function or DECL1 itself. */
15405
15406 if (warn_missing_declarations
15407 && olddecl == decl1
15408 && !DECL_MAIN_P (decl1)
15409 && TREE_PUBLIC (decl1)
15410 && !DECL_DECLARED_INLINE_P (decl1))
15411 {
15412 tree context;
15413
15414 /* Check whether DECL1 is in an anonymous
15415 namespace. */
15416 for (context = DECL_CONTEXT (decl1);
15417 context;
15418 context = DECL_CONTEXT (context))
15419 {
15420 if (TREE_CODE (context) == NAMESPACE_DECL
15421 && DECL_NAME (context) == NULL_TREE)
15422 break;
15423 }
15424
15425 if (context == NULL)
15426 warning_at (DECL_SOURCE_LOCATION (decl1),
15427 OPT_Wmissing_declarations,
15428 "no previous declaration for %qD", decl1);
15429 }
15430
15431 decl1 = olddecl;
15432 }
15433 }
15434 else
15435 {
15436 /* We need to set the DECL_CONTEXT. */
15437 if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
15438 DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
15439 }
15440 fntype = TREE_TYPE (decl1);
15441 restype = TREE_TYPE (fntype);
15442
15443 /* If #pragma weak applies, mark the decl appropriately now.
15444 The pragma only applies to global functions. Because
15445 determining whether or not the #pragma applies involves
15446 computing the mangled name for the declaration, we cannot
15447 apply the pragma until after we have merged this declaration
15448 with any previous declarations; if the original declaration
15449 has a linkage specification, that specification applies to
15450 the definition as well, and may affect the mangled name. */
15451 if (DECL_FILE_SCOPE_P (decl1))
15452 maybe_apply_pragma_weak (decl1);
15453 }
15454
15455 /* We are now in the scope of the function being defined. */
15456 current_function_decl = decl1;
15457
15458 /* Save the parm names or decls from this function's declarator
15459 where store_parm_decls will find them. */
15460 current_function_parms = DECL_ARGUMENTS (decl1);
15461
15462 /* Let the user know we're compiling this function. */
15463 announce_function (decl1);
15464
15465 gcc_assert (DECL_INITIAL (decl1));
15466
15467 /* This function may already have been parsed, in which case just
15468 return; our caller will skip over the body without parsing. */
15469 if (DECL_INITIAL (decl1) != error_mark_node)
15470 return true;
15471
15472 /* Initialize RTL machinery. We cannot do this until
15473 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
15474 even when processing a template; this is how we get
15475 CFUN set up, and our per-function variables initialized.
15476 FIXME factor out the non-RTL stuff. */
15477 bl = current_binding_level;
15478 allocate_struct_function (decl1, processing_template_decl);
15479
15480 /* Initialize the language data structures. Whenever we start
15481 a new function, we destroy temporaries in the usual way. */
15482 cfun->language = ggc_cleared_alloc<language_function> ();
15483 current_stmt_tree ()->stmts_are_full_exprs_p = 1;
15484 current_binding_level = bl;
15485
15486 if (!processing_template_decl && type_uses_auto (restype))
15487 {
15488 FNDECL_USED_AUTO (decl1) = true;
15489 current_function_auto_return_pattern = restype;
15490 }
15491
15492 /* Start the statement-tree, start the tree now. */
15493 DECL_SAVED_TREE (decl1) = push_stmt_list ();
15494
15495 /* If we are (erroneously) defining a function that we have already
15496 defined before, wipe out what we knew before. */
15497 if (!DECL_PENDING_INLINE_P (decl1))
15498 DECL_SAVED_FUNCTION_DATA (decl1) = NULL;
15499
15500 if (ctype && !doing_friend && !DECL_STATIC_FUNCTION_P (decl1))
15501 {
15502 /* We know that this was set up by `grokclassfn'. We do not
15503 wait until `store_parm_decls', since evil parse errors may
15504 never get us to that point. Here we keep the consistency
15505 between `current_class_type' and `current_class_ptr'. */
15506 tree t = DECL_ARGUMENTS (decl1);
15507
15508 gcc_assert (t != NULL_TREE && TREE_CODE (t) == PARM_DECL);
15509 gcc_assert (TYPE_PTR_P (TREE_TYPE (t)));
15510
15511 cp_function_chain->x_current_class_ref
15512 = cp_build_fold_indirect_ref (t);
15513 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
15514 cp_function_chain->x_current_class_ptr = t;
15515
15516 /* Constructors and destructors need to know whether they're "in
15517 charge" of initializing virtual base classes. */
15518 t = DECL_CHAIN (t);
15519 if (DECL_HAS_IN_CHARGE_PARM_P (decl1))
15520 {
15521 current_in_charge_parm = t;
15522 t = DECL_CHAIN (t);
15523 }
15524 if (DECL_HAS_VTT_PARM_P (decl1))
15525 {
15526 gcc_assert (DECL_NAME (t) == vtt_parm_identifier);
15527 current_vtt_parm = t;
15528 }
15529 }
15530
15531 honor_interface = (!DECL_TEMPLATE_INSTANTIATION (decl1)
15532 /* Implicitly-defined methods (like the
15533 destructor for a class in which no destructor
15534 is explicitly declared) must not be defined
15535 until their definition is needed. So, we
15536 ignore interface specifications for
15537 compiler-generated functions. */
15538 && !DECL_ARTIFICIAL (decl1));
15539
15540 if (processing_template_decl)
15541 /* Don't mess with interface flags. */;
15542 else if (DECL_INTERFACE_KNOWN (decl1))
15543 {
15544 tree ctx = decl_function_context (decl1);
15545
15546 if (DECL_NOT_REALLY_EXTERN (decl1))
15547 DECL_EXTERNAL (decl1) = 0;
15548
15549 if (ctx != NULL_TREE && vague_linkage_p (ctx))
15550 /* This is a function in a local class in an extern inline
15551 or template function. */
15552 comdat_linkage (decl1);
15553 }
15554 /* If this function belongs to an interface, it is public.
15555 If it belongs to someone else's interface, it is also external.
15556 This only affects inlines and template instantiations. */
15557 else if (!finfo->interface_unknown && honor_interface)
15558 {
15559 if (DECL_DECLARED_INLINE_P (decl1)
15560 || DECL_TEMPLATE_INSTANTIATION (decl1))
15561 {
15562 DECL_EXTERNAL (decl1)
15563 = (finfo->interface_only
15564 || (DECL_DECLARED_INLINE_P (decl1)
15565 && ! flag_implement_inlines
15566 && !DECL_VINDEX (decl1)));
15567
15568 /* For WIN32 we also want to put these in linkonce sections. */
15569 maybe_make_one_only (decl1);
15570 }
15571 else
15572 DECL_EXTERNAL (decl1) = 0;
15573 DECL_INTERFACE_KNOWN (decl1) = 1;
15574 /* If this function is in an interface implemented in this file,
15575 make sure that the back end knows to emit this function
15576 here. */
15577 if (!DECL_EXTERNAL (decl1))
15578 mark_needed (decl1);
15579 }
15580 else if (finfo->interface_unknown && finfo->interface_only
15581 && honor_interface)
15582 {
15583 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
15584 interface, we will have both finfo->interface_unknown and
15585 finfo->interface_only set. In that case, we don't want to
15586 use the normal heuristics because someone will supply a
15587 #pragma implementation elsewhere, and deducing it here would
15588 produce a conflict. */
15589 comdat_linkage (decl1);
15590 DECL_EXTERNAL (decl1) = 0;
15591 DECL_INTERFACE_KNOWN (decl1) = 1;
15592 DECL_DEFER_OUTPUT (decl1) = 1;
15593 }
15594 else
15595 {
15596 /* This is a definition, not a reference.
15597 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
15598 if (!GNU_INLINE_P (decl1))
15599 DECL_EXTERNAL (decl1) = 0;
15600
15601 if ((DECL_DECLARED_INLINE_P (decl1)
15602 || DECL_TEMPLATE_INSTANTIATION (decl1))
15603 && ! DECL_INTERFACE_KNOWN (decl1))
15604 DECL_DEFER_OUTPUT (decl1) = 1;
15605 else
15606 DECL_INTERFACE_KNOWN (decl1) = 1;
15607 }
15608
15609 /* Determine the ELF visibility attribute for the function. We must not
15610 do this before calling "pushdecl", as we must allow "duplicate_decls"
15611 to merge any attributes appropriately. We also need to wait until
15612 linkage is set. */
15613 if (!DECL_CLONED_FUNCTION_P (decl1))
15614 determine_visibility (decl1);
15615
15616 if (!processing_template_decl)
15617 maybe_instantiate_noexcept (decl1);
15618
15619 begin_scope (sk_function_parms, decl1);
15620
15621 ++function_depth;
15622
15623 if (DECL_DESTRUCTOR_P (decl1)
15624 || (DECL_CONSTRUCTOR_P (decl1)
15625 && targetm.cxx.cdtor_returns_this ()))
15626 {
15627 cdtor_label = create_artificial_label (input_location);
15628 LABEL_DECL_CDTOR (cdtor_label) = true;
15629 }
15630
15631 start_fname_decls ();
15632
15633 store_parm_decls (current_function_parms);
15634
15635 push_operator_bindings ();
15636
15637 if (!processing_template_decl
15638 && (flag_lifetime_dse > 1)
15639 && DECL_CONSTRUCTOR_P (decl1)
15640 && !DECL_CLONED_FUNCTION_P (decl1)
15641 /* Clobbering an empty base is harmful if it overlays real data. */
15642 && !is_empty_class (current_class_type)
15643 /* We can't clobber safely for an implicitly-defined default constructor
15644 because part of the initialization might happen before we enter the
15645 constructor, via AGGR_INIT_ZERO_FIRST (c++/68006). */
15646 && !implicit_default_ctor_p (decl1))
15647 finish_expr_stmt (build_clobber_this ());
15648
15649 if (!processing_template_decl
15650 && DECL_CONSTRUCTOR_P (decl1)
15651 && sanitize_flags_p (SANITIZE_VPTR)
15652 && !DECL_CLONED_FUNCTION_P (decl1)
15653 && !implicit_default_ctor_p (decl1))
15654 cp_ubsan_maybe_initialize_vtbl_ptrs (current_class_ptr);
15655
15656 if (!DECL_OMP_DECLARE_REDUCTION_P (decl1))
15657 start_lambda_scope (decl1);
15658
15659 return true;
15660 }
15661
15662
15663 /* Like start_preparsed_function, except that instead of a
15664 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
15665
15666 Returns true on success. If the DECLARATOR is not suitable
15667 for a function, we return false, which tells the parser to
15668 skip the entire function. */
15669
15670 bool
start_function(cp_decl_specifier_seq * declspecs,const cp_declarator * declarator,tree attrs)15671 start_function (cp_decl_specifier_seq *declspecs,
15672 const cp_declarator *declarator,
15673 tree attrs)
15674 {
15675 tree decl1;
15676
15677 decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs);
15678 invoke_plugin_callbacks (PLUGIN_START_PARSE_FUNCTION, decl1);
15679 if (decl1 == error_mark_node)
15680 return false;
15681 /* If the declarator is not suitable for a function definition,
15682 cause a syntax error. */
15683 if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL)
15684 {
15685 error ("invalid function declaration");
15686 return false;
15687 }
15688
15689 if (DECL_MAIN_P (decl1))
15690 /* main must return int. grokfndecl should have corrected it
15691 (and issued a diagnostic) if the user got it wrong. */
15692 gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1)),
15693 integer_type_node));
15694
15695 return start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT);
15696 }
15697
15698 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
15699 FN. */
15700
15701 static bool
use_eh_spec_block(tree fn)15702 use_eh_spec_block (tree fn)
15703 {
15704 return (flag_exceptions && flag_enforce_eh_specs
15705 && !processing_template_decl
15706 && !type_throw_all_p (TREE_TYPE (fn))
15707 /* We insert the EH_SPEC_BLOCK only in the original
15708 function; then, it is copied automatically to the
15709 clones. */
15710 && !DECL_CLONED_FUNCTION_P (fn)
15711 /* Implicitly-generated constructors and destructors have
15712 exception specifications. However, those specifications
15713 are the union of the possible exceptions specified by the
15714 constructors/destructors for bases and members, so no
15715 unallowed exception will ever reach this function. By
15716 not creating the EH_SPEC_BLOCK we save a little memory,
15717 and we avoid spurious warnings about unreachable
15718 code. */
15719 && !DECL_DEFAULTED_FN (fn));
15720 }
15721
15722 /* Store the parameter declarations into the current function declaration.
15723 This is called after parsing the parameter declarations, before
15724 digesting the body of the function.
15725
15726 Also install to binding contour return value identifier, if any. */
15727
15728 static void
store_parm_decls(tree current_function_parms)15729 store_parm_decls (tree current_function_parms)
15730 {
15731 tree fndecl = current_function_decl;
15732 tree parm;
15733
15734 /* This is a chain of any other decls that came in among the parm
15735 declarations. If a parm is declared with enum {foo, bar} x;
15736 then CONST_DECLs for foo and bar are put here. */
15737 tree nonparms = NULL_TREE;
15738
15739 if (current_function_parms)
15740 {
15741 /* This case is when the function was defined with an ANSI prototype.
15742 The parms already have decls, so we need not do anything here
15743 except record them as in effect
15744 and complain if any redundant old-style parm decls were written. */
15745
15746 tree specparms = current_function_parms;
15747 tree next;
15748
15749 /* Must clear this because it might contain TYPE_DECLs declared
15750 at class level. */
15751 current_binding_level->names = NULL;
15752
15753 /* If we're doing semantic analysis, then we'll call pushdecl
15754 for each of these. We must do them in reverse order so that
15755 they end in the correct forward order. */
15756 specparms = nreverse (specparms);
15757
15758 for (parm = specparms; parm; parm = next)
15759 {
15760 next = DECL_CHAIN (parm);
15761 if (TREE_CODE (parm) == PARM_DECL)
15762 pushdecl (parm);
15763 else
15764 {
15765 /* If we find an enum constant or a type tag,
15766 put it aside for the moment. */
15767 TREE_CHAIN (parm) = NULL_TREE;
15768 nonparms = chainon (nonparms, parm);
15769 }
15770 }
15771
15772 /* Get the decls in their original chain order and record in the
15773 function. This is all and only the PARM_DECLs that were
15774 pushed into scope by the loop above. */
15775 DECL_ARGUMENTS (fndecl) = get_local_decls ();
15776 }
15777 else
15778 DECL_ARGUMENTS (fndecl) = NULL_TREE;
15779
15780 /* Now store the final chain of decls for the arguments
15781 as the decl-chain of the current lexical scope.
15782 Put the enumerators in as well, at the front so that
15783 DECL_ARGUMENTS is not modified. */
15784 current_binding_level->names = chainon (nonparms, DECL_ARGUMENTS (fndecl));
15785
15786 if (use_eh_spec_block (current_function_decl))
15787 current_eh_spec_block = begin_eh_spec_block ();
15788 }
15789
15790
15791 /* We have finished doing semantic analysis on DECL, but have not yet
15792 generated RTL for its body. Save away our current state, so that
15793 when we want to generate RTL later we know what to do. */
15794
15795 static void
save_function_data(tree decl)15796 save_function_data (tree decl)
15797 {
15798 struct language_function *f;
15799
15800 /* Save the language-specific per-function data so that we can
15801 get it back when we really expand this function. */
15802 gcc_assert (!DECL_PENDING_INLINE_P (decl));
15803
15804 /* Make a copy. */
15805 f = ggc_alloc<language_function> ();
15806 memcpy (f, cp_function_chain, sizeof (struct language_function));
15807 DECL_SAVED_FUNCTION_DATA (decl) = f;
15808
15809 /* Clear out the bits we don't need. */
15810 f->base.x_stmt_tree.x_cur_stmt_list = NULL;
15811 f->bindings = NULL;
15812 f->base.local_typedefs = NULL;
15813 }
15814
15815
15816 /* Set the return value of the constructor (if present). */
15817
15818 static void
finish_constructor_body(void)15819 finish_constructor_body (void)
15820 {
15821 tree val;
15822 tree exprstmt;
15823
15824 if (targetm.cxx.cdtor_returns_this ())
15825 {
15826 /* Any return from a constructor will end up here. */
15827 add_stmt (build_stmt (input_location, LABEL_EXPR, cdtor_label));
15828
15829 val = DECL_ARGUMENTS (current_function_decl);
15830 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
15831 DECL_RESULT (current_function_decl), val);
15832 /* Return the address of the object. */
15833 exprstmt = build_stmt (input_location, RETURN_EXPR, val);
15834 add_stmt (exprstmt);
15835 }
15836 }
15837
15838 /* Do all the processing for the beginning of a destructor; set up the
15839 vtable pointers and cleanups for bases and members. */
15840
15841 static void
begin_destructor_body(void)15842 begin_destructor_body (void)
15843 {
15844 tree compound_stmt;
15845
15846 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
15847 issued an error message. We still want to try to process the
15848 body of the function, but initialize_vtbl_ptrs will crash if
15849 TYPE_BINFO is NULL. */
15850 if (COMPLETE_TYPE_P (current_class_type))
15851 {
15852 compound_stmt = begin_compound_stmt (0);
15853 /* Make all virtual function table pointers in non-virtual base
15854 classes point to CURRENT_CLASS_TYPE's virtual function
15855 tables. */
15856 initialize_vtbl_ptrs (current_class_ptr);
15857 finish_compound_stmt (compound_stmt);
15858
15859 if (flag_lifetime_dse
15860 /* Clobbering an empty base is harmful if it overlays real data. */
15861 && !is_empty_class (current_class_type))
15862 {
15863 if (sanitize_flags_p (SANITIZE_VPTR)
15864 && (flag_sanitize_recover & SANITIZE_VPTR) == 0
15865 && TYPE_CONTAINS_VPTR_P (current_class_type))
15866 {
15867 tree binfo = TYPE_BINFO (current_class_type);
15868 tree ref
15869 = cp_build_fold_indirect_ref (current_class_ptr);
15870
15871 tree vtbl_ptr = build_vfield_ref (ref, TREE_TYPE (binfo));
15872 tree vtbl = build_zero_cst (TREE_TYPE (vtbl_ptr));
15873 tree stmt = cp_build_modify_expr (input_location, vtbl_ptr,
15874 NOP_EXPR, vtbl,
15875 tf_warning_or_error);
15876 /* If the vptr is shared with some virtual nearly empty base,
15877 don't clear it if not in charge, the dtor of the virtual
15878 nearly empty base will do that later. */
15879 if (CLASSTYPE_VBASECLASSES (current_class_type))
15880 {
15881 tree c = current_class_type;
15882 while (CLASSTYPE_PRIMARY_BINFO (c))
15883 {
15884 if (BINFO_VIRTUAL_P (CLASSTYPE_PRIMARY_BINFO (c)))
15885 {
15886 stmt = convert_to_void (stmt, ICV_STATEMENT,
15887 tf_warning_or_error);
15888 stmt = build_if_in_charge (stmt);
15889 break;
15890 }
15891 c = BINFO_TYPE (CLASSTYPE_PRIMARY_BINFO (c));
15892 }
15893 }
15894 finish_decl_cleanup (NULL_TREE, stmt);
15895 }
15896 else
15897 finish_decl_cleanup (NULL_TREE, build_clobber_this ());
15898 }
15899
15900 /* And insert cleanups for our bases and members so that they
15901 will be properly destroyed if we throw. */
15902 push_base_cleanups ();
15903 }
15904 }
15905
15906 /* At the end of every destructor we generate code to delete the object if
15907 necessary. Do that now. */
15908
15909 static void
finish_destructor_body(void)15910 finish_destructor_body (void)
15911 {
15912 tree exprstmt;
15913
15914 /* Any return from a destructor will end up here; that way all base
15915 and member cleanups will be run when the function returns. */
15916 add_stmt (build_stmt (input_location, LABEL_EXPR, cdtor_label));
15917
15918 if (targetm.cxx.cdtor_returns_this ())
15919 {
15920 tree val;
15921
15922 val = DECL_ARGUMENTS (current_function_decl);
15923 val = build2 (MODIFY_EXPR, TREE_TYPE (val),
15924 DECL_RESULT (current_function_decl), val);
15925 /* Return the address of the object. */
15926 exprstmt = build_stmt (input_location, RETURN_EXPR, val);
15927 add_stmt (exprstmt);
15928 }
15929 }
15930
15931 /* Do the necessary processing for the beginning of a function body, which
15932 in this case includes member-initializers, but not the catch clauses of
15933 a function-try-block. Currently, this means opening a binding level
15934 for the member-initializers (in a ctor), member cleanups (in a dtor),
15935 and capture proxies (in a lambda operator()). */
15936
15937 tree
begin_function_body(void)15938 begin_function_body (void)
15939 {
15940 tree stmt;
15941
15942 if (! FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
15943 return NULL_TREE;
15944
15945 if (processing_template_decl)
15946 /* Do nothing now. */;
15947 else
15948 /* Always keep the BLOCK node associated with the outermost pair of
15949 curly braces of a function. These are needed for correct
15950 operation of dwarfout.c. */
15951 keep_next_level (true);
15952
15953 stmt = begin_compound_stmt (BCS_FN_BODY);
15954
15955 if (processing_template_decl)
15956 /* Do nothing now. */;
15957 else if (DECL_DESTRUCTOR_P (current_function_decl))
15958 begin_destructor_body ();
15959
15960 return stmt;
15961 }
15962
15963 /* Do the processing for the end of a function body. Currently, this means
15964 closing out the cleanups for fully-constructed bases and members, and in
15965 the case of the destructor, deleting the object if desired. Again, this
15966 is only meaningful for [cd]tors, since they are the only functions where
15967 there is a significant distinction between the main body and any
15968 function catch clauses. Handling, say, main() return semantics here
15969 would be wrong, as flowing off the end of a function catch clause for
15970 main() would also need to return 0. */
15971
15972 void
finish_function_body(tree compstmt)15973 finish_function_body (tree compstmt)
15974 {
15975 if (compstmt == NULL_TREE)
15976 return;
15977
15978 /* Close the block. */
15979 finish_compound_stmt (compstmt);
15980
15981 if (processing_template_decl)
15982 /* Do nothing now. */;
15983 else if (DECL_CONSTRUCTOR_P (current_function_decl))
15984 finish_constructor_body ();
15985 else if (DECL_DESTRUCTOR_P (current_function_decl))
15986 finish_destructor_body ();
15987 }
15988
15989 /* Given a function, returns the BLOCK corresponding to the outermost level
15990 of curly braces, skipping the artificial block created for constructor
15991 initializers. */
15992
15993 tree
outer_curly_brace_block(tree fndecl)15994 outer_curly_brace_block (tree fndecl)
15995 {
15996 tree block = DECL_INITIAL (fndecl);
15997 if (BLOCK_OUTER_CURLY_BRACE_P (block))
15998 return block;
15999 block = BLOCK_SUBBLOCKS (block);
16000 if (BLOCK_OUTER_CURLY_BRACE_P (block))
16001 return block;
16002 block = BLOCK_SUBBLOCKS (block);
16003 gcc_assert (BLOCK_OUTER_CURLY_BRACE_P (block));
16004 return block;
16005 }
16006
16007 /* If FNDECL is a class's key method, add the class to the list of
16008 keyed classes that should be emitted. */
16009
16010 static void
record_key_method_defined(tree fndecl)16011 record_key_method_defined (tree fndecl)
16012 {
16013 if (DECL_NONSTATIC_MEMBER_FUNCTION_P (fndecl)
16014 && DECL_VIRTUAL_P (fndecl)
16015 && !processing_template_decl)
16016 {
16017 tree fnclass = DECL_CONTEXT (fndecl);
16018 if (fndecl == CLASSTYPE_KEY_METHOD (fnclass))
16019 vec_safe_push (keyed_classes, fnclass);
16020 }
16021 }
16022
16023 /* Subroutine of finish_function.
16024 Save the body of constexpr functions for possible
16025 future compile time evaluation. */
16026
16027 static void
maybe_save_function_definition(tree fun)16028 maybe_save_function_definition (tree fun)
16029 {
16030 if (!processing_template_decl
16031 && DECL_DECLARED_CONSTEXPR_P (fun)
16032 && !cp_function_chain->invalid_constexpr
16033 && !DECL_CLONED_FUNCTION_P (fun))
16034 register_constexpr_fundef (fun, DECL_SAVED_TREE (fun));
16035 }
16036
16037 /* Attempt to add a fix-it hint to RICHLOC suggesting the insertion
16038 of "return *this;" immediately before its location, using FNDECL's
16039 first statement (if any) to give the indentation, if appropriate. */
16040
16041 static void
add_return_star_this_fixit(gcc_rich_location * richloc,tree fndecl)16042 add_return_star_this_fixit (gcc_rich_location *richloc, tree fndecl)
16043 {
16044 location_t indent = UNKNOWN_LOCATION;
16045 tree stmts = expr_first (DECL_SAVED_TREE (fndecl));
16046 if (stmts)
16047 indent = EXPR_LOCATION (stmts);
16048 richloc->add_fixit_insert_formatted ("return *this;",
16049 richloc->get_loc (),
16050 indent);
16051 }
16052
16053 /* Finish up a function declaration and compile that function
16054 all the way to assembler language output. The free the storage
16055 for the function definition. INLINE_P is TRUE if we just
16056 finished processing the body of an in-class inline function
16057 definition. (This processing will have taken place after the
16058 class definition is complete.) */
16059
16060 tree
finish_function(bool inline_p)16061 finish_function (bool inline_p)
16062 {
16063 tree fndecl = current_function_decl;
16064 tree fntype, ctype = NULL_TREE;
16065
16066 /* When we get some parse errors, we can end up without a
16067 current_function_decl, so cope. */
16068 if (fndecl == NULL_TREE)
16069 return error_mark_node;
16070
16071 if (!DECL_OMP_DECLARE_REDUCTION_P (fndecl))
16072 finish_lambda_scope ();
16073
16074 if (c_dialect_objc ())
16075 objc_finish_function ();
16076
16077 record_key_method_defined (fndecl);
16078
16079 fntype = TREE_TYPE (fndecl);
16080
16081 /* TREE_READONLY (fndecl) = 1;
16082 This caused &foo to be of type ptr-to-const-function
16083 which then got a warning when stored in a ptr-to-function variable. */
16084
16085 gcc_assert (building_stmt_list_p ());
16086 /* The current function is being defined, so its DECL_INITIAL should
16087 be set, and unless there's a multiple definition, it should be
16088 error_mark_node. */
16089 gcc_assert (DECL_INITIAL (fndecl) == error_mark_node);
16090
16091 /* For a cloned function, we've already got all the code we need;
16092 there's no need to add any extra bits. */
16093 if (!DECL_CLONED_FUNCTION_P (fndecl))
16094 {
16095 /* Make it so that `main' always returns 0 by default. */
16096 if (DECL_MAIN_P (current_function_decl))
16097 finish_return_stmt (integer_zero_node);
16098
16099 if (use_eh_spec_block (current_function_decl))
16100 finish_eh_spec_block (TYPE_RAISES_EXCEPTIONS
16101 (TREE_TYPE (current_function_decl)),
16102 current_eh_spec_block);
16103 }
16104
16105 /* If we're saving up tree structure, tie off the function now. */
16106 DECL_SAVED_TREE (fndecl) = pop_stmt_list (DECL_SAVED_TREE (fndecl));
16107
16108 finish_fname_decls ();
16109
16110 /* If this function can't throw any exceptions, remember that. */
16111 if (!processing_template_decl
16112 && !cp_function_chain->can_throw
16113 && !flag_non_call_exceptions
16114 && !decl_replaceable_p (fndecl))
16115 TREE_NOTHROW (fndecl) = 1;
16116
16117 /* This must come after expand_function_end because cleanups might
16118 have declarations (from inline functions) that need to go into
16119 this function's blocks. */
16120
16121 /* If the current binding level isn't the outermost binding level
16122 for this function, either there is a bug, or we have experienced
16123 syntax errors and the statement tree is malformed. */
16124 if (current_binding_level->kind != sk_function_parms)
16125 {
16126 /* Make sure we have already experienced errors. */
16127 gcc_assert (errorcount);
16128
16129 /* Throw away the broken statement tree and extra binding
16130 levels. */
16131 DECL_SAVED_TREE (fndecl) = alloc_stmt_list ();
16132
16133 while (current_binding_level->kind != sk_function_parms)
16134 {
16135 if (current_binding_level->kind == sk_class)
16136 pop_nested_class ();
16137 else
16138 poplevel (0, 0, 0);
16139 }
16140 }
16141 poplevel (1, 0, 1);
16142
16143 /* Statements should always be full-expressions at the outermost set
16144 of curly braces for a function. */
16145 gcc_assert (stmts_are_full_exprs_p ());
16146
16147 /* If there are no return statements in a function with auto return type,
16148 the return type is void. But if the declared type is something like
16149 auto*, this is an error. */
16150 if (!processing_template_decl && FNDECL_USED_AUTO (fndecl)
16151 && TREE_TYPE (fntype) == current_function_auto_return_pattern)
16152 {
16153 if (is_auto (current_function_auto_return_pattern))
16154 {
16155 apply_deduced_return_type (fndecl, void_type_node);
16156 fntype = TREE_TYPE (fndecl);
16157 }
16158 else if (!current_function_returns_value
16159 && !current_function_returns_null)
16160 {
16161 error ("no return statements in function returning %qT",
16162 current_function_auto_return_pattern);
16163 inform (input_location, "only plain %<auto%> return type can be "
16164 "deduced to %<void%>");
16165 }
16166 }
16167
16168 // If this is a concept, check that the definition is reasonable.
16169 if (DECL_DECLARED_CONCEPT_P (fndecl))
16170 check_function_concept (fndecl);
16171
16172 /* Lambda closure members are implicitly constexpr if possible. */
16173 if (cxx_dialect >= cxx17
16174 && LAMBDA_TYPE_P (CP_DECL_CONTEXT (fndecl)))
16175 DECL_DECLARED_CONSTEXPR_P (fndecl)
16176 = ((processing_template_decl
16177 || is_valid_constexpr_fn (fndecl, /*complain*/false))
16178 && potential_constant_expression (DECL_SAVED_TREE (fndecl)));
16179
16180 /* Save constexpr function body before it gets munged by
16181 the NRV transformation. */
16182 maybe_save_function_definition (fndecl);
16183
16184 /* Invoke the pre-genericize plugin before we start munging things. */
16185 if (!processing_template_decl)
16186 invoke_plugin_callbacks (PLUGIN_PRE_GENERICIZE, fndecl);
16187
16188 /* Perform delayed folding before NRV transformation. */
16189 if (!processing_template_decl && !DECL_OMP_DECLARE_REDUCTION_P (fndecl))
16190 cp_fold_function (fndecl);
16191
16192 /* Set up the named return value optimization, if we can. Candidate
16193 variables are selected in check_return_expr. */
16194 if (current_function_return_value)
16195 {
16196 tree r = current_function_return_value;
16197 tree outer;
16198
16199 if (r != error_mark_node
16200 /* This is only worth doing for fns that return in memory--and
16201 simpler, since we don't have to worry about promoted modes. */
16202 && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl)), fndecl)
16203 /* Only allow this for variables declared in the outer scope of
16204 the function so we know that their lifetime always ends with a
16205 return; see g++.dg/opt/nrv6.C. We could be more flexible if
16206 we were to do this optimization in tree-ssa. */
16207 && (outer = outer_curly_brace_block (fndecl))
16208 && chain_member (r, BLOCK_VARS (outer)))
16209 finalize_nrv (&DECL_SAVED_TREE (fndecl), r, DECL_RESULT (fndecl));
16210
16211 current_function_return_value = NULL_TREE;
16212 }
16213
16214 /* Remember that we were in class scope. */
16215 if (current_class_name)
16216 ctype = current_class_type;
16217
16218 /* Must mark the RESULT_DECL as being in this function. */
16219 DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
16220
16221 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
16222 to the FUNCTION_DECL node itself. */
16223 BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
16224
16225 /* Save away current state, if appropriate. */
16226 if (!processing_template_decl)
16227 save_function_data (fndecl);
16228
16229 /* Complain if there's just no return statement. */
16230 if (warn_return_type
16231 && !VOID_TYPE_P (TREE_TYPE (fntype))
16232 && !dependent_type_p (TREE_TYPE (fntype))
16233 && !current_function_returns_value && !current_function_returns_null
16234 /* Don't complain if we abort or throw. */
16235 && !current_function_returns_abnormally
16236 /* Don't complain if there's an infinite loop. */
16237 && !current_function_infinite_loop
16238 /* Don't complain if we are declared noreturn. */
16239 && !TREE_THIS_VOLATILE (fndecl)
16240 && !DECL_NAME (DECL_RESULT (fndecl))
16241 && !TREE_NO_WARNING (fndecl)
16242 /* Structor return values (if any) are set by the compiler. */
16243 && !DECL_CONSTRUCTOR_P (fndecl)
16244 && !DECL_DESTRUCTOR_P (fndecl)
16245 && targetm.warn_func_return (fndecl))
16246 {
16247 gcc_rich_location richloc (input_location);
16248 /* Potentially add a "return *this;" fix-it hint for
16249 assignment operators. */
16250 if (IDENTIFIER_ASSIGN_OP_P (DECL_NAME (fndecl)))
16251 {
16252 tree valtype = TREE_TYPE (DECL_RESULT (fndecl));
16253 if (TREE_CODE (valtype) == REFERENCE_TYPE
16254 && current_class_ref
16255 && same_type_ignoring_top_level_qualifiers_p
16256 (TREE_TYPE (valtype), TREE_TYPE (current_class_ref))
16257 && global_dc->option_enabled (OPT_Wreturn_type,
16258 global_dc->option_state))
16259 add_return_star_this_fixit (&richloc, fndecl);
16260 }
16261 if (warning_at (&richloc, OPT_Wreturn_type,
16262 "no return statement in function returning non-void"))
16263 TREE_NO_WARNING (fndecl) = 1;
16264 }
16265
16266 /* Store the end of the function, so that we get good line number
16267 info for the epilogue. */
16268 cfun->function_end_locus = input_location;
16269
16270 /* Complain about parameters that are only set, but never otherwise used. */
16271 if (warn_unused_but_set_parameter
16272 && !processing_template_decl
16273 && errorcount == unused_but_set_errorcount
16274 && !DECL_CLONED_FUNCTION_P (fndecl))
16275 {
16276 tree decl;
16277
16278 for (decl = DECL_ARGUMENTS (fndecl);
16279 decl;
16280 decl = DECL_CHAIN (decl))
16281 if (TREE_USED (decl)
16282 && TREE_CODE (decl) == PARM_DECL
16283 && !DECL_READ_P (decl)
16284 && DECL_NAME (decl)
16285 && !DECL_ARTIFICIAL (decl)
16286 && !TREE_NO_WARNING (decl)
16287 && !DECL_IN_SYSTEM_HEADER (decl)
16288 && TREE_TYPE (decl) != error_mark_node
16289 && !TYPE_REF_P (TREE_TYPE (decl))
16290 && (!CLASS_TYPE_P (TREE_TYPE (decl))
16291 || !TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl))))
16292 warning_at (DECL_SOURCE_LOCATION (decl),
16293 OPT_Wunused_but_set_parameter,
16294 "parameter %qD set but not used", decl);
16295 unused_but_set_errorcount = errorcount;
16296 }
16297
16298 /* Complain about locally defined typedefs that are not used in this
16299 function. */
16300 maybe_warn_unused_local_typedefs ();
16301
16302 /* Possibly warn about unused parameters. */
16303 if (warn_unused_parameter
16304 && !processing_template_decl
16305 && !DECL_CLONED_FUNCTION_P (fndecl))
16306 do_warn_unused_parameter (fndecl);
16307
16308 /* Genericize before inlining. */
16309 if (!processing_template_decl)
16310 {
16311 struct language_function *f = DECL_SAVED_FUNCTION_DATA (fndecl);
16312 if (!DECL_OMP_DECLARE_REDUCTION_P (fndecl))
16313 cp_genericize (fndecl);
16314 /* Clear out the bits we don't need. */
16315 f->x_current_class_ptr = NULL;
16316 f->x_current_class_ref = NULL;
16317 f->x_eh_spec_block = NULL;
16318 f->x_in_charge_parm = NULL;
16319 f->x_vtt_parm = NULL;
16320 f->x_return_value = NULL;
16321 f->bindings = NULL;
16322 f->extern_decl_map = NULL;
16323 f->infinite_loops = NULL;
16324 }
16325
16326 /* We're leaving the context of this function, so zap cfun. It's still in
16327 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
16328 set_cfun (NULL);
16329 current_function_decl = NULL;
16330
16331 /* If this is an in-class inline definition, we may have to pop the
16332 bindings for the template parameters that we added in
16333 maybe_begin_member_template_processing when start_function was
16334 called. */
16335 if (inline_p)
16336 maybe_end_member_template_processing ();
16337
16338 /* Leave the scope of the class. */
16339 if (ctype)
16340 pop_nested_class ();
16341
16342 --function_depth;
16343
16344 /* Clean up. */
16345 current_function_decl = NULL_TREE;
16346
16347 invoke_plugin_callbacks (PLUGIN_FINISH_PARSE_FUNCTION, fndecl);
16348 return fndecl;
16349 }
16350
16351 /* Create the FUNCTION_DECL for a function definition.
16352 DECLSPECS and DECLARATOR are the parts of the declaration;
16353 they describe the return type and the name of the function,
16354 but twisted together in a fashion that parallels the syntax of C.
16355
16356 This function creates a binding context for the function body
16357 as well as setting up the FUNCTION_DECL in current_function_decl.
16358
16359 Returns a FUNCTION_DECL on success.
16360
16361 If the DECLARATOR is not suitable for a function (it defines a datum
16362 instead), we return 0, which tells yyparse to report a parse error.
16363
16364 May return void_type_node indicating that this method is actually
16365 a friend. See grokfield for more details.
16366
16367 Came here with a `.pushlevel' .
16368
16369 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
16370 CHANGES TO CODE IN `grokfield'. */
16371
16372 tree
grokmethod(cp_decl_specifier_seq * declspecs,const cp_declarator * declarator,tree attrlist)16373 grokmethod (cp_decl_specifier_seq *declspecs,
16374 const cp_declarator *declarator, tree attrlist)
16375 {
16376 tree fndecl = grokdeclarator (declarator, declspecs, MEMFUNCDEF, 0,
16377 &attrlist);
16378
16379 if (fndecl == error_mark_node)
16380 return error_mark_node;
16381
16382 if (fndecl == NULL || TREE_CODE (fndecl) != FUNCTION_DECL)
16383 {
16384 error ("invalid member function declaration");
16385 return error_mark_node;
16386 }
16387
16388 if (attrlist)
16389 cplus_decl_attributes (&fndecl, attrlist, 0);
16390
16391 /* Pass friends other than inline friend functions back. */
16392 if (fndecl == void_type_node)
16393 return fndecl;
16394
16395 if (DECL_IN_AGGR_P (fndecl))
16396 {
16397 if (DECL_CLASS_SCOPE_P (fndecl))
16398 error ("%qD is already defined in class %qT", fndecl,
16399 DECL_CONTEXT (fndecl));
16400 return error_mark_node;
16401 }
16402
16403 check_template_shadow (fndecl);
16404
16405 if (TREE_PUBLIC (fndecl))
16406 DECL_COMDAT (fndecl) = 1;
16407 DECL_DECLARED_INLINE_P (fndecl) = 1;
16408 DECL_NO_INLINE_WARNING_P (fndecl) = 1;
16409
16410 /* We process method specializations in finish_struct_1. */
16411 if (processing_template_decl && !DECL_TEMPLATE_SPECIALIZATION (fndecl))
16412 {
16413 fndecl = push_template_decl (fndecl);
16414 if (fndecl == error_mark_node)
16415 return fndecl;
16416 }
16417
16418 if (! DECL_FRIEND_P (fndecl))
16419 {
16420 if (DECL_CHAIN (fndecl))
16421 {
16422 fndecl = copy_node (fndecl);
16423 TREE_CHAIN (fndecl) = NULL_TREE;
16424 }
16425 }
16426
16427 cp_finish_decl (fndecl, NULL_TREE, false, NULL_TREE, 0);
16428
16429 DECL_IN_AGGR_P (fndecl) = 1;
16430 return fndecl;
16431 }
16432
16433
16434 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
16435 we can lay it out later, when and if its type becomes complete.
16436
16437 Also handle constexpr variables where the initializer involves
16438 an unlowered PTRMEM_CST because the class isn't complete yet. */
16439
16440 void
maybe_register_incomplete_var(tree var)16441 maybe_register_incomplete_var (tree var)
16442 {
16443 gcc_assert (VAR_P (var));
16444
16445 /* Keep track of variables with incomplete types. */
16446 if (!processing_template_decl && TREE_TYPE (var) != error_mark_node
16447 && DECL_EXTERNAL (var))
16448 {
16449 tree inner_type = TREE_TYPE (var);
16450
16451 while (TREE_CODE (inner_type) == ARRAY_TYPE)
16452 inner_type = TREE_TYPE (inner_type);
16453 inner_type = TYPE_MAIN_VARIANT (inner_type);
16454
16455 if ((!COMPLETE_TYPE_P (inner_type) && CLASS_TYPE_P (inner_type))
16456 /* RTTI TD entries are created while defining the type_info. */
16457 || (TYPE_LANG_SPECIFIC (inner_type)
16458 && TYPE_BEING_DEFINED (inner_type)))
16459 {
16460 incomplete_var iv = {var, inner_type};
16461 vec_safe_push (incomplete_vars, iv);
16462 }
16463 else if (!(DECL_LANG_SPECIFIC (var) && DECL_TEMPLATE_INFO (var))
16464 && decl_constant_var_p (var)
16465 && (TYPE_PTRMEM_P (inner_type) || CLASS_TYPE_P (inner_type)))
16466 {
16467 /* When the outermost open class is complete we can resolve any
16468 pointers-to-members. */
16469 tree context = outermost_open_class ();
16470 incomplete_var iv = {var, context};
16471 vec_safe_push (incomplete_vars, iv);
16472 }
16473 }
16474 }
16475
16476 /* Called when a class type (given by TYPE) is defined. If there are
16477 any existing VAR_DECLs whose type has been completed by this
16478 declaration, update them now. */
16479
16480 void
complete_vars(tree type)16481 complete_vars (tree type)
16482 {
16483 unsigned ix;
16484 incomplete_var *iv;
16485
16486 for (ix = 0; vec_safe_iterate (incomplete_vars, ix, &iv); )
16487 {
16488 if (same_type_p (type, iv->incomplete_type))
16489 {
16490 tree var = iv->decl;
16491 tree type = TREE_TYPE (var);
16492
16493 if (type != error_mark_node
16494 && (TYPE_MAIN_VARIANT (strip_array_types (type))
16495 == iv->incomplete_type))
16496 {
16497 /* Complete the type of the variable. The VAR_DECL itself
16498 will be laid out in expand_expr. */
16499 complete_type (type);
16500 cp_apply_type_quals_to_decl (cp_type_quals (type), var);
16501 }
16502
16503 /* Remove this entry from the list. */
16504 incomplete_vars->unordered_remove (ix);
16505 }
16506 else
16507 ix++;
16508 }
16509
16510 /* Check for pending declarations which may have abstract type. */
16511 complete_type_check_abstract (type);
16512 }
16513
16514 /* If DECL is of a type which needs a cleanup, build and return an
16515 expression to perform that cleanup here. Return NULL_TREE if no
16516 cleanup need be done. DECL can also be a _REF when called from
16517 split_nonconstant_init_1. */
16518
16519 tree
cxx_maybe_build_cleanup(tree decl,tsubst_flags_t complain)16520 cxx_maybe_build_cleanup (tree decl, tsubst_flags_t complain)
16521 {
16522 tree type;
16523 tree attr;
16524 tree cleanup;
16525
16526 /* Assume no cleanup is required. */
16527 cleanup = NULL_TREE;
16528
16529 if (error_operand_p (decl))
16530 return cleanup;
16531
16532 /* Handle "__attribute__((cleanup))". We run the cleanup function
16533 before the destructor since the destructor is what actually
16534 terminates the lifetime of the object. */
16535 if (DECL_P (decl))
16536 attr = lookup_attribute ("cleanup", DECL_ATTRIBUTES (decl));
16537 else
16538 attr = NULL_TREE;
16539 if (attr)
16540 {
16541 tree id;
16542 tree fn;
16543 tree arg;
16544
16545 /* Get the name specified by the user for the cleanup function. */
16546 id = TREE_VALUE (TREE_VALUE (attr));
16547 /* Look up the name to find the cleanup function to call. It is
16548 important to use lookup_name here because that is what is
16549 used in c-common.c:handle_cleanup_attribute when performing
16550 initial checks on the attribute. Note that those checks
16551 include ensuring that the function found is not an overloaded
16552 function, or an object with an overloaded call operator,
16553 etc.; we can rely on the fact that the function found is an
16554 ordinary FUNCTION_DECL. */
16555 fn = lookup_name (id);
16556 arg = build_address (decl);
16557 if (!mark_used (decl, complain) && !(complain & tf_error))
16558 return error_mark_node;
16559 cleanup = cp_build_function_call_nary (fn, complain, arg, NULL_TREE);
16560 if (cleanup == error_mark_node)
16561 return error_mark_node;
16562 }
16563 /* Handle ordinary C++ destructors. */
16564 type = TREE_TYPE (decl);
16565 if (type_build_dtor_call (type))
16566 {
16567 int flags = LOOKUP_NORMAL|LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR;
16568 tree addr;
16569 tree call;
16570
16571 if (TREE_CODE (type) == ARRAY_TYPE)
16572 addr = decl;
16573 else
16574 addr = build_address (decl);
16575
16576 call = build_delete (TREE_TYPE (addr), addr,
16577 sfk_complete_destructor, flags, 0, complain);
16578 if (call == error_mark_node)
16579 cleanup = error_mark_node;
16580 else if (TYPE_HAS_TRIVIAL_DESTRUCTOR (type))
16581 /* Discard the call. */;
16582 else if (cleanup)
16583 cleanup = cp_build_compound_expr (cleanup, call, complain);
16584 else
16585 cleanup = call;
16586 }
16587
16588 /* build_delete sets the location of the destructor call to the
16589 current location, even though the destructor is going to be
16590 called later, at the end of the current scope. This can lead to
16591 a "jumpy" behavior for users of debuggers when they step around
16592 the end of the block. So let's unset the location of the
16593 destructor call instead. */
16594 protected_set_expr_location (cleanup, UNKNOWN_LOCATION);
16595
16596 if (cleanup
16597 && DECL_P (decl)
16598 && !lookup_attribute ("warn_unused", TYPE_ATTRIBUTES (TREE_TYPE (decl)))
16599 /* Treat objects with destructors as used; the destructor may do
16600 something substantive. */
16601 && !mark_used (decl, complain) && !(complain & tf_error))
16602 return error_mark_node;
16603
16604 return cleanup;
16605 }
16606
16607
16608 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
16609 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
16610 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
16611
16612 tree
static_fn_type(tree memfntype)16613 static_fn_type (tree memfntype)
16614 {
16615 tree fntype;
16616 tree args;
16617
16618 if (TYPE_PTRMEMFUNC_P (memfntype))
16619 memfntype = TYPE_PTRMEMFUNC_FN_TYPE (memfntype);
16620 if (INDIRECT_TYPE_P (memfntype)
16621 || TREE_CODE (memfntype) == FUNCTION_DECL)
16622 memfntype = TREE_TYPE (memfntype);
16623 if (TREE_CODE (memfntype) == FUNCTION_TYPE)
16624 return memfntype;
16625 gcc_assert (TREE_CODE (memfntype) == METHOD_TYPE);
16626 args = TYPE_ARG_TYPES (memfntype);
16627 fntype = build_function_type (TREE_TYPE (memfntype), TREE_CHAIN (args));
16628 fntype = apply_memfn_quals (fntype, type_memfn_quals (memfntype));
16629 fntype = (cp_build_type_attribute_variant
16630 (fntype, TYPE_ATTRIBUTES (memfntype)));
16631 fntype = cxx_copy_lang_qualifiers (fntype, memfntype);
16632 return fntype;
16633 }
16634
16635 /* DECL was originally constructed as a non-static member function,
16636 but turned out to be static. Update it accordingly. */
16637
16638 void
revert_static_member_fn(tree decl)16639 revert_static_member_fn (tree decl)
16640 {
16641 tree stype = static_fn_type (decl);
16642 cp_cv_quals quals = type_memfn_quals (stype);
16643 cp_ref_qualifier rqual = type_memfn_rqual (stype);
16644
16645 if (quals != TYPE_UNQUALIFIED || rqual != REF_QUAL_NONE)
16646 stype = apply_memfn_quals (stype, TYPE_UNQUALIFIED, REF_QUAL_NONE);
16647
16648 TREE_TYPE (decl) = stype;
16649
16650 if (DECL_ARGUMENTS (decl))
16651 DECL_ARGUMENTS (decl) = DECL_CHAIN (DECL_ARGUMENTS (decl));
16652 DECL_STATIC_FUNCTION_P (decl) = 1;
16653 }
16654
16655 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
16656 one of the language-independent trees. */
16657
16658 enum cp_tree_node_structure_enum
cp_tree_node_structure(union lang_tree_node * t)16659 cp_tree_node_structure (union lang_tree_node * t)
16660 {
16661 switch (TREE_CODE (&t->generic))
16662 {
16663 case DEFAULT_ARG: return TS_CP_DEFAULT_ARG;
16664 case DEFERRED_NOEXCEPT: return TS_CP_DEFERRED_NOEXCEPT;
16665 case IDENTIFIER_NODE: return TS_CP_IDENTIFIER;
16666 case OVERLOAD: return TS_CP_OVERLOAD;
16667 case TEMPLATE_PARM_INDEX: return TS_CP_TPI;
16668 case PTRMEM_CST: return TS_CP_PTRMEM;
16669 case BASELINK: return TS_CP_BASELINK;
16670 case TEMPLATE_DECL: return TS_CP_TEMPLATE_DECL;
16671 case STATIC_ASSERT: return TS_CP_STATIC_ASSERT;
16672 case ARGUMENT_PACK_SELECT: return TS_CP_ARGUMENT_PACK_SELECT;
16673 case TRAIT_EXPR: return TS_CP_TRAIT_EXPR;
16674 case LAMBDA_EXPR: return TS_CP_LAMBDA_EXPR;
16675 case TEMPLATE_INFO: return TS_CP_TEMPLATE_INFO;
16676 case CONSTRAINT_INFO: return TS_CP_CONSTRAINT_INFO;
16677 case USERDEF_LITERAL: return TS_CP_USERDEF_LITERAL;
16678 default: return TS_CP_GENERIC;
16679 }
16680 }
16681
16682 /* Build the void_list_node (void_type_node having been created). */
16683 tree
build_void_list_node(void)16684 build_void_list_node (void)
16685 {
16686 tree t = build_tree_list (NULL_TREE, void_type_node);
16687 return t;
16688 }
16689
16690 bool
cp_missing_noreturn_ok_p(tree decl)16691 cp_missing_noreturn_ok_p (tree decl)
16692 {
16693 /* A missing noreturn is ok for the `main' function. */
16694 return DECL_MAIN_P (decl);
16695 }
16696
16697 /* Return the decl used to identify the COMDAT group into which DECL should
16698 be placed. */
16699
16700 tree
cxx_comdat_group(tree decl)16701 cxx_comdat_group (tree decl)
16702 {
16703 /* Virtual tables, construction virtual tables, and virtual table
16704 tables all go in a single COMDAT group, named after the primary
16705 virtual table. */
16706 if (VAR_P (decl) && DECL_VTABLE_OR_VTT_P (decl))
16707 decl = CLASSTYPE_VTABLES (DECL_CONTEXT (decl));
16708 /* For all other DECLs, the COMDAT group is the mangled name of the
16709 declaration itself. */
16710 else
16711 {
16712 while (DECL_THUNK_P (decl))
16713 {
16714 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
16715 into the same section as the target function. In that case
16716 we must return target's name. */
16717 tree target = THUNK_TARGET (decl);
16718 if (TARGET_USE_LOCAL_THUNK_ALIAS_P (target)
16719 && DECL_SECTION_NAME (target) != NULL
16720 && DECL_ONE_ONLY (target))
16721 decl = target;
16722 else
16723 break;
16724 }
16725 }
16726
16727 return decl;
16728 }
16729
16730 /* Returns the return type for FN as written by the user, which may include
16731 a placeholder for a deduced return type. */
16732
16733 tree
fndecl_declared_return_type(tree fn)16734 fndecl_declared_return_type (tree fn)
16735 {
16736 fn = STRIP_TEMPLATE (fn);
16737 if (FNDECL_USED_AUTO (fn))
16738 {
16739 struct language_function *f = NULL;
16740 if (DECL_STRUCT_FUNCTION (fn))
16741 f = DECL_STRUCT_FUNCTION (fn)->language;
16742 if (f == NULL)
16743 f = DECL_SAVED_FUNCTION_DATA (fn);
16744 return f->x_auto_return_pattern;
16745 }
16746 return TREE_TYPE (TREE_TYPE (fn));
16747 }
16748
16749 /* Returns true iff DECL is a variable or function declared with an auto type
16750 that has not yet been deduced to a real type. */
16751
16752 bool
undeduced_auto_decl(tree decl)16753 undeduced_auto_decl (tree decl)
16754 {
16755 if (cxx_dialect < cxx11)
16756 return false;
16757 STRIP_ANY_LOCATION_WRAPPER (decl);
16758 return ((VAR_OR_FUNCTION_DECL_P (decl)
16759 || TREE_CODE (decl) == TEMPLATE_DECL)
16760 && type_uses_auto (TREE_TYPE (decl)));
16761 }
16762
16763 /* Complain if DECL has an undeduced return type. */
16764
16765 bool
require_deduced_type(tree decl,tsubst_flags_t complain)16766 require_deduced_type (tree decl, tsubst_flags_t complain)
16767 {
16768 if (undeduced_auto_decl (decl))
16769 {
16770 if (complain & tf_error)
16771 error ("use of %qD before deduction of %<auto%>", decl);
16772 return false;
16773 }
16774 return true;
16775 }
16776
16777 /* Create a representation of the explicit-specifier with
16778 constant-expression of EXPR. COMPLAIN is as for tsubst. */
16779
16780 tree
build_explicit_specifier(tree expr,tsubst_flags_t complain)16781 build_explicit_specifier (tree expr, tsubst_flags_t complain)
16782 {
16783 if (instantiation_dependent_expression_p (expr))
16784 /* Wait for instantiation, tsubst_function_decl will handle it. */
16785 return expr;
16786
16787 expr = instantiate_non_dependent_expr_sfinae (expr, complain);
16788 /* Don't let convert_like_real create more template codes. */
16789 processing_template_decl_sentinel s;
16790 expr = build_converted_constant_bool_expr (expr, complain);
16791 expr = cxx_constant_value (expr);
16792 return expr;
16793 }
16794
16795 #include "gt-cp-decl.h"
16796