| blob | 07fb9855cd20b4fbc91fd55b4961abedb7269299 |
1 /* Process declarations and variables for -*- C++ -*- compiler.
2 Copyright (C) 1988-2024 Free Software Foundation, Inc.
3 Contributed by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
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.
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.
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/>. */
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. */
26 /* ??? not all decl nodes are given the most useful possible
27 line numbers. For example, the CONST_DECLs for enum values. */
30 #define INCLUDE_MEMORY
65 /* Possible cases of bad specifiers type used by bad_specifiers. */
70 BSP_FIELD /* field */
71 };
101 static tree check_special_function_return_type
112 /* The following symbols are subsumed in the cp_global_trees array, and
113 listed here individually for documentation purposes.
115 C++ extensions
116 tree wchar_decl_node;
118 tree vtable_entry_type;
119 tree delta_type_node;
120 tree __t_desc_type_node;
122 tree class_type_node;
123 tree unknown_type_node;
125 Array type `vtable_entry_type[]'
127 tree vtbl_type_node;
128 tree vtbl_ptr_type_node;
130 Namespaces,
132 tree std_node;
133 tree abi_node;
135 A FUNCTION_DECL which can call `abort'. Not necessarily the
136 one that the user will declare, but sufficient to be called
137 by routines that want to abort the program.
139 tree abort_fndecl;
141 Used by RTTI
142 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
143 tree tinfo_var_id; */
147 /* A list of objects which have constructors or destructors
148 which reside in namespace scope. The decl is stored in
149 the TREE_VALUE slot and the initializer is stored
150 in the TREE_PURPOSE slot. */
151 tree static_aggregates;
153 /* Like static_aggregates, but for thread_local variables. */
154 tree tls_aggregates;
156 /* A hash-map mapping from variable decls to the dynamic initializer for
157 the decl. This is currently only used by OpenMP. */
160 /* -- end of C++ */
162 /* A node for the integer constant 2. */
164 tree integer_two_node;
166 /* vector of static decls. */
169 /* vector of keyed classes. */
172 /* Used only for jumps to as-yet undefined labels, since jumps to
173 defined labels can have their validity checked immediately. */
177 /* The binding level to which this entry is *currently* attached.
178 This is initially the binding level in which the goto appeared,
179 but is modified as scopes are closed. */
181 /* The head of the names list that was current when the goto appeared,
182 or the inner scope popped. These are the decls that will *not* be
183 skipped when jumping to the label. */
184 tree names_in_scope;
185 /* If the use is a possible destination of a computed goto, a vec of decls
186 that aren't destroyed, filled in by poplevel_named_label_1. */
188 /* The location of the goto, for error reporting. */
189 location_t o_goto_locus;
190 /* True if an OpenMP structured block scope has been closed since
191 the goto appeared. This means that the branch from the label will
192 illegally exit an OpenMP scope. */
194 };
196 /* A list of all LABEL_DECLs in the function that have names. Here so
197 we can clear out their names' definitions at the end of the
198 function, and so we can check the validity of jumps to these labels. */
208 /* The binding level to which the label is *currently* attached.
209 This is initially set to the binding level in which the label
210 is defined, but is modified as scopes are closed. */
213 /* The head of the names list that was current when the label was
214 defined, or the inner scope popped. These are the decls that will
215 be skipped when jumping to the label. */
216 tree names_in_scope;
218 /* A vector of all decls from all binding levels that would be
219 crossed by a backward branch to the label. */
222 /* A list of uses of the label, before the label is defined. */
225 /* True if we've seen &&label. Appalently we can't use TREE_ADDRESSABLE for
226 this, it has a more specific meaning for LABEL_DECL. */
229 /* The following bits are set after the label is defined, and are
230 updated as scopes are popped. They indicate that a jump to the
231 label will illegally enter a scope of the given flavor. */
239 };
241 #define named_labels cp_function_chain->x_named_labels
242 \f
243 /* The number of function bodies which we are currently processing.
244 (Zero if we are at namespace scope, one inside the body of a
245 function, two inside the body of a function in a local class, etc.) */
248 /* Whether the exception-specifier is part of a function type (i.e. C++17). */
251 /* States indicating how grokdeclarator() should handle declspecs marked
252 with __attribute__((deprecated)). An object declared as
253 __attribute__((deprecated)) suppresses warnings of uses of other
254 deprecated items. */
257 \f
258 /* A list of VAR_DECLs whose type was incomplete at the time the
259 variable was declared. */
262 tree decl;
263 tree incomplete_type;
264 };
268 \f
269 /* Returns the kind of template specialization we are currently
270 processing, given that it's declaration contained N_CLASS_SCOPES
271 explicit scope qualifications. */
273 tmpl_spec_kind
275 {
281 /* Scan through the template parameter scopes. */
285 {
286 /* If we see a specialization scope inside a parameter scope,
287 then something is wrong. That corresponds to a declaration
288 like:
290 template <class T> template <> ...
292 which is always invalid since [temp.expl.spec] forbids the
293 specialization of a class member template if the enclosing
294 class templates are not explicitly specialized as well. */
296 {
299 else
301 }
306 }
308 /* Handle explicit instantiations. */
310 {
312 /* We've seen a template parameter list during an explicit
313 instantiation. For example:
315 template <class T> template void f(int);
317 This is erroneous. */
319 else
321 }
324 /* We've not seen enough template headers to match all the
325 specialized classes present. For example:
327 template <class T> void R<T>::S<T>::f(int);
329 This is invalid; there needs to be one set of template
330 parameters for each class. */
333 /* We're processing a non-template declaration (even though it may
334 be a member of a template class.) For example:
336 template <class T> void S<T>::f(int);
338 The `class T' matches the `S<T>', leaving no template headers
339 corresponding to the `f'. */
342 /* We've got too many template headers. For example:
344 template <> template <class T> void f (T);
346 There need to be more enclosing classes. */
348 else
349 /* This must be a template. It's of the form:
351 template <class T> template <class U> void S<T>::f(U);
353 This is a specialization if the innermost level was a
354 specialization; otherwise it's just a definition of the
355 template. */
357 }
359 /* Exit the current scope. */
361 void
363 {
365 }
367 /* When a label goes out of scope, check to see if that label was used
368 in a valid manner, and issue any appropriate warnings or errors. */
370 static void
372 {
374 {
376 {
377 location_t location;
381 /* FIXME want (LOCATION_FILE (input_location), (line)0) */
382 /* Avoid crashing later. */
384 }
385 else
387 }
388 }
390 /* Helper function to sort named label entries in a vector by DECL_UID. */
392 static int
394 {
398 /* DECL_UIDs can never be equal. */
400 }
402 /* At the end of a function, all labels declared within the function
403 go out of scope. BLOCK is the top-level block for the
404 function. */
406 static void
408 {
412 /* We need to add the labels to the block chain, so debug
413 information is emitted. But, we want the order to be stable so
414 need to sort them first. Otherwise the debug output could be
415 randomly ordered. I guess it's mostly stable, unless the hash
416 table implementation changes. */
421 {
428 }
433 {
440 }
441 }
443 /* At the end of a block with local labels, restore the outer definition. */
445 static void
447 {
455 else
456 {
459 }
461 }
463 /* The following two routines are used to interface to Objective-C++.
464 The binding level is purposely treated as an opaque type. */
468 {
470 }
472 /* The following routine is used by the NeXT-style SJLJ exceptions;
473 variables get marked 'volatile' so as to not be clobbered by
474 _setjmp()/_longjmp() calls. All variables in the current scope,
475 as well as parent scopes up to (but not including) ENCLOSING_BLK
476 shall be thusly marked. */
478 void
480 {
486 {
487 tree decl;
492 /* Do not climb up past the current function. */
495 }
496 }
498 /* True if B is the level for the condition of a constexpr if. */
500 static bool
502 {
506 }
508 /* True if B is the level for the condition of a consteval if. */
510 static bool
512 {
516 }
518 /* True if T is a non-static VAR_DECL that has a non-trivial destructor.
519 See [stmt.dcl]/2. */
521 static bool
523 {
530 }
532 /* Update data for defined and undefined labels when leaving a scope. */
534 int
536 {
541 {
542 tree decl;
544 /* ENT->NAMES_IN_SCOPE may contain a mixture of DECLs and
545 TREE_LISTs representing OVERLOADs, so be careful. */
555 {
579 }
580 }
582 {
587 {
589 {
595 }
601 }
602 }
605 }
607 /* Saved errorcount to avoid -Wunused-but-set-{parameter,variable} warnings
608 when errors were reported, except for -Werror-unused-but-set-*. */
611 /* Exit a binding level.
612 Pop the level off, and restore the state of the identifier-decl mappings
613 that were in effect when this level was entered.
615 If KEEP == 1, this level had explicit declarations, so
616 and create a "block" (a BLOCK node) for the level
617 to record its declarations and subblocks for symbol table output.
619 If FUNCTIONBODY is nonzero, this level is the body of a function,
620 so create a block as if KEEP were set and also clear out all
621 label names.
623 If REVERSE is nonzero, reverse the order of decls before putting
624 them into the BLOCK. */
626 tree
628 {
629 tree link;
630 /* The chain of decls was accumulated in reverse order.
631 Put it into forward order, just for cleanliness. */
632 tree decls;
633 tree subblocks;
634 tree block;
635 tree decl;
636 scope_kind kind;
639 restart:
652 /* We used to use KEEP == 2 to indicate that the new block should go
653 at the beginning of the list of blocks at this binding level,
654 rather than the end. This hack is no longer used. */
660 /* Any uses of undefined labels, and any defined labels, now operate
661 under constraints of next binding contour. */
666 /* Get the decls in the order they were written.
667 Usually current_binding_level->names is in reverse order.
668 But parameter decls were previously put in forward order. */
672 {
675 }
677 /* If there were any declarations or structure tags in that level,
678 or if this level is a function body,
679 create a BLOCK to record them for the life of this function. */
681 /* Avoid function body block if possible. */
687 {
690 }
692 /* In each subblock, record that this is its superior. */
697 /* Before we remove the declarations first check for unused variables. */
702 {
703 /* There are cases where D itself is a TREE_LIST. See in
704 push_local_binding where the list of decls returned by
705 getdecls is built. */
713 /* For structured bindings, consider only real variables, not
714 subobjects. */
717 /* Don't warn about name-independent declarations. */
724 {
726 {
729 OPT_Wunused_variable,
733 OPT_Wunused_variable,
735 else
739 }
741 // For -Wunused-but-set-variable leave references alone.
744 {
749 else
751 OPT_Wunused_but_set_variable,
754 }
755 }
756 }
758 /* Remove declarations for all the DECLs in this level. */
760 {
761 tree name;
763 {
767 }
768 else
769 {
772 }
774 /* Remove the binding. */
777 else
779 }
781 /* Restore the IDENTIFIER_TYPE_VALUEs. */
786 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
787 list if a `using' declaration put them there. The debugging
788 back ends won't understand OVERLOAD, so we remove them here.
789 Because the BLOCK_VARS are (temporarily) shared with
790 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
791 popped all the bindings. Also remove undeduced 'auto' decls,
792 which LTO doesn't understand, and can't have been used by anything. */
794 {
798 {
800 || (!processing_template_decl
803 else
805 }
806 }
808 /* If the level being exited is the top level of a function,
809 check over all the labels. */
811 {
813 {
814 /* Since this is the top level block of a function, the vars are
815 the function's parameters. Don't leave them in the BLOCK
816 because they are found in the FUNCTION_DECL instead. */
819 }
820 else
822 }
826 {
827 tree stmt;
829 /* If this is a temporary binding created for a cleanup, then we'll
830 have pushed a statement list level. Pop that, create a new
831 BIND_EXPR for the block, and insert it into the stream. */
835 }
839 {
840 /* The current function is being defined, so its DECL_INITIAL
841 should be error_mark_node. */
845 {
847 {
850 }
851 else
853 }
854 }
856 current_binding_level->blocks
859 /* If we did not make a block for the level just exited,
860 any blocks made for inner levels
861 (since they cannot be recorded as subblocks in that level)
862 must be carried forward so they will later become subblocks
863 of something else. */
865 current_binding_level->blocks
868 /* Each and every BLOCK node created here in `poplevel' is important
869 (e.g. for proper debugging information) so if we created one
870 earlier, mark it as "used". */
874 /* All temporary bindings created for cleanups are popped silently. */
879 }
881 /* Call wrapup_globals_declarations for the globals in NAMESPACE. */
882 /* Diagnose odr-used extern inline variables without definitions
883 in the current TU. */
885 int
887 {
889 {
891 {
901 OPT_Wunused_function,
910 }
912 /* Clear out the list, so we don't rescan next time. */
915 /* Write out any globals that need to be output. */
918 }
920 }
921 \f
922 /* In C++, you don't have to write `struct S' to refer to `S'; you
923 can just use `S'. We accomplish this by creating a TYPE_DECL as
924 if the user had written `typedef struct S S'. Create and return
925 the TYPE_DECL for TYPE. */
927 tree
929 {
930 tree decl;
934 /* There are other implicit type declarations, like the one *within*
935 a class that allows you to write `S::S'. We must distinguish
936 amongst these. */
942 }
944 /* Function-scope local entities that need discriminators. Each entry
945 is a {decl,name} pair. VAR_DECLs for anon unions get their name
946 smashed, so we cannot rely on DECL_NAME. */
950 /* Determine the mangling discriminator of local DECL. There are
951 generally very few of these in any particular function. */
953 void
955 {
965 {
973 {
979 /* Replace the saved decl. */
983 }
984 }
987 {
991 }
992 }
994 \f
995 /* True if DECL is a constrained hidden friend as per [temp.friend]/9:
997 A non-template friend declaration with a requires-clause shall be a
998 definition. A friend function template with a constraint that depends on a
999 template parameter from an enclosing template shall be a definition. Such a
1000 constrained friend function or function template declaration does not
1001 declare the same function or function template as a declaration in any other
1002 scope.
1004 The ABI calls this a "member-like constrained friend" and mangles it like a
1005 member function to avoid collisions. */
1007 bool
1009 {
1016 || (uses_outer_template_parms_in_constraints
1018 }
1020 /* Returns true if functions FN1 and FN2 have equivalent trailing
1021 requires clauses. */
1023 static bool
1025 {
1026 /* [temp.friend]/9 "Such a constrained friend function does not declare the
1027 same function as a declaration in any other scope." So no need to
1028 actually compare the requirements. */
1033 /* Compare only trailing requirements. */
1039 /* Substitution is needed when friends are involved. */
1044 }
1046 /* Two functions of the same name correspond [basic.scope.scope] if
1048 + both declare functions with the same non-object-parameter-type-list,
1049 equivalent ([temp.over.link]) trailing requires-clauses (if any, except as
1050 specified in [temp.friend]), and, if both are non-static members, they have
1051 corresponding object parameters, or
1053 + both declare function templates with equivalent
1054 non-object-parameter-type-lists, return types (if any), template-heads, and
1055 trailing requires-clauses (if any), and, if both are non-static members,
1056 they have corresponding object parameters.
1058 This is a subset of decls_match: it identifies declarations that cannot be
1059 overloaded with one another. This function does not consider DECL_NAME. */
1061 bool
1063 {
1068 {
1073 }
1081 /* If only one is a non-static member function, ignore ref-quals. */
1084 /* Two non-static member functions have corresponding object parameters if:
1085 + exactly one is an implicit object member function with no ref-qualifier
1086 and the types of their object parameters ([dcl.fct]), after removing
1087 top-level references, are the same, or
1088 + their object parameters have the same type. */
1089 /* ??? We treat member functions of different classes as corresponding even
1090 though that means the object parameters have different types. */
1097 {
1101 }
1103 /* Two function declarations match if either has a requires-clause
1104 then both have a requires-clause and their constraints-expressions
1105 are equivalent. */
1110 }
1112 /* Subroutine of duplicate_decls: return truthvalue of whether
1113 or not types of these decls match.
1115 For C++, we must compare the parameter list so that `int' can match
1116 `int&' in a parameter position, but `int&' is not confused with
1117 `const int&'. */
1119 int
1121 {
1128 /* If the two DECLs are not even the same kind of thing, we're not
1129 interested in their types. */
1135 {
1136 /* Specializations of different templates are different functions
1137 even if they have the same type. */
1152 /* A new declaration doesn't match a built-in one unless it
1153 is also extern "C". */
1163 /* A declaration with deduced return type should use its pre-deduction
1164 type for declaration matching. */
1168 /* For memchr et al, allow const void* return type (as specified by C++)
1169 when we expect void* (as in C). */
1182 {
1185 {
1189 }
1190 else
1191 types_match =
1197 }
1198 else
1201 /* Two function declarations match if either has a requires-clause
1202 then both have a requires-clause and their constraints-expressions
1203 are equivalent. */
1207 /* The decls dont match if they correspond to two different versions
1208 of the same function. Disallow extern "C" functions to be
1209 versions for now. */
1214 {
1220 }
1221 }
1223 {
1233 /* Two template types match if they are the same. Otherwise, compare
1234 the underlying declarations. */
1237 else
1239 }
1240 else
1241 {
1242 /* Need to check scope for variable declaration (VAR_DECL).
1243 For typedef (TYPE_DECL), scope is ignored. */
1246 /* [dcl.link]
1247 Two declarations for an object with C language linkage
1248 with the same name (ignoring the namespace that qualify
1249 it) that appear in different namespace scopes refer to
1250 the same object. */
1260 else
1263 COMPARE_REDECLARATION);
1264 }
1267 }
1269 /* Mark DECL as versioned if it isn't already. */
1271 static void
1273 {
1275 {
1277 /* If DECL_ASSEMBLER_NAME has already been set, re-mangle
1278 to include the version marker. */
1281 }
1282 }
1284 /* NEWDECL and OLDDECL have identical signatures. If they are
1285 different versions adjust them and return true.
1286 If RECORD is set to true, record function versions. */
1288 bool
1290 {
1296 {
1299 }
1303 {
1304 /* Unfortunately, we can get here before pushdecl naturally calls
1305 push_local_extern_decl_alias, so we need to call it directly. */
1310 }
1316 }
1318 /* If NEWDECL is `static' and an `extern' was seen previously,
1319 warn about it. OLDDECL is the previous declaration.
1321 Note that this does not apply to the C++ case of declaring
1322 a variable `extern const' and then later `const'.
1324 Don't complain about built-in functions, since they are beyond
1325 the user's control. */
1327 void
1329 {
1336 /* Don't get confused by static member functions; that's a different
1337 use of `static'. */
1342 /* If the old declaration was `static', or the new one isn't, then
1343 everything is OK. */
1347 /* It's OK to declare a builtin function as `static'. */
1352 auto_diagnostic_group d;
1357 }
1359 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1360 function templates. If their exception specifications do not
1361 match, issue a diagnostic. */
1363 static void
1365 tree old_decl)
1366 {
1370 /* Two default specs are equivalent, don't force evaluation. */
1376 {
1379 }
1383 /* [except.spec]
1385 If any declaration of a function has an exception-specification,
1386 all declarations, including the definition and an explicit
1387 specialization, of that function shall have an
1388 exception-specification with the same set of type-ids. */
1392 {
1397 auto_diagnostic_group d;
1400 /* Don't fuss about the C library; the C library functions are not
1401 specified to have exception specifications (just behave as if they
1402 have them), but some implementations include them. */
1405 /* We used to silently permit mismatched eh specs with
1406 -fno-exceptions, so only complain if -pedantic. */
1409 /* Reduce to pedwarn for omitted exception specification. No warning
1410 flag for this; silence the warning by correcting the code. */
1412 else
1419 /* Copy the old exception specification if new_decl has none. Unless the
1420 old decl is extern "C", as obscure code might depend on the type of
1421 the new declaration (e.g. noexcept-type19.C). */
1425 }
1426 }
1428 /* Return true if OLD_DECL and NEW_DECL agree on constexprness.
1429 Otherwise issue diagnostics. */
1431 bool
1433 {
1441 {
1447 }
1449 {
1450 /* With -fimplicit-constexpr, ignore changes in the constexpr
1451 keyword. */
1457 {
1458 /* Hide a built-in declaration. */
1464 }
1465 /* 7.1.5 [dcl.constexpr]
1466 Note: An explicit specialization can differ from the template
1467 declaration with respect to the constexpr specifier. */
1476 auto_diagnostic_group d;
1478 "redeclaration %qD differs in %qs "
1480 kind);
1484 }
1486 }
1488 /* DECL is a redeclaration of a function or function template. If
1489 it does have default arguments issue a diagnostic. Note: this
1490 function is used to enforce the requirements in C++11 8.3.6 about
1491 no default arguments in redeclarations. */
1493 static void
1495 {
1501 {
1503 "redeclaration of %q#D may not have default "
1506 }
1507 }
1509 /* NEWDECL is a redeclaration of a function or function template OLDDECL,
1510 in any case represented as FUNCTION_DECLs (the DECL_TEMPLATE_RESULTs of
1511 the TEMPLATE_DECLs in case of function templates). This function is used
1512 to enforce the final part of C++17 11.3.6/4, about a single declaration:
1513 "If a friend declaration specifies a default argument expression, that
1514 declaration shall be a definition and shall be the only declaration of
1515 the function or function template in the translation unit." */
1517 static void
1519 {
1529 {
1530 auto_diagnostic_group d;
1532 "friend declaration of %q#D specifies default "
1537 }
1538 }
1540 /* Merge tree bits that correspond to attributes noreturn, nothrow,
1541 const, malloc, and pure from NEWDECL with those of OLDDECL. */
1543 static void
1545 {
1562 }
1564 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1566 DECL_ATTRIBUTES (fn)))
1568 /* A subroutine of duplicate_decls. Emits a diagnostic when newdecl
1569 ambiguates olddecl. Returns true if an error occurs. */
1571 static bool
1573 {
1576 /* Function template declarations can be differentiated by parameter
1577 and return type. */
1582 {
1583 /* ... and also by their template-heads and requires-clauses. */
1586 {
1587 auto_diagnostic_group d;
1592 }
1594 /* FIXME: The types are the same but the are differences
1595 in either the template heads or function requirements.
1596 We should be able to diagnose a set of common errors
1597 stemming from these declarations. For example:
1599 template<typename T> requires C void f(...);
1600 template<typename T> void f(...) requires C;
1602 These are functionally equivalent but not equivalent. */
1603 }
1606 }
1608 /* OLD_PARMS is the innermost set of template parameters for some template
1609 declaration, and NEW_PARMS is the corresponding set of template parameters
1610 for a redeclaration of that template. Merge the default arguments within
1611 these two sets of parameters. CLASS_P is true iff the template in
1612 question is a class template. */
1614 bool
1616 {
1620 {
1628 {
1629 auto_diagnostic_group d;
1634 }
1636 /* Update the previous template parameters (which are the ones
1637 that will really count) with the new default value. */
1640 /* Update the new parameters, too; they'll be used as the
1641 parameters for any members. */
1643 }
1645 }
1647 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1648 If the redeclaration is invalid, a diagnostic is issued, and the
1649 error_mark_node is returned. Otherwise, OLDDECL is returned.
1651 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1652 returned.
1654 HIDING is true if the new decl is being hidden. WAS_HIDDEN is true
1655 if the old decl was hidden.
1657 Hidden decls can be anticipated builtins, injected friends, or
1658 (coming soon) injected from a local-extern decl. */
1660 tree
1662 {
1666 tree new_template_info;
1675 /* If either the type of the new decl or the type of the old decl is an
1676 error_mark_node, then that implies that we have already issued an
1677 error (earlier) for some bogus type specification, and in that case,
1678 it is rather pointless to harass the user with yet more error message
1679 about the same declaration, so just pretend the types match here. */
1684 /* Check for redeclaration and other discrepancies. */
1687 {
1689 {
1690 /* Avoid warnings redeclaring built-ins which have not been
1691 explicitly declared. */
1693 {
1697 OPT_Wbuiltin_declaration_mismatch,
1699 newdecl);
1701 }
1703 /* If you declare a built-in or predefined function name as static,
1704 the old definition is overridden, but optionally warn this was a
1705 bad choice of name. */
1707 {
1709 OPT_Wshadow,
1713 /* Discard the old built-in function. */
1715 }
1716 /* If the built-in is not ansi, then programs can override
1717 it even globally without an error. */
1722 else
1724 "declaration of %q#D conflicts with built-in "
1727 }
1729 {
1730 /* Avoid warnings redeclaring built-ins which have not been
1731 explicitly declared. */
1733 {
1736 /* A new declaration doesn't match a built-in one unless it
1737 is also extern "C". */
1747 {
1750 /* FILE, tm types are not known at the time
1751 we create the builtins. */
1757 {
1764 {
1774 }
1776 }
1780 next_arg:;
1781 }
1784 OPT_Wbuiltin_declaration_mismatch,
1785 "declaration of %q#D conflicts with built-in "
1787 }
1792 {
1793 /* Don't really override olddecl for __* prefixed builtins
1794 except for __[^b]*_chk, the compiler might be using those
1795 explicitly. */
1797 {
1808 {
1810 {
1812 "definition of %q#D ambiguates built-in "
1815 }
1816 auto_diagnostic_group d;
1818 "new declaration %q#D ambiguates built-in"
1824 }
1825 }
1827 /* A near match; override the builtin. */
1831 OPT_Wbuiltin_declaration_mismatch,
1832 "new declaration %q#D ambiguates built-in "
1834 else
1839 }
1840 else
1841 /* Discard the old built-in function. */
1844 /* Replace the old RTL to avoid problems with inlining. */
1846 }
1847 else
1848 {
1849 /* Even if the types match, prefer the new declarations type
1850 for built-ins which have not been explicitly declared,
1851 for exception lists, etc... */
1858 }
1860 /* If a function is explicitly declared "throw ()", propagate that to
1861 the corresponding builtin. */
1863 && was_hidden
1866 {
1871 }
1873 /* Whether or not the builtin can throw exceptions has no
1874 bearing on this declarator. */
1878 {
1879 /* If a builtin function is redeclared as `static', merge
1880 the declarations, but make the original one static. */
1884 /* Make the old declaration consistent with the new one so
1885 that all remnants of the builtin-ness of this function
1886 will be banished. */
1889 }
1890 }
1892 {
1893 /* C++ Standard, 3.3, clause 4:
1894 "[Note: a namespace name or a class template name must be unique
1895 in its declarative region (7.3.2, clause 14). ]" */
1916 {
1917 /* One is a function and the other is a template
1918 function. */
1922 /* There can only be one! */
1923 auto_diagnostic_group d;
1927 "literal operator %q#D conflicts with"
1931 "raw literal operator %q#D conflicts with"
1933 else
1938 }
1943 /* One is an implicit typedef, that's ok. */
1946 auto_diagnostic_group d;
1951 }
1953 {
1955 /* These are certainly not duplicate declarations; they're
1956 from different scopes. */
1960 {
1964 /* The name of a class template may not be declared to refer to
1965 any other template, class, function, object, namespace, value,
1966 or type in the same scope. */
1969 {
1970 auto_diagnostic_group d;
1976 }
1980 {
1984 }
1986 }
1988 {
1990 {
1991 auto_diagnostic_group d;
1994 newdecl);
1998 }
1999 /* For function versions, params and types match, but they
2000 are not ambiguous. */
2003 /* Let constrained hidden friends coexist for now, we'll
2004 check satisfaction later. */
2007 // The functions have the same parameter types.
2010 // And the same constraints.
2012 {
2013 auto_diagnostic_group d;
2019 }
2020 else
2022 }
2023 else
2024 {
2025 auto_diagnostic_group d;
2030 }
2031 }
2034 {
2035 /* OMP UDRs are never duplicates. */
2037 auto_diagnostic_group d;
2043 }
2053 /* It's OK to have a template specialization and a non-template
2054 with the same type, or to have specializations of two
2055 different templates with the same type. Note that if one is a
2056 specialization, and the other is an instantiation of the same
2057 template, that we do not exit at this point. That situation
2058 can occur if we instantiate a template class, and then
2059 specialize one of its methods. This situation is valid, but
2060 the declarations must be merged in the usual way. */
2067 /* One of the declarations is a template instantiation, and the
2068 other is not a template at all. That's OK. */
2071 {
2072 /* In [namespace.alias] we have:
2074 In a declarative region, a namespace-alias-definition can be
2075 used to redefine a namespace-alias declared in that declarative
2076 region to refer only to the namespace to which it already
2077 refers.
2079 Therefore, if we encounter a second alias directive for the same
2080 alias, we can just ignore the second directive. */
2086 /* Leave it to update_binding to merge or report error. */
2088 }
2089 else
2090 {
2093 {
2094 auto_diagnostic_group d;
2105 {
2110 {
2113 "structured binding at namespace scope is not "
2117 "static structured binding is not "
2121 "extern structured binding is not "
2123 }
2138 }
2140 }
2145 {
2146 /* Prototype decl follows defn w/o prototype. */
2147 auto_diagnostic_group d;
2152 }
2155 {
2156 /* [dcl.link]
2157 If two declarations of the same function or object
2158 specify different linkage-specifications ..., the program
2159 is ill-formed.... Except for functions with C++ linkage,
2160 a function declaration without a linkage specification
2161 shall not precede the first linkage specification for
2162 that function. A function can be declared without a
2163 linkage specification after an explicit linkage
2164 specification has been seen; the linkage explicitly
2165 specified in the earlier declaration is not affected by
2166 such a function declaration.
2168 DR 563 raises the question why the restrictions on
2169 functions should not also apply to objects. Older
2170 versions of G++ silently ignore the linkage-specification
2171 for this example:
2173 namespace N {
2174 extern int i;
2175 extern "C" int i;
2176 }
2178 which is clearly wrong. Therefore, we now treat objects
2179 like functions. */
2181 {
2182 /* There is no explicit linkage-specification, so we use
2183 the linkage from the previous declaration. */
2186 }
2187 else
2188 {
2189 auto_diagnostic_group d;
2196 }
2197 }
2200 ;
2202 {
2203 /* Note: free functions, as TEMPLATE_DECLs, are handled below. */
2206 as FUNCTION_DECLs. */
2208 /* C++11 8.3.6/6.
2209 Default arguments for a member function of a class
2210 template shall be specified on the initial declaration
2211 of the member function within the class template. */
2213 {
2218 {
2222 tree old_parms
2226 }
2227 }
2228 else
2229 {
2237 {
2240 {
2241 auto_diagnostic_group d;
2243 "default argument given for parameter "
2247 olddecl);
2248 }
2249 else
2250 {
2251 auto_diagnostic_group d;
2253 "default argument given for parameter %d "
2257 olddecl);
2258 }
2259 }
2261 /* C++17 11.3.6/4: "If a friend declaration specifies a default
2262 argument expression, that declaration... shall be the only
2263 declaration of the function or function template in the
2264 translation unit." */
2266 }
2267 }
2268 }
2270 /* Do not merge an implicit typedef with an explicit one. In:
2272 class A;
2273 ...
2274 typedef class A A __attribute__ ((foo));
2276 the attribute should apply only to the typedef. */
2291 {
2296 {
2297 /* The old declaration should match the exportingness of the new
2298 declaration. But hidden friend declarations just keep the
2299 exportingness of the old declaration; see CWG2588. */
2303 /* Typedefs are not entities and so are OK to be redeclared
2304 as exported: see [module.interface]/p6. */
2306 {
2309 {
2310 auto_diagnostic_group d;
2314 }
2315 }
2318 }
2319 }
2321 /* We have committed to returning OLDDECL at this point. */
2323 /* If new decl is `static' and an `extern' was seen previously,
2324 warn about it. */
2327 /* True to merge attributes between the declarations, false to
2328 set OLDDECL's attributes to those of NEWDECL (for template
2329 explicit specializations that specify their own attributes
2330 independent of those specified for the primary template). */
2336 {
2338 {
2339 {
2340 auto_diagnostic_group d;
2345 }
2347 /* [dcl.attr.noreturn]: The first declaration of a function shall
2348 specify the noreturn attribute if any declaration of that function
2349 specifies the noreturn attribute. */
2350 tree a;
2353 /* This applies to [[noreturn]] only, not its GNU variants. */
2357 {
2358 auto_diagnostic_group d;
2362 }
2363 }
2365 /* Now that functions must hold information normally held
2366 by field decls, there is extra work to do so that
2367 declaration information does not get destroyed during
2368 definition. */
2390 /* Optionally warn about more than one declaration for the same
2391 name, but don't warn about a function declaration followed by a
2392 definition. */
2395 /* Don't warn about extern decl followed by definition. */
2397 /* Don't warn if at least one is/was hidden. */
2399 /* Don't warn about declaration followed by specialization. */
2402 {
2403 auto_diagnostic_group d;
2405 OPT_Wredundant_decls,
2407 newdecl))
2410 }
2412 /* [dcl.fct.def.delete] A deleted definition of a function shall be the
2413 first declaration of the function or, for an explicit specialization
2414 of a function template, the first declaration of that
2415 specialization. */
2418 {
2420 {
2421 auto_diagnostic_group d;
2426 }
2432 }
2433 }
2435 /* Deal with C++: must preserve virtual function table size. */
2437 {
2447 }
2449 /* Copy all the DECL_... slots specified in the new decl except for
2450 any that we copy here from the old type. */
2454 else
2458 {
2463 /* The new decl should not already have gathered any
2464 specializations. */
2467 /* Make sure the contracts are equivalent. */
2470 /* Remove contracts from old_result so they aren't appended to
2471 old_result by the merge function. */
2478 {
2481 {
2482 /* Per C++11 8.3.6/4, default arguments cannot be added in
2483 later declarations of a function template. */
2485 /* C++17 11.3.6/4: "If a friend declaration specifies a default
2486 argument expression, that declaration... shall be the only
2487 declaration of the function or function template in the
2488 translation unit." */
2489 check_no_redeclaration_friend_default_args
2496 }
2504 {
2507 else
2518 }
2519 else
2520 {
2528 }
2529 }
2531 /* Propagate purviewness and importingness as with
2532 set_instantiating_module. */
2534 {
2539 }
2541 /* If the new declaration is a definition, update the file and
2542 line information on the declaration, and also make
2543 the old declaration the same definition. */
2545 {
2551 {
2558 }
2559 }
2562 }
2565 {
2569 /* Automatically handles default parameters. */
2571 tree newtype;
2573 /* For typedefs use the old type, as the new type's DECL_NAME points
2574 at newdecl, which will be ggc_freed. */
2576 {
2577 /* But NEWTYPE might have an attribute, honor that. */
2582 {
2586 }
2588 /* And remove the new type from the variants list. */
2590 {
2593 {
2595 /* If remove is the main variant, no need to remove that
2596 from the list. One of the DECL_ORIGINAL_TYPE
2597 variants, e.g. created for aligned attribute, might still
2598 refer to the newdecl TYPE_DECL though, so remove that one
2599 in that case. */
2605 {
2609 }
2610 }
2611 else
2615 {
2618 }
2619 }
2620 }
2623 else
2627 {
2629 /* For already initialized vars, TREE_READONLY could have been
2630 cleared in cp_finish_decl, because the var needs runtime
2631 initialization or destruction. Make sure not to set
2632 TREE_READONLY on it again. */
2649 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
2652 {
2653 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
2656 }
2657 }
2659 /* An explicit specialization of a function template or of a member
2660 function of a class template can be declared transaction_safe
2661 independently of whether the corresponding template entity is declared
2662 transaction_safe. */
2675 /* Lay the type out, unless already done. */
2689 /* Merge deprecatedness. */
2693 /* Merge unavailability. */
2697 /* Preserve function specific target and optimization options */
2699 {
2712 }
2713 else
2714 {
2715 /* Merge the const type qualifier. */
2718 /* Merge the volatile type qualifier. */
2721 }
2723 /* Merge the initialization information. */
2726 {
2730 {
2733 }
2734 }
2737 {
2750 else
2751 {
2752 /* Merge the noreturn bit. */
2758 }
2759 /* Keep the old RTL. */
2761 }
2764 {
2765 /* Keep the old RTL. We cannot keep the old RTL if the old
2766 declaration was for an incomplete object and the new
2767 declaration is not since many attributes of the RTL will
2768 change. */
2770 }
2771 }
2772 /* If cannot merge, then use the new type and qualifiers,
2773 and don't preserve the old rtl. */
2774 else
2775 {
2776 /* Clean out any memory we had of the old declaration. */
2786 }
2788 /* Merge the storage class information. */
2800 {
2802 /* This can happen if olddecl was brought in from the
2803 enclosing namespace via a using-decl. The new decl is
2804 then not a block-scope extern at all. */
2806 else
2807 {
2812 {
2817 }
2818 }
2819 }
2823 {
2835 {
2839 }
2842 {
2847 /* If the OLDDECL is an instantiation and/or specialization,
2848 then the NEWDECL must be too. But, it may not yet be marked
2849 as such if the caller has created NEWDECL, but has not yet
2850 figured out that it is a redeclaration. */
2857 }
2859 /* Don't really know how much of the language-specific
2860 values we should copy from old to new. */
2864 {
2867 {
2871 /* Remember the presence of explicit specialization args. */
2874 }
2876 /* We don't want to copy template info from a non-templated friend
2877 (PR105761), but these shouldn't have DECL_TEMPLATE_INFO now. */
2881 }
2884 {
2885 /* Only functions have these fields. */
2890 /* DECL_THUNKS is only valid for virtual functions,
2891 otherwise it is a DECL_FRIEND_CONTEXT. */
2896 }
2898 {
2899 /* Only variables have this field. */
2902 }
2903 }
2906 {
2907 tree parm;
2909 /* Merge parameter attributes. */
2914 {
2918 }
2922 {
2923 /* If newdecl is not a specialization, then it is not a
2924 template-related function at all. And that means that we
2925 should have exited above, returning 0. */
2929 /* From [temp.expl.spec]:
2931 If a template, a member template or the member of a class
2932 template is explicitly specialized then that
2933 specialization shall be declared before the first use of
2934 that specialization that would cause an implicit
2935 instantiation to take place, in every translation unit in
2936 which such a use occurs. */
2938 olddecl);
2944 /* Don't propagate visibility from the template to the
2945 specialization here. We'll do that in determine_visibility if
2946 appropriate. */
2949 /* [temp.expl.spec/14] We don't inline explicit specialization
2950 just because the primary template says so. */
2960 }
2962 {
2963 /* Never inline re-defined extern inline functions.
2964 FIXME: this could be better handled by keeping both
2965 function as separate declarations. */
2967 }
2968 else
2969 {
2971 {
2975 }
2977 ;
2991 }
2993 /* Preserve abstractness on cloned [cd]tors. */
2996 /* Update newdecl's parms to point at olddecl. */
3002 {
3006 }
3008 {
3009 /* These are the final DECL_ARGUMENTS that will be used within the
3010 body; update any references to old DECL_ARGUMENTS in the
3011 contracts, if present. */
3015 /* These need to be copied so that the names are available.
3016 Note that if the types do match, we'll preserve inline
3017 info and other bits, but if not, we won't. */
3021 /* In some cases, duplicate_contracts will remove contracts from
3022 OLDDECL, to avoid duplications. Sometimes, the contracts end up
3023 shared. If we removed them, re-add them. */
3026 }
3027 /* If redeclaring a builtin function, it stays built in
3028 if newdecl is a gnu_inline definition, or if newdecl is just
3029 a declaration. */
3032 {
3034 /* If we're keeping the built-in definition, keep the rtl,
3035 regardless of declaration matches. */
3038 {
3041 {
3042 /* A compatible prototype of these builtin functions
3043 is seen, assume the runtime implements it with
3044 the expected semantics. */
3046 {
3053 }
3054 }
3057 }
3058 }
3060 /* If defining a function declared with other language
3061 linkage, use the previously declared language linkage. */
3064 {
3066 /* Don't clear out the arguments if we're just redeclaring a
3067 function. */
3069 {
3070 /* If we removed contracts from previous definition, re-attach
3071 them. Otherwise, rewrite the contracts so they match the
3072 parameters of the new declaration. */
3077 else
3078 {
3079 /* Temporarily undo the re-contexting of parameters so we can
3080 actually remap parameters. The inliner won't replace
3081 parameters if we don't do this. */
3086 /* Save new argument names for use in contracts parsing,
3087 unless we've already started parsing the body of olddecl
3088 (particular issues arise when newdecl is from a prior
3089 friend decl with no argument names, see
3090 modules/contracts-tpl-friend-1). */
3094 /* And reverse this operation again. */
3097 }
3100 }
3101 }
3102 }
3106 /* Now preserve various other info from the definition. */
3112 /* Warn about conflicting visibility specifications. */
3116 {
3117 auto_diagnostic_group d;
3119 "%qD: visibility attribute ignored because it "
3123 }
3124 /* Choose the declaration which specified visibility. */
3126 {
3129 }
3130 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
3131 so keep this behavior. */
3133 {
3136 }
3137 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
3139 {
3142 }
3155 /* Merge module entity mapping information. */
3159 {
3163 }
3165 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
3166 with that from NEWDECL below. */
3168 {
3172 }
3174 /* Merge the USED information. */
3181 {
3186 }
3193 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
3194 to olddecl and deleted. */
3197 {
3198 /* Set the flag for newdecl so that it gets copied to olddecl. */
3200 /* newdecl will be purged after copying to olddecl and is no longer
3201 a version. */
3203 }
3206 {
3220 /* Preserve symtab node mapping. */
3224 /* If newdecl is a template instantiation, it is possible that
3225 the following sequence of events has occurred:
3227 o A friend function was declared in a class template. The
3228 class template was instantiated.
3230 o The instantiation of the friend declaration was
3231 recorded on the instantiation list, and is newdecl.
3233 o Later, however, instantiate_class_template called pushdecl
3234 on the newdecl to perform name injection. But, pushdecl in
3235 turn called duplicate_decls when it discovered that another
3236 declaration of a global function with the same name already
3237 existed.
3239 o Here, in duplicate_decls, we decided to clobber newdecl.
3241 If we're going to do that, we'd better make sure that
3242 olddecl, and not newdecl, is on the list of
3243 instantiations so that if we try to do the instantiation
3244 again we won't get the clobbered declaration. */
3246 new_template_info,
3247 olddecl);
3248 }
3249 else
3250 {
3258 {
3266 {
3279 }
3287 }
3288 }
3291 {
3295 {
3296 /* Merge the section attribute.
3297 We want to issue an error if the sections conflict but that must be
3298 done later in decl_attributes since we are called before attributes
3299 are assigned. */
3304 {
3308 else
3312 }
3313 }
3317 {
3321 }
3322 }
3326 /* NEWDECL contains the merged attribute lists.
3327 Update OLDDECL to be the same. */
3330 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
3331 so that encode_section_info has a chance to look at the new decl
3332 flags and attributes. */
3339 /* The NEWDECL will no longer be needed. Because every out-of-class
3340 declaration of a member results in a call to duplicate_decls,
3341 freeing these nodes represents in a significant savings.
3343 Before releasing the node, be sore to remove function from symbol
3344 table that might have been inserted there to record comdat group.
3345 Be sure to however do not free DECL_STRUCT_FUNCTION because this
3346 structure is shared in between newdecl and oldecl. */
3350 {
3354 }
3357 {
3358 tree clone;
3360 {
3363 }
3364 }
3366 /* Remove the associated constraints for newdecl, if any, before
3367 reclaiming memory. */
3371 /* And similarly for any module tracking data. */
3378 }
3379 \f
3380 /* Return zero if the declaration NEWDECL is valid
3381 when the declaration OLDDECL (assumed to be for the same name)
3382 has already been seen.
3383 Otherwise return an error message format string with a %s
3384 where the identifier should go. */
3388 {
3390 {
3391 /* Because C++ can put things into name space for free,
3392 constructs like "typedef struct foo { ... } foo"
3393 would look like an erroneous redeclaration. */
3396 else
3398 }
3400 {
3401 /* If this is a pure function, its olddecl will actually be
3402 the original initialization to `0' (which we force to call
3403 abort()). Don't complain about redefinition in this case. */
3408 /* If both functions come from different namespaces, this is not
3409 a redeclaration - this is a conflict with a used function. */
3415 /* We'll complain about linkage mismatches in
3416 warn_extern_redeclared_static. */
3418 /* Defining the same name twice is no good. */
3421 {
3427 }
3430 {
3435 {
3439 else
3442 }
3443 }
3445 /* [class.compare.default]: A definition of a comparison operator as
3446 defaulted that appears in a class shall be the first declaration of
3447 that function. */
3453 check_abi_tag_redeclaration
3458 }
3460 {
3484 {
3489 {
3493 else
3496 }
3497 }
3499 /* Core issue #226 (C++11):
3501 If a friend function template declaration specifies a
3502 default template-argument, that declaration shall be a
3503 definition and shall be the only declaration of the
3504 function template in the translation unit. */
3515 }
3522 {
3523 /* Only variables can be thread-local, and all declarations must
3524 agree on this property. */
3528 else
3531 }
3533 {
3534 /* The objects have been declared at namespace scope. If either
3535 is a member of an anonymous union, then this is an invalid
3536 redeclaration. For example:
3538 int i;
3539 union { int i; };
3541 is invalid. */
3545 /* If at least one declaration is a reference, there is no
3546 conflict. For example:
3548 int i = 3;
3549 extern int i;
3551 is valid. */
3555 /* Static data member declared outside a class definition
3556 if the variable is defined within the class with constexpr
3557 specifier is declaration rather than definition (and
3558 deprecated). */
3564 {
3566 /* For now, only warn with explicit -Wdeprecated. */
3568 {
3569 auto_diagnostic_group d;
3571 "redundant redeclaration of %<constexpr%> "
3575 }
3577 }
3579 /* Reject two definitions. */
3581 }
3582 else
3583 {
3584 /* Objects declared with block scope: */
3585 /* Reject two definitions, and reject a definition
3586 together with an external reference. */
3590 }
3591 }
3592 \f
3594 /* Hash and equality functions for the named_label table. */
3596 hashval_t
3598 {
3600 }
3602 bool
3604 {
3606 }
3608 /* Look for a label named ID in the current function. If one cannot
3609 be found, create one. Return the named_label_entry, or NULL on
3610 failure. */
3614 {
3617 /* You can't use labels at global scope. */
3619 {
3622 }
3628 named_label_entry **slot
3633 {
3638 {
3639 auto_diagnostic_group d;
3643 }
3644 }
3646 /* We are making a new decl, create or reuse the named_label_entry */
3650 else
3651 {
3656 }
3658 /* Now create the LABEL_DECL. */
3664 {
3668 }
3673 }
3675 /* Wrapper for lookup_label_1. */
3677 tree
3679 {
3682 }
3684 /* Remember that we've seen &&ID. */
3686 void
3688 {
3691 }
3693 tree
3695 {
3698 }
3700 /* Returns true if it is ill-formed to jump past the declaration of DECL. */
3702 static bool
3704 {
3705 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
3706 with automatic storage duration is not in scope to a point where it is
3707 in scope is ill-formed unless the variable has scalar type, class type
3708 with a trivial default constructor and a trivial destructor, a
3709 cv-qualified version of one of these types, or an array of one of the
3710 preceding types and is declared without an initializer (8.5). */
3718 }
3720 /* A subroutine of check_previous_goto_1 and check_goto to identify a branch
3721 to the user. */
3723 static bool
3726 {
3729 bool complained
3734 {
3737 else
3739 }
3741 }
3743 /* Check that a single previously seen jump to a newly defined label
3744 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
3745 the jump context; NAMES are the names in scope in LEVEL at the jump
3746 context; LOCUS is the source position of the jump or 0. COMPUTED
3747 is a vec of decls if the jump is a computed goto. Returns
3748 true if all is well. */
3750 static bool
3754 {
3755 auto_diagnostic_group d;
3763 {
3765 computed);
3770 }
3773 {
3779 {
3785 {
3787 computed);
3789 }
3793 }
3801 {
3834 {
3838 }
3840 {
3844 }
3849 }
3852 {
3855 computed);
3859 }
3860 }
3863 {
3866 computed);
3870 {
3875 }
3876 }
3879 }
3881 static void
3883 {
3887 }
3889 static bool
3891 {
3894 }
3896 /* Check that a new jump to a label ENT is OK. COMPUTED is true
3897 if this is a possible target of a computed goto. */
3899 void
3901 {
3902 auto_diagnostic_group d;
3905 /* If the label hasn't been defined yet, defer checking. */
3907 {
3908 /* Don't bother creating another use if the last goto had the
3909 same data, and will therefore create the same set of errors. */
3914 named_label_use_entry *new_use
3925 }
3929 tree bad;
3936 {
3945 }
3948 {
3952 {
3953 /* Can't skip init of __exception_info. */
3955 {
3959 }
3963 }
3967 }
3970 {
3983 }
3986 {
3989 }
3992 {
3996 {
3998 {
4002 computed);
4004 }
4008 }
4009 }
4011 /* Warn if a computed goto might involve a local variable going out of scope
4012 without being cleaned up. */
4014 {
4018 {
4020 {
4022 {
4023 complained
4027 }
4031 }
4034 {
4036 {
4038 {
4039 complained
4043 }
4047 }
4048 }
4051 }
4052 }
4053 }
4055 /* Check that a new jump to a label DECL is OK. Called by
4056 finish_goto_stmt. */
4058 void
4060 {
4064 {
4065 /* We don't know where a computed goto is jumping,
4066 so check all addressable labels. */
4070 {
4074 }
4075 }
4076 else
4077 {
4079 named_label_entry **slot
4083 }
4084 }
4086 /* Check that a return is ok wrt OpenMP structured blocks.
4087 Called by finish_return_stmt. Returns true if all is well. */
4089 bool
4091 {
4094 {
4097 }
4101 }
4103 /* Define a label, specifying the location in the source file.
4104 Return the LABEL_DECL node for the label. */
4106 tree
4108 {
4111 /* After labels, make any new cleanups in the function go into their
4112 own new (temporary) binding contour. */
4122 {
4125 }
4126 else
4127 {
4128 /* Mark label as having been defined. */
4130 /* Say where in the source. */
4139 }
4142 }
4144 struct cp_switch
4145 {
4148 /* The SWITCH_STMT being built. */
4149 tree switch_stmt;
4150 /* A splay-tree mapping the low element of a case range to the high
4151 element, or NULL_TREE if there is no high element. Used to
4152 determine whether or not a new case label duplicates an old case
4153 label. We need a tree, rather than simply a hash table, because
4154 of the GNU case range extension. */
4155 splay_tree cases;
4156 /* Remember whether a default: case label has been seen. */
4158 /* Remember whether a BREAK_STMT has been seen in this SWITCH_STMT. */
4160 /* Set if inside of {FOR,DO,WHILE}_BODY nested inside of a switch,
4161 where BREAK_STMT doesn't belong to the SWITCH_STMT. */
4163 };
4165 /* A stack of the currently active switch statements. The innermost
4166 switch statement is on the top of the stack. There is no need to
4167 mark the stack for garbage collection because it is only active
4168 during the processing of the body of a function, and we never
4169 collect at that point. */
4173 /* Called right after a switch-statement condition is parsed.
4174 SWITCH_STMT is the switch statement being parsed. */
4176 void
4178 {
4188 }
4190 void
4192 {
4195 /* Emit warnings as needed. */
4198 const bool bool_cond_p
4204 bool_cond_p);
4206 /* For the benefit of block_may_fallthru remember if the switch body
4207 case labels cover all possible values and if there are break; stmts. */
4209 || (!processing_template_decl
4215 /* Now that we're done with the switch warnings, set the switch type
4216 to the type of the condition if the index type was of scoped enum type.
4217 (Such types don't participate in the integer promotions.) We do this
4218 because of bit-fields whose declared type is a scoped enum type:
4219 gimplification will use the lowered index type, but convert the
4220 case values to SWITCH_STMT_TYPE, which would have been the declared type
4221 and verify_gimple_switch doesn't accept that. */
4228 }
4230 /* Note that a BREAK_STMT is about to be added. If it is inside of
4231 a SWITCH_STMT and not inside of a loop body inside of it, note
4232 in switch_stack we've seen a BREAK_STMT. */
4234 void
4236 {
4239 }
4241 /* Note the start of processing of an iteration statement's body.
4242 The note_break_stmt function will do nothing while processing it.
4243 Return a flag that should be passed to note_iteration_stmt_body_end. */
4245 bool
4247 {
4253 }
4255 /* Note the end of processing of an iteration statement's body. */
4257 void
4259 {
4262 }
4264 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
4265 condition. Note that if TYPE and VALUE are already integral we don't
4266 really do the conversion because the language-independent
4267 warning/optimization code will work better that way. */
4269 static tree
4271 {
4281 /* The constant-expression VALUE shall be a converted constant expression
4282 of the adjusted type of the switch condition, which doesn't allow
4283 narrowing conversions. */
4290 else
4291 /* The already integral case. */
4295 }
4297 /* Note that we've seen a definition of a case label, and complain if this
4298 is a bad place for one. */
4300 tree
4302 {
4305 tree type;
4311 {
4312 tree label;
4314 /* For templates, just add the case label; we'll do semantic
4315 analysis at instantiation-time. */
4318 }
4320 /* Find the condition on which this switch statement depends. */
4337 /* After labels, make any new cleanups in the function go into their
4338 own new (temporary) binding contour. */
4345 }
4346 \f
4348 tree scope;
4349 tree name;
4350 tree template_id;
4353 };
4356 {
4359 /* Hash a TYPENAME_TYPE. */
4361 static hashval_t
4363 {
4368 }
4370 static hashval_t
4372 {
4374 }
4376 static hashval_t
4378 {
4380 }
4382 /* Compare two TYPENAME_TYPEs. */
4384 static bool
4386 {
4392 }
4393 };
4395 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
4396 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
4398 Returns the new TYPENAME_TYPE. */
4402 tree
4405 {
4406 typename_info ti;
4420 /* See if we already have this type. */
4425 else
4426 {
4427 /* Build the TYPENAME_TYPE. */
4434 /* Build the corresponding TYPE_DECL. */
4441 /* Store it in the hash table. */
4444 /* TYPENAME_TYPEs must always be compared structurally, because
4445 they may or may not resolve down to another type depending on
4446 the currently open classes. */
4448 }
4451 }
4453 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
4454 provided to name the type. Returns an appropriate type, unless an
4455 error occurs, in which case error_mark_node is returned. If we
4456 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
4457 return that, rather than the _TYPE it corresponds to, in other
4458 cases we look through the type decl. If TF_ERROR is set, complain
4459 about errors, otherwise be quiet. */
4461 tree
4463 tsubst_flags_t complain)
4464 {
4465 tree fullname;
4466 tree t;
4475 {
4480 else
4481 /* Create a TEMPLATE_ID_EXPR for the type. */
4485 }
4492 {
4497 {
4501 }
4502 }
4504 {
4508 }
4510 {
4514 }
4521 {
4525 }
4527 /* When the CONTEXT is a dependent type, NAME could refer to a
4528 dependent base class of CONTEXT. But look inside it anyway
4529 if CONTEXT is a currently open scope, in case it refers to a
4530 member of the current instantiation or a non-dependent base;
4531 lookup will stop when we hit a dependent base. */
4533 {
4534 /* We generally don't ignore non-types during TYPENAME_TYPE lookup
4535 (as per [temp.res.general]/3), unless
4536 - the tag corresponds to a class-key or 'enum' so
4537 [basic.lookup.elab] applies, or
4538 - the tag corresponds to scope_type or tf_qualifying_scope is
4539 set so [basic.lookup.qual]/1 applies.
4540 TODO: If we'd set/track the scope_type tag thoroughly on all
4541 TYPENAME_TYPEs that are followed by :: then we wouldn't need the
4542 tf_qualifying_scope flag. */
4546 }
4547 else
4556 {
4558 {
4561 else
4564 }
4566 }
4568 /* Pull out the template from an injected-class-name (or multiple). */
4573 {
4575 {
4576 auto_diagnostic_group d;
4579 }
4581 }
4584 {
4589 }
4591 {
4594 /* The caller permits this typename-specifier to name a template
4596 else
4597 {
4602 }
4603 }
4613 {
4620 }
4628 }
4630 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
4631 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
4632 in which case error_mark_node is returned.
4634 If PARM_LIST is non-NULL, also make sure that the template parameter
4635 list of TEMPLATE_DECL matches.
4637 If COMPLAIN zero, don't complain about any errors that occur. */
4639 tree
4641 tsubst_flags_t complain)
4642 {
4651 {
4661 {
4665 }
4669 {
4671 {
4672 auto_diagnostic_group d;
4676 }
4678 }
4681 complain))
4685 }
4688 }
4690 /* Build an UNBOUND_CLASS_TEMPLATE. */
4692 tree
4694 {
4695 /* Build the UNBOUND_CLASS_TEMPLATE. */
4701 /* Build the corresponding TEMPLATE_DECL. */
4710 }
4712 \f
4714 /* Push the declarations of builtin types into the global namespace.
4715 RID_INDEX is the index of the builtin type in the array
4716 RID_POINTERS. NAME is the name used when looking up the builtin
4717 type. TYPE is the _TYPE node for the builtin type.
4719 The calls to set_global_binding below should be
4720 eliminated. Built-in types should not be looked up name; their
4721 names are keywords that the parser can recognize. However, there
4722 is code in c-common.cc that uses identifier_global_value to look up
4723 built-in types by name. */
4725 void
4728 tree type)
4729 {
4733 {
4739 }
4744 {
4750 }
4753 {
4757 }
4758 }
4760 /* Push a type into the namespace so that the back ends ignore it. */
4762 static void
4764 {
4767 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
4774 }
4776 /* Create all the predefined identifiers. */
4778 static void
4780 {
4781 struct predefined_identifier
4782 {
4786 };
4788 /* A table of identifiers to create at startup. */
4792 /* Some of these names have a trailing space so that it is
4793 impossible for them to conflict with names written by users. */
4810 /* The demangler expects anonymous namespaces to be called
4811 something starting with '_GLOBAL__N_'. It no longer needs
4812 to be unique to the TU. */
4842 };
4846 {
4848 /* Some of these identifiers already have a special kind. */
4851 }
4852 }
4854 /* Create the predefined scalar types of C,
4855 and some nodes representing standard constants (0, 1, (void *)0).
4856 Initialize the global binding level.
4857 Make definitions for built-in primitive functions. */
4859 void
4861 {
4862 tree void_ftype;
4863 tree void_ftype_ptr;
4865 /* Create all the identifiers we need. */
4868 /* Create the global variables. */
4873 /* Enter the global namespace. */
4876 void_type_node);
4881 /* Remember whether we want the empty class passing ABI change warning
4882 in this TU. */
4885 debug_hooks->register_main_translation_unit
4893 /* Initially, C. */
4896 /* Create the `std' namespace. */
4906 tree decl
4912 /* The concrete return type of __builtin_source_location is
4913 const std::source_location::__impl*, but we can't form the type
4914 at this point. So we initially declare it with an auto return
4915 type which we then "deduce" from require_deduced_type upon first use. */
4923 NULL_TREE);
4924 decl
4926 bool_vaftype,
4927 CP_BUILT_IN_IS_CORRESPONDING_MEMBER,
4931 decl
4933 bool_vaftype,
4934 CP_BUILT_IN_IS_POINTER_INTERCONVERTIBLE_WITH_CLASS,
4940 /* Guess at the initial static decls size. */
4943 /* ... and keyed classes. */
4955 NULL_TREE);
4957 #if 0
4959 #endif
4968 void_ftype_ptr
4971 /* Create the conversion operator marker. This operator's DECL_NAME
4972 is in the identifier table, so we can use identifier equality to
4973 find it. */
4975 void_ftype);
4977 /* C++ extensions */
4982 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
4985 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
4986 result. */
4993 /* Used when parsing to distinguish parameter-lists () and (void). */
4996 {
4997 /* Make sure we get a unique function type, so we can give
4998 its pointer type a name. (This wins for gdb.) */
5005 }
5008 vtbl_type_node
5024 /* Now, C++. */
5029 {
5031 aligned_new_threshold);
5033 }
5039 {
5042 tree ptr_ftype_sizetype;
5043 tree new_eh_spec;
5045 ptr_ftype_sizetype
5048 {
5049 tree bad_alloc_id;
5050 tree bad_alloc_type_node;
5051 tree bad_alloc_decl;
5057 bad_alloc_decl
5062 new_eh_spec
5064 }
5065 else
5068 /* Ensure attribs.cc is initialized. */
5072 NULL_TREE);
5075 extvisattr);
5095 {
5096 /* Also push the sized deallocation variants:
5097 void operator delete(void*, std::size_t) throw();
5098 void operator delete[](void*, std::size_t) throw(); */
5099 tree void_ftype_ptr_size
5103 extvisattr);
5111 }
5114 {
5121 /* operator new (size_t, align_val_t); */
5135 /* operator delete (void *, align_val_t); */
5148 {
5149 /* operator delete (void *, size_t, align_val_t); */
5152 NULL_TREE);
5161 }
5162 }
5164 /* C++-specific nullptr initialization. */
5168 }
5173 abort_fndecl
5177 /* If no definition is available, resolve references to NULL. */
5180 /* Perform other language dependent initializations. */
5197 /* Show we use EH for cleanups. */
5201 /* Check that the hardware interference sizes are at least
5202 alignof(max_align_t), as required by the standard. */
5205 {
5211 "%<--param destructive-interference-size=%d%> "
5214 }
5219 /* else leave it unset. */
5222 {
5229 "%<--param constructive-interference-size=%d%> "
5232 }
5237 }
5239 /* Enter an abi node in global-module context. returns a cookie to
5240 give to pop_abi_namespace. */
5242 unsigned
5244 {
5250 }
5252 /* Pop an abi namespace, FLAGS is the cookie push_abi_namespace gave
5253 you. */
5255 void
5257 {
5261 }
5263 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
5264 the decl, LOC is the location to give the decl, NAME is the
5265 initialization string and TYPE_DEP indicates whether NAME depended
5266 on the type of the function. We make use of that to detect
5267 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
5268 at the point of first use, so we mustn't push the decl now. */
5270 static tree
5272 {
5277 {
5284 {
5285 /* __FUNCTION__ */
5288 }
5289 else
5290 {
5291 /* __PRETTY_FUNCTION__ */
5294 }
5301 }
5308 else
5322 /* For decl_constant_var_p. */
5326 {
5331 }
5332 else
5333 {
5336 }
5339 }
5341 /* Install DECL as a builtin function at current global scope. Return
5342 the new decl (if we found an existing version). Also installs it
5343 into ::std, if it's not '_*'. */
5345 tree
5347 {
5352 /* Runtime library routines are, by definition, available in an
5353 external shared object. */
5361 /* In the user's namespace, it must be declared before use. */
5367 /* Treat __*_chk fortification functions as anticipated as well,
5368 unless they are __builtin_*_chk. */
5371 /* All builtins that don't begin with an '_' should additionally
5372 go in the 'std' namespace. */
5374 {
5381 }
5387 }
5389 /* Like cxx_builtin_function, but guarantee the function is added to the global
5390 scope. This is to allow function specific options to add new machine
5391 dependent builtins when the target ISA changes via attribute((target(...)))
5392 which saves space on program startup if the program does not use non-generic
5393 ISAs. */
5395 tree
5397 {
5403 }
5405 /* Implement LANG_HOOKS_SIMULATE_BUILTIN_FUNCTION_DECL. */
5407 tree
5409 {
5416 }
5418 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
5419 function. Not called directly. */
5421 static tree
5424 {
5432 /* Runtime library routines are, by definition, available in an
5433 external shared object. */
5438 }
5440 /* Returns the _DECL for a library function with C++ linkage. */
5442 static tree
5445 {
5450 }
5452 /* Like build_library_fn, but takes a C string instead of an
5453 IDENTIFIER_NODE. */
5455 tree
5457 {
5459 }
5461 /* Like build_cp_library_fn, but takes a C string instead of an
5462 IDENTIFIER_NODE. */
5464 tree
5466 {
5468 ecf_flags);
5469 }
5471 /* Like build_library_fn, but also pushes the function so that we will
5472 be able to find it via get_global_binding. Also, the function
5473 may throw exceptions listed in RAISES. */
5475 tree
5477 {
5483 }
5485 /* Like build_cp_library_fn, but also pushes the function so that it
5486 will be found by normal lookup. */
5488 static tree
5491 {
5498 }
5500 /* Like push_library_fn, but also note that this function throws
5501 and does not return. Used for __throw_foo and the like. */
5503 tree
5505 {
5509 }
5510 \f
5511 /* When we call finish_struct for an anonymous union, we create
5512 default copy constructors and such. But, an anonymous union
5513 shouldn't have such things; this function undoes the damage to the
5514 anonymous union type T.
5516 (The reason that we create the synthesized methods is that we don't
5517 distinguish `union { int i; }' from `typedef union { int i; } U'.
5518 The first is an anonymous union; the second is just an ordinary
5519 union type.) */
5521 void
5523 {
5524 /* Wipe out memory of synthesized methods. */
5532 /* Splice the implicitly generated functions out of TYPE_FIELDS and diagnose
5533 invalid members. */
5535 {
5538 else
5548 {
5549 /* We already complained about static data members in
5550 finish_static_data_member_decl. */
5552 {
5553 auto_diagnostic_group d;
5557 "only have public non-static data members"
5560 {
5563 {
5566 "this flexibility is deprecated and will be "
5568 }
5569 }
5570 }
5571 }
5572 }
5574 /* Splice all functions out of CLASSTYPE_MEMBER_VEC. */
5582 /* Wipe RTTI info. */
5585 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
5586 assignment operators (because they cannot have these methods themselves).
5587 For anonymous unions this is already checked because they are not allowed
5588 in any union, otherwise we have to check it. */
5590 {
5594 {
5596 /* Avoid ICE after error on anon-struct9.C. */
5598 }
5602 {
5605 {
5615 }
5616 }
5617 }
5618 }
5620 /* Warn for an attribute located at LOCATION that appertains to the
5621 class type CLASS_TYPE that has not been properly placed after its
5622 class-key, in it class-specifier. */
5624 void
5626 tree class_type)
5627 {
5630 auto_diagnostic_group d;
5632 "attribute ignored in declaration "
5637 }
5639 /* Returns the cv-qualifiers that apply to the type specified
5640 by the DECLSPECS. */
5642 static int
5644 {
5655 }
5657 /* Make sure that a declaration with no declarator is well-formed, i.e.
5658 just declares a tagged type or anonymous union.
5660 Returns the type declared; or NULL_TREE if none. */
5662 tree
5665 {
5668 /* If a class, struct, or enum type is declared by the DECLSPECS
5669 (i.e, if a class-specifier, enum-specifier, or non-typename
5670 elaborated-type-specifier appears in the DECLSPECS),
5671 DECLARED_TYPE is set to the corresponding type. */
5679 {
5685 }
5697 {
5699 "%<auto%> can only be specified for variables "
5702 }
5709 /* Check for an anonymous union. */
5712 {
5713 /* 7/3 In a simple-declaration, the optional init-declarator-list
5714 can be omitted only when declaring a class (clause 9) or
5715 enumeration (7.2), that is, when the decl-specifier-seq contains
5716 either a class-specifier, an elaborated-type-specifier with
5717 a class-key (9.1), or an enum-specifier. In these cases and
5718 whenever a class-specifier or enum-specifier is present in the
5719 decl-specifier-seq, the identifiers in these specifiers are among
5720 the names being declared by the declaration (as class-name,
5721 enum-names, or enumerators, depending on the syntax). In such
5722 cases, and except for the declaration of an unnamed bit-field (9.6),
5723 the decl-specifier-seq shall introduce one or more names into the
5724 program, or shall redeclare a name introduced by a previous
5725 declaration. [Example:
5726 enum { }; // ill-formed
5727 typedef class { }; // ill-formed
5728 --end example] */
5730 {
5734 }
5741 }
5743 else
5744 {
5752 && (!current_class_type
5761 "a storage class can only be specified for objects "
5765 "%<const%> can only be specified for objects and "
5769 "%<volatile%> can only be specified for objects and "
5773 "%<__restrict%> can only be specified for objects and "
5777 "%<__thread%> can only be specified for objects "
5791 }
5794 {
5795 location_t loc;
5798 /* For a non-template class, use the name location. */
5800 else
5801 /* For a template class (an explicit instantiation), use the
5802 current location. */
5806 /* [dcl.attr.grammar]/4:
5808 No attribute-specifier-seq shall appertain to an explicit
5809 instantiation. */
5810 {
5811 auto_diagnostic_group d;
5814 declared_type))
5816 "no attribute can be applied to "
5818 }
5819 else
5821 }
5823 /* Diagnose invalid application of contracts, if any. */
5826 else
5830 }
5832 /* Called when a declaration is seen that contains no names to declare.
5833 If its type is a reference to a structure, union or enum inherited
5834 from a containing scope, shadow that tag name for the current scope
5835 with a forward reference.
5836 If its type defines a new named structure or union
5837 or defines an enum, it is valid but we need not do anything here.
5838 Otherwise, it is an error.
5840 C++: may have to grok the declspecs to learn about static,
5841 complain for anonymous unions.
5843 Returns the TYPE declared -- or NULL_TREE if none. */
5845 tree
5847 {
5858 /* This is where the variables in an anonymous union are
5859 declared. An anonymous union declaration looks like:
5860 union { ... } ;
5861 because there is no declarator after the union, the parser
5862 sends that declaration here. */
5864 {
5868 {
5872 }
5873 }
5876 }
5877 \f
5878 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
5880 tree
5884 {
5885 tree attrs;
5886 tree type;
5887 enum decl_context context
5893 {
5898 /* A template type parameter or other dependent type. */
5901 else
5903 }
5905 }
5907 /* Process a DECLARATOR for a function-scope or namespace-scope
5908 variable or function declaration.
5909 (Function definitions go through start_function; class member
5910 declarations appearing in the body of the class go through
5911 grokfield.) The DECL corresponding to the DECLARATOR is returned.
5912 If an error occurs, the error_mark_node is returned instead.
5914 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
5915 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
5916 for an explicitly defaulted function, or SD_DELETED for an explicitly
5917 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
5918 implicitly initialized via a default constructor. It can also be
5919 SD_DECOMPOSITION which behaves much like SD_INITIALIZED, but we also
5920 mark the new decl as DECL_DECOMPOSITION_P.
5922 ATTRIBUTES and PREFIX_ATTRIBUTES are GNU attributes associated with this
5923 declaration.
5925 The scope represented by the context of the returned DECL is pushed
5926 (if it is not the global namespace) and is assigned to
5927 *PUSHED_SCOPE_P. The caller is then responsible for calling
5928 pop_scope on *PUSHED_SCOPE_P if it is set. */
5930 tree
5934 tree attributes,
5935 tree prefix_attributes,
5937 {
5938 tree decl;
5939 tree context;
5943 tree initial;
5963 {
5968 }
5970 /* Save the DECL_INITIAL value in case it gets clobbered to assist
5971 with attribute validation. */
5975 {
5979 decl);
5983 /* Tell 'cplus_decl_attributes' this is an initialized decl,
5984 even though we might not yet have the initializer expression. */
5987 }
5993 /* If this is a typedef that names the class for linkage purposes
5994 (7.1.3p8), apply any attributes directly to the type. */
5999 else
6002 /* Set attributes here so if duplicate decl, will have proper attributes. */
6005 /* Restore the original DECL_INITIAL that we may have clobbered earlier to
6006 assist with attribute validation. */
6009 /* Dllimported symbols cannot be defined. Static data members (which
6010 can be initialized in-class and dllimported) go through grokfield,
6011 not here, so we don't need to exclude those decls when checking for
6012 a definition. */
6014 {
6018 }
6020 /* If #pragma weak was used, mark the decl weak now. */
6032 {
6036 {
6046 {
6047 auto_diagnostic_group d;
6053 }
6054 else
6055 {
6060 {
6067 }
6068 /* Static data member are tricky; an in-class initialization
6069 still doesn't provide a definition, so the in-class
6070 declaration will have DECL_EXTERNAL set, but will have an
6071 initialization. Thus, duplicate_decls won't warn
6072 about this situation, and so we check here. */
6080 }
6081 }
6082 else
6083 {
6085 this_tmpl
6086 ? current_template_parms
6091 }
6093 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
6095 /* Do not mark DECL as an explicit specialization if it was not
6096 already marked as an instantiation; a declaration should
6097 never be marked as a specialization unless we know what
6098 template is being specialized. */
6100 {
6105 else
6108 /* [temp.expl.spec] An explicit specialization of a static data
6109 member of a template is a definition if the declaration
6110 includes an initializer; otherwise, it is a declaration.
6112 We check for processing_specialization so this only applies
6113 to the new specialization syntax. */
6116 }
6119 /* Aliases are definitions. */
6121 {
6125 decl);
6129 decl);
6130 }
6131 }
6133 /* Create a DECL_LANG_SPECIFIC so that DECL_DECOMPOSITION_P works. */
6141 {
6142 /* A function-scope decl of some namespace-scope decl. */
6146 "block-scope extern declaration %q#D must not be"
6148 }
6150 /* Enter this declaration into the symbol table. Don't push the plain
6151 VAR_DECL for a variable template. */
6165 /* But not templated variables. */
6167 {
6168 /* This is a const variable with implicit 'static'. Set
6169 DECL_THIS_STATIC so we can tell it from variables that are
6170 !TREE_PUBLIC because of the anonymous namespace. */
6173 }
6178 {
6182 "%qD defined %<thread_local%> in %qs function only "
6188 "%qD defined %<static%> in %qs function only available "
6192 else
6196 }
6202 }
6204 /* Process the declaration of a variable DECL. INITIALIZED is true
6205 iff DECL is explicitly initialized. (INITIALIZED is false if the
6206 variable is initialized via an implicitly-called constructor.)
6207 This function must be called for ordinary variables (including, for
6208 example, implicit instantiations of templates), but must not be
6209 called for template declarations. */
6211 void
6213 {
6223 bool aggregate_definition_p
6226 /* If an explicit initializer is present, or if this is a definition
6227 of an aggregate, then we need a complete type at this point.
6228 (Scalars are always complete types, so there is nothing to
6229 check.) This code just sets COMPLETE_P; errors (if necessary)
6230 are issued below. */
6232 && !complete_p
6234 {
6236 /* We will not yet have set TREE_READONLY on DECL if the type
6237 was "const", but incomplete, before this point. But, now, we
6238 have a complete type, so we can try again. */
6240 }
6243 /* Is it valid for this decl to have an initializer at all? */
6244 {
6245 /* Don't allow initializations for incomplete types except for
6246 arrays which might be completed by the initialization. */
6252 {
6253 auto_diagnostic_group d;
6259 }
6261 {
6264 /* else we already gave an error in start_decl. */
6265 }
6266 }
6268 {
6271 else
6272 {
6273 auto_diagnostic_group d;
6275 decl);
6279 /* Change the type so that assemble_variable will give
6280 DECL an rtl we can live with: (mem (const_int 0)). */
6282 }
6283 }
6285 /* Create a new scope to hold this declaration if necessary.
6286 Whether or not a new scope is necessary cannot be determined
6287 until after the type has been completed; if the type is a
6288 specialization of a class template it is not until after
6289 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
6290 will be set correctly. */
6292 }
6294 /* Given a parenthesized list of values INIT, create a CONSTRUCTOR to handle
6295 C++20 P0960. TYPE is the type of the object we're initializing. */
6297 tree
6299 {
6303 {
6304 /* If the list has a single element and it's a string literal,
6305 then it's the initializer for the array as a whole. */
6311 /* Handle non-standard extensions like compound literals. This also
6312 prevents triggering aggregate parenthesized-initialization in
6313 compiler-generated code for =default. */
6317 }
6323 }
6325 /* Handle initialization of references. DECL, TYPE, and INIT have the
6326 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
6327 but will be set to a new CLEANUP_STMT if a temporary is created
6328 that must be destroyed subsequently.
6330 Returns an initializer expression to use to initialize DECL, or
6331 NULL if the initialization can be performed statically.
6333 Quotes on semantics can be found in ARM 8.4.3. */
6335 static tree
6337 {
6339 {
6346 }
6350 {
6351 /* This handles (C++20 only) code like
6353 const A& r(1, 2, 3);
6355 where we treat the parenthesized list as a CONSTRUCTOR. */
6360 {
6361 /* We don't know yet if we should treat const A& r(1) as
6362 const A& r{1}. */
6364 {
6367 tf_warning_or_error);
6368 }
6369 /* If the list had more than one element, the code is ill-formed
6370 pre-C++20, so we can build a constructor right away. */
6371 else
6373 }
6374 else
6376 tf_warning_or_error);
6377 }
6381 /* Note: default conversion is only called in very special cases. */
6384 /* check_initializer handles this for non-reference variables, but for
6385 references we need to do it here or the initializer will get the
6386 incomplete array type and confuse later calls to
6387 cp_complete_array_type. */
6392 {
6396 }
6398 /* Convert INIT to the reference type TYPE. This may involve the
6399 creation of a temporary, whose lifetime must be the same as that
6400 of the reference. If so, a DECL_EXPR for the temporary will be
6401 added just after the DECL_EXPR for DECL. That's why we don't set
6402 DECL_INITIAL for local references (instead assigning to them
6403 explicitly); we need to allow the temporary to be initialized
6404 first. */
6406 tf_warning_or_error);
6407 }
6409 /* Designated initializers in arrays are not supported in GNU C++.
6410 The parser cannot detect this error since it does not know whether
6411 a given brace-enclosed initializer is for a class type or for an
6412 array. This function checks that CE does not use a designated
6413 initializer. If it does, an error is issued. Returns true if CE
6414 is valid, i.e., does not have a designated initializer. */
6416 bool
6419 {
6420 /* Designated initializers for array elements are not supported. */
6422 {
6423 /* The parser only allows identifiers as designated
6424 initializers. */
6426 {
6430 }
6432 {
6436 }
6444 {
6445 /* A C99 designator is OK if it matches the current index. */
6447 {
6450 }
6451 else
6453 }
6454 else
6460 }
6463 }
6465 /* When parsing `int a[] = {1, 2};' we don't know the size of the
6466 array until we finish parsing the initializer. If that's the
6467 situation we're in, update DECL accordingly. */
6469 static void
6471 {
6477 {
6478 /* do_default is really a C-ism to deal with tentative definitions.
6479 But let's leave it here to ease the eventual merge. */
6484 /* Check that there are no designated initializers in INIT, as
6485 those are not supported in GNU C++, and as the middle-end
6486 will crash if presented with a non-numeric designated
6487 initializer. */
6489 {
6492 HOST_WIDE_INT i;
6494 {
6499 /* If an un-designated initializer is type-dependent, we can't
6500 check brace elision yet. */
6504 }
6505 }
6509 else
6510 {
6512 do_default);
6514 {
6518 }
6520 {
6522 {
6525 }
6526 /* If a `static' var's size isn't known, make it extern as
6527 well as static, so it does not get allocated. If it's not
6528 `static', then don't mark it extern; finish_incomplete_decl
6529 will give it a default size and it will get allocated. */
6532 }
6534 {
6537 }
6538 }
6543 }
6544 }
6546 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
6547 any appropriate error messages regarding the layout. */
6549 static void
6551 {
6552 tree type;
6558 /* If we haven't already laid out this declaration, do so now.
6559 Note that we must not call complete type for an external object
6560 because it's type might involve templates that we are not
6561 supposed to instantiate yet. (And it's perfectly valid to say
6562 `extern X x' for some incomplete type `X'.) */
6571 {
6572 /* An automatic variable with an incomplete type: that is an error.
6573 Don't talk about array types here, since we took care of that
6574 message in grokdeclarator. */
6578 }
6579 #if 0
6580 /* Keep this code around in case we later want to control debug info
6581 based on whether a type is "used". (jason 1999-11-11) */
6584 /* Let debugger know it should output info for this type. */
6589 #endif
6594 {
6598 else
6599 {
6604 }
6605 }
6607 /* If the final element initializes a flexible array field, adjust
6608 the size of the DECL with the initializer based on whether the
6609 DECL is a union or a structure. */
6619 {
6622 {
6629 {
6630 /* For a structure, add the size of the initializer to the DECL's
6631 size. */
6633 {
6640 }
6641 /* For a union, the DECL's size is the maximum of the current size
6642 and the size of the initializer. */
6643 else
6644 {
6651 }
6652 }
6653 }
6654 }
6655 }
6657 /* If a local static variable is declared in an inline function, or if
6658 we have a weak definition, we must endeavor to create only one
6659 instance of the variable at link-time. */
6661 void
6663 {
6664 /* Don't mess with __FUNCTION__ and similar. But do handle structured
6665 bindings. */
6669 /* Static data in a function with comdat linkage also has comdat
6670 linkage. */
6675 {
6677 {
6678 /* With weak symbols, we simply make the variable COMDAT;
6679 that will cause copies in multiple translations units to
6680 be merged. */
6682 }
6683 else
6684 {
6687 {
6688 /* Without weak symbols, we can use COMMON to merge
6689 uninitialized variables. */
6692 }
6693 else
6694 {
6695 /* While for initialized variables, we must use internal
6696 linkage -- which means that multiple copies will not
6697 be merged. */
6704 "%q#D are wrong (you%'ll wind up with "
6706 else
6708 "static data %q#D are wrong (you%'ll wind "
6710 auto_diagnostic_group d;
6715 }
6716 }
6717 }
6718 }
6720 /* Issue an error message if DECL is an uninitialized const variable.
6721 CONSTEXPR_CONTEXT_P is true when the function is called in a constexpr
6722 context from potential_constant_expression. Returns true if all is well,
6723 false otherwise. */
6725 bool
6727 tsubst_flags_t complain)
6728 {
6731 /* ``Unless explicitly declared extern, a const object does not have
6732 external linkage and must be initialized. ($8.4; $12.1)'' ARM
6733 7.1.6 */
6737 /* C++20 permits trivial default initialization in constexpr
6738 context (P1331R2). */
6740 && (constexpr_context_p
6743 {
6748 auto_diagnostic_group d;
6752 {
6754 {
6758 }
6759 else
6760 {
6764 "uninitialized variable %qD in %<constexpr%> "
6766 else
6769 }
6770 }
6774 decl);
6777 {
6778 tree defaulted_ctor;
6785 "constructor is not user-provided because it is "
6788 "and the implicitly-defined constructor does not "
6790 }
6793 }
6796 }
6797 \f
6798 /* Structure holding the current initializer being processed by reshape_init.
6799 CUR is a pointer to the current element being processed, END is a pointer
6800 after the last element present in the initializer. */
6801 struct reshape_iter
6802 {
6805 };
6809 /* FIELD is an element of TYPE_FIELDS or NULL. In the former case, the value
6810 returned is the next FIELD_DECL (possibly FIELD itself) that can be
6811 initialized as if for an aggregate class. If there are no more such fields,
6812 the return value will be NULL. */
6814 tree
6816 {
6821 /* In C++17, aggregates can have bases. */
6826 }
6828 /* FIELD is an element of TYPE_FIELDS or NULL. In the former case, the value
6829 returned is the next FIELD_DECL (possibly FIELD itself) that corresponds
6830 to a subobject. If there are no more such fields, the return value will be
6831 NULL. */
6833 tree
6835 {
6845 }
6847 /* Return true for [dcl.init.list] direct-list-initialization from
6848 single element of enumeration with a fixed underlying type. */
6850 bool
6852 {
6859 /* DR 2374: The single element needs to be implicitly
6860 convertible to the underlying type of the enum. */
6868 }
6870 /* Subroutine of reshape_init_array and reshape_init_vector, which does
6871 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
6872 INTEGER_CST representing the size of the array minus one (the maximum index),
6873 or NULL_TREE if the array was declared without specifying the size. D is
6874 the iterator within the constructor. */
6876 static tree
6879 {
6880 tree new_init;
6885 /* The initializer for an array is always a CONSTRUCTOR. If this is the
6886 outermost CONSTRUCTOR and the element type is non-aggregate, we don't need
6887 to build a new one. But don't reuse if not complaining; if this is
6888 tentative, we might also reshape to another type (95319). */
6895 else
6899 {
6900 /* Minus 1 is used for zero sized arrays. */
6906 /* sizetype is sign extended, not zero extended. */
6907 else
6909 }
6911 /* Loop until there are no more initializers. */
6915 {
6916 tree elt_init;
6924 complain);
6929 {
6932 }
6933 else
6939 /* This can happen with an invalid initializer (c++/54501). */
6942 }
6945 }
6947 /* Subroutine of reshape_init_r, processes the initializers for arrays.
6948 Parameters are the same of reshape_init_r. */
6950 static tree
6952 tsubst_flags_t complain)
6953 {
6963 }
6965 /* Subroutine of reshape_init_r, processes the initializers for vectors.
6966 Parameters are the same of reshape_init_r. */
6968 static tree
6970 {
6976 {
6979 {
6984 }
6987 }
6989 /* For a vector, we initialize it as an array of the appropriate size. */
6995 }
6997 /* Subroutine of reshape_init*: We're initializing an element with TYPE from
6998 INIT, in isolation from any designator or other initializers. */
7000 static tree
7002 {
7003 /* We could also implement this by wrapping init in a new CONSTRUCTOR and
7004 calling reshape_init, but this way can just live on the stack. */
7009 complain);
7010 }
7012 /* Subroutine of reshape_init_r, processes the initializers for classes
7013 or union. Parameters are the same of reshape_init_r. */
7015 static tree
7017 tsubst_flags_t complain)
7018 {
7019 tree field;
7020 tree new_init;
7024 /* The initializer for a class is always a CONSTRUCTOR. */
7031 {
7032 /* We get here from maybe_aggr_guide for C++20 class template argument
7033 deduction. In this case we need to look through the binfo because a
7034 template doesn't have base fields. */
7037 }
7040 else
7044 {
7045 /* [dcl.init.aggr]
7047 An initializer for an aggregate member that is an
7048 empty class shall have the form of an empty
7049 initializer-list {}. */
7051 {
7055 }
7057 }
7059 /* For C++20 CTAD, handle pack expansions in the base list. */
7062 /* Loop through the initializable fields, gathering initializers. */
7064 {
7065 tree field_init;
7069 /* Handle C++20 designated initializers. */
7071 {
7076 {
7077 /* We already reshaped this; we should have returned early from
7078 reshape_init. */
7081 {
7086 }
7087 }
7089 {
7093 }
7094 else
7095 {
7100 }
7103 /* Apparently the designator isn't for a member of this anonymous
7104 struct, so head back to the enclosing class. */
7108 {
7110 {
7112 {
7113 auto_diagnostic_group g;
7117 }
7118 else
7121 }
7123 }
7125 /* If the element is an anonymous union object and the initializer
7126 list is a designated-initializer-list, the anonymous union object
7127 is initialized by the designated-initializer-list { D }, where D
7128 is the designated-initializer-clause naming a member of the
7129 anonymous union object. */
7132 {
7133 /* Find the anon aggr that is a direct member of TYPE. */
7135 {
7140 }
7142 /* Not found, e.g. FIELD is a member of a base class. */
7147 found:
7148 /* Now find the TYPE member with that anon aggr type. */
7156 }
7157 }
7159 /* If we processed all the member of the class, we are done. */
7166 /* Each non-trailing aggregate element that is a pack expansion is
7167 assumed to correspond to no elements of the initializer list. */
7171 {
7172 /* The designated field F is initialized from this one element.
7174 Note that we don't want to do this if we found the designator
7175 inside an anon aggr above; we use the normal code to implement:
7177 "If the element is an anonymous union member and the initializer
7178 list is a brace-enclosed designated- initializer-list, the element
7179 is initialized by the designated-initializer-list { D }, where D
7180 is the designated- initializer-clause naming a member of the
7181 anonymous union member." */
7185 }
7186 else
7189 complain);
7195 {
7196 /* This can happen with an invalid initializer for a flexible
7197 array member (c++/54441). */
7201 }
7205 /* [dcl.init.aggr]
7207 When a union is initialized with a brace-enclosed
7208 initializer, the braces shall only contain an
7209 initializer for the first member of the union. */
7213 continue_:
7215 {
7218 else
7220 }
7221 else
7223 }
7225 /* A trailing aggregate element that is a pack expansion is assumed to
7226 correspond to all remaining elements of the initializer list (if any). */
7228 {
7233 }
7236 }
7238 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
7239 designators are not valid; either complain or return true to indicate
7240 that reshape_init_r should return error_mark_node. */
7242 static bool
7244 {
7246 {
7251 else
7253 }
7255 }
7257 /* Subroutine of reshape_init, which processes a single initializer (part of
7258 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
7259 iterator within the CONSTRUCTOR which points to the initializer to process.
7260 If this is the first initializer of the outermost CONSTRUCTOR node,
7261 FIRST_INITIALIZER_P is that CONSTRUCTOR; otherwise, it is NULL_TREE. */
7263 static tree
7265 tsubst_flags_t complain)
7266 {
7279 {
7280 /* A complex type can be initialized from one or two initializers,
7281 but braces are not elided. */
7284 {
7286 {
7289 else
7291 }
7292 }
7294 {
7302 }
7304 }
7306 /* A non-aggregate type is always initialized with a single
7307 initializer. */
7309 /* As is an array with dependent bound, which we can see
7310 during C++20 aggregate CTAD. */
7314 {
7315 /* It is invalid to initialize a non-aggregate type with a
7316 brace-enclosed initializer before C++0x.
7317 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
7318 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
7319 a CONSTRUCTOR (with a record type). */
7321 /* Don't complain about a capture-init. */
7324 {
7326 {
7328 {
7331 type);
7333 }
7336 && (BRACE_ENCLOSED_INITIALIZER_P
7338 {
7343 }
7344 }
7345 else
7347 }
7351 }
7353 /* "If T is a class type and the initializer list has a single element of
7354 type cv U, where U is T or a class derived from T, the object is
7355 initialized from that element." Even if T is an aggregate. */
7357 && first_initializer_p
7358 /* But not if it's a designated init. */
7362 {
7365 }
7367 /* [dcl.init.aggr]
7369 All implicit type conversions (clause _conv_) are considered when
7370 initializing the aggregate member with an initializer from an
7371 initializer-list. If the initializer can initialize a member,
7372 the member is initialized. Otherwise, if the member is itself a
7373 non-empty subaggregate, brace elision is assumed and the
7374 initializer is considered for the initialization of the first
7375 member of the subaggregate. */
7377 /* But don't try this for the first initializer, since that would be
7378 looking through the outermost braces; A a2 = { a1 }; is not a
7379 valid aggregate initialization. */
7380 && !first_initializer_p
7383 complain)))
7384 {
7387 }
7389 /* [dcl.init.string]
7391 A char array (whether plain char, signed char, or unsigned char)
7392 can be initialized by a string-literal (optionally enclosed in
7393 braces); a wchar_t array can be initialized by a wide
7394 string-literal (optionally enclosed in braces). */
7397 {
7400 reshape_iter stripd = {};
7402 /* Strip one level of braces if and only if they enclose a single
7403 element (as allowed by [dcl.init.string]). */
7407 {
7411 }
7413 /* If it's a string literal, then it's the initializer for the array
7414 as a whole. Otherwise, continue with normal initialization for
7415 array types (one value per array element). */
7417 {
7423 }
7424 }
7426 /* The following cases are about aggregates. If we are not within a full
7427 initializer already, and there is not a CONSTRUCTOR, it means that there
7428 is a missing set of braces (that is, we are processing the case for
7429 which reshape_init exists). */
7432 {
7434 {
7437 /* There is no need to call reshape_init for pointer-to-member
7438 function initializers, as they are always constructed correctly
7439 by the front end. Here we have e.g. {.__pfn=0B, .__delta=0},
7440 which is missing outermost braces. We should warn below, and
7442 /* For a nested compound literal, proceed to specialized routines,
7443 to handle initialization of arrays and similar. */
7446 /* If we have an unresolved designator, we need to find the member it
7447 designates within TYPE, so proceed to the routines below. For
7448 FIELD_DECL or INTEGER_CST designators, we're already initializing
7449 the designated element. */
7452 /* Brace elision with designators is only permitted for anonymous
7453 aggregates. */
7455 /* A CONSTRUCTOR of the target's type is a previously
7456 digested initializer. */
7458 {
7461 }
7462 else
7463 {
7464 /* Something that hasn't been reshaped yet. */
7468 }
7469 }
7474 type);
7476 }
7478 /* Dispatch to specialized routines. */
7479 tree new_init;
7486 else
7494 }
7496 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
7497 brace-enclosed aggregate initializer.
7499 INIT is the CONSTRUCTOR containing the list of initializers describing
7500 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
7501 It may not presently match the shape of the TYPE; for example:
7503 struct S { int a; int b; };
7504 struct S a[] = { 1, 2, 3, 4 };
7506 Here INIT will hold a vector of four elements, rather than a
7507 vector of two elements, each itself a vector of two elements. This
7508 routine transforms INIT from the former form into the latter. The
7509 revised CONSTRUCTOR node is returned. */
7511 tree
7513 {
7515 reshape_iter d;
7516 tree new_init;
7522 /* An empty constructor does not need reshaping, and it is always a valid
7523 initializer. */
7528 /* Already reshaped. */
7531 /* Brace elision is not performed for a CONSTRUCTOR representing
7532 parenthesized aggregate initialization. */
7534 {
7536 /* If we're initializing a char array from a string-literal that is
7537 enclosed in braces, unwrap it here. */
7544 }
7546 /* Handle [dcl.init.list] direct-list-initialization from
7547 single element of enumeration with a fixed underlying type. */
7549 {
7553 {
7557 tf_warning_or_error);
7558 }
7559 else
7561 }
7563 /* Recurse on this CONSTRUCTOR. */
7571 /* Make sure all the element of the constructor were used. Otherwise,
7572 issue an error about exceeding initializers. */
7574 {
7578 }
7589 }
7591 /* Verify array initializer. Returns true if errors have been reported. */
7593 bool
7595 {
7598 /* Structured binding when initialized with an array type needs
7599 to have complete type. */
7604 {
7609 }
7611 /* The array type itself need not be complete, because the
7612 initializer may tell us how many elements are in the array.
7613 But, the elements of the array must be complete. */
7615 {
7619 else
7622 }
7628 /* A compound literal can't have variable size. */
7632 {
7635 }
7637 }
7639 /* Subroutine of check_initializer; args are passed down from that function.
7640 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
7642 static tree
7644 {
7649 }
7651 /* Verify INIT (the initializer for DECL), and record the
7652 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
7653 grok_reference_init.
7655 If the return value is non-NULL, it is an expression that must be
7656 evaluated dynamically to initialize DECL. */
7658 static tree
7660 {
7661 tree type;
7663 tree core_type;
7665 /* Things that are going to be initialized need to have complete
7666 type. */
7670 {
7671 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
7672 it doesn't have storage to be initialized. */
7675 }
7678 /* We will have already complained. */
7682 {
7685 }
7687 {
7692 }
7693 else
7694 /* There is no way to make a variable-sized class type in GNU C++. */
7698 {
7701 {
7703 {
7706 }
7708 {
7710 "scalar object %qD requires one element in "
7714 }
7715 }
7716 }
7719 {
7726 }
7728 ;
7731 {
7733 {
7736 }
7739 tf_warning_or_error);
7740 /* Do not reshape constructors of vectors (they don't need to be
7741 reshaped. */
7743 {
7745 {
7747 tf_warning_or_error);
7749 }
7751 {
7752 /* Don't reshape if the class has constructors. */
7755 "in C++98 %qD must be initialized by "
7757 decl);
7758 }
7760 {
7763 }
7764 else
7765 {
7768 }
7769 }
7770 /* [dcl.init] "Otherwise, if the destination type is an array, the object
7771 is initialized as follows..." So handle things like
7773 int a[](1, 2, 3);
7775 which is permitted in C++20 by P0960. */
7785 {
7788 /* We get here with code like `int a (2);' */
7790 tf_warning_or_error);
7791 }
7793 /* If DECL has an array type without a specific bound, deduce the
7794 array size from the initializer. */
7805 /* The call to build_aggr_init below could end up
7806 calling build_vec_init, which may break when we
7807 are processing a template. */
7808 || processing_template_decl
7812 {
7815 /* A constructor call is a non-trivial initializer even if
7816 it isn't explicitly written. */
7820 /* If this is a constexpr initializer, expand_default_init will
7821 have returned an INIT_EXPR rather than a CALL_EXPR. In that
7822 case, pull the initializer back out and pass it down into
7823 store_init_value. */
7825 {
7832 else
7834 }
7836 {
7837 /* In C++20, the call to build_aggr_init could have created
7838 an INIT_EXPR with a CONSTRUCTOR as the RHS to handle
7839 A(1, 2). */
7842 /* Avoid leaking TARGET_EXPR into template trees. */
7847 /* Don't call digest_init; it's unnecessary and will complain
7848 about aggregate initialization of non-aggregate classes. */
7850 }
7853 {
7854 /* Declared constexpr or constinit, but no suitable initializer;
7855 massage init appropriately so we can pass it into
7856 store_init_value for the error. */
7866 {
7871 }
7873 }
7874 else
7876 }
7879 {
7885 {
7890 }
7902 }
7903 }
7904 else
7905 {
7913 tf_warning_or_error);
7914 }
7924 {
7925 /* We might have set these in cp_finish_decl. */
7928 }
7933 {
7936 auto_diagnostic_group d;
7942 else
7946 {
7950 }
7952 }
7955 }
7957 /* If DECL is not a local variable, give it RTL. */
7959 static void
7961 {
7965 /* Set the DECL_ASSEMBLER_NAME for the object. */
7967 {
7968 /* The `register' keyword, when used together with an
7969 asm-specification, indicates that the variable should be
7970 placed in a particular register. */
7972 {
7975 }
7976 else
7977 {
7984 /* We have to propagate the name to the ns-alias.
7985 This is horrible, as we're affecting a
7986 possibly-shared decl. Again, a one-true-decl
7987 model breaks down. */
7990 }
7991 }
7993 /* Handle non-variables up front. */
7995 {
7998 }
8000 /* If we see a class member here, it should be a static data
8001 member. */
8003 {
8005 /* An in-class declaration of a static data member should be
8006 external; it is only a declaration, and not a definition. */
8010 }
8012 /* We don't create any RTL for local variables. */
8016 /* We defer emission of local statics until the corresponding
8017 DECL_EXPR is expanded. But with constexpr its function might never
8018 be expanded, so go ahead and tell cgraph about the variable now. */
8023 /* Defer template instantiations. */
8028 /* If we're not deferring, go ahead and assemble the variable. */
8031 }
8033 /* walk_tree helper for wrap_temporary_cleanups, below. */
8035 static tree
8037 {
8038 /* Stop at types or full-expression boundaries. */
8041 {
8044 }
8047 {
8053 {
8055 /* Tell honor_protect_cleanup_actions to handle this as a separate
8056 cleanup. */
8059 }
8060 }
8063 }
8065 /* We're initializing a local variable which has a cleanup GUARD. If there
8066 are any temporaries used in the initializer INIT of this variable, we
8067 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
8068 variable will be cleaned up properly if one of them throws.
8070 Unfortunately, there's no way to express this properly in terms of
8071 nesting, as the regions for the temporaries overlap the region for the
8072 variable itself; if there are two temporaries, the variable needs to be
8073 the first thing destroyed if either of the temporary destructors throws.
8074 However, we only want to run the variable's cleanup if it actually got
8075 constructed. So we need to guard the temporary cleanups with the
8076 variable's cleanup if they are run on the normal path, but not if they
8077 are run on the exceptional path. We implement this by telling
8078 honor_protect_cleanup_actions to strip the variable cleanup from the
8079 exceptional path.
8081 Another approach could be to make the variable cleanup region enclose
8082 initialization, but depend on a flag to indicate that the variable is
8083 initialized; that's effectively what we do for arrays. But the current
8084 approach works fine for non-arrays, and has no code overhead in the usual
8085 case where the temporary destructors are noexcept. */
8087 static void
8089 {
8091 {
8092 /* An array cleanup region already encloses any temporary cleanups,
8093 don't wrap it around them again. */
8096 }
8098 }
8100 /* Generate code to initialize DECL (a local variable). */
8102 static void
8104 {
8106 tree cleanup;
8113 {
8114 /* If we used it already as memory, it must stay in memory. */
8118 }
8123 /* Compute and store the initial value. */
8128 /* Generate a cleanup, if necessary. */
8132 /* Perform the initialization. */
8134 {
8139 {
8140 /* Stick simple initializers in DECL_INITIAL so that
8141 -Wno-init-self works (c++/34772). */
8145 {
8149 OPT_Winit_self,
8151 }
8152 }
8153 else
8154 {
8157 /* If we're only initializing a single object, guard the
8158 destructors of any temporaries used in its initializer with
8159 its destructor. */
8165 /* Avoid CLEANUP_POINT_EXPR for the structured binding
8166 bases, those will have CLEANUP_POINT_EXPR at the end of
8167 code emitted by cp_finish_decomp. */
8170 /* P2718R0 - avoid CLEANUP_POINT_EXPR for range-for-initializer,
8171 temporaries from there should have lifetime extended. */
8175 else
8180 }
8181 }
8183 /* Set this to 0 so we can tell whether an aggregate which was
8184 initialized was ever used. Don't do this if it has a
8185 destructor, so we don't complain about the 'resource
8186 allocation is initialization' idiom. Now set
8187 attribute((unused)) on types so decls of that type will be
8188 marked used. (see TREE_USED, above.) */
8190 && ! already_used
8199 }
8201 /* DECL is a VAR_DECL for a compiler-generated variable with static
8202 storage duration (like a virtual table) whose initializer is a
8203 compile-time constant. Initialize the variable and provide it to the
8204 back end. */
8206 void
8208 {
8209 tree init;
8215 /* Mark the decl as constexpr so that we can access its content
8216 at compile time. */
8223 }
8225 /* INIT is the initializer for a variable, as represented by the
8226 parser. Returns true iff INIT is value-dependent. */
8228 static bool
8230 {
8232 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
8235 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
8236 {
8249 }
8250 else
8251 /* It must be a simple expression, e.g., int i = 3; */
8255 }
8257 /* A helper function to be called via walk_tree. If any label exists
8258 under *TP, it is (going to be) forced. Set has_forced_label_in_static. */
8260 static tree
8262 {
8268 }
8270 /* Return true if DECL has either a trivial destructor, or for C++20
8271 is constexpr and has a constexpr destructor. */
8273 static bool
8275 {
8281 }
8285 /* Helper function of omp_declare_variant_finalize. Finalize one
8286 "omp declare variant base" attribute. Return true if it should be
8287 removed. */
8289 static bool
8291 {
8293 {
8298 }
8302 OMP_TRAIT_CONSTRUCT_SIMD);
8304 {
8308 /* FIXME, adjusting simd args unimplemented. */
8310 }
8313 location_t varid_loc
8322 releasing_vec args;
8331 else
8336 {
8338 /* In C++20, we may need to perform ADL for a template
8339 name. */
8342 {
8344 {
8348 tf_warning_or_error);
8349 }
8350 else
8352 }
8354 {
8360 {
8364 tf_warning_or_error);
8365 }
8366 }
8367 }
8372 else
8382 {
8385 {
8389 }
8394 {
8397 }
8398 else
8399 {
8400 tree construct
8406 }
8407 }
8409 {
8412 }
8415 }
8417 /* Helper function, finish up "omp declare variant base" attribute
8418 now that there is a DECL. ATTR is the first "omp declare variant base"
8419 attribute. */
8421 void
8423 {
8433 {
8436 }
8438 {
8441 }
8443 {
8446 }
8448 {
8451 }
8453 {
8456 }
8457 /* This loop is like private_lookup_attribute, except that it works
8458 with tree * rather than tree, as we might want to remove the
8459 attributes that are diagnosed as errorneous. */
8461 {
8466 {
8468 {
8471 }
8472 }
8474 }
8475 }
8479 /* Finish processing of a declaration;
8480 install its line number and initial value.
8481 If the length of an array type is not known before,
8482 it must be determined now, from the initial value, or it is an error.
8484 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
8485 true, then INIT is an integral constant expression.
8487 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8488 if the (init) syntax was used.
8490 DECOMP is first identifier's DECL and identifier count in a structured
8491 bindings, nullptr if not a structured binding. */
8493 void
8496 {
8501 tree auto_node;
8504 tree decl;
8507 {
8510 }
8516 {
8520 }
8523 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
8533 /* Warn about register storage specifiers except when in GNU global
8534 or local register variable extension. */
8536 {
8539 "ISO C++17 does not allow %<register%> storage "
8541 else
8544 }
8546 /* If a name was specified, get the string. */
8552 bool in_class_decl
8553 = (current_class_type
8564 {
8565 tree d_init;
8567 {
8571 {
8572 /* init is null because we're deferring instantiating the
8573 initializer until we need it. Well, we need it now. */
8576 }
8580 else
8581 {
8582 /* Ordinary auto deduction without an initializer, a situation
8583 which grokdeclarator already detects and rejects for the most
8584 part. But we can still get here if we're instantiating a
8585 variable template before we've fully parsed (and attached) its
8586 initializer, e.g. template<class> auto x = x<int>; */
8591 }
8592 }
8595 {
8599 tf_warning_or_error);
8601 /* Force auto deduction now. Use tf_none to avoid redundant warnings
8602 on deprecated-14.C. */
8604 }
8613 /* The outer template arguments might be needed for satisfaction.
8614 (For function scope variables, do_auto_deduction will obtain the
8615 outer template arguments from current_function_decl.) */
8623 {
8628 }
8629 /* As in start_decl_1, complete so TREE_READONLY is set properly. */
8633 {
8634 auto_diagnostic_group d;
8640 }
8643 /* Update the type of the corresponding TEMPLATE_DECL to match. */
8648 }
8651 {
8654 {
8657 }
8658 }
8668 {
8670 ? TCTX_THREAD_STORAGE
8673 }
8676 {
8677 tree clone;
8681 {
8682 /* FIXME check this is 1st decl. */
8684 {
8685 /* [basic.start.main]/3: A program that defines main as deleted
8686 is ill-formed. */
8689 }
8690 else
8691 {
8697 {
8701 }
8702 }
8704 }
8706 {
8709 else
8711 }
8712 }
8715 {
8717 /* If DECL is a reference, then we want to know whether init is a
8718 reference constant; init_const_expr_p as passed tells us whether
8719 it's an rvalue constant. */
8723 {
8724 /* Set these flags now for templates. We'll update the flags in
8725 store_init_value for instantiations. */
8728 /* FIXME setting TREE_CONSTANT on refs breaks the back end. */
8731 }
8732 /* This is handled mostly by gimplify.cc, but we have to deal with
8733 not warning about int x = x; as it is a GCC extension to turn off
8734 this warning but only if warn_init_self is zero. */
8740 }
8746 /* We have no initializer but there's nothing to initialize anyway.
8747 Treat DECL as constant due to c++/109876. */
8752 /* #pragma omp declare variant on methods handled in finish_struct
8753 instead. */
8761 {
8764 /* Add this declaration to the statement-tree. */
8771 {
8774 }
8776 /* Generally, initializers in templates are expanded when the
8777 template is instantiated. But, if DECL is a variable constant
8778 then it can be used in future constant expressions, so its value
8779 must be available. */
8790 {
8791 /* This variable seems to be a non-dependent constant, so process
8792 its initializer. If check_initializer returns non-null the
8793 initialization wasn't constant after all. */
8794 tree init_code;
8800 }
8801 else
8802 {
8804 /* Try to deduce array size. */
8806 /* And complain about multiple initializers. */
8810 tf_warning_or_error);
8811 }
8817 {
8820 }
8823 {
8826 }
8828 }
8830 /* Just store non-static data member initializers for later. */
8834 /* Take care of TYPE_DECLs up front. */
8836 {
8839 {
8843 }
8845 /* If we have installed this as the canonical typedef for this
8846 type, and that type has not been defined yet, delay emitting
8847 the debug information for it, as we will emit it later. */
8853 at_eof);
8855 }
8857 /* A reference will be modified here, as it is initialized. */
8861 {
8864 }
8866 /* This needs to happen before extend_ref_init_temps. */
8868 {
8872 }
8875 {
8877 /* [dcl.constinit]/1 "The constinit specifier shall be applied
8878 only to a declaration of a variable with static or thread storage
8879 duration." */
8882 {
8884 "%<constinit%> can only be applied to a variable with "
8887 }
8892 /* If this is a local variable that will need a mangled name,
8893 register it now. We must do this before processing the
8894 initializer for the variable, since the initialization might
8895 require a guard variable, and since the mangled name of the
8896 guard variable will depend on the mangled name of this
8897 variable. */
8901 {
8902 /* The variable holding an anonymous union will have had its
8903 discriminator set in finish_anon_union, after which it's
8904 NAME will have been cleared. */
8907 /* Normally has_forced_label_in_static is set during GIMPLE
8908 lowering, but [cd]tors are never actually compiled directly.
8909 We need to set this early so we can deal with the label
8910 address extension. */
8914 {
8917 }
8918 /* And make sure it's in the symbol table for
8919 c_parse_final_cleanups to find. */
8921 }
8923 /* Convert the initializer to the type of DECL, if we have not
8924 already initialized DECL. */
8926 /* If !DECL_EXTERNAL then DECL is being defined. In the
8927 case of a static data member initialized inside the
8928 class-specifier, there can be an initializer even if DECL
8929 is *not* defined. */
8931 {
8935 /* Handle:
8937 [dcl.init]
8939 The memory occupied by any object of static storage
8940 duration is zero-initialized at program startup before
8941 any other initialization takes place.
8943 We cannot create an appropriate initializer until after
8944 the type of DECL is finalized. If DECL_INITIAL is set,
8945 then the DECL is statically initialized, and any
8946 necessary zero-initialization has already been performed. */
8951 /* Remember that the initialization for this variable has
8952 taken place. */
8954 /* This declaration is the definition of this variable,
8955 unless we are initializing a static data member within
8956 the class specifier. */
8959 }
8960 /* If the variable has an array type, lay out the type, even if
8961 there is no initializer. It is valid to index through the
8962 array, and we must get TYPE_ALIGN set correctly on the array
8963 type. */
8970 /* So decl is a global variable or a static member of a
8971 non local class. Record the types it uses
8972 so that we can decide later to emit debug info for them. */
8974 }
8976 /* Add this declaration to the statement-tree. This needs to happen
8977 after the call to check_initializer so that the DECL_EXPR for a
8978 reference temp is added before the DECL_EXPR for the reference itself. */
8980 {
8981 /* If we're building a variable sized type, and we might be
8982 reachable other than via the top of the current binding
8983 level, then create a new BIND_EXPR so that we deallocate
8984 the object at the right time. */
8989 {
8990 tree bind;
8995 }
8997 }
9000 /* Let the middle end know about variables and functions -- but not
9001 static data members in uninstantiated class templates. */
9003 {
9005 {
9008 /* Check again now that we have an initializer. */
9010 /* A class-scope constexpr variable with an out-of-class declaration.
9011 C++17 makes them implicitly inline, but still force it out. */
9017 }
9020 /* With -fmerge-all-constants, gimplify_init_constructor
9021 might add TREE_STATIC to aggregate variables. */
9025 {
9026 /* If a TREE_READONLY variable needs initialization
9027 at runtime, it is no longer readonly and we need to
9028 avoid MEM_READONLY_P being set on RTL created for it. */
9030 {
9034 }
9038 /* Likewise if it needs destruction. */
9041 }
9047 {
9048 /* TLS variables need dynamic initialization by the TLS wrapper
9049 function, we don't want to hoist accesses to it before the
9050 wrapper. */
9053 }
9057 /* Check for abstractness of the type. */
9065 /* No initialization required. */
9066 ;
9068 {
9070 {
9072 {
9073 /* An out-of-class default definition is defined at
9074 the point where it is explicitly defaulted. */
9079 }
9080 else
9084 decl);
9085 }
9086 /* else no initialization required. */
9087 }
9091 {
9092 /* check_initializer will have done any constant initialization. */
9093 }
9094 /* A variable definition. */
9096 {
9097 /* Initialize the local variable. */
9100 else
9101 {
9105 /* If cp_finish_decomp needs to emit any code, we need to emit that
9106 code after code emitted by initialize_local_var in a single
9107 CLEANUP_POINT_EXPR, so that temporaries are destructed only
9108 after the cp_finish_decomp emitted code.
9109 If there are any cleanups, either extend_ref_init_temps
9110 created ones or e.g. array destruction, push those first
9111 with the cleanups guarded on a bool temporary, initially
9112 set to false and set to true after initialize_local_var
9113 emitted code. */
9116 {
9121 }
9125 {
9134 }
9141 {
9142 /* If cp_finish_decomp needs any cleanups, such as for
9143 extend_ref_init_temps created vars, pop_stmt_list
9144 popped that all, so push those extra cleanups around
9145 the whole sequence with a guard variable. */
9152 {
9165 integer_type_node,
9167 TSI_SAME_STMT);
9172 }
9173 }
9177 }
9178 }
9180 /* If a variable is defined, and then a subsequent
9181 definition with external linkage is encountered, we will
9182 get here twice for the same variable. We want to avoid
9183 calling expand_static_init more than once. For variables
9184 that are not static data members, we can call
9185 expand_static_init only when we actually process the
9186 initializer. It is not legal to redeclare a static data
9187 member, so this issue does not arise in that case. */
9190 }
9192 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
9193 reference, insert it in the statement-tree now. */
9195 {
9197 {
9199 /* As in initialize_local_var. */
9201 }
9203 }
9218 {
9224 {
9225 auto_diagnostic_group d;
9231 }
9236 {
9242 {
9245 {
9249 }
9250 }
9251 }
9252 }
9254 /* This is the last point we can lower alignment so give the target the
9255 chance to do so. */
9262 }
9264 /* For class TYPE return itself or some its bases that contain
9265 any direct non-static data members. Return error_mark_node if an
9266 error has been diagnosed. */
9268 static tree
9270 {
9280 {
9281 auto_diagnostic_group d;
9285 else
9290 }
9292 {
9293 auto_diagnostic_group d;
9301 }
9302 else
9312 {
9317 {
9319 {
9324 }
9328 {
9330 "classes %qT and %qT have non-static data "
9333 }
9334 else
9336 }
9337 }
9339 }
9341 /* Return std::tuple_size<TYPE>::value. */
9343 static tree
9345 {
9351 tf_none);
9365 else
9367 }
9369 /* Return std::tuple_element<I,TYPE>::type. */
9371 static tree
9373 {
9380 tf_warning_or_error);
9383 }
9385 /* Return e.get<i>() or get<i>(e). */
9387 static tree
9389 {
9396 /* [The id-expression] e is an lvalue if the type of the entity e is an
9397 lvalue reference and an xvalue otherwise. */
9406 /* To use a member get, member lookup must find at least one
9407 declaration that is a function template
9408 whose first template parameter is a non-type parameter. */
9410 {
9413 {
9417 {
9420 }
9421 }
9422 }
9425 {
9430 }
9431 else
9432 {
9438 }
9439 }
9441 /* It's impossible to recover the decltype of a tuple decomposition variable
9442 based on the actual type of the variable, so store it in a hash table. */
9446 tree
9448 {
9452 }
9454 /* Mangle a decomposition declaration if needed. Arguments like
9455 in cp_finish_decomp. */
9457 static void
9459 {
9463 {
9470 {
9479 {
9484 }
9487 }
9490 }
9491 }
9493 /* Finish a decomposition declaration. DECL is the underlying declaration
9494 "e", FIRST is the head of a chain of decls for the individual identifiers
9495 chained through DECL_CHAIN in reverse order and COUNT is the number of
9496 those decls. If TEST_P is true, return true if any code would need to be
9497 actually emitted but don't emit it. Return false otherwise. */
9499 bool
9501 {
9505 {
9506 error_out:
9508 {
9511 {
9514 }
9516 }
9520 }
9524 /* This happens for range for when not in templates.
9525 Still add the DECL_VALUE_EXPRs for later processing. */
9526 || (!processing_template_decl
9528 {
9530 {
9532 {
9538 }
9542 }
9544 }
9550 {
9553 }
9559 {
9565 {
9567 type);
9569 }
9570 }
9575 {
9576 tree nelts;
9581 {
9585 }
9587 {
9590 }
9593 {
9594 cnt_mismatch:
9595 auto_diagnostic_group d;
9600 else
9609 }
9612 {
9621 }
9622 }
9623 /* 2 GNU extensions. */
9625 {
9631 {
9640 }
9641 }
9643 {
9645 {
9648 }
9653 {
9664 }
9665 }
9667 {
9669 {
9673 }
9675 {
9676 auto_diagnostic_group d;
9683 }
9690 {
9691 /* For structured bindings used in conditions we need to evaluate
9692 the conversion of decl (aka e in the standard) to bool or
9693 integral/enumeral type (the latter for switch conditions)
9694 before the get methods. */
9697 /* switch condition. */
9700 else
9701 /* if/while/for condition. */
9704 {
9705 /* Wrap that value into a TARGET_EXPR, emit it right
9706 away and save for later uses in the cp_parse_condition
9707 or its instantiation. */
9711 }
9712 }
9715 {
9726 {
9730 }
9732 {
9736 }
9737 /* Save the decltype away before reference collapse. */
9743 {
9744 /* In this case the names are variables, not just proxies. */
9747 }
9749 {
9753 }
9754 }
9755 /* Ignore reads from the underlying decl performed during initialization
9756 of the individual variables. If those will be read, we'll mark
9757 the underlying decl as read at that point. */
9759 }
9761 {
9764 }
9766 {
9769 }
9771 {
9774 }
9779 type);
9780 else
9781 {
9786 {
9790 }
9796 else
9797 eltscnt++;
9802 {
9806 }
9813 else
9814 {
9816 NULL_TREE);
9822 {
9825 }
9826 i++;
9827 }
9828 }
9830 {
9833 {
9838 }
9839 }
9841 }
9843 /* Returns a declaration for a VAR_DECL as if:
9845 extern "C" TYPE NAME;
9847 had been seen. Used to create compiler-generated global
9848 variables. */
9850 static tree
9852 {
9859 /* If the user has explicitly declared this variable (perhaps
9860 because the code we are compiling is part of a low-level runtime
9861 library), then it is possible that our declaration will be merged
9862 with theirs by pushdecl. */
9868 }
9870 /* Returns the type for the argument to "atexit" corresponding to the function
9871 to be called when the program exits. */
9873 static tree
9875 {
9877 {
9880 }
9883 }
9885 /* Returns the type for the argument to "__cxa_atexit", "__cxa_thread_atexit"
9886 or "__cxa_throw" corresponding to the destructor to be called when the
9887 program exits. */
9889 tree
9891 {
9893 {
9898 }
9901 }
9903 /* Returns a pointer to the `atexit' function. Note that if
9904 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
9905 `__cxa_atexit' function specified in the IA64 C++ ABI. */
9907 static tree
9909 {
9910 tree atexit_fndecl;
9911 tree fn_type;
9912 tree fn_ptr_type;
9921 {
9922 /* The declaration for `__cxa_atexit' is:
9924 int __cxa_atexit (void (*)(void *), void *, void *)
9926 We build up the argument types and then the function type
9927 itself. */
9931 /* First, build the pointer-to-function type for the first
9932 argument. */
9934 /* Then, build the rest of the argument types. */
9937 {
9940 }
9941 else
9942 {
9945 }
9946 /* And the final __cxa_atexit type. */
9949 NULL_TREE);
9950 /* ... which needs noexcept. */
9953 {
9961 }
9962 else
9963 {
9966 }
9967 }
9968 else
9969 {
9970 /* The declaration for `atexit' is:
9972 int atexit (void (*)());
9974 We build up the argument types and then the function type
9975 itself. */
9977 /* Build the final atexit type. */
9980 /* ... which needs noexcept. */
9983 }
9985 /* Now, build the function declaration. */
9990 /* Install as hidden builtin so we're (a) more relaxed about
9991 exception spec matching and (b) will not give a confusing location
9992 in diagnostic and (c) won't magically appear in user-visible name
9993 lookups. */
10002 }
10004 /* Like get_atexit_node, but for thread-local cleanups. */
10006 static tree
10008 {
10012 /* The declaration for `__cxa_thread_atexit' is:
10014 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
10018 NULL_TREE);
10020 /* Now, build the function declaration, as with __cxa_atexit. */
10032 }
10034 /* Returns the __dso_handle VAR_DECL. */
10036 static tree
10038 {
10042 /* Declare the variable. */
10044 ptr_type_node);
10046 #ifdef HAVE_GAS_HIDDEN
10048 {
10051 }
10052 #endif
10055 }
10057 /* Begin a new function with internal linkage whose job will be simply
10058 to destroy some particular variable. OB_PARM is true if object pointer
10059 is passed to the cleanup function, otherwise no argument is passed. */
10063 static tree
10065 {
10070 /* No need to mangle this. */
10073 /* Build the name of the function. */
10077 /* Build the function declaration. */
10080 /* It's a function with internal linkage, generated by the
10081 compiler. */
10084 /* Make the function `inline' so that it is only emitted if it is
10085 actually needed. It is unlikely that it will be inlined, since
10086 it is only called via a function pointer, but we avoid unnecessary
10087 emissions this way. */
10091 {
10092 /* Build the parameter. */
10097 }
10105 }
10107 /* Finish the cleanup function begun by start_cleanup_fn. */
10109 static void
10111 {
10115 }
10117 /* Generate code to handle the destruction of DECL, an object with
10118 static storage duration. */
10120 tree
10122 {
10123 tree cleanup;
10124 tree addr;
10125 tree compound_stmt;
10126 tree fcall;
10127 tree type;
10130 tree atex_node;
10138 {
10141 }
10143 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
10144 "__aeabi_atexit"), and DECL is a class object, we can just pass the
10145 destructor to "__cxa_atexit"; we don't have to build a temporary
10146 function to do the cleanup. */
10147 dso_parm = (flag_use_cxa_atexit
10152 {
10155 /* Make sure it is accessible. */
10157 tf_warning_or_error);
10158 }
10159 else
10160 {
10161 /* Call build_cleanup before we enter the anonymous function so
10162 that any access checks will be done relative to the current
10163 scope, rather than the scope of the anonymous function. */
10166 /* Now start the function. */
10169 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
10170 to the original function, rather than the anonymous one. That
10171 will make the back end think that nested functions are in use,
10172 which causes confusion. */
10177 /* Create the body of the anonymous function. */
10182 }
10184 /* Call atexit with the cleanup function. */
10190 else
10194 {
10195 /* We must convert CLEANUP to the type that "__cxa_atexit"
10196 expects. */
10198 /* "__cxa_atexit" will pass the address of DECL to the
10199 cleanup function. */
10202 /* The declared type of the parameter to "__cxa_atexit" is
10203 "void *". For plain "T*", we could just let the
10204 machinery in cp_build_function_call convert it -- but if the
10205 type is "cv-qualified T *", then we need to convert it
10206 before passing it in, to avoid spurious errors. */
10208 }
10209 else
10210 /* Since the cleanup functions we build ignore the address
10211 they're given, there's no reason to pass the actual address
10212 in, and, in general, it's cheaper to pass NULL than any
10213 other value. */
10218 tf_warning_or_error);
10220 /* Just pass NULL to the dso handle parm if we don't actually
10221 have a DSO handle on this target. */
10223 else
10227 {
10230 {
10233 }
10234 else
10235 {
10238 }
10239 }
10240 else
10241 {
10244 }
10247 }
10249 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
10250 is its initializer. Generate code to handle the construction
10251 and destruction of DECL. */
10253 static void
10255 {
10259 /* Some variables require no dynamic initialization. */
10261 {
10262 /* Make sure the destructor is callable. */
10266 }
10270 {
10271 auto_diagnostic_group d;
10276 else
10281 {
10285 }
10287 }
10290 {
10291 /* Emit code to perform this initialization but once. */
10296 /* We don't need thread-safety code for thread-local vars. */
10300 /* Emit code to perform this initialization but once. This code
10301 looks like:
10303 static <type> guard;
10304 if (!__atomic_load (guard.first_byte)) {
10305 if (__cxa_guard_acquire (&guard)) {
10306 bool flag = false;
10307 try {
10308 // Do initialization.
10309 flag = true; __cxa_guard_release (&guard);
10310 // Register variable for destruction at end of program.
10311 } catch {
10312 if (!flag) __cxa_guard_abort (&guard);
10313 }
10314 }
10315 }
10317 Note that the `flag' variable is only set to 1 *after* the
10318 initialization is complete. This ensures that an exception,
10319 thrown during the construction, will cause the variable to
10320 reinitialized when we pass through this code again, as per:
10322 [stmt.dcl]
10324 If the initialization exits by throwing an exception, the
10325 initialization is not complete, so it will be tried again
10326 the next time control enters the declaration.
10328 This process should be thread-safe, too; multiple threads
10329 should not be able to initialize the variable more than
10330 once. */
10332 /* Create the guard variable. */
10335 /* Begin the conditional initialization. */
10342 {
10355 acquire_fn = push_library_fn
10358 NULL_TREE),
10363 NULL_TREE);
10366 ECF_NOTHROW);
10373 inner_if_stmt);
10381 void_node,
10385 /* Do the initialization itself. */
10391 /* Use atexit to register a function for destroying this static
10392 variable. Do this before calling __cxa_guard_release. */
10396 guard_addr));
10397 }
10398 else
10399 {
10402 /* Use atexit to register a function for destroying this static
10403 variable. */
10405 }
10410 {
10414 }
10419 }
10422 else
10424 }
10426 \f
10427 /* Make TYPE a complete type based on INITIAL_VALUE.
10428 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
10429 2 if there was no information (in which case assume 0 if DO_DEFAULT),
10430 3 if the initializer list is empty (in pedantic mode). */
10432 int
10434 {
10438 /* Don't get confused by a CONSTRUCTOR for some other type. */
10445 {
10446 /* An array of character type can be initialized from a
10447 brace-enclosed string constant so call reshape_init to
10448 remove the optional braces from a braced string literal. */
10452 tf_warning_or_error);
10454 /* If any of the elements are parameter packs, we can't actually
10455 complete this type now because the array size is dependent. */
10460 }
10464 /* We can create the array before the element type is complete, which
10465 means that we didn't have these two bits set in the original type
10466 either. In completing the type, we are expected to propagate these
10467 bits. See also complete_type which does the same thing for arrays
10468 of fixed size. */
10471 {
10476 }
10479 }
10481 /* As above, but either give an error or reject zero-size arrays, depending
10482 on COMPLAIN. */
10484 int
10487 {
10490 /* In SFINAE context we can't be lenient about zero-size arrays. */
10497 {
10503 {
10506 }
10510 }
10512 }
10513 \f
10514 /* Return zero if something is declared to be a member of type
10515 CTYPE when in the context of CUR_TYPE. STRING is the error
10516 message to print in that case. Otherwise, quietly return 1. */
10518 static int
10520 {
10522 {
10525 else
10528 }
10530 }
10531 \f
10532 /* Subroutine of `grokdeclarator'. */
10534 /* Generate errors possibly applicable for a given set of specifiers.
10535 This is for ARM $7.1.2. */
10537 static void
10546 {
10548 {
10592 }
10596 && !flag_noexcept_type
10602 }
10604 /* DECL is a member function or static data member and is presently
10605 being defined. Check that the definition is taking place in a
10606 valid namespace. */
10608 static void
10610 {
10611 /* These checks only apply to member functions and static data
10612 members. */
10614 /* We check for problems with specializations in pt.cc in
10615 check_specialization_namespace, where we can issue better
10616 diagnostics. */
10619 /* We check this in check_explicit_instantiation_namespace. */
10622 /* [class.mfct]
10624 A member function definition that appears outside of the
10625 class definition shall appear in a namespace scope enclosing
10626 the class definition.
10628 [class.static.data]
10630 The definition for a static data member shall appear in a
10631 namespace scope enclosing the member's class definition. */
10635 }
10637 /* Build a PARM_DECL for the "this" parameter of FN. TYPE is the
10638 METHOD_TYPE for a non-static member function; QUALS are the
10639 cv-qualifiers that apply to the function. */
10641 tree
10643 {
10644 tree this_type;
10645 tree qual_type;
10646 tree parm;
10647 cp_cv_quals this_quals;
10650 {
10651 this_type
10654 }
10655 else
10657 /* The `this' parameter is implicitly `const'; it cannot be
10658 assigned to. */
10664 }
10666 /* DECL is a static member function. Complain if it was declared
10667 with function-cv-quals. */
10669 static void
10671 {
10674 decl);
10675 }
10677 /* Helper function. Replace the temporary this parameter injected
10678 during cp_finish_omp_declare_simd with the real this parameter. */
10680 static tree
10682 {
10691 }
10693 /* CTYPE is class type, or null if non-class.
10694 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
10695 or METHOD_TYPE.
10696 DECLARATOR is the function's name.
10697 PARMS is a chain of PARM_DECLs for the function.
10698 VIRTUALP is truthvalue of whether the function is virtual or not.
10699 FLAGS are to be passed through to `grokclassfn'.
10700 QUALS are qualifiers indicating whether the function is `const'
10701 or `volatile'.
10702 RAISES is a list of exceptions that this function can raise.
10703 CHECK is 1 if we must find this method in CTYPE, 0 if we should
10704 not look, and -1 if we should not call `grokclassfn' at all.
10706 SFK is the kind of special function (if any) for the new function.
10708 Returns `NULL_TREE' if something goes wrong, after issuing
10709 applicable error messages. */
10711 static tree
10713 tree type,
10714 tree declarator,
10715 tree parms,
10716 tree orig_declarator,
10718 tree decl_reqs,
10721 cp_cv_quals quals,
10722 cp_ref_qualifier rqual,
10723 tree raises,
10730 special_function_kind sfk,
10734 tree in_namespace,
10736 location_t location)
10737 {
10738 tree decl;
10739 tree t;
10744 /* Was the concept specifier present? */
10748 {
10751 }
10757 /* Set the constraints on the declaration. */
10759 {
10764 && (current_template_depth
10767 {
10769 /* If there are no template parameters, something must have
10770 gone wrong. */
10772 else
10774 }
10776 /* C++20 CA378: Remove non-templated constrained functions. */
10777 /* [temp.friend]/9 A non-template friend declaration with a
10778 requires-clause shall be a definition. A friend function template with
10779 a constraint that depends on a template parameter from an enclosing
10780 template shall be a definition. */
10782 && (block_local
10783 || !processing_template_decl
10785 {
10788 else
10792 }
10798 }
10801 {
10806 /* Allocate space to hold the vptr bit if needed. */
10808 }
10814 /* Propagate volatile out from type to decl. */
10818 /* Setup decl according to sfk. */
10820 {
10832 /* Give deduction guides a definition even though they don't really
10833 have one: the restriction that you can't repeat a deduction guide
10834 makes them more like a definition anyway. */
10839 }
10842 {
10846 orig_declarator);
10847 else
10848 {
10853 {
10854 /* Something like `template <class T> friend void f<T>()'. */
10856 "invalid use of template-id %qD in declaration "
10858 orig_declarator);
10860 }
10862 /* A friend declaration of the form friend void f<>(). Record
10863 the information in the TEMPLATE_ID_EXPR. */
10872 {
10874 "default arguments are not allowed in declaration "
10876 decl);
10878 }
10881 {
10883 "%<inline%> is not allowed in declaration of friend "
10885 decl);
10887 }
10888 }
10889 }
10891 /* C++17 11.3.6/4: "If a friend declaration specifies a default argument
10892 expression, that declaration shall be a definition..." */
10894 {
10898 {
10900 "friend declaration of %qD specifies default "
10903 }
10904 }
10906 /* If this decl has namespace scope, set that up. */
10911 else
10914 /* `main' and builtins have implicit 'C' linkage. */
10940 {
10961 }
10963 /* Members of anonymous types and local classes have no linkage; make
10964 them internal. If a typedef is made later, this will be changed. */
10968 /* But members of local classes in a module CMI should have their
10969 definitions exported, in case they are (directly or indirectly)
10970 used by an importer. We don't just use module_has_cmi_p here
10971 because for entities in the GMF we don't yet know whether this
10972 module will have a CMI, so we'll conservatively assume it might. */
10976 {
10977 /* [basic.link]: A name with no linkage (notably, the name of a class
10978 or enumeration declared in a local scope) shall not be used to
10979 declare an entity with linkage.
10981 DR 757 relaxes this restriction for C++0x. */
10983 }
10987 {
10990 }
10992 /* If the declaration was declared inline, mark it as such. */
10994 {
10998 }
11002 {
11005 }
11009 {
11012 TYPE_UNQUALIFIED,
11013 REF_QUAL_NONE);
11014 auto_diagnostic_group d;
11018 : !xobj_func_p
11022 decl);
11026 : !xobj_func_p
11030 decl);
11038 }
11041 {
11045 {
11046 auto_diagnostic_group d;
11051 }
11054 {
11055 auto_diagnostic_group d;
11059 }
11063 }
11068 {
11072 /* [over.literal]/6: Literal operators shall not have C linkage. */
11074 {
11075 auto_diagnostic_group d;
11079 }
11082 {
11085 {
11088 }
11092 {
11096 }
11098 {
11102 }
11103 /* 17.6.3.3.5 */
11107 "literal operator suffixes not preceded by %<_%>"
11109 }
11110 else
11111 {
11114 }
11115 }
11118 /* Make the init_value nonzero so pushdecl knows this is not
11119 tentative. error_mark_node is replaced later with the BLOCK. */
11126 {
11127 /* Adjust "omp declare simd" attributes. */
11130 {
11131 tree attr;
11134 {
11139 {
11141 cl = c_omp_declare_simd_clauses_to_numbers
11145 else
11147 }
11148 }
11149 }
11150 }
11152 /* Caller will do the rest of this. */
11159 /* 12.4/3 */
11169 template_count,
11180 {
11183 }
11188 /* Check main's type after attributes have been applied. */
11190 {
11192 integer_type_node))
11193 {
11195 tree newtype;
11200 }
11203 }
11206 {
11208 (current_template_depth
11210 ? current_template_parms
11217 {
11218 tree ok;
11219 tree pushed_scope;
11222 /* Because grokfndecl is always supposed to return a
11223 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
11224 here. We depend on our callers to figure out that its
11225 really a template that's being returned. */
11230 {
11231 /* Remove the `this' parm added by grokclassfn. */
11234 }
11236 {
11239 }
11241 {
11242 auto_diagnostic_group d;
11247 }
11249 /* Since we've smashed OLD_DECL to its
11250 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
11254 /* Attempt to merge the declarations. This can fail, in
11255 the case of some invalid specialization declarations. */
11261 {
11265 }
11269 }
11270 }
11282 }
11284 /* decl is a FUNCTION_DECL.
11285 specifiers are the parsed virt-specifiers.
11287 Set flags to reflect the virt-specifiers.
11289 Returns decl. */
11291 static tree
11293 {
11301 }
11303 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
11304 the linkage that DECL will receive in the object file. */
11306 static void
11308 {
11309 /* A static data member always has static storage duration and
11310 external linkage. Note that static data members are forbidden in
11311 local classes -- the only situation in which a class has
11312 non-external linkage. */
11315 /* For non-template classes, static data members are always put
11316 out in exactly those files where they are defined, just as
11317 with ordinary namespace-scope variables. */
11320 }
11322 /* Create a VAR_DECL named NAME with the indicated TYPE.
11324 If SCOPE is non-NULL, it is the class type or namespace containing
11325 the variable. If SCOPE is NULL, the variable should is created in
11326 the innermost enclosing scope. */
11328 static tree
11330 tree name,
11331 tree orig_declarator,
11338 tree scope,
11339 location_t location)
11340 {
11341 tree decl;
11342 tree explicit_scope;
11349 /* Compute the scope in which to place the variable, but remember
11350 whether or not that scope was explicitly specified by the user. */
11353 {
11354 /* An explicit "extern" specifier indicates a namespace-scope
11355 variable. */
11360 }
11364 template, we need DECL_LANG_SPECIFIC. */
11366 /* Similarly for namespace-scope variables with language linkage
11367 other than C++. */
11370 /* Similarly for static data members. */
11372 /* Similarly for explicit specializations. */
11373 || (orig_declarator
11376 else
11381 else
11385 {
11388 }
11391 {
11393 /* This function is only called with out-of-class definitions. */
11396 }
11397 /* At top level, either `static' or no s.c. makes a definition
11398 (perhaps tentative), and absence of `static' makes it public. */
11400 {
11403 || ! constp
11404 || volatilep
11405 || inlinep
11406 || in_template_context
11407 || processing_specialization
11410 }
11411 /* Not at top level, only `static' makes a static definition. */
11412 else
11413 {
11416 }
11421 {
11423 {
11427 }
11430 }
11432 /* If the type of the decl has no linkage, make sure that we'll
11433 notice that in mark_used. */
11442 {
11443 /* [basic.link]: A name with no linkage (notably, the name of a class
11444 or enumeration declared in a local scope) shall not be used to
11445 declare an entity with linkage.
11447 DR 757 relaxes this restriction for C++0x. */
11450 }
11451 else
11456 {
11462 "an entity named %<main%> cannot be declared with "
11464 }
11466 /* Check if a variable is being declared as a concept. */
11468 {
11475 else
11479 }
11482 {
11485 }
11487 // Handle explicit specializations and instantiations of variable templates.
11493 }
11495 /* Create and return a canonical pointer to member function type, for
11496 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
11498 tree
11500 {
11502 tree t;
11507 /* Make sure that we always have the unqualified pointer-to-member
11508 type first. */
11510 {
11513 }
11515 /* If a canonical type already exists for this type, use it. We use
11516 this method instead of type_hash_canon, because it only does a
11517 simple equality check on the list of field members. */
11525 /* Let the front end know this is a pointer to member function. */
11533 delta_type_node);
11540 /* Zap out the name so that the back end will give us the debugging
11541 information for this anonymous RECORD_TYPE. */
11544 /* Cache this pointer-to-member type so that we can find it again
11545 later. */
11554 }
11556 /* Create and return a pointer to data member type. */
11558 tree
11560 {
11562 {
11567 }
11568 else
11569 {
11572 }
11573 }
11575 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
11576 Check to see that the definition is valid. Issue appropriate error
11577 messages. */
11579 static void
11581 {
11582 /* Avoid redundant diagnostics on out-of-class definitions. */
11584 ;
11585 /* Can't check yet if we don't know the type. */
11587 ;
11588 /* If DECL is declared constexpr, we'll do the appropriate checks
11589 in check_initializer. Similarly for inline static data members. */
11593 ;
11595 {
11598 "in-class initialization of static data member %q#D of "
11602 "%<constexpr%> needed for in-class initialization of "
11604 else
11606 "in-class initialization of static data member %q#D of "
11608 }
11609 /* Motion 10 at San Diego: If a static const integral data member is
11610 initialized with an integral constant expression, the initializer
11611 may appear either in the declaration (within the class), or in
11612 the definition, but not both. If it appears in the class, the
11613 member is a member constant. The file-scope definition is always
11614 required. */
11617 "invalid in-class initialization of static data member "
11619 type);
11622 "ISO C++ forbids in-class initialization of non-const "
11624 decl);
11627 "ISO C++ forbids initialization of member constant "
11629 }
11631 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
11632 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
11633 expressions out into temporary variables so that walk_tree doesn't
11634 step into them (c++/15764). */
11636 static tree
11638 {
11642 {
11648 }
11652 }
11654 /* Entry point for the above. */
11656 static void
11658 {
11660 /* Break out any function calls into temporary variables. */
11662 }
11664 /* Reduce a SIZEOF_EXPR to its value. */
11666 tree
11668 {
11669 tree r;
11678 else
11685 }
11687 /* Given the SIZE (i.e., number of elements) in an array, compute
11688 an appropriate index type for the array. If non-NULL, NAME is
11689 the name of the entity being declared. */
11691 static tree
11693 tsubst_flags_t complain)
11694 {
11698 /* The type of the index being computed. */
11699 tree itype;
11701 /* The original numeric size as seen in the source code before
11702 conversion to size_t. */
11708 {
11713 /* In C++98, we mark a non-constant array bound with a magic
11715 else
11716 {
11718 /* Pedantically a constant expression is required here and so
11719 __builtin_is_constant_evaluated () should fold to true if it
11720 is successfully folded into a constant. */
11726 }
11731 /* The array bound must be an integer type. */
11734 {
11740 else
11743 }
11744 }
11746 /* A type is dependent if it is...an array type constructed from any
11747 dependent type or whose size is specified by a constant expression
11748 that is value-dependent. */
11749 /* We can only call value_dependent_expression_p on integral constant
11750 expressions. */
11754 {
11755 /* Just build the index type and mark that it requires
11756 structural equality checks. */
11757 in_template:
11764 }
11767 {
11770 {
11774 else
11777 }
11779 /* We might have lost the TREE_CONSTANT flag e.g. when we are
11780 folding a conversion from a pointer to integral type. In that
11782 else
11783 /* Use the folded result for VLAs, too; it will have resolved
11784 SIZEOF_EXPR. */
11786 }
11788 /* Normally, the array-bound will be a constant. */
11790 {
11791 /* The size to use in diagnostics that reflects the constant
11792 size used in the source, rather than SIZE massaged above. */
11795 /* If the original size before conversion to size_t was signed
11796 and negative, convert it to ssizetype to restore the sign. */
11800 {
11803 /* Clear the overflow bit that may have been set as a result
11804 of the conversion from the sizetype of the new size to
11805 ssizetype. */
11807 }
11809 /* Verify that the array has a positive number of elements
11810 and issue the appropriate diagnostic if it doesn't. */
11812 {
11816 }
11817 /* As an extension we allow zero-sized arrays. */
11819 {
11821 /* We must fail if performing argument deduction (as
11822 indicated by the state of complain), so that
11823 another substitution can be found. */
11828 else
11831 }
11832 }
11834 /* We don't allow VLAs at non-function scopes, or during
11835 tentative template substitution. */
11838 {
11841 /* `(int) &fn' is not a valid array bound. */
11845 name);
11846 else
11849 }
11851 {
11855 else
11858 }
11860 {
11864 else
11867 }
11871 else
11872 {
11874 {
11875 /* A variable sized array. Arrange for the SAVE_EXPR on the inside
11876 of the MINUS_EXPR, which allows the -1 to get folded with the +1
11877 that happens when building TYPE_SIZE. */
11880 }
11882 /* Compute the index of the largest element in the array. It is
11883 one less than the number of elements in the array. We save
11884 and restore PROCESSING_TEMPLATE_DECL so that computations in
11885 cp_build_binary_op will be appropriately folded. */
11886 {
11887 processing_template_decl_sentinel s;
11889 MINUS_EXPR,
11892 complain),
11893 complain);
11895 }
11898 {
11901 {
11902 /* We have to add 1 -- in the ubsan routine we generate
11903 LE_EXPR rather than LT_EXPR. */
11908 }
11909 }
11910 /* Make sure that there was no overflow when creating to a signed
11911 index type. (For example, on a 32-bit machine, an array with
11912 size 2^32 - 1 is too big.) */
11915 {
11920 }
11921 }
11923 /* Create and return the appropriate index type. */
11926 /* If the index type were dependent, we would have returned early, so
11927 remember that it isn't. */
11931 }
11933 tree
11935 {
11937 }
11939 /* Returns the scope (if any) in which the entity declared by
11940 DECLARATOR will be located. If the entity was declared with an
11941 unqualified name, NULL_TREE is returned. */
11943 tree
11945 {
11949 /* If the declarator-id is a SCOPE_REF, the scope in which the
11950 declaration occurs is the first operand. */
11955 /* Otherwise, the declarator is not a qualified name; the entity will
11956 be declared in the current scope. */
11958 }
11960 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
11961 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
11962 with this type. */
11964 static tree
11966 {
11969 /* If things have already gone awry, bail now. */
11973 /* [dcl.type.class.deduct] prohibits forming an array of placeholder
11974 for a deduced class type. */
11976 {
11980 else
11983 }
11985 /* If there are some types which cannot be array elements,
11986 issue an error-message and return. */
11988 {
11992 else
11999 else
12006 else
12013 name);
12014 else
12020 }
12026 /* [dcl.array]
12028 The constant expressions that specify the bounds of the arrays
12029 can be omitted only for the first member of the sequence. */
12031 {
12035 name);
12036 else
12041 }
12043 /* Figure out the index type for the array. */
12045 {
12047 tf_warning_or_error);
12050 {
12053 }
12054 }
12057 }
12059 /* Returns the smallest location that is not UNKNOWN_LOCATION. */
12061 static location_t
12063 {
12069 }
12071 /* Returns the smallest location != UNKNOWN_LOCATION among the
12072 three stored in LOCATIONS[ds_const], LOCATIONS[ds_volatile],
12073 and LOCATIONS[ds_restrict]. */
12075 static location_t
12077 {
12090 }
12092 /* Returns the smallest among the latter and locations[ds_type_spec]. */
12094 static location_t
12096 {
12099 }
12101 static location_t
12103 {
12106 }
12108 /* Check that it's OK to declare a function with the indicated TYPE
12109 and TYPE_QUALS. SFK indicates the kind of special function (if any)
12110 that this function is. OPTYPE is the type given in a conversion
12111 operator declaration, or the class type for a constructor/destructor.
12112 Returns the actual return type of the function; that may be different
12113 than TYPE if an error occurs, or for certain special functions. */
12115 static tree
12117 tree type,
12118 tree optype,
12121 {
12123 {
12134 else
12146 /* We can't use the proper return type here because we run into
12147 problems with ambiguous bases and covariant returns. */
12150 else
12160 "qualifiers are not allowed on declaration of "
12172 "qualifiers are not allowed on declaration of "
12175 {
12179 }
12180 else
12190 }
12193 }
12195 /* A variable or data member (whose unqualified name is IDENTIFIER)
12196 has been declared with the indicated TYPE. If the TYPE is not
12197 acceptable, issue an error message and return a type to use for
12198 error-recovery purposes. */
12200 tree
12202 {
12204 {
12208 {
12211 identifier);
12212 }
12213 else
12216 }
12219 }
12221 /* Handle declaring DECL as an inline variable. */
12223 static void
12225 {
12228 {
12232 }
12237 {
12240 }
12241 }
12244 /* Assign a typedef-given name to a class or enumeration type declared
12245 as anonymous at first. This was split out of grokdeclarator
12246 because it is also used in libcc1. */
12248 void
12250 {
12253 /* Replace the anonymous decl with the real decl. Be careful not to
12254 rename other typedefs (such as the self-reference) of type. */
12260 /* If this is a typedef within a template class, the nested
12261 type is a (non-primary) template. The name for the
12262 template needs updating as well. */
12266 /* Adjust linkage now that we aren't unnamed anymore. */
12269 /* FIXME remangle member functions; member functions of a
12270 type with external linkage have external linkage. */
12272 /* Check that our job is done, and that it would fail if we
12273 attempted to do it again. */
12275 }
12277 /* Check that decltype(auto) was well-formed: only plain decltype(auto)
12278 is allowed. TYPE might contain a decltype(auto). Returns true if
12279 there was a problem, false otherwise. */
12281 static bool
12283 {
12285 {
12287 {
12289 {
12293 }
12295 {
12298 }
12299 }
12300 }
12302 }
12304 /* Given declspecs and a declarator (abstract or otherwise), determine
12305 the name and type of the object declared and construct a DECL node
12306 for it.
12308 DECLSPECS points to the representation of declaration-specifier
12309 sequence that precedes declarator.
12311 DECL_CONTEXT says which syntactic context this declaration is in:
12312 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
12313 FUNCDEF for a function definition. Like NORMAL but a few different
12314 error messages in each case. Return value may be zero meaning
12315 this definition is too screwy to try to parse.
12316 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
12317 handle member functions (which have FIELD context).
12318 Return value may be zero meaning this definition is too screwy to
12319 try to parse.
12320 PARM for a parameter declaration (either within a function prototype
12321 or before a function body). Make a PARM_DECL, or return void_type_node.
12322 TPARM for a template parameter declaration.
12323 CATCHPARM for a parameter declaration before a catch clause.
12324 TYPENAME if for a typename (in a cast or sizeof).
12325 Don't make a DECL node; just return the ..._TYPE node.
12326 FIELD for a struct or union field; make a FIELD_DECL.
12327 BITFIELD for a field with specified width.
12329 INITIALIZED is as for start_decl.
12331 ATTRLIST is a pointer to the list of attributes, which may be NULL
12332 if there are none; *ATTRLIST may be modified if attributes from inside
12333 the declarator should be applied to the declaration.
12335 When this function is called, scoping variables (such as
12336 CURRENT_CLASS_TYPE) should reflect the scope in which the
12337 declaration occurs, not the scope in which the new declaration will
12338 be placed. For example, on:
12340 void S::f() { ... }
12342 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
12343 should not be `S'.
12345 Returns a DECL (if a declarator is present), a TYPE (if there is no
12346 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
12347 error occurs. */
12349 tree
12355 {
12368 /* True if this declarator is a function definition. */
12372 #if 0
12373 /* See the code below that used this. */
12375 #endif
12377 /* Keep track of what sort of function is being processed
12378 so that we can warn about default return values, or explicit
12379 return values which do not match prescribed defaults. */
12385 /* cv-qualifiers that apply to the declarator, for a declaration of
12386 a member function. */
12388 /* virt-specifiers that apply to the declarator, for a declaration of
12389 a member function. */
12391 /* ref-qualifier that applies to the declarator, for a declaration of
12392 a member function. */
12394 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
12401 /* The unqualified name of the declarator; either an
12402 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
12403 tree unqualified_id;
12404 /* The class type, if any, in which this entity is located,
12405 or NULL_TREE if none. Note that this value may be different from
12406 the current class type; for example if an attempt is made to declare
12407 "A::f" inside "B", this value will be "A". */
12409 /* The NAMESPACE_DECL for the namespace in which this entity is
12410 located. If an unqualified name is used to declare the entity,
12411 this value will be NULL_TREE, even if the entity is located at
12412 namespace scope. */
12414 cp_storage_class storage_class;
12437 // Was concept_p specified? Note that ds_concept
12438 // implies ds_constexpr!
12460 location_t id_loc;
12461 location_t init_loc;
12463 {
12466 }
12467 else
12470 /* Look inside a declarator for the name being declared
12471 and get it as a string, for an error message. */
12473 id_declarator;
12475 {
12480 {
12484 {
12488 }
12492 {
12498 {
12503 {
12504 /* [dcl.meaning]
12506 A declarator-id shall not be qualified except
12507 for ...
12509 None of the cases are permitted in block
12510 scope. */
12513 decl);
12517 else
12521 }
12523 {
12526 {
12530 }
12532 && current_class_type
12534 current_class_type))
12535 {
12540 }
12541 }
12544 }
12546 {
12548 {
12550 {
12554 }
12557 {
12561 }
12568 }
12572 {
12578 }
12579 /* Fall through. */
12586 {
12588 dname);
12590 }
12593 else
12594 {
12601 else
12603 }
12608 }
12610 }
12627 }
12630 }
12632 /* [dcl.fct.edf]
12634 The declarator in a function-definition shall have the form
12635 D1 ( parameter-declaration-clause) ... */
12637 {
12640 }
12645 {
12648 }
12651 {
12654 {
12657 }
12660 {
12662 {
12665 }
12667 {
12670 }
12671 }
12672 }
12674 /* Anything declared one level down from the top level
12675 must be one of the parameters of a function
12676 (because the body is at least two levels down). */
12678 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
12679 by not allowing C++ class definitions to specify their parameters
12680 with xdecls (must be spec.d in the parmlist).
12682 Since we now wait to push a class scope until we are sure that
12683 we are in a legitimate method context, we must set oldcname
12684 explicitly (since current_class_name is not yet alive).
12686 We also want to avoid calling this a PARM if it is in a namespace. */
12689 {
12695 }
12701 {
12705 }
12708 {
12712 }
12715 {
12719 }
12722 {
12726 }
12729 {
12733 }
12735 /* [dcl.spec]/2 "At most one of the constexpr, consteval, and constinit
12736 keywords shall appear in a decl-specifier-seq." */
12738 {
12742 "can use at most one of the %<constinit%> and %<constexpr%> "
12745 }
12747 /* If there were multiple types specified in the decl-specifier-seq,
12748 issue an error message. */
12750 {
12754 }
12759 /* Extract the basic type from the decl-specifier-seq. */
12762 {
12765 }
12767 /* Ignore erroneous attributes. */
12771 /* An object declared as __attribute__((unavailable)) suppresses
12772 any reports of being declared with unavailable or deprecated
12773 items. An object declared as __attribute__((deprecated))
12774 suppresses warnings of uses of other deprecated items. */
12783 {
12789 }
12790 /* No type at all: default to `int', and set DEFAULTED_INT
12791 because it was not a user-defined typedef. */
12793 {
12795 {
12796 /* These imply 'int'. */
12799 }
12800 /* If we just have "complex", it is equivalent to "complex double". */
12803 {
12806 "ISO C++ does not support plain %<complex%> meaning "
12808 }
12809 }
12810 /* Gather flags. */
12814 #if 0
12815 /* See the code below that used this. */
12818 #endif
12823 else
12827 {
12829 ctor_return_type,
12830 type_quals,
12833 }
12835 {
12840 /* We handle `main' specially here, because 'main () { }' is so
12841 common. With no options, it is allowed. With -Wreturn-type,
12842 it is a warning. It is only an error with -pedantic-errors. */
12843 is_main = (funcdef_flag
12856 name);
12860 else
12865 /* FIXME we should be able to propagate the error_mark_node as is
12866 for other contexts too. */
12868 else
12870 }
12875 {
12877 {
12882 }
12883 /* Don't pedwarn if the alternate "__intN__" form has been used instead
12884 of "__intN". */
12889 }
12891 /* Now process the modifiers that were specified
12892 and check for invalid combinations. */
12894 /* Long double is a special combination. */
12896 {
12900 }
12902 /* Check all other uses of type modifiers. */
12905 {
12906 location_t loc;
12909 {
12912 }
12914 {
12917 }
12919 {
12922 }
12924 {
12927 }
12929 {
12932 }
12937 {
12942 }
12944 {
12948 }
12958 {
12960 {
12965 /* PR108099: __int128_t comes from c_common_nodes_and_builtins,
12966 and is not built as a typedef. */
12969 }
12972 else
12974 }
12975 else
12978 /* Discard the type modifiers if they are invalid. */
12980 {
12986 }
12987 }
12989 /* Decide whether an integer type is signed or not.
12990 Optionally treat bitfields as signed by default. */
12992 /* [class.bit]
12994 It is implementation-defined whether a plain (neither
12995 explicitly signed or unsigned) char, short, int, or long
12996 bit-field is signed or unsigned.
12998 Naturally, we extend this to long long as well. Note that
12999 this does not include wchar_t. */
13001 && !signed_p
13002 /* A typedef for plain `int' without `signed' can be
13003 controlled just like plain `int', but a typedef for
13004 `signed int' cannot be so controlled. */
13005 && !(typedef_decl
13009 {
13022 else
13024 }
13039 {
13043 /* If a modifier is specified, the resulting complex is the complex
13044 form of TYPE. E.g, "complex short" is "complex short int". */
13053 else
13055 }
13057 /* If we're using the injected-class-name to form a compound type or a
13058 declaration, replace it with the underlying class so we don't get
13059 redundant typedefs in the debug output. But if we are returning the
13060 type unchanged, leave it alone so that it's available to
13061 maybe_get_template_decl_from_type_decl. */
13069 type = cp_build_qualified_type
13073 /* We might have ignored or rejected some of the qualifiers. */
13078 /* Placeholder in parm gets a better error below. */
13082 {
13083 auto_diagnostic_group g;
13087 "for deduction, template placeholder must be followed "
13091 }
13102 /* Treat class-scope deduction guides as static member functions
13103 so that they get a FUNCTION_TYPE instead of a METHOD_TYPE. */
13107 {
13109 {
13116 }
13118 {
13122 "declared both %<virtual%> and %<constexpr%> only in "
13124 }
13125 }
13128 /* Issue errors about use of storage classes for parameters. */
13130 {
13132 {
13136 }
13138 {
13142 name);
13144 }
13148 {
13153 }
13155 /* Function parameters cannot be concept. */
13157 {
13162 }
13163 /* Function parameters cannot be constexpr. If we saw one, moan
13164 and pretend it wasn't there. */
13166 {
13170 }
13172 {
13176 }
13178 {
13182 }
13183 }
13185 /* Give error if `virtual' is used outside of class declaration. */
13188 {
13192 }
13195 {
13212 "structured binding declaration can be %qs only in "
13214 declspecs->gnu_thread_keyword_p
13219 /* [dcl.struct.bind] "A cv that includes volatile is deprecated." */
13224 {
13234 "structured binding declaration can be %qs only in "
13251 }
13254 {
13256 {
13257 auto_diagnostic_group d;
13261 "type must be cv-qualified %<auto%> or reference to "
13263 }
13266 }
13269 "structured binding declaration cannot have constrained "
13277 {
13280 }
13281 }
13283 /* Static anonymous unions are dealt with here. */
13289 /* Warn about storage classes that are invalid for certain
13290 kinds of declarations (parameters, typenames, etc.). */
13292 && ((storage_class
13296 {
13297 location_t loc
13302 }
13307 {
13311 ;
13313 ;
13315 /* C++ allows static class elements. */
13317 /* C++ also allows inlines and signed and unsigned elements,
13318 but in those cases we don't come in here. */
13319 ;
13320 else
13321 {
13322 location_t loc
13329 else
13336 }
13337 }
13342 {
13346 }
13350 {
13356 /* When thread_local is applied to a variable of block scope the
13357 storage-class-specifier static is implied if it does not appear
13358 explicitly. */
13361 }
13364 {
13367 "storage class specifiers invalid in friend function "
13371 }
13375 else
13376 {
13379 {
13392 }
13393 }
13397 {
13399 auto_diagnostic_group d;
13404 }
13409 /* Skip over build_memfn_type when a FUNCTION_DECL is an xobj memfn. */
13411 /* Determine the type of the entity declared by recurring on the
13412 declarator. */
13414 {
13416 tree attrs;
13423 {
13435 /* Assume that any attributes that get applied late to
13436 templates will DTRT when applied to the declaration
13437 as a whole. */
13441 attrs),
13442 attr_flags);
13444 }
13448 /* Check that contracts aren't misapplied. */
13454 /* We don't want to warn in parameter context because we don't
13455 yet know if the parse will succeed, and this might turn out
13456 to be a constructor call. */
13459 && !typedef_p
13461 /* If the type is class-like and the inner name used a
13462 global namespace qualifier, we need the parens.
13463 Unfortunately all we can tell is whether a qualified name
13464 was used or not. */
13465 && !(inner_declarator
13470 {
13471 auto_diagnostic_group d;
13474 name))
13475 {
13480 }
13481 }
13486 {
13497 /* [dcl.array]/1:
13499 The optional attribute-specifier-seq appertains to the
13500 array type. */
13505 {
13506 tree arg_types;
13509 /* Declaring a function type. */
13511 /* Pick up type qualifiers which should be applied to `this'. */
13513 /* Pick up virt-specifiers. */
13515 /* And ref-qualifier, too */
13517 /* And tx-qualifier. */
13519 /* Pick up the exception specifications. */
13521 /* If the exception-specification is ill-formed, let's pretend
13522 there wasn't one. */
13527 {
13528 /* There is no need to iterate over the list,
13529 only the first parm can be a valid xobj parm. */
13532 /* If we make it here, we are looking at an xobj parm.
13534 Non-null 'purpose' usually means the parm has a default
13535 argument, we don't want to violate this assumption. */
13538 };
13540 tree xobj_parm
13546 "explicit object member function only available "
13550 {
13551 /* We inform in every case, just differently depending on what
13552 case it is. */
13553 auto_diagnostic_group d;
13555 /* If declarator->kind is cdk_function and we are at the end of
13556 the declarator chain, we are looking at a function type. */
13558 {
13560 "a function type cannot "
13563 }
13566 "a pointer to function type cannot "
13570 "a pointer to member function type "
13572 else
13575 /* The locations being used here are probably not correct. */
13578 "the type of a pointer to explicit object member "
13580 else
13582 "the type of an explicit object "
13584 /* Ideally we should synthesize the correct syntax
13585 for the user, perhaps this could be added later. */
13586 }
13587 /* Since a valid xobj parm has its purpose cleared in find_xobj_parm
13588 the first parm node will never erroneously be detected here. */
13589 {
13590 auto_diagnostic_group d;
13595 {
13600 gcc_rich_location bad_xobj_parm
13603 "only the first parameter of a member function "
13605 }
13609 }
13615 /* Say it's a definition only for the CALL_EXPR
13616 closest to the identifier. */
13619 /* Handle a late-specified return type. */
13622 {
13624 {
13631 {
13632 auto_diagnostic_group d;
13634 "%<auto%> type specifier without "
13637 "deduced return type only available "
13639 }
13641 {
13645 }
13646 }
13648 {
13650 "return type has %qT as its type rather "
13653 }
13655 {
13658 "%qs function with trailing return type "
13659 "has %<decltype(auto)%> as its type "
13661 else
13665 }
13671 {
13673 {
13674 auto_diagnostic_group g;
13681 }
13683 {
13684 auto_diagnostic_group d;
13686 "for %qT must have trailing return "
13691 }
13697 else
13701 }
13702 }
13705 {
13709 /* Not using maybe_warn_cpp0x because this should
13710 always be an error. */
13712 "trailing return type only available "
13714 else
13716 "return type not declared with %<auto%> "
13719 }
13721 {
13724 }
13730 {
13733 }
13736 {
13737 /* It's wrong, for instance, to issue a -Wignored-qualifiers
13738 warning for
13739 static_assert(!is_same_v<void(*)(), const void(*)()>);
13740 because there the qualifier matters. */
13744 /* [dcl.fct] "A volatile-qualified return type is
13745 deprecated." */
13748 "%<volatile%>-qualified return type is "
13751 /* We now know that the TYPE_QUALS don't apply to the
13752 decl, but to its return type. */
13754 }
13756 /* Error about some types functions can't return. */
13759 {
13763 }
13765 {
13769 }
13771 {
13773 "%<constinit%> on function return type is not "
13776 }
13783 && funcdecl_p
13789 {
13790 /* We are within a class's scope. If our declarator name
13791 is the same as the class name, and we are defining
13792 a function, then it is a constructor/destructor, and
13793 therefore returns a void type. */
13795 /* ISO C++ 12.4/2. A destructor may not be declared
13796 const or volatile. A destructor may not be static.
13797 A destructor may not be declared with ref-qualifier.
13799 ISO C++ 12.1. A constructor may not be declared
13800 const or volatile. A constructor may not be
13801 virtual. A constructor may not be static.
13802 A constructor may not be declared with ref-qualifier. */
13811 {
13816 }
13819 {
13825 }
13829 current_class_type,
13830 flags))
13834 {
13835 /* It's a constructor. */
13839 {
13843 }
13847 }
13850 }
13852 {
13854 {
13855 /* Cannot be both friend and virtual. */
13860 }
13865 {
13867 "cannot define friend function %qs in a local "
13870 }
13871 /* [class.friend]/6: A function can be defined in a friend
13872 declaration if the function name is unqualified. */
13874 {
13877 "friend function definition %qs cannot have "
13879 else
13881 "friend function definition %qs cannot have "
13883 in_namespace);
13884 }
13885 }
13887 {
13889 {
13892 }
13893 }
13895 {
13898 }
13901 {
13904 && (in_namespace
13907 "a non-member function cannot have "
13909 else
13910 {
13912 {
13913 auto_diagnostic_group d;
13915 "an explicit object member function cannot "
13920 }
13922 {
13923 auto_diagnostic_group d;
13925 "an explicit object member function cannot "
13929 }
13934 "%qD cannot be an explicit object member "
13936 }
13937 }
13943 pushed_scope
13955 {
13961 }
13967 {
13969 /* transaction_safe applies to the type, but
13970 transaction_safe_dynamic applies to the function. */
13973 else
13975 }
13977 /* Actually apply the contract attributes to the declaration. */
13979 {
13982 {
13984 /* Intentionally reverse order of contracts so they're
13985 reversed back into their lexical order. */
13988 }
13989 else
13991 }
13994 /* [dcl.fct]/2:
13996 The optional attribute-specifier-seq appertains to
13997 the function type. */
14002 }
14008 /* Filter out pointers-to-references and references-to-references.
14009 We can get these if a TYPE_DECL is used. */
14012 {
14014 {
14017 }
14019 /* In C++0x, we allow reference to reference declarations
14020 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
14021 and template type arguments [14.3.1/4 temp.arg.type]. The
14022 check for direct reference to reference declarations, which
14023 are still forbidden, occurs below. Reasoning behind the change
14024 can be found in DR106, DR540, and the rvalue reference
14025 proposals. */
14027 {
14030 }
14031 }
14033 {
14038 }
14040 /* We now know that the TYPE_QUALS don't apply to the decl,
14041 but to the target of the pointer. */
14044 /* This code used to handle METHOD_TYPE, but I don't think it's
14045 possible to get it here anymore. */
14049 {
14053 memfn_quals,
14054 rqual);
14060 }
14068 type);
14070 /* When the pointed-to type involves components of variable size,
14071 care must be taken to ensure that the size evaluation code is
14072 emitted early enough to dominate all the possible later uses
14073 and late enough for the variables on which it depends to have
14074 been assigned.
14076 This is expected to happen automatically when the pointed-to
14077 type has a name/declaration of it's own, but special attention
14078 is required if the type is anonymous.
14080 We handle the NORMAL and FIELD contexts here by inserting a
14081 dummy statement that just evaluates the size at a safe point
14082 and ensures it is not deferred until e.g. within a deeper
14083 conditional context (c++/43555).
14085 We expect nothing to be needed here for PARM or TYPENAME.
14086 Evaluating the size at this point for TYPENAME would
14087 actually be incorrect, as we might be in the middle of an
14088 expression with side effects on the pointed-to type size
14089 "arguments" prior to the pointer declaration point and the
14090 size evaluation could end up prior to the side effects. */
14096 {
14100 }
14103 {
14104 /* In C++0x, the type we are creating a reference to might be
14105 a typedef which is itself a reference type. In that case,
14106 we follow the reference collapsing rules in
14107 [7.1.3/8 dcl.typedef] to create the final reference type:
14109 "If a typedef TD names a type that is a reference to a type
14110 T, an attempt to create the type 'lvalue reference to cv TD'
14111 creates the type 'lvalue reference to T,' while an attempt
14112 to create the type "rvalue reference to cv TD' creates the
14113 type TD."
14114 */
14118 {
14121 else
14123 }
14124 else
14125 type = cp_build_reference_type
14128 /* In C++0x, we need this check for direct reference to
14129 reference declarations, which are forbidden by
14130 [8.3.2/5 dcl.ref]. Reference to reference declarations
14131 are only allowed indirectly through typedefs and template
14132 type arguments. Example:
14134 void foo(int & &); // invalid ref-to-ref decl
14136 typedef int & int_ref;
14137 void foo(int_ref &); // valid ref-to-ref decl
14138 */
14142 }
14146 {
14150 /* We will already have complained. */
14152 else
14154 type);
14155 }
14156 else
14159 /* Process a list of type modifier keywords (such as
14160 const or volatile) that were given inside the `*' or `&'. */
14163 {
14164 type
14168 }
14170 /* Apply C++11 attributes to the pointer, and not to the
14171 type pointed to. This is unlike what is done for GNU
14172 attributes above. It is to comply with [dcl.ptr]/1:
14174 [the optional attribute-specifier-seq (7.6.1) appertains
14175 to the pointer and not to the object pointed to]. */
14188 }
14189 }
14194 /* Don't check this if it can be the artifical decltype(auto)
14195 we created when building a constraint in a compound-requirement:
14196 that the type-constraint is plain is going to be checked in
14197 cp_parser_compound_requirement. */
14202 /* A `constexpr' specifier used in an object declaration declares
14203 the object as `const'. */
14205 {
14206 /* DR1688 says that a `constexpr' specifier in combination with
14207 `volatile' is valid. */
14210 {
14213 }
14214 }
14219 {
14221 unqualified_id);
14223 }
14225 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
14226 qualified with a class-name, turn it into a METHOD_TYPE, unless
14227 we know that the function is static. We take advantage of this
14228 opportunity to do other processing that pertains to entities
14229 explicitly declared to be class members. Note that if DECLARATOR
14230 is non-NULL, we know it is a cdk_id declarator; otherwise, we
14231 would not have exited the loop above. */
14236 {
14242 {
14244 {
14246 "member functions are implicitly "
14249 }
14250 else
14253 }
14255 can skip the following checks. */
14258 qualifying type must certainly be complete. */
14259 funcdef_flag
14260 /* A friend declaration of "T::f" is OK, even if
14261 "T" is a template parameter. But, if this
14262 function is not a friend, the qualifying type
14263 must be a class. */
14265 /* For a declaration, the type need not be
14266 complete, if either it is dependent (since there
14267 is no meaningful definition of complete in that
14268 case) or the qualifying class is currently being
14269 defined. */
14272 /* Check that the qualifying type is complete. */
14276 {
14279 {
14287 }
14288 }
14290 {
14294 }
14295 }
14300 /* Now TYPE has the actual type. */
14303 {
14306 else
14308 }
14314 {
14315 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
14316 a declarator-id appertains to the entity that is declared. */
14319 else
14320 /* We should have already diagnosed the issue (c++/78344). */
14322 }
14324 /* Handle parameter packs. */
14326 {
14328 /* Turn the type into a pack expansion.*/
14330 else
14332 }
14335 && !processing_template_decl
14337 {
14341 else
14345 }
14348 {
14349 /* [dcl.fct.spec] (C++11) The explicit specifier shall be used only
14350 in the declaration of a constructor or conversion function within
14351 a class definition. */
14358 else
14360 "only declarations of constructors and conversion operators "
14363 }
14366 {
14369 {
14371 name);
14373 }
14375 {
14378 name);
14380 }
14382 {
14384 name);
14386 }
14388 {
14390 name);
14392 }
14394 {
14396 name);
14398 }
14400 {
14402 name);
14404 }
14405 }
14407 /* If this is declaring a typedef name, return a TYPE_DECL. */
14409 {
14411 tree decl;
14414 {
14418 else
14422 }
14424 /* This declaration:
14426 typedef void f(int) const;
14428 declares a function type which is not a member of any
14429 particular class, but which is cv-qualified; for
14430 example "f S::*" declares a pointer to a const-qualified
14431 member function of S. We record the cv-qualification in the
14432 function type. */
14434 {
14437 /* We have now dealt with these qualifiers. */
14440 }
14443 {
14447 else
14451 }
14457 {
14460 }
14464 else
14468 {
14472 /* The TYPE_DECL is "abstract" because there will be
14473 clones of this constructor/destructor, and there will
14474 be copies of this TYPE_DECL generated in those
14475 clones. The decloning optimization (for space) may
14476 revert this subsequently if it determines that
14477 the clones should share a common implementation. */
14481 }
14486 unqualified_id);
14488 /* If the user declares "typedef struct {...} foo" then the
14489 struct will have an anonymous name. Fill that name in now.
14490 Nothing can refer to it, so nothing needs know about the name
14491 change. */
14493 && unqualified_id
14512 /* Acknowledge that this was written:
14513 `using analias = atype;'. */
14517 }
14519 /* Detect the case of an array type of unspecified size
14520 which came, as such, direct from a typedef name.
14521 We must copy the type, so that the array's domain can be
14522 individually set by the object's initializer. */
14529 /* Detect where we're using a typedef of function type to declare a
14530 function. PARMS will not be set, so we must create it now. */
14533 {
14535 tree args;
14540 {
14546 }
14551 {
14552 /* The qualifiers on the function type become the qualifiers on
14553 the non-static member function. */
14558 }
14559 }
14561 /* If this is a type name (such as, in a cast or sizeof),
14562 compute the type and return it now. */
14565 {
14566 /* Note that here we don't care about type_quals. */
14568 /* Special case: "friend class foo" looks like a TYPENAME context. */
14570 {
14572 {
14575 }
14578 {
14579 /* Don't allow friend declaration without a class-key. */
14586 else
14589 type);
14590 }
14592 /* Only try to do this stuff if we didn't already give up. */
14594 {
14595 /* A friendly class? */
14599 else
14601 type);
14604 }
14605 }
14607 {
14614 /* Core issue #547: need to allow this in template type args.
14615 Allow it in general in C++11 for alias-declarations. */
14619 else
14621 }
14627 }
14631 && ! bitfield
14633 {
14636 }
14639 {
14640 /* Only functions may be declared using an operator-function-id. */
14642 {
14645 }
14650 type);
14651 }
14653 /* We don't check parameter types here because we can emit a better
14654 error message later. */
14656 {
14660 }
14662 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
14663 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
14666 {
14672 {
14675 {
14680 {
14681 auto_diagnostic_group g;
14685 "missing template argument list after %qE; template "
14691 }
14695 else
14696 /* Do not issue an error while tentatively parsing a function
14697 parameter: for T t(auto(a), 42);, when we just saw the 1st
14698 parameter, we don't know yet that this construct won't be
14699 a function declaration. Defer the checking to
14700 cp_parser_parameter_declaration_clause. */
14702 }
14703 else
14707 }
14709 /* A parameter declared as an array of T is really a pointer to T.
14710 One declared as a function is really a pointer to a function.
14711 One declared as a member is really a pointer to member. */
14714 {
14715 /* Transfer const-ness of array into that of type pointed to. */
14719 }
14722 }
14725 /* Don't convert xobj member functions to METHOD_TYPE. */
14726 && !is_xobj_member_function
14727 && !(unqualified_id
14730 {
14736 }
14738 {
14742 {
14750 }
14752 {
14755 {
14761 else
14765 }
14767 /* The C99 flexible array extension. */
14770 {
14777 else
14778 {
14779 /* Array is a flexible member. */
14783 else
14787 /* Flexible array member has a null domain. */
14789 }
14790 }
14793 {
14794 /* Happens when declaring arrays of sizes which
14795 are error_mark_node, for example. */
14797 }
14799 {
14800 /* Something like struct S { int N::j; }; */
14803 }
14805 {
14807 tree function_context;
14810 {
14811 /* This should never happen in pure C++ (the check
14812 could be an assert). It could happen in
14813 Objective-C++ if someone writes invalid code that
14814 uses a function declaration for an instance
14815 variable or property (instance variables and
14816 properties are parsed as FIELD_DECLs, but they are
14817 part of an Objective-C class, not a C++ class).
14818 That code is invalid and is caught by this
14819 check. */
14821 {
14823 unqualified_id);
14825 }
14827 /* ``A union may [ ... ] not [ have ] virtual functions.''
14828 ARM 9.5 */
14830 {
14833 unqualified_id);
14835 }
14840 {
14842 "%qD cannot be declared %<virtual%>, since it "
14845 }
14846 }
14848 /* Check that the name used for a destructor makes sense. */
14850 {
14854 {
14859 }
14862 {
14866 }
14868 {
14872 }
14874 {
14876 "%<constexpr%> destructors only available"
14879 }
14881 {
14885 }
14886 }
14888 {
14893 }
14896 {
14900 }
14902 {
14906 }
14910 {
14914 }
14917 {
14920 {
14921 auto_diagnostic_group d;
14927 }
14928 }
14930 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
14931 function_context
14940 parms,
14941 unqualified_id,
14942 declspecs,
14943 reqs,
14956 #if 0
14957 /* This clobbers the attrs stored in `decl' from `attrlist'. */
14958 /* The decl and setting of decl_attr is also turned off. */
14960 #endif
14962 /* [class.conv.ctor]
14964 A constructor declared without the function-specifier
14965 explicit that can be called with a single parameter
14966 specifies a conversion from the type of its first
14967 parameter to the type of its class. Such a constructor
14968 is called a converting constructor. */
14974 }
14976 && ((current_class_type
14982 {
14985 {
14987 {
14988 auto_diagnostic_group d;
14992 }
14993 else
14998 }
14999 }
15001 staticp
15002 ? TCTX_STATIC_STORAGE
15004 {
15007 }
15008 else
15009 {
15011 {
15014 "%qE is neither function nor member function; "
15016 else
15020 }
15022 }
15025 {
15026 /* Packages tend to use GNU attributes on friends, so we only
15027 warn for standard attributes. */
15029 && !funcdef_flag
15032 {
15034 auto_diagnostic_group d;
15038 }
15039 /* Friends are treated specially. */
15043 {
15047 /* Kludge: We need funcdef_flag to be true in do_friend for
15048 in-class defaulted functions, but that breaks grokfndecl.
15049 So set it here. */
15059 }
15060 else
15062 }
15064 /* Structure field. It may not be a function, except for C++. */
15067 {
15069 {
15070 /* C++ allows static class members. All other work
15071 for this is done by grokfield. */
15076 {
15078 template_count,
15082 }
15089 {
15091 "%<constexpr%> static data member %qD must "
15094 }
15105 /* Even if there is an in-class initialization, DECL
15106 is considered undefined until an out-of-class
15107 definition is provided, unless this is an inline
15108 variable. */
15112 {
15118 }
15120 /* Set the constraints on the declaration. */
15124 {
15127 }
15128 }
15129 else
15130 {
15132 {
15138 }
15140 {
15145 }
15147 {
15152 }
15154 {
15159 }
15166 {
15169 }
15172 {
15173 /* An attempt is being made to initialize a non-static
15174 member. This is new in C++11. */
15177 /* If this has been parsed with static storage class, but
15178 errors forced staticp to be cleared, ensure NSDMI is
15179 not present. */
15182 }
15183 }
15190 }
15191 }
15193 {
15194 tree original_name;
15202 else
15204 // FIXME:gcc_assert (original_name == dname);
15212 name);
15214 {
15218 name);
15219 else
15221 "storage class %<thread_local%> invalid for "
15223 }
15231 /* Function declaration not at top level.
15232 Storage classes other than `extern' are not allowed
15233 and `extern' makes no difference. */
15238 {
15241 "%<static%> specifier invalid for function %qs "
15243 else
15245 "%<inline%> specifier invalid for function %qs "
15247 }
15250 {
15252 {
15255 }
15258 {
15263 }
15264 }
15268 {
15272 }
15274 /* Record whether the function is public. */
15279 declspecs,
15282 publicp,
15287 funcdef_flag,
15288 late_return_type_p,
15290 id_loc);
15297 {
15300 /* Don't allow a static member function in a class, and forbid
15301 declaring main to be static. */
15303 {
15307 }
15309 {
15310 /* 7.1.1: There can be no static function declarations within a
15311 block. */
15315 }
15318 {
15321 }
15322 }
15325 }
15326 else
15327 {
15328 /* It's a variable. */
15330 /* An uninitialized decl with `extern' is a reference. */
15332 declspecs,
15333 initialized,
15334 type_quals,
15335 inlinep,
15336 concept_p,
15337 template_count,
15339 id_loc);
15349 {
15352 {
15354 "%<static%> may not be used when defining "
15358 }
15360 {
15363 }
15365 {
15367 "cannot explicitly declare member %q#D to have "
15370 }
15371 }
15373 {
15375 "declaration of %<constexpr%> variable %qD "
15378 }
15380 {
15384 }
15389 {
15394 }
15395 }
15400 {
15404 }
15407 {
15409 {
15410 /* It's common practice (and completely valid) to have a const
15411 be initialized and declared extern. */
15415 }
15416 else
15417 {
15421 }
15422 }
15424 /* Record `register' declaration for warnings on &
15425 and in case doing stupid register allocation. */
15428 {
15430 /* Warn about register storage specifiers on PARM_DECLs. */
15432 {
15435 "ISO C++17 does not allow %<register%> storage "
15437 else
15440 }
15441 }
15448 {
15449 /* Set constexpr flag on vars (functions got it in grokfndecl). */
15452 /* And the constinit flag (which only applies to variables). */
15455 }
15457 {
15458 /* If we saw a return type, record its location. */
15463 {
15469 }
15472 }
15474 /* Record constancy and volatility on the DECL itself . There's
15475 no need to do this when processing a template; we'll do this
15476 for the instantiated declaration based on the type of DECL. */
15478 /* Don't do it for instantiated variable templates either,
15479 cp_apply_type_quals_to_decl should have been called on it
15480 already and might have been overridden in cp_finish_decl
15481 if initializer needs runtime initialization. */
15486 }
15487 }
15488 \f
15489 /* Subroutine of start_function. Ensure that each of the parameter
15490 types (as listed in PARMS) is complete, as is required for a
15491 function definition. */
15493 static void
15495 {
15497 {
15502 {
15509 }
15510 else
15511 /* grokparms or complete_type_or_else will have already issued
15512 an error. */
15514 }
15515 }
15517 /* Returns nonzero if T is a local variable. */
15519 int
15521 {
15530 }
15532 /* Like local_variable_p, but suitable for use as a tree-walking
15533 function. */
15535 static tree
15538 {
15540 {
15541 /* DR 2082 permits local variables in unevaluated contexts
15542 within a default argument. */
15545 }
15554 }
15556 /* Check that ARG, which is a default-argument expression for a
15557 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
15558 something goes wrong. DECL may also be a _TYPE node, rather than a
15559 DECL, if there is no DECL available. */
15561 tree
15563 {
15564 tree var;
15565 tree decl_type;
15568 /* We get a DEFERRED_PARSE when looking at an in-class declaration
15569 with a default argument. Ignore the argument for now; we'll
15570 deal with it after the class is complete. */
15574 {
15577 }
15578 else
15585 /* Something already went wrong. There's no need to check
15586 further. */
15589 /* [dcl.fct.default]
15591 A default argument expression is implicitly converted to the
15592 parameter type. */
15594 /* Avoid digest_init clobbering the initializer. */
15597 LOOKUP_IMPLICIT);
15600 /* Avoid redundant -Wzero-as-null-pointer-constant warnings at
15601 the call sites. */
15604 /* Don't lose side-effects as in PR90473. */
15608 /* [dcl.fct.default]
15610 Local variables shall not be used in default argument
15611 expressions.
15613 The keyword `this' shall not be used in a default argument of a
15614 member function. */
15617 {
15619 {
15623 else
15625 }
15627 }
15629 /* All is well. */
15631 }
15633 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
15635 static tree
15637 {
15642 {
15645 else
15646 {
15649 }
15650 }
15652 /* Do warn about using typedefs to a deprecated class. */
15664 return type_is_deprecated
15668 }
15670 /* Returns an unavailable type used within TYPE, or NULL_TREE if none. */
15672 static tree
15674 {
15679 {
15682 else
15683 {
15686 }
15687 }
15689 /* Do warn about using typedefs to a deprecated class. */
15701 return type_is_unavailable
15705 }
15707 /* Decode the list of parameter types for a function type.
15708 Given the list of things declared inside the parens,
15709 return a list of types.
15711 If this parameter does not end with an ellipsis, we append
15712 void_list_node.
15714 *PARMS is set to the chain of PARM_DECLs created. */
15716 tree
15718 {
15721 tree parm;
15725 {
15734 {
15737 }
15741 {
15743 && !init
15746 /* DR 577: A parameter list consisting of a single
15747 unnamed parameter of non-dependent type 'void'. */
15751 "invalid use of cv-qualified type %qT in "
15753 else
15755 "invalid use of type %<void%> in parameter "
15757 /* It's not a good idea to actually create parameters of
15758 type `void'; other parts of the compiler assume that a
15759 void type terminates the parameter list. */
15762 }
15765 {
15767 {
15771 }
15774 {
15778 }
15780 /* [dcl.fct] "A parameter with volatile-qualified type is
15781 deprecated." */
15784 "%<volatile%>-qualified parameter is "
15787 /* Top-level qualifiers on the parameters are
15788 ignored for function types. */
15791 {
15795 }
15797 {
15798 /* Before C++17 DR 393:
15799 [dcl.fct]/6, parameter types cannot contain pointers
15800 (references) to arrays of unknown bound. */
15805 {
15813 }
15816 ptr
15822 }
15826 }
15831 }
15841 /* We had parm errors, recover by giving the function (...) type. */
15845 }
15847 \f
15848 /* D is a constructor or overloaded `operator='.
15850 Let T be the class in which D is declared. Then, this function
15851 returns:
15853 -1 if D's is an ill-formed constructor or copy assignment operator
15854 whose first parameter is of type `T'.
15855 0 if D is not a copy constructor or copy assignment
15856 operator.
15857 1 if D is a copy constructor or copy assignment operator whose
15858 first parameter is a reference to non-const qualified T.
15859 2 if D is a copy constructor or copy assignment operator whose
15860 first parameter is a reference to const qualified T.
15862 This function can be used as a predicate. Positive values indicate
15863 a copy constructor and nonzero values indicate a copy assignment
15864 operator. */
15866 int
15868 {
15869 tree args;
15870 tree arg_type;
15878 /* Instantiations of template member functions are never copy
15879 functions. Note that member functions of templated classes are
15880 represented as template functions internally, and we must
15881 accept those as copy functions. */
15889 {
15893 /* Reject unrelated object parameters. */
15898 }
15899 else
15909 {
15910 /* Pass by value copy assignment operator. */
15912 }
15916 {
15919 }
15920 else
15926 /* There are more non-optional args. */
15930 }
15932 /* D is a constructor or overloaded `operator='.
15934 Let T be the class in which D is declared. Then, this function
15935 returns true when D is a move constructor or move assignment
15936 operator, false otherwise. */
15938 bool
15940 {
15942 /* There are no move constructors if we are in C++98 mode. */
15948 /* Instantiations of template member functions are never move
15949 functions. Note that member functions of templated classes are
15950 represented as template functions internally, and we must
15951 accept those as move functions. */
15955 }
15957 /* D is a constructor or overloaded `operator='.
15959 Then, this function returns true when D has the same signature as a move
15960 constructor or move assignment operator (because either it is such a
15961 ctor/op= or it is a template specialization with the same signature),
15962 false otherwise. */
15964 bool
15966 {
15967 tree args;
15968 tree arg_type;
15976 {
15980 /* Reject unrelated object parameters. */
15985 }
15986 else
16004 /* There are more non-optional args. */
16008 }
16010 /* Remember any special properties of member function DECL. */
16012 void
16014 {
16015 tree class_type;
16023 {
16030 {
16031 /* [class.copy]
16033 A non-template constructor for class X is a copy
16034 constructor if its first parameter is of type X&, const
16035 X&, volatile X& or const volatile X&, and either there
16036 are no other parameters or else all other parameters have
16037 default arguments. */
16041 }
16052 }
16054 {
16055 /* [class.copy]
16057 A non-template assignment operator for class X is a copy
16058 assignment operator if its parameter is of type X, X&, const
16059 X&, volatile X& or const volatile X&. */
16064 {
16068 }
16069 }
16073 /* Destructors are handled in check_methods. */
16074 }
16076 /* Check a constructor DECL has the correct form. Complains
16077 if the class has a constructor of the form X(X). */
16079 bool
16081 {
16085 {
16086 /* [class.copy]
16088 A declaration of a constructor for a class X is ill-formed if
16089 its first parameter is of type (optionally cv-qualified) X
16090 and either there are no other parameters or else all other
16091 parameters have default arguments.
16093 We *don't* complain about member template instantiations that
16094 have this form, though; they can occur as we try to decide
16095 what constructor to use during overload resolution. Since
16096 overload resolution will never prefer such a constructor to
16097 the non-template copy constructor (which is either explicitly
16098 or implicitly defined), there's no need to worry about their
16099 existence. Theoretically, they should never even be
16100 instantiated, but that's hard to forestall. */
16105 }
16108 }
16110 /* DECL is a declaration for an overloaded or conversion operator. If
16111 COMPLAIN is true, errors are issued for invalid declarations. */
16113 bool
16115 {
16125 tree_code operator_code;
16128 {
16129 /* Conversion operators are TYPE_EXPR for the purposes of this
16130 function. */
16133 }
16134 else
16135 {
16142 }
16145 {
16146 /* operator new and operator delete are quite special. */
16149 {
16168 }
16170 /* [basic.std.dynamic.allocation]/1:
16172 A program is ill-formed if an allocation function is declared
16173 in a namespace scope other than global scope or declared
16174 static in global scope.
16176 The same also holds true for deallocation functions. */
16178 {
16180 {
16182 decl);
16184 }
16187 {
16190 }
16191 }
16194 {
16197 }
16198 else
16199 {
16202 }
16205 }
16207 /* An operator function must either be a non-static member function
16208 or have at least one parameter of a class, a reference to a class,
16209 an enumeration, or a reference to an enumeration. 13.4.0.6 */
16211 {
16215 {
16218 }
16221 {
16223 {
16226 }
16228 /* For lambdas we diagnose static lambda specifier elsewhere. */
16230 /* For instantiations, we have diagnosed this already. */
16234 decl);
16236 /* static operator[] should have exactly one argument
16237 for C++20 and earlier, so that it isn't multidimensional. */
16239 }
16241 {
16245 }
16246 else
16248 {
16250 {
16255 }
16261 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
16262 because these checks are performed even on template
16263 functions. */
16267 }
16268 }
16271 /* There are no further restrictions on the arguments to an overloaded
16272 "operator ()". */
16275 /* C++23 allows an arbitrary number of parameters and default arguments for
16276 operator[], and none of the other checks below apply. */
16281 {
16282 /* 13.4.0.3 */
16285 }
16287 /* Count the number of arguments and check for ellipsis. */
16290 {
16292 {
16294 decl);
16296 }
16298 }
16299 /* FIXME: We need tests for these errors with xobj member functions. */
16300 /* Verify correct number of arguments. */
16302 {
16305 {
16306 /* We have a unary instance of an ambi-ary op. Remap to the
16307 unary one. */
16313 }
16315 {
16316 /* This was an ambiguous operator but is invalid. */
16318 methodp
16322 }
16325 && ! processing_template_decl
16326 /* x++ and x--'s second argument must be an int. */
16328 integer_type_node))
16329 {
16331 methodp
16334 decl);
16336 }
16341 {
16343 methodp
16347 }
16352 {
16354 methodp
16358 }
16363 }
16365 /* There can be no default arguments. */
16369 {
16373 }
16375 /* At this point the declaration is well-formed. It may not be
16376 sensible though. */
16378 /* Check member function warnings only on the in-class declaration.
16379 There's no point warning on an out-of-class definition. */
16383 /* Warn about conversion operators that will never be used. */
16387 {
16398 {
16401 ref
16406 class_type);
16407 /* Don't force t to be complete here. */
16412 ref
16418 }
16419 }
16424 /* Effective C++ rules below. */
16426 /* More Effective C++ rule 7. */
16433 /* More Effective C++ rule 6. */
16438 {
16447 {
16452 }
16453 else
16454 {
16458 }
16459 }
16461 /* Effective C++ rule 23. */
16472 }
16473 \f
16474 /* Return a string giving the keyword associate with CODE. */
16478 {
16480 {
16493 }
16494 }
16496 /* Name lookup in an elaborated-type-specifier (after the keyword
16497 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
16498 elaborated-type-specifier is invalid, issue a diagnostic and return
16499 error_mark_node; otherwise, return the *_TYPE to which it referred.
16500 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
16502 tree
16504 tree decl,
16506 {
16507 tree type;
16509 /* In the case of:
16511 struct S { struct S *p; };
16513 name lookup will find the TYPE_DECL for the implicit "S::S"
16514 typedef. Adjust for that here. */
16520 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
16521 is false for this case as well. */
16523 {
16527 }
16528 /* Accept template template parameters. */
16532 ;
16533 /* [dcl.type.elab]
16535 If the identifier resolves to a typedef-name or the
16536 simple-template-id resolves to an alias template
16537 specialization, the elaborated-type-specifier is ill-formed.
16539 In other words, the only legitimate declaration to use in the
16540 elaborated type specifier is the implicit typedef created when
16541 the type is declared. */
16545 {
16546 auto_diagnostic_group d;
16550 else
16555 }
16560 {
16561 auto_diagnostic_group d;
16565 }
16568 {
16569 auto_diagnostic_group d;
16573 }
16577 {
16578 /* If a class template appears as elaborated type specifier
16579 without a template header such as:
16581 template <class T> class C {};
16582 void f(class C); // No template header here
16584 then the required template argument is missing. */
16589 }
16592 }
16594 /* Lookup NAME of an elaborated type specifier according to SCOPE and
16595 issue diagnostics if necessary. Return *_TYPE node upon success,
16596 NULL_TREE when the NAME is not found, and ERROR_MARK_NODE for type
16597 error. */
16599 static tree
16602 {
16603 tree decl;
16605 {
16606 /* First try ordinary name lookup, ignoring hidden class name
16607 injected via friend declaration. */
16609 /* If that fails, the name will be placed in the smallest
16610 non-class, non-function-prototype scope according to 3.3.1/5.
16611 We may already have a hidden name declared as friend in this
16612 scope. So lookup again but not ignoring hidden names.
16613 If we find one, that name will be made visible rather than
16614 creating a new tag. */
16617 }
16618 else
16622 /* We found nothing. */
16626 {
16627 auto_diagnostic_group d;
16631 }
16634 && !template_header_p
16636 {
16637 auto_diagnostic_group d;
16642 }
16645 /* If scope is TAG_how::CURRENT_ONLY we're defining a class,
16646 so ignore a template template parameter. */
16651 /* Found not-a-type. */
16654 /* Look for invalid nested type:
16655 class C {
16656 class C {};
16657 }; */
16659 {
16663 }
16665 /* Two cases we need to consider when deciding if a class
16666 template is allowed as an elaborated type specifier:
16667 1. It is a self reference to its own class.
16668 2. It comes with a template header.
16670 For example:
16672 template <class T> class C {
16673 class C *c1; // DECL_SELF_REFERENCE_P is true
16674 class D;
16675 };
16676 template <class U> class C; // template_header_p is true
16677 template <class T> class C<T>::D {
16678 class C *c2; // DECL_SELF_REFERENCE_P is true
16679 }; */
16682 template_header_p
16687 {
16688 auto_diagnostic_group d;
16697 }
16700 }
16702 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
16703 Define the tag as a forward-reference if it is not defined.
16705 If a declaration is given, process it here, and report an error if
16706 multiple declarations are not identical.
16708 SCOPE is TS_CURRENT when this is also a definition. Only look in
16709 the current frame for the name (since C++ allows new names in any
16710 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
16711 declaration. Only look beginning from the current scope outward up
16712 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
16714 TEMPLATE_HEADER_P is true when this declaration is preceded by
16715 a set of template parameters. */
16717 tree
16720 {
16729 {
16742 }
16744 /* In case of anonymous name, xref_tag is only called to
16745 make type node and push name. Name lookup is not required. */
16756 {
16760 /* Since HOW is not TAG_how::CURRENT_ONLY, we are not looking at
16761 a definition of this tag. Since, in addition, we are
16762 currently processing a (member) template declaration of a
16763 template class, we must be very careful; consider:
16765 template <class X> struct S1
16767 template <class U> struct S2
16768 {
16769 template <class V> friend struct S1;
16770 };
16772 Here, the S2::S1 declaration should not be confused with the
16773 outer declaration. In particular, the inner version should
16774 have a template parameter of level 2, not level 1.
16776 On the other hand, when presented with:
16778 template <class T> struct S1
16779 {
16780 template <class U> struct S2 {};
16781 template <class U> friend struct S2;
16782 };
16784 the friend must find S1::S2 eventually. We accomplish this
16785 by making sure that the new type we create to represent this
16786 declaration has the right TYPE_CONTEXT. */
16789 }
16792 {
16793 /* If no such tag is yet defined, create a forward-reference node
16794 and record it as the "definition".
16795 When a real declaration of this type is found,
16796 the forward-reference will be altered into a real type. */
16798 {
16801 }
16806 /* Mark it as a lambda type right now. Our caller will
16807 correct the value. */
16810 }
16811 else
16812 {
16814 {
16815 /* Check that we aren't trying to overload a class with different
16816 constraints. */
16820 }
16824 {
16825 auto_diagnostic_group d;
16829 }
16833 {
16843 {
16844 auto_diagnostic_group d;
16848 }
16854 /* FIXME: we should do a more precise check for redefinitions
16855 of a conflicting using-declaration here, as these diagnostics
16856 are not ideal. */
16860 {
16861 /* Push it into this TU's symbol slot. */
16863 /* We're in the template parm binding level.
16864 Pushtag has logic to slide under that, but we're
16865 not pushing a *new* type. */
16871 }
16874 }
16875 }
16878 }
16880 /* Create the binfo hierarchy for REF with (possibly NULL) base list
16881 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
16882 access_* node, and the TREE_VALUE is the type of the base-class.
16883 Non-NULL TREE_TYPE indicates virtual inheritance. */
16885 void
16887 {
16894 tree default_access;
16900 /* The base of a derived class is private by default, all others are
16901 public. */
16906 /* First, make sure that any templates in base-classes are
16907 instantiated. This ensures that if we call ourselves recursively
16908 we do not get confused about which classes are marked and which
16909 are not. */
16912 {
16915 /* The dependent_type_p call below should really be dependent_scope_p
16916 so that we give a hard error about using an incomplete type as a
16917 base, but we allow it with a pedwarn for backward
16918 compatibility. */
16924 /* An incomplete type. Remove it from the list. */
16926 else
16927 {
16928 max_bases++;
16930 max_dvbases++;
16934 }
16935 }
16940 /* The binfo slot should be empty, unless this is an (ill-formed)
16941 redefinition. */
16952 /* Apply base-class info set up to the variants of this type. */
16956 {
16958 /* A C++98 POD cannot have base classes. */
16962 {
16965 }
16966 }
16973 {
16974 /* An aggregate can't have virtual base classes. */
16982 }
16985 {
16993 /* Before C++17, an aggregate cannot have base classes. In C++17, an
16994 aggregate can't have virtual, private, or protected base classes. */
17005 {
17007 basetype);
17009 }
17013 {
17015 /* The original basetype could have been a typedef'd type. */
17018 /* Inherit flags from the base. */
17029 }
17031 /* We must do this test after we've seen through a typedef
17032 type. */
17034 {
17037 else
17040 }
17043 /* Regenerate the pack expansion for the bases. */
17057 dropped_base:
17058 /* Update max_vbases to reflect the reality that we are dropping
17059 this base: if it reaches zero we want to undo the vec_alloc
17060 above to avoid inconsistencies during error-recovery: eg, in
17061 build_special_member_call, CLASSTYPE_VBASECLASSES non null
17062 and vtt null (c++/27952). */
17064 max_vbases--;
17066 max_vbases
17068 }
17075 /* If we didn't get max_vbases vbases, we must have shared at
17076 least one of them, and are therefore diamond shaped. */
17079 /* Unmark all the types. */
17084 /* Now see if we have a repeated base type. */
17086 {
17089 {
17091 {
17094 }
17096 }
17101 else
17103 }
17104 }
17106 \f
17107 /* Copies the enum-related properties from type SRC to type DST.
17108 Used with the underlying type of an enum and the enum itself. */
17109 static void
17111 {
17112 tree t;
17114 {
17124 else
17128 }
17129 }
17131 /* Begin compiling the definition of an enumeration type.
17132 NAME is its name,
17134 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
17136 UNDERLYING_TYPE is the type that will be used as the storage for
17137 the enumeration type. This should be NULL_TREE if no storage type
17138 was specified.
17140 ATTRIBUTES are any attributes specified after the enum-key.
17142 SCOPED_ENUM_P is true if this is a scoped enumeration type.
17144 if IS_NEW is not NULL, gets TRUE iff a new type is created.
17146 Returns the type object, as yet incomplete.
17147 Also records info about it so that build_enumerator
17148 may be used to declare the individual values as they are read. */
17150 tree
17153 {
17159 /* [C++0x dcl.enum]p5:
17161 If not explicitly specified, the underlying type of a scoped
17162 enumeration type is int. */
17169 /* If this is the real definition for a previous forward reference,
17170 fill in the contents in the same object that used to be the
17171 forward reference. */
17177 /* In case of a template_decl, the only check that should be deferred
17178 to instantiation time is the comparison of underlying types. */
17180 {
17181 /* Attempt to set the declaring module. */
17183 {
17187 else
17189 }
17192 ;
17194 {
17195 auto_diagnostic_group d;
17201 }
17203 {
17204 auto_diagnostic_group d;
17210 }
17214 {
17215 auto_diagnostic_group d;
17221 }
17222 }
17226 {
17227 /* In case of error, make a dummy enum to allow parsing to
17228 continue. */
17230 {
17233 }
17235 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
17236 of an opaque enum, or an opaque enum of an already defined
17237 enumeration (C++11).
17238 In any other case, it'll be NULL_TREE. */
17240 {
17243 }
17246 /* Do not push the decl more than once. */
17249 {
17254 {
17255 /* The enum is considered opaque until the opening '{' of the
17256 enumerator list. */
17260 /* std::byte aliases anything. */
17264 }
17265 }
17266 else
17271 }
17278 {
17280 /* We already checked that it matches, don't change it to a different
17283 {
17286 }
17289 else
17290 {
17294 }
17295 }
17297 /* If into a template class, the returned enum is always the first
17298 declaration (opaque or not) seen. This way all the references to
17299 this type will be to the same declaration. The following ones are used
17300 only to check for definition errors. */
17303 else
17305 }
17307 /* After processing and defining all the values of an enumeration type,
17308 install their decls in the enumeration type.
17309 ENUMTYPE is the type object. */
17311 void
17313 {
17314 tree values;
17315 tree underlying_type;
17316 tree decl;
17317 tree value;
17319 tree t;
17321 bool fixed_underlying_type_p
17324 /* We built up the VALUES in reverse order. */
17327 /* For an enum defined in a template, just set the type of the values;
17328 all further processing is postponed until the template is
17329 instantiated. We need to set the type so that tsubst of a CONST_DECL
17330 works. */
17332 {
17334 values;
17338 }
17340 /* Determine the minimum and maximum values of the enumerators. */
17342 {
17346 values;
17348 {
17351 /* [dcl.enum]: Following the closing brace of an enum-specifier,
17352 each enumerator has the type of its enumeration. Prior to the
17353 closing brace, the type of each enumerator is the type of its
17354 initializing value. */
17357 /* Update the minimum and maximum values, if appropriate. */
17361 /* Figure out what the minimum and maximum values of the
17362 enumerators are. */
17369 }
17370 }
17371 else
17372 /* [dcl.enum]
17374 If the enumerator-list is empty, the underlying type is as if
17375 the enumeration had a single enumerator with value 0. */
17379 {
17380 /* Compute the number of bits require to represent all values of the
17381 enumeration. We must do this before the type of MINNODE and
17382 MAXNODE are transformed, since tree_int_cst_min_precision relies
17383 on the TREE_TYPE of the value it is passed. */
17391 /* Determine the underlying type of the enumeration.
17393 [dcl.enum]
17395 The underlying type of an enumeration is an integral type that
17396 can represent all the enumerator values defined in the
17397 enumeration. It is implementation-defined which integral type is
17398 used as the underlying type for an enumeration except that the
17399 underlying type shall not be larger than int unless the value of
17400 an enumerator cannot fit in an int or unsigned int.
17402 We use "int" or an "unsigned int" as the underlying type, even if
17403 a smaller integral type would work, unless the user has
17404 explicitly requested that we use the smallest possible type. The
17405 user can request that for all enumerations with a command line
17406 flag, or for just one enumeration with an attribute. */
17408 use_short_enum = flag_short_enums
17411 /* If the precision of the type was specified with an attribute and it
17412 was too small, give an error. Otherwise, use it. */
17414 {
17417 else
17418 {
17421 }
17422 }
17426 itk++)
17427 {
17433 }
17435 {
17436 /* DR 377
17438 IF no integral type can represent all the enumerator values, the
17439 enumeration is ill-formed. */
17444 }
17446 /* [dcl.enum]
17448 The value of sizeof() applied to an enumeration type, an object
17449 of an enumeration type, or an enumerator, is the value of sizeof()
17450 applied to the underlying type. */
17453 /* Compute the minimum and maximum values for the type.
17455 [dcl.enum]
17457 For an enumeration where emin is the smallest enumerator and emax
17458 is the largest, the values of the enumeration are the values of the
17459 underlying type in the range bmin to bmax, where bmin and bmax are,
17460 respectively, the smallest and largest values of the smallest bit-
17461 field that can store emin and emax. */
17463 /* The middle-end currently assumes that types with TYPE_PRECISION
17464 narrower than their underlying type are suitably zero or sign
17465 extended to fill their mode. Similarly, it assumes that the front
17466 end assures that a value of a particular type must be within
17467 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
17469 We used to set these fields based on bmin and bmax, but that led
17470 to invalid assumptions like optimizing away bounds checking. So
17471 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
17472 TYPE_MAX_VALUE to the values for the mode above and only restrict
17473 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
17477 set_min_and_max_values_for_integral_type
17480 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
17485 {
17488 }
17489 }
17490 else
17493 /* If the enum is exported, mark the consts too. */
17498 /* Convert each of the enumerators to the type of the underlying
17499 type of the enumeration. */
17501 {
17505 /* If the enumeration type has a fixed underlying type, we
17506 already checked all of the enumerator values. */
17508 else
17511 tf_warning_or_error);
17512 /* Do not clobber shared ints. */
17514 {
17518 }
17522 }
17524 /* Fix up all variant types of this enum type. */
17531 {
17533 /* TYPE_FIELDS needs fixup. */
17535 }
17537 /* Finish debugging output for this type. */
17540 /* Each enumerator now has the type of its enumeration. Clear the cache
17541 so that this change in types doesn't confuse us later on. */
17543 }
17545 /* Finishes the enum type. This is called only the first time an
17546 enumeration is seen, be it opaque or odinary.
17547 ENUMTYPE is the type object. */
17549 void
17551 {
17553 {
17557 }
17559 /* If this is a forward declaration, there should not be any variants,
17560 though we can get a variant in the middle of an enum-specifier with
17561 wacky code like 'enum E { e = sizeof(const E*) };' */
17565 }
17567 /* Build and install a CONST_DECL for an enumeration constant of the
17568 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
17569 Apply ATTRIBUTES if available. LOC is the location of NAME.
17570 Assignment of sequential values by default is handled here. */
17572 tree
17574 location_t loc)
17575 {
17576 tree decl;
17577 tree context;
17578 tree type;
17580 /* scalar_constant_value will pull out this expression, so make sure
17581 it's folded as appropriate.
17583 Creating a TARGET_EXPR in a template breaks when substituting, and
17584 here we would create it for instance when using a class prvalue with
17585 a user-defined conversion function. So don't use such a tree. We
17586 instantiate VALUE here to get errors about bad enumerators even in
17587 a template that does not get instantiated. */
17591 /* If the VALUE was erroneous, pretend it wasn't there; that will
17592 result in the enum being assigned the next value in sequence. */
17596 /* Remove no-op casts from the value. */
17601 {
17602 /* Validate and default VALUE. */
17604 {
17606 {
17611 }
17614 value = perform_implicit_conversion_flags
17622 {
17625 {
17627 "enumerator value for %qD must have integral or "
17630 }
17631 else
17632 {
17636 {
17640 }
17641 }
17642 }
17643 }
17645 /* Default based on previous value. */
17647 {
17649 {
17650 tree prev_value;
17652 /* C++03 7.2/4: If no initializer is specified for the first
17653 enumerator, the type is an unspecified integral
17654 type. Otherwise the type is the same as the type of the
17655 initializing value of the preceding enumerator unless the
17656 incremented value is not representable in that type, in
17657 which case the type is an unspecified integral type
17658 sufficient to contain the incremented value. */
17662 else
17663 {
17670 {
17673 {
17676 {
17682 }
17689 }
17692 else
17694 }
17697 {
17700 }
17701 }
17702 }
17703 else
17705 }
17707 /* Remove no-op casts from the value. */
17710 /* If the underlying type of the enum is fixed, check whether
17711 the enumerator values fits in the underlying type. If it
17712 does not fit, the program is ill-formed [C++0x dcl.enum]. */
17714 && value
17716 {
17721 /* Convert the value to the appropriate type. */
17723 }
17724 }
17726 /* C++ associates enums with global, function, or class declarations. */
17729 /* Build the actual enumeration constant. Note that the enumeration
17730 constants have the underlying type of the enum (if it is fixed)
17731 or the type of their initializer (if the underlying type of the
17732 enum is not fixed):
17734 [ C++0x dcl.enum ]
17736 If the underlying type is fixed, the type of each enumerator
17737 prior to the closing brace is the underlying type; if the
17738 initializing value of an enumerator cannot be represented by
17739 the underlying type, the program is ill-formed. If the
17740 underlying type is not fixed, the type of each enumerator is
17741 the type of its initializing value.
17743 If the underlying type is not fixed, it will be computed by
17744 finish_enum and we will reset the type of this enumerator. Of
17745 course, if we're processing a template, there may be no value. */
17759 {
17760 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
17761 on the TYPE_FIELDS list for `S'. (That's so that you can say
17762 things like `S::i' later.) */
17764 /* The enumerator may be getting declared outside of its enclosing
17765 class, like so:
17767 class S { public: enum E : int; }; enum S::E : int { i = 7; };
17769 For which case we need to make sure that the access of `S::i'
17770 matches the access of `S::E'. */
17774 }
17775 else
17778 /* Add this enumeration constant to the list for this type. */
17782 }
17784 /* Look for an enumerator with the given NAME within the enumeration
17785 type ENUMTYPE. This routine is used primarily for qualified name
17786 lookup into an enumerator in C++0x, e.g.,
17788 enum class Color { Red, Green, Blue };
17790 Color color = Color::Red;
17792 Returns the value corresponding to the enumerator, or
17793 NULL_TREE if no such enumerator was found. */
17794 tree
17796 {
17797 tree e;
17802 }
17804 /* Implement LANG_HOOKS_SIMULATE_ENUM_DECL. */
17806 tree
17809 {
17816 {
17817 auto_diagnostic_group d;
17822 }
17836 }
17838 /* Implement LANG_HOOKS_SIMULATE_RECORD_DECL. */
17840 tree
17843 {
17850 {
17853 }
17872 }
17873 \f
17874 /* We're defining DECL. Make sure that its type is OK. */
17876 static void
17878 {
17882 /* In a function definition, arg types must be complete. */
17889 {
17894 /* Make it return void instead. */
17897 void_type_node,
17899 else
17901 fntype = (cp_build_type_attribute_variant
17905 }
17906 else
17907 {
17911 }
17912 }
17914 /* True iff FN is an implicitly-defined default constructor. */
17916 static bool
17918 {
17922 }
17924 /* Clobber the contents of *this to let the back end know that the object
17925 storage is dead when we enter the constructor or leave the destructor. */
17927 static tree
17929 {
17930 /* Clobbering an empty base is pointless, and harmful if its one byte
17931 TYPE_SIZE overlays real data. */
17935 /* If we have virtual bases, clobber the whole object, but only if we're in
17936 charge. If we don't have virtual bases, clobber the as-base type so we
17937 don't mess with tail padding. */
17948 {
17951 }
17958 }
17960 /* Create the FUNCTION_DECL for a function definition.
17961 DECLSPECS and DECLARATOR are the parts of the declaration;
17962 they describe the function's name and the type it returns,
17963 but twisted together in a fashion that parallels the syntax of C.
17965 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
17966 DECLARATOR is really the DECL for the function we are about to
17967 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
17968 indicating that the function is an inline defined in-class.
17970 This function creates a binding context for the function body
17971 as well as setting up the FUNCTION_DECL in current_function_decl.
17973 For C++, we must first check whether that datum makes any sense.
17974 For example, "class A local_a(1,2);" means that variable local_a
17975 is an aggregate of type A, which should have a constructor
17976 applied to it with the argument list [1, 2].
17978 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
17979 or may be a BLOCK if the function has been defined previously
17980 in this translation unit. On exit, DECL_INITIAL (decl1) will be
17981 error_mark_node if the function has never been defined, or
17982 a BLOCK if the function has been defined somewhere. */
17984 bool
17986 {
17990 /* Sanity check. */
17997 else
17998 {
18003 }
18005 /* Adjust for #pragma target/optimize if this is an artificial function that
18006 (probably) didn't go through grokfndecl. We particularly don't want this
18007 for deferred instantiations, which should match their template. */
18016 /* Handle gnu_inline attribute. */
18018 {
18023 }
18026 /* This is a constructor, we must ensure that any default args
18027 introduced by this definition are propagated to the clones
18028 now. The clones are used directly in overload resolution. */
18031 /* Sometimes we don't notice that a function is a static member, and
18032 build a METHOD_TYPE for it. Fix that up now. */
18036 /* Set up current_class_type, and enter the scope of the class, if
18037 appropriate. */
18041 /* Now that we have entered the scope of the class, we must restore
18042 the bindings for any template parameters surrounding DECL1, if it
18043 is an inline member template. (Order is important; consider the
18044 case where a template parameter has the same name as a field of
18045 the class.) It is not until after this point that
18046 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
18050 /* Effective C++ rule 15. */
18058 /* Make the init_value nonzero so pushdecl knows this is not tentative.
18059 error_mark_node is replaced below (in poplevel) with the BLOCK. */
18063 /* This function exists in static storage.
18064 (This does not mean `static' in the C sense!) */
18067 /* We must call push_template_decl after current_class_type is set
18068 up. (If we are processing inline definitions after exiting a
18069 class scope, current_class_type will be NULL_TREE until set above
18070 by push_nested_class.) */
18072 {
18075 {
18079 }
18081 }
18083 /* Make sure the parameter and return types are reasonable. When
18084 you declare a function, these types can be incomplete, but they
18085 must be complete when you define the function. */
18088 /* Build the return declaration for the function. */
18092 {
18093 /* In a template instantiation, copy the return type location. When
18094 parsing, the location will be set in grokdeclarator. */
18097 {
18101 }
18109 }
18111 /* Record the decl so that the function name is defined.
18112 If we already have a decl for this name, and it is a FUNCTION_DECL,
18113 use the old decl. */
18115 {
18116 /* A specialization is not used to guide overload resolution. */
18120 {
18124 /* If something went wrong when registering the declaration,
18125 use DECL1; we have to have a FUNCTION_DECL to use when
18126 parsing the body of the function. */
18127 ;
18128 else
18129 {
18130 /* Otherwise, OLDDECL is either a previous declaration
18131 of the same function or DECL1 itself. */
18138 {
18139 tree context;
18141 /* Check whether DECL1 is in an anonymous
18142 namespace. */
18144 context;
18146 {
18150 }
18154 OPT_Wmissing_declarations,
18156 }
18159 }
18160 }
18161 else
18162 {
18163 /* We need to set the DECL_CONTEXT. */
18166 }
18170 /* If #pragma weak applies, mark the decl appropriately now.
18171 The pragma only applies to global functions. Because
18172 determining whether or not the #pragma applies involves
18173 computing the mangled name for the declaration, we cannot
18174 apply the pragma until after we have merged this declaration
18175 with any previous declarations; if the original declaration
18176 has a linkage specification, that specification applies to
18177 the definition as well, and may affect the mangled name. */
18180 }
18182 /* We are now in the scope of the function being defined. */
18185 /* Save the parm names or decls from this function's declarator
18186 where store_parm_decls will find them. */
18189 /* Let the user know we're compiling this function. */
18194 /* This function may already have been parsed, in which case just
18195 return; our caller will skip over the body without parsing. */
18199 /* Initialize RTL machinery. We cannot do this until
18200 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
18201 even when processing a template; this is how we get
18202 CFUN set up, and our per-function variables initialized.
18203 FIXME factor out the non-RTL stuff. */
18207 /* Initialize the language data structures. Whenever we start
18208 a new function, we destroy temporaries in the usual way. */
18213 /* If we are (erroneously) defining a function that we have already
18214 defined before, wipe out what we knew before. */
18220 {
18223 }
18225 /* Start the statement-tree, start the tree now. */
18229 {
18230 /* We know that this was set up by `grokclassfn'. We do not
18231 wait until `store_parm_decls', since evil parse errors may
18232 never get us to that point. Here we keep the consistency
18233 between `current_class_type' and `current_class_ptr'. */
18239 cp_function_chain->x_current_class_ref
18241 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
18244 /* Constructors and destructors need to know whether they're "in
18245 charge" of initializing virtual base classes. */
18248 {
18251 }
18253 {
18256 }
18257 }
18260 /* Implicitly-defined methods (like the
18261 destructor for a class in which no destructor
18262 is explicitly declared) must not be defined
18263 until their definition is needed. So, we
18264 ignore interface specifications for
18265 compiler-generated functions. */
18273 {
18280 /* This is a function in a local class in an extern inline
18281 or template function. */
18283 }
18284 /* If this function belongs to an interface, it is public.
18285 If it belongs to someone else's interface, it is also external.
18286 This only affects inlines and template instantiations. */
18288 {
18291 {
18295 && ! flag_implement_inlines
18298 /* For WIN32 we also want to put these in linkonce sections. */
18300 }
18301 else
18304 /* If this function is in an interface implemented in this file,
18305 make sure that the back end knows to emit this function
18306 here. */
18309 }
18312 {
18313 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
18314 interface, we will have both finfo->interface_unknown and
18315 finfo->interface_only set. In that case, we don't want to
18316 use the normal heuristics because someone will supply a
18317 #pragma implementation elsewhere, and deducing it here would
18318 produce a conflict. */
18323 }
18324 else
18325 {
18326 /* This is a definition, not a reference.
18327 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
18335 else
18337 }
18339 /* Determine the ELF visibility attribute for the function. We must not
18340 do this before calling "pushdecl", as we must allow "duplicate_decls"
18341 to merge any attributes appropriately. We also need to wait until
18342 linkage is set. */
18363 /* Clobbering an empty base is harmful if it overlays real data. */
18365 /* We can't clobber safely for an implicitly-defined default constructor
18366 because part of the initialization might happen before we enter the
18367 constructor, via AGGR_INIT_ZERO_FIRST (c++/68006). */
18382 }
18385 /* Like start_preparsed_function, except that instead of a
18386 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
18388 Returns true on success. If the DECLARATOR is not suitable
18389 for a function, we return false, which tells the parser to
18390 skip the entire function. */
18392 bool
18395 tree attrs)
18396 {
18397 tree decl1;
18405 /* main must return int. grokfndecl should have corrected it
18406 (and issued a diagnostic) if the user got it wrong. */
18408 integer_type_node));
18411 }
18412 \f
18413 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
18414 FN. */
18416 bool
18418 {
18420 && !processing_template_decl
18421 /* We insert the EH_SPEC_BLOCK only in the original
18422 function; then, it is copied automatically to the
18423 clones. */
18425 /* Implicitly-generated constructors and destructors have
18426 exception specifications. However, those specifications
18427 are the union of the possible exceptions specified by the
18428 constructors/destructors for bases and members, so no
18429 unallowed exception will ever reach this function. By
18430 not creating the EH_SPEC_BLOCK we save a little memory,
18431 and we avoid spurious warnings about unreachable
18432 code. */
18435 }
18437 /* Helper function to push ARGS into the current lexical scope. DECL
18438 is the function declaration. NONPARMS is used to handle enum
18439 constants. */
18441 void
18443 {
18444 /* If we're doing semantic analysis, then we'll call pushdecl
18445 for each of these. We must do them in reverse order so that
18446 they end in the correct forward order. */
18449 tree next;
18451 {
18456 {
18457 /* If we find an enum constant or a type tag, put it aside for
18458 the moment. */
18461 }
18462 }
18464 /* Get the decls in their original chain order and record in the
18465 function. This is all and only the PARM_DECLs that were
18466 pushed into scope by the loop above. */
18468 }
18470 /* Store the parameter declarations into the current function declaration.
18471 This is called after parsing the parameter declarations, before
18472 digesting the body of the function.
18474 Also install to binding contour return value identifier, if any. */
18476 static void
18478 {
18481 /* This is a chain of any other decls that came in among the parm
18482 declarations. If a parm is declared with enum {foo, bar} x;
18483 then CONST_DECLs for foo and bar are put here. */
18487 {
18488 /* This case is when the function was defined with an ANSI prototype.
18489 The parms already have decls, so we need not do anything here
18490 except record them as in effect
18491 and complain if any redundant old-style parm decls were written. */
18495 /* Must clear this because it might contain TYPE_DECLs declared
18496 at class level. */
18500 }
18501 else
18504 /* Now store the final chain of decls for the arguments
18505 as the decl-chain of the current lexical scope.
18506 Put the enumerators in as well, at the front so that
18507 DECL_ARGUMENTS is not modified. */
18512 }
18514 \f
18515 /* Mark CDTOR's implicit THIS argument for returning, if required by
18516 the ABI.. Return the decl for THIS, if it is to be returned, and
18517 NULL otherwise. */
18519 tree
18521 {
18524 {
18527 }
18530 }
18532 /* Set the return value of the [cd]tor if the ABI wants that. */
18534 void
18536 {
18538 {
18539 /* Return the address of the object. */
18545 }
18546 }
18548 /* Do all the processing for the beginning of a destructor; set up the
18549 vtable pointers and cleanups for bases and members. */
18551 static void
18553 {
18554 tree compound_stmt;
18556 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
18557 issued an error message. We still want to try to process the
18558 body of the function, but initialize_vtbl_ptrs will crash if
18559 TYPE_BINFO is NULL. */
18561 {
18563 /* Make all virtual function table pointers in non-virtual base
18564 classes point to CURRENT_CLASS_TYPE's virtual function
18565 tables. */
18570 /* Clobbering an empty base is harmful if it overlays real data. */
18572 {
18576 {
18578 tree ref
18585 tf_warning_or_error);
18586 /* If the vptr is shared with some virtual nearly empty base,
18587 don't clear it if not in charge, the dtor of the virtual
18588 nearly empty base will do that later. */
18590 {
18593 {
18595 {
18597 tf_warning_or_error);
18600 }
18602 }
18603 }
18605 }
18606 else
18609 }
18611 /* And insert cleanups for our bases and members so that they
18612 will be properly destroyed if we throw. */
18614 }
18615 }
18617 /* Do the necessary processing for the beginning of a function body, which
18618 in this case includes member-initializers, but not the catch clauses of
18619 a function-try-block. Currently, this means opening a binding level
18620 for the member-initializers (in a ctor), member cleanups (in a dtor),
18621 and capture proxies (in a lambda operator()). */
18623 tree
18625 {
18631 else
18632 /* Always keep the BLOCK node associated with the outermost pair of
18633 curly braces of a function. These are needed for correct
18634 operation of dwarfout.c. */
18646 }
18648 /* Do the processing for the end of a function body. Currently, this means
18649 closing out the cleanups for fully-constructed bases and members, and in
18650 the case of the destructor, deleting the object if desired. Again, this
18651 is only meaningful for [cd]tors, since they are the only functions where
18652 there is a significant distinction between the main body and any
18653 function catch clauses. Handling, say, main() return semantics here
18654 would be wrong, as flowing off the end of a function catch clause for
18655 main() would also need to return 0. */
18657 void
18659 {
18663 /* Close the block. */
18671 }
18673 /* Given a function, returns the BLOCK corresponding to the outermost level
18674 of curly braces, skipping the artificial block created for constructor
18675 initializers. */
18677 tree
18679 {
18689 }
18691 /* If FNDECL is a class's key method, add the class to the list of
18692 keyed classes that should be emitted. */
18694 static void
18696 {
18700 {
18703 {
18705 /* Classes attached to a named module are already handled. */
18709 }
18710 }
18711 }
18713 /* Attempt to add a fix-it hint to RICHLOC suggesting the insertion
18714 of "return *this;" immediately before its location, using FNDECL's
18715 first statement (if any) to give the indentation, if appropriate. */
18717 static void
18719 {
18726 indent);
18727 }
18729 /* Finish up a function declaration and compile that function
18730 all the way to assembler language output. The free the storage
18731 for the function definition. INLINE_P is TRUE if we just
18732 finished processing the body of an in-class inline function
18733 definition. (This processing will have taken place after the
18734 class definition is complete.) */
18736 tree
18738 {
18743 /* When we get some parse errors, we can end up without a
18744 current_function_decl, so cope. */
18761 /* TREE_READONLY (fndecl) = 1;
18762 This caused &foo to be of type ptr-to-const-function
18763 which then got a warning when stored in a ptr-to-function variable. */
18766 /* The current function is being defined, so its DECL_INITIAL should
18767 be set, and unless there's a multiple definition, it should be
18768 error_mark_node. */
18773 && !processing_template_decl
18776 {
18783 /* We should handle coroutine IFNs in middle end lowering. */
18786 /* Do not try to process the ramp's EH unless outlining succeeded. */
18790 current_eh_spec_block);
18792 /* If outlining succeeded, then add contracts handling if needed. */
18795 }
18796 else
18797 /* For a cloned function, we've already got all the code we need;
18798 there's no need to add any extra bits. */
18800 {
18801 /* Make it so that `main' always returns 0 by default. */
18809 current_eh_spec_block);
18814 }
18816 /* If we're saving up tree structure, tie off the function now. */
18821 /* This must come after expand_function_end because cleanups might
18822 have declarations (from inline functions) that need to go into
18823 this function's blocks. */
18825 /* If the current binding level isn't the outermost binding level
18826 for this function, either there is a bug, or we have experienced
18827 syntax errors and the statement tree is malformed. */
18829 {
18830 /* Make sure we have already experienced errors. */
18833 /* Throw away the broken statement tree and extra binding
18834 levels. */
18838 {
18841 else
18843 }
18844 }
18847 /* Statements should always be full-expressions at the outermost set
18848 of curly braces for a function. */
18851 /* If there are no return statements in a function with auto return type,
18852 the return type is void. But if the declared type is something like
18853 auto*, this is an error. */
18856 {
18858 && !current_function_returns_value
18860 {
18861 /* We haven't applied return type deduction because we haven't
18862 seen any return statements. Do that now. */
18866 adc_return_type);
18870 }
18873 {
18874 auto_diagnostic_group d;
18879 }
18880 }
18882 /* Remember that we were in class scope. */
18887 {
18891 }
18898 /* Complain if there's just no return statement. */
18905 /* Don't complain if we abort or throw. */
18906 && !current_function_returns_abnormally
18907 /* Don't complain if there's an infinite loop. */
18908 && !current_function_infinite_loop
18909 /* Don't complain if we are declared noreturn. */
18913 /* Structor return values (if any) are set by the compiler. */
18917 {
18919 /* Potentially add a "return *this;" fix-it hint for
18920 assignment operators. */
18922 {
18925 && current_class_ref
18926 && same_type_ignoring_top_level_qualifiers_p
18930 }
18936 "no return statement in function returning "
18939 }
18941 /* Lambda closure members are implicitly constexpr if possible. */
18945 = ((processing_template_decl
18949 /* Save constexpr function body before it gets munged by
18950 the NRV transformation. */
18953 /* Invoke the pre-genericize plugin before we start munging things. */
18957 /* Perform delayed folding before NRV transformation. */
18963 /* Set up the named return value optimization, if we can. Candidate
18964 variables are selected in check_return_expr. */
18966 {
18970 }
18972 /* Must mark the RESULT_DECL as being in this function. */
18975 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
18976 to the FUNCTION_DECL node itself. */
18979 /* Store the end of the function, so that we get good line number
18980 info for the epilogue. */
18983 /* Complain about parameters that are only set, but never otherwise used. */
18985 && !processing_template_decl
18988 {
18989 tree decl;
18992 decl;
19006 OPT_Wunused_but_set_parameter,
19009 }
19011 /* Complain about locally defined typedefs that are not used in this
19012 function. */
19015 /* Possibly warn about unused parameters. */
19017 && !processing_template_decl
19021 /* Genericize before inlining. */
19027 /* If this function can't throw any exceptions, remember that. */
19030 && !flag_non_call_exceptions
19035 cleanup:
19037 /* We're leaving the context of this function, so zap cfun. It's still in
19038 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
19042 /* If this is an in-class inline definition, we may have to pop the
19043 bindings for the template parameters that we added in
19044 maybe_begin_member_template_processing when start_function was
19045 called. */
19049 /* Leave the scope of the class. */
19055 /* Clean up. */
19058 /* Build outlined functions for coroutines and contracts. */
19061 {
19062 /* Emit the resumer and destroyer functions now, providing that we have
19063 not encountered some fatal error. */
19065 {
19071 }
19073 }
19075 /* If we have used outlined contracts checking functions, build and emit
19076 them here. */
19080 }
19081 \f
19082 /* Create the FUNCTION_DECL for a function definition.
19083 DECLSPECS and DECLARATOR are the parts of the declaration;
19084 they describe the return type and the name of the function,
19085 but twisted together in a fashion that parallels the syntax of C.
19087 This function creates a binding context for the function body
19088 as well as setting up the FUNCTION_DECL in current_function_decl.
19090 Returns a FUNCTION_DECL on success.
19092 If the DECLARATOR is not suitable for a function (it defines a datum
19093 instead), we return 0, which tells yyparse to report a parse error.
19095 May return void_type_node indicating that this method is actually
19096 a friend. See grokfield for more details.
19098 Came here with a `.pushlevel' .
19100 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
19101 CHANGES TO CODE IN `grokfield'. */
19103 tree
19106 {
19116 /* Pass friends other than inline friend functions back. */
19121 {
19126 }
19130 /* p1779 ABI-Isolation makes inline not a default for in-class
19131 definitions attached to a named module. If the user explicitly
19132 made it inline, grokdeclarator will already have done the right
19133 things. */
19135 || flag_module_implicit_inline
19136 /* Lambda's operator function remains inline. */
19138 /* If the user explicitly asked for this to be inline, we don't
19139 need to do more, but more importantly we want to warn if we
19140 can't inline it. */
19142 {
19146 /* It's ok if we can't inline this. */
19148 }
19150 /* We process method specializations in finish_struct_1. */
19152 {
19153 /* Avoid calling decl_spec_seq... until we have to. */
19158 }
19161 {
19164 }
19170 }
19171 \f
19173 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
19174 we can lay it out later, when and if its type becomes complete.
19176 Also handle constexpr variables where the initializer involves
19177 an unlowered PTRMEM_CST because the class isn't complete yet. */
19179 void
19181 {
19184 /* Keep track of variables with incomplete types. */
19187 {
19195 /* RTTI TD entries are created while defining the type_info. */
19198 {
19201 }
19207 {
19208 /* When the outermost open class is complete we can resolve any
19209 pointers-to-members. */
19213 }
19214 }
19215 }
19217 /* Called when a class type (given by TYPE) is defined. If there are
19218 any existing VAR_DECLs whose type has been completed by this
19219 declaration, update them now. */
19221 void
19223 {
19228 {
19230 {
19237 {
19238 /* Complete the type of the variable. */
19243 }
19245 /* Remove this entry from the list. */
19247 }
19248 else
19249 ix++;
19250 }
19251 }
19253 /* If DECL is of a type which needs a cleanup, build and return an
19254 expression to perform that cleanup here. Return NULL_TREE if no
19255 cleanup need be done. DECL can also be a _REF when called from
19256 split_nonconstant_init_1. */
19258 tree
19260 {
19261 tree type;
19262 tree attr;
19263 tree cleanup;
19265 /* Assume no cleanup is required. */
19271 /* Handle "__attribute__((cleanup))". We run the cleanup function
19272 before the destructor since the destructor is what actually
19273 terminates the lifetime of the object. */
19276 else
19279 {
19280 tree id;
19281 tree fn;
19282 tree arg;
19284 /* Get the name specified by the user for the cleanup function. */
19286 /* Look up the name to find the cleanup function to call. It is
19287 important to use lookup_name here because that is what is
19288 used in c-common.cc:handle_cleanup_attribute when performing
19289 initial checks on the attribute. Note that those checks
19290 include ensuring that the function found is not an overloaded
19291 function, or an object with an overloaded call operator,
19292 etc.; we can rely on the fact that the function found is an
19293 ordinary FUNCTION_DECL. */
19301 }
19302 /* Handle ordinary C++ destructors. */
19305 {
19307 tree addr;
19308 tree call;
19312 else
19326 else
19328 }
19330 /* build_delete sets the location of the destructor call to the
19331 current location, even though the destructor is going to be
19332 called later, at the end of the current scope. This can lead to
19333 a "jumpy" behavior for users of debuggers when they step around
19334 the end of the block. So let's unset the location of the
19335 destructor call instead. */
19343 /* Treat objects with destructors as used; the destructor may do
19344 something substantive. */
19353 }
19355 \f
19356 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
19357 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
19358 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
19360 tree
19362 {
19363 tree fntype;
19364 tree args;
19377 fntype = (cp_build_type_attribute_variant
19381 }
19383 /* DECL was originally constructed as a non-static member function,
19384 but turned out to be static. Update it accordingly. */
19386 void
19388 {
19401 }
19403 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
19404 one of the language-independent trees. */
19406 enum cp_tree_node_structure_enum
19408 {
19410 {
19428 }
19429 }
19431 bool
19433 {
19434 /* A missing noreturn is ok for the `main' function. */
19436 }
19438 /* Return the decl used to identify the COMDAT group into which DECL should
19439 be placed. */
19441 tree
19443 {
19444 /* Virtual tables, construction virtual tables, and virtual table
19445 tables all go in a single COMDAT group, named after the primary
19446 virtual table. */
19449 /* For all other DECLs, the COMDAT group is the mangled name of the
19450 declaration itself. */
19451 else
19452 {
19454 {
19455 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
19456 into the same section as the target function. In that case
19457 we must return target's name. */
19463 else
19465 }
19466 /* If a ctor/dtor has already set the comdat group by
19467 maybe_clone_body, don't override it. */
19473 }
19476 }
19478 /* Returns the return type for FN as written by the user, which may include
19479 a placeholder for a deduced return type. */
19481 tree
19483 {
19489 }
19491 /* Returns true iff DECL is a variable or function declared with an auto type
19492 that has not yet been deduced to a real type. */
19494 bool
19496 {
19503 }
19505 /* Complain if DECL has an undeduced return type. */
19507 bool
19509 {
19511 {
19515 {
19516 /* Set the return type of __builtin_source_location. */
19519 {
19522 }
19527 }
19535 }
19537 }
19539 /* Create a representation of the explicit-specifier with
19540 constant-expression of EXPR. COMPLAIN is as for tsubst. */
19542 tree
19544 {
19549 /* Wait for instantiation, tsubst_function_decl will handle it. */
19556 }