| blob | 255c4026bdbdf565ca5ecab1bc2f9df114ceb103 |
1 /* Process declarations and variables for -*- C++ -*- compiler.
2 Copyright (C) 1988-2023 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
64 /* Possible cases of bad specifiers type used by bad_specifiers. */
69 BSP_FIELD /* field */
70 };
100 static tree check_special_function_return_type
109 /* The following symbols are subsumed in the cp_global_trees array, and
110 listed here individually for documentation purposes.
112 C++ extensions
113 tree wchar_decl_node;
115 tree vtable_entry_type;
116 tree delta_type_node;
117 tree __t_desc_type_node;
119 tree class_type_node;
120 tree unknown_type_node;
122 Array type `vtable_entry_type[]'
124 tree vtbl_type_node;
125 tree vtbl_ptr_type_node;
127 Namespaces,
129 tree std_node;
130 tree abi_node;
132 A FUNCTION_DECL which can call `abort'. Not necessarily the
133 one that the user will declare, but sufficient to be called
134 by routines that want to abort the program.
136 tree abort_fndecl;
138 Used by RTTI
139 tree type_info_type_node, tinfo_decl_id, tinfo_decl_type;
140 tree tinfo_var_id; */
144 /* A list of objects which have constructors or destructors
145 which reside in namespace scope. The decl is stored in
146 the TREE_VALUE slot and the initializer is stored
147 in the TREE_PURPOSE slot. */
148 tree static_aggregates;
150 /* Like static_aggregates, but for thread_local variables. */
151 tree tls_aggregates;
153 /* A hash-map mapping from variable decls to the dynamic initializer for
154 the decl. This is currently only used by OpenMP. */
157 /* -- end of C++ */
159 /* A node for the integer constant 2. */
161 tree integer_two_node;
163 /* vector of static decls. */
166 /* vector of keyed classes. */
169 /* Used only for jumps to as-yet undefined labels, since jumps to
170 defined labels can have their validity checked immediately. */
174 /* The binding level to which this entry is *currently* attached.
175 This is initially the binding level in which the goto appeared,
176 but is modified as scopes are closed. */
178 /* The head of the names list that was current when the goto appeared,
179 or the inner scope popped. These are the decls that will *not* be
180 skipped when jumping to the label. */
181 tree names_in_scope;
182 /* The location of the goto, for error reporting. */
183 location_t o_goto_locus;
184 /* True if an OpenMP structured block scope has been closed since
185 the goto appeared. This means that the branch from the label will
186 illegally exit an OpenMP scope. */
188 };
190 /* A list of all LABEL_DECLs in the function that have names. Here so
191 we can clear out their names' definitions at the end of the
192 function, and so we can check the validity of jumps to these labels. */
202 /* The binding level to which the label is *currently* attached.
203 This is initially set to the binding level in which the label
204 is defined, but is modified as scopes are closed. */
207 /* The head of the names list that was current when the label was
208 defined, or the inner scope popped. These are the decls that will
209 be skipped when jumping to the label. */
210 tree names_in_scope;
212 /* A vector of all decls from all binding levels that would be
213 crossed by a backward branch to the label. */
216 /* A list of uses of the label, before the label is defined. */
219 /* The following bits are set after the label is defined, and are
220 updated as scopes are popped. They indicate that a jump to the
221 label will illegally enter a scope of the given flavor. */
229 };
231 #define named_labels cp_function_chain->x_named_labels
232 \f
233 /* The number of function bodies which we are currently processing.
234 (Zero if we are at namespace scope, one inside the body of a
235 function, two inside the body of a function in a local class, etc.) */
238 /* Whether the exception-specifier is part of a function type (i.e. C++17). */
241 /* States indicating how grokdeclarator() should handle declspecs marked
242 with __attribute__((deprecated)). An object declared as
243 __attribute__((deprecated)) suppresses warnings of uses of other
244 deprecated items. */
247 \f
248 /* A list of VAR_DECLs whose type was incomplete at the time the
249 variable was declared. */
252 tree decl;
253 tree incomplete_type;
254 };
258 \f
259 /* Returns the kind of template specialization we are currently
260 processing, given that it's declaration contained N_CLASS_SCOPES
261 explicit scope qualifications. */
263 tmpl_spec_kind
265 {
271 /* Scan through the template parameter scopes. */
275 {
276 /* If we see a specialization scope inside a parameter scope,
277 then something is wrong. That corresponds to a declaration
278 like:
280 template <class T> template <> ...
282 which is always invalid since [temp.expl.spec] forbids the
283 specialization of a class member template if the enclosing
284 class templates are not explicitly specialized as well. */
286 {
289 else
291 }
296 }
298 /* Handle explicit instantiations. */
300 {
302 /* We've seen a template parameter list during an explicit
303 instantiation. For example:
305 template <class T> template void f(int);
307 This is erroneous. */
309 else
311 }
314 /* We've not seen enough template headers to match all the
315 specialized classes present. For example:
317 template <class T> void R<T>::S<T>::f(int);
319 This is invalid; there needs to be one set of template
320 parameters for each class. */
323 /* We're processing a non-template declaration (even though it may
324 be a member of a template class.) For example:
326 template <class T> void S<T>::f(int);
328 The `class T' matches the `S<T>', leaving no template headers
329 corresponding to the `f'. */
332 /* We've got too many template headers. For example:
334 template <> template <class T> void f (T);
336 There need to be more enclosing classes. */
338 else
339 /* This must be a template. It's of the form:
341 template <class T> template <class U> void S<T>::f(U);
343 This is a specialization if the innermost level was a
344 specialization; otherwise it's just a definition of the
345 template. */
347 }
349 /* Exit the current scope. */
351 void
353 {
355 }
357 /* When a label goes out of scope, check to see if that label was used
358 in a valid manner, and issue any appropriate warnings or errors. */
360 static void
362 {
364 {
366 {
367 location_t location;
371 /* FIXME want (LOCATION_FILE (input_location), (line)0) */
372 /* Avoid crashing later. */
374 }
375 else
377 }
378 }
380 /* Helper function to sort named label entries in a vector by DECL_UID. */
382 static int
384 {
388 /* DECL_UIDs can never be equal. */
390 }
392 /* At the end of a function, all labels declared within the function
393 go out of scope. BLOCK is the top-level block for the
394 function. */
396 static void
398 {
402 /* We need to add the labels to the block chain, so debug
403 information is emitted. But, we want the order to be stable so
404 need to sort them first. Otherwise the debug output could be
405 randomly ordered. I guess it's mostly stable, unless the hash
406 table implementation changes. */
411 {
418 }
423 {
430 }
431 }
433 /* At the end of a block with local labels, restore the outer definition. */
435 static void
437 {
445 else
446 {
449 }
451 }
453 /* The following two routines are used to interface to Objective-C++.
454 The binding level is purposely treated as an opaque type. */
458 {
460 }
462 /* The following routine is used by the NeXT-style SJLJ exceptions;
463 variables get marked 'volatile' so as to not be clobbered by
464 _setjmp()/_longjmp() calls. All variables in the current scope,
465 as well as parent scopes up to (but not including) ENCLOSING_BLK
466 shall be thusly marked. */
468 void
470 {
476 {
477 tree decl;
482 /* Do not climb up past the current function. */
485 }
486 }
488 /* True if B is the level for the condition of a constexpr if. */
490 static bool
492 {
496 }
498 /* True if B is the level for the condition of a consteval if. */
500 static bool
502 {
506 }
508 /* Update data for defined and undefined labels when leaving a scope. */
510 int
512 {
517 {
518 tree decl;
520 /* ENT->NAMES_IN_SCOPE may contain a mixture of DECLs and
521 TREE_LISTs representing OVERLOADs, so be careful. */
531 {
555 }
556 }
558 {
563 {
568 }
569 }
572 }
574 /* Saved errorcount to avoid -Wunused-but-set-{parameter,variable} warnings
575 when errors were reported, except for -Werror-unused-but-set-*. */
578 /* Exit a binding level.
579 Pop the level off, and restore the state of the identifier-decl mappings
580 that were in effect when this level was entered.
582 If KEEP == 1, this level had explicit declarations, so
583 and create a "block" (a BLOCK node) for the level
584 to record its declarations and subblocks for symbol table output.
586 If FUNCTIONBODY is nonzero, this level is the body of a function,
587 so create a block as if KEEP were set and also clear out all
588 label names.
590 If REVERSE is nonzero, reverse the order of decls before putting
591 them into the BLOCK. */
593 tree
595 {
596 tree link;
597 /* The chain of decls was accumulated in reverse order.
598 Put it into forward order, just for cleanliness. */
599 tree decls;
600 tree subblocks;
601 tree block;
602 tree decl;
603 scope_kind kind;
606 restart:
619 /* We used to use KEEP == 2 to indicate that the new block should go
620 at the beginning of the list of blocks at this binding level,
621 rather than the end. This hack is no longer used. */
627 /* Any uses of undefined labels, and any defined labels, now operate
628 under constraints of next binding contour. */
633 /* Get the decls in the order they were written.
634 Usually current_binding_level->names is in reverse order.
635 But parameter decls were previously put in forward order. */
639 {
642 }
644 /* If there were any declarations or structure tags in that level,
645 or if this level is a function body,
646 create a BLOCK to record them for the life of this function. */
648 /* Avoid function body block if possible. */
654 {
657 }
659 /* In each subblock, record that this is its superior. */
664 /* Before we remove the declarations first check for unused variables. */
669 {
670 /* There are cases where D itself is a TREE_LIST. See in
671 push_local_binding where the list of decls returned by
672 getdecls is built. */
679 /* For structured bindings, consider only real variables, not
680 subobjects. */
688 {
690 {
693 OPT_Wunused_variable,
695 else
699 }
701 // For -Wunused-but-set-variable leave references alone.
704 {
709 else
711 OPT_Wunused_but_set_variable,
714 }
715 }
716 }
718 /* Remove declarations for all the DECLs in this level. */
720 {
721 tree name;
723 {
727 }
728 else
729 {
732 }
734 /* Remove the binding. */
737 else
739 }
741 /* Restore the IDENTIFIER_TYPE_VALUEs. */
746 /* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
747 list if a `using' declaration put them there. The debugging
748 back ends won't understand OVERLOAD, so we remove them here.
749 Because the BLOCK_VARS are (temporarily) shared with
750 CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
751 popped all the bindings. Also remove undeduced 'auto' decls,
752 which LTO doesn't understand, and can't have been used by anything. */
754 {
758 {
760 || (!processing_template_decl
763 else
765 }
766 }
768 /* If the level being exited is the top level of a function,
769 check over all the labels. */
771 {
773 {
774 /* Since this is the top level block of a function, the vars are
775 the function's parameters. Don't leave them in the BLOCK
776 because they are found in the FUNCTION_DECL instead. */
779 }
780 else
782 }
786 {
787 tree stmt;
789 /* If this is a temporary binding created for a cleanup, then we'll
790 have pushed a statement list level. Pop that, create a new
791 BIND_EXPR for the block, and insert it into the stream. */
795 }
799 {
800 /* The current function is being defined, so its DECL_INITIAL
801 should be error_mark_node. */
805 {
807 {
810 }
811 else
813 }
814 }
816 current_binding_level->blocks
819 /* If we did not make a block for the level just exited,
820 any blocks made for inner levels
821 (since they cannot be recorded as subblocks in that level)
822 must be carried forward so they will later become subblocks
823 of something else. */
825 current_binding_level->blocks
828 /* Each and every BLOCK node created here in `poplevel' is important
829 (e.g. for proper debugging information) so if we created one
830 earlier, mark it as "used". */
834 /* All temporary bindings created for cleanups are popped silently. */
839 }
841 /* Call wrapup_globals_declarations for the globals in NAMESPACE. */
842 /* Diagnose odr-used extern inline variables without definitions
843 in the current TU. */
845 int
847 {
849 {
851 {
861 OPT_Wunused_function,
870 }
872 /* Clear out the list, so we don't rescan next time. */
875 /* Write out any globals that need to be output. */
878 }
880 }
881 \f
882 /* In C++, you don't have to write `struct S' to refer to `S'; you
883 can just use `S'. We accomplish this by creating a TYPE_DECL as
884 if the user had written `typedef struct S S'. Create and return
885 the TYPE_DECL for TYPE. */
887 tree
889 {
890 tree decl;
894 /* There are other implicit type declarations, like the one *within*
895 a class that allows you to write `S::S'. We must distinguish
896 amongst these. */
902 }
904 /* Function-scope local entities that need discriminators. Each entry
905 is a {decl,name} pair. VAR_DECLs for anon unions get their name
906 smashed, so we cannot rely on DECL_NAME. */
910 /* Determine the mangling discriminator of local DECL. There are
911 generally very few of these in any particular function. */
913 void
915 {
925 {
933 {
939 /* Replace the saved decl. */
943 }
944 }
947 {
951 }
952 }
954 \f
955 /* True if DECL is a constrained hidden friend as per [temp.friend]/9:
957 A non-template friend declaration with a requires-clause shall be a
958 definition. A friend function template with a constraint that depends on a
959 template parameter from an enclosing template shall be a definition. Such a
960 constrained friend function or function template declaration does not
961 declare the same function or function template as a declaration in any other
962 scope.
964 The ABI calls this a "member-like constrained friend" and mangles it like a
965 member function to avoid collisions. */
967 bool
969 {
976 || (uses_outer_template_parms_in_constraints
978 }
980 /* Returns true if functions FN1 and FN2 have equivalent trailing
981 requires clauses. */
983 static bool
985 {
986 /* In the concepts TS, the combined constraints are compared. */
988 {
994 }
996 /* [temp.friend]/9 "Such a constrained friend function does not declare the
997 same function as a declaration in any other scope." So no need to
998 actually compare the requirements. */
1003 /* Compare only trailing requirements. */
1009 /* Substitution is needed when friends are involved. */
1014 }
1016 /* Two functions of the same name correspond [basic.scope.scope] if
1018 + both declare functions with the same non-object-parameter-type-list,
1019 equivalent ([temp.over.link]) trailing requires-clauses (if any, except as
1020 specified in [temp.friend]), and, if both are non-static members, they have
1021 corresponding object parameters, or
1023 + both declare function templates with equivalent
1024 non-object-parameter-type-lists, return types (if any), template-heads, and
1025 trailing requires-clauses (if any), and, if both are non-static members,
1026 they have corresponding object parameters.
1028 This is a subset of decls_match: it identifies declarations that cannot be
1029 overloaded with one another. This function does not consider DECL_NAME. */
1031 bool
1033 {
1038 {
1043 }
1051 /* If only one is a non-static member function, ignore ref-quals. */
1054 /* Two non-static member functions have corresponding object parameters if:
1055 + exactly one is an implicit object member function with no ref-qualifier
1056 and the types of their object parameters ([dcl.fct]), after removing
1057 top-level references, are the same, or
1058 + their object parameters have the same type. */
1059 /* ??? We treat member functions of different classes as corresponding even
1060 though that means the object parameters have different types. */
1067 {
1071 }
1073 /* Two function declarations match if either has a requires-clause
1074 then both have a requires-clause and their constraints-expressions
1075 are equivalent. */
1080 }
1082 /* Subroutine of duplicate_decls: return truthvalue of whether
1083 or not types of these decls match.
1085 For C++, we must compare the parameter list so that `int' can match
1086 `int&' in a parameter position, but `int&' is not confused with
1087 `const int&'. */
1089 int
1091 {
1098 /* If the two DECLs are not even the same kind of thing, we're not
1099 interested in their types. */
1105 {
1106 /* Specializations of different templates are different functions
1107 even if they have the same type. */
1122 /* A new declaration doesn't match a built-in one unless it
1123 is also extern "C". */
1133 /* A declaration with deduced return type should use its pre-deduction
1134 type for declaration matching. */
1142 {
1145 {
1149 }
1150 else
1151 types_match =
1157 }
1158 else
1161 /* Two function declarations match if either has a requires-clause
1162 then both have a requires-clause and their constraints-expressions
1163 are equivalent. */
1167 /* The decls dont match if they correspond to two different versions
1168 of the same function. Disallow extern "C" functions to be
1169 versions for now. */
1174 {
1180 }
1181 }
1183 {
1193 /* Two template types match if they are the same. Otherwise, compare
1194 the underlying declarations. */
1197 else
1199 }
1200 else
1201 {
1202 /* Need to check scope for variable declaration (VAR_DECL).
1203 For typedef (TYPE_DECL), scope is ignored. */
1206 /* [dcl.link]
1207 Two declarations for an object with C language linkage
1208 with the same name (ignoring the namespace that qualify
1209 it) that appear in different namespace scopes refer to
1210 the same object. */
1220 else
1223 COMPARE_REDECLARATION);
1224 }
1227 }
1229 /* Mark DECL as versioned if it isn't already. */
1231 static void
1233 {
1235 {
1237 /* If DECL_ASSEMBLER_NAME has already been set, re-mangle
1238 to include the version marker. */
1241 }
1242 }
1244 /* NEWDECL and OLDDECL have identical signatures. If they are
1245 different versions adjust them and return true.
1246 If RECORD is set to true, record function versions. */
1248 bool
1250 {
1256 {
1259 }
1263 {
1264 /* Unfortunately, we can get here before pushdecl naturally calls
1265 push_local_extern_decl_alias, so we need to call it directly. */
1270 }
1276 }
1278 /* If NEWDECL is `static' and an `extern' was seen previously,
1279 warn about it. OLDDECL is the previous declaration.
1281 Note that this does not apply to the C++ case of declaring
1282 a variable `extern const' and then later `const'.
1284 Don't complain about built-in functions, since they are beyond
1285 the user's control. */
1287 void
1289 {
1296 /* Don't get confused by static member functions; that's a different
1297 use of `static'. */
1302 /* If the old declaration was `static', or the new one isn't, then
1303 everything is OK. */
1307 /* It's OK to declare a builtin function as `static'. */
1312 auto_diagnostic_group d;
1317 }
1319 /* NEW_DECL is a redeclaration of OLD_DECL; both are functions or
1320 function templates. If their exception specifications do not
1321 match, issue a diagnostic. */
1323 static void
1325 tree old_decl)
1326 {
1330 /* Two default specs are equivalent, don't force evaluation. */
1336 {
1339 }
1343 /* [except.spec]
1345 If any declaration of a function has an exception-specification,
1346 all declarations, including the definition and an explicit
1347 specialization, of that function shall have an
1348 exception-specification with the same set of type-ids. */
1352 {
1357 auto_diagnostic_group d;
1361 /* We used to silently permit mismatched eh specs with
1362 -fno-exceptions, so make them a pedwarn now. */
1364 else
1369 }
1370 }
1372 /* Return true if OLD_DECL and NEW_DECL agree on constexprness.
1373 Otherwise issue diagnostics. */
1375 static bool
1377 {
1385 {
1391 }
1393 {
1394 /* With -fimplicit-constexpr, ignore changes in the constexpr
1395 keyword. */
1401 {
1402 /* Hide a built-in declaration. */
1408 }
1409 /* 7.1.5 [dcl.constexpr]
1410 Note: An explicit specialization can differ from the template
1411 declaration with respect to the constexpr specifier. */
1421 "redeclaration %qD differs in %qs "
1423 kind);
1427 }
1429 }
1431 // If OLDDECL and NEWDECL are concept declarations with the same type
1432 // (i.e., and template parameters), but different requirements,
1433 // emit diagnostics and return true. Otherwise, return false.
1436 {
1448 {
1453 {
1456 }
1457 }
1459 }
1461 /* DECL is a redeclaration of a function or function template. If
1462 it does have default arguments issue a diagnostic. Note: this
1463 function is used to enforce the requirements in C++11 8.3.6 about
1464 no default arguments in redeclarations. */
1466 static void
1468 {
1474 {
1476 "redeclaration of %q#D may not have default "
1479 }
1480 }
1482 /* NEWDECL is a redeclaration of a function or function template OLDDECL,
1483 in any case represented as FUNCTION_DECLs (the DECL_TEMPLATE_RESULTs of
1484 the TEMPLATE_DECLs in case of function templates). This function is used
1485 to enforce the final part of C++17 11.3.6/4, about a single declaration:
1486 "If a friend declaration specifies a default argument expression, that
1487 declaration shall be a definition and shall be the only declaration of
1488 the function or function template in the translation unit." */
1490 static void
1492 {
1502 {
1503 auto_diagnostic_group d;
1505 "friend declaration of %q#D specifies default "
1510 }
1511 }
1513 /* Merge tree bits that correspond to attributes noreturn, nothrow,
1514 const, malloc, and pure from NEWDECL with those of OLDDECL. */
1516 static void
1518 {
1531 }
1533 #define GNU_INLINE_P(fn) (DECL_DECLARED_INLINE_P (fn) \
1535 DECL_ATTRIBUTES (fn)))
1537 /* A subroutine of duplicate_decls. Emits a diagnostic when newdecl
1538 ambiguates olddecl. Returns true if an error occurs. */
1540 static bool
1542 {
1546 /* Function template declarations can be differentiated by parameter
1547 and return type. */
1552 {
1553 /* ... and also by their template-heads and requires-clauses. */
1556 {
1561 }
1563 /* FIXME: The types are the same but the are differences
1564 in either the template heads or function requirements.
1565 We should be able to diagnose a set of common errors
1566 stemming from these declarations. For example:
1568 template<typename T> requires C void f(...);
1569 template<typename T> void f(...) requires C;
1571 These are functionally equivalent but not equivalent. */
1572 }
1575 }
1577 /* OLD_PARMS is the innermost set of template parameters for some template
1578 declaration, and NEW_PARMS is the corresponding set of template parameters
1579 for a redeclaration of that template. Merge the default arguments within
1580 these two sets of parameters. CLASS_P is true iff the template in
1581 question is a class template. */
1583 bool
1585 {
1589 {
1597 {
1598 auto_diagnostic_group d;
1603 }
1605 /* Update the previous template parameters (which are the ones
1606 that will really count) with the new default value. */
1609 /* Update the new parameters, too; they'll be used as the
1610 parameters for any members. */
1612 }
1614 }
1616 /* If NEWDECL is a redeclaration of OLDDECL, merge the declarations.
1617 If the redeclaration is invalid, a diagnostic is issued, and the
1618 error_mark_node is returned. Otherwise, OLDDECL is returned.
1620 If NEWDECL is not a redeclaration of OLDDECL, NULL_TREE is
1621 returned.
1623 HIDING is true if the new decl is being hidden. WAS_HIDDEN is true
1624 if the old decl was hidden.
1626 Hidden decls can be anticipated builtins, injected friends, or
1627 (coming soon) injected from a local-extern decl. */
1629 tree
1631 {
1635 tree new_template_info;
1644 /* If either the type of the new decl or the type of the old decl is an
1645 error_mark_node, then that implies that we have already issued an
1646 error (earlier) for some bogus type specification, and in that case,
1647 it is rather pointless to harass the user with yet more error message
1648 about the same declaration, so just pretend the types match here. */
1653 /* Check for redeclaration and other discrepancies. */
1656 {
1658 {
1659 /* Avoid warnings redeclaring built-ins which have not been
1660 explicitly declared. */
1662 {
1666 OPT_Wbuiltin_declaration_mismatch,
1668 newdecl);
1670 }
1672 /* If you declare a built-in or predefined function name as static,
1673 the old definition is overridden, but optionally warn this was a
1674 bad choice of name. */
1676 {
1678 OPT_Wshadow,
1682 /* Discard the old built-in function. */
1684 }
1685 /* If the built-in is not ansi, then programs can override
1686 it even globally without an error. */
1691 else
1693 "declaration of %q#D conflicts with built-in "
1696 }
1698 {
1699 /* Avoid warnings redeclaring built-ins which have not been
1700 explicitly declared. */
1702 {
1705 /* A new declaration doesn't match a built-in one unless it
1706 is also extern "C". */
1716 {
1719 /* FILE, tm types are not known at the time
1720 we create the builtins. */
1726 {
1733 {
1743 }
1745 }
1749 next_arg:;
1750 }
1753 OPT_Wbuiltin_declaration_mismatch,
1754 "declaration of %q#D conflicts with built-in "
1756 }
1761 {
1762 /* Don't really override olddecl for __* prefixed builtins
1763 except for __[^b]*_chk, the compiler might be using those
1764 explicitly. */
1766 {
1777 {
1779 {
1781 "definition of %q#D ambiguates built-in "
1784 }
1785 auto_diagnostic_group d;
1787 "new declaration %q#D ambiguates built-in"
1793 }
1794 }
1796 /* A near match; override the builtin. */
1800 OPT_Wbuiltin_declaration_mismatch,
1801 "new declaration %q#D ambiguates built-in "
1803 else
1808 }
1809 else
1810 /* Discard the old built-in function. */
1813 /* Replace the old RTL to avoid problems with inlining. */
1815 }
1816 else
1817 {
1818 /* Even if the types match, prefer the new declarations type
1819 for built-ins which have not been explicitly declared,
1820 for exception lists, etc... */
1827 }
1829 /* If a function is explicitly declared "throw ()", propagate that to
1830 the corresponding builtin. */
1832 && was_hidden
1835 {
1840 }
1842 /* Whether or not the builtin can throw exceptions has no
1843 bearing on this declarator. */
1847 {
1848 /* If a builtin function is redeclared as `static', merge
1849 the declarations, but make the original one static. */
1853 /* Make the old declaration consistent with the new one so
1854 that all remnants of the builtin-ness of this function
1855 will be banished. */
1858 }
1859 }
1861 {
1862 /* C++ Standard, 3.3, clause 4:
1863 "[Note: a namespace name or a class template name must be unique
1864 in its declarative region (7.3.2, clause 14). ]" */
1885 {
1886 /* One is a function and the other is a template
1887 function. */
1891 /* There can only be one! */
1895 "literal operator %q#D conflicts with"
1899 "raw literal operator %q#D conflicts with"
1901 else
1906 }
1912 /* One is an implicit typedef, that's ok. */
1919 }
1921 {
1923 /* These are certainly not duplicate declarations; they're
1924 from different scopes. */
1928 {
1932 /* The name of a class template may not be declared to refer to
1933 any other template, class, function, object, namespace, value,
1934 or type in the same scope. */
1937 {
1943 }
1947 {
1951 }
1955 }
1957 {
1959 {
1962 newdecl);
1966 }
1967 /* For function versions, params and types match, but they
1968 are not ambiguous. */
1971 /* Let constrained hidden friends coexist for now, we'll
1972 check satisfaction later. */
1975 // The functions have the same parameter types.
1978 // And the same constraints.
1980 {
1986 }
1987 else
1989 }
1990 else
1991 {
1996 }
1997 }
2000 {
2001 /* OMP UDRs are never duplicates. */
2008 }
2018 /* It's OK to have a template specialization and a non-template
2019 with the same type, or to have specializations of two
2020 different templates with the same type. Note that if one is a
2021 specialization, and the other is an instantiation of the same
2022 template, that we do not exit at this point. That situation
2023 can occur if we instantiate a template class, and then
2024 specialize one of its methods. This situation is valid, but
2025 the declarations must be merged in the usual way. */
2032 /* One of the declarations is a template instantiation, and the
2033 other is not a template at all. That's OK. */
2036 {
2037 /* In [namespace.alias] we have:
2039 In a declarative region, a namespace-alias-definition can be
2040 used to redefine a namespace-alias declared in that declarative
2041 region to refer only to the namespace to which it already
2042 refers.
2044 Therefore, if we encounter a second alias directive for the same
2045 alias, we can just ignore the second directive. */
2051 /* Leave it to update_binding to merge or report error. */
2053 }
2054 else
2055 {
2058 {
2059 auto_diagnostic_group d;
2067 }
2072 {
2073 /* Prototype decl follows defn w/o prototype. */
2074 auto_diagnostic_group d;
2079 }
2082 {
2083 /* [dcl.link]
2084 If two declarations of the same function or object
2085 specify different linkage-specifications ..., the program
2086 is ill-formed.... Except for functions with C++ linkage,
2087 a function declaration without a linkage specification
2088 shall not precede the first linkage specification for
2089 that function. A function can be declared without a
2090 linkage specification after an explicit linkage
2091 specification has been seen; the linkage explicitly
2092 specified in the earlier declaration is not affected by
2093 such a function declaration.
2095 DR 563 raises the question why the restrictions on
2096 functions should not also apply to objects. Older
2097 versions of G++ silently ignore the linkage-specification
2098 for this example:
2100 namespace N {
2101 extern int i;
2102 extern "C" int i;
2103 }
2105 which is clearly wrong. Therefore, we now treat objects
2106 like functions. */
2108 {
2109 /* There is no explicit linkage-specification, so we use
2110 the linkage from the previous declaration. */
2113 }
2114 else
2115 {
2116 auto_diagnostic_group d;
2123 }
2124 }
2127 ;
2129 {
2130 /* Note: free functions, as TEMPLATE_DECLs, are handled below. */
2133 as FUNCTION_DECLs. */
2135 /* C++11 8.3.6/6.
2136 Default arguments for a member function of a class
2137 template shall be specified on the initial declaration
2138 of the member function within the class template. */
2140 {
2145 {
2149 tree old_parms
2153 }
2154 }
2155 else
2156 {
2164 {
2167 {
2168 auto_diagnostic_group d;
2170 "default argument given for parameter "
2174 olddecl);
2175 }
2176 else
2177 {
2178 auto_diagnostic_group d;
2180 "default argument given for parameter %d "
2184 olddecl);
2185 }
2186 }
2188 /* C++17 11.3.6/4: "If a friend declaration specifies a default
2189 argument expression, that declaration... shall be the only
2190 declaration of the function or function template in the
2191 translation unit." */
2193 }
2194 }
2195 }
2197 /* Do not merge an implicit typedef with an explicit one. In:
2199 class A;
2200 ...
2201 typedef class A A __attribute__ ((foo));
2203 the attribute should apply only to the typedef. */
2219 {
2221 {
2224 else
2225 {
2228 }
2231 }
2235 {
2238 {
2241 }
2242 }
2245 }
2247 /* We have committed to returning OLDDECL at this point. */
2249 /* If new decl is `static' and an `extern' was seen previously,
2250 warn about it. */
2253 /* True to merge attributes between the declarations, false to
2254 set OLDDECL's attributes to those of NEWDECL (for template
2255 explicit specializations that specify their own attributes
2256 independent of those specified for the primary template). */
2262 {
2264 {
2270 /* [dcl.attr.noreturn]: The first declaration of a function shall
2271 specify the noreturn attribute if any declaration of that function
2272 specifies the noreturn attribute. */
2273 tree a;
2276 /* This applies to [[noreturn]] only, not its GNU variants. */
2280 {
2284 }
2285 }
2287 /* Now that functions must hold information normally held
2288 by field decls, there is extra work to do so that
2289 declaration information does not get destroyed during
2290 definition. */
2312 /* Optionally warn about more than one declaration for the same
2313 name, but don't warn about a function declaration followed by a
2314 definition. */
2317 /* Don't warn about extern decl followed by definition. */
2319 /* Don't warn if at least one is/was hidden. */
2321 /* Don't warn about declaration followed by specialization. */
2324 {
2325 auto_diagnostic_group d;
2327 OPT_Wredundant_decls,
2329 newdecl))
2332 }
2334 /* [dcl.fct.def.delete] A deleted definition of a function shall be the
2335 first declaration of the function or, for an explicit specialization
2336 of a function template, the first declaration of that
2337 specialization. */
2340 {
2342 {
2343 auto_diagnostic_group d;
2348 }
2350 }
2351 }
2353 /* Deal with C++: must preserve virtual function table size. */
2355 {
2365 }
2367 /* Copy all the DECL_... slots specified in the new decl except for
2368 any that we copy here from the old type. */
2372 else
2376 {
2381 /* The new decl should not already have gathered any
2382 specializations. */
2385 /* Make sure the contracts are equivalent. */
2388 /* Remove contracts from old_result so they aren't appended to
2389 old_result by the merge function. */
2396 {
2399 {
2400 /* Per C++11 8.3.6/4, default arguments cannot be added in
2401 later declarations of a function template. */
2403 /* C++17 11.3.6/4: "If a friend declaration specifies a default
2404 argument expression, that declaration... shall be the only
2405 declaration of the function or function template in the
2406 translation unit." */
2407 check_no_redeclaration_friend_default_args
2414 }
2422 {
2425 else
2436 }
2437 else
2438 {
2446 }
2447 }
2449 /* If the new declaration is a definition, update the file and
2450 line information on the declaration, and also make
2451 the old declaration the same definition. */
2453 {
2459 {
2466 }
2467 }
2470 }
2473 {
2477 /* Automatically handles default parameters. */
2479 tree newtype;
2481 /* For typedefs use the old type, as the new type's DECL_NAME points
2482 at newdecl, which will be ggc_freed. */
2484 {
2485 /* But NEWTYPE might have an attribute, honor that. */
2490 {
2494 }
2496 /* And remove the new type from the variants list. */
2498 {
2501 {
2503 /* If remove is the main variant, no need to remove that
2504 from the list. One of the DECL_ORIGINAL_TYPE
2505 variants, e.g. created for aligned attribute, might still
2506 refer to the newdecl TYPE_DECL though, so remove that one
2507 in that case. */
2513 {
2517 }
2518 }
2519 else
2523 {
2526 }
2527 }
2528 }
2531 else
2535 {
2537 /* For already initialized vars, TREE_READONLY could have been
2538 cleared in cp_finish_decl, because the var needs runtime
2539 initialization or destruction. Make sure not to set
2540 TREE_READONLY on it again. */
2557 /* Merge the threadprivate attribute from OLDDECL into NEWDECL. */
2560 {
2561 /* Allocate a LANG_SPECIFIC structure for NEWDECL, if needed. */
2564 }
2565 }
2567 /* An explicit specialization of a function template or of a member
2568 function of a class template can be declared transaction_safe
2569 independently of whether the corresponding template entity is declared
2570 transaction_safe. */
2583 /* Lay the type out, unless already done. */
2597 /* Merge deprecatedness. */
2601 /* Merge unavailability. */
2605 /* Preserve function specific target and optimization options */
2607 {
2620 }
2621 else
2622 {
2623 /* Merge the const type qualifier. */
2626 /* Merge the volatile type qualifier. */
2629 }
2631 /* Merge the initialization information. */
2634 {
2638 {
2641 }
2642 }
2645 {
2658 else
2659 {
2660 /* Merge the noreturn bit. */
2666 }
2667 /* Keep the old RTL. */
2669 }
2672 {
2673 /* Keep the old RTL. We cannot keep the old RTL if the old
2674 declaration was for an incomplete object and the new
2675 declaration is not since many attributes of the RTL will
2676 change. */
2678 }
2679 }
2680 /* If cannot merge, then use the new type and qualifiers,
2681 and don't preserve the old rtl. */
2682 else
2683 {
2684 /* Clean out any memory we had of the old declaration. */
2694 }
2696 /* Merge the storage class information. */
2708 {
2710 /* This can happen if olddecl was brought in from the
2711 enclosing namespace via a using-decl. The new decl is
2712 then not a block-scope extern at all. */
2714 else
2715 {
2723 }
2724 }
2728 {
2740 {
2744 }
2747 {
2752 /* If the OLDDECL is an instantiation and/or specialization,
2753 then the NEWDECL must be too. But, it may not yet be marked
2754 as such if the caller has created NEWDECL, but has not yet
2755 figured out that it is a redeclaration. */
2762 }
2764 /* Don't really know how much of the language-specific
2765 values we should copy from old to new. */
2769 {
2772 {
2776 /* Remember the presence of explicit specialization args. */
2779 }
2781 /* We don't want to copy template info from a non-templated friend
2782 (PR105761), but these shouldn't have DECL_TEMPLATE_INFO now. */
2786 }
2789 {
2790 /* Only functions have these fields. */
2795 /* DECL_THUNKS is only valid for virtual functions,
2796 otherwise it is a DECL_FRIEND_CONTEXT. */
2801 }
2803 {
2804 /* Only variables have this field. */
2807 }
2808 }
2811 {
2812 tree parm;
2814 /* Merge parameter attributes. */
2819 {
2823 }
2827 {
2828 /* If newdecl is not a specialization, then it is not a
2829 template-related function at all. And that means that we
2830 should have exited above, returning 0. */
2834 /* From [temp.expl.spec]:
2836 If a template, a member template or the member of a class
2837 template is explicitly specialized then that
2838 specialization shall be declared before the first use of
2839 that specialization that would cause an implicit
2840 instantiation to take place, in every translation unit in
2841 which such a use occurs. */
2843 olddecl);
2849 /* Don't propagate visibility from the template to the
2850 specialization here. We'll do that in determine_visibility if
2851 appropriate. */
2854 /* [temp.expl.spec/14] We don't inline explicit specialization
2855 just because the primary template says so. */
2865 }
2867 {
2868 /* Never inline re-defined extern inline functions.
2869 FIXME: this could be better handled by keeping both
2870 function as separate declarations. */
2872 }
2873 else
2874 {
2876 {
2880 }
2882 ;
2896 }
2898 /* Preserve abstractness on cloned [cd]tors. */
2901 /* Update newdecl's parms to point at olddecl. */
2907 {
2911 }
2913 {
2914 /* These are the final DECL_ARGUMENTS that will be used within the
2915 body; update any references to old DECL_ARGUMENTS in the
2916 contracts, if present. */
2920 /* These need to be copied so that the names are available.
2921 Note that if the types do match, we'll preserve inline
2922 info and other bits, but if not, we won't. */
2926 /* In some cases, duplicate_contracts will remove contracts from
2927 OLDDECL, to avoid duplications. Sometimes, the contracts end up
2928 shared. If we removed them, re-add them. */
2931 }
2932 /* If redeclaring a builtin function, it stays built in
2933 if newdecl is a gnu_inline definition, or if newdecl is just
2934 a declaration. */
2937 {
2939 /* If we're keeping the built-in definition, keep the rtl,
2940 regardless of declaration matches. */
2943 {
2946 {
2947 /* A compatible prototype of these builtin functions
2948 is seen, assume the runtime implements it with
2949 the expected semantics. */
2951 {
2958 }
2959 }
2962 }
2963 }
2965 /* If defining a function declared with other language
2966 linkage, use the previously declared language linkage. */
2969 {
2971 /* Don't clear out the arguments if we're just redeclaring a
2972 function. */
2974 {
2975 /* If we removed contracts from previous definition, re-attach
2976 them. Otherwise, rewrite the contracts so they match the
2977 parameters of the new declaration. */
2982 else
2983 {
2984 /* Temporarily undo the re-contexting of parameters so we can
2985 actually remap parameters. The inliner won't replace
2986 parameters if we don't do this. */
2991 /* Save new argument names for use in contracts parsing,
2992 unless we've already started parsing the body of olddecl
2993 (particular issues arise when newdecl is from a prior
2994 friend decl with no argument names, see
2995 modules/contracts-tpl-friend-1). */
2999 /* And reverse this operation again. */
3002 }
3005 }
3006 }
3007 }
3011 /* Now preserve various other info from the definition. */
3017 /* Warn about conflicting visibility specifications. */
3021 {
3022 auto_diagnostic_group d;
3024 "%qD: visibility attribute ignored because it "
3028 }
3029 /* Choose the declaration which specified visibility. */
3031 {
3034 }
3035 /* Init priority used to be merged from newdecl to olddecl by the memcpy,
3036 so keep this behavior. */
3038 {
3041 }
3042 /* Likewise for DECL_ALIGN, DECL_USER_ALIGN and DECL_PACKED. */
3044 {
3047 }
3060 /* The DECL_LANG_SPECIFIC information in OLDDECL will be replaced
3061 with that from NEWDECL below. */
3063 {
3067 }
3069 /* Merge the USED information. */
3076 {
3081 }
3088 /* Merge the DECL_FUNCTION_VERSIONED information. newdecl will be copied
3089 to olddecl and deleted. */
3092 {
3093 /* Set the flag for newdecl so that it gets copied to olddecl. */
3095 /* newdecl will be purged after copying to olddecl and is no longer
3096 a version. */
3098 }
3101 {
3115 /* Preserve symtab node mapping. */
3119 /* If newdecl is a template instantiation, it is possible that
3120 the following sequence of events has occurred:
3122 o A friend function was declared in a class template. The
3123 class template was instantiated.
3125 o The instantiation of the friend declaration was
3126 recorded on the instantiation list, and is newdecl.
3128 o Later, however, instantiate_class_template called pushdecl
3129 on the newdecl to perform name injection. But, pushdecl in
3130 turn called duplicate_decls when it discovered that another
3131 declaration of a global function with the same name already
3132 existed.
3134 o Here, in duplicate_decls, we decided to clobber newdecl.
3136 If we're going to do that, we'd better make sure that
3137 olddecl, and not newdecl, is on the list of
3138 instantiations so that if we try to do the instantiation
3139 again we won't get the clobbered declaration. */
3141 new_template_info,
3142 olddecl);
3143 }
3144 else
3145 {
3153 {
3161 {
3174 }
3182 }
3183 }
3186 {
3190 {
3191 /* Merge the section attribute.
3192 We want to issue an error if the sections conflict but that must be
3193 done later in decl_attributes since we are called before attributes
3194 are assigned. */
3199 {
3203 else
3207 }
3208 }
3212 {
3216 }
3217 }
3221 /* NEWDECL contains the merged attribute lists.
3222 Update OLDDECL to be the same. */
3225 /* If OLDDECL had its DECL_RTL instantiated, re-invoke make_decl_rtl
3226 so that encode_section_info has a chance to look at the new decl
3227 flags and attributes. */
3234 /* The NEWDECL will no longer be needed. Because every out-of-class
3235 declaration of a member results in a call to duplicate_decls,
3236 freeing these nodes represents in a significant savings.
3238 Before releasing the node, be sore to remove function from symbol
3239 table that might have been inserted there to record comdat group.
3240 Be sure to however do not free DECL_STRUCT_FUNCTION because this
3241 structure is shared in between newdecl and oldecl. */
3245 {
3249 }
3252 {
3253 tree clone;
3255 {
3258 }
3259 }
3261 /* Remove the associated constraints for newdecl, if any, before
3262 reclaiming memory. */
3269 }
3270 \f
3271 /* Return zero if the declaration NEWDECL is valid
3272 when the declaration OLDDECL (assumed to be for the same name)
3273 has already been seen.
3274 Otherwise return an error message format string with a %s
3275 where the identifier should go. */
3279 {
3281 {
3282 /* Because C++ can put things into name space for free,
3283 constructs like "typedef struct foo { ... } foo"
3284 would look like an erroneous redeclaration. */
3287 else
3289 }
3291 {
3292 /* If this is a pure function, its olddecl will actually be
3293 the original initialization to `0' (which we force to call
3294 abort()). Don't complain about redefinition in this case. */
3299 /* If both functions come from different namespaces, this is not
3300 a redeclaration - this is a conflict with a used function. */
3306 /* We'll complain about linkage mismatches in
3307 warn_extern_redeclared_static. */
3309 /* Defining the same name twice is no good. */
3312 {
3318 }
3321 {
3326 {
3330 else
3333 }
3334 }
3336 /* [class.compare.default]: A definition of a comparison operator as
3337 defaulted that appears in a class shall be the first declaration of
3338 that function. */
3344 check_abi_tag_redeclaration
3349 }
3351 {
3375 {
3380 {
3384 else
3387 }
3388 }
3390 /* Core issue #226 (C++11):
3392 If a friend function template declaration specifies a
3393 default template-argument, that declaration shall be a
3394 definition and shall be the only declaration of the
3395 function template in the translation unit. */
3406 }
3413 {
3414 /* Only variables can be thread-local, and all declarations must
3415 agree on this property. */
3419 else
3422 }
3424 {
3425 /* The objects have been declared at namespace scope. If either
3426 is a member of an anonymous union, then this is an invalid
3427 redeclaration. For example:
3429 int i;
3430 union { int i; };
3432 is invalid. */
3436 /* If at least one declaration is a reference, there is no
3437 conflict. For example:
3439 int i = 3;
3440 extern int i;
3442 is valid. */
3446 /* Static data member declared outside a class definition
3447 if the variable is defined within the class with constexpr
3448 specifier is declaration rather than definition (and
3449 deprecated). */
3455 {
3457 /* For now, only warn with explicit -Wdeprecated. */
3459 {
3460 auto_diagnostic_group d;
3462 "redundant redeclaration of %<constexpr%> "
3466 }
3468 }
3470 /* Reject two definitions. */
3472 }
3473 else
3474 {
3475 /* Objects declared with block scope: */
3476 /* Reject two definitions, and reject a definition
3477 together with an external reference. */
3481 }
3482 }
3483 \f
3485 /* Hash and equality functions for the named_label table. */
3487 hashval_t
3489 {
3491 }
3493 bool
3495 {
3497 }
3499 /* Look for a label named ID in the current function. If one cannot
3500 be found, create one. Return the named_label_entry, or NULL on
3501 failure. */
3505 {
3508 /* You can't use labels at global scope. */
3510 {
3513 }
3519 named_label_entry **slot
3524 {
3529 {
3533 }
3534 }
3536 /* We are making a new decl, create or reuse the named_label_entry */
3540 else
3541 {
3546 }
3548 /* Now create the LABEL_DECL. */
3554 {
3558 }
3563 }
3565 /* Wrapper for lookup_label_1. */
3567 tree
3569 {
3572 }
3574 tree
3576 {
3579 }
3581 /* Returns true if it is ill-formed to jump past the declaration of DECL. */
3583 static bool
3585 {
3586 /* [stmt.dcl]/3: A program that jumps from a point where a local variable
3587 with automatic storage duration is not in scope to a point where it is
3588 in scope is ill-formed unless the variable has scalar type, class type
3589 with a trivial default constructor and a trivial destructor, a
3590 cv-qualified version of one of these types, or an array of one of the
3591 preceding types and is declared without an initializer (8.5). */
3599 }
3601 /* A subroutine of check_previous_goto_1 and check_goto to identify a branch
3602 to the user. */
3604 static bool
3606 diagnostic_t diag_kind)
3607 {
3608 bool complained
3615 }
3617 /* Check that a single previously seen jump to a newly defined label
3618 is OK. DECL is the LABEL_DECL or 0; LEVEL is the binding_level for
3619 the jump context; NAMES are the names in scope in LEVEL at the jump
3620 context; LOCUS is the source position of the jump or 0. Returns
3621 true if all is well. */
3623 static bool
3626 {
3634 {
3640 }
3643 {
3649 {
3655 {
3658 }
3662 }
3670 {
3703 {
3707 }
3709 {
3713 }
3718 }
3721 {
3727 }
3728 }
3731 }
3733 static void
3735 {
3739 }
3741 static bool
3743 {
3745 }
3747 /* Check that a new jump to a label DECL is OK. Called by
3748 finish_goto_stmt. */
3750 void
3752 {
3753 /* We can't know where a computed goto is jumping.
3754 So we assume that it's OK. */
3759 named_label_entry **slot
3763 /* If the label hasn't been defined yet, defer checking. */
3765 {
3766 /* Don't bother creating another use if the last goto had the
3767 same data, and will therefore create the same set of errors. */
3772 named_label_use_entry *new_use
3782 }
3786 tree bad;
3793 {
3802 }
3805 {
3809 {
3810 /* Can't skip init of __exception_info. */
3812 {
3816 }
3820 }
3824 }
3827 {
3840 }
3843 {
3846 }
3849 {
3853 {
3855 {
3860 }
3864 }
3865 }
3866 }
3868 /* Check that a return is ok wrt OpenMP structured blocks.
3869 Called by finish_return_stmt. Returns true if all is well. */
3871 bool
3873 {
3876 {
3879 }
3883 }
3885 /* Define a label, specifying the location in the source file.
3886 Return the LABEL_DECL node for the label. */
3888 tree
3890 {
3893 /* After labels, make any new cleanups in the function go into their
3894 own new (temporary) binding contour. */
3904 {
3907 }
3908 else
3909 {
3910 /* Mark label as having been defined. */
3912 /* Say where in the source. */
3921 }
3924 }
3926 struct cp_switch
3927 {
3930 /* The SWITCH_STMT being built. */
3931 tree switch_stmt;
3932 /* A splay-tree mapping the low element of a case range to the high
3933 element, or NULL_TREE if there is no high element. Used to
3934 determine whether or not a new case label duplicates an old case
3935 label. We need a tree, rather than simply a hash table, because
3936 of the GNU case range extension. */
3937 splay_tree cases;
3938 /* Remember whether a default: case label has been seen. */
3940 /* Remember whether a BREAK_STMT has been seen in this SWITCH_STMT. */
3942 /* Set if inside of {FOR,DO,WHILE}_BODY nested inside of a switch,
3943 where BREAK_STMT doesn't belong to the SWITCH_STMT. */
3945 };
3947 /* A stack of the currently active switch statements. The innermost
3948 switch statement is on the top of the stack. There is no need to
3949 mark the stack for garbage collection because it is only active
3950 during the processing of the body of a function, and we never
3951 collect at that point. */
3955 /* Called right after a switch-statement condition is parsed.
3956 SWITCH_STMT is the switch statement being parsed. */
3958 void
3960 {
3970 }
3972 void
3974 {
3977 /* Emit warnings as needed. */
3980 const bool bool_cond_p
3986 bool_cond_p);
3988 /* For the benefit of block_may_fallthru remember if the switch body
3989 case labels cover all possible values and if there are break; stmts. */
3991 || (!processing_template_decl
3997 /* Now that we're done with the switch warnings, set the switch type
3998 to the type of the condition if the index type was of scoped enum type.
3999 (Such types don't participate in the integer promotions.) We do this
4000 because of bit-fields whose declared type is a scoped enum type:
4001 gimplification will use the lowered index type, but convert the
4002 case values to SWITCH_STMT_TYPE, which would have been the declared type
4003 and verify_gimple_switch doesn't accept that. */
4010 }
4012 /* Note that a BREAK_STMT is about to be added. If it is inside of
4013 a SWITCH_STMT and not inside of a loop body inside of it, note
4014 in switch_stack we've seen a BREAK_STMT. */
4016 void
4018 {
4021 }
4023 /* Note the start of processing of an iteration statement's body.
4024 The note_break_stmt function will do nothing while processing it.
4025 Return a flag that should be passed to note_iteration_stmt_body_end. */
4027 bool
4029 {
4035 }
4037 /* Note the end of processing of an iteration statement's body. */
4039 void
4041 {
4044 }
4046 /* Convert a case constant VALUE in a switch to the type TYPE of the switch
4047 condition. Note that if TYPE and VALUE are already integral we don't
4048 really do the conversion because the language-independent
4049 warning/optimization code will work better that way. */
4051 static tree
4053 {
4063 /* The constant-expression VALUE shall be a converted constant expression
4064 of the adjusted type of the switch condition, which doesn't allow
4065 narrowing conversions. */
4072 else
4073 /* The already integral case. */
4077 }
4079 /* Note that we've seen a definition of a case label, and complain if this
4080 is a bad place for one. */
4082 tree
4084 {
4087 tree type;
4093 {
4094 tree label;
4096 /* For templates, just add the case label; we'll do semantic
4097 analysis at instantiation-time. */
4100 }
4102 /* Find the condition on which this switch statement depends. */
4119 /* After labels, make any new cleanups in the function go into their
4120 own new (temporary) binding contour. */
4127 }
4128 \f
4130 tree scope;
4131 tree name;
4132 tree template_id;
4135 };
4138 {
4141 /* Hash a TYPENAME_TYPE. */
4143 static hashval_t
4145 {
4150 }
4152 static hashval_t
4154 {
4156 }
4158 static hashval_t
4160 {
4162 }
4164 /* Compare two TYPENAME_TYPEs. */
4166 static bool
4168 {
4174 }
4175 };
4177 /* Build a TYPENAME_TYPE. If the type is `typename T::t', CONTEXT is
4178 the type of `T', NAME is the IDENTIFIER_NODE for `t'.
4180 Returns the new TYPENAME_TYPE. */
4184 tree
4187 {
4188 typename_info ti;
4202 /* See if we already have this type. */
4207 else
4208 {
4209 /* Build the TYPENAME_TYPE. */
4216 /* Build the corresponding TYPE_DECL. */
4223 /* Store it in the hash table. */
4226 /* TYPENAME_TYPEs must always be compared structurally, because
4227 they may or may not resolve down to another type depending on
4228 the currently open classes. */
4230 }
4233 }
4235 /* Resolve `typename CONTEXT::NAME'. TAG_TYPE indicates the tag
4236 provided to name the type. Returns an appropriate type, unless an
4237 error occurs, in which case error_mark_node is returned. If we
4238 locate a non-artificial TYPE_DECL and TF_KEEP_TYPE_DECL is set, we
4239 return that, rather than the _TYPE it corresponds to, in other
4240 cases we look through the type decl. If TF_ERROR is set, complain
4241 about errors, otherwise be quiet. */
4243 tree
4245 tsubst_flags_t complain)
4246 {
4247 tree fullname;
4248 tree t;
4257 {
4262 else
4263 /* Create a TEMPLATE_ID_EXPR for the type. */
4267 }
4274 {
4279 {
4283 }
4284 }
4286 {
4290 }
4292 {
4296 }
4303 {
4307 }
4309 /* When the CONTEXT is a dependent type, NAME could refer to a
4310 dependent base class of CONTEXT. But look inside it anyway
4311 if CONTEXT is a currently open scope, in case it refers to a
4312 member of the current instantiation or a non-dependent base;
4313 lookup will stop when we hit a dependent base. */
4315 {
4316 /* We generally don't ignore non-types during TYPENAME_TYPE lookup
4317 (as per [temp.res.general]/3), unless
4318 - the tag corresponds to a class-key or 'enum' so
4319 [basic.lookup.elab] applies, or
4320 - the tag corresponds to scope_type or tf_qualifying_scope is
4321 set so [basic.lookup.qual]/1 applies.
4322 TODO: If we'd set/track the scope_type tag thoroughly on all
4323 TYPENAME_TYPEs that are followed by :: then we wouldn't need the
4324 tf_qualifying_scope flag. */
4328 }
4329 else
4338 {
4340 {
4343 else
4346 }
4348 }
4350 /* Pull out the template from an injected-class-name (or multiple). */
4355 {
4357 {
4360 }
4362 }
4365 {
4370 }
4372 {
4375 /* The caller permits this typename-specifier to name a template
4377 else
4378 {
4383 }
4384 }
4394 {
4402 }
4410 }
4412 /* Resolve `CONTEXT::template NAME'. Returns a TEMPLATE_DECL if the name
4413 can be resolved or an UNBOUND_CLASS_TEMPLATE, unless an error occurs,
4414 in which case error_mark_node is returned.
4416 If PARM_LIST is non-NULL, also make sure that the template parameter
4417 list of TEMPLATE_DECL matches.
4419 If COMPLAIN zero, don't complain about any errors that occur. */
4421 tree
4423 tsubst_flags_t complain)
4424 {
4433 {
4443 {
4447 }
4451 {
4453 {
4457 }
4459 }
4462 complain))
4466 }
4469 }
4471 /* Build an UNBOUND_CLASS_TEMPLATE. */
4473 tree
4475 {
4476 /* Build the UNBOUND_CLASS_TEMPLATE. */
4482 /* Build the corresponding TEMPLATE_DECL. */
4491 }
4493 \f
4495 /* Push the declarations of builtin types into the global namespace.
4496 RID_INDEX is the index of the builtin type in the array
4497 RID_POINTERS. NAME is the name used when looking up the builtin
4498 type. TYPE is the _TYPE node for the builtin type.
4500 The calls to set_global_binding below should be
4501 eliminated. Built-in types should not be looked up name; their
4502 names are keywords that the parser can recognize. However, there
4503 is code in c-common.cc that uses identifier_global_value to look up
4504 built-in types by name. */
4506 void
4509 tree type)
4510 {
4514 {
4520 }
4525 {
4531 }
4534 {
4538 }
4539 }
4541 /* Push a type into the namespace so that the back ends ignore it. */
4543 static void
4545 {
4548 /* Make sure the "unknown type" typedecl gets ignored for debug info. */
4555 }
4557 /* Create all the predefined identifiers. */
4559 static void
4561 {
4562 struct predefined_identifier
4563 {
4567 };
4569 /* A table of identifiers to create at startup. */
4573 /* Some of these names have a trailing space so that it is
4574 impossible for them to conflict with names written by users. */
4591 /* The demangler expects anonymous namespaces to be called
4592 something starting with '_GLOBAL__N_'. It no longer needs
4593 to be unique to the TU. */
4623 };
4627 {
4629 /* Some of these identifiers already have a special kind. */
4632 }
4633 }
4635 /* Create the predefined scalar types of C,
4636 and some nodes representing standard constants (0, 1, (void *)0).
4637 Initialize the global binding level.
4638 Make definitions for built-in primitive functions. */
4640 void
4642 {
4643 tree void_ftype;
4644 tree void_ftype_ptr;
4646 /* Create all the identifiers we need. */
4649 /* Create the global variables. */
4654 /* Enter the global namespace. */
4657 void_type_node);
4662 /* Remember whether we want the empty class passing ABI change warning
4663 in this TU. */
4666 debug_hooks->register_main_translation_unit
4674 /* Initially, C. */
4677 /* Create the `std' namespace. */
4687 tree decl
4693 /* The concrete return type of __builtin_source_location is
4694 const std::source_location::__impl*, but we can't form the type
4695 at this point. So we initially declare it with an auto return
4696 type which we then "deduce" from require_deduced_type upon first use. */
4704 NULL_TREE);
4705 decl
4707 bool_vaftype,
4708 CP_BUILT_IN_IS_CORRESPONDING_MEMBER,
4712 decl
4714 bool_vaftype,
4715 CP_BUILT_IN_IS_POINTER_INTERCONVERTIBLE_WITH_CLASS,
4721 /* Guess at the initial static decls size. */
4724 /* ... and keyed classes. */
4736 NULL_TREE);
4738 #if 0
4740 #endif
4749 void_ftype_ptr
4752 /* Create the conversion operator marker. This operator's DECL_NAME
4753 is in the identifier table, so we can use identifier equality to
4754 find it. */
4756 void_ftype);
4758 /* C++ extensions */
4763 /* Indirecting an UNKNOWN_TYPE node yields an UNKNOWN_TYPE node. */
4766 /* Looking up TYPE_POINTER_TO and TYPE_REFERENCE_TO yield the same
4767 result. */
4774 /* Used when parsing to distinguish parameter-lists () and (void). */
4777 {
4778 /* Make sure we get a unique function type, so we can give
4779 its pointer type a name. (This wins for gdb.) */
4786 }
4789 vtbl_type_node
4805 /* Now, C++. */
4810 {
4812 aligned_new_threshold);
4814 }
4820 {
4823 tree ptr_ftype_sizetype;
4824 tree new_eh_spec;
4826 ptr_ftype_sizetype
4829 {
4830 tree bad_alloc_id;
4831 tree bad_alloc_type_node;
4832 tree bad_alloc_decl;
4838 bad_alloc_decl
4843 new_eh_spec
4845 }
4846 else
4849 /* Ensure attribs.cc is initialized. */
4853 NULL_TREE);
4856 extvisattr);
4876 {
4877 /* Also push the sized deallocation variants:
4878 void operator delete(void*, std::size_t) throw();
4879 void operator delete[](void*, std::size_t) throw(); */
4880 tree void_ftype_ptr_size
4884 extvisattr);
4892 }
4895 {
4902 /* operator new (size_t, align_val_t); */
4916 /* operator delete (void *, align_val_t); */
4929 {
4930 /* operator delete (void *, size_t, align_val_t); */
4933 NULL_TREE);
4942 }
4943 }
4945 /* C++-specific nullptr initialization. */
4949 }
4954 abort_fndecl
4958 /* If no definition is available, resolve references to NULL. */
4961 /* Perform other language dependent initializations. */
4975 /* Show we use EH for cleanups. */
4979 /* Check that the hardware interference sizes are at least
4980 alignof(max_align_t), as required by the standard. */
4983 {
4989 "%<--param destructive-interference-size=%d%> "
4992 }
4997 /* else leave it unset. */
5000 {
5007 "%<--param constructive-interference-size=%d%> "
5010 }
5015 }
5017 /* Enter an abi node in global-module context. returns a cookie to
5018 give to pop_abi_namespace. */
5020 unsigned
5022 {
5028 }
5030 /* Pop an abi namespace, FLAGS is the cookie push_abi_namespace gave
5031 you. */
5033 void
5035 {
5039 }
5041 /* Create the VAR_DECL for __FUNCTION__ etc. ID is the name to give
5042 the decl, LOC is the location to give the decl, NAME is the
5043 initialization string and TYPE_DEP indicates whether NAME depended
5044 on the type of the function. We make use of that to detect
5045 __PRETTY_FUNCTION__ inside a template fn. This is being done lazily
5046 at the point of first use, so we mustn't push the decl now. */
5048 static tree
5050 {
5055 {
5062 {
5063 /* __FUNCTION__ */
5066 }
5067 else
5068 {
5069 /* __PRETTY_FUNCTION__ */
5072 }
5079 }
5086 else
5100 /* For decl_constant_var_p. */
5104 {
5109 }
5110 else
5111 {
5114 }
5117 }
5119 /* Install DECL as a builtin function at current global scope. Return
5120 the new decl (if we found an existing version). Also installs it
5121 into ::std, if it's not '_*'. */
5123 tree
5125 {
5130 /* Runtime library routines are, by definition, available in an
5131 external shared object. */
5139 /* In the user's namespace, it must be declared before use. */
5145 /* Treat __*_chk fortification functions as anticipated as well,
5146 unless they are __builtin_*_chk. */
5149 /* All builtins that don't begin with an '_' should additionally
5150 go in the 'std' namespace. */
5152 {
5159 }
5165 }
5167 /* Like cxx_builtin_function, but guarantee the function is added to the global
5168 scope. This is to allow function specific options to add new machine
5169 dependent builtins when the target ISA changes via attribute((target(...)))
5170 which saves space on program startup if the program does not use non-generic
5171 ISAs. */
5173 tree
5175 {
5181 }
5183 /* Implement LANG_HOOKS_SIMULATE_BUILTIN_FUNCTION_DECL. */
5185 tree
5187 {
5194 }
5196 /* Generate a FUNCTION_DECL with the typical flags for a runtime library
5197 function. Not called directly. */
5199 static tree
5202 {
5210 /* Runtime library routines are, by definition, available in an
5211 external shared object. */
5216 }
5218 /* Returns the _DECL for a library function with C++ linkage. */
5220 static tree
5223 {
5228 }
5230 /* Like build_library_fn, but takes a C string instead of an
5231 IDENTIFIER_NODE. */
5233 tree
5235 {
5237 }
5239 /* Like build_cp_library_fn, but takes a C string instead of an
5240 IDENTIFIER_NODE. */
5242 tree
5244 {
5246 ecf_flags);
5247 }
5249 /* Like build_library_fn, but also pushes the function so that we will
5250 be able to find it via get_global_binding. Also, the function
5251 may throw exceptions listed in RAISES. */
5253 tree
5255 {
5261 }
5263 /* Like build_cp_library_fn, but also pushes the function so that it
5264 will be found by normal lookup. */
5266 static tree
5269 {
5276 }
5278 /* Like push_library_fn, but also note that this function throws
5279 and does not return. Used for __throw_foo and the like. */
5281 tree
5283 {
5286 }
5287 \f
5288 /* When we call finish_struct for an anonymous union, we create
5289 default copy constructors and such. But, an anonymous union
5290 shouldn't have such things; this function undoes the damage to the
5291 anonymous union type T.
5293 (The reason that we create the synthesized methods is that we don't
5294 distinguish `union { int i; }' from `typedef union { int i; } U'.
5295 The first is an anonymous union; the second is just an ordinary
5296 union type.) */
5298 void
5300 {
5301 /* Wipe out memory of synthesized methods. */
5309 /* Splice the implicitly generated functions out of TYPE_FIELDS and diagnose
5310 invalid members. */
5312 {
5315 else
5325 {
5326 /* We already complained about static data members in
5327 finish_static_data_member_decl. */
5329 {
5330 auto_diagnostic_group d;
5334 "only have public non-static data members"
5337 {
5340 {
5343 "this flexibility is deprecated and will be "
5345 }
5346 }
5347 }
5348 }
5349 }
5351 /* Splice all functions out of CLASSTYPE_MEMBER_VEC. */
5359 /* Wipe RTTI info. */
5362 /* Anonymous aggregates cannot have fields with ctors, dtors or complex
5363 assignment operators (because they cannot have these methods themselves).
5364 For anonymous unions this is already checked because they are not allowed
5365 in any union, otherwise we have to check it. */
5367 {
5371 {
5373 /* Avoid ICE after error on anon-struct9.C. */
5375 }
5379 {
5382 {
5392 }
5393 }
5394 }
5395 }
5397 /* Warn for an attribute located at LOCATION that appertains to the
5398 class type CLASS_TYPE that has not been properly placed after its
5399 class-key, in it class-specifier. */
5401 void
5403 tree class_type)
5404 {
5407 auto_diagnostic_group d;
5409 "attribute ignored in declaration "
5414 }
5416 /* Returns the cv-qualifiers that apply to the type specified
5417 by the DECLSPECS. */
5419 static int
5421 {
5432 }
5434 /* Make sure that a declaration with no declarator is well-formed, i.e.
5435 just declares a tagged type or anonymous union.
5437 Returns the type declared; or NULL_TREE if none. */
5439 tree
5442 {
5445 /* If a class, struct, or enum type is declared by the DECLSPECS
5446 (i.e, if a class-specifier, enum-specifier, or non-typename
5447 elaborated-type-specifier appears in the DECLSPECS),
5448 DECLARED_TYPE is set to the corresponding type. */
5456 {
5462 }
5474 {
5476 "%<auto%> can only be specified for variables "
5479 }
5486 /* Check for an anonymous union. */
5489 {
5490 /* 7/3 In a simple-declaration, the optional init-declarator-list
5491 can be omitted only when declaring a class (clause 9) or
5492 enumeration (7.2), that is, when the decl-specifier-seq contains
5493 either a class-specifier, an elaborated-type-specifier with
5494 a class-key (9.1), or an enum-specifier. In these cases and
5495 whenever a class-specifier or enum-specifier is present in the
5496 decl-specifier-seq, the identifiers in these specifiers are among
5497 the names being declared by the declaration (as class-name,
5498 enum-names, or enumerators, depending on the syntax). In such
5499 cases, and except for the declaration of an unnamed bit-field (9.6),
5500 the decl-specifier-seq shall introduce one or more names into the
5501 program, or shall redeclare a name introduced by a previous
5502 declaration. [Example:
5503 enum { }; // ill-formed
5504 typedef class { }; // ill-formed
5505 --end example] */
5507 {
5511 }
5518 }
5520 else
5521 {
5529 && (!current_class_type
5538 "a storage class can only be specified for objects "
5542 "%<const%> can only be specified for objects and "
5546 "%<volatile%> can only be specified for objects and "
5550 "%<__restrict%> can only be specified for objects and "
5554 "%<__thread%> can only be specified for objects "
5568 }
5571 {
5572 location_t loc;
5575 /* For a non-template class, use the name location. */
5577 else
5578 /* For a template class (an explicit instantiation), use the
5579 current location. */
5583 /* [dcl.attr.grammar]/4:
5585 No attribute-specifier-seq shall appertain to an explicit
5586 instantiation. */
5587 {
5590 declared_type))
5592 "no attribute can be applied to "
5594 }
5595 else
5597 }
5599 /* Diagnose invalid application of contracts, if any. */
5602 else
5606 }
5608 /* Called when a declaration is seen that contains no names to declare.
5609 If its type is a reference to a structure, union or enum inherited
5610 from a containing scope, shadow that tag name for the current scope
5611 with a forward reference.
5612 If its type defines a new named structure or union
5613 or defines an enum, it is valid but we need not do anything here.
5614 Otherwise, it is an error.
5616 C++: may have to grok the declspecs to learn about static,
5617 complain for anonymous unions.
5619 Returns the TYPE declared -- or NULL_TREE if none. */
5621 tree
5623 {
5634 /* This is where the variables in an anonymous union are
5635 declared. An anonymous union declaration looks like:
5636 union { ... } ;
5637 because there is no declarator after the union, the parser
5638 sends that declaration here. */
5640 {
5644 {
5648 }
5649 }
5652 }
5653 \f
5654 /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
5656 tree
5660 {
5661 tree attrs;
5662 tree type;
5663 enum decl_context context
5669 {
5674 /* A template type parameter or other dependent type. */
5677 else
5679 }
5681 }
5683 /* Process a DECLARATOR for a function-scope or namespace-scope
5684 variable or function declaration.
5685 (Function definitions go through start_function; class member
5686 declarations appearing in the body of the class go through
5687 grokfield.) The DECL corresponding to the DECLARATOR is returned.
5688 If an error occurs, the error_mark_node is returned instead.
5690 DECLSPECS are the decl-specifiers for the declaration. INITIALIZED is
5691 SD_INITIALIZED if an explicit initializer is present, or SD_DEFAULTED
5692 for an explicitly defaulted function, or SD_DELETED for an explicitly
5693 deleted function, but 0 (SD_UNINITIALIZED) if this is a variable
5694 implicitly initialized via a default constructor. It can also be
5695 SD_DECOMPOSITION which behaves much like SD_INITIALIZED, but we also
5696 mark the new decl as DECL_DECOMPOSITION_P.
5698 ATTRIBUTES and PREFIX_ATTRIBUTES are GNU attributes associated with this
5699 declaration.
5701 The scope represented by the context of the returned DECL is pushed
5702 (if it is not the global namespace) and is assigned to
5703 *PUSHED_SCOPE_P. The caller is then responsible for calling
5704 pop_scope on *PUSHED_SCOPE_P if it is set. */
5706 tree
5710 tree attributes,
5711 tree prefix_attributes,
5713 {
5714 tree decl;
5715 tree context;
5719 tree initial;
5739 {
5744 }
5746 /* Save the DECL_INITIAL value in case it gets clobbered to assist
5747 with attribute validation. */
5751 {
5755 decl);
5759 /* Tell 'cplus_decl_attributes' this is an initialized decl,
5760 even though we might not yet have the initializer expression. */
5763 }
5769 /* If this is a typedef that names the class for linkage purposes
5770 (7.1.3p8), apply any attributes directly to the type. */
5775 else
5778 /* Set attributes here so if duplicate decl, will have proper attributes. */
5781 /* Restore the original DECL_INITIAL that we may have clobbered earlier to
5782 assist with attribute validation. */
5785 /* Dllimported symbols cannot be defined. Static data members (which
5786 can be initialized in-class and dllimported) go through grokfield,
5787 not here, so we don't need to exclude those decls when checking for
5788 a definition. */
5790 {
5794 }
5796 /* If #pragma weak was used, mark the decl weak now. */
5808 {
5812 {
5822 {
5828 }
5829 else
5830 {
5835 {
5842 }
5843 /* Static data member are tricky; an in-class initialization
5844 still doesn't provide a definition, so the in-class
5845 declaration will have DECL_EXTERNAL set, but will have an
5846 initialization. Thus, duplicate_decls won't warn
5847 about this situation, and so we check here. */
5855 }
5856 }
5857 else
5858 {
5860 this_tmpl
5861 ? current_template_parms
5866 }
5868 /* cp_finish_decl sets DECL_EXTERNAL if DECL_IN_AGGR_P is set. */
5870 /* Do not mark DECL as an explicit specialization if it was not
5871 already marked as an instantiation; a declaration should
5872 never be marked as a specialization unless we know what
5873 template is being specialized. */
5875 {
5880 else
5883 /* [temp.expl.spec] An explicit specialization of a static data
5884 member of a template is a definition if the declaration
5885 includes an initializer; otherwise, it is a declaration.
5887 We check for processing_specialization so this only applies
5888 to the new specialization syntax. */
5891 }
5894 /* Aliases are definitions. */
5896 {
5900 decl);
5904 decl);
5905 }
5906 }
5908 /* Create a DECL_LANG_SPECIFIC so that DECL_DECOMPOSITION_P works. */
5916 {
5917 /* A function-scope decl of some namespace-scope decl. */
5921 "block-scope extern declaration %q#D not permitted"
5923 }
5925 /* Enter this declaration into the symbol table. Don't push the plain
5926 VAR_DECL for a variable template. */
5940 /* But not templated variables. */
5942 {
5943 /* This is a const variable with implicit 'static'. Set
5944 DECL_THIS_STATIC so we can tell it from variables that are
5945 !TREE_PUBLIC because of the anonymous namespace. */
5948 }
5953 {
5957 "%qD defined %<thread_local%> in %qs function only "
5963 "%qD defined %<static%> in %qs function only available "
5967 else
5971 }
5977 }
5979 /* Process the declaration of a variable DECL. INITIALIZED is true
5980 iff DECL is explicitly initialized. (INITIALIZED is false if the
5981 variable is initialized via an implicitly-called constructor.)
5982 This function must be called for ordinary variables (including, for
5983 example, implicit instantiations of templates), but must not be
5984 called for template declarations. */
5986 void
5988 {
5998 bool aggregate_definition_p
6001 /* If an explicit initializer is present, or if this is a definition
6002 of an aggregate, then we need a complete type at this point.
6003 (Scalars are always complete types, so there is nothing to
6004 check.) This code just sets COMPLETE_P; errors (if necessary)
6005 are issued below. */
6007 && !complete_p
6009 {
6011 /* We will not yet have set TREE_READONLY on DECL if the type
6012 was "const", but incomplete, before this point. But, now, we
6013 have a complete type, so we can try again. */
6015 }
6018 /* Is it valid for this decl to have an initializer at all? */
6019 {
6020 /* Don't allow initializations for incomplete types except for
6021 arrays which might be completed by the initialization. */
6027 {
6028 auto_diagnostic_group d;
6034 }
6036 {
6039 /* else we already gave an error in start_decl. */
6040 }
6041 }
6043 {
6046 else
6047 {
6048 auto_diagnostic_group d;
6050 decl);
6054 /* Change the type so that assemble_variable will give
6055 DECL an rtl we can live with: (mem (const_int 0)). */
6057 }
6058 }
6060 /* Create a new scope to hold this declaration if necessary.
6061 Whether or not a new scope is necessary cannot be determined
6062 until after the type has been completed; if the type is a
6063 specialization of a class template it is not until after
6064 instantiation has occurred that TYPE_HAS_NONTRIVIAL_DESTRUCTOR
6065 will be set correctly. */
6067 }
6069 /* Given a parenthesized list of values INIT, create a CONSTRUCTOR to handle
6070 C++20 P0960. TYPE is the type of the object we're initializing. */
6072 tree
6074 {
6078 {
6079 /* If the list has a single element and it's a string literal,
6080 then it's the initializer for the array as a whole. */
6086 /* Handle non-standard extensions like compound literals. This also
6087 prevents triggering aggregate parenthesized-initialization in
6088 compiler-generated code for =default. */
6092 }
6098 }
6100 /* Handle initialization of references. DECL, TYPE, and INIT have the
6101 same meaning as in cp_finish_decl. *CLEANUP must be NULL on entry,
6102 but will be set to a new CLEANUP_STMT if a temporary is created
6103 that must be destroyed subsequently.
6105 Returns an initializer expression to use to initialize DECL, or
6106 NULL if the initialization can be performed statically.
6108 Quotes on semantics can be found in ARM 8.4.3. */
6110 static tree
6112 {
6114 {
6121 }
6125 {
6126 /* This handles (C++20 only) code like
6128 const A& r(1, 2, 3);
6130 where we treat the parenthesized list as a CONSTRUCTOR. */
6135 {
6136 /* We don't know yet if we should treat const A& r(1) as
6137 const A& r{1}. */
6139 {
6142 tf_warning_or_error);
6143 }
6144 /* If the list had more than one element, the code is ill-formed
6145 pre-C++20, so we can build a constructor right away. */
6146 else
6148 }
6149 else
6151 tf_warning_or_error);
6152 }
6156 /* Note: default conversion is only called in very special cases. */
6159 /* check_initializer handles this for non-reference variables, but for
6160 references we need to do it here or the initializer will get the
6161 incomplete array type and confuse later calls to
6162 cp_complete_array_type. */
6167 {
6171 }
6173 /* Convert INIT to the reference type TYPE. This may involve the
6174 creation of a temporary, whose lifetime must be the same as that
6175 of the reference. If so, a DECL_EXPR for the temporary will be
6176 added just after the DECL_EXPR for DECL. That's why we don't set
6177 DECL_INITIAL for local references (instead assigning to them
6178 explicitly); we need to allow the temporary to be initialized
6179 first. */
6181 tf_warning_or_error);
6182 }
6184 /* Designated initializers in arrays are not supported in GNU C++.
6185 The parser cannot detect this error since it does not know whether
6186 a given brace-enclosed initializer is for a class type or for an
6187 array. This function checks that CE does not use a designated
6188 initializer. If it does, an error is issued. Returns true if CE
6189 is valid, i.e., does not have a designated initializer. */
6191 bool
6194 {
6195 /* Designated initializers for array elements are not supported. */
6197 {
6198 /* The parser only allows identifiers as designated
6199 initializers. */
6201 {
6205 }
6207 {
6211 }
6219 {
6220 /* A C99 designator is OK if it matches the current index. */
6222 {
6225 }
6226 else
6228 }
6229 else
6235 }
6238 }
6240 /* When parsing `int a[] = {1, 2};' we don't know the size of the
6241 array until we finish parsing the initializer. If that's the
6242 situation we're in, update DECL accordingly. */
6244 static void
6246 {
6252 {
6253 /* do_default is really a C-ism to deal with tentative definitions.
6254 But let's leave it here to ease the eventual merge. */
6259 /* Check that there are no designated initializers in INIT, as
6260 those are not supported in GNU C++, and as the middle-end
6261 will crash if presented with a non-numeric designated
6262 initializer. */
6264 {
6267 HOST_WIDE_INT i;
6269 {
6274 /* If an un-designated initializer is type-dependent, we can't
6275 check brace elision yet. */
6279 }
6280 }
6284 else
6285 {
6287 do_default);
6289 {
6293 }
6295 {
6297 {
6300 }
6301 /* If a `static' var's size isn't known, make it extern as
6302 well as static, so it does not get allocated. If it's not
6303 `static', then don't mark it extern; finish_incomplete_decl
6304 will give it a default size and it will get allocated. */
6307 }
6309 {
6312 }
6313 }
6318 }
6319 }
6321 /* Set DECL_SIZE, DECL_ALIGN, etc. for DECL (a VAR_DECL), and issue
6322 any appropriate error messages regarding the layout. */
6324 static void
6326 {
6327 tree type;
6333 /* If we haven't already laid out this declaration, do so now.
6334 Note that we must not call complete type for an external object
6335 because it's type might involve templates that we are not
6336 supposed to instantiate yet. (And it's perfectly valid to say
6337 `extern X x' for some incomplete type `X'.) */
6346 {
6347 /* An automatic variable with an incomplete type: that is an error.
6348 Don't talk about array types here, since we took care of that
6349 message in grokdeclarator. */
6353 }
6354 #if 0
6355 /* Keep this code around in case we later want to control debug info
6356 based on whether a type is "used". (jason 1999-11-11) */
6359 /* Let debugger know it should output info for this type. */
6364 #endif
6369 {
6373 else
6374 {
6379 }
6380 }
6382 /* If the final element initializes a flexible array field, add the size of
6383 that initializer to DECL's size. */
6393 {
6396 {
6403 {
6409 }
6410 }
6411 }
6412 }
6414 /* If a local static variable is declared in an inline function, or if
6415 we have a weak definition, we must endeavor to create only one
6416 instance of the variable at link-time. */
6418 void
6420 {
6421 /* Don't mess with __FUNCTION__ and similar. But do handle structured
6422 bindings. */
6426 /* Static data in a function with comdat linkage also has comdat
6427 linkage. */
6432 {
6434 {
6435 /* With weak symbols, we simply make the variable COMDAT;
6436 that will cause copies in multiple translations units to
6437 be merged. */
6439 }
6440 else
6441 {
6444 {
6445 /* Without weak symbols, we can use COMMON to merge
6446 uninitialized variables. */
6449 }
6450 else
6451 {
6452 /* While for initialized variables, we must use internal
6453 linkage -- which means that multiple copies will not
6454 be merged. */
6461 "%q#D are wrong (you%'ll wind up with "
6463 else
6465 "static data %q#D are wrong (you%'ll wind "
6471 }
6472 }
6473 }
6474 }
6476 /* Issue an error message if DECL is an uninitialized const variable.
6477 CONSTEXPR_CONTEXT_P is true when the function is called in a constexpr
6478 context from potential_constant_expression. Returns true if all is well,
6479 false otherwise. */
6481 bool
6483 tsubst_flags_t complain)
6484 {
6487 /* ``Unless explicitly declared extern, a const object does not have
6488 external linkage and must be initialized. ($8.4; $12.1)'' ARM
6489 7.1.6 */
6493 /* C++20 permits trivial default initialization in constexpr
6494 context (P1331R2). */
6496 && (constexpr_context_p
6499 {
6507 {
6509 {
6513 }
6514 else
6515 {
6519 "uninitialized variable %qD in %<constexpr%> "
6521 else
6524 }
6525 }
6529 decl);
6532 {
6533 tree defaulted_ctor;
6540 "constructor is not user-provided because it is "
6543 "and the implicitly-defined constructor does not "
6545 }
6548 }
6551 }
6552 \f
6553 /* Structure holding the current initializer being processed by reshape_init.
6554 CUR is a pointer to the current element being processed, END is a pointer
6555 after the last element present in the initializer. */
6556 struct reshape_iter
6557 {
6560 };
6564 /* FIELD is an element of TYPE_FIELDS or NULL. In the former case, the value
6565 returned is the next FIELD_DECL (possibly FIELD itself) that can be
6566 initialized as if for an aggregate class. If there are no more such fields,
6567 the return value will be NULL. */
6569 tree
6571 {
6576 /* In C++17, aggregates can have bases. */
6581 }
6583 /* FIELD is an element of TYPE_FIELDS or NULL. In the former case, the value
6584 returned is the next FIELD_DECL (possibly FIELD itself) that corresponds
6585 to a subobject. If there are no more such fields, the return value will be
6586 NULL. */
6588 tree
6590 {
6600 }
6602 /* Return true for [dcl.init.list] direct-list-initialization from
6603 single element of enumeration with a fixed underlying type. */
6605 bool
6607 {
6614 /* DR 2374: The single element needs to be implicitly
6615 convertible to the underlying type of the enum. */
6622 }
6624 /* Subroutine of reshape_init_array and reshape_init_vector, which does
6625 the actual work. ELT_TYPE is the element type of the array. MAX_INDEX is an
6626 INTEGER_CST representing the size of the array minus one (the maximum index),
6627 or NULL_TREE if the array was declared without specifying the size. D is
6628 the iterator within the constructor. */
6630 static tree
6633 {
6634 tree new_init;
6639 /* The initializer for an array is always a CONSTRUCTOR. If this is the
6640 outermost CONSTRUCTOR and the element type is non-aggregate, we don't need
6641 to build a new one. But don't reuse if not complaining; if this is
6642 tentative, we might also reshape to another type (95319). */
6649 else
6653 {
6654 /* Minus 1 is used for zero sized arrays. */
6660 /* sizetype is sign extended, not zero extended. */
6661 else
6663 }
6665 /* Loop until there are no more initializers. */
6669 {
6670 tree elt_init;
6678 complain);
6683 {
6686 }
6687 else
6693 /* This can happen with an invalid initializer (c++/54501). */
6696 }
6699 }
6701 /* Subroutine of reshape_init_r, processes the initializers for arrays.
6702 Parameters are the same of reshape_init_r. */
6704 static tree
6706 tsubst_flags_t complain)
6707 {
6717 }
6719 /* Subroutine of reshape_init_r, processes the initializers for vectors.
6720 Parameters are the same of reshape_init_r. */
6722 static tree
6724 {
6730 {
6733 {
6738 }
6741 }
6743 /* For a vector, we initialize it as an array of the appropriate size. */
6749 }
6751 /* Subroutine of reshape_init*: We're initializing an element with TYPE from
6752 INIT, in isolation from any designator or other initializers. */
6754 static tree
6756 {
6757 /* We could also implement this by wrapping init in a new CONSTRUCTOR and
6758 calling reshape_init, but this way can just live on the stack. */
6763 complain);
6764 }
6766 /* Subroutine of reshape_init_r, processes the initializers for classes
6767 or union. Parameters are the same of reshape_init_r. */
6769 static tree
6771 tsubst_flags_t complain)
6772 {
6773 tree field;
6774 tree new_init;
6778 /* The initializer for a class is always a CONSTRUCTOR. */
6785 {
6786 /* We get here from maybe_aggr_guide for C++20 class template argument
6787 deduction. In this case we need to look through the binfo because a
6788 template doesn't have base fields. */
6791 }
6794 else
6798 {
6799 /* [dcl.init.aggr]
6801 An initializer for an aggregate member that is an
6802 empty class shall have the form of an empty
6803 initializer-list {}. */
6805 {
6809 }
6811 }
6813 /* For C++20 CTAD, handle pack expansions in the base list. */
6816 /* Loop through the initializable fields, gathering initializers. */
6818 {
6819 tree field_init;
6823 /* Handle C++20 designated initializers. */
6825 {
6830 {
6831 /* We already reshaped this; we should have returned early from
6832 reshape_init. */
6835 {
6840 }
6841 }
6843 {
6847 }
6848 else
6849 {
6854 }
6857 /* Apparently the designator isn't for a member of this anonymous
6858 struct, so head back to the enclosing class. */
6862 {
6867 }
6869 /* If the element is an anonymous union object and the initializer
6870 list is a designated-initializer-list, the anonymous union object
6871 is initialized by the designated-initializer-list { D }, where D
6872 is the designated-initializer-clause naming a member of the
6873 anonymous union object. */
6876 {
6877 /* Find the anon aggr that is a direct member of TYPE. */
6879 {
6884 }
6886 /* Not found, e.g. FIELD is a member of a base class. */
6891 found:
6892 /* Now find the TYPE member with that anon aggr type. */
6900 }
6901 }
6903 /* If we processed all the member of the class, we are done. */
6910 /* Each non-trailing aggregate element that is a pack expansion is
6911 assumed to correspond to no elements of the initializer list. */
6915 {
6916 /* The designated field F is initialized from this one element.
6918 Note that we don't want to do this if we found the designator
6919 inside an anon aggr above; we use the normal code to implement:
6921 "If the element is an anonymous union member and the initializer
6922 list is a brace-enclosed designated- initializer-list, the element
6923 is initialized by the designated-initializer-list { D }, where D
6924 is the designated- initializer-clause naming a member of the
6925 anonymous union member." */
6929 }
6930 else
6933 complain);
6939 {
6940 /* This can happen with an invalid initializer for a flexible
6941 array member (c++/54441). */
6945 }
6949 /* [dcl.init.aggr]
6951 When a union is initialized with a brace-enclosed
6952 initializer, the braces shall only contain an
6953 initializer for the first member of the union. */
6957 continue_:
6959 {
6962 else
6964 }
6965 else
6967 }
6969 /* A trailing aggregate element that is a pack expansion is assumed to
6970 correspond to all remaining elements of the initializer list (if any). */
6972 {
6977 }
6980 }
6982 /* Subroutine of reshape_init_r. We're in a context where C99 initializer
6983 designators are not valid; either complain or return true to indicate
6984 that reshape_init_r should return error_mark_node. */
6986 static bool
6988 {
6990 {
6995 else
6997 }
6999 }
7001 /* Subroutine of reshape_init, which processes a single initializer (part of
7002 a CONSTRUCTOR). TYPE is the type of the variable being initialized, D is the
7003 iterator within the CONSTRUCTOR which points to the initializer to process.
7004 If this is the first initializer of the outermost CONSTRUCTOR node,
7005 FIRST_INITIALIZER_P is that CONSTRUCTOR; otherwise, it is NULL_TREE. */
7007 static tree
7009 tsubst_flags_t complain)
7010 {
7023 {
7024 /* A complex type can be initialized from one or two initializers,
7025 but braces are not elided. */
7028 {
7030 {
7033 else
7035 }
7036 }
7038 {
7046 }
7048 }
7050 /* A non-aggregate type is always initialized with a single
7051 initializer. */
7053 /* As is an array with dependent bound, which we can see
7054 during C++20 aggregate CTAD. */
7058 {
7059 /* It is invalid to initialize a non-aggregate type with a
7060 brace-enclosed initializer before C++0x.
7061 We need to check for BRACE_ENCLOSED_INITIALIZER_P here because
7062 of g++.old-deja/g++.mike/p7626.C: a pointer-to-member constant is
7063 a CONSTRUCTOR (with a record type). */
7065 /* Don't complain about a capture-init. */
7068 {
7070 {
7072 {
7075 type);
7077 }
7080 && (BRACE_ENCLOSED_INITIALIZER_P
7082 {
7087 }
7088 }
7089 else
7091 }
7095 }
7097 /* "If T is a class type and the initializer list has a single element of
7098 type cv U, where U is T or a class derived from T, the object is
7099 initialized from that element." Even if T is an aggregate. */
7101 && first_initializer_p
7102 /* But not if it's a designated init. */
7106 {
7109 }
7111 /* [dcl.init.aggr]
7113 All implicit type conversions (clause _conv_) are considered when
7114 initializing the aggregate member with an initializer from an
7115 initializer-list. If the initializer can initialize a member,
7116 the member is initialized. Otherwise, if the member is itself a
7117 non-empty subaggregate, brace elision is assumed and the
7118 initializer is considered for the initialization of the first
7119 member of the subaggregate. */
7121 /* But don't try this for the first initializer, since that would be
7122 looking through the outermost braces; A a2 = { a1 }; is not a
7123 valid aggregate initialization. */
7124 && !first_initializer_p
7127 complain)))
7128 {
7131 }
7133 /* [dcl.init.string]
7135 A char array (whether plain char, signed char, or unsigned char)
7136 can be initialized by a string-literal (optionally enclosed in
7137 braces); a wchar_t array can be initialized by a wide
7138 string-literal (optionally enclosed in braces). */
7141 {
7144 reshape_iter stripd = {};
7146 /* Strip one level of braces if and only if they enclose a single
7147 element (as allowed by [dcl.init.string]). */
7151 {
7155 }
7157 /* If it's a string literal, then it's the initializer for the array
7158 as a whole. Otherwise, continue with normal initialization for
7159 array types (one value per array element). */
7161 {
7167 }
7168 }
7170 /* The following cases are about aggregates. If we are not within a full
7171 initializer already, and there is not a CONSTRUCTOR, it means that there
7172 is a missing set of braces (that is, we are processing the case for
7173 which reshape_init exists). */
7176 {
7178 {
7181 /* There is no need to call reshape_init for pointer-to-member
7182 function initializers, as they are always constructed correctly
7183 by the front end. Here we have e.g. {.__pfn=0B, .__delta=0},
7184 which is missing outermost braces. We should warn below, and
7186 /* For a nested compound literal, proceed to specialized routines,
7187 to handle initialization of arrays and similar. */
7190 /* If we have an unresolved designator, we need to find the member it
7191 designates within TYPE, so proceed to the routines below. For
7192 FIELD_DECL or INTEGER_CST designators, we're already initializing
7193 the designated element. */
7196 /* Brace elision with designators is only permitted for anonymous
7197 aggregates. */
7199 /* A CONSTRUCTOR of the target's type is a previously
7200 digested initializer. */
7202 {
7205 }
7206 else
7207 {
7208 /* Something that hasn't been reshaped yet. */
7212 }
7213 }
7218 type);
7220 }
7222 /* Dispatch to specialized routines. */
7223 tree new_init;
7230 else
7238 }
7240 /* Undo the brace-elision allowed by [dcl.init.aggr] in a
7241 brace-enclosed aggregate initializer.
7243 INIT is the CONSTRUCTOR containing the list of initializers describing
7244 a brace-enclosed initializer for an entity of the indicated aggregate TYPE.
7245 It may not presently match the shape of the TYPE; for example:
7247 struct S { int a; int b; };
7248 struct S a[] = { 1, 2, 3, 4 };
7250 Here INIT will hold a vector of four elements, rather than a
7251 vector of two elements, each itself a vector of two elements. This
7252 routine transforms INIT from the former form into the latter. The
7253 revised CONSTRUCTOR node is returned. */
7255 tree
7257 {
7259 reshape_iter d;
7260 tree new_init;
7266 /* An empty constructor does not need reshaping, and it is always a valid
7267 initializer. */
7272 /* Already reshaped. */
7275 /* Brace elision is not performed for a CONSTRUCTOR representing
7276 parenthesized aggregate initialization. */
7278 {
7280 /* If we're initializing a char array from a string-literal that is
7281 enclosed in braces, unwrap it here. */
7288 }
7290 /* Handle [dcl.init.list] direct-list-initialization from
7291 single element of enumeration with a fixed underlying type. */
7293 {
7297 {
7301 tf_warning_or_error);
7302 }
7303 else
7305 }
7307 /* Recurse on this CONSTRUCTOR. */
7315 /* Make sure all the element of the constructor were used. Otherwise,
7316 issue an error about exceeding initializers. */
7318 {
7322 }
7333 }
7335 /* Verify array initializer. Returns true if errors have been reported. */
7337 bool
7339 {
7342 /* Structured binding when initialized with an array type needs
7343 to have complete type. */
7348 {
7353 }
7355 /* The array type itself need not be complete, because the
7356 initializer may tell us how many elements are in the array.
7357 But, the elements of the array must be complete. */
7359 {
7363 else
7366 }
7372 /* A compound literal can't have variable size. */
7376 {
7379 }
7381 }
7383 /* Subroutine of check_initializer; args are passed down from that function.
7384 Set stmts_are_full_exprs_p to 1 across a call to build_aggr_init. */
7386 static tree
7388 {
7393 }
7395 /* Verify INIT (the initializer for DECL), and record the
7396 initialization in DECL_INITIAL, if appropriate. CLEANUP is as for
7397 grok_reference_init.
7399 If the return value is non-NULL, it is an expression that must be
7400 evaluated dynamically to initialize DECL. */
7402 static tree
7404 {
7405 tree type;
7407 tree core_type;
7409 /* Things that are going to be initialized need to have complete
7410 type. */
7414 {
7415 /* A variable with DECL_HAS_VALUE_EXPR_P set is just a placeholder,
7416 it doesn't have storage to be initialized. */
7419 }
7422 /* We will have already complained. */
7426 {
7429 }
7431 {
7436 }
7437 else
7438 /* There is no way to make a variable-sized class type in GNU C++. */
7442 {
7445 {
7447 {
7450 }
7452 {
7454 "scalar object %qD requires one element in "
7458 }
7459 }
7460 }
7463 {
7470 }
7472 ;
7475 {
7477 {
7480 }
7483 tf_warning_or_error);
7484 /* Do not reshape constructors of vectors (they don't need to be
7485 reshaped. */
7487 {
7489 {
7491 tf_warning_or_error);
7493 }
7495 {
7496 /* Don't reshape if the class has constructors. */
7499 "in C++98 %qD must be initialized by "
7501 decl);
7502 }
7504 {
7507 }
7508 else
7509 {
7512 }
7513 }
7514 /* [dcl.init] "Otherwise, if the destination type is an array, the object
7515 is initialized as follows..." So handle things like
7517 int a[](1, 2, 3);
7519 which is permitted in C++20 by P0960. */
7529 {
7532 /* We get here with code like `int a (2);' */
7534 tf_warning_or_error);
7535 }
7537 /* If DECL has an array type without a specific bound, deduce the
7538 array size from the initializer. */
7549 /* The call to build_aggr_init below could end up
7550 calling build_vec_init, which may break when we
7551 are processing a template. */
7552 || processing_template_decl
7556 {
7559 /* A constructor call is a non-trivial initializer even if
7560 it isn't explicitly written. */
7564 /* If this is a constexpr initializer, expand_default_init will
7565 have returned an INIT_EXPR rather than a CALL_EXPR. In that
7566 case, pull the initializer back out and pass it down into
7567 store_init_value. */
7569 {
7576 else
7578 }
7580 {
7581 /* In C++20, the call to build_aggr_init could have created
7582 an INIT_EXPR with a CONSTRUCTOR as the RHS to handle
7583 A(1, 2). */
7586 /* Avoid leaking TARGET_EXPR into template trees. */
7591 /* Don't call digest_init; it's unnecessary and will complain
7592 about aggregate initialization of non-aggregate classes. */
7594 }
7597 {
7598 /* Declared constexpr or constinit, but no suitable initializer;
7599 massage init appropriately so we can pass it into
7600 store_init_value for the error. */
7610 {
7615 }
7617 }
7618 else
7620 }
7623 {
7629 {
7634 }
7646 }
7647 }
7648 else
7649 {
7657 tf_warning_or_error);
7658 }
7668 {
7669 /* We might have set these in cp_finish_decl. */
7672 }
7677 {
7685 else
7689 {
7693 }
7695 }
7698 }
7700 /* If DECL is not a local variable, give it RTL. */
7702 static void
7704 {
7708 /* Set the DECL_ASSEMBLER_NAME for the object. */
7710 {
7711 /* The `register' keyword, when used together with an
7712 asm-specification, indicates that the variable should be
7713 placed in a particular register. */
7715 {
7718 }
7719 else
7720 {
7727 /* We have to propagate the name to the ns-alias.
7728 This is horrible, as we're affecting a
7729 possibly-shared decl. Again, a one-true-decl
7730 model breaks down. */
7733 }
7734 }
7736 /* Handle non-variables up front. */
7738 {
7741 }
7743 /* If we see a class member here, it should be a static data
7744 member. */
7746 {
7748 /* An in-class declaration of a static data member should be
7749 external; it is only a declaration, and not a definition. */
7753 }
7755 /* We don't create any RTL for local variables. */
7759 /* We defer emission of local statics until the corresponding
7760 DECL_EXPR is expanded. But with constexpr its function might never
7761 be expanded, so go ahead and tell cgraph about the variable now. */
7766 /* Defer template instantiations. */
7771 /* If we're not deferring, go ahead and assemble the variable. */
7774 }
7776 /* walk_tree helper for wrap_temporary_cleanups, below. */
7778 static tree
7780 {
7781 /* Stop at types or full-expression boundaries. */
7784 {
7787 }
7790 {
7796 {
7798 /* Tell honor_protect_cleanup_actions to handle this as a separate
7799 cleanup. */
7802 }
7803 }
7806 }
7808 /* We're initializing a local variable which has a cleanup GUARD. If there
7809 are any temporaries used in the initializer INIT of this variable, we
7810 need to wrap their cleanups with TRY_CATCH_EXPR (, GUARD) so that the
7811 variable will be cleaned up properly if one of them throws.
7813 Unfortunately, there's no way to express this properly in terms of
7814 nesting, as the regions for the temporaries overlap the region for the
7815 variable itself; if there are two temporaries, the variable needs to be
7816 the first thing destroyed if either of them throws. However, we only
7817 want to run the variable's cleanup if it actually got constructed. So
7818 we need to guard the temporary cleanups with the variable's cleanup if
7819 they are run on the normal path, but not if they are run on the
7820 exceptional path. We implement this by telling
7821 honor_protect_cleanup_actions to strip the variable cleanup from the
7822 exceptional path.
7824 Another approach could be to make the variable cleanup region enclose
7825 initialization, but depend on a flag to indicate that the variable is
7826 initialized; that's effectively what we do for arrays. But the current
7827 approach works fine for non-arrays, and has no code overhead in the usual
7828 case where the temporary destructors are noexcept. */
7830 static void
7832 {
7834 {
7835 /* An array cleanup region already encloses any temporary cleanups,
7836 don't wrap it around them again. */
7839 }
7841 }
7843 /* Generate code to initialize DECL (a local variable). */
7845 static void
7847 {
7849 tree cleanup;
7857 {
7858 /* If we used it already as memory, it must stay in memory. */
7862 }
7867 /* Compute and store the initial value. */
7872 /* Generate a cleanup, if necessary. */
7875 /* Perform the initialization. */
7877 {
7882 {
7883 /* Stick simple initializers in DECL_INITIAL so that
7884 -Wno-init-self works (c++/34772). */
7888 {
7892 OPT_Winit_self,
7894 }
7895 }
7896 else
7897 {
7900 /* If we're only initializing a single object, guard the
7901 destructors of any temporaries used in its initializer with
7902 its destructor. */
7911 saved_stmts_are_full_exprs_p;
7912 }
7913 }
7915 /* Set this to 0 so we can tell whether an aggregate which was
7916 initialized was ever used. Don't do this if it has a
7917 destructor, so we don't complain about the 'resource
7918 allocation is initialization' idiom. Now set
7919 attribute((unused)) on types so decls of that type will be
7920 marked used. (see TREE_USED, above.) */
7922 && ! already_used
7931 }
7933 /* DECL is a VAR_DECL for a compiler-generated variable with static
7934 storage duration (like a virtual table) whose initializer is a
7935 compile-time constant. Initialize the variable and provide it to the
7936 back end. */
7938 void
7940 {
7941 tree init;
7947 /* Mark the decl as constexpr so that we can access its content
7948 at compile time. */
7955 }
7957 /* INIT is the initializer for a variable, as represented by the
7958 parser. Returns true iff INIT is value-dependent. */
7960 static bool
7962 {
7964 /* A parenthesized initializer, e.g.: int i (3, 2); ? */
7967 /* A brace-enclosed initializer, e.g.: int i = { 3 }; ? */
7968 {
7981 }
7982 else
7983 /* It must be a simple expression, e.g., int i = 3; */
7987 }
7989 // Returns true if a DECL is VAR_DECL with the concept specifier.
7992 {
7994 // Not all variables have DECL_LANG_SPECIFIC.
7997 }
7999 /* A helper function to be called via walk_tree. If any label exists
8000 under *TP, it is (going to be) forced. Set has_forced_label_in_static. */
8002 static tree
8004 {
8010 }
8012 /* Return true if DECL has either a trivial destructor, or for C++20
8013 is constexpr and has a constexpr destructor. */
8015 static bool
8017 {
8023 }
8027 /* Helper function of omp_declare_variant_finalize. Finalize one
8028 "omp declare variant base" attribute. Return true if it should be
8029 removed. */
8031 static bool
8033 {
8035 {
8040 }
8045 {
8049 /* FIXME, adjusting simd args unimplemented. */
8051 }
8054 location_t varid_loc
8063 releasing_vec args;
8072 else
8077 {
8079 /* In C++20, we may need to perform ADL for a template
8080 name. */
8083 {
8085 {
8089 tf_warning_or_error);
8090 }
8091 else
8093 }
8095 {
8101 {
8105 tf_warning_or_error);
8106 }
8107 }
8108 }
8113 else
8123 {
8126 {
8130 }
8135 {
8138 }
8139 else
8140 {
8146 }
8147 }
8149 {
8152 }
8155 }
8157 /* Helper function, finish up "omp declare variant base" attribute
8158 now that there is a DECL. ATTR is the first "omp declare variant base"
8159 attribute. */
8161 void
8163 {
8173 {
8176 }
8178 {
8181 }
8183 {
8186 }
8188 {
8191 }
8193 {
8196 }
8197 /* This loop is like private_lookup_attribute, except that it works
8198 with tree * rather than tree, as we might want to remove the
8199 attributes that are diagnosed as errorneous. */
8201 {
8206 {
8208 {
8211 }
8212 }
8214 }
8215 }
8219 /* Finish processing of a declaration;
8220 install its line number and initial value.
8221 If the length of an array type is not known before,
8222 it must be determined now, from the initial value, or it is an error.
8224 INIT is the initializer (if any) for DECL. If INIT_CONST_EXPR_P is
8225 true, then INIT is an integral constant expression.
8227 FLAGS is LOOKUP_ONLYCONVERTING if the = init syntax was used, else 0
8228 if the (init) syntax was used.
8230 DECOMP is first identifier's DECL and identifier count in a structured
8231 bindings, nullptr if not a structured binding. */
8233 void
8236 {
8241 tree auto_node;
8246 {
8250 }
8253 /* Parameters are handled by store_parm_decls, not cp_finish_decl. */
8263 /* Warn about register storage specifiers except when in GNU global
8264 or local register variable extension. */
8266 {
8269 "ISO C++17 does not allow %<register%> storage "
8271 else
8274 }
8276 /* If a name was specified, get the string. */
8282 bool in_class_decl
8283 = (current_class_type
8294 {
8295 tree d_init;
8297 {
8301 {
8302 /* init is null because we're deferring instantiating the
8303 initializer until we need it. Well, we need it now. */
8306 }
8310 else
8311 {
8312 /* Ordinary auto deduction without an initializer, a situation
8313 which grokdeclarator already detects and rejects for the most
8314 part. But we can still get here if we're instantiating a
8315 variable template before we've fully parsed (and attached) its
8316 initializer, e.g. template<class> auto x = x<int>; */
8321 }
8322 }
8325 {
8329 tf_warning_or_error);
8331 /* Force auto deduction now. Use tf_none to avoid redundant warnings
8332 on deprecated-14.C. */
8334 }
8343 /* The outer template arguments might be needed for satisfaction.
8344 (For function scope variables, do_auto_deduction will obtain the
8345 outer template arguments from current_function_decl.) */
8353 {
8358 }
8359 /* As in start_decl_1, complete so TREE_READONLY is set properly. */
8363 {
8369 }
8372 /* Update the type of the corresponding TEMPLATE_DECL to match. */
8377 }
8380 {
8383 {
8386 }
8387 }
8397 {
8399 ? TCTX_THREAD_STORAGE
8402 }
8405 {
8406 tree clone;
8408 {
8409 /* FIXME check this is 1st decl. */
8414 {
8418 }
8420 }
8422 {
8425 else
8427 }
8428 }
8431 {
8433 /* If DECL is a reference, then we want to know whether init is a
8434 reference constant; init_const_expr_p as passed tells us whether
8435 it's an rvalue constant. */
8439 {
8440 /* Set these flags now for templates. We'll update the flags in
8441 store_init_value for instantiations. */
8444 /* FIXME setting TREE_CONSTANT on refs breaks the back end. */
8447 }
8448 /* This is handled mostly by gimplify.cc, but we have to deal with
8449 not warning about int x = x; as it is a GCC extension to turn off
8450 this warning but only if warn_init_self is zero. */
8456 }
8462 /* We have no initializer but there's nothing to initialize anyway.
8463 Treat DECL as constant due to c++/109876. */
8468 /* #pragma omp declare variant on methods handled in finish_struct
8469 instead. */
8477 {
8480 /* Add this declaration to the statement-tree. */
8487 {
8490 }
8492 /* Generally, initializers in templates are expanded when the
8493 template is instantiated. But, if DECL is a variable constant
8494 then it can be used in future constant expressions, so its value
8495 must be available. */
8502 {
8505 }
8511 {
8512 /* This variable seems to be a non-dependent constant, so process
8513 its initializer. If check_initializer returns non-null the
8514 initialization wasn't constant after all. */
8515 tree init_code;
8521 }
8522 else
8523 {
8525 /* Try to deduce array size. */
8527 /* And complain about multiple initializers. */
8531 tf_warning_or_error);
8532 }
8538 {
8541 }
8544 {
8547 }
8549 }
8551 /* Just store non-static data member initializers for later. */
8555 /* Take care of TYPE_DECLs up front. */
8557 {
8560 {
8564 }
8566 /* If we have installed this as the canonical typedef for this
8567 type, and that type has not been defined yet, delay emitting
8568 the debug information for it, as we will emit it later. */
8574 at_eof);
8576 }
8578 /* A reference will be modified here, as it is initialized. */
8582 {
8585 }
8587 /* This needs to happen before extend_ref_init_temps. */
8589 {
8593 }
8596 {
8598 /* [dcl.constinit]/1 "The constinit specifier shall be applied
8599 only to a declaration of a variable with static or thread storage
8600 duration." */
8603 {
8605 "%<constinit%> can only be applied to a variable with "
8608 }
8613 /* If this is a local variable that will need a mangled name,
8614 register it now. We must do this before processing the
8615 initializer for the variable, since the initialization might
8616 require a guard variable, and since the mangled name of the
8617 guard variable will depend on the mangled name of this
8618 variable. */
8622 {
8623 /* The variable holding an anonymous union will have had its
8624 discriminator set in finish_anon_union, after which it's
8625 NAME will have been cleared. */
8628 /* Normally has_forced_label_in_static is set during GIMPLE
8629 lowering, but [cd]tors are never actually compiled directly.
8630 We need to set this early so we can deal with the label
8631 address extension. */
8635 {
8638 }
8639 /* And make sure it's in the symbol table for
8640 c_parse_final_cleanups to find. */
8642 }
8644 /* Convert the initializer to the type of DECL, if we have not
8645 already initialized DECL. */
8647 /* If !DECL_EXTERNAL then DECL is being defined. In the
8648 case of a static data member initialized inside the
8649 class-specifier, there can be an initializer even if DECL
8650 is *not* defined. */
8652 {
8656 /* Handle:
8658 [dcl.init]
8660 The memory occupied by any object of static storage
8661 duration is zero-initialized at program startup before
8662 any other initialization takes place.
8664 We cannot create an appropriate initializer until after
8665 the type of DECL is finalized. If DECL_INITIAL is set,
8666 then the DECL is statically initialized, and any
8667 necessary zero-initialization has already been performed. */
8672 /* Remember that the initialization for this variable has
8673 taken place. */
8675 /* This declaration is the definition of this variable,
8676 unless we are initializing a static data member within
8677 the class specifier. */
8680 }
8681 /* If the variable has an array type, lay out the type, even if
8682 there is no initializer. It is valid to index through the
8683 array, and we must get TYPE_ALIGN set correctly on the array
8684 type. */
8691 /* So decl is a global variable or a static member of a
8692 non local class. Record the types it uses
8693 so that we can decide later to emit debug info for them. */
8695 }
8697 /* Add this declaration to the statement-tree. This needs to happen
8698 after the call to check_initializer so that the DECL_EXPR for a
8699 reference temp is added before the DECL_EXPR for the reference itself. */
8701 {
8702 /* If we're building a variable sized type, and we might be
8703 reachable other than via the top of the current binding
8704 level, then create a new BIND_EXPR so that we deallocate
8705 the object at the right time. */
8710 {
8711 tree bind;
8716 }
8718 }
8720 /* Let the middle end know about variables and functions -- but not
8721 static data members in uninstantiated class templates. */
8723 {
8725 {
8728 /* Check again now that we have an initializer. */
8730 /* A class-scope constexpr variable with an out-of-class declaration.
8731 C++17 makes them implicitly inline, but still force it out. */
8737 }
8740 /* With -fmerge-all-constants, gimplify_init_constructor
8741 might add TREE_STATIC to aggregate variables. */
8745 {
8746 /* If a TREE_READONLY variable needs initialization
8747 at runtime, it is no longer readonly and we need to
8748 avoid MEM_READONLY_P being set on RTL created for it. */
8750 {
8754 }
8758 /* Likewise if it needs destruction. */
8761 }
8767 {
8768 /* TLS variables need dynamic initialization by the TLS wrapper
8769 function, we don't want to hoist accesses to it before the
8770 wrapper. */
8773 }
8777 /* Check for abstractness of the type. */
8782 /* No initialization required. */
8783 ;
8785 {
8787 {
8789 {
8790 /* An out-of-class default definition is defined at
8791 the point where it is explicitly defaulted. */
8796 }
8797 else
8801 decl);
8802 }
8803 /* else no initialization required. */
8804 }
8808 {
8809 /* check_initializer will have done any constant initialization. */
8810 }
8811 /* A variable definition. */
8813 /* Initialize the local variable. */
8816 /* If a variable is defined, and then a subsequent
8817 definition with external linkage is encountered, we will
8818 get here twice for the same variable. We want to avoid
8819 calling expand_static_init more than once. For variables
8820 that are not static data members, we can call
8821 expand_static_init only when we actually process the
8822 initializer. It is not legal to redeclare a static data
8823 member, so this issue does not arise in that case. */
8826 }
8828 /* If a CLEANUP_STMT was created to destroy a temporary bound to a
8829 reference, insert it in the statement-tree now. */
8831 {
8833 {
8835 /* As in initialize_local_var. */
8837 }
8839 }
8848 {
8854 {
8860 }
8865 {
8871 {
8874 {
8878 }
8879 }
8880 }
8881 }
8883 /* This is the last point we can lower alignment so give the target the
8884 chance to do so. */
8891 }
8893 /* For class TYPE return itself or some its bases that contain
8894 any direct non-static data members. Return error_mark_node if an
8895 error has been diagnosed. */
8897 static tree
8899 {
8909 {
8913 else
8918 }
8920 {
8928 }
8929 else
8939 {
8944 {
8946 {
8951 }
8955 {
8957 "classes %qT and %qT have non-static data "
8960 }
8961 else
8963 }
8964 }
8966 }
8968 /* Return std::tuple_size<TYPE>::value. */
8970 static tree
8972 {
8992 else
8994 }
8996 /* Return std::tuple_element<I,TYPE>::type. */
8998 static tree
9000 {
9008 tf_warning_or_error);
9011 }
9013 /* Return e.get<i>() or get<i>(e). */
9015 static tree
9017 {
9024 /* [The id-expression] e is an lvalue if the type of the entity e is an
9025 lvalue reference and an xvalue otherwise. */
9034 /* To use a member get, member lookup must find at least one
9035 declaration that is a function template
9036 whose first template parameter is a non-type parameter. */
9038 {
9041 {
9045 {
9048 }
9049 }
9050 }
9053 {
9058 }
9059 else
9060 {
9066 }
9067 }
9069 /* It's impossible to recover the decltype of a tuple decomposition variable
9070 based on the actual type of the variable, so store it in a hash table. */
9074 tree
9076 {
9078 }
9080 /* Mangle a decomposition declaration if needed. Arguments like
9081 in cp_finish_decomp. */
9083 static void
9085 {
9089 {
9096 {
9105 {
9110 }
9113 }
9116 }
9117 }
9119 /* Finish a decomposition declaration. DECL is the underlying declaration
9120 "e", FIRST is the head of a chain of decls for the individual identifiers
9121 chained through DECL_CHAIN in reverse order and COUNT is the number of
9122 those decls. */
9124 void
9126 {
9130 {
9131 error_out:
9133 {
9136 {
9139 }
9141 }
9145 }
9149 /* This happens for range for when not in templates.
9150 Still add the DECL_VALUE_EXPRs for later processing. */
9151 || (!processing_template_decl
9153 {
9155 {
9157 {
9163 }
9167 }
9169 }
9175 {
9178 }
9184 {
9190 {
9192 type);
9194 }
9195 }
9200 {
9201 tree nelts;
9206 {
9209 }
9212 {
9213 cnt_mismatch:
9218 else
9227 }
9230 {
9239 }
9240 }
9241 /* 2 GNU extensions. */
9243 {
9249 {
9258 }
9259 }
9261 {
9263 {
9266 }
9271 {
9282 }
9283 }
9285 {
9287 {
9291 }
9293 {
9300 }
9306 {
9317 {
9321 }
9323 {
9327 }
9328 /* Save the decltype away before reference collapse. */
9334 {
9335 /* In this case the names are variables, not just proxies. */
9338 }
9340 {
9344 }
9345 }
9346 /* Ignore reads from the underlying decl performed during initialization
9347 of the individual variables. If those will be read, we'll mark
9348 the underlying decl as read at that point. */
9350 }
9352 {
9355 }
9357 {
9360 }
9362 {
9365 }
9370 type);
9371 else
9372 {
9377 {
9381 }
9387 else
9388 eltscnt++;
9393 {
9397 }
9404 else
9405 {
9407 NULL_TREE);
9413 {
9416 }
9417 i++;
9418 }
9419 }
9421 {
9424 {
9429 }
9430 }
9431 }
9433 /* Returns a declaration for a VAR_DECL as if:
9435 extern "C" TYPE NAME;
9437 had been seen. Used to create compiler-generated global
9438 variables. */
9440 static tree
9442 {
9449 /* If the user has explicitly declared this variable (perhaps
9450 because the code we are compiling is part of a low-level runtime
9451 library), then it is possible that our declaration will be merged
9452 with theirs by pushdecl. */
9458 }
9460 /* Returns the type for the argument to "__cxa_atexit" (or "atexit",
9461 if "__cxa_atexit" is not being used) corresponding to the function
9462 to be called when the program exits. */
9464 static tree
9466 {
9467 tree fn_type;
9470 {
9471 tree arg_type;
9474 /* The parameter to "__cxa_atexit" is "void (*)(void *)". */
9476 else
9477 /* The parameter to "atexit" is "void (*)(void)". */
9483 }
9486 }
9488 /* Returns a pointer to the `atexit' function. Note that if
9489 FLAG_USE_CXA_ATEXIT is nonzero, then this will actually be the new
9490 `__cxa_atexit' function specified in the IA64 C++ ABI. */
9492 static tree
9494 {
9495 tree atexit_fndecl;
9496 tree fn_type;
9497 tree fn_ptr_type;
9506 {
9507 /* The declaration for `__cxa_atexit' is:
9509 int __cxa_atexit (void (*)(void *), void *, void *)
9511 We build up the argument types and then the function type
9512 itself. */
9516 /* First, build the pointer-to-function type for the first
9517 argument. */
9519 /* Then, build the rest of the argument types. */
9522 {
9525 }
9526 else
9527 {
9530 }
9531 /* And the final __cxa_atexit type. */
9534 NULL_TREE);
9535 /* ... which needs noexcept. */
9538 {
9546 }
9547 else
9548 {
9551 }
9552 }
9553 else
9554 {
9555 /* The declaration for `atexit' is:
9557 int atexit (void (*)());
9559 We build up the argument types and then the function type
9560 itself. */
9562 /* Build the final atexit type. */
9565 /* ... which needs noexcept. */
9568 }
9570 /* Now, build the function declaration. */
9575 /* Install as hidden builtin so we're (a) more relaxed about
9576 exception spec matching and (b) will not give a confusing location
9577 in diagnostic and (c) won't magically appear in user-visible name
9578 lookups. */
9587 }
9589 /* Like get_atexit_node, but for thread-local cleanups. */
9591 static tree
9593 {
9594 /* The declaration for `__cxa_thread_atexit' is:
9596 int __cxa_thread_atexit (void (*)(void *), void *, void *) */
9600 NULL_TREE);
9602 /* Now, build the function declaration. */
9606 }
9608 /* Returns the __dso_handle VAR_DECL. */
9610 static tree
9612 {
9616 /* Declare the variable. */
9618 ptr_type_node);
9620 #ifdef HAVE_GAS_HIDDEN
9622 {
9625 }
9626 #endif
9629 }
9631 /* Begin a new function with internal linkage whose job will be simply
9632 to destroy some particular variable. */
9636 static tree
9638 {
9643 /* No need to mangle this. */
9646 /* Build the name of the function. */
9648 /* Build the function declaration. */
9652 /* It's a function with internal linkage, generated by the
9653 compiler. */
9656 /* Make the function `inline' so that it is only emitted if it is
9657 actually needed. It is unlikely that it will be inlined, since
9658 it is only called via a function pointer, but we avoid unnecessary
9659 emissions this way. */
9663 {
9664 /* Build the parameter. */
9669 }
9677 }
9679 /* Finish the cleanup function begun by start_cleanup_fn. */
9681 static void
9683 {
9687 }
9689 /* Generate code to handle the destruction of DECL, an object with
9690 static storage duration. */
9692 tree
9694 {
9695 tree cleanup;
9696 tree addr;
9697 tree compound_stmt;
9698 tree fcall;
9699 tree type;
9702 tree atex_node;
9710 {
9713 }
9715 /* If we're using "__cxa_atexit" (or "__cxa_thread_atexit" or
9716 "__aeabi_atexit"), and DECL is a class object, we can just pass the
9717 destructor to "__cxa_atexit"; we don't have to build a temporary
9718 function to do the cleanup. */
9719 dso_parm = (flag_use_cxa_atexit
9724 {
9727 /* Make sure it is accessible. */
9729 tf_warning_or_error);
9730 }
9731 else
9732 {
9733 /* Call build_cleanup before we enter the anonymous function so
9734 that any access checks will be done relative to the current
9735 scope, rather than the scope of the anonymous function. */
9738 /* Now start the function. */
9741 /* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
9742 to the original function, rather than the anonymous one. That
9743 will make the back end think that nested functions are in use,
9744 which causes confusion. */
9749 /* Create the body of the anonymous function. */
9754 }
9756 /* Call atexit with the cleanup function. */
9762 else
9766 {
9767 /* We must convert CLEANUP to the type that "__cxa_atexit"
9768 expects. */
9770 /* "__cxa_atexit" will pass the address of DECL to the
9771 cleanup function. */
9774 /* The declared type of the parameter to "__cxa_atexit" is
9775 "void *". For plain "T*", we could just let the
9776 machinery in cp_build_function_call convert it -- but if the
9777 type is "cv-qualified T *", then we need to convert it
9778 before passing it in, to avoid spurious errors. */
9780 }
9781 else
9782 /* Since the cleanup functions we build ignore the address
9783 they're given, there's no reason to pass the actual address
9784 in, and, in general, it's cheaper to pass NULL than any
9785 other value. */
9790 tf_warning_or_error);
9792 /* Just pass NULL to the dso handle parm if we don't actually
9793 have a DSO handle on this target. */
9795 else
9799 {
9802 {
9805 }
9806 else
9807 {
9810 }
9811 }
9812 else
9813 {
9816 }
9819 }
9821 /* DECL is a VAR_DECL with static storage duration. INIT, if present,
9822 is its initializer. Generate code to handle the construction
9823 and destruction of DECL. */
9825 static void
9827 {
9831 /* Some variables require no dynamic initialization. */
9833 {
9834 /* Make sure the destructor is callable. */
9838 }
9842 {
9847 else
9852 {
9856 }
9858 }
9861 {
9862 /* Emit code to perform this initialization but once. */
9867 /* We don't need thread-safety code for thread-local vars. */
9871 /* Emit code to perform this initialization but once. This code
9872 looks like:
9874 static <type> guard;
9875 if (!__atomic_load (guard.first_byte)) {
9876 if (__cxa_guard_acquire (&guard)) {
9877 bool flag = false;
9878 try {
9879 // Do initialization.
9880 flag = true; __cxa_guard_release (&guard);
9881 // Register variable for destruction at end of program.
9882 } catch {
9883 if (!flag) __cxa_guard_abort (&guard);
9884 }
9885 }
9886 }
9888 Note that the `flag' variable is only set to 1 *after* the
9889 initialization is complete. This ensures that an exception,
9890 thrown during the construction, will cause the variable to
9891 reinitialized when we pass through this code again, as per:
9893 [stmt.dcl]
9895 If the initialization exits by throwing an exception, the
9896 initialization is not complete, so it will be tried again
9897 the next time control enters the declaration.
9899 This process should be thread-safe, too; multiple threads
9900 should not be able to initialize the variable more than
9901 once. */
9903 /* Create the guard variable. */
9906 /* Begin the conditional initialization. */
9913 {
9926 acquire_fn = push_library_fn
9929 NULL_TREE),
9934 NULL_TREE);
9937 ECF_NOTHROW);
9944 inner_if_stmt);
9952 void_node,
9956 /* Do the initialization itself. */
9962 /* Use atexit to register a function for destroying this static
9963 variable. Do this before calling __cxa_guard_release. */
9967 guard_addr));
9968 }
9969 else
9970 {
9973 /* Use atexit to register a function for destroying this static
9974 variable. */
9976 }
9981 {
9985 }
9990 }
9993 else
9995 }
9997 \f
9998 /* Make TYPE a complete type based on INITIAL_VALUE.
9999 Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
10000 2 if there was no information (in which case assume 0 if DO_DEFAULT),
10001 3 if the initializer list is empty (in pedantic mode). */
10003 int
10005 {
10009 /* Don't get confused by a CONSTRUCTOR for some other type. */
10016 {
10017 /* An array of character type can be initialized from a
10018 brace-enclosed string constant so call reshape_init to
10019 remove the optional braces from a braced string literal. */
10023 tf_warning_or_error);
10025 /* If any of the elements are parameter packs, we can't actually
10026 complete this type now because the array size is dependent. */
10031 }
10035 /* We can create the array before the element type is complete, which
10036 means that we didn't have these two bits set in the original type
10037 either. In completing the type, we are expected to propagate these
10038 bits. See also complete_type which does the same thing for arrays
10039 of fixed size. */
10042 {
10047 }
10050 }
10052 /* As above, but either give an error or reject zero-size arrays, depending
10053 on COMPLAIN. */
10055 int
10058 {
10061 /* In SFINAE context we can't be lenient about zero-size arrays. */
10068 {
10074 {
10077 }
10081 }
10083 }
10084 \f
10085 /* Return zero if something is declared to be a member of type
10086 CTYPE when in the context of CUR_TYPE. STRING is the error
10087 message to print in that case. Otherwise, quietly return 1. */
10089 static int
10091 {
10093 {
10096 else
10099 }
10101 }
10102 \f
10103 /* Subroutine of `grokdeclarator'. */
10105 /* Generate errors possibly applicable for a given set of specifiers.
10106 This is for ARM $7.1.2. */
10108 static void
10117 {
10119 {
10163 }
10167 && !flag_noexcept_type
10173 }
10175 /* DECL is a member function or static data member and is presently
10176 being defined. Check that the definition is taking place in a
10177 valid namespace. */
10179 static void
10181 {
10182 /* These checks only apply to member functions and static data
10183 members. */
10185 /* We check for problems with specializations in pt.cc in
10186 check_specialization_namespace, where we can issue better
10187 diagnostics. */
10190 /* We check this in check_explicit_instantiation_namespace. */
10193 /* [class.mfct]
10195 A member function definition that appears outside of the
10196 class definition shall appear in a namespace scope enclosing
10197 the class definition.
10199 [class.static.data]
10201 The definition for a static data member shall appear in a
10202 namespace scope enclosing the member's class definition. */
10206 }
10208 /* Build a PARM_DECL for the "this" parameter of FN. TYPE is the
10209 METHOD_TYPE for a non-static member function; QUALS are the
10210 cv-qualifiers that apply to the function. */
10212 tree
10214 {
10215 tree this_type;
10216 tree qual_type;
10217 tree parm;
10218 cp_cv_quals this_quals;
10221 {
10222 this_type
10225 }
10226 else
10228 /* The `this' parameter is implicitly `const'; it cannot be
10229 assigned to. */
10235 }
10237 /* DECL is a static member function. Complain if it was declared
10238 with function-cv-quals. */
10240 static void
10242 {
10245 decl);
10246 }
10248 // Check that FN takes no arguments and returns bool.
10249 static void
10251 {
10252 // A constraint is nullary.
10257 // The declared return type of the concept shall be bool, and
10258 // it shall not be deduced from it definition.
10266 }
10268 /* Helper function. Replace the temporary this parameter injected
10269 during cp_finish_omp_declare_simd with the real this parameter. */
10271 static tree
10273 {
10282 }
10284 /* CTYPE is class type, or null if non-class.
10285 TYPE is type this FUNCTION_DECL should have, either FUNCTION_TYPE
10286 or METHOD_TYPE.
10287 DECLARATOR is the function's name.
10288 PARMS is a chain of PARM_DECLs for the function.
10289 VIRTUALP is truthvalue of whether the function is virtual or not.
10290 FLAGS are to be passed through to `grokclassfn'.
10291 QUALS are qualifiers indicating whether the function is `const'
10292 or `volatile'.
10293 RAISES is a list of exceptions that this function can raise.
10294 CHECK is 1 if we must find this method in CTYPE, 0 if we should
10295 not look, and -1 if we should not call `grokclassfn' at all.
10297 SFK is the kind of special function (if any) for the new function.
10299 Returns `NULL_TREE' if something goes wrong, after issuing
10300 applicable error messages. */
10302 static tree
10304 tree type,
10305 tree declarator,
10306 tree parms,
10307 tree orig_declarator,
10309 tree decl_reqs,
10312 cp_cv_quals quals,
10313 cp_ref_qualifier rqual,
10314 tree raises,
10320 special_function_kind sfk,
10324 tree in_namespace,
10326 location_t location)
10327 {
10328 tree decl;
10330 tree t;
10335 /* Was the concept specifier present? */
10338 /* Concept declarations must have a corresponding definition. */
10340 {
10343 }
10349 /* Set the constraints on the declaration. */
10351 {
10356 && (current_template_depth
10359 {
10361 /* If there are no template parameters, something must have
10362 gone wrong. */
10364 else
10366 }
10369 {
10372 }
10373 /* C++20 CA378: Remove non-templated constrained functions. */
10374 /* [temp.friend]/9 A non-template friend declaration with a
10375 requires-clause shall be a definition. A friend function template with
10376 a constraint that depends on a template parameter from an enclosing
10377 template shall be a definition. */
10379 && (block_local
10380 || (!flag_concepts_ts
10381 && (!processing_template_decl
10383 {
10386 else
10390 }
10396 }
10399 {
10404 /* Allocate space to hold the vptr bit if needed. */
10406 }
10412 /* Propagate volatile out from type to decl. */
10416 /* Setup decl according to sfk. */
10418 {
10430 /* Give deduction guides a definition even though they don't really
10431 have one: the restriction that you can't repeat a deduction guide
10432 makes them more like a definition anyway. */
10437 }
10440 {
10444 orig_declarator);
10445 else
10446 {
10451 {
10452 /* Something like `template <class T> friend void f<T>()'. */
10454 "invalid use of template-id %qD in declaration "
10456 orig_declarator);
10458 }
10460 /* A friend declaration of the form friend void f<>(). Record
10461 the information in the TEMPLATE_ID_EXPR. */
10470 {
10472 "default arguments are not allowed in declaration "
10474 decl);
10476 }
10479 {
10481 "%<inline%> is not allowed in declaration of friend "
10483 decl);
10485 }
10486 }
10487 }
10489 /* C++17 11.3.6/4: "If a friend declaration specifies a default argument
10490 expression, that declaration shall be a definition..." */
10492 {
10496 {
10498 "friend declaration of %qD specifies default "
10501 }
10502 }
10504 /* If this decl has namespace scope, set that up. */
10509 else
10512 /* `main' and builtins have implicit 'C' linkage. */
10527 /* Should probably propagate const out from type to decl I bet (mrs). */
10529 {
10532 }
10541 {
10557 }
10559 /* Members of anonymous types and local classes have no linkage; make
10560 them internal. If a typedef is made later, this will be changed. */
10566 {
10567 /* [basic.link]: A name with no linkage (notably, the name of a class
10568 or enumeration declared in a local scope) shall not be used to
10569 declare an entity with linkage.
10571 DR 757 relaxes this restriction for C++0x. */
10573 }
10577 {
10580 }
10582 /* If the declaration was declared inline, mark it as such. */
10584 {
10588 }
10592 {
10595 }
10597 // If the concept declaration specifier was found, check
10598 // that the declaration satisfies the necessary requirements.
10600 {
10603 }
10607 {
10610 TYPE_UNQUALIFIED,
10611 REF_QUAL_NONE);
10614 {
10618 decl);
10620 }
10623 {
10627 decl);
10629 }
10630 }
10633 {
10637 {
10642 }
10645 {
10649 }
10653 }
10658 {
10662 /* [over.literal]/6: Literal operators shall not have C linkage. */
10664 {
10668 }
10671 {
10674 {
10677 }
10681 {
10685 }
10687 {
10691 }
10692 /* 17.6.3.3.5 */
10696 "literal operator suffixes not preceded by %<_%>"
10698 }
10699 else
10700 {
10703 }
10704 }
10707 /* Make the init_value nonzero so pushdecl knows this is not
10708 tentative. error_mark_node is replaced later with the BLOCK. */
10715 {
10716 /* Adjust "omp declare simd" attributes. */
10719 {
10720 tree attr;
10723 {
10728 {
10730 cl = c_omp_declare_simd_clauses_to_numbers
10734 else
10736 }
10737 }
10738 }
10739 }
10741 /* Caller will do the rest of this. */
10748 /* 12.4/3 */
10758 template_count,
10770 {
10773 }
10778 /* Check main's type after attributes have been applied. */
10780 {
10782 integer_type_node))
10783 {
10785 tree newtype;
10790 }
10793 }
10796 {
10798 (current_template_depth
10800 ? current_template_parms
10807 {
10808 tree ok;
10809 tree pushed_scope;
10812 /* Because grokfndecl is always supposed to return a
10813 FUNCTION_DECL, we pull out the DECL_TEMPLATE_RESULT
10814 here. We depend on our callers to figure out that its
10815 really a template that's being returned. */
10820 {
10821 /* Remove the `this' parm added by grokclassfn. */
10824 }
10826 {
10829 }
10831 {
10836 }
10838 /* Since we've smashed OLD_DECL to its
10839 DECL_TEMPLATE_RESULT, we must do the same to DECL. */
10843 /* Attempt to merge the declarations. This can fail, in
10844 the case of some invalid specialization declarations. */
10850 {
10854 }
10858 }
10859 }
10871 }
10873 /* decl is a FUNCTION_DECL.
10874 specifiers are the parsed virt-specifiers.
10876 Set flags to reflect the virt-specifiers.
10878 Returns decl. */
10880 static tree
10882 {
10890 }
10892 /* DECL is a VAR_DECL for a static data member. Set flags to reflect
10893 the linkage that DECL will receive in the object file. */
10895 static void
10897 {
10898 /* A static data member always has static storage duration and
10899 external linkage. Note that static data members are forbidden in
10900 local classes -- the only situation in which a class has
10901 non-external linkage. */
10904 /* For non-template classes, static data members are always put
10905 out in exactly those files where they are defined, just as
10906 with ordinary namespace-scope variables. */
10909 }
10911 /* Create a VAR_DECL named NAME with the indicated TYPE.
10913 If SCOPE is non-NULL, it is the class type or namespace containing
10914 the variable. If SCOPE is NULL, the variable should is created in
10915 the innermost enclosing scope. */
10917 static tree
10919 tree name,
10920 tree orig_declarator,
10927 tree scope,
10928 location_t location)
10929 {
10930 tree decl;
10931 tree explicit_scope;
10938 /* Compute the scope in which to place the variable, but remember
10939 whether or not that scope was explicitly specified by the user. */
10942 {
10943 /* An explicit "extern" specifier indicates a namespace-scope
10944 variable. */
10949 }
10953 template, we need DECL_LANG_SPECIFIC. */
10955 /* Similarly for namespace-scope variables with language linkage
10956 other than C++. */
10959 /* Similarly for static data members. */
10961 /* Similarly for explicit specializations. */
10962 || (orig_declarator
10965 else
10970 else
10974 {
10977 }
10980 {
10982 /* This function is only called with out-of-class definitions. */
10985 }
10986 /* At top level, either `static' or no s.c. makes a definition
10987 (perhaps tentative), and absence of `static' makes it public. */
10989 {
10992 || ! constp
10993 || volatilep
10996 }
10997 /* Not at top level, only `static' makes a static definition. */
10998 else
10999 {
11002 }
11007 {
11009 {
11013 }
11016 }
11018 /* If the type of the decl has no linkage, make sure that we'll
11019 notice that in mark_used. */
11028 {
11029 /* [basic.link]: A name with no linkage (notably, the name of a class
11030 or enumeration declared in a local scope) shall not be used to
11031 declare an entity with linkage.
11033 DR 757 relaxes this restriction for C++0x. */
11036 }
11037 else
11046 /* Check that the variable can be safely declared as a concept.
11047 Note that this also forbids explicit specializations. */
11049 {
11051 {
11055 }
11057 {
11061 }
11062 else
11068 {
11071 }
11072 }
11075 {
11078 }
11080 // Handle explicit specializations and instantiations of variable templates.
11086 }
11088 /* Create and return a canonical pointer to member function type, for
11089 TYPE, which is a POINTER_TYPE to a METHOD_TYPE. */
11091 tree
11093 {
11095 tree t;
11100 /* Make sure that we always have the unqualified pointer-to-member
11101 type first. */
11103 {
11106 }
11108 /* If a canonical type already exists for this type, use it. We use
11109 this method instead of type_hash_canon, because it only does a
11110 simple equality check on the list of field members. */
11118 /* Let the front end know this is a pointer to member function. */
11126 delta_type_node);
11133 /* Zap out the name so that the back end will give us the debugging
11134 information for this anonymous RECORD_TYPE. */
11137 /* Cache this pointer-to-member type so that we can find it again
11138 later. */
11147 }
11149 /* Create and return a pointer to data member type. */
11151 tree
11153 {
11155 {
11160 }
11161 else
11162 {
11165 }
11166 }
11168 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
11169 Check to see that the definition is valid. Issue appropriate error
11170 messages. */
11172 static void
11174 {
11175 /* Avoid redundant diagnostics on out-of-class definitions. */
11177 ;
11178 /* Can't check yet if we don't know the type. */
11180 ;
11181 /* If DECL is declared constexpr, we'll do the appropriate checks
11182 in check_initializer. Similarly for inline static data members. */
11186 ;
11188 {
11191 "in-class initialization of static data member %q#D of "
11195 "%<constexpr%> needed for in-class initialization of "
11197 else
11199 "in-class initialization of static data member %q#D of "
11201 }
11202 /* Motion 10 at San Diego: If a static const integral data member is
11203 initialized with an integral constant expression, the initializer
11204 may appear either in the declaration (within the class), or in
11205 the definition, but not both. If it appears in the class, the
11206 member is a member constant. The file-scope definition is always
11207 required. */
11210 "invalid in-class initialization of static data member "
11212 type);
11215 "ISO C++ forbids in-class initialization of non-const "
11217 decl);
11220 "ISO C++ forbids initialization of member constant "
11222 }
11224 /* *expr_p is part of the TYPE_SIZE of a variably-sized array. If any
11225 SAVE_EXPRs in *expr_p wrap expressions with side-effects, break those
11226 expressions out into temporary variables so that walk_tree doesn't
11227 step into them (c++/15764). */
11229 static tree
11231 {
11235 {
11241 }
11245 }
11247 /* Entry point for the above. */
11249 static void
11251 {
11253 /* Break out any function calls into temporary variables. */
11255 }
11257 /* Reduce a SIZEOF_EXPR to its value. */
11259 tree
11261 {
11262 tree r;
11271 else
11278 }
11280 /* Given the SIZE (i.e., number of elements) in an array, compute
11281 an appropriate index type for the array. If non-NULL, NAME is
11282 the name of the entity being declared. */
11284 static tree
11286 tsubst_flags_t complain)
11287 {
11291 /* The type of the index being computed. */
11292 tree itype;
11294 /* The original numeric size as seen in the source code before
11295 conversion to size_t. */
11301 {
11306 /* In C++98, we mark a non-constant array bound with a magic
11308 else
11309 {
11311 /* Pedantically a constant expression is required here and so
11312 __builtin_is_constant_evaluated () should fold to true if it
11313 is successfully folded into a constant. */
11319 }
11324 /* The array bound must be an integer type. */
11327 {
11333 else
11336 }
11337 }
11339 /* A type is dependent if it is...an array type constructed from any
11340 dependent type or whose size is specified by a constant expression
11341 that is value-dependent. */
11342 /* We can only call value_dependent_expression_p on integral constant
11343 expressions. */
11347 {
11348 /* Just build the index type and mark that it requires
11349 structural equality checks. */
11350 in_template:
11357 }
11360 {
11363 {
11367 else
11370 }
11372 /* We might have lost the TREE_CONSTANT flag e.g. when we are
11373 folding a conversion from a pointer to integral type. In that
11375 else
11376 /* Use the folded result for VLAs, too; it will have resolved
11377 SIZEOF_EXPR. */
11379 }
11381 /* Normally, the array-bound will be a constant. */
11383 {
11384 /* The size to use in diagnostics that reflects the constant
11385 size used in the source, rather than SIZE massaged above. */
11388 /* If the original size before conversion to size_t was signed
11389 and negative, convert it to ssizetype to restore the sign. */
11393 {
11396 /* Clear the overflow bit that may have been set as a result
11397 of the conversion from the sizetype of the new size to
11398 ssizetype. */
11400 }
11402 /* Verify that the array has a positive number of elements
11403 and issue the appropriate diagnostic if it doesn't. */
11405 {
11409 }
11410 /* As an extension we allow zero-sized arrays. */
11412 {
11414 /* We must fail if performing argument deduction (as
11415 indicated by the state of complain), so that
11416 another substitution can be found. */
11421 else
11424 }
11425 }
11427 /* We don't allow VLAs at non-function scopes, or during
11428 tentative template substitution. */
11431 {
11434 /* `(int) &fn' is not a valid array bound. */
11438 name);
11439 else
11442 }
11444 {
11448 else
11451 }
11453 {
11457 else
11460 }
11464 else
11465 {
11467 {
11468 /* A variable sized array. Arrange for the SAVE_EXPR on the inside
11469 of the MINUS_EXPR, which allows the -1 to get folded with the +1
11470 that happens when building TYPE_SIZE. */
11473 }
11475 /* Compute the index of the largest element in the array. It is
11476 one less than the number of elements in the array. We save
11477 and restore PROCESSING_TEMPLATE_DECL so that computations in
11478 cp_build_binary_op will be appropriately folded. */
11479 {
11480 processing_template_decl_sentinel s;
11482 MINUS_EXPR,
11485 complain),
11486 complain);
11488 }
11491 {
11494 {
11495 /* We have to add 1 -- in the ubsan routine we generate
11496 LE_EXPR rather than LT_EXPR. */
11501 }
11502 }
11503 /* Make sure that there was no overflow when creating to a signed
11504 index type. (For example, on a 32-bit machine, an array with
11505 size 2^32 - 1 is too big.) */
11508 {
11513 }
11514 }
11516 /* Create and return the appropriate index type. */
11519 /* If the index type were dependent, we would have returned early, so
11520 remember that it isn't. */
11524 }
11526 tree
11528 {
11530 }
11532 /* Returns the scope (if any) in which the entity declared by
11533 DECLARATOR will be located. If the entity was declared with an
11534 unqualified name, NULL_TREE is returned. */
11536 tree
11538 {
11542 /* If the declarator-id is a SCOPE_REF, the scope in which the
11543 declaration occurs is the first operand. */
11548 /* Otherwise, the declarator is not a qualified name; the entity will
11549 be declared in the current scope. */
11551 }
11553 /* Returns an ARRAY_TYPE for an array with SIZE elements of the
11554 indicated TYPE. If non-NULL, NAME is the NAME of the declaration
11555 with this type. */
11557 static tree
11559 {
11562 /* If things have already gone awry, bail now. */
11566 /* [dcl.type.class.deduct] prohibits forming an array of placeholder
11567 for a deduced class type. */
11569 {
11573 else
11576 }
11578 /* If there are some types which cannot be array elements,
11579 issue an error-message and return. */
11581 {
11585 else
11592 else
11599 else
11606 name);
11607 else
11613 }
11619 /* [dcl.array]
11621 The constant expressions that specify the bounds of the arrays
11622 can be omitted only for the first member of the sequence. */
11624 {
11628 name);
11629 else
11634 }
11636 /* Figure out the index type for the array. */
11638 {
11640 tf_warning_or_error);
11643 {
11646 }
11647 }
11650 }
11652 /* Returns the smallest location that is not UNKNOWN_LOCATION. */
11654 static location_t
11656 {
11662 }
11664 /* Returns the smallest location != UNKNOWN_LOCATION among the
11665 three stored in LOCATIONS[ds_const], LOCATIONS[ds_volatile],
11666 and LOCATIONS[ds_restrict]. */
11668 static location_t
11670 {
11683 }
11685 /* Returns the smallest among the latter and locations[ds_type_spec]. */
11687 static location_t
11689 {
11692 }
11694 static location_t
11696 {
11699 }
11701 /* Check that it's OK to declare a function with the indicated TYPE
11702 and TYPE_QUALS. SFK indicates the kind of special function (if any)
11703 that this function is. OPTYPE is the type given in a conversion
11704 operator declaration, or the class type for a constructor/destructor.
11705 Returns the actual return type of the function; that may be different
11706 than TYPE if an error occurs, or for certain special functions. */
11708 static tree
11710 tree type,
11711 tree optype,
11714 {
11716 {
11727 else
11739 /* We can't use the proper return type here because we run into
11740 problems with ambiguous bases and covariant returns. */
11743 else
11753 "qualifiers are not allowed on declaration of "
11765 "qualifiers are not allowed on declaration of "
11768 {
11772 }
11773 else
11783 }
11786 }
11788 /* A variable or data member (whose unqualified name is IDENTIFIER)
11789 has been declared with the indicated TYPE. If the TYPE is not
11790 acceptable, issue an error message and return a type to use for
11791 error-recovery purposes. */
11793 tree
11795 {
11797 {
11801 {
11804 identifier);
11805 }
11806 else
11809 }
11812 }
11814 /* Handle declaring DECL as an inline variable. */
11816 static void
11818 {
11821 {
11825 }
11830 {
11833 }
11834 }
11837 /* Assign a typedef-given name to a class or enumeration type declared
11838 as anonymous at first. This was split out of grokdeclarator
11839 because it is also used in libcc1. */
11841 void
11843 {
11846 /* Replace the anonymous decl with the real decl. Be careful not to
11847 rename other typedefs (such as the self-reference) of type. */
11853 /* If this is a typedef within a template class, the nested
11854 type is a (non-primary) template. The name for the
11855 template needs updating as well. */
11859 /* Adjust linkage now that we aren't unnamed anymore. */
11862 /* FIXME remangle member functions; member functions of a
11863 type with external linkage have external linkage. */
11865 /* Check that our job is done, and that it would fail if we
11866 attempted to do it again. */
11868 }
11870 /* Check that decltype(auto) was well-formed: only plain decltype(auto)
11871 is allowed. TYPE might contain a decltype(auto). Returns true if
11872 there was a problem, false otherwise. */
11874 static bool
11876 {
11878 {
11880 {
11882 {
11886 }
11888 {
11891 }
11892 }
11893 }
11895 }
11897 /* Given declspecs and a declarator (abstract or otherwise), determine
11898 the name and type of the object declared and construct a DECL node
11899 for it.
11901 DECLSPECS points to the representation of declaration-specifier
11902 sequence that precedes declarator.
11904 DECL_CONTEXT says which syntactic context this declaration is in:
11905 NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
11906 FUNCDEF for a function definition. Like NORMAL but a few different
11907 error messages in each case. Return value may be zero meaning
11908 this definition is too screwy to try to parse.
11909 MEMFUNCDEF for a function definition. Like FUNCDEF but prepares to
11910 handle member functions (which have FIELD context).
11911 Return value may be zero meaning this definition is too screwy to
11912 try to parse.
11913 PARM for a parameter declaration (either within a function prototype
11914 or before a function body). Make a PARM_DECL, or return void_type_node.
11915 TPARM for a template parameter declaration.
11916 CATCHPARM for a parameter declaration before a catch clause.
11917 TYPENAME if for a typename (in a cast or sizeof).
11918 Don't make a DECL node; just return the ..._TYPE node.
11919 FIELD for a struct or union field; make a FIELD_DECL.
11920 BITFIELD for a field with specified width.
11922 INITIALIZED is as for start_decl.
11924 ATTRLIST is a pointer to the list of attributes, which may be NULL
11925 if there are none; *ATTRLIST may be modified if attributes from inside
11926 the declarator should be applied to the declaration.
11928 When this function is called, scoping variables (such as
11929 CURRENT_CLASS_TYPE) should reflect the scope in which the
11930 declaration occurs, not the scope in which the new declaration will
11931 be placed. For example, on:
11933 void S::f() { ... }
11935 when grokdeclarator is called for `S::f', the CURRENT_CLASS_TYPE
11936 should not be `S'.
11938 Returns a DECL (if a declarator is present), a TYPE (if there is no
11939 declarator, in cases like "struct S;"), or the ERROR_MARK_NODE if an
11940 error occurs. */
11942 tree
11948 {
11961 /* True if this declarator is a function definition. */
11965 #if 0
11966 /* See the code below that used this. */
11968 #endif
11970 /* Keep track of what sort of function is being processed
11971 so that we can warn about default return values, or explicit
11972 return values which do not match prescribed defaults. */
11978 /* cv-qualifiers that apply to the declarator, for a declaration of
11979 a member function. */
11981 /* virt-specifiers that apply to the declarator, for a declaration of
11982 a member function. */
11984 /* ref-qualifier that applies to the declarator, for a declaration of
11985 a member function. */
11987 /* cv-qualifiers that apply to the type specified by the DECLSPECS. */
11994 /* The unqualified name of the declarator; either an
11995 IDENTIFIER_NODE, BIT_NOT_EXPR, or TEMPLATE_ID_EXPR. */
11996 tree unqualified_id;
11997 /* The class type, if any, in which this entity is located,
11998 or NULL_TREE if none. Note that this value may be different from
11999 the current class type; for example if an attempt is made to declare
12000 "A::f" inside "B", this value will be "A". */
12002 /* The NAMESPACE_DECL for the namespace in which this entity is
12003 located. If an unqualified name is used to declare the entity,
12004 this value will be NULL_TREE, even if the entity is located at
12005 namespace scope. */
12007 cp_storage_class storage_class;
12030 // Was concept_p specified? Note that ds_concept
12031 // implies ds_constexpr!
12053 location_t id_loc;
12054 location_t init_loc;
12056 {
12059 }
12060 else
12063 /* Look inside a declarator for the name being declared
12064 and get it as a string, for an error message. */
12066 id_declarator;
12068 {
12073 {
12077 {
12081 }
12085 {
12091 {
12096 {
12097 /* [dcl.meaning]
12099 A declarator-id shall not be qualified except
12100 for ...
12102 None of the cases are permitted in block
12103 scope. */
12106 decl);
12110 else
12114 }
12116 {
12119 {
12123 }
12125 && current_class_type
12127 current_class_type))
12128 {
12133 }
12134 }
12137 }
12139 {
12141 {
12143 {
12147 }
12150 {
12154 }
12161 }
12165 {
12171 }
12172 /* Fall through. */
12179 {
12181 dname);
12183 }
12186 else
12187 {
12194 else
12196 }
12201 }
12203 }
12220 }
12223 }
12225 /* [dcl.fct.edf]
12227 The declarator in a function-definition shall have the form
12228 D1 ( parameter-declaration-clause) ... */
12230 {
12233 }
12238 {
12241 }
12244 {
12247 {
12250 }
12253 {
12255 {
12258 }
12260 {
12263 }
12264 }
12265 }
12267 /* Anything declared one level down from the top level
12268 must be one of the parameters of a function
12269 (because the body is at least two levels down). */
12271 /* This heuristic cannot be applied to C++ nodes! Fixed, however,
12272 by not allowing C++ class definitions to specify their parameters
12273 with xdecls (must be spec.d in the parmlist).
12275 Since we now wait to push a class scope until we are sure that
12276 we are in a legitimate method context, we must set oldcname
12277 explicitly (since current_class_name is not yet alive).
12279 We also want to avoid calling this a PARM if it is in a namespace. */
12282 {
12288 }
12294 {
12298 }
12301 {
12305 }
12308 {
12312 }
12315 {
12319 }
12322 {
12326 }
12328 /* [dcl.spec]/2 "At most one of the constexpr, consteval, and constinit
12329 keywords shall appear in a decl-specifier-seq." */
12331 {
12335 "can use at most one of the %<constinit%> and %<constexpr%> "
12338 }
12340 /* If there were multiple types specified in the decl-specifier-seq,
12341 issue an error message. */
12343 {
12347 }
12352 /* Extract the basic type from the decl-specifier-seq. */
12355 {
12358 }
12360 /* Ignore erroneous attributes. */
12364 /* An object declared as __attribute__((unavailable)) suppresses
12365 any reports of being declared with unavailable or deprecated
12366 items. An object declared as __attribute__((deprecated))
12367 suppresses warnings of uses of other deprecated items. */
12376 {
12382 }
12383 /* No type at all: default to `int', and set DEFAULTED_INT
12384 because it was not a user-defined typedef. */
12386 {
12388 {
12389 /* These imply 'int'. */
12392 }
12393 /* If we just have "complex", it is equivalent to "complex double". */
12396 {
12399 "ISO C++ does not support plain %<complex%> meaning "
12401 }
12402 }
12403 /* Gather flags. */
12407 #if 0
12408 /* See the code below that used this. */
12411 #endif
12416 else
12420 {
12422 ctor_return_type,
12423 type_quals,
12426 }
12428 {
12433 /* We handle `main' specially here, because 'main () { }' is so
12434 common. With no options, it is allowed. With -Wreturn-type,
12435 it is a warning. It is only an error with -pedantic-errors. */
12436 is_main = (funcdef_flag
12449 name);
12453 else
12458 /* FIXME we should be able to propagate the error_mark_node as is
12459 for other contexts too. */
12461 else
12463 }
12468 {
12470 {
12475 }
12476 /* Don't pedwarn if the alternate "__intN__" form has been used instead
12477 of "__intN". */
12482 }
12484 /* Now process the modifiers that were specified
12485 and check for invalid combinations. */
12487 /* Long double is a special combination. */
12489 {
12493 }
12495 /* Check all other uses of type modifiers. */
12498 {
12499 location_t loc;
12502 {
12505 }
12507 {
12510 }
12512 {
12515 }
12517 {
12520 }
12522 {
12525 }
12530 {
12535 }
12537 {
12541 }
12551 {
12553 {
12558 /* PR108099: __int128_t comes from c_common_nodes_and_builtins,
12559 and is not built as a typedef. */
12562 }
12565 else
12567 }
12568 else
12571 /* Discard the type modifiers if they are invalid. */
12573 {
12579 }
12580 }
12582 /* Decide whether an integer type is signed or not.
12583 Optionally treat bitfields as signed by default. */
12585 /* [class.bit]
12587 It is implementation-defined whether a plain (neither
12588 explicitly signed or unsigned) char, short, int, or long
12589 bit-field is signed or unsigned.
12591 Naturally, we extend this to long long as well. Note that
12592 this does not include wchar_t. */
12594 && !signed_p
12595 /* A typedef for plain `int' without `signed' can be
12596 controlled just like plain `int', but a typedef for
12597 `signed int' cannot be so controlled. */
12598 && !(typedef_decl
12602 {
12615 else
12617 }
12632 {
12636 /* If a modifier is specified, the resulting complex is the complex
12637 form of TYPE. E.g, "complex short" is "complex short int". */
12646 else
12648 }
12650 /* If we're using the injected-class-name to form a compound type or a
12651 declaration, replace it with the underlying class so we don't get
12652 redundant typedefs in the debug output. But if we are returning the
12653 type unchanged, leave it alone so that it's available to
12654 maybe_get_template_decl_from_type_decl. */
12662 type = cp_build_qualified_type
12666 /* We might have ignored or rejected some of the qualifiers. */
12671 /* Placeholder in parm gets a better error below. */
12675 {
12676 auto_diagnostic_group g;
12680 "for deduction, template placeholder must be followed "
12684 }
12695 /* Treat class-scope deduction guides as static member functions
12696 so that they get a FUNCTION_TYPE instead of a METHOD_TYPE. */
12700 {
12702 {
12709 }
12711 {
12715 "declared both %<virtual%> and %<constexpr%> only in "
12717 }
12718 }
12721 /* Issue errors about use of storage classes for parameters. */
12723 {
12725 {
12729 }
12731 {
12735 name);
12737 }
12741 {
12746 }
12748 /* Function parameters cannot be concept. */
12750 {
12755 }
12756 /* Function parameters cannot be constexpr. If we saw one, moan
12757 and pretend it wasn't there. */
12759 {
12763 }
12765 {
12769 }
12771 {
12775 }
12776 }
12778 /* Give error if `virtual' is used outside of class declaration. */
12781 {
12785 }
12788 {
12805 "structured binding declaration can be %qs only in "
12807 declspecs->gnu_thread_keyword_p
12812 /* [dcl.struct.bind] "A cv that includes volatile is deprecated." */
12817 {
12827 "structured binding declaration can be %qs only in "
12844 }
12847 {
12849 {
12850 auto_diagnostic_group d;
12854 "type must be cv-qualified %<auto%> or reference to "
12856 }
12859 }
12862 "structured binding declaration cannot have constrained "
12870 {
12873 }
12874 }
12876 /* Static anonymous unions are dealt with here. */
12882 /* Warn about storage classes that are invalid for certain
12883 kinds of declarations (parameters, typenames, etc.). */
12885 && ((storage_class
12889 {
12890 location_t loc
12895 }
12900 {
12904 ;
12906 ;
12908 /* C++ allows static class elements. */
12910 /* C++ also allows inlines and signed and unsigned elements,
12911 but in those cases we don't come in here. */
12912 ;
12913 else
12914 {
12915 location_t loc
12922 else
12929 }
12930 }
12935 {
12939 }
12943 {
12949 /* When thread_local is applied to a variable of block scope the
12950 storage-class-specifier static is implied if it does not appear
12951 explicitly. */
12954 }
12957 {
12960 "storage class specifiers invalid in friend function "
12964 }
12968 else
12969 {
12972 {
12985 }
12986 }
12990 {
12995 }
13000 /* Determine the type of the entity declared by recurring on the
13001 declarator. */
13003 {
13005 tree attrs;
13012 {
13024 /* Assume that any attributes that get applied late to
13025 templates will DTRT when applied to the declaration
13026 as a whole. */
13030 attrs),
13031 attr_flags);
13033 }
13037 /* Check that contracts aren't misapplied. */
13043 /* We don't want to warn in parameter context because we don't
13044 yet know if the parse will succeed, and this might turn out
13045 to be a constructor call. */
13048 && !typedef_p
13050 /* If the type is class-like and the inner name used a
13051 global namespace qualifier, we need the parens.
13052 Unfortunately all we can tell is whether a qualified name
13053 was used or not. */
13054 && !(inner_declarator
13059 {
13062 name))
13063 {
13068 }
13069 }
13074 {
13085 /* [dcl.array]/1:
13087 The optional attribute-specifier-seq appertains to the
13088 array. */
13094 {
13095 tree arg_types;
13098 /* Declaring a function type. */
13100 /* Pick up type qualifiers which should be applied to `this'. */
13102 /* Pick up virt-specifiers. */
13104 /* And ref-qualifier, too */
13106 /* And tx-qualifier. */
13108 /* Pick up the exception specifications. */
13110 /* If the exception-specification is ill-formed, let's pretend
13111 there wasn't one. */
13119 /* Say it's a definition only for the CALL_EXPR
13120 closest to the identifier. */
13123 /* Handle a late-specified return type. */
13126 {
13128 {
13135 {
13137 "%<auto%> type specifier without "
13140 "deduced return type only available "
13142 }
13144 {
13148 }
13149 }
13151 {
13153 "return type has %qT as its type rather "
13156 }
13158 {
13161 "%qs function with trailing return type "
13162 "has %<decltype(auto)%> as its type "
13164 else
13168 }
13174 {
13176 {
13177 auto_diagnostic_group g;
13184 }
13186 {
13188 "for %qT must have trailing return "
13193 }
13199 else
13203 }
13204 }
13207 {
13211 /* Not using maybe_warn_cpp0x because this should
13212 always be an error. */
13214 "trailing return type only available "
13216 else
13218 "return type not declared with %<auto%> "
13221 }
13223 {
13226 }
13232 {
13235 }
13238 {
13239 /* It's wrong, for instance, to issue a -Wignored-qualifiers
13240 warning for
13241 static_assert(!is_same_v<void(*)(), const void(*)()>);
13242 because there the qualifier matters. */
13246 /* [dcl.fct] "A volatile-qualified return type is
13247 deprecated." */
13250 "%<volatile%>-qualified return type is "
13253 /* We now know that the TYPE_QUALS don't apply to the
13254 decl, but to its return type. */
13256 }
13258 /* Error about some types functions can't return. */
13261 {
13265 }
13267 {
13271 }
13273 {
13275 "%<constinit%> on function return type is not "
13278 }
13285 && funcdecl_p
13291 {
13292 /* We are within a class's scope. If our declarator name
13293 is the same as the class name, and we are defining
13294 a function, then it is a constructor/destructor, and
13295 therefore returns a void type. */
13297 /* ISO C++ 12.4/2. A destructor may not be declared
13298 const or volatile. A destructor may not be static.
13299 A destructor may not be declared with ref-qualifier.
13301 ISO C++ 12.1. A constructor may not be declared
13302 const or volatile. A constructor may not be
13303 virtual. A constructor may not be static.
13304 A constructor may not be declared with ref-qualifier. */
13313 {
13318 }
13321 {
13327 }
13331 current_class_type,
13332 flags))
13336 {
13337 /* It's a constructor. */
13341 {
13345 }
13349 }
13352 }
13354 {
13356 {
13357 /* Cannot be both friend and virtual. */
13362 }
13367 {
13369 "cannot define friend function %qs in a local "
13372 }
13373 /* [class.friend]/6: A function can be defined in a friend
13374 declaration if the function name is unqualified. */
13376 {
13379 "friend function definition %qs cannot have "
13381 else
13383 "friend function definition %qs cannot have "
13385 in_namespace);
13386 }
13387 }
13389 {
13391 {
13394 }
13395 }
13397 {
13400 }
13407 pushed_scope
13419 {
13424 }
13430 {
13432 /* transaction_safe applies to the type, but
13433 transaction_safe_dynamic applies to the function. */
13436 else
13438 }
13440 /* Actually apply the contract attributes to the declaration. */
13442 {
13445 {
13447 /* Intentionally reverse order of contracts so they're
13448 reversed back into their lexical order. */
13451 }
13452 else
13454 }
13457 /* [dcl.fct]/2:
13459 The optional attribute-specifier-seq appertains to
13460 the function type. */
13465 }
13471 /* Filter out pointers-to-references and references-to-references.
13472 We can get these if a TYPE_DECL is used. */
13475 {
13477 {
13480 }
13482 /* In C++0x, we allow reference to reference declarations
13483 that occur indirectly through typedefs [7.1.3/8 dcl.typedef]
13484 and template type arguments [14.3.1/4 temp.arg.type]. The
13485 check for direct reference to reference declarations, which
13486 are still forbidden, occurs below. Reasoning behind the change
13487 can be found in DR106, DR540, and the rvalue reference
13488 proposals. */
13490 {
13493 }
13494 }
13496 {
13501 }
13503 /* We now know that the TYPE_QUALS don't apply to the decl,
13504 but to the target of the pointer. */
13507 /* This code used to handle METHOD_TYPE, but I don't think it's
13508 possible to get it here anymore. */
13512 {
13516 memfn_quals,
13517 rqual);
13523 }
13531 type);
13533 /* When the pointed-to type involves components of variable size,
13534 care must be taken to ensure that the size evaluation code is
13535 emitted early enough to dominate all the possible later uses
13536 and late enough for the variables on which it depends to have
13537 been assigned.
13539 This is expected to happen automatically when the pointed-to
13540 type has a name/declaration of it's own, but special attention
13541 is required if the type is anonymous.
13543 We handle the NORMAL and FIELD contexts here by inserting a
13544 dummy statement that just evaluates the size at a safe point
13545 and ensures it is not deferred until e.g. within a deeper
13546 conditional context (c++/43555).
13548 We expect nothing to be needed here for PARM or TYPENAME.
13549 Evaluating the size at this point for TYPENAME would
13550 actually be incorrect, as we might be in the middle of an
13551 expression with side effects on the pointed-to type size
13552 "arguments" prior to the pointer declaration point and the
13553 size evaluation could end up prior to the side effects. */
13559 {
13563 }
13566 {
13567 /* In C++0x, the type we are creating a reference to might be
13568 a typedef which is itself a reference type. In that case,
13569 we follow the reference collapsing rules in
13570 [7.1.3/8 dcl.typedef] to create the final reference type:
13572 "If a typedef TD names a type that is a reference to a type
13573 T, an attempt to create the type 'lvalue reference to cv TD'
13574 creates the type 'lvalue reference to T,' while an attempt
13575 to create the type "rvalue reference to cv TD' creates the
13576 type TD."
13577 */
13581 {
13584 else
13586 }
13587 else
13588 type = cp_build_reference_type
13591 /* In C++0x, we need this check for direct reference to
13592 reference declarations, which are forbidden by
13593 [8.3.2/5 dcl.ref]. Reference to reference declarations
13594 are only allowed indirectly through typedefs and template
13595 type arguments. Example:
13597 void foo(int & &); // invalid ref-to-ref decl
13599 typedef int & int_ref;
13600 void foo(int_ref &); // valid ref-to-ref decl
13601 */
13605 }
13609 {
13613 /* We will already have complained. */
13615 else
13617 type);
13618 }
13619 else
13622 /* Process a list of type modifier keywords (such as
13623 const or volatile) that were given inside the `*' or `&'. */
13626 {
13627 type
13631 }
13633 /* Apply C++11 attributes to the pointer, and not to the
13634 type pointed to. This is unlike what is done for GNU
13635 attributes above. It is to comply with [dcl.ptr]/1:
13637 [the optional attribute-specifier-seq (7.6.1) appertains
13638 to the pointer and not to the object pointed to]. */
13651 }
13652 }
13657 /* Don't check this if it can be the artifical decltype(auto)
13658 we created when building a constraint in a compound-requirement:
13659 that the type-constraint is plain is going to be checked in
13660 cp_parser_compound_requirement. */
13665 /* A `constexpr' specifier used in an object declaration declares
13666 the object as `const'. */
13668 {
13669 /* DR1688 says that a `constexpr' specifier in combination with
13670 `volatile' is valid. */
13673 {
13676 }
13677 }
13682 {
13684 unqualified_id);
13686 }
13688 /* If TYPE is a FUNCTION_TYPE, but the function name was explicitly
13689 qualified with a class-name, turn it into a METHOD_TYPE, unless
13690 we know that the function is static. We take advantage of this
13691 opportunity to do other processing that pertains to entities
13692 explicitly declared to be class members. Note that if DECLARATOR
13693 is non-NULL, we know it is a cdk_id declarator; otherwise, we
13694 would not have exited the loop above. */
13699 {
13705 {
13707 {
13709 "member functions are implicitly "
13712 }
13713 else
13716 }
13718 can skip the following checks. */
13721 qualifying type must certainly be complete. */
13722 funcdef_flag
13723 /* A friend declaration of "T::f" is OK, even if
13724 "T" is a template parameter. But, if this
13725 function is not a friend, the qualifying type
13726 must be a class. */
13728 /* For a declaration, the type need not be
13729 complete, if either it is dependent (since there
13730 is no meaningful definition of complete in that
13731 case) or the qualifying class is currently being
13732 defined. */
13735 /* Check that the qualifying type is complete. */
13739 {
13742 {
13750 }
13751 }
13753 {
13757 }
13758 }
13763 /* Now TYPE has the actual type. */
13766 {
13769 else
13771 }
13777 {
13778 /* [dcl.meaning]/1: The optional attribute-specifier-seq following
13779 a declarator-id appertains to the entity that is declared. */
13782 else
13783 /* We should have already diagnosed the issue (c++/78344). */
13785 }
13787 /* Handle parameter packs. */
13789 {
13791 /* Turn the type into a pack expansion.*/
13793 else
13795 }
13798 && !processing_template_decl
13800 {
13804 else
13808 }
13811 {
13812 /* [dcl.fct.spec] (C++11) The explicit specifier shall be used only
13813 in the declaration of a constructor or conversion function within
13814 a class definition. */
13821 else
13823 "only declarations of constructors and conversion operators "
13826 }
13829 {
13832 {
13834 name);
13836 }
13838 {
13841 name);
13843 }
13845 {
13847 name);
13849 }
13851 {
13853 name);
13855 }
13857 {
13859 name);
13861 }
13863 {
13865 name);
13867 }
13868 }
13870 /* If this is declaring a typedef name, return a TYPE_DECL. */
13872 {
13874 tree decl;
13877 {
13881 else
13885 }
13887 /* This declaration:
13889 typedef void f(int) const;
13891 declares a function type which is not a member of any
13892 particular class, but which is cv-qualified; for
13893 example "f S::*" declares a pointer to a const-qualified
13894 member function of S. We record the cv-qualification in the
13895 function type. */
13897 {
13900 /* We have now dealt with these qualifiers. */
13903 }
13906 {
13910 else
13914 }
13920 {
13923 }
13927 else
13931 {
13935 /* The TYPE_DECL is "abstract" because there will be
13936 clones of this constructor/destructor, and there will
13937 be copies of this TYPE_DECL generated in those
13938 clones. The decloning optimization (for space) may
13939 revert this subsequently if it determines that
13940 the clones should share a common implementation. */
13944 }
13949 unqualified_id);
13951 /* If the user declares "typedef struct {...} foo" then the
13952 struct will have an anonymous name. Fill that name in now.
13953 Nothing can refer to it, so nothing needs know about the name
13954 change. */
13956 && unqualified_id
13975 /* Acknowledge that this was written:
13976 `using analias = atype;'. */
13980 }
13982 /* Detect the case of an array type of unspecified size
13983 which came, as such, direct from a typedef name.
13984 We must copy the type, so that the array's domain can be
13985 individually set by the object's initializer. */
13992 /* Detect where we're using a typedef of function type to declare a
13993 function. PARMS will not be set, so we must create it now. */
13996 {
13998 tree args;
14003 {
14009 }
14014 {
14015 /* The qualifiers on the function type become the qualifiers on
14016 the non-static member function. */
14021 }
14022 }
14024 /* If this is a type name (such as, in a cast or sizeof),
14025 compute the type and return it now. */
14028 {
14029 /* Note that here we don't care about type_quals. */
14031 /* Special case: "friend class foo" looks like a TYPENAME context. */
14033 {
14035 {
14038 }
14041 {
14042 /* Don't allow friend declaration without a class-key. */
14049 else
14052 type);
14053 }
14055 /* Only try to do this stuff if we didn't already give up. */
14057 {
14058 /* A friendly class? */
14062 else
14064 type);
14067 }
14068 }
14070 {
14077 /* Core issue #547: need to allow this in template type args.
14078 Allow it in general in C++11 for alias-declarations. */
14082 else
14084 }
14090 }
14094 && ! bitfield
14096 {
14099 }
14102 {
14103 /* Only functions may be declared using an operator-function-id. */
14105 {
14108 }
14113 type);
14114 }
14116 /* We don't check parameter types here because we can emit a better
14117 error message later. */
14119 {
14123 }
14125 /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
14126 or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
14129 {
14135 {
14137 {
14142 {
14143 auto_diagnostic_group g;
14147 "missing template argument list after %qE; template "
14153 }
14154 else
14157 }
14158 else
14161 }
14163 /* A parameter declared as an array of T is really a pointer to T.
14164 One declared as a function is really a pointer to a function.
14165 One declared as a member is really a pointer to member. */
14168 {
14169 /* Transfer const-ness of array into that of type pointed to. */
14173 }
14176 }
14179 && !(unqualified_id
14182 {
14188 }
14190 {
14194 {
14202 }
14204 {
14207 {
14213 else
14217 }
14219 /* The C99 flexible array extension. */
14222 {
14226 {
14229 }
14230 else
14231 {
14232 /* Array is a flexible member. */
14236 else
14240 /* Flexible array member has a null domain. */
14242 }
14243 }
14246 {
14247 /* Happens when declaring arrays of sizes which
14248 are error_mark_node, for example. */
14250 }
14252 {
14253 /* Something like struct S { int N::j; }; */
14256 }
14258 {
14260 tree function_context;
14263 {
14264 /* This should never happen in pure C++ (the check
14265 could be an assert). It could happen in
14266 Objective-C++ if someone writes invalid code that
14267 uses a function declaration for an instance
14268 variable or property (instance variables and
14269 properties are parsed as FIELD_DECLs, but they are
14270 part of an Objective-C class, not a C++ class).
14271 That code is invalid and is caught by this
14272 check. */
14274 {
14276 unqualified_id);
14278 }
14280 /* ``A union may [ ... ] not [ have ] virtual functions.''
14281 ARM 9.5 */
14283 {
14286 unqualified_id);
14288 }
14293 {
14295 "%qD cannot be declared %<virtual%>, since it "
14298 }
14299 }
14301 /* Check that the name used for a destructor makes sense. */
14303 {
14307 {
14312 }
14315 {
14319 }
14321 {
14325 }
14327 {
14329 "%<constexpr%> destructors only available"
14332 }
14334 {
14338 }
14339 }
14341 {
14346 }
14349 {
14353 }
14355 {
14359 }
14363 {
14367 }
14370 {
14373 {
14379 }
14380 }
14382 /* Tell grokfndecl if it needs to set TREE_PUBLIC on the node. */
14383 function_context
14392 parms,
14393 unqualified_id,
14394 declspecs,
14395 reqs,
14407 #if 0
14408 /* This clobbers the attrs stored in `decl' from `attrlist'. */
14409 /* The decl and setting of decl_attr is also turned off. */
14411 #endif
14413 /* [class.conv.ctor]
14415 A constructor declared without the function-specifier
14416 explicit that can be called with a single parameter
14417 specifies a conversion from the type of its first
14418 parameter to the type of its class. Such a constructor
14419 is called a converting constructor. */
14425 }
14427 && ((current_class_type
14433 {
14436 {
14438 {
14442 }
14443 else
14448 }
14449 }
14451 staticp
14452 ? TCTX_STATIC_STORAGE
14454 {
14457 }
14458 else
14459 {
14461 {
14464 "%qE is neither function nor member function; "
14466 else
14470 }
14472 }
14475 {
14476 /* Packages tend to use GNU attributes on friends, so we only
14477 warn for standard attributes. */
14479 && !funcdef_flag
14482 {
14487 }
14488 /* Friends are treated specially. */
14492 {
14496 /* Kludge: We need funcdef_flag to be true in do_friend for
14497 in-class defaulted functions, but that breaks grokfndecl.
14498 So set it here. */
14508 }
14509 else
14511 }
14513 /* Structure field. It may not be a function, except for C++. */
14516 {
14518 {
14519 /* C++ allows static class members. All other work
14520 for this is done by grokfield. */
14525 {
14527 template_count,
14531 }
14538 {
14540 "%<constexpr%> static data member %qD must "
14543 }
14554 /* Even if there is an in-class initialization, DECL
14555 is considered undefined until an out-of-class
14556 definition is provided, unless this is an inline
14557 variable. */
14561 {
14567 }
14569 /* Set the constraints on the declaration. */
14573 {
14576 }
14577 }
14578 else
14579 {
14581 {
14587 }
14589 {
14594 }
14596 {
14601 }
14603 {
14608 }
14615 {
14618 }
14621 {
14622 /* An attempt is being made to initialize a non-static
14623 member. This is new in C++11. */
14626 /* If this has been parsed with static storage class, but
14627 errors forced staticp to be cleared, ensure NSDMI is
14628 not present. */
14631 }
14632 }
14639 }
14640 }
14642 {
14643 tree original_name;
14651 else
14653 // FIXME:gcc_assert (original_name == dname);
14661 name);
14663 {
14667 name);
14668 else
14670 "storage class %<thread_local%> invalid for "
14672 }
14680 /* Function declaration not at top level.
14681 Storage classes other than `extern' are not allowed
14682 and `extern' makes no difference. */
14687 {
14690 "%<static%> specifier invalid for function %qs "
14692 else
14694 "%<inline%> specifier invalid for function %qs "
14696 }
14699 {
14701 {
14704 }
14707 {
14712 }
14713 }
14717 {
14721 }
14723 /* Record whether the function is public. */
14728 declspecs,
14731 publicp,
14735 sfk,
14736 funcdef_flag,
14737 late_return_type_p,
14739 id_loc);
14746 {
14749 /* Don't allow a static member function in a class, and forbid
14750 declaring main to be static. */
14752 {
14756 }
14758 {
14759 /* 7.1.1: There can be no static function declarations within a
14760 block. */
14764 }
14767 {
14770 }
14771 }
14774 }
14775 else
14776 {
14777 /* It's a variable. */
14779 /* An uninitialized decl with `extern' is a reference. */
14781 declspecs,
14782 initialized,
14783 type_quals,
14784 inlinep,
14785 concept_p,
14786 template_count,
14788 id_loc);
14798 {
14801 {
14803 "%<static%> may not be used when defining "
14807 }
14809 {
14812 }
14814 {
14816 "cannot explicitly declare member %q#D to have "
14819 }
14820 }
14822 {
14824 "declaration of %<constexpr%> variable %qD "
14827 }
14829 {
14833 }
14838 {
14843 }
14844 }
14849 {
14853 }
14856 {
14858 {
14859 /* It's common practice (and completely valid) to have a const
14860 be initialized and declared extern. */
14864 }
14865 else
14866 {
14870 }
14871 }
14873 /* Record `register' declaration for warnings on &
14874 and in case doing stupid register allocation. */
14877 {
14879 /* Warn about register storage specifiers on PARM_DECLs. */
14881 {
14884 "ISO C++17 does not allow %<register%> storage "
14886 else
14889 }
14890 }
14897 {
14898 /* Set constexpr flag on vars (functions got it in grokfndecl). */
14901 /* And the constinit flag (which only applies to variables). */
14904 }
14906 {
14907 /* If we saw a return type, record its location. */
14912 {
14918 }
14921 }
14923 /* Record constancy and volatility on the DECL itself . There's
14924 no need to do this when processing a template; we'll do this
14925 for the instantiated declaration based on the type of DECL. */
14930 }
14931 }
14932 \f
14933 /* Subroutine of start_function. Ensure that each of the parameter
14934 types (as listed in PARMS) is complete, as is required for a
14935 function definition. */
14937 static void
14939 {
14941 {
14946 {
14953 }
14954 else
14955 /* grokparms or complete_type_or_else will have already issued
14956 an error. */
14958 }
14959 }
14961 /* Returns nonzero if T is a local variable. */
14963 int
14965 {
14974 }
14976 /* Like local_variable_p, but suitable for use as a tree-walking
14977 function. */
14979 static tree
14982 {
14984 {
14985 /* DR 2082 permits local variables in unevaluated contexts
14986 within a default argument. */
14989 }
14998 }
15000 /* Check that ARG, which is a default-argument expression for a
15001 parameter DECL, is valid. Returns ARG, or ERROR_MARK_NODE, if
15002 something goes wrong. DECL may also be a _TYPE node, rather than a
15003 DECL, if there is no DECL available. */
15005 tree
15007 {
15008 tree var;
15009 tree decl_type;
15012 /* We get a DEFERRED_PARSE when looking at an in-class declaration
15013 with a default argument. Ignore the argument for now; we'll
15014 deal with it after the class is complete. */
15018 {
15021 }
15022 else
15029 /* Something already went wrong. There's no need to check
15030 further. */
15033 /* [dcl.fct.default]
15035 A default argument expression is implicitly converted to the
15036 parameter type. */
15038 /* Avoid digest_init clobbering the initializer. */
15041 LOOKUP_IMPLICIT);
15044 /* Avoid redundant -Wzero-as-null-pointer-constant warnings at
15045 the call sites. */
15048 /* Don't lose side-effects as in PR90473. */
15052 /* [dcl.fct.default]
15054 Local variables shall not be used in default argument
15055 expressions.
15057 The keyword `this' shall not be used in a default argument of a
15058 member function. */
15061 {
15063 {
15067 else
15069 }
15071 }
15073 /* All is well. */
15075 }
15077 /* Returns a deprecated type used within TYPE, or NULL_TREE if none. */
15079 static tree
15081 {
15086 {
15089 else
15090 {
15093 }
15094 }
15096 /* Do warn about using typedefs to a deprecated class. */
15108 return type_is_deprecated
15112 }
15114 /* Returns an unavailable type used within TYPE, or NULL_TREE if none. */
15116 static tree
15118 {
15123 {
15126 else
15127 {
15130 }
15131 }
15133 /* Do warn about using typedefs to a deprecated class. */
15145 return type_is_unavailable
15149 }
15151 /* Decode the list of parameter types for a function type.
15152 Given the list of things declared inside the parens,
15153 return a list of types.
15155 If this parameter does not end with an ellipsis, we append
15156 void_list_node.
15158 *PARMS is set to the chain of PARM_DECLs created. */
15160 tree
15162 {
15165 tree parm;
15169 {
15178 {
15181 }
15185 {
15187 && !init
15190 /* DR 577: A parameter list consisting of a single
15191 unnamed parameter of non-dependent type 'void'. */
15195 "invalid use of cv-qualified type %qT in "
15197 else
15199 "invalid use of type %<void%> in parameter "
15201 /* It's not a good idea to actually create parameters of
15202 type `void'; other parts of the compiler assume that a
15203 void type terminates the parameter list. */
15206 }
15209 {
15211 {
15215 }
15218 {
15222 }
15224 /* [dcl.fct] "A parameter with volatile-qualified type is
15225 deprecated." */
15228 "%<volatile%>-qualified parameter is "
15231 /* Top-level qualifiers on the parameters are
15232 ignored for function types. */
15235 {
15239 }
15241 {
15242 /* Before C++17 DR 393:
15243 [dcl.fct]/6, parameter types cannot contain pointers
15244 (references) to arrays of unknown bound. */
15249 {
15257 }
15260 ptr
15266 }
15270 }
15275 }
15285 /* We had parm errors, recover by giving the function (...) type. */
15289 }
15291 \f
15292 /* D is a constructor or overloaded `operator='.
15294 Let T be the class in which D is declared. Then, this function
15295 returns:
15297 -1 if D's is an ill-formed constructor or copy assignment operator
15298 whose first parameter is of type `T'.
15299 0 if D is not a copy constructor or copy assignment
15300 operator.
15301 1 if D is a copy constructor or copy assignment operator whose
15302 first parameter is a reference to non-const qualified T.
15303 2 if D is a copy constructor or copy assignment operator whose
15304 first parameter is a reference to const qualified T.
15306 This function can be used as a predicate. Positive values indicate
15307 a copy constructor and nonzero values indicate a copy assignment
15308 operator. */
15310 int
15312 {
15313 tree args;
15314 tree arg_type;
15322 /* Instantiations of template member functions are never copy
15323 functions. Note that member functions of templated classes are
15324 represented as template functions internally, and we must
15325 accept those as copy functions. */
15341 {
15342 /* Pass by value copy assignment operator. */
15344 }
15348 {
15351 }
15352 else
15358 /* There are more non-optional args. */
15362 }
15364 /* D is a constructor or overloaded `operator='.
15366 Let T be the class in which D is declared. Then, this function
15367 returns true when D is a move constructor or move assignment
15368 operator, false otherwise. */
15370 bool
15372 {
15374 /* There are no move constructors if we are in C++98 mode. */
15380 /* Instantiations of template member functions are never move
15381 functions. Note that member functions of templated classes are
15382 represented as template functions internally, and we must
15383 accept those as move functions. */
15387 }
15389 /* D is a constructor or overloaded `operator='.
15391 Then, this function returns true when D has the same signature as a move
15392 constructor or move assignment operator (because either it is such a
15393 ctor/op= or it is a template specialization with the same signature),
15394 false otherwise. */
15396 bool
15398 {
15399 tree args;
15400 tree arg_type;
15424 /* There are more non-optional args. */
15428 }
15430 /* Remember any special properties of member function DECL. */
15432 void
15434 {
15435 tree class_type;
15443 {
15450 {
15451 /* [class.copy]
15453 A non-template constructor for class X is a copy
15454 constructor if its first parameter is of type X&, const
15455 X&, volatile X& or const volatile X&, and either there
15456 are no other parameters or else all other parameters have
15457 default arguments. */
15461 }
15472 }
15474 {
15475 /* [class.copy]
15477 A non-template assignment operator for class X is a copy
15478 assignment operator if its parameter is of type X, X&, const
15479 X&, volatile X& or const volatile X&. */
15484 {
15488 }
15489 }
15493 /* Destructors are handled in check_methods. */
15494 }
15496 /* Check a constructor DECL has the correct form. Complains
15497 if the class has a constructor of the form X(X). */
15499 bool
15501 {
15505 {
15506 /* [class.copy]
15508 A declaration of a constructor for a class X is ill-formed if
15509 its first parameter is of type (optionally cv-qualified) X
15510 and either there are no other parameters or else all other
15511 parameters have default arguments.
15513 We *don't* complain about member template instantiations that
15514 have this form, though; they can occur as we try to decide
15515 what constructor to use during overload resolution. Since
15516 overload resolution will never prefer such a constructor to
15517 the non-template copy constructor (which is either explicitly
15518 or implicitly defined), there's no need to worry about their
15519 existence. Theoretically, they should never even be
15520 instantiated, but that's hard to forestall. */
15525 }
15528 }
15530 /* DECL is a declaration for an overloaded or conversion operator. If
15531 COMPLAIN is true, errors are issued for invalid declarations. */
15533 bool
15535 {
15545 tree_code operator_code;
15548 {
15549 /* Conversion operators are TYPE_EXPR for the purposes of this
15550 function. */
15553 }
15554 else
15555 {
15562 }
15565 {
15566 /* operator new and operator delete are quite special. */
15569 {
15588 }
15590 /* [basic.std.dynamic.allocation]/1:
15592 A program is ill-formed if an allocation function is declared
15593 in a namespace scope other than global scope or declared
15594 static in global scope.
15596 The same also holds true for deallocation functions. */
15598 {
15600 {
15602 decl);
15604 }
15607 {
15610 }
15611 }
15614 {
15617 }
15618 else
15619 {
15622 }
15625 }
15627 /* An operator function must either be a non-static member function
15628 or have at least one parameter of a class, a reference to a class,
15629 an enumeration, or a reference to an enumeration. 13.4.0.6 */
15631 {
15635 {
15638 }
15641 {
15643 {
15646 }
15648 /* For lambdas we diagnose static lambda specifier elsewhere. */
15650 /* For instantiations, we have diagnosed this already. */
15654 decl);
15656 /* static operator[] should have exactly one argument
15657 for C++20 and earlier, so that it isn't multidimensional. */
15659 }
15661 {
15665 }
15666 else
15668 {
15670 {
15675 }
15681 /* MAYBE_CLASS_TYPE_P, rather than CLASS_TYPE_P, is used
15682 because these checks are performed even on template
15683 functions. */
15687 }
15688 }
15691 /* There are no further restrictions on the arguments to an overloaded
15692 "operator ()". */
15695 /* C++23 allows an arbitrary number of parameters and default arguments for
15696 operator[], and none of the other checks below apply. */
15701 {
15702 /* 13.4.0.3 */
15705 }
15707 /* Count the number of arguments and check for ellipsis. */
15710 {
15712 {
15714 decl);
15716 }
15718 }
15720 /* Verify correct number of arguments. */
15722 {
15725 {
15726 /* We have a unary instance of an ambi-ary op. Remap to the
15727 unary one. */
15733 }
15735 {
15736 /* This was an ambiguous operator but is invalid. */
15738 methodp
15742 }
15745 && ! processing_template_decl
15746 /* x++ and x--'s second argument must be an int. */
15748 integer_type_node))
15749 {
15751 methodp
15754 decl);
15756 }
15761 {
15763 methodp
15767 }
15772 {
15774 methodp
15778 }
15783 }
15785 /* There can be no default arguments. */
15789 {
15793 }
15795 /* At this point the declaration is well-formed. It may not be
15796 sensible though. */
15798 /* Check member function warnings only on the in-class declaration.
15799 There's no point warning on an out-of-class definition. */
15803 /* Warn about conversion operators that will never be used. */
15807 {
15818 {
15821 ref
15826 class_type);
15827 /* Don't force t to be complete here. */
15832 ref
15838 }
15839 }
15844 /* Effective C++ rules below. */
15846 /* More Effective C++ rule 7. */
15853 /* More Effective C++ rule 6. */
15858 {
15867 {
15872 }
15873 else
15874 {
15878 }
15879 }
15881 /* Effective C++ rule 23. */
15892 }
15893 \f
15894 /* Return a string giving the keyword associate with CODE. */
15898 {
15900 {
15913 }
15914 }
15916 /* Name lookup in an elaborated-type-specifier (after the keyword
15917 indicated by TAG_CODE) has found the TYPE_DECL DECL. If the
15918 elaborated-type-specifier is invalid, issue a diagnostic and return
15919 error_mark_node; otherwise, return the *_TYPE to which it referred.
15920 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
15922 tree
15924 tree decl,
15926 {
15927 tree type;
15929 /* In the case of:
15931 struct S { struct S *p; };
15933 name lookup will find the TYPE_DECL for the implicit "S::S"
15934 typedef. Adjust for that here. */
15940 /* Check TEMPLATE_TYPE_PARM first because DECL_IMPLICIT_TYPEDEF_P
15941 is false for this case as well. */
15943 {
15947 }
15948 /* Accept template template parameters. */
15952 ;
15953 /* [dcl.type.elab]
15955 If the identifier resolves to a typedef-name or the
15956 simple-template-id resolves to an alias template
15957 specialization, the elaborated-type-specifier is ill-formed.
15959 In other words, the only legitimate declaration to use in the
15960 elaborated type specifier is the implicit typedef created when
15961 the type is declared. */
15965 {
15969 else
15974 }
15979 {
15983 }
15986 {
15990 }
15994 {
15995 /* If a class template appears as elaborated type specifier
15996 without a template header such as:
15998 template <class T> class C {};
15999 void f(class C); // No template header here
16001 then the required template argument is missing. */
16006 }
16009 }
16011 /* Lookup NAME of an elaborated type specifier according to SCOPE and
16012 issue diagnostics if necessary. Return *_TYPE node upon success,
16013 NULL_TREE when the NAME is not found, and ERROR_MARK_NODE for type
16014 error. */
16016 static tree
16019 {
16020 tree decl;
16022 {
16023 /* First try ordinary name lookup, ignoring hidden class name
16024 injected via friend declaration. */
16027 /* If that fails, the name will be placed in the smallest
16028 non-class, non-function-prototype scope according to 3.3.1/5.
16029 We may already have a hidden name declared as friend in this
16030 scope. So lookup again but not ignoring hidden names.
16031 If we find one, that name will be made visible rather than
16032 creating a new tag. */
16035 }
16036 else
16040 /* We found nothing. */
16044 {
16048 }
16051 && !template_header_p
16053 {
16058 }
16061 /* If scope is TAG_how::CURRENT_ONLY we're defining a class,
16062 so ignore a template template parameter. */
16067 /* Found not-a-type. */
16070 /* Look for invalid nested type:
16071 class C {
16072 class C {};
16073 }; */
16075 {
16079 }
16081 /* Two cases we need to consider when deciding if a class
16082 template is allowed as an elaborated type specifier:
16083 1. It is a self reference to its own class.
16084 2. It comes with a template header.
16086 For example:
16088 template <class T> class C {
16089 class C *c1; // DECL_SELF_REFERENCE_P is true
16090 class D;
16091 };
16092 template <class U> class C; // template_header_p is true
16093 template <class T> class C<T>::D {
16094 class C *c2; // DECL_SELF_REFERENCE_P is true
16095 }; */
16098 template_header_p
16103 {
16112 }
16115 }
16117 /* Get the struct, enum or union (TAG_CODE says which) with tag NAME.
16118 Define the tag as a forward-reference if it is not defined.
16120 If a declaration is given, process it here, and report an error if
16121 multiple declarations are not identical.
16123 SCOPE is TS_CURRENT when this is also a definition. Only look in
16124 the current frame for the name (since C++ allows new names in any
16125 scope.) It is TS_WITHIN_ENCLOSING_NON_CLASS if this is a friend
16126 declaration. Only look beginning from the current scope outward up
16127 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
16129 TEMPLATE_HEADER_P is true when this declaration is preceded by
16130 a set of template parameters. */
16132 tree
16135 {
16144 {
16157 }
16159 /* In case of anonymous name, xref_tag is only called to
16160 make type node and push name. Name lookup is not required. */
16171 {
16175 /* Since HOW is not TAG_how::CURRENT_ONLY, we are not looking at
16176 a definition of this tag. Since, in addition, we are
16177 currently processing a (member) template declaration of a
16178 template class, we must be very careful; consider:
16180 template <class X> struct S1
16182 template <class U> struct S2
16183 {
16184 template <class V> friend struct S1;
16185 };
16187 Here, the S2::S1 declaration should not be confused with the
16188 outer declaration. In particular, the inner version should
16189 have a template parameter of level 2, not level 1.
16191 On the other hand, when presented with:
16193 template <class T> struct S1
16194 {
16195 template <class U> struct S2 {};
16196 template <class U> friend struct S2;
16197 };
16199 the friend must find S1::S2 eventually. We accomplish this
16200 by making sure that the new type we create to represent this
16201 declaration has the right TYPE_CONTEXT. */
16204 }
16207 {
16208 /* If no such tag is yet defined, create a forward-reference node
16209 and record it as the "definition".
16210 When a real declaration of this type is found,
16211 the forward-reference will be altered into a real type. */
16213 {
16216 }
16221 /* Mark it as a lambda type right now. Our caller will
16222 correct the value. */
16225 }
16226 else
16227 {
16229 {
16230 /* Check that we aren't trying to overload a class with different
16231 constraints. */
16235 }
16239 {
16243 }
16247 {
16250 {
16254 }
16263 {
16264 /* Push it into this TU's symbol slot. */
16267 /* We're in the template parm binding level.
16268 Pushtag has logic to slide under that, but we're
16269 not pushing a *new* type. */
16275 }
16278 }
16279 }
16282 }
16284 /* Create the binfo hierarchy for REF with (possibly NULL) base list
16285 BASE_LIST. For each element on BASE_LIST the TREE_PURPOSE is an
16286 access_* node, and the TREE_VALUE is the type of the base-class.
16287 Non-NULL TREE_TYPE indicates virtual inheritance. */
16289 void
16291 {
16298 tree default_access;
16304 /* The base of a derived class is private by default, all others are
16305 public. */
16310 /* First, make sure that any templates in base-classes are
16311 instantiated. This ensures that if we call ourselves recursively
16312 we do not get confused about which classes are marked and which
16313 are not. */
16316 {
16319 /* The dependent_type_p call below should really be dependent_scope_p
16320 so that we give a hard error about using an incomplete type as a
16321 base, but we allow it with a pedwarn for backward
16322 compatibility. */
16328 /* An incomplete type. Remove it from the list. */
16330 else
16331 {
16332 max_bases++;
16334 max_dvbases++;
16338 }
16339 }
16344 /* The binfo slot should be empty, unless this is an (ill-formed)
16345 redefinition. */
16356 /* Apply base-class info set up to the variants of this type. */
16360 {
16362 /* A C++98 POD cannot have base classes. */
16366 {
16369 }
16370 }
16377 {
16378 /* An aggregate can't have virtual base classes. */
16386 }
16389 {
16397 /* Before C++17, an aggregate cannot have base classes. In C++17, an
16398 aggregate can't have virtual, private, or protected base classes. */
16409 {
16411 basetype);
16413 }
16417 {
16419 /* The original basetype could have been a typedef'd type. */
16422 /* Inherit flags from the base. */
16433 }
16435 /* We must do this test after we've seen through a typedef
16436 type. */
16438 {
16441 else
16444 }
16447 /* Regenerate the pack expansion for the bases. */
16461 dropped_base:
16462 /* Update max_vbases to reflect the reality that we are dropping
16463 this base: if it reaches zero we want to undo the vec_alloc
16464 above to avoid inconsistencies during error-recovery: eg, in
16465 build_special_member_call, CLASSTYPE_VBASECLASSES non null
16466 and vtt null (c++/27952). */
16468 max_vbases--;
16470 max_vbases
16472 }
16479 /* If we didn't get max_vbases vbases, we must have shared at
16480 least one of them, and are therefore diamond shaped. */
16483 /* Unmark all the types. */
16488 /* Now see if we have a repeated base type. */
16490 {
16493 {
16495 {
16498 }
16500 }
16505 else
16507 }
16508 }
16510 \f
16511 /* Copies the enum-related properties from type SRC to type DST.
16512 Used with the underlying type of an enum and the enum itself. */
16513 static void
16515 {
16516 tree t;
16518 {
16528 else
16532 }
16533 }
16535 /* Begin compiling the definition of an enumeration type.
16536 NAME is its name,
16538 if ENUMTYPE is not NULL_TREE then the type has alredy been found.
16540 UNDERLYING_TYPE is the type that will be used as the storage for
16541 the enumeration type. This should be NULL_TREE if no storage type
16542 was specified.
16544 ATTRIBUTES are any attributes specified after the enum-key.
16546 SCOPED_ENUM_P is true if this is a scoped enumeration type.
16548 if IS_NEW is not NULL, gets TRUE iff a new type is created.
16550 Returns the type object, as yet incomplete.
16551 Also records info about it so that build_enumerator
16552 may be used to declare the individual values as they are read. */
16554 tree
16557 {
16563 /* [C++0x dcl.enum]p5:
16565 If not explicitly specified, the underlying type of a scoped
16566 enumeration type is int. */
16573 /* If this is the real definition for a previous forward reference,
16574 fill in the contents in the same object that used to be the
16575 forward reference. */
16581 /* In case of a template_decl, the only check that should be deferred
16582 to instantiation time is the comparison of underlying types. */
16584 {
16586 {
16592 }
16594 {
16600 }
16604 {
16610 }
16613 {
16615 {
16621 }
16623 }
16624 }
16628 {
16629 /* In case of error, make a dummy enum to allow parsing to
16630 continue. */
16632 {
16635 }
16637 /* enumtype may be an ENUMERAL_TYPE if this is a redefinition
16638 of an opaque enum, or an opaque enum of an already defined
16639 enumeration (C++11).
16640 In any other case, it'll be NULL_TREE. */
16642 {
16645 }
16648 /* Do not push the decl more than once. */
16651 {
16655 /* std::byte aliases anything. */
16660 }
16661 else
16667 /* The enum is considered opaque until the opening '{' of the
16668 enumerator list. */
16671 }
16678 {
16680 /* We already checked that it matches, don't change it to a different
16683 {
16686 }
16689 else
16690 {
16694 }
16695 }
16697 /* If into a template class, the returned enum is always the first
16698 declaration (opaque or not) seen. This way all the references to
16699 this type will be to the same declaration. The following ones are used
16700 only to check for definition errors. */
16703 else
16705 }
16707 /* After processing and defining all the values of an enumeration type,
16708 install their decls in the enumeration type.
16709 ENUMTYPE is the type object. */
16711 void
16713 {
16714 tree values;
16715 tree underlying_type;
16716 tree decl;
16717 tree value;
16719 tree t;
16721 bool fixed_underlying_type_p
16724 /* We built up the VALUES in reverse order. */
16727 /* For an enum defined in a template, just set the type of the values;
16728 all further processing is postponed until the template is
16729 instantiated. We need to set the type so that tsubst of a CONST_DECL
16730 works. */
16732 {
16734 values;
16738 }
16740 /* Determine the minimum and maximum values of the enumerators. */
16742 {
16746 values;
16748 {
16751 /* [dcl.enum]: Following the closing brace of an enum-specifier,
16752 each enumerator has the type of its enumeration. Prior to the
16753 closing brace, the type of each enumerator is the type of its
16754 initializing value. */
16757 /* Update the minimum and maximum values, if appropriate. */
16761 /* Figure out what the minimum and maximum values of the
16762 enumerators are. */
16769 }
16770 }
16771 else
16772 /* [dcl.enum]
16774 If the enumerator-list is empty, the underlying type is as if
16775 the enumeration had a single enumerator with value 0. */
16779 {
16780 /* Compute the number of bits require to represent all values of the
16781 enumeration. We must do this before the type of MINNODE and
16782 MAXNODE are transformed, since tree_int_cst_min_precision relies
16783 on the TREE_TYPE of the value it is passed. */
16791 /* Determine the underlying type of the enumeration.
16793 [dcl.enum]
16795 The underlying type of an enumeration is an integral type that
16796 can represent all the enumerator values defined in the
16797 enumeration. It is implementation-defined which integral type is
16798 used as the underlying type for an enumeration except that the
16799 underlying type shall not be larger than int unless the value of
16800 an enumerator cannot fit in an int or unsigned int.
16802 We use "int" or an "unsigned int" as the underlying type, even if
16803 a smaller integral type would work, unless the user has
16804 explicitly requested that we use the smallest possible type. The
16805 user can request that for all enumerations with a command line
16806 flag, or for just one enumeration with an attribute. */
16808 use_short_enum = flag_short_enums
16811 /* If the precision of the type was specified with an attribute and it
16812 was too small, give an error. Otherwise, use it. */
16814 {
16817 else
16818 {
16821 }
16822 }
16826 itk++)
16827 {
16833 }
16835 {
16836 /* DR 377
16838 IF no integral type can represent all the enumerator values, the
16839 enumeration is ill-formed. */
16844 }
16846 /* [dcl.enum]
16848 The value of sizeof() applied to an enumeration type, an object
16849 of an enumeration type, or an enumerator, is the value of sizeof()
16850 applied to the underlying type. */
16853 /* Compute the minimum and maximum values for the type.
16855 [dcl.enum]
16857 For an enumeration where emin is the smallest enumerator and emax
16858 is the largest, the values of the enumeration are the values of the
16859 underlying type in the range bmin to bmax, where bmin and bmax are,
16860 respectively, the smallest and largest values of the smallest bit-
16861 field that can store emin and emax. */
16863 /* The middle-end currently assumes that types with TYPE_PRECISION
16864 narrower than their underlying type are suitably zero or sign
16865 extended to fill their mode. Similarly, it assumes that the front
16866 end assures that a value of a particular type must be within
16867 TYPE_MIN_VALUE and TYPE_MAX_VALUE.
16869 We used to set these fields based on bmin and bmax, but that led
16870 to invalid assumptions like optimizing away bounds checking. So
16871 now we just set the TYPE_PRECISION, TYPE_MIN_VALUE, and
16872 TYPE_MAX_VALUE to the values for the mode above and only restrict
16873 the ENUM_UNDERLYING_TYPE for the benefit of diagnostics. */
16877 set_min_and_max_values_for_integral_type
16880 /* If -fstrict-enums, still constrain TYPE_MIN/MAX_VALUE. */
16883 }
16884 else
16887 /* If the enum is exported, mark the consts too. */
16892 /* Convert each of the enumerators to the type of the underlying
16893 type of the enumeration. */
16895 {
16899 /* If the enumeration type has a fixed underlying type, we
16900 already checked all of the enumerator values. */
16902 else
16905 tf_warning_or_error);
16906 /* Do not clobber shared ints. */
16908 {
16912 }
16916 }
16918 /* Fix up all variant types of this enum type. */
16925 {
16927 /* TYPE_FIELDS needs fixup. */
16929 }
16931 /* Finish debugging output for this type. */
16934 /* Each enumerator now has the type of its enumeration. Clear the cache
16935 so that this change in types doesn't confuse us later on. */
16937 }
16939 /* Finishes the enum type. This is called only the first time an
16940 enumeration is seen, be it opaque or odinary.
16941 ENUMTYPE is the type object. */
16943 void
16945 {
16947 {
16951 }
16953 /* If this is a forward declaration, there should not be any variants,
16954 though we can get a variant in the middle of an enum-specifier with
16955 wacky code like 'enum E { e = sizeof(const E*) };' */
16959 }
16961 /* Build and install a CONST_DECL for an enumeration constant of the
16962 enumeration type ENUMTYPE whose NAME and VALUE (if any) are provided.
16963 Apply ATTRIBUTES if available. LOC is the location of NAME.
16964 Assignment of sequential values by default is handled here. */
16966 tree
16968 location_t loc)
16969 {
16970 tree decl;
16971 tree context;
16972 tree type;
16974 /* scalar_constant_value will pull out this expression, so make sure
16975 it's folded as appropriate. */
16979 /* If the VALUE was erroneous, pretend it wasn't there; that will
16980 result in the enum being assigned the next value in sequence. */
16984 /* Remove no-op casts from the value. */
16989 {
16990 /* Validate and default VALUE. */
16992 {
16994 {
16999 }
17002 value = perform_implicit_conversion_flags
17010 {
17013 {
17015 "enumerator value for %qD must have integral or "
17018 }
17019 else
17020 {
17024 {
17028 }
17029 }
17030 }
17031 }
17033 /* Default based on previous value. */
17035 {
17037 {
17038 tree prev_value;
17040 /* C++03 7.2/4: If no initializer is specified for the first
17041 enumerator, the type is an unspecified integral
17042 type. Otherwise the type is the same as the type of the
17043 initializing value of the preceding enumerator unless the
17044 incremented value is not representable in that type, in
17045 which case the type is an unspecified integral type
17046 sufficient to contain the incremented value. */
17050 else
17051 {
17058 {
17061 {
17064 {
17070 }
17077 }
17080 else
17082 }
17085 {
17088 }
17089 }
17090 }
17091 else
17093 }
17095 /* Remove no-op casts from the value. */
17098 /* If the underlying type of the enum is fixed, check whether
17099 the enumerator values fits in the underlying type. If it
17100 does not fit, the program is ill-formed [C++0x dcl.enum]. */
17102 && value
17104 {
17109 /* Convert the value to the appropriate type. */
17111 }
17112 }
17114 /* C++ associates enums with global, function, or class declarations. */
17117 /* Build the actual enumeration constant. Note that the enumeration
17118 constants have the underlying type of the enum (if it is fixed)
17119 or the type of their initializer (if the underlying type of the
17120 enum is not fixed):
17122 [ C++0x dcl.enum ]
17124 If the underlying type is fixed, the type of each enumerator
17125 prior to the closing brace is the underlying type; if the
17126 initializing value of an enumerator cannot be represented by
17127 the underlying type, the program is ill-formed. If the
17128 underlying type is not fixed, the type of each enumerator is
17129 the type of its initializing value.
17131 If the underlying type is not fixed, it will be computed by
17132 finish_enum and we will reset the type of this enumerator. Of
17133 course, if we're processing a template, there may be no value. */
17147 {
17148 /* In something like `struct S { enum E { i = 7 }; };' we put `i'
17149 on the TYPE_FIELDS list for `S'. (That's so that you can say
17150 things like `S::i' later.) */
17152 /* The enumerator may be getting declared outside of its enclosing
17153 class, like so:
17155 class S { public: enum E : int; }; enum S::E : int { i = 7; };
17157 For which case we need to make sure that the access of `S::i'
17158 matches the access of `S::E'. */
17162 }
17163 else
17166 /* Add this enumeration constant to the list for this type. */
17170 }
17172 /* Look for an enumerator with the given NAME within the enumeration
17173 type ENUMTYPE. This routine is used primarily for qualified name
17174 lookup into an enumerator in C++0x, e.g.,
17176 enum class Color { Red, Green, Blue };
17178 Color color = Color::Red;
17180 Returns the value corresponding to the enumerator, or
17181 NULL_TREE if no such enumerator was found. */
17182 tree
17184 {
17185 tree e;
17190 }
17192 /* Implement LANG_HOOKS_SIMULATE_ENUM_DECL. */
17194 tree
17197 {
17204 {
17209 }
17223 }
17225 /* Implement LANG_HOOKS_SIMULATE_RECORD_DECL. */
17227 tree
17230 {
17237 {
17240 }
17259 }
17260 \f
17261 /* We're defining DECL. Make sure that its type is OK. */
17263 static void
17265 {
17269 /* In a function definition, arg types must be complete. */
17276 {
17281 /* Make it return void instead. */
17284 void_type_node,
17286 else
17288 fntype = (cp_build_type_attribute_variant
17292 }
17293 else
17294 {
17298 }
17299 }
17301 /* True iff FN is an implicitly-defined default constructor. */
17303 static bool
17305 {
17309 }
17311 /* Clobber the contents of *this to let the back end know that the object
17312 storage is dead when we enter the constructor or leave the destructor. */
17314 static tree
17316 {
17317 /* Clobbering an empty base is pointless, and harmful if its one byte
17318 TYPE_SIZE overlays real data. */
17322 /* If we have virtual bases, clobber the whole object, but only if we're in
17323 charge. If we don't have virtual bases, clobber the as-base type so we
17324 don't mess with tail padding. */
17335 {
17338 }
17345 }
17347 /* Create the FUNCTION_DECL for a function definition.
17348 DECLSPECS and DECLARATOR are the parts of the declaration;
17349 they describe the function's name and the type it returns,
17350 but twisted together in a fashion that parallels the syntax of C.
17352 FLAGS is a bitwise or of SF_PRE_PARSED (indicating that the
17353 DECLARATOR is really the DECL for the function we are about to
17354 process and that DECLSPECS should be ignored), SF_INCLASS_INLINE
17355 indicating that the function is an inline defined in-class.
17357 This function creates a binding context for the function body
17358 as well as setting up the FUNCTION_DECL in current_function_decl.
17360 For C++, we must first check whether that datum makes any sense.
17361 For example, "class A local_a(1,2);" means that variable local_a
17362 is an aggregate of type A, which should have a constructor
17363 applied to it with the argument list [1, 2].
17365 On entry, DECL_INITIAL (decl1) should be NULL_TREE or error_mark_node,
17366 or may be a BLOCK if the function has been defined previously
17367 in this translation unit. On exit, DECL_INITIAL (decl1) will be
17368 error_mark_node if the function has never been defined, or
17369 a BLOCK if the function has been defined somewhere. */
17371 bool
17373 {
17377 /* Sanity check. */
17384 else
17385 {
17390 }
17397 /* Handle gnu_inline attribute. */
17399 {
17404 }
17407 /* This is a constructor, we must ensure that any default args
17408 introduced by this definition are propagated to the clones
17409 now. The clones are used directly in overload resolution. */
17412 /* Sometimes we don't notice that a function is a static member, and
17413 build a METHOD_TYPE for it. Fix that up now. */
17417 /* Set up current_class_type, and enter the scope of the class, if
17418 appropriate. */
17424 /* Now that we have entered the scope of the class, we must restore
17425 the bindings for any template parameters surrounding DECL1, if it
17426 is an inline member template. (Order is important; consider the
17427 case where a template parameter has the same name as a field of
17428 the class.) It is not until after this point that
17429 PROCESSING_TEMPLATE_DECL is guaranteed to be set up correctly. */
17433 /* Effective C++ rule 15. */
17441 /* Make the init_value nonzero so pushdecl knows this is not tentative.
17442 error_mark_node is replaced below (in poplevel) with the BLOCK. */
17446 /* This function exists in static storage.
17447 (This does not mean `static' in the C sense!) */
17450 /* We must call push_template_decl after current_class_type is set
17451 up. (If we are processing inline definitions after exiting a
17452 class scope, current_class_type will be NULL_TREE until set above
17453 by push_nested_class.) */
17455 {
17458 {
17462 }
17464 }
17466 /* Make sure the parameter and return types are reasonable. When
17467 you declare a function, these types can be incomplete, but they
17468 must be complete when you define the function. */
17471 /* Build the return declaration for the function. */
17475 {
17476 /* In a template instantiation, copy the return type location. When
17477 parsing, the location will be set in grokdeclarator. */
17480 {
17484 }
17492 }
17494 /* Record the decl so that the function name is defined.
17495 If we already have a decl for this name, and it is a FUNCTION_DECL,
17496 use the old decl. */
17498 {
17499 /* A specialization is not used to guide overload resolution. */
17503 {
17507 /* If something went wrong when registering the declaration,
17508 use DECL1; we have to have a FUNCTION_DECL to use when
17509 parsing the body of the function. */
17510 ;
17511 else
17512 {
17513 /* Otherwise, OLDDECL is either a previous declaration
17514 of the same function or DECL1 itself. */
17521 {
17522 tree context;
17524 /* Check whether DECL1 is in an anonymous
17525 namespace. */
17527 context;
17529 {
17533 }
17537 OPT_Wmissing_declarations,
17539 }
17542 }
17543 }
17544 else
17545 {
17546 /* We need to set the DECL_CONTEXT. */
17549 }
17553 /* If #pragma weak applies, mark the decl appropriately now.
17554 The pragma only applies to global functions. Because
17555 determining whether or not the #pragma applies involves
17556 computing the mangled name for the declaration, we cannot
17557 apply the pragma until after we have merged this declaration
17558 with any previous declarations; if the original declaration
17559 has a linkage specification, that specification applies to
17560 the definition as well, and may affect the mangled name. */
17563 }
17565 /* We are now in the scope of the function being defined. */
17568 /* Save the parm names or decls from this function's declarator
17569 where store_parm_decls will find them. */
17572 /* Let the user know we're compiling this function. */
17577 /* This function may already have been parsed, in which case just
17578 return; our caller will skip over the body without parsing. */
17582 /* Initialize RTL machinery. We cannot do this until
17583 CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this
17584 even when processing a template; this is how we get
17585 CFUN set up, and our per-function variables initialized.
17586 FIXME factor out the non-RTL stuff. */
17590 /* Initialize the language data structures. Whenever we start
17591 a new function, we destroy temporaries in the usual way. */
17596 /* If we are (erroneously) defining a function that we have already
17597 defined before, wipe out what we knew before. */
17603 {
17606 }
17608 /* Start the statement-tree, start the tree now. */
17612 {
17613 /* We know that this was set up by `grokclassfn'. We do not
17614 wait until `store_parm_decls', since evil parse errors may
17615 never get us to that point. Here we keep the consistency
17616 between `current_class_type' and `current_class_ptr'. */
17622 cp_function_chain->x_current_class_ref
17624 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
17627 /* Constructors and destructors need to know whether they're "in
17628 charge" of initializing virtual base classes. */
17631 {
17634 }
17636 {
17639 }
17640 }
17643 /* Implicitly-defined methods (like the
17644 destructor for a class in which no destructor
17645 is explicitly declared) must not be defined
17646 until their definition is needed. So, we
17647 ignore interface specifications for
17648 compiler-generated functions. */
17656 {
17663 /* This is a function in a local class in an extern inline
17664 or template function. */
17666 }
17667 /* If this function belongs to an interface, it is public.
17668 If it belongs to someone else's interface, it is also external.
17669 This only affects inlines and template instantiations. */
17671 {
17674 {
17678 && ! flag_implement_inlines
17681 /* For WIN32 we also want to put these in linkonce sections. */
17683 }
17684 else
17687 /* If this function is in an interface implemented in this file,
17688 make sure that the back end knows to emit this function
17689 here. */
17692 }
17695 {
17696 /* If MULTIPLE_SYMBOL_SPACES is defined and we saw a #pragma
17697 interface, we will have both finfo->interface_unknown and
17698 finfo->interface_only set. In that case, we don't want to
17699 use the normal heuristics because someone will supply a
17700 #pragma implementation elsewhere, and deducing it here would
17701 produce a conflict. */
17706 }
17707 else
17708 {
17709 /* This is a definition, not a reference.
17710 So clear DECL_EXTERNAL, unless this is a GNU extern inline. */
17718 else
17720 }
17722 /* Determine the ELF visibility attribute for the function. We must not
17723 do this before calling "pushdecl", as we must allow "duplicate_decls"
17724 to merge any attributes appropriately. We also need to wait until
17725 linkage is set. */
17746 /* Clobbering an empty base is harmful if it overlays real data. */
17748 /* We can't clobber safely for an implicitly-defined default constructor
17749 because part of the initialization might happen before we enter the
17750 constructor, via AGGR_INIT_ZERO_FIRST (c++/68006). */
17765 }
17768 /* Like start_preparsed_function, except that instead of a
17769 FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR.
17771 Returns true on success. If the DECLARATOR is not suitable
17772 for a function, we return false, which tells the parser to
17773 skip the entire function. */
17775 bool
17778 tree attrs)
17779 {
17780 tree decl1;
17788 /* main must return int. grokfndecl should have corrected it
17789 (and issued a diagnostic) if the user got it wrong. */
17791 integer_type_node));
17794 }
17795 \f
17796 /* Returns true iff an EH_SPEC_BLOCK should be created in the body of
17797 FN. */
17799 static bool
17801 {
17803 && !processing_template_decl
17804 /* We insert the EH_SPEC_BLOCK only in the original
17805 function; then, it is copied automatically to the
17806 clones. */
17808 /* Implicitly-generated constructors and destructors have
17809 exception specifications. However, those specifications
17810 are the union of the possible exceptions specified by the
17811 constructors/destructors for bases and members, so no
17812 unallowed exception will ever reach this function. By
17813 not creating the EH_SPEC_BLOCK we save a little memory,
17814 and we avoid spurious warnings about unreachable
17815 code. */
17818 }
17820 /* Helper function to push ARGS into the current lexical scope. DECL
17821 is the function declaration. NONPARMS is used to handle enum
17822 constants. */
17824 void
17826 {
17827 /* If we're doing semantic analysis, then we'll call pushdecl
17828 for each of these. We must do them in reverse order so that
17829 they end in the correct forward order. */
17832 tree next;
17834 {
17839 {
17840 /* If we find an enum constant or a type tag, put it aside for
17841 the moment. */
17844 }
17845 }
17847 /* Get the decls in their original chain order and record in the
17848 function. This is all and only the PARM_DECLs that were
17849 pushed into scope by the loop above. */
17851 }
17853 /* Store the parameter declarations into the current function declaration.
17854 This is called after parsing the parameter declarations, before
17855 digesting the body of the function.
17857 Also install to binding contour return value identifier, if any. */
17859 static void
17861 {
17864 /* This is a chain of any other decls that came in among the parm
17865 declarations. If a parm is declared with enum {foo, bar} x;
17866 then CONST_DECLs for foo and bar are put here. */
17870 {
17871 /* This case is when the function was defined with an ANSI prototype.
17872 The parms already have decls, so we need not do anything here
17873 except record them as in effect
17874 and complain if any redundant old-style parm decls were written. */
17878 /* Must clear this because it might contain TYPE_DECLs declared
17879 at class level. */
17883 }
17884 else
17887 /* Now store the final chain of decls for the arguments
17888 as the decl-chain of the current lexical scope.
17889 Put the enumerators in as well, at the front so that
17890 DECL_ARGUMENTS is not modified. */
17895 }
17897 \f
17898 /* Set the return value of the [cd]tor if the ABI wants that. */
17900 void
17902 {
17904 {
17905 /* Return the address of the object. */
17913 }
17914 }
17916 /* Do all the processing for the beginning of a destructor; set up the
17917 vtable pointers and cleanups for bases and members. */
17919 static void
17921 {
17922 tree compound_stmt;
17924 /* If the CURRENT_CLASS_TYPE is incomplete, we will have already
17925 issued an error message. We still want to try to process the
17926 body of the function, but initialize_vtbl_ptrs will crash if
17927 TYPE_BINFO is NULL. */
17929 {
17931 /* Make all virtual function table pointers in non-virtual base
17932 classes point to CURRENT_CLASS_TYPE's virtual function
17933 tables. */
17938 /* Clobbering an empty base is harmful if it overlays real data. */
17940 {
17944 {
17946 tree ref
17953 tf_warning_or_error);
17954 /* If the vptr is shared with some virtual nearly empty base,
17955 don't clear it if not in charge, the dtor of the virtual
17956 nearly empty base will do that later. */
17958 {
17961 {
17963 {
17965 tf_warning_or_error);
17968 }
17970 }
17971 }
17973 }
17974 else
17976 }
17978 /* And insert cleanups for our bases and members so that they
17979 will be properly destroyed if we throw. */
17981 }
17982 }
17984 /* Do the necessary processing for the beginning of a function body, which
17985 in this case includes member-initializers, but not the catch clauses of
17986 a function-try-block. Currently, this means opening a binding level
17987 for the member-initializers (in a ctor), member cleanups (in a dtor),
17988 and capture proxies (in a lambda operator()). */
17990 tree
17992 {
17998 else
17999 /* Always keep the BLOCK node associated with the outermost pair of
18000 curly braces of a function. These are needed for correct
18001 operation of dwarfout.c. */
18013 }
18015 /* Do the processing for the end of a function body. Currently, this means
18016 closing out the cleanups for fully-constructed bases and members, and in
18017 the case of the destructor, deleting the object if desired. Again, this
18018 is only meaningful for [cd]tors, since they are the only functions where
18019 there is a significant distinction between the main body and any
18020 function catch clauses. Handling, say, main() return semantics here
18021 would be wrong, as flowing off the end of a function catch clause for
18022 main() would also need to return 0. */
18024 void
18026 {
18030 /* Close the block. */
18038 }
18040 /* Given a function, returns the BLOCK corresponding to the outermost level
18041 of curly braces, skipping the artificial block created for constructor
18042 initializers. */
18044 tree
18046 {
18056 }
18058 /* If FNDECL is a class's key method, add the class to the list of
18059 keyed classes that should be emitted. */
18061 static void
18063 {
18067 {
18071 }
18072 }
18074 /* Attempt to add a fix-it hint to RICHLOC suggesting the insertion
18075 of "return *this;" immediately before its location, using FNDECL's
18076 first statement (if any) to give the indentation, if appropriate. */
18078 static void
18080 {
18087 indent);
18088 }
18090 /* This function carries out the subset of finish_function operations needed
18091 to emit the compiler-generated outlined helper functions used by the
18092 coroutines implementation. */
18094 static void
18096 {
18097 /* This is a partial set of the operations done by finish_function()
18098 plus emitting the result. */
18108 /* We must start each function with a clear fold cache. */
18113 /* This function has coroutine IFNs that we should handle in middle
18114 end lowering. */
18118 }
18120 /* Finish up a function declaration and compile that function
18121 all the way to assembler language output. The free the storage
18122 for the function definition. INLINE_P is TRUE if we just
18123 finished processing the body of an in-class inline function
18124 definition. (This processing will have taken place after the
18125 class definition is complete.) */
18127 tree
18129 {
18134 && !processing_template_decl
18138 /* When we get some parse errors, we can end up without a
18139 current_function_decl, so cope. */
18153 /* TREE_READONLY (fndecl) = 1;
18154 This caused &foo to be of type ptr-to-const-function
18155 which then got a warning when stored in a ptr-to-function variable. */
18158 /* The current function is being defined, so its DECL_INITIAL should
18159 be set, and unless there's a multiple definition, it should be
18160 error_mark_node. */
18164 {
18165 /* Only try to emit the coroutine outlined helper functions if the
18166 transforms succeeded. Otherwise, treat errors in the same way as
18167 a regular function. */
18170 /* We should handle coroutine IFNs in middle end lowering. */
18173 /* Do not try to process the ramp's EH unless outlining succeeded. */
18177 current_eh_spec_block);
18178 }
18179 else
18180 /* For a cloned function, we've already got all the code we need;
18181 there's no need to add any extra bits. */
18183 {
18184 /* Make it so that `main' always returns 0 by default. */
18192 current_eh_spec_block);
18193 }
18195 /* If we're saving up tree structure, tie off the function now. */
18200 /* This must come after expand_function_end because cleanups might
18201 have declarations (from inline functions) that need to go into
18202 this function's blocks. */
18204 /* If the current binding level isn't the outermost binding level
18205 for this function, either there is a bug, or we have experienced
18206 syntax errors and the statement tree is malformed. */
18208 {
18209 /* Make sure we have already experienced errors. */
18212 /* Throw away the broken statement tree and extra binding
18213 levels. */
18217 {
18220 else
18222 }
18223 }
18226 /* Statements should always be full-expressions at the outermost set
18227 of curly braces for a function. */
18230 /* If there are no return statements in a function with auto return type,
18231 the return type is void. But if the declared type is something like
18232 auto*, this is an error. */
18235 {
18237 && !current_function_returns_value
18239 {
18240 /* We haven't applied return type deduction because we haven't
18241 seen any return statements. Do that now. */
18245 adc_return_type);
18249 }
18252 {
18257 }
18258 }
18260 /* Remember that we were in class scope. */
18265 {
18269 }
18271 // If this is a concept, check that the definition is reasonable.
18280 /* Complain if there's just no return statement. */
18287 /* Don't complain if we abort or throw. */
18288 && !current_function_returns_abnormally
18289 /* Don't complain if there's an infinite loop. */
18290 && !current_function_infinite_loop
18291 /* Don't complain if we are declared noreturn. */
18295 /* Structor return values (if any) are set by the compiler. */
18299 {
18301 /* Potentially add a "return *this;" fix-it hint for
18302 assignment operators. */
18304 {
18307 && current_class_ref
18308 && same_type_ignoring_top_level_qualifiers_p
18314 }
18320 "no return statement in function returning "
18323 }
18325 /* Lambda closure members are implicitly constexpr if possible. */
18329 = ((processing_template_decl
18333 /* Save constexpr function body before it gets munged by
18334 the NRV transformation. */
18337 /* Invoke the pre-genericize plugin before we start munging things. */
18341 /* Perform delayed folding before NRV transformation. */
18347 /* Set up the named return value optimization, if we can. Candidate
18348 variables are selected in check_return_expr. */
18350 {
18354 }
18356 /* Must mark the RESULT_DECL as being in this function. */
18359 /* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
18360 to the FUNCTION_DECL node itself. */
18363 /* Store the end of the function, so that we get good line number
18364 info for the epilogue. */
18367 /* Complain about parameters that are only set, but never otherwise used. */
18369 && !processing_template_decl
18372 {
18373 tree decl;
18376 decl;
18390 OPT_Wunused_but_set_parameter,
18393 }
18395 /* Complain about locally defined typedefs that are not used in this
18396 function. */
18399 /* Possibly warn about unused parameters. */
18401 && !processing_template_decl
18405 /* Genericize before inlining. */
18411 /* If this function can't throw any exceptions, remember that. */
18414 && !flag_non_call_exceptions
18419 /* Emit the resumer and destroyer functions now, providing that we have
18420 not encountered some fatal error. */
18422 {
18425 }
18427 cleanup:
18428 /* We're leaving the context of this function, so zap cfun. It's still in
18429 DECL_STRUCT_FUNCTION, and we'll restore it in tree_rest_of_compilation. */
18433 /* If this is an in-class inline definition, we may have to pop the
18434 bindings for the template parameters that we added in
18435 maybe_begin_member_template_processing when start_function was
18436 called. */
18440 /* Leave the scope of the class. */
18446 /* Clean up. */
18454 }
18455 \f
18456 /* Create the FUNCTION_DECL for a function definition.
18457 DECLSPECS and DECLARATOR are the parts of the declaration;
18458 they describe the return type and the name of the function,
18459 but twisted together in a fashion that parallels the syntax of C.
18461 This function creates a binding context for the function body
18462 as well as setting up the FUNCTION_DECL in current_function_decl.
18464 Returns a FUNCTION_DECL on success.
18466 If the DECLARATOR is not suitable for a function (it defines a datum
18467 instead), we return 0, which tells yyparse to report a parse error.
18469 May return void_type_node indicating that this method is actually
18470 a friend. See grokfield for more details.
18472 Came here with a `.pushlevel' .
18474 DO NOT MAKE ANY CHANGES TO THIS CODE WITHOUT MAKING CORRESPONDING
18475 CHANGES TO CODE IN `grokfield'. */
18477 tree
18480 {
18490 /* Pass friends other than inline friend functions back. */
18495 {
18500 }
18504 /* p1779 ABI-Isolation makes inline not a default for in-class
18505 definitions in named module purview. If the user explicitly
18506 made it inline, grokdeclarator will already have done the right
18507 things. */
18509 || flag_module_implicit_inline
18510 /* Lambda's operator function remains inline. */
18512 /* If the user explicitly asked for this to be inline, we don't
18513 need to do more, but more importantly we want to warn if we
18514 can't inline it. */
18516 {
18520 /* It's ok if we can't inline this. */
18522 }
18524 /* We process method specializations in finish_struct_1. */
18526 {
18527 /* Avoid calling decl_spec_seq... until we have to. */
18532 }
18535 {
18538 }
18544 }
18545 \f
18547 /* VAR is a VAR_DECL. If its type is incomplete, remember VAR so that
18548 we can lay it out later, when and if its type becomes complete.
18550 Also handle constexpr variables where the initializer involves
18551 an unlowered PTRMEM_CST because the class isn't complete yet. */
18553 void
18555 {
18558 /* Keep track of variables with incomplete types. */
18561 {
18569 /* RTTI TD entries are created while defining the type_info. */
18572 {
18575 }
18579 {
18580 /* When the outermost open class is complete we can resolve any
18581 pointers-to-members. */
18585 }
18586 }
18587 }
18589 /* Called when a class type (given by TYPE) is defined. If there are
18590 any existing VAR_DECLs whose type has been completed by this
18591 declaration, update them now. */
18593 void
18595 {
18600 {
18602 {
18609 {
18610 /* Complete the type of the variable. */
18615 }
18617 /* Remove this entry from the list. */
18619 }
18620 else
18621 ix++;
18622 }
18623 }
18625 /* If DECL is of a type which needs a cleanup, build and return an
18626 expression to perform that cleanup here. Return NULL_TREE if no
18627 cleanup need be done. DECL can also be a _REF when called from
18628 split_nonconstant_init_1. */
18630 tree
18632 {
18633 tree type;
18634 tree attr;
18635 tree cleanup;
18637 /* Assume no cleanup is required. */
18643 /* Handle "__attribute__((cleanup))". We run the cleanup function
18644 before the destructor since the destructor is what actually
18645 terminates the lifetime of the object. */
18648 else
18651 {
18652 tree id;
18653 tree fn;
18654 tree arg;
18656 /* Get the name specified by the user for the cleanup function. */
18658 /* Look up the name to find the cleanup function to call. It is
18659 important to use lookup_name here because that is what is
18660 used in c-common.cc:handle_cleanup_attribute when performing
18661 initial checks on the attribute. Note that those checks
18662 include ensuring that the function found is not an overloaded
18663 function, or an object with an overloaded call operator,
18664 etc.; we can rely on the fact that the function found is an
18665 ordinary FUNCTION_DECL. */
18673 }
18674 /* Handle ordinary C++ destructors. */
18677 {
18679 tree addr;
18680 tree call;
18684 else
18698 else
18700 }
18702 /* build_delete sets the location of the destructor call to the
18703 current location, even though the destructor is going to be
18704 called later, at the end of the current scope. This can lead to
18705 a "jumpy" behavior for users of debuggers when they step around
18706 the end of the block. So let's unset the location of the
18707 destructor call instead. */
18715 /* Treat objects with destructors as used; the destructor may do
18716 something substantive. */
18725 }
18727 \f
18728 /* Return the FUNCTION_TYPE that corresponds to MEMFNTYPE, which can be a
18729 FUNCTION_DECL, METHOD_TYPE, FUNCTION_TYPE, pointer or reference to
18730 METHOD_TYPE or FUNCTION_TYPE, or pointer to member function. */
18732 tree
18734 {
18735 tree fntype;
18736 tree args;
18749 fntype = (cp_build_type_attribute_variant
18753 }
18755 /* DECL was originally constructed as a non-static member function,
18756 but turned out to be static. Update it accordingly. */
18758 void
18760 {
18773 }
18775 /* Return which tree structure is used by T, or TS_CP_GENERIC if T is
18776 one of the language-independent trees. */
18778 enum cp_tree_node_structure_enum
18780 {
18782 {
18800 }
18801 }
18803 bool
18805 {
18806 /* A missing noreturn is ok for the `main' function. */
18808 }
18810 /* Return the decl used to identify the COMDAT group into which DECL should
18811 be placed. */
18813 tree
18815 {
18816 /* Virtual tables, construction virtual tables, and virtual table
18817 tables all go in a single COMDAT group, named after the primary
18818 virtual table. */
18821 /* For all other DECLs, the COMDAT group is the mangled name of the
18822 declaration itself. */
18823 else
18824 {
18826 {
18827 /* If TARGET_USE_LOCAL_THUNK_ALIAS_P, use_thunk puts the thunk
18828 into the same section as the target function. In that case
18829 we must return target's name. */
18835 else
18837 }
18838 }
18841 }
18843 /* Returns the return type for FN as written by the user, which may include
18844 a placeholder for a deduced return type. */
18846 tree
18848 {
18854 }
18856 /* Returns true iff DECL is a variable or function declared with an auto type
18857 that has not yet been deduced to a real type. */
18859 bool
18861 {
18868 }
18870 /* Complain if DECL has an undeduced return type. */
18872 bool
18874 {
18876 {
18880 {
18881 /* Set the return type of __builtin_source_location. */
18884 {
18887 }
18892 }
18900 }
18902 }
18904 /* Create a representation of the explicit-specifier with
18905 constant-expression of EXPR. COMPLAIN is as for tsubst. */
18907 tree
18909 {
18914 /* Wait for instantiation, tsubst_function_decl will handle it. */
18921 }